switchroom 0.18.23 → 0.18.25

package/telegram-plugin/tests/registry-turns.test.ts

@@ -20,6 +20,8 @@ import {
   markOrphanedWithTimeoutClassification,
   findLatestTurnIfInterrupted,
   markTurnResumed,
+  markAnswerRedelivered,
+  stampTurnSessionId,
   getTurnByKey,
 } from '../registry/turns-schema.js'
 
@@ -574,3 +576,52 @@ describe('markTurnResumed', () => {
     db.close()
   })
 })
+
+// ---------------------------------------------------------------------------
+// stampTurnSessionId + markAnswerRedelivered — crash-survival redelivery
+// ---------------------------------------------------------------------------
+
+describe('stampTurnSessionId', () => {
+  it('pins the session id on the turn (first-write-wins) and defaults null', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: 'sx:1', chatId: 'sx' })
+    expect(getTurnByKey(db, 'sx:1')!.session_id).toBeNull()
+    stampTurnSessionId(db, 'sx:1', 'sess-abc')
+    expect(getTurnByKey(db, 'sx:1')!.session_id).toBe('sess-abc')
+    // first-write-wins: a later different session id does not overwrite
+    stampTurnSessionId(db, 'sx:1', 'sess-def')
+    expect(getTurnByKey(db, 'sx:1')!.session_id).toBe('sess-abc')
+    db.close()
+  })
+
+  it('ignores an empty session id and no-ops on unknown key', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: 'sx:2', chatId: 'sx' })
+    stampTurnSessionId(db, 'sx:2', '')
+    expect(getTurnByKey(db, 'sx:2')!.session_id).toBeNull()
+    expect(() => stampTurnSessionId(db, 'nope', 'x')).not.toThrow()
+    db.close()
+  })
+})
+
+describe('markAnswerRedelivered', () => {
+  it('stamps answer_redelivered_at (first-write-wins) on a SEPARATE marker from resumed_at', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: 'rd:1', chatId: 'rd' })
+    recordTurnEnd(db, { turnKey: 'rd:1', endedVia: 'restart' })
+    expect(getTurnByKey(db, 'rd:1')!.answer_redelivered_at).toBeNull()
+    markAnswerRedelivered(db, 'rd:1', 1_700_000_000_000)
+    expect(getTurnByKey(db, 'rd:1')!.answer_redelivered_at).toBe(1_700_000_000_000)
+    // does not touch resumed_at — the two ledgers are independent
+    expect(getTurnByKey(db, 'rd:1')!.resumed_at).toBeNull()
+    markAnswerRedelivered(db, 'rd:1', 1_800_000_000_000)
+    expect(getTurnByKey(db, 'rd:1')!.answer_redelivered_at).toBe(1_700_000_000_000)
+    db.close()
+  })
+
+  it('no-ops for an unknown turn_key', () => {
+    const db = openTurnsDbInMemory()
+    expect(() => markAnswerRedelivered(db, 'nope:1')).not.toThrow()
+    db.close()
+  })
+})

package/telegram-plugin/tests/reply-owner-resolve.test.ts

