switchroom 0.18.3 → 0.18.7

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
@@ -575,6 +629,67 @@ describe('startSubagentWatcher', () => {
       expect(narrativeCues[0]).toContain('find the repo')
     })
 
+    it('narration-clobber regression: a narration cue immediately followed by its resolving tool_use in the same poll does NOT get overwritten by the tool-label cue', () => {
+      // Reproduces the bug: sub_agent_text ("On it...") + sub_agent_tool_use
+      // (Bash) land in the SAME jsonl-tail read, so both the narrative
+      // resolution (fireNarrativeProgress) and the tool-description
+      // onProgress fire within one loop iteration over `events`. Since the
+      // card renders replace-on-write, the tool-label call previously always
+      // clobbered the narration call that fired moments earlier — narration
+      // was staged and "SHOWN" per the dedup gate, but never actually
+      // visible on the pinned card. Assert only ONE onProgress cue fires for
+      // this tick, and it's the narration (progressLine == null), not the
+      // tool label.
+      const allCues: Array<{ progressLine?: string; latestSummary: 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: ({ progressLine, latestSummary }) => {
+          allCues.push({ progressLine, latestSummary })
+        },
+      })
+      writeFileSync(jsonlPath, buildJSONL(subAgentUserMsg('Find the repo')))
+      h.poll()
+      // Narration text + its resolving tool_use appended and tailed together
+      // in a single poll — this is the "same tick" race.
+      appendFileSync(
+        jsonlPath,
+        buildJSONL(subAgentAssistantText('On it. Let me find the repo.'), subAgentToolUse('Bash', 'b1')),
+      )
+      h.poll()
+      expect(allCues.length).toBe(1)
+      expect(allCues[0].progressLine).toBeUndefined()
+      expect(allCues[0].latestSummary).toContain('find the repo')
+    })
+
+    it('unregressed: two sub_agent_tool_use events with no narration between them both still show tool labels (named foreground blindspot)', () => {
+      // Guards against the clobber-guard fix over-suppressing: narrativeJustFired
+      // must be false for a tool_use that has no preceding pending narrative,
+      // so back-to-back tool calls (a researcher reading files with no prose)
+      // must both still surface a progressLine.
+      const toolCues: Array<string | undefined> = []
+      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: ({ progressLine }) => {
+          if (progressLine != null) toolCues.push(progressLine)
+        },
+      })
+      writeFileSync(jsonlPath, buildJSONL(subAgentUserMsg('Find the repo')))
+      h.poll()
+      appendFileSync(jsonlPath, buildJSONL(subAgentToolUse('Bash', 'b1')))
+      h.poll()
+      appendFileSync(jsonlPath, buildJSONL(subAgentToolUse('Bash', 'b2')))
+      h.poll()
+      expect(toolCues.length).toBe(2)
+    })
+
     it('narrative gate: trailing narration at turn_end is SHOWN', () => {
       const narrativeCues: string[] = []
       const agentDir = join(tmpRoot, 'agent')

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/unhandled-rejection-policy.test.ts

@@ -96,6 +96,25 @@ describe('classifyRejection — benign Telegram 400s', () => {
     )
     expect(classifyRejection(err)).toBe('log_only')
   })
+  it('returns "log_only" for "group chat was upgraded to a supergroup chat" (marko 2026-07-09, recurring 2026-06-07/2026-06-09)', () => {
+    // A send targeted a basic-group chat_id that Telegram had since
+    // migrated to a supergroup (new -100xxxxxxxxxx id). This crashed the
+    // ENTIRE gateway process (every agent/chat) over a single stale
+    // cached chat_id — the same root cause recurred three times across a
+    // month because the crash-on-leak behavior masked the underlying
+    // stale-id bug instead of just logging it. A migrated/invalid
+    // destination chat must never take down the whole gateway.
+    const err = grammyError(
+      400,
+      'Bad Request: group chat was upgraded to a supergroup chat',
+    )
+    expect(classifyRejection(err)).toBe('log_only')
+  })
+
+  it('returns "log_only" for "group chat was deactivated"', () => {
+    const err = grammyError(400, 'Bad Request: group chat was deactivated')
+    expect(classifyRejection(err)).toBe('log_only')
+  })
 })
 
 describe('classifyRejection — genuine errors still crash', () => {

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**')
@@ -945,6 +956,103 @@ describe('createWorkerActivityFeed — heartbeat', () => {
   })
 })
 
