fix(cli): count Claude advisor_message iteration tokens

`message.usage.iterations[]` breaks an assistant message into the calls
that produced it. Entries of type `message` are the main model's own
iterations and are already summed into the enclosing usage — verified on
201 real lines locally, where their counts match it exactly. Entries of
type `advisor_message` are a different model's call that the enclosing
usage does not carry, so their tokens were dropped entirely and the
model billing at its own rate never showed up.

Emit one model.usage per advisor iteration, attributed to the advisor's
model. Each needs a refs.sourceId: the import key is built from
(source, file, line, type, sourceId), so without one every usage event
on the line would collapse into the main model's id. The main event
deliberately keeps no sourceId so its id stays stable across re-imports.

Claude-Session: https://claude.ai/code/session_019u3RKiNJY1sRknveHJy9iJ

Author: Jannchie

packages/cli/src/adapters/claude-code.ts

@@ -268,6 +268,26 @@ async function parseClaudeCodeSessionFile(
       }), lineNumber, topType, 'usage')
     }
 
+    // Advisor calls bill at their own model's rate and are not part of the usage
+    // above, so each becomes its own model.usage event. They need a sourceId: the
+    // import key is built from (source, file, line, type, sourceId), and without
+    // one every usage event on this line would collapse into the main model's id.
+    // The main event deliberately keeps no sourceId so its id stays stable.
+    for (const [advisorIndex, advisor] of claudeAdvisorUsages(message).entries()) {
+      push(baseClaudeEvent({
+        ts,
+        type: 'model.usage',
+        sessionId,
+        turnId: state.currentTurnId,
+        cwd,
+        project,
+        model: advisor.model,
+        confidence: 'partial',
+        metrics: advisor.usage,
+        refs: stringRefs({ sourceId: `advisor:${advisorIndex}` }),
+      }), lineNumber, topType, 'usage')
+    }
+
     for (const toolUse of claudeToolUseItems(message)) {
       const tool = stringField(toolUse, 'name') || 'tool'
       const toolUseId = stringField(toolUse, 'id') || `tool_${createStableHash([filePath, lineNumber, tool]).slice(0, 24)}`
@@ -373,7 +393,44 @@ function baseClaudeEvent(
 }
 
 export function claudeUsageFromMessage(message: Record<string, unknown>): Partial<MetricBag> | undefined {
-  const usage = objectField(message, 'usage')
+  return claudeUsageFromUsage(objectField(message, 'usage'))
+}
+
+/**
+ * Advisor-model calls folded into one assistant message.
+ *
+ * `message.usage.iterations[]` breaks the message down into the calls that
+ * produced it. Entries of type `message` are the main model's own iterations and
+ * are already summed into the enclosing `usage`, so counting them again would
+ * double the message. `advisor_message` entries are a *different* model's call
+ * whose tokens the enclosing usage does not carry — dropping them loses those
+ * tokens entirely and hides a model that bills at its own rate. Mirrors ccusage
+ * advisor_usages_from_line (adapter/claude/mod.rs, #1423).
+ */
+function claudeAdvisorUsages(
+  message: Record<string, unknown>,
+): { model: string, usage: Partial<MetricBag> }[] {
+  const iterations = objectField(message, 'usage').iterations
+  if (!Array.isArray(iterations)) {
+    return []
+  }
+  const advisors: { model: string, usage: Partial<MetricBag> }[] = []
+  for (const iteration of iterations) {
+    if (!isPlainObject(iteration) || stringField(iteration, 'type') !== 'advisor_message') {
+      continue
+    }
+    const model = stringField(iteration, 'model')
+    const usage = claudeUsageFromUsage(iteration)
+    if (model && usage) {
+      advisors.push({ model, usage })
+    }
+  }
+  return advisors
+}
+
+// Token counts live in the same field layout whether they come from
+// `message.usage` or from one of its `iterations[]` entries.
+function claudeUsageFromUsage(usage: Record<string, unknown>): Partial<MetricBag> | undefined {
   if (Object.keys(usage).length === 0) {
     return undefined
   }

packages/cli/test/claude-code.test.ts

@@ -134,3 +134,136 @@ test('divergence: claude does NOT drop sidechain replay with a new requestId', a
   assert.equal(usages.length, 2)
   assert.equal(totalCacheRead, 20 + 50_000)
 })
+
+// ── advisor-model iterations ──
+//
+// `message.usage.iterations[]` breaks an assistant message into the calls that
+// produced it. Main-model (`type: "message"`) entries are already summed into the
+// enclosing usage; `advisor_message` entries are a different model's call whose
+// tokens the enclosing usage does not carry. Mirrors ccusage #1423.
+
+test('parity: ccusage claude calculates_advisor_cost_with_the_advisor_model', async () => {
+  // Fixture from ccusage adapter/claude/mod.rs
+  // calculates_advisor_cost_with_the_advisor_model.
+  const usages = usageEvents(await parse([
+    assistant('req-parent', 'msg-parent', {
+      input_tokens: 1,
+      output_tokens: 2,
+      iterations: [{
+        type: 'advisor_message',
+        model: 'advisor-model',
+        input_tokens: 10,
+        output_tokens: 2,
+        cache_creation_input_tokens: 0,
+        cache_read_input_tokens: 0,
+      }],
+    } as unknown as Record<string, number>),
+  ]))
+
+  assert.equal(usages.length, 2)
+  // The main model's totals are untouched.
+  assert.equal(usages[0].model, 'claude-sonnet-4-20250514')
+  assert.equal(usages[0].metrics?.tokensInput, 1)
+  assert.equal(usages[0].metrics?.tokensOutput, 2)
+  // The advisor's tokens are attributed to the advisor's own model.
+  assert.equal(usages[1].model, 'advisor-model')
+  assert.equal(usages[1].metrics?.tokensInput, 10)
+  assert.equal(usages[1].metrics?.tokensOutput, 2)
+  assert.equal(usages[1].metrics?.modelCalls, 1)
+  // Distinct import identities, or the server would treat one as a repeat of the other.
+  assert.notEqual(usages[0].id, usages[1].id)
+  assert.notEqual(usages[0].refs?.importKey, usages[1].refs?.importKey)
+})
+
+test('main-model iterations are never counted twice', async () => {
+  // Real transcripts carry a `type: "message"` iteration whose counts equal the
+  // enclosing usage exactly (verified across 201 such lines locally). Expanding
+  // those would double every assistant message. Today those entries carry no
+  // `model`, but the type check — not the missing field — has to be what stops
+  // them, so this fixture supplies a model the filter must ignore.
+  const usages = usageEvents(await parse([
+    assistant('req-1', 'msg-1', {
+      input_tokens: 2,
+      output_tokens: 234,
+      cache_creation_input_tokens: 29_586,
+      cache_read_input_tokens: 0,
+      iterations: [{
+        type: 'message',
+        model: 'claude-sonnet-4-20250514',
+        input_tokens: 2,
+        output_tokens: 234,
+        cache_creation_input_tokens: 29_586,
+        cache_read_input_tokens: 0,
+      }],
+    } as unknown as Record<string, number>),
+  ]))
+
+  assert.equal(usages.length, 1)
+  assert.equal(usages[0].metrics?.tokensOutput, 234)
+})
+
+test('advisor iterations inherit the TTL split and skip malformed entries', async () => {
+  const usages = usageEvents(await parse([
+    assistant('req-1', 'msg-1', {
+      input_tokens: 1,
+      output_tokens: 2,
+      iterations: [
+        // No model → cannot be priced, so it is not emitted.
+        { type: 'advisor_message', input_tokens: 5, output_tokens: 1 },
+        // Not an object.
+        'garbage',
+        {
+          type: 'advisor_message',
+          model: 'advisor-model',
+          input_tokens: 3,
+          output_tokens: 1,
+          cache_creation_input_tokens: 100,
+          cache_read_input_tokens: 7,
+          cache_creation: { ephemeral_5m_input_tokens: 40, ephemeral_1h_input_tokens: 60 },
+        },
+      ],
+    } as unknown as Record<string, number>),
+  ]))
+
+  assert.equal(usages.length, 2)
+  const advisor = usages[1]
+  assert.equal(advisor.model, 'advisor-model')
+  assert.equal(advisor.metrics?.tokensInput, 3 + 100 + 7) // cache-inclusive
+  assert.equal(advisor.metrics?.tokensCacheCreation5mInput, 40)
+  assert.equal(advisor.metrics?.tokensCacheCreation1hInput, 60)
+})
+
+test('two advisor iterations on one line get distinct import identities', async () => {
+  const events = await parse([
+    assistant('req-1', 'msg-1', {
+      input_tokens: 1,
+      output_tokens: 2,
+      iterations: [
+        { type: 'advisor_message', model: 'advisor-a', input_tokens: 3, output_tokens: 1 },
+        { type: 'advisor_message', model: 'advisor-b', input_tokens: 4, output_tokens: 1 },
+      ],
+    } as unknown as Record<string, number>),
+  ])
+
+  const usages = usageEvents(events)
+  assert.equal(usages.length, 3)
+  assert.equal(new Set(usages.map(usage => usage.id)).size, 3)
+})
+
+test('a duplicate assistant entry does not re-emit its advisor usage', async () => {
+  // The (messageId, requestId) dedup skips the whole entry, advisors included.
+  const usages = usageEvents(await parse([
+    assistant('req-1', 'msg-1', {
+      input_tokens: 1,
+      output_tokens: 2,
+      iterations: [{ type: 'advisor_message', model: 'advisor-model', input_tokens: 10, output_tokens: 2 }],
+    } as unknown as Record<string, number>),
+    assistant('req-1', 'msg-1', {
+      input_tokens: 1,
+      output_tokens: 2,
+      iterations: [{ type: 'advisor_message', model: 'advisor-model', input_tokens: 10, output_tokens: 2 }],
+    } as unknown as Record<string, number>),
+  ]))
+
+  assert.equal(usages.length, 2)
+})