@@ -0,0 +1,279 @@
+/**
+ * Regression coverage for the 2026-07 double-reply-on-DM fix — completes the
+ * #3236 turnId-keyed dedup (`flushed-turn-supersede.ts`) for the late-reply / DM
+ * path.
+ *
+ * ## The incident these tests pin
+ *
+ * On a DM agent a turn DOUBLE-SENT: the answer-ready quiescence flush posted the
+ * composed terminal answer as message A (no quote), then the model's REAL
+ * `reply` tool call landed and sent message B (quoted). The user should have
+ * received exactly ONE message (the quoted reply).
+ *
+ * #3236's supersede is turnId-identity-keyed and text-agnostic BY DESIGN, so the
+ * 275-vs-249-char rewording is NOT why it missed. It missed because the reply's
+ * owner turn resolved to `null` on the late path: `currentTurn` was nulled by the
+ * flush's synthetic turn_end, and `origin_turn_id` (a forum-supergroup field) is
+ * absent in DMs — so the OLD 2-tier chain `currentTurn ?? findTurnByOriginId`
+ * yielded null, and `decideSupersede` never lets a null live turn supersede a
+ * turnId-bearing record.
+ *
+ * The router recovered the SAME reply's owner via `findTurnByQuotedMessageId` and
+ * `findLatestEndedTurnForChat`; the supersede chain omitted BOTH. The fix
+ * (`resolveReplyOwnerTurnId`) unifies the two onto one precedence.
+ *
+ * These tests exercise the extracted pure cores — the exact precedence and latch
+ * decision the gateway runs (`gateway.ts` is not importable in tests; the repo's
+ * `decideTurnFlush` / `decideSupersede` pattern). The core test also asserts the
+ * OLD 2-tier chain FAILS to recover the owner (the red-on-main contrast) while
+ * the unified chain recovers it and the supersede fires.
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  resolveReplyOwnerTurnId,
+  decideAnswerLatchSuppression,
+  type ReplyOwnerCandidates,
+} from '../reply-owner-resolve.js'
+import { FlushedTurnSupersedeRegistry, DEFAULT_SUPERSEDE_TTL_MS } from '../flushed-turn-supersede.js'
+
+const NONE: ReplyOwnerCandidates = {
+  liveTurnId: null,
+  originTurnId: null,
+  quotedTurnId: null,
+  latestEndedTurnId: null,
+}
+
+/** The OLD (pre-fix) resolver chain the gateway ran on main — the 2-tier
+ *  `currentTurn ?? findTurnByOriginId` — reproduced here to prove the incident
+ *  went unrecovered before the fix (red-on-main contrast). */
+function oldTwoTierResolve(c: ReplyOwnerCandidates): string | null {
+  return c.liveTurnId ?? c.originTurnId ?? null
+}
+
+describe('resolveReplyOwnerTurnId — unified owner-turn precedence (Part 1)', () => {
+  it('prefers the live currentTurn when present', () => {
+    expect(
+      resolveReplyOwnerTurnId({ ...NONE, liveTurnId: 'live', originTurnId: 'origin', latestEndedTurnId: 'ended' }),
+    ).toBe('live')
+  })
+
+  it('falls to the model-echoed origin turn when no live turn', () => {
+    expect(
+      resolveReplyOwnerTurnId({ ...NONE, originTurnId: 'origin', quotedTurnId: 'quoted', latestEndedTurnId: 'ended' }),
+    ).toBe('origin')
+  })
+
+  it('falls to the framework-owned quoted-message turn when no live/origin', () => {
+    expect(
+      resolveReplyOwnerTurnId({ ...NONE, quotedTurnId: 'quoted', latestEndedTurnId: 'ended' }),
+    ).toBe('quoted')
+  })
+
+  it('falls to the chat latest-ended turn as the final tier — the DM recovery', () => {
+    expect(resolveReplyOwnerTurnId({ ...NONE, latestEndedTurnId: 'ended' })).toBe('ended')
+  })
+
+  it('returns null only when every lookup missed', () => {
+    expect(resolveReplyOwnerTurnId(NONE)).toBeNull()
+  })
+
+  it('RED-ON-MAIN CONTRAST: the DM late reply (no live turn, no origin) is ' +
+    'unrecovered by the old 2-tier chain but recovered by the unified chain', () => {
+    // The exact incident inputs: flush nulled currentTurn (liveTurnId=null),
+    // DM has no origin_turn_id (originTurnId=null); the owner survives only in
+    // the latest-ended registry (latestEndedTurnId).
+    const incident: ReplyOwnerCandidates = { ...NONE, latestEndedTurnId: 'turn-T' }
+    // Old behaviour (what shipped on main): null → no supersede → duplicate.
+    expect(oldTwoTierResolve(incident)).toBeNull()
+    // Fixed behaviour: recovers the owning turn T.
+    expect(resolveReplyOwnerTurnId(incident)).toBe('turn-T')
+  })
+})
+
+describe('Part 1 end-to-end: unified resolver drives the flush supersede', () => {
+  const CHAT = '424242'
+
+  it('CORE INCIDENT: flush records message A for turn T, then a late DM reply ' +
+    '(currentTurn=null, no origin_turn_id) SUPERSEDES via the recovered owner', () => {
+    const reg = new FlushedTurnSupersedeRegistry()
+    const now = 1_000
+    // Flush commits message A for turn T.
+    reg.record(CHAT, undefined, { turnId: 'turn-T', messageIds: [5001], text: 'A' }, now)
+
+    // Late DM reply: no live turn, no origin echo; owner survives in the
+    // latest-ended registry as turn-T.
+    const incident: ReplyOwnerCandidates = { ...NONE, latestEndedTurnId: 'turn-T' }
+
+    // Old 2-tier chain → null → supersede DECLINES (the duplicate ships).
+    const oldId = oldTwoTierResolve(incident)
+    expect(reg.peek(CHAT, undefined, { liveTurnId: oldId, now: now + 10 }).supersede).toBe(false)
+
+    // Unified chain → turn-T → supersede FIRES and deletes message A, so the
+    // reply below delivers as the single clean message.
+    const newId = resolveReplyOwnerTurnId(incident)
+    const decision = reg.take(CHAT, undefined, { liveTurnId: newId, now: now + 10 })
+    expect(decision.supersede).toBe(true)
+    expect(decision.deleteMessageIds).toEqual([5001])
+  })
+
+  it('a DIFFERENT newer turn recovered as owner does NOT supersede turn T', () => {
+    const reg = new FlushedTurnSupersedeRegistry()
+    const now = 2_000
+    reg.record(CHAT, undefined, { turnId: 'turn-T', messageIds: [7001], text: 'A' }, now)
+    // Owner recovers to a newer turn (its own flush isn't recorded here).
+    const id = resolveReplyOwnerTurnId({ ...NONE, latestEndedTurnId: 'turn-NEWER' })
+    expect(reg.take(CHAT, undefined, { liveTurnId: id, now: now + 10 }).supersede).toBe(false)
+  })
+})
+
+describe('decideAnswerLatchSuppression — race backstop (Part 2)', () => {
+  it('RACE: a late substantive reply lands in the flush post-fire pre-record ' +
+    'window (no supersede record yet) → SUPPRESSED by the latch', () => {
+    expect(
+      decideAnswerLatchSuppression({
+        superseded: false,
+        replySubstantive: true,
+        isLateReply: true,
+        ownerAnswerDelivered: true,
+      }),
+    ).toBe(true)
+  })
+
+  it('does NOT double-suppress when Part 1 already superseded (else the turn ' +
+    'ends with ZERO messages)', () => {
+    expect(
+      decideAnswerLatchSuppression({
+        superseded: true,
+        replySubstantive: true,
+        isLateReply: true,
+        ownerAnswerDelivered: true,
+      }),
+    ).toBe(false)
+  })
+
+  it('NEGATIVE: an interim sub-floor ack (not substantive) is never suppressed ' +
+    '— so interim-ack-then-final both send', () => {
+    expect(
+      decideAnswerLatchSuppression({
+        superseded: false,
+        replySubstantive: false,
+        isLateReply: true,
+        ownerAnswerDelivered: true,
+      }),
+    ).toBe(false)
+  })
+
+  it('NEGATIVE: a normal in-turn reply with a live currentTurn is never ' +
+    'suppressed (a legitimate second substantive reply still sends)', () => {
+    expect(
+      decideAnswerLatchSuppression({
+        superseded: false,
+        replySubstantive: true,
+        isLateReply: false,
+        ownerAnswerDelivered: true,
+      }),
+    ).toBe(false)
+  })
+
+  it('does not suppress when the owner latch is unset (a normal answer)', () => {
+    expect(
+      decideAnswerLatchSuppression({
+        superseded: false,
+        replySubstantive: true,
+        isLateReply: true,
+        ownerAnswerDelivered: false,
+      }),
+    ).toBe(false)
+  })
+})
+
+describe('F1 — flush send failure must NOT suppress the late reply (zero-message guard)', () => {
+  // The flush arms `answerDelivered` synchronously at FIRE time, BEFORE the async
+  // send. If the send then throws and NOTHING was delivered, the supersede record
+  // is never written (gated on sentIds>0), so Part 1 cannot fire. Leaving the
+  // latch armed would make a genuine late reply suppress itself → the user gets
+  // ZERO messages. The gateway's send-failure catch resets `answerDelivered =
+  // false`; these assert the resulting coordination outcome at the pure core.
+  const lateSubstantiveReply = (ownerAnswerDelivered: boolean) =>
+    decideAnswerLatchSuppression({
+      superseded: false,
+      replySubstantive: true,
+      isLateReply: true,
+      ownerAnswerDelivered,
+    })
+
+  it('WITHOUT the catch-reset (latch still armed) the late reply is suppressed ' +
+    '— the zero-message bug', () => {
+    // Models the buggy state: flush armed the latch, send failed, latch left true.
+    expect(lateSubstantiveReply(true)).toBe(true)
+  })
+
+  it('WITH the catch-reset (answerDelivered=false) the late reply DELIVERS', () => {
+    // Models the fixed state: catch reset the latch, so the genuine late reply
+    // is not suppressed and the user still receives the answer.
+    expect(lateSubstantiveReply(false)).toBe(false)
+  })
+})
+
+describe('F2 — recency-bound the destructive latest-ended supersede tier', () => {
+  const CHAT = '515151'
+  const base: ReplyOwnerCandidates = {
+    liveTurnId: null,
+    originTurnId: null,
+    quotedTurnId: null,
+    latestEndedTurnId: null,
+  }
+
+  it('accepts a latest-ended turn that ended within the supersede TTL', () => {
+    expect(
+      resolveReplyOwnerTurnId({
+        ...base,
+        latestEndedTurnId: 'turn-T',
+        latestEndedAgeMs: DEFAULT_SUPERSEDE_TTL_MS - 1,
+        latestEndedTtlMs: DEFAULT_SUPERSEDE_TTL_MS,
+      }),
+    ).toBe('turn-T')
+  })
+
+  it('REJECTS a STALE latest-ended turn (ended past the supersede TTL) so it ' +
+    'cannot inherit deletion authority — resolver returns null', () => {
+    expect(
+      resolveReplyOwnerTurnId({
+        ...base,
+        latestEndedTurnId: 'turn-STALE',
+        latestEndedAgeMs: DEFAULT_SUPERSEDE_TTL_MS + 5_000,
+        latestEndedTtlMs: DEFAULT_SUPERSEDE_TTL_MS,
+      }),
+    ).toBeNull()
+  })
+
+  it('end-to-end: a stale latest-ended turn does NOT delete a live flush ' +
+    "record it doesn't own", () => {
+    const reg = new FlushedTurnSupersedeRegistry()
+    const now = 1_000_000
+    // A fresh flush record for the newer turn T2 (its owner, well within TTL).
+    reg.record(CHAT, undefined, { turnId: 'turn-T2', messageIds: [9001], text: 'A2' }, now)
+    // A late reply whose only recoverable owner is a STALE turn (ended long ago).
+    // Without the recency bound the resolver would hand back the stale turn id
+    // and a take() keyed on it could mis-target; with the bound it resolves null,
+    // so no deletion authority is granted and T2's record survives untouched.
+    const ownerId = resolveReplyOwnerTurnId({
+      ...base,
+      latestEndedTurnId: 'turn-STALE',
+      latestEndedAgeMs: DEFAULT_SUPERSEDE_TTL_MS + 5_000,
+      latestEndedTtlMs: DEFAULT_SUPERSEDE_TTL_MS,
+    })
+    expect(ownerId).toBeNull()
+    const decision = reg.take(CHAT, undefined, { liveTurnId: ownerId, now: now + 10 })
+    expect(decision.supersede).toBe(false)
+    // T2's record is intact (a null owner never reaches its turnId-keyed lane).
+    expect(reg.peek(CHAT, undefined, { liveTurnId: 'turn-T2', now: now + 10 }).supersede).toBe(true)
+  })
+
+  it('unbounded when no age is supplied (back-compat: pre-F2 precedence intact)', () => {
+    expect(
+      resolveReplyOwnerTurnId({ ...base, latestEndedTurnId: 'turn-T' }),
+    ).toBe('turn-T')
+  })
+})