+// ─── Resurrection guard + deferred finalize (review findings #2 & #3) ─────────
+// #3: a late watcher onProgress tick arriving after `finish()` queued its
+//    chain must NOT resurrect the handle and paint a fresh running message.
+// #2: a terminal edit that hit a 429 cooldown stages on `pendingFinish` and
+//    is re-driven by the heartbeat after cooldown — the card can't get stuck
+//    on its last running render. "not modified" / message-gone are success/drop.
+describe('createWorkerActivityFeed — resurrection guard + deferred finalize', () => {
+  const drain = () => new Promise((r) => setTimeout(r, 0))
+
+  it('#3: a late update tick after finish does not resurrect a running card', async () => {
+    const bot = makeFakeBot()
+    let clock = 10_000
+    const feed = createWorkerActivityFeed({ bot, now: () => clock, minEditIntervalMs: 0 })
+    await feed.update('w1', 'chat', view({ toolCount: 1, latestSummary: 'step one' }))
+    expect(bot.sent).toHaveLength(1)
+
+    await feed.finish('w1', view({ state: 'done', toolCount: 1, latestSummary: 'done result' }))
+    // finish landed a terminal edit and dropped the handle.
+    expect(bot.edits.some((e) => e.text.includes('_done ·'))).toBe(true)
+    expect(feed.has('w1')).toBe(false)
+
+    // Late watcher tick arrives AFTER finish. Pre-fix this would create a
+    // fresh handle and paint a new running message on a finalized worker.
+    clock = 12_000
+    await feed.update('w1', 'chat', view({ toolCount: 2, latestSummary: 'step two' }))
+    expect(bot.sent).toHaveLength(1) // no new running message
+    expect(feed.has('w1')).toBe(false)
+    expect(feed.size).toBe(0)
+  })
+
+  it('#2: a 429 on the finish edit stages pendingFinish; the heartbeat re-drives it after cooldown', async () => {
+    const bot = makeFakeBot()
+    let clock = 10_000
+    const feed = createWorkerActivityFeed({
+      bot,
+      now: () => clock,
+      minEditIntervalMs: 0,
+      heartbeatTickMs: 6000,
+      setInterval: () => 1,
+      clearInterval: () => {},
+    })
+    await feed.update('w1', 'chat', view({ toolCount: 1, latestSummary: 'running step' }))
+    expect(bot.sent).toHaveLength(1)
+
+    // The terminal edit hits a 429 with a 2s retry_after.
+    bot.failNextEditWith = { error_code: 429, parameters: { retry_after: 2 } }
+    await feed.finish('w1', view({ state: 'done', toolCount: 1, latestSummary: 'final result' }))
+    await drain()
+    // No terminal edit landed yet — the last edit is still the running render.
+    expect(bot.edits.some((e) => e.text.includes('_done ·'))).toBe(false)
+
+    // Inside the cooldown — a heartbeat tick must NOT retry (would re-429).
+    clock = 11_000
+    feed.heartbeatTick()
+    await drain()
+    expect(bot.edits.some((e) => e.text.includes('_done ·'))).toBe(false)
+
+    // Past the cooldown (10_000 + 2000 + 500 jitter = 12_500) — the heartbeat
+    // re-drives the deferred finalize and the terminal edit lands.
+    clock = 13_000
+    feed.heartbeatTick()
+    await drain()
+    expect(bot.edits.some((e) => e.text.includes('_done ·'))).toBe(true)
+    expect(feed.has('w1')).toBe(false) // handle dropped after the terminal edit landed
+  })
+
+  it('#2: "message is not modified" on finish is treated as success (card already correct)', async () => {
+    const bot = makeFakeBot()
+    let clock = 10_000
+    const feed = createWorkerActivityFeed({ bot, now: () => clock, minEditIntervalMs: 0 })
+    await feed.update('w1', 'chat', view({ toolCount: 1, latestSummary: 'x' }))
+    expect(bot.sent).toHaveLength(1)
+
+    bot.failNextEditWith = new Error('Bad Request: message is not modified')
+    await feed.finish('w1', view({ state: 'done', toolCount: 1, latestSummary: 'x' }))
+    await drain()
+    // The handle is dropped — the not-modified outcome is success, no retry.
+    expect(feed.has('w1')).toBe(false)
+  })
+
+  it('#2: a gone message on finish drops the handle silently (no card to finalize)', async () => {
+    const bot = makeFakeBot()
+    const logs: string[] = []
+    let clock = 10_000
+    const feed = createWorkerActivityFeed({ bot, now: () => clock, minEditIntervalMs: 0, log: (m) => logs.push(m) })
+    await feed.update('w1', 'chat', view({ toolCount: 1, latestSummary: 'x' }))
+    expect(bot.sent).toHaveLength(1)
+
+    bot.failNextEditWith = new Error('Bad Request: message to edit not found')
+    await feed.finish('w1', view({ state: 'done', toolCount: 1, latestSummary: 'done' }))
+    await drain()
+    expect(feed.has('w1')).toBe(false)
+    // No scary "finish edit failed" warning for a transport-gone outcome.
+    expect(logs.some((l) => l.includes('finish edit failed'))).toBe(false)
+  })
+})
+
 // ─── Extreme-edge: single oversized narrative line (no-truncate ON) ──────────
 // Reproduces the bug where accumulateNarrative's char-budget splice would push
 // the oversized line then immediately splice it out, making the narrative empty