fix(core): roll up subagent cost into parent session and fix fork double-counting

[AndyS77]

Issue for this PR

Closes #39740
Closes #31032
Closes #36944

Type of change

• Bug fix
• New feature

What does this PR do?

Subagent session costs were not rolled up to the parent session (#39740), and forked sessions double-counted pre-fork costs (#31032, #36944). This PR fixes both issues and exposes the aggregated cost through the protocol layer so the TUI, stats, and ACP can display it.

Fork double-counting fix: When a session is forked, the cloned step-finish parts now have their cost and tokens zeroed out. The forked session starts with zero cost and only accumulates cost from its own LLM calls, not the parent's pre-fork history.

Cost rollup: Added children() and totalCost() to both V1 Session.Service and V2 SessionV2.Interface. totalCost() does a BFS walk across all descendant sessions, summing cost and tokens.

Protocol endpoint: Added session.cost and session.children to the protocol session group (/api/session/:sessionID/cost, /api/session/:sessionID/children) with handlers in both the protocol handler (packages/server) and the server handler (packages/opencode). Both SDKs were regenerated.

TUI: refreshCost effect in stream.transport.ts calls sdk.session.cost() on message.updated and bootstrap. SessionData.totalCost field; footer formatUsage uses totalCost when > 0, falls back to info.cost.

Stats + ACP: Stats uses totalCost() for top-level sessions. ACP sendUpdate uses sdk.session.cost() with totalSessionCost(messages) fallback.

How did you verify your code works?

• 9 service-level tests (cost-rollup.test.ts): fork zeroing, own cost, child cost, nested children, multiple children
• 10 ACP usage tests (usage.test.ts): mock updated with cost method
• 2 HTTP E2E tests (httpapi-session.test.ts): aggregated cost across nested children (parent -> child -> grandchild, verifying 0.06 = 0.01 + 0.02 + 0.03), 404 for missing session
• bun typecheck clean (0 source-code errors)
• Both SDKs regenerated via bun run generate

Related PRs (used as reference)

• feat(tui): show subagent cost rollup in sidebar and task history #25712 (open, incomplete — companion UI PR)
• feat(tui): aggregate subagent costs into sidebar spent total #27952 (closed in favor of feat(tui): show subagent cost rollup in sidebar and task history #25712)
• feat: nested sub-agent spawning (up to 5 levels) + fixes for #23091 / #13715 #32301 (related subagent spawning PR)
• feat: add sub-agent cost breakdown with recursive session walker #13588 (stale)
• feat(task): expose subagent token consumption to primary agent #4611 (closed)
• fix: add persistent cost to prevent under-reporting spent value #7763 (closed)

Checklist

• I have tested my changes locally
• I have not included unrelated changes in this PR

[github-actions]

The following comment was made by an LLM, it may be inaccurate:

Found Potential Duplicates/Related PRs

#25712 - #25712

• Title: feat(tui): show subagent cost rollup in sidebar and task history
• This is already referenced in PR fix(core): roll up subagent cost into parent session and fix fork double-counting #43645 as an incomplete open PR. It directly addresses displaying the subagent cost rollup that the current PR implements at the core/protocol layer.

#32301 - #32301

• Title: feat: nested sub-agent spawning (up to 5 levels) + fixes for #23091 / #13715
• Related to subagent session handling and may have overlapping cost tracking concerns.

These are the most relevant matches. PR #25712 is particularly important as it appears to be the companion UI PR that would consume the cost aggregation API being implemented in #43645.

[github-actions]

Thanks for updating your PR! It now meets our contributing guidelines. 👍

[greedyivan]

Reviewed against a billing-reconciled session tree (root + 3 subagents, cross-checked against the provider's invoice — context in #45417): the BFS rollup with the visited set is correct, fork zeroing works, and the test coverage (nested / multi-child / fork scenarios) is good. One real issue in the stats aggregation:

opencode stats grand total double-counts child sessions.

getAllSessions() returns every row from the session table (no parentID filter), and the aggregate does stats.totalCost += result.sessionCost per session. With this PR a top-level session contributes totalCost (own + all descendants) while its children still contribute their own session.cost — every child is counted twice in the grand total.

Numbers from my reconciled tree (root $0.168 own + children $0.0417 / $0.0395 / $0.0396):

• correct total: $0.2887
• stats.totalCost with this PR: 0.2887 + 0.1208 = $0.4095 (+42%)

Suggested fix: contribute 0 from child rows to the grand total when their parent is present in the aggregated set (or only aggregate top-level rows). Per-session rows can still display each session's own cost.

Two smaller notes:

• Fork zeroing sets cloned step-finish parts to cost 0, so inside a fork the inherited messages display as free. Reasonable for "what has this fork spent since forking", but worth a line in the description since per-message cost display changes meaning after a fork.
• Hidden LLM calls (title/summary generation) remain outside both session.cost and totalCost — tracked in Hidden LLM calls (session title / message summaries) are billed by the provider but absent from session cost #46371; not a defect of this PR, but relevant to anyone reconciling stats against invoices.

[janorga]

Heads-up: this PR's fork-zeroing fixes the over-count (#36944) but doesn't cover the deleted-parent case (#48306). After zeroing, an orphan fork's inherited spend becomes unrecoverable even from message-level data. Consider preserving deleted-session aggregates (rollup) or reattributing inherited cost at fork time.

[AndyS77]

Good catch on the deleted-parent case (#48306).

The fix is in the latest push (commit b741286). In aggregateSessionStats, sessions are now treated as top-level when their parentID does not exist in the session set — this covers the orphan case where a parent row was deleted directly (bypassing session.remove, which cascades to children).

// Before:
const isTopLevel = !session.parentID

// After:
const isTopLevel = !session.parentID || !sessionIDs.has(session.parentID)

This ensures orphaned sessions use totalCost (BFS including their own descendants) instead of just session.cost, so the inherited spend remains recoverable.

Note: session.remove already cascades (deletes all descendants), so orphans only arise from direct DB deletion (migrations, crashes, manual SQL). The fix is defensive — it handles the edge case gracefully.