package/telegram-plugin/tests/session-model-source.test.ts

@@ -56,6 +56,17 @@ describe('createSessionModelSource — freshest observation wins', () => {
     expect(s.resolve()).toEqual({ model: 'claude-opus-4-8', source: 'transcript' })
   })
 
+  it('#3241 optimistic override: a silently-switched model recorded without a confirmation still wins /status', () => {
+    // Part B — the typed set path records the REQUESTED model optimistically when
+    // the confirmation line was missed. That override, being the freshest write,
+    // must reclaim /status from the stale transcript line just like a confirmed
+    // switch (symptom 4: "/status shows old model" after an in-place typed switch).
+    const s = createSessionModelSource()
+    s.noteTranscriptModel('claude-opus-4-8') // old model's last assistant line
+    s.setOverride('fable') // optimistic record of the requested model (no confirmation read)
+    expect(s.resolve()).toEqual({ model: 'fable', source: 'override' })
+  })
+
   it('getOverride reports the override independent of freshness', () => {
     const s = createSessionModelSource()
     s.setOverride('sr-glm-5')

package/telegram-plugin/tests/session-tail.test.ts

@@ -6,12 +6,65 @@ import {
   projectTranscriptLine,
   projectSubagentLine,
   projectAssistantTextBlocks,
+  sumUsageTokens,
   sanitizeCwdToProjectName,
   getProjectsDirForCwd,
   startSessionTail,
   type SessionEvent,
 } from '../session-tail.js'
 
+describe('sumUsageTokens', () => {
+  it('sums input + output + cache_creation (cache_read excluded)', () => {
+    expect(
+      sumUsageTokens({
+        input_tokens: 100,
+        output_tokens: 50,
+        cache_read_input_tokens: 1000,
+        cache_creation_input_tokens: 200,
+      }),
+    ).toBe(350)
+  })
+
+  it('excludes a large cache_read_input_tokens from the total', () => {
+    // Locks in the deliberate exclusion: replayed cached context must not
+    // inflate the "new work this turn" figure. A future regression that
+    // re-adds cache_read makes this fail.
+    expect(
+      sumUsageTokens({
+        input_tokens: 100,
+        output_tokens: 50,
+        cache_read_input_tokens: 999_999,
+        cache_creation_input_tokens: 200,
+      }),
+    ).toBe(350)
+  })
+
+  it('guards missing fields with 0', () => {
+    expect(sumUsageTokens({ output_tokens: 42 })).toBe(42)
+    expect(sumUsageTokens({})).toBe(0)
+  })
+
+  it('ignores the nested iterations / cache_creation breakdown (no double count)', () => {
+    expect(
+      sumUsageTokens({
+        input_tokens: 2,
+        output_tokens: 3,
+        cache_read_input_tokens: 4,
+        cache_creation_input_tokens: 5,
+        cache_creation: { ephemeral_1h_input_tokens: 5, ephemeral_5m_input_tokens: 0 },
+        iterations: [{ input_tokens: 2, output_tokens: 3 }],
+      }),
+    ).toBe(10)
+  })
+
+  it('returns 0 for null / non-object / non-numeric fields', () => {
+    expect(sumUsageTokens(null)).toBe(0)
+    expect(sumUsageTokens(undefined)).toBe(0)
+    expect(sumUsageTokens('nope')).toBe(0)
+    expect(sumUsageTokens({ input_tokens: 'x', output_tokens: null })).toBe(0)
+  })
+})
+
 describe('sanitizeCwdToProjectName', () => {
   it('replaces non-alphanumeric chars with hyphens', () => {
     expect(sanitizeCwdToProjectName('/home/user/.switchroom/agents/assistant')).toBe(
@@ -381,6 +434,49 @@ describe('projectTranscriptLine', () => {
     })
     expect(projectTranscriptLine(line)).toEqual([{ kind: 'thinking' }])
   })
+
+  it('emits a main-tier usage event with the summed per-message token delta + message.id', () => {
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        id: 'msg_main_1',
+        model: 'claude-opus-4-8',
+        usage: {
+          input_tokens: 100,
+          output_tokens: 50,
+          cache_read_input_tokens: 1000,
+          cache_creation_input_tokens: 200,
+        },
+        content: [{ type: 'tool_use', id: 'toolu_a', name: 'Read', input: { file_path: '/a' } }],
+      },
+    })
+    const usage = projectTranscriptLine(line).find((e) => e.kind === 'usage')
+    expect(usage).toEqual({ kind: 'usage', messageId: 'msg_main_1', totalTokens: 350 })
+  })
+
+  it('emits no main-tier usage event when the assistant line carries no usage', () => {
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        id: 'msg_main_2',
+        model: 'claude-opus-4-8',
+        content: [{ type: 'tool_use', id: 'toolu_a', name: 'Read', input: { file_path: '/a' } }],
+      },
+    })
+    expect(projectTranscriptLine(line).some((e) => e.kind === 'usage')).toBe(false)
+  })
+
+  it('carries a null messageId on the main-tier usage event when message.id is absent', () => {
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        usage: { input_tokens: 5, output_tokens: 5 },
+        content: [{ type: 'text', text: 'working' }],
+      },
+    })
+    const usage = projectTranscriptLine(line).find((e) => e.kind === 'usage')
+    expect(usage).toEqual({ kind: 'usage', messageId: null, totalTokens: 10 })
+  })
 })
 
 // ─── Bug 1 regression: per-file cursor state survives re-attachment ────
