switchroom 0.18.6 → 0.18.7

package/telegram-plugin/tests/subagent-watcher-boot-promotion-replay.test.ts

@@ -37,14 +37,19 @@ describe('boot promotion — in-flight worker replays its activity through onPro
     let currentTime = 100_000
     // The file EXISTS AT BOOT with real in-flight activity: a prompt and two
     // tool steps, still running (no turn_end). mtime is fresh (30s ago) so
-    // the freshness gate promotes it.
-    const content = Buffer.from(buildJSONL(
+    // the freshness gate makes it ELIGIBLE — but fix #5 also requires actual
+    // post-boot growth before promoting (mtime freshness alone can't
+    // distinguish this from a worker killed moments before the restart).
+    // `content` grows below via the captured fs.watch callback to supply
+    // that confirmation.
+    let content = Buffer.from(buildJSONL(
       { type: 'user', message: { content: [{ type: 'text', text: 'long research task' }] } },
       { type: 'assistant', message: { content: [{ type: 'tool_use', id: 't1', name: 'Read', input: { file_path: '/repo/a.ts' } }] } },
       { type: 'assistant', message: { content: [{ type: 'tool_use', id: 't2', name: 'Bash', input: { command: 'npm test' } }] } },
     ), 'utf-8')
 
     let lastOpened: string | null = null
+    let watchCb: (() => void) | null = null
     const mockFs = {
       existsSync: ((p: fs.PathLike) => {
         const ps = String(p)
@@ -69,7 +74,10 @@ describe('boot promotion — in-flight worker replays its activity through onPro
         src.copy(buf as Buffer, offset)
         return src.length
       }) as unknown as typeof fs.readSync,
-      watch: (() => ({ close: vi.fn() }) as unknown as fs.FSWatcher) as unknown as typeof fs.watch,
+      watch: ((_p: fs.PathLike, cb?: () => void) => {
+        watchCb = cb ?? null
+        return { close: vi.fn() } as unknown as fs.FSWatcher
+      }) as unknown as typeof fs.watch,
     }
 
     const progressCalls: Array<{ agentId: string; progressLine?: string; toolCount: number }> = []
@@ -86,10 +94,25 @@ describe('boot promotion — in-flight worker replays its activity through onPro
       },
     })
 
+    // Fix #5: registration alone (mtime-fresh, no observed growth yet) must
+    // NOT promote — it stays historical/pending until growth confirms it.
+    const preGrowthEntry = watcher.getRegistry().get(agentId)
+    expect(preGrowthEntry?.historical).toBe(true)
+    expect(preGrowthEntry?.bootPromotionPending).toBeDefined()
+
+    // Simulate the worker taking one more real step post-boot: the JSONL
+    // grows, and Claude Code's fs notification fires.
+    content = Buffer.concat([content, Buffer.from(buildJSONL(
+      { type: 'assistant', message: { content: [{ type: 'text', text: 'still going' }] } },
+    ), 'utf-8')])
+    currentTime += 1000
+    watchCb?.()
+
     const entry = watcher.getRegistry().get(agentId)
     expect(entry).toBeDefined()
-    // Promoted live (fresh mtime, still running).
+    // Promoted live now that post-boot growth was actually observed.
     expect(entry?.historical).toBe(false)
+    expect(entry?.bootPromotionPending).toBeUndefined()
     // Replay rebuilt the entry WITHOUT double-counting the initial read.
     expect(entry?.toolCount).toBe(2)
     expect(entry?.lastTool?.name).toBe('Bash')
@@ -102,6 +125,86 @@ describe('boot promotion — in-flight worker replays its activity through onPro
     watcher.stop()
   })
 
+  it('fix #5: a running-at-boot file with fresh mtime but NO post-boot growth is never promoted (avoids a stale completed handback)', () => {
+    const agentId = 'inflight-no-growth-01'
+    const agentDir = '/home/user/.switchroom/agents/myagent'
+    const projectsRoot = `${agentDir}/.claude/projects`
+    const projectDir = `${projectsRoot}/mock-cwd`
+    const sessionDir = `${projectDir}/sess`
+    const subagentsDir = `${sessionDir}/subagents`
+    const jsonlPath = `${subagentsDir}/agent-${agentId}.jsonl`
+
+    let currentTime = 100_000
+    // Fresh mtime (30s old) but the file NEVER grows again — indistinguishable
+    // from a worker that was killed moments before this restart.
+    const content = Buffer.from(buildJSONL(
+      { type: 'user', message: { content: [{ type: 'text', text: 'task that got killed' }] } },
+      { type: 'assistant', message: { content: [{ type: 'tool_use', id: 't1', name: 'Read', input: { file_path: '/repo/a.ts' } }] } },
+    ), 'utf-8')
+
+    let lastOpened: string | null = null
+    const intervals: Array<{ fn: () => void; ms: number; fireAt: number }> = []
+    const mockFs = {
+      existsSync: ((p: fs.PathLike) => {
+        const ps = String(p)
+        return ps === projectsRoot || ps === projectDir || ps === sessionDir || ps === subagentsDir || ps === jsonlPath
+      }) as typeof fs.existsSync,
+      readdirSync: ((p: fs.PathLike) => {
+        const ps = String(p)
+        if (ps === projectsRoot) return ['mock-cwd']
+        if (ps === projectDir) return ['sess']
+        if (ps === sessionDir) return ['subagents']
+        if (ps === subagentsDir) return [`agent-${agentId}.jsonl`]
+        return []
+      }) as unknown as typeof fs.readdirSync,
+      statSync: (() => ({ size: content.length, mtimeMs: 100_000 - 30_000 }) as fs.Stats) as typeof fs.statSync,
+      openSync: ((p: fs.PathLike) => { lastOpened = String(p); return 7 }) as unknown as typeof fs.openSync,
+      closeSync: (() => { lastOpened = null }) as typeof fs.closeSync,
+      readSync: ((
+        _fd: number, buf: NodeJS.ArrayBufferView, offset: number, length: number, position: number | null,
+      ): number => {
+        if (lastOpened !== jsonlPath) return 0
+        const src = content.slice(position ?? 0, (position ?? 0) + length)
+        src.copy(buf as Buffer, offset)
+        return src.length
+      }) as unknown as typeof fs.readSync,
+      watch: (() => ({ close: vi.fn() }) as unknown as fs.FSWatcher) as unknown as typeof fs.watch,
+    }
+
+    const finishCalls: Array<{ agentId: string; outcome: string }> = []
+    const watcher = startSubagentWatcher({
+      agentDir,
+      fs: mockFs,
+      inflightPromoteMaxAgeMs: 60_000, // small bound so the test can cross it
+      now: () => currentTime,
+      setInterval: (fn, ms) => {
+        intervals.push({ fn, ms, fireAt: currentTime + ms })
+        return { ref: 0 }
+      },
+      clearInterval: () => {},
+      setTimeout: () => ({ ref: 0 }),
+      clearTimeout: () => {},
+      onFinish: ({ agentId: id, outcome }) => finishCalls.push({ agentId: id, outcome }),
+    })
+
+    const entryAtBoot = watcher.getRegistry().get(agentId)
+    expect(entryAtBoot?.historical).toBe(true)
+    expect(entryAtBoot?.bootPromotionPending).toBeDefined()
+
+    // Advance well past the promotion window WITHOUT the file ever growing.
+    currentTime += 120_000
+    for (const iv of intervals) if (iv.fireAt <= currentTime) iv.fn()
+
+    const entry = watcher.getRegistry().get(agentId)
+    // Never promoted: still historical, no completed/failed handback ever
+    // synthesised from these pre-restart bytes.
+    expect(entry?.historical).toBe(true)
+    expect(entry?.bootPromotionPending).toBeUndefined() // gave up after the deadline
+    expect(finishCalls).toHaveLength(0)
+
+    watcher.stop()
+  })
+
   it('a STALE running-at-boot file stays historical and fires no onProgress (no replay spam)', () => {
     const agentId = 'stale-at-boot-01'
     const agentDir = '/home/user/.switchroom/agents/myagent'

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

@@ -224,14 +224,22 @@ describe('Gap 1 — background worker in-flight across a gateway restart', () =>
     expect(h.finishCalls[0].agentId).toBe('gap1-complete')
     expect(h.finishCalls[0].outcome).toBe('completed') // pre-fix: 'orphan' → dropped
     expect(h.finishCalls[0].resultText).toContain('root cause')
-    // The promotion is logged so the path is observable in prod.
-    expect(h.logs.some((l) => l.includes('in-flight at boot — promoting to live'))).toBe(true)
+    // Fix #5: promotion now requires an observed post-boot growth event
+    // (mtime freshness alone is refused) — the `append` above supplied it,
+    // and the promotion is logged so the path is observable in prod.
+    expect(h.logs.some((l) => l.includes('confirmed live') && l.includes('post-boot JSONL growth'))).toBe(true)
   })
 
-  it('an in-flight-at-boot worker that dies silently is rescued by stall synthesis', () => {
+  it('an in-flight-at-boot worker that dies silently (after proving liveness) is rescued by stall synthesis', () => {
     // Pre-fix, historical entries were skipped by stall detection, so a
     // worker that crossed a restart and then went silent sat running
     // forever — no handback ever. After promotion it gets the safety net.
+    //
+    // Fix #5: promotion additionally requires proof of post-boot liveness —
+    // a single real step (e.g. a narrative line) grows the JSONL past its
+    // boot-time snapshot, confirming this is NOT a worker killed moments
+    // before the restart. Only THEN does it get the stall-synthesis safety
+    // net when it subsequently goes silent for good.
     const h = makeHarness({
       agentId: 'gap1-silent',
       bootLines: [subAgentUserMsg('bg task')],
@@ -239,6 +247,11 @@ describe('Gap 1 — background worker in-flight across a gateway restart', () =>
       silentStallTerminalMs: 120_000,
     })
 
+    h.append(subAgentText('still investigating'))
+    h.advance(600) // one poll observes the post-boot growth → promotes
+
+    expect(h.watcher.getRegistry().get('gap1-silent')?.historical).toBe(false)
+
     h.advance(62_000) // stall threshold crossed
     expect(h.stallTerminalCalls).toHaveLength(0)
     h.advance(121_000) // silent-stall terminal window elapses → synthesis
@@ -247,6 +260,30 @@ describe('Gap 1 — background worker in-flight across a gateway restart', () =>
     expect(h.finishCalls[0].outcome).toBe('completed')
   })
 
+  it('fix #5: an in-flight-at-boot worker that NEVER shows post-boot growth is left historical (no stale completed handback)', () => {
+    // The bug this closes: a worker killed <15min before a restart is
+    // byte-for-byte indistinguishable from a live one by mtime alone. Absent
+    // any actual post-boot growth, it must NOT be promoted — so it can never
+    // synthesise a false 'completed' handback from the pre-restart bytes.
+    const h = makeHarness({
+      agentId: 'gap1-killed-before-restart',
+      bootLines: [subAgentUserMsg('bg task')],
+      stallThresholdMs: 60_000,
+      silentStallTerminalMs: 120_000,
+      inflightPromoteMaxAgeMs: 60_000,
+    })
+
+    // No append — the file never grows again after boot.
+    h.advance(62_000)
+    h.advance(121_000)
+    h.advance(600_000) // well past the promotion window too
+
+    expect(h.watcher.getRegistry().get('gap1-killed-before-restart')?.historical).toBe(true)
+    expect(h.stallTerminalCalls).toHaveLength(0)
+    expect(h.finishCalls).toHaveLength(0)
+    expect(h.logs.some((l) => l.includes('never observed post-boot JSONL growth'))).toBe(true)
+  })
+
   it('a worker already DONE at boot stays suppressed (no spurious replay)', () => {
     // The legitimate use of `historical`: a worker that finished in a prior
     // session must NOT re-fire a handback on every restart. This is the
@@ -298,7 +335,8 @@ describe('Gap 1 freshness gate — v0.14.24 stale-replay regression', () => {
 
     expect(h.finishCalls).toHaveLength(1)
     expect(h.finishCalls[0].outcome).toBe('completed')
-    expect(h.logs.some((l) => l.includes('promoting to live'))).toBe(true)
+    // Fix #5: the append above supplies the required post-boot growth proof.
+    expect(h.logs.some((l) => l.includes('confirmed live'))).toBe(true)
   })
 
   it('kill-switch (bootPromoteEnabled=false) suppresses even a fresh running-at-boot worker', () => {

package/telegram-plugin/tests/subagent-watcher-parent-turn-key.test.ts

@@ -265,6 +265,53 @@ describe('backfillJsonlAgentId — overlapping windows / hook precedence (#2081)
   })
 })
 
+// ─── Fix #3: ambiguous fuzzy backfill refuses to link ────────────────────────
+// Legacy meta.json (no toolUseId) falls back to the fuzzy (agentType,
+// description) match. With N unlinked rows sharing that key, a bare
+// `ORDER BY started_at DESC LIMIT 1` assigned by start-order, not true
+// correspondence — a genuine mislink for a cross-topic identical dispatch.
+// The fix: link only when the candidate is UNAMBIGUOUS (exactly one match);
+// otherwise leave jsonl_agent_id NULL and let the marker/window path
+// attribute it.
+describe('backfillJsonlAgentId — fix #3: ambiguous fuzzy match refused', () => {
+  it('two unlinked rows sharing (agent_type, description) → fuzzy link refused, row stays NULL', () => {
+    insertSub({ id: 'toolu_amb_1', agentType: 'general-purpose', description: 'Run the tests', startedAt: 1000 })
+    insertSub({ id: 'toolu_amb_2', agentType: 'general-purpose', description: 'Run the tests', startedAt: 2000 })
+
+    // Legacy meta.json — no toolUseId, forces the fuzzy fallback path.
+    const jsonlPath = writeMeta('general-purpose', 'Run the tests')
+    const logs: string[] = []
+    backfillJsonlAgentId(db, jsonlPath, 'agentstem_ambiguous', (m) => logs.push(m))
+
+    // Neither candidate gets mis-assigned — both remain unlinked.
+    expect(readSub('toolu_amb_1')?.jsonl_agent_id ?? null).toBeNull()
+    expect(readSub('toolu_amb_2')?.jsonl_agent_id ?? null).toBeNull()
+    expect(logs.some((l) => l.includes('ambiguous') && l.includes('agentstem_ambiguous'))).toBe(true)
+  })
+
+  it('a SINGLE unambiguous candidate still links normally (no regression)', () => {
+    insertSub({ id: 'toolu_unamb', agentType: 'general-purpose', description: 'Unique task', startedAt: 1000 })
+
+    const jsonlPath = writeMeta('general-purpose', 'Unique task')
+    backfillJsonlAgentId(db, jsonlPath, 'agentstem_unambiguous')
+
+    expect(readSub('toolu_unamb')?.jsonl_agent_id).toBe('agentstem_unambiguous')
+  })
+
+  it('three unlinked rows sharing the same key → still refused (not just a 2-row edge case)', () => {
+    insertSub({ id: 'toolu_amb3_1', agentType: 'researcher', description: 'Investigate', startedAt: 1000 })
+    insertSub({ id: 'toolu_amb3_2', agentType: 'researcher', description: 'Investigate', startedAt: 2000 })
+    insertSub({ id: 'toolu_amb3_3', agentType: 'researcher', description: 'Investigate', startedAt: 3000 })
+
+    const jsonlPath = writeMeta('researcher', 'Investigate')
+    backfillJsonlAgentId(db, jsonlPath, 'agentstem_amb3')
+
+    expect(readSub('toolu_amb3_1')?.jsonl_agent_id ?? null).toBeNull()
+    expect(readSub('toolu_amb3_2')?.jsonl_agent_id ?? null).toBeNull()
+    expect(readSub('toolu_amb3_3')?.jsonl_agent_id ?? null).toBeNull()
+  })
+})
+
 // ─── #2506: null meta.json guard ─────────────────────────────────────────────
 // JSON.parse('null') succeeds and returns null. Before the fix, the enclosing
 // try/catch only covered the read+parse, so execution fell through to

package/telegram-plugin/tests/subagent-watcher-terminated-ids-cap.test.ts

@@ -0,0 +1,150 @@
+/**
+ * Fix #9a — `terminatedAgentIds` (the re-discovery dedup guard added on
+ * every `cleanupTerminalAgent`, read in `scanSubagentsDir`'s skip-check)
+ * grew unboundedly: only ever cleared wholesale in `stop()`. This pins the
+ * bound: once the cap is hit, the OLDEST id is evicted on each new insert
+ * (Set preserves insertion order), while the dedup guarantee for recently-
+ * terminated ids still holds.
+ *
+ * `terminatedAgentIdsCap` is a config override so the test can exercise
+ * eviction with a handful of entries instead of the production cap
+ * (a few thousand).
+ */
+
+import { describe, it, expect, vi } from 'vitest'
+import { startSubagentWatcher } from '../subagent-watcher.js'
+import * as fs from 'fs'
+
+function buildJSONL(...lines: object[]): string {
+  return lines.map((l) => JSON.stringify(l)).join('\n') + '\n'
+}
+function subAgentUserMsg(promptText: string) {
+  return { type: 'user', message: { content: [{ type: 'text', text: promptText }] } }
+}
+function subAgentTurnEnd() {
+  return { type: 'system', subtype: 'turn_duration', duration_ms: 100 }
+}
+
+describe('terminatedAgentIds cap (fix #9a)', () => {
+  it('evicts the oldest terminated id once the cap is hit, but keeps dedup for recent ids', () => {
+    const agentDir = '/home/user/.switchroom/agents/myagent'
+    const projectsRoot = `${agentDir}/.claude/projects`
+    const projectDir = `${projectsRoot}/mock-cwd`
+    const sessionDir = `${projectDir}/sess`
+    const subagentsDir = `${sessionDir}/subagents`
+
+    // 4 agents, already fully done (turn_end present) at "boot" — each will
+    // schedule a terminal cleanup immediately.
+    const agentIds = ['agent-a', 'agent-b', 'agent-c', 'agent-d']
+    const fileNames = agentIds.map((id) => `agent-${id}.jsonl`)
+    const filePaths = new Map(agentIds.map((id) => [id, `${subagentsDir}/agent-${id}.jsonl`]))
+    // Files visible to a directory scan — stay present throughout (a real
+    // gateway's JSONL files don't disappear on cleanup either; only the
+    // in-memory `terminatedAgentIds` dedup guard decides re-registration).
+    const visibleFiles = [...fileNames]
+
+    const content = Buffer.from(buildJSONL(subAgentUserMsg('done task'), subAgentTurnEnd()), 'utf-8')
+
+    let lastOpened: string | null = null
+    const mockFs = {
+      existsSync: ((p: fs.PathLike) => {
+        const ps = String(p)
+        if (ps === projectsRoot || ps === projectDir || ps === sessionDir || ps === subagentsDir) return true
+        return [...filePaths.values()].includes(ps)
+      }) as typeof fs.existsSync,
+      readdirSync: ((p: fs.PathLike) => {
+        const ps = String(p)
+        if (ps === projectsRoot) return ['mock-cwd']
+        if (ps === projectDir) return ['sess']
+        if (ps === sessionDir) return ['subagents']
+        if (ps === subagentsDir) return visibleFiles
+        return []
+      }) as unknown as typeof fs.readdirSync,
+      statSync: (() => ({ size: content.length, mtimeMs: 0 }) as fs.Stats) as typeof fs.statSync,
+      openSync: ((p: fs.PathLike) => { lastOpened = String(p); return 7 }) as unknown as typeof fs.openSync,
+      closeSync: (() => { lastOpened = null }) as typeof fs.closeSync,
+      readSync: ((
+        _fd: number, buf: NodeJS.ArrayBufferView, offset: number, length: number, position: number | null,
+      ): number => {
+        if (lastOpened == null) return 0
+        const src = content.slice(position ?? 0, (position ?? 0) + length)
+        src.copy(buf as Buffer, offset)
+        return src.length
+      }) as unknown as typeof fs.readSync,
+      watch: (() => ({ close: vi.fn() }) as unknown as fs.FSWatcher) as unknown as typeof fs.watch,
+    }
+
+    let currentTime = 1_000_000
+    const intervals: Array<{ fn: () => void; ms: number; fireAt: number }> = []
+    const timeouts: Array<{ fn: () => void; ms: number; fireAt: number; ref: number }> = []
+    let nextTimeoutRef = 1
+
+    const advance = (ms: number): void => {
+      currentTime += ms
+      for (;;) {
+        timeouts.sort((a, b) => a.fireAt - b.fireAt)
+        const next = timeouts[0]
+        if (!next || next.fireAt > currentTime) break
+        timeouts.shift()
+        next.fn()
+      }
+      for (const iv of intervals) {
+        while (iv.fireAt <= currentTime) {
+          iv.fn()
+          iv.fireAt += iv.ms
+        }
+      }
+    }
+
+    const watcher = startSubagentWatcher({
+      agentDir,
+      fs: mockFs,
+      terminatedAgentIdsCap: 3,
+      now: () => currentTime,
+      setInterval: (fn, ms) => {
+        intervals.push({ fn, ms, fireAt: currentTime + ms })
+        return { ref: 0 }
+      },
+      clearInterval: () => {},
+      setTimeout: (fn, ms) => {
+        const ref = nextTimeoutRef++
+        timeouts.push({ fn, ms, fireAt: currentTime + ms, ref })
+        return { ref }
+      },
+      clearTimeout: (handle) => {
+        const { ref } = handle as { ref: number }
+        const idx = timeouts.findIndex((t) => t.ref === ref)
+        if (idx !== -1) timeouts.splice(idx, 1)
+      },
+    })
+
+    // All 4 discovered at boot, already `done` → each schedules a terminal
+    // cleanup TERMINAL_CLEANUP_GRACE_MS (30s) out, in discovery order.
+    for (const id of agentIds) {
+      expect(watcher.getRegistry().has(id)).toBe(true)
+    }
+
+    // Fire all 4 scheduled cleanups (in order a, b, c, d). With cap=3, the
+    // 4th cleanup (d) evicts the OLDEST tracked id (a) before inserting d.
+    // `advance()` also drives the rescan interval (default 1s) forward as
+    // part of the same clock jump, so by the time it returns the poll
+    // loop has ALSO already rediscovered the just-evicted agent-a (its
+    // JSONL file is still on disk throughout — nothing "disappears" for a
+    // real gateway either) — that's the observable proof the eviction
+    // took effect, not a separate step.
+    advance(30_000)
+
+    // agent-a was evicted from `terminatedAgentIds` (cap=3, it was the
+    // oldest insert) → the dedup guard no longer suppresses it, so the
+    // rescan re-discovered and re-registered it.
+    expect(watcher.getRegistry().has('agent-a')).toBe(true)
+    // agent-b, agent-c, agent-d are still within the cap window → the
+    // dedup guard still suppresses their re-discovery even though their
+    // JSONL files are also still sitting on disk.
+    expect(watcher.getRegistry().has('agent-b')).toBe(false)
+    expect(watcher.getRegistry().has('agent-c')).toBe(false)
+    expect(watcher.getRegistry().has('agent-d')).toBe(false)
+
+    watcher.stop()
+  })
+})

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

@@ -519,6 +519,60 @@ describe('startSubagentWatcher', () => {
       expect(toolTick?.latestSummary).toBe('')
     })
 
+    it('captures message.model into entry.currentModel and threads it onto onProgress', () => {
+      const progress: Array<{ model?: string }> = []
+      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: ({ model }) => { progress.push({ model }) },
+      })
+      writeFileSync(jsonlPath, buildJSONL(subAgentUserMsg('Research the competitors')))
+      h.poll()
+
+      // Assistant line carrying a resolved model + a tool_use (drives an
+      // onProgress tick). The model event is projected first, so the entry's
+      // currentModel is set before the tool tick fires.
+      appendFileSync(jsonlPath, buildJSONL({
+        type: 'assistant',
+        message: {
+          model: 'claude-opus-4-8',
+          content: [{ type: 'tool_use', name: 'Read', id: 'r1', input: { file_path: '/x/CLAUDE.md' } }],
+        },
+      }))
+      h.poll()
+
+      expect(h.watcher.getRegistry().get('deadbeef')?.currentModel).toBe('claude-opus-4-8')
+      const modelled = progress.find((p) => p.model != null)
+      expect(modelled?.model).toBe('claude-opus-4-8')
+    })
+
+    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')
+      mkdirSync(subagentsDir, { recursive: true })
+      const jsonlPath = join(subagentsDir, 'agent-deadbeef.jsonl')
+
+      const h = startWatcherSync({ agentDir })
+      writeFileSync(jsonlPath, buildJSONL(subAgentUserMsg('Research')))
+      h.poll()
+      appendFileSync(jsonlPath, buildJSONL({
+        type: 'assistant',
+        message: { model: 'claude-opus-4-8', content: [{ type: 'tool_use', name: 'Read', id: 'r1', input: {} }] },
+      }))
+      h.poll()
+      // A compaction/synthetic line — must NOT clobber the last real model.
+      appendFileSync(jsonlPath, buildJSONL({
+        type: 'assistant',
+        message: { model: '<synthetic>', content: [{ type: 'tool_use', name: 'Bash', id: 'b1', input: {} }] },
+      }))
+      h.poll()
+      expect(h.watcher.getRegistry().get('deadbeef')?.currentModel).toBe('claude-opus-4-8')
+    })
+
     it('narrative gate: a draft-then-reply sub_agent_text is SUPPRESSED (no progress cue)', () => {
       // The worker composes its answer as a text block, then calls
       // stream_reply with near-identical text. The narrative cue must be

package/telegram-plugin/tests/tool-activity-summary.test.ts

@@ -723,6 +723,28 @@ describe("renderActivityHeader — two-line header builder", () => {
     const [h1] = renderActivityHeader("🤖", "Agent", "run a_b & c*d", 5_000, 1, "running");
     expect(h1).toContain("run a\\_b & c\\*d");
   });
+
+  it("appends the friendly live model to the running metrics line", () => {
+    const [, h2] = renderActivityHeader("🤖", "Agent", "", 120_000, 14, "running", "claude-opus-4-8");
+    expect(h2).toBe("_2m00s · 14 tools · opus 4.8_");
+  });
+
+  it("appends the friendly live model to the done metrics line", () => {
+    const [, h2] = renderActivityHeader("🤖", "Agent", "", 65_000, 3, "done", "claude-sonnet-5");
+    expect(h2).toBe("_done · 3 tools · 1m05s · sonnet 5_");
+  });
+
+  it("shows an sr-* model id verbatim on the metrics line", () => {
+    const [, h2] = renderActivityHeader("🛠", "Worker", "run tests", 10_000, 2, "running", "sr-glm-5");
+    expect(h2).toBe("_10s · 2 tools · sr-glm-5_");
+  });
+
+  it("omits the model tag for a sentinel / absent value", () => {
+    const [, h2none] = renderActivityHeader("🤖", "Agent", "", 15_000, 7, "running");
+    expect(h2none).toBe("_15s · 7 tools_");
+    const [, h2synth] = renderActivityHeader("🤖", "Agent", "", 15_000, 7, "running", "<synthetic>");
+    expect(h2synth).toBe("_15s · 7 tools_");
+  });
 });
 
 describe("agent flat path routes through the shared step-feed primitive", () => {
@@ -815,6 +837,21 @@ describe("renderActivityFeed — header param (main-session card fix)", () => {
     expect(out).toContain("**→ Searching memory**");
   });
 
+  it("threads the header model through the flat and nested feed paths", () => {
+    const header: SessionActivityHeader = {
+      label: "Agent",
+      elapsedMs: 120_000,
+      toolCount: 14,
+      state: "running",
+      model: "claude-opus-4-8",
+    };
+    const flat = renderActivityFeed(["Searching memory"], false, "", undefined, header)!;
+    expect(flat).toContain("_2m00s · 14 tools · opus 4.8_");
+    // Nested path (with a child line) carries the same model tag.
+    const nested = renderActivityFeedWithNested(["Reading"], ["nested step"], false, "", undefined, header)!;
+    expect(nested).toContain("· opus 4.8_");
+  });
+
   it("prepends the done header when final=true", () => {
     const header: SessionActivityHeader = {
       label: "Agent",

package/telegram-plugin/tests/typing-wrap.test.ts

@@ -64,6 +64,29 @@ describe('createTypingWrapper', () => {
     expect(deps.startTypingLoop).toHaveBeenCalledTimes(1)
   })
 
+  it('fix #7: does NOT stop typing when the first of two parallel tools resolves while the second is still running', () => {
+    const deps = makeDeps()
+    const w = createTypingWrapper(deps)
+    // Two overlapping tool_use blocks on the same lane. The first fires the
+    // loop immediately; the second (still in-flight) uses the debounce.
+    w.onToolUse('t1', 'chat-A', 'Bash')
+    w.onToolUse('t2', 'chat-A', 'Read')
+    expect(deps.startTypingLoop).toHaveBeenCalledTimes(1)
+    // Let t2's debounce fire so it's a live, started entry on the lane too.
+    vi.advanceTimersByTime(500)
+    expect(deps.startTypingLoop).toHaveBeenCalledTimes(2)
+
+    // t1 resolves first — with the pre-fix boolean Set, this deleted the
+    // lane and stopped the loop even though t2 is still running.
+    w.onToolResult('t1')
+    expect(deps.stopTypingLoop).not.toHaveBeenCalled()
+
+    // t2 resolves too — now the lane's ref-count hits zero and the loop stops.
+    w.onToolResult('t2')
+    expect(deps.stopTypingLoop).toHaveBeenCalledTimes(1)
+    expect(deps.stopTypingLoop).toHaveBeenCalledWith('chat-A', null)
+  })
+
   it('starts then stops typing when a single slow tool completes', () => {
     const deps = makeDeps()
     const w = createTypingWrapper(deps)

package/telegram-plugin/tests/worker-activity-feed.test.ts

@@ -86,6 +86,17 @@ describe('renderWorkerActivity', () => {
     expect(out).not.toContain('<code>')
   })
 
+  it('renders the friendly live model on the worker metrics line', () => {
+    const out = renderWorkerActivity(view({ model: 'claude-sonnet-5' }))
+    expect(out).toContain('_10s · 3 tools · sonnet 5_')
+  })
+
+  it('omits the model tag when the worker model is unknown', () => {
+    const out = renderWorkerActivity(view())
+    expect(out).toContain('_10s · 3 tools_')
+    expect(out).not.toContain('· sonnet')
+  })
+
   it('shows a "starting…" line when no step has run yet', () => {
     const out = renderWorkerActivity(view({ lastTool: null, latestSummary: '' }))
     expect(out).toContain('🛠 **Worker**')