fix(agents): roll subagent token usage and cost into parent session

[filipkujawa]

Subagents run in their own session, so their tokens and cost never reached the parent. Every delegating turn under-reported cost-per-outcome and slipped past per-session budgets.

This folds a finished subagent's usage/cost into the parent's accumulated_* totals at the run_subagent_task chokepoint (sync + async delegate). The parent's context window is left untouched, so compaction is unaffected. Accumulated totals now use an atomic SQL increment, so a background subagent rolling up concurrently with the parent's reply loop can't clobber it.

Existing cost/usage readers (ACP usage_update, CLI display) pick this up for free.

assisted by claude code

[filipkujawa]

Ran the same delegating task on pre-fix vs post-fix binaries, then inspected sessions.db:

┌──────────────────┬──────────────────┐
│  parent acc_tok  │ subagent acc_tok │
├──────────────────┼──────────────────┤
│ pre-fix: 18,782  │ 5,918            │
├──────────────────┼──────────────────┤
│ post-fix: 24,774 │ 5,947            │
└──────────────────┴──────────────────┘

Pre-fix the subagent's ~5.9K tokens are missing from the parent (bug reproduced). Post-fix 24,774 − 5,947 = 18,827 ≈ pre-fix parent-own (18,782) → subagent spend now rolls up. Cost rolls up too (parent $0.0208, both sessions non-zero). Parent context window stayed ~9.4K in both, so compaction is unaffected.

[michaelneale]

is this for migration from old?

[filipkujawa]

No, not a migration. It adds a delta to a session's accumulated_usage/accumulated_cost., called on every usage update (and again when a subagent's totals roll up into its parent). The COALESCE bits aren't backfilling old rows- the columns are nullable (a fresh session starts with NULL accumulated tokens), so without them NULL + delta would evaluate to NULL and wipe the total on first increment

[michaelneale]

nice @filipkujawa - would it be possible to make it a little more atomic so when it updates it is one SQL call when it can. Fairly minor thing but wondered if worth a try.

Something like the following:

one UPDATE sessions ... that both sets current context usage and increments accumulated usage/cost:

  UPDATE sessions SET
    schedule_id = ?,
    total_tokens = ?,
    input_tokens = ?,
    output_tokens = ?,
    cache_read_tokens = ?,
    cache_write_tokens = ?,

    accumulated_total_tokens =
      COALESCE(accumulated_total_tokens, 0) + COALESCE(?, 0),
    accumulated_input_tokens =
      COALESCE(accumulated_input_tokens, 0) + COALESCE(?, 0),
    accumulated_output_tokens =
      COALESCE(accumulated_output_tokens, 0) + COALESCE(?, 0),
    accumulated_cache_read_tokens =
      COALESCE(accumulated_cache_read_tokens, 0) + COALESCE(?, 0),
    accumulated_cache_write_tokens =
      COALESCE(accumulated_cache_write_tokens, 0) + COALESCE(?, 0),

    accumulated_cost = CASE
      WHEN ? IS NULL THEN accumulated_cost
      ELSE COALESCE(accumulated_cost, 0) + ?
    END,

    updated_at = datetime('now')
  WHERE id = ?

  Binding order would be:

  .bind(schedule_id)
  .bind(current_usage.total_tokens)
  .bind(current_usage.input_tokens)
  .bind(current_usage.output_tokens)
  .bind(current_usage.cache_read_input_tokens)
  .bind(current_usage.cache_write_input_tokens)
  .bind(accumulated_delta.total_tokens)
  .bind(accumulated_delta.input_tokens)
  .bind(accumulated_delta.output_tokens)
  .bind(accumulated_delta.cache_read_input_tokens)
  .bind(accumulated_delta.cache_write_input_tokens)
  .bind(cost_delta)
  .bind(cost_delta)
  .bind(session_id)


crates/goose/src/session/session_manager.rs:1577

  Specifically, add a new SessionStorage::update_usage_metrics(...) method near the PR’s new
  SessionStorage::add_accumulated_usage(...).

  Then expose it with a SessionManager::update_usage_metrics(...) wrapper near:

  crates/goose/src/session/session_manager.rs:395

  Finally call it from:

  crates/goose/src/agents/reply_parts.rs:545

  replacing the two current calls:

  manager.update(...).usage(...).apply().await?;
  manager.add_accumulated_usage(...).await?;

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: e4bd435dec

ℹ️ About Codex in GitHub

Codex has been enabled to automatically review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

When you sign up for Codex through ChatGPT, Codex can also answer questions or update the PR, like "@codex address that feedback".

[chatgpt-codex-connector]

Make subagent usage roll-up abort-safe

Because the roll-up is sequenced after awaiting the entire subagent run, an async delegate that is cancelled and then force-aborted by handle_load_task_result after its 5-second grace period drops this future while it is still inside get_agent_messages(params).await, so execution never reaches the roll-up call. Any usage already persisted in the subagent session before that abort remains absent from the parent, preserving under-reporting for stuck/cancelled background delegates; move the roll-up to an abort-safe cleanup path or have the abort path add the persisted subagent totals.

Useful? React with 👍 / 👎.

[filipkujawa]

superseded-by #10172