@@ -554,6 +650,55 @@ describe('projectSubagentLine', () => {
     expect(events[0].kind).toBe('sub_agent_tool_use')
   })
 
+  it('emits sub_agent_usage with the summed per-message token delta + message.id', () => {
+    const st = { hasEmittedStart: true }
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        id: 'msg_1',
+        model: 'claude-opus-4-8',
+        usage: {
+          input_tokens: 100,
+          output_tokens: 50,
+          cache_read_input_tokens: 1000,
+          cache_creation_input_tokens: 200,
+        },
+        content: [{ type: 'tool_use', id: 'toolu_a', name: 'Read', input: { file_path: '/a' } }],
+      },
+    })
+    const events = projectSubagentLine(line, 'X', st)
+    const usage = events.find((e) => e.kind === 'sub_agent_usage')
+    expect(usage).toEqual({ kind: 'sub_agent_usage', agentId: 'X', messageId: 'msg_1', totalTokens: 350 })
+  })
+
+  it('emits no sub_agent_usage when the assistant line carries no usage', () => {
+    const st = { hasEmittedStart: true }
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        id: 'msg_2',
+        model: 'claude-opus-4-8',
+        content: [{ type: 'tool_use', id: 'toolu_a', name: 'Read', input: { file_path: '/a' } }],
+      },
+    })
+    const events = projectSubagentLine(line, 'X', st)
+    expect(events.some((e) => e.kind === 'sub_agent_usage')).toBe(false)
+  })
+
+  it('carries a null messageId when message.id is absent', () => {
+    const st = { hasEmittedStart: true }
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        usage: { input_tokens: 5, output_tokens: 5 },
+        content: [{ type: 'text', text: 'working' }],
+      },
+    })
+    const events = projectSubagentLine(line, 'X', st)
+    const usage = events.find((e) => e.kind === 'sub_agent_usage')
+    expect(usage).toEqual({ kind: 'sub_agent_usage', agentId: 'X', messageId: null, totalTokens: 10 })
+  })
+
   it('emits sub_agent_tool_use for regular tools; nested Agent fires ONLY nested_spawn', () => {
     const st = { hasEmittedStart: true }
     const line = JSON.stringify({

package/telegram-plugin/tests/subagent-watcher.test.ts

@@ -550,6 +550,56 @@ describe('startSubagentWatcher', () => {
       expect(modelled?.model).toBe('claude-opus-4-8')
     })
 
+    it('accumulates total tokens across assistant messages, deduped by message.id', () => {
+      const progress: Array<{ totalTokens: number }> = []
+      const agentDir = join(tmpRoot, 'agent')
+      const subagentsDir = join(agentDir, '.claude', 'projects', 'p1', 'session-abc', 'subagents')
+      mkdirSync(subagentsDir, { recursive: true })
+      const jsonlPath = join(subagentsDir, 'agent-deadbeef.jsonl')
+
+      const h = startWatcherSync({
+        agentDir,
+        onProgress: ({ totalTokens }) => { progress.push({ totalTokens }) },
+      })
+      writeFileSync(jsonlPath, buildJSONL(subAgentUserMsg('Research the competitors')))
+      h.poll()
+
+      // Message 1 persisted as TWO JSONL lines sharing one message.id + the
+      // SAME usage block (the ≥2.1.x split-message shape). Must count ONCE.
+      const usage1 = {
+        input_tokens: 100,
+        output_tokens: 50,
+        cache_read_input_tokens: 1000,
+        cache_creation_input_tokens: 200,
+      }
+      appendFileSync(jsonlPath, buildJSONL({
+        type: 'assistant',
+        message: { id: 'msg_1', model: 'claude-opus-4-8', usage: usage1, content: [{ type: 'text', text: 'thinking about it' }] },
+      }))
+      appendFileSync(jsonlPath, buildJSONL({
+        type: 'assistant',
+        message: { id: 'msg_1', model: 'claude-opus-4-8', usage: usage1, content: [{ type: 'tool_use', name: 'Read', id: 'r1', input: { file_path: '/x/a.ts' } }] },
+      }))
+      h.poll()
+
+      // A DISTINCT message adds on top; a line with NO usage contributes nothing.
+      appendFileSync(jsonlPath, buildJSONL({
+        type: 'assistant',
+        message: { id: 'msg_2', model: 'claude-opus-4-8', usage: { input_tokens: 2, output_tokens: 40 }, content: [{ type: 'tool_use', name: 'Bash', id: 'r2', input: {} }] },
+      }))
+      appendFileSync(jsonlPath, buildJSONL({
+        type: 'assistant',
+        message: { id: 'msg_3', model: 'claude-opus-4-8', content: [{ type: 'tool_use', name: 'Edit', id: 'r3', input: {} }] },
+      }))
+      h.poll()
+
+      // msg_1 (350, counted once despite two lines; cache_read excluded)
+      // + msg_2 (42) = 392.
+      expect(h.watcher.getRegistry().get('deadbeef')?.totalTokens).toBe(392)
+      const last = progress[progress.length - 1]
+      expect(last.totalTokens).toBe(392)
+    })
+
     it('ignores a synthetic model sentinel, keeping the last real model', () => {
       const agentDir = join(tmpRoot, 'agent')
       const subagentsDir = join(agentDir, '.claude', 'projects', 'p1', 'session-abc', 'subagents')