switchroom 0.18.18 → 0.18.20

package/telegram-plugin/tests/subagent-watcher-narrative-early-paint.test.ts

@@ -0,0 +1,218 @@
+/**
+ * Residual A regression: a worker / sub-agent's OPENING narration must paint
+ * EARLY on its card (~the next poll after PENDING_NARRATIVE_FLUSH_MS) WITHOUT
+ * waiting for the worker's first tool — the same time-box the main-agent card
+ * got in #3227, applied uniformly to the poll-driven worker/sub-agent path via
+ * the SHARED NarrativeFlushController kernel driven by the injected poll clock.
+ *
+ * These assert OUTCOMES on the onProgress cue stream (the worker card is
+ * replace-on-write via onProgress), driven by an INJECTED clock so the timing
+ * is deterministic:
+ *   - a parked opening narration fires a narrative cue after the flush window
+ *     with NO tool event (RED if the early-paint tick is removed);
+ *   - it fires at more than one entry (depth-generic — the registry is flat, so
+ *     every sub-agent/worker/nested sub-worker is a WorkerEntry and the gate is
+ *     per-entry);
+ *   - the early-painted block is NOT re-fired (no double-print) and does not
+ *     leave a stale duplicate when the first real tool step lands after it;
+ *   - a tool arriving WITHIN the window still resolves the block exactly once
+ *     (no early-paint + resolve double).
+ */
+
+import { describe, it, expect, afterEach } from 'vitest'
+import { mkdtempSync, mkdirSync, writeFileSync, appendFileSync, rmSync } from 'fs'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import { startSubagentWatcher } from '../subagent-watcher.js'
+import { PENDING_NARRATIVE_FLUSH_MS } from '../narrative-flush.js'
+
+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 subAgentAssistantText(text: string) {
+  return { type: 'assistant', message: { content: [{ type: 'text', text }] } }
+}
+function subAgentToolUse(name: string, id: string) {
+  return { type: 'assistant', message: { content: [{ type: 'tool_use', name, id, input: {} }] } }
+}
+
+interface Cue { progressLine?: string; latestSummary: string }
+
+describe('worker/sub-agent opening-narration early paint (Residual A)', () => {
+  let tmpRoot = ''
+  const started: Array<ReturnType<typeof startSubagentWatcher>> = []
+
+  afterEach(() => {
+    while (started.length) {
+      try { started.pop()?.stop() } catch { /* ignore */ }
+    }
+    if (tmpRoot) {
+      try { rmSync(tmpRoot, { recursive: true, force: true }) } catch { /* ignore */ }
+      tmpRoot = ''
+    }
+  })
+
+  /** Watcher over a real tmpdir with an INJECTED, manually-advanced clock. */
+  function startWatcher(agentDir: string) {
+    let currentTime = 100_000
+    const cues: Array<{ agentId: string } & Cue> = []
+    const intervals: Array<{ fn: () => void; ref: number }> = []
+    let nextRef = 1
+    const watcher = startSubagentWatcher({
+      agentDir,
+      onFinish: () => {},
+      onProgress: ({ agentId, progressLine, latestSummary }) => {
+        cues.push({ agentId, progressLine, latestSummary })
+      },
+      stallThresholdMs: 600_000,
+      silentSynthesisStallThresholdMs: 600_000,
+      rescanMs: 1000,
+      now: () => currentTime,
+      setInterval: (fn) => { const ref = nextRef++; intervals.push({ fn, ref }); return { ref } },
+      clearInterval: (handle) => {
+        const { ref } = handle as { ref: number }
+        const idx = intervals.findIndex((i) => i.ref === ref)
+        if (idx !== -1) intervals.splice(idx, 1)
+      },
+      setTimeout: () => ({ ref: nextRef++ }),
+      clearTimeout: () => {},
+      log: () => {},
+    })
+    started.push(watcher)
+    return {
+      watcher,
+      cues,
+      poll: () => intervals[0]?.fn(),
+      advance: (ms: number) => { currentTime += ms },
+    }
+  }
+
+  function narrativeCues(cues: Cue[]): string[] {
+    // Narrative cues carry NO progressLine; tool-label cues do.
+    return cues.filter((c) => c.progressLine == null).map((c) => c.latestSummary)
+  }
+
+  it('paints a parked opening narration after the flush window with NO tool event', () => {
+    tmpRoot = mkdtempSync(join(tmpdir(), 'sr-early-paint-'))
+    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')
+
+    writeFileSync(jsonlPath, buildJSONL(subAgentUserMsg('Do the task')))
+    const h = startWatcher(agentDir)
+    h.poll() // register + promote to live
+
+    // Opening narration arrives; the worker then "thinks" (no tool yet).
+    appendFileSync(jsonlPath, buildJSONL(subAgentAssistantText('On it — pulling the logs first.')))
+    h.poll() // parks the block, arms the early-paint timer — NO cue yet
+    expect(narrativeCues(h.cues), 'parked block must not paint before the window').toHaveLength(0)
+
+    // Advance past the flush window and poll again — STILL no new jsonl event.
+    h.advance(PENDING_NARRATIVE_FLUSH_MS + 50)
+    h.poll()
+
+    const narr = narrativeCues(h.cues)
+    expect(narr, 'opening narration must early-paint without a tool').toHaveLength(1)
+    expect(narr[0]).toContain('pulling the logs')
+  })
+
+  it('does NOT paint before the flush window elapses', () => {
+    tmpRoot = mkdtempSync(join(tmpdir(), 'sr-early-paint-nofire-'))
+    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')
+
+    writeFileSync(jsonlPath, buildJSONL(subAgentUserMsg('Do the task')))
+    const h = startWatcher(agentDir)
+    h.poll()
+    appendFileSync(jsonlPath, buildJSONL(subAgentAssistantText('On it — pulling the logs first.')))
+    h.poll()
+
+    // Advance LESS than the window — the tick must not fire yet.
+    h.advance(PENDING_NARRATIVE_FLUSH_MS - 50)
+    h.poll()
+    expect(narrativeCues(h.cues), 'must not paint before the window').toHaveLength(0)
+  })
+
+  it('is depth-generic: two independent entries each early-paint their opening narration', () => {
+    tmpRoot = mkdtempSync(join(tmpdir(), 'sr-early-paint-depth-'))
+    const agentDir = join(tmpRoot, 'agent')
+    const subagentsDir = join(agentDir, '.claude', 'projects', 'p1', 'session-abc', 'subagents')
+    mkdirSync(subagentsDir, { recursive: true })
+    // Two entries stand in for two nesting levels: the registry is FLAT, so a
+    // top worker and a nested depth-2 sub-worker are both plain WorkerEntry
+    // rows and take the identical per-entry gate — this proves the mechanism
+    // is depth-generic (it operates on the generic node, not a fixed level).
+    const aPath = join(subagentsDir, 'agent-aaaa0000.jsonl')
+    const bPath = join(subagentsDir, 'agent-bbbb1111.jsonl')
+    writeFileSync(aPath, buildJSONL(subAgentUserMsg('Level 1 task')))
+    writeFileSync(bPath, buildJSONL(subAgentUserMsg('Level 2 task')))
+    const h = startWatcher(agentDir)
+    h.poll()
+    appendFileSync(aPath, buildJSONL(subAgentAssistantText('Worker A: reading the config.')))
+    appendFileSync(bPath, buildJSONL(subAgentAssistantText('Worker B: cloning the repo.')))
+    h.poll()
+    expect(narrativeCues(h.cues)).toHaveLength(0)
+
+    h.advance(PENDING_NARRATIVE_FLUSH_MS + 50)
+    h.poll()
+
+    const aCues = h.cues.filter((c) => c.agentId === 'aaaa0000' && c.progressLine == null)
+    const bCues = h.cues.filter((c) => c.agentId === 'bbbb1111' && c.progressLine == null)
+    expect(aCues.map((c) => c.latestSummary).join(' ')).toContain('reading the config')
+    expect(bCues.map((c) => c.latestSummary).join(' ')).toContain('cloning the repo')
+  })
+
+  it('does not double-print: an early-painted block is not re-shown when the first real tool lands', () => {
+    tmpRoot = mkdtempSync(join(tmpdir(), 'sr-early-paint-nodup-'))
+    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')
+    writeFileSync(jsonlPath, buildJSONL(subAgentUserMsg('Do the task')))
+    const h = startWatcher(agentDir)
+    h.poll()
+    appendFileSync(jsonlPath, buildJSONL(subAgentAssistantText('On it — pulling the logs first.')))
+    h.poll()
+    h.advance(PENDING_NARRATIVE_FLUSH_MS + 50)
+    h.poll() // early-paint fires (1 narrative cue)
+    expect(narrativeCues(h.cues)).toHaveLength(1)
+
+    // Now the worker's first real tool lands. The parked block was already
+    // consumed by the timer → it must NOT re-fire as a narrative cue, and the
+    // tool-label cue is a SEPARATE step (no stale duplicate narration).
+    appendFileSync(jsonlPath, buildJSONL(subAgentToolUse('Bash', 'b1')))
+    h.advance(10)
+    h.poll()
+
+    expect(narrativeCues(h.cues), 'narration must not be re-shown').toHaveLength(1)
+    const toolCues = h.cues.filter((c) => c.progressLine != null)
+    expect(toolCues.length, 'the tool step fires as its own cue').toBeGreaterThanOrEqual(1)
+  })
+
+  it('a tool arriving WITHIN the window resolves the block exactly once (no early-paint + resolve double)', () => {
+    tmpRoot = mkdtempSync(join(tmpdir(), 'sr-early-paint-within-'))
+    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')
+    writeFileSync(jsonlPath, buildJSONL(subAgentUserMsg('Do the task')))
+    const h = startWatcher(agentDir)
+    h.poll()
+    appendFileSync(jsonlPath, buildJSONL(subAgentAssistantText('On it — let me find the repo.')))
+    h.poll()
+    // Tool lands well within the window → resolve shows it once; timer never fires.
+    h.advance(50)
+    appendFileSync(jsonlPath, buildJSONL(subAgentToolUse('Bash', 'b1')))
+    h.poll()
+    // Advance past the window: the (already-consumed) block must not re-paint.
+    h.advance(PENDING_NARRATIVE_FLUSH_MS + 50)
+    h.poll()
+    expect(narrativeCues(h.cues), 'resolved narration shows exactly once').toHaveLength(1)
+  })
+})

package/telegram-plugin/tests/telegram-format.test.ts

@@ -235,10 +235,6 @@ describe('splitMarkdownChunks', () => {
       // chunker's normal space-boundary behaviour, orthogonal to spacers.)
       const words = (s: string): string[] =>
         s.split(/\s+/).filter((w) => w.length > 0 && w !== PARAGRAPH_SPACER)
-      // Join chunks with a space — each chunk is a separate Telegram message,
-      // so inter-chunk whitespace is irrelevant; what matters is no word is
-      // lost or fused. (A small cap may end a chunk mid-sentence at a space
-      // boundary, e.g. "...here." | "Paragraph 1...", which is normal.)
       expect(words(chunks.join(' '))).toEqual(words(paras.join(' ')))
     }
   })
@@ -251,6 +247,78 @@ describe('splitMarkdownChunks', () => {
     const rejoined = chunks.join('\n').replace(/\n+/g, '\n')
     expect(rejoined).toBe(text.replace(/\n+/g, '\n'))
   })
+
+  // -------------------------------------------------------------------------
+  // Entity-aware chunking (#finding-3): a cut must never bisect an inline
+  // span (`**bold**`, `` `code` ``, `_italic_`, `[label](href)`), which would
+  // strand an unclosed delimiter in the emitted chunk.
+  // -------------------------------------------------------------------------
+
+  test('a bold/code/link span straddling the cap is not bisected (balanced delimiters)', () => {
+    // Build a body where each inline span sits right around a small cap so the
+    // naive space/newline cut would land inside it. Every span is shorter than
+    // the smallest cap tried (the longest is the 34-char link), so a straddling
+    // span can always be kept whole — the entity-aware back-off must do so.
+    const filler = 'x'.repeat(30)
+    const body =
+      `${filler} **bold span here** ` +
+      `${filler} \`code span here\` ` +
+      `${filler} [label here](https://ex.com/a-b-c) ` +
+      `${filler} _italic span here_ ${filler}`
+    for (const cap of [40, 50, 60, 70, 80]) {
+      const chunks = splitMarkdownChunks(body, cap)
+      for (const c of chunks) {
+        // Balanced `**` and single-backtick delimiters in every chunk.
+        expect((c.match(/\*\*/g) ?? []).length % 2).toBe(0)
+        expect((c.match(/`/g) ?? []).length % 2).toBe(0)
+        // No chunk ends mid-link (an open `](` with no closing `)`), and no
+        // chunk starts with an orphan link tail.
+        const opens = (c.match(/\]\(/g) ?? []).length
+        const closesAfterOpen = (c.match(/\]\([^)\n]*\)/g) ?? []).length
+        expect(opens).toBe(closesAfterOpen)
+      }
+      // Nothing is dropped.
+      const words = (s: string): string[] => s.split(/\s+/).filter((w) => w.length > 0)
+      expect(words(chunks.join(' '))).toEqual(words(body))
+    }
+  })
+
+  test('a `***bold-italic***` / `___…___` span straddling the cap keeps SINGLE-marker balance', () => {
+    // Regression for the triple-marker case: without the `***…***` pattern, the
+    // bold pattern matches only the inner `**…**`, so a cut inside `***x***`
+    // strands the lone outer `*` (odd asterisk count → the italic is lost). A
+    // `**`-PAIR balance check misses that, so assert SINGLE-`*` / SINGLE-`_`
+    // balance in every chunk.
+    const filler = 'x'.repeat(30)
+    const body =
+      `${filler} ***bold italic here*** ` +
+      `${filler} ___under bold here___ ${filler}`
+    for (const cap of [40, 50, 60, 70]) {
+      const chunks = splitMarkdownChunks(body, cap)
+      for (const c of chunks) {
+        // SINGLE-marker balance: an even count of `*` and of `_` in every chunk
+        // (a stranded lone `*`/`_` from a bisected triple span makes it odd).
+        expect((c.match(/\*/g) ?? []).length % 2).toBe(0)
+        expect((c.match(/_/g) ?? []).length % 2).toBe(0)
+      }
+      // Each triple span survives intact in exactly one chunk.
+      const rejoined = chunks.join('\n')
+      expect(rejoined).toContain('***bold italic here***')
+      expect(rejoined).toContain('___under bold here___')
+      // Nothing dropped.
+      const words = (s: string): string[] => s.split(/\s+/).filter((w) => w.length > 0)
+      expect(words(chunks.join(' '))).toEqual(words(body))
+    }
+  })
+
+  test('a boundary with NO spacer is unaffected (legacy ^\\n+ behaviour preserved)', () => {
+    const text = Array.from({ length: 10 }, (_, i) => `plain line ${i}`).join('\n\n')
+    const chunks = splitMarkdownChunks(text, 40)
+    // No spacer was ever present, so no chunk gains/loses anything beyond the
+    // normal leading-newline strip; content is preserved.
+    const rejoined = chunks.join('\n').replace(/\n+/g, '\n')
+    expect(rejoined).toBe(text.replace(/\n+/g, '\n'))
+  })
 })
 
 // ---------------------------------------------------------------------------

package/telegram-plugin/tests/turn-record-status.test.ts

@@ -0,0 +1,119 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  computeTurnStatus,
+  backstopSendOutcome,
+  finalizeBackstopSend,
+  buildTurnRecord,
+  type DeliveryOutcome,
+} from '../gateway/turn-record-status.js'
+
+/**
+ * PR B — send-honesty. The turns.jsonl `status` must reflect the REAL send
+ * outcome, not the speculative `finalAnswerDelivered` flag the turn-flush
+ * backstop sets before its async send runs.
+ *
+ * These assert the recorded status OUTCOME for each turn shape — the exact
+ * string `emitTurnRecord` writes — not merely that a code path ran.
+ */
+
+describe('computeTurnStatus — recorded turn status reflects real outcome', () => {
+  it('genuine no-reply turn → no_reply', () => {
+    expect(computeTurnStatus({ finalAnswerDelivered: false })).toBe('no_reply')
+  })
+
+  it('synchronous reply-tool delivery (no deliveryOutcome) → complete', () => {
+    expect(computeTurnStatus({ finalAnswerDelivered: true })).toBe('complete')
+  })
+
+  it('reply-tool short-circuit suppressed the flush → complete (reply delivered)', () => {
+    expect(
+      computeTurnStatus({ finalAnswerDelivered: true, deliveryOutcome: 'suppressed' }),
+    ).toBe('complete')
+  })
+
+  it('fail-safe: undefined outcome + finalAnswerDelivered false never fabricates complete', () => {
+    expect(computeTurnStatus({ finalAnswerDelivered: false, deliveryOutcome: undefined })).toBe(
+      'no_reply',
+    )
+  })
+})
+
+describe('backstopSendOutcome — resolve outcome from what happened on the wire', () => {
+  it('throw → failed', () => {
+    expect(backstopSendOutcome({ threw: true, sentCount: 0, chunkCount: 1 })).toBe('failed')
+  })
+
+  it('partial (no throw, short delivery) → failed', () => {
+    expect(backstopSendOutcome({ threw: false, sentCount: 1, chunkCount: 2 })).toBe('failed')
+  })
+
+  it('full delivery → delivered', () => {
+    expect(backstopSendOutcome({ threw: false, sentCount: 3, chunkCount: 3 })).toBe('delivered')
+  })
+
+  it('Fix 5 — empty split (0 chunks, no throw) → failed, not delivered', () => {
+    expect(backstopSendOutcome({ threw: false, sentCount: 0, chunkCount: 0 })).toBe('failed')
+  })
+})
+
+/**
+ * Fix 3 — WIRING integration. These drive the SAME seams the gateway
+ * turn-flush IIFE runs — `finalizeBackstopSend` (the stamp) feeding
+ * `buildTurnRecord` (which `emitTurnRecord` serializes verbatim) — and assert
+ * the RECORDED status string. If the accounting stamps the wrong branch, or the
+ * record builder ever reverted to the speculative `finalAnswerDelivered`
+ * ternary, these fail — not just if the pure predicate is wrong.
+ */
+describe('turn-flush wiring → recorded turns.jsonl status', () => {
+  const ENDED_AT = 1_700_000_500_000
+  const mkTurn = () => ({
+    agent: 'test-agent',
+    startedAt: ENDED_AT - 5_000,
+    toolCallCount: 0,
+    turnId: 'turn-abc',
+    // speculatively set at gateway.ts flush site BEFORE the send runs:
+    finalAnswerDelivered: true,
+    deliveryOutcome: undefined as DeliveryOutcome | undefined,
+  })
+
+  const recordAfterSend = (send: { threw: boolean; sentCount: number; chunkCount: number }) => {
+    const turn = mkTurn()
+    finalizeBackstopSend(turn, send) // mutates turn.deliveryOutcome — as the IIFE does
+    return buildTurnRecord(turn, ENDED_AT)
+  }
+
+  it('send SUCCEEDS (all chunks delivered) → complete', () => {
+    expect(recordAfterSend({ threw: false, sentCount: 2, chunkCount: 2 }).status).toBe('complete')
+  })
+
+  it('send THROWS (simulated FLOOD_WAIT_ACTIVE) → send_failed, never complete', () => {
+    // BUG ORACLE: pre-fix, `finalAnswerDelivered=true` was written BEFORE the
+    // send ran and the record read that flag → 'complete' even though the send
+    // threw and the user got nothing. Assert the wired outcome is honest.
+    const rec = recordAfterSend({ threw: true, sentCount: 0, chunkCount: 1 })
+    expect(rec.status).toBe('send_failed')
+    expect(rec.status).not.toBe('complete')
+  })
+
+  it('PARTIAL multi-chunk (chunk 1 ok, chunk 2 throws) → send_failed', () => {
+    expect(recordAfterSend({ threw: true, sentCount: 1, chunkCount: 3 }).status).toBe('send_failed')
+  })
+
+  it('reply-tool suppressed the flush → complete (reply delivered), via the stamp', () => {
+    const turn = mkTurn()
+    turn.deliveryOutcome = 'suppressed' // the IIFE's suppressed-branch stamp
+    expect(buildTurnRecord(turn, ENDED_AT).status).toBe('complete')
+  })
+
+  it('record carries the honest tuple (tools + duration) alongside status', () => {
+    const rec = recordAfterSend({ threw: true, sentCount: 0, chunkCount: 1 })
+    expect(rec).toMatchObject({
+      status: 'send_failed',
+      tools: 0,
+      duration_ms: 5_000,
+      turn_id: 'turn-abc',
+      agent: 'test-agent',
+    })
+  })
+})

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

@@ -4,7 +4,7 @@ import {
   type BotApiForWorkerFeed,
   type WorkerActivityView,
 } from '../worker-activity-feed.js'
-import { renderCombinedWorkerFeed } from '../tool-activity-summary.js'
+import { renderCombinedWorkerFeed, combinedHistoryDepth } from '../tool-activity-summary.js'
 import { STATUS_CARD_CHAR_BUDGET } from '../status-no-truncate.js'
 import { createSendGate, isSendGateShed, type Clock } from '../send-gate.js'
 
@@ -489,4 +489,221 @@ describe('renderCombinedWorkerFeed (pure)', () => {
   it('returns null for an empty worker set', () => {
     expect(renderCombinedWorkerFeed([], { maxRows: 8 })).toBeNull()
   })
+
+  // ── Adaptive density: per-worker rolling history within a line budget ──────
+  const rowH = (i: number, history: string[]) => ({
+    description: `task number ${i}`,
+    elapsedMs: 12_000 + i * 1000,
+    toolCount: i,
+    currentStep: history[history.length - 1] ?? '',
+    historyLines: history,
+  })
+
+  // A history line rendered as a PRIOR (done) step in the single-worker idiom.
+  const struck = (s: string) => `~~_✓ ${s}_~~`
+  // A history line rendered as the NEWEST in-progress step.
+  const current = (s: string) => `**→ ${s}**`
+
+  it('with 2 workers paints each worker MULTIPLE history lines with the ✓/→ strikethrough idiom', () => {
+    const body = renderCombinedWorkerFeed(
+      [
+        rowH(1, ['a first', 'a second', 'a third']),
+        rowH(2, ['b first', 'b second', 'b third']),
+      ],
+      { maxRows: 8 },
+    )!
+    // Prior steps struck-through, newest bold — same idiom as the single card.
+    expect(body).toContain(struck('a first'))
+    expect(body).toContain(struck('a second'))
+    expect(body).toContain(current('a third'))
+    expect(body).toContain(struck('b first'))
+    expect(body).toContain(struck('b second'))
+    expect(body).toContain(current('b third'))
+    // This is the regression assertion: the OLD single-line-only render would
+    // have shown only 'a third'/'b third' as `→ _step_`, never the earlier
+    // struck lines. Prove the trail is restored.
+    expect(body).toContain('a first')
+    expect(body).toContain('b first')
+  })
+
+  it('degrades to ONE history line per worker at a large fan-out and stays within the body budget', () => {
+    const rows = Array.from({ length: 6 }, (_, i) =>
+      rowH(i, [`w${i} oldest`, `w${i} middle`, `w${i} newest`]),
+    )
+    const body = renderCombinedWorkerFeed(rows, { maxRows: 8 })!
+    // Only the newest step of each worker survives — the earlier lines are
+    // dropped by the per-worker depth clamp (floor((13-6)/6)=1).
+    for (let i = 0; i < 6; i++) {
+      expect(body).toContain(current(`w${i} newest`))
+      expect(body).not.toContain(`w${i} oldest`)
+      expect(body).not.toContain(`w${i} middle`)
+    }
+    // Total body lines (worker headers + history) stay within the budget: 6
+    // header lines + 6 history lines = 12 ≤ MAX_COMBINED_BODY_LINES (13). Count
+    // only the per-worker body lines (exclude the top count line + any spill).
+    const bodyLines = body
+      .split('\n')
+      .map((l) => l.trim())
+      .filter((l) => l.length > 0)
+    const headerAndHistory = bodyLines.filter(
+      (l) => !l.startsWith('🛠') && !l.includes('more working'),
+    )
+    expect(headerAndHistory.length).toBeLessThanOrEqual(13)
+  })
+
+  it('exposes the deterministic depth formula (2→5, 3→3, 4→2, 6→1)', () => {
+    expect(combinedHistoryDepth(2)).toBe(5)
+    expect(combinedHistoryDepth(3)).toBe(3)
+    expect(combinedHistoryDepth(4)).toBe(2)
+    expect(combinedHistoryDepth(6)).toBe(1)
+    expect(combinedHistoryDepth(8)).toBe(1)
+  })
+})
+
+/**
+ * Worker-feed ghost-leak (immortal/unpinned/buried card) — outcome tests.
+ *
+ * Root cause: the feed removed a worker's row ONLY from the gateway's
+ * `onFinish` handler. Terminal paths that never fire `onFinish` (the watcher's
+ * JSONL-vanished `onFileVanished` → `cleanupTerminalAgent`, and boot done-at-
+ * boot orphans) left the row in the feed forever — the shared card never
+ * emptied, so it never collapsed/unpinned and heartbeat-edited indefinitely
+ * while buried up-chat. The fix wires feed removal to the watcher's
+ * authoritative terminal sweep (`terminate`, driven by `onTerminalCleanup`)
+ * PLUS a backstop TTL sweep. These assert the OUTCOMES, not the code paths.
+ */
+function ghostHarness(opts: { staleWorkerTtlMs?: number; now: () => number }) {
+  const edits: { messageId: number; text: string }[] = []
+  const sends: { text: string }[] = []
+  const pins: { messageId: number | null }[] = []
+  let seq = 500
+  const bot: BotApiForWorkerFeed = {
+    sendMessage: async (_chatId, text) => {
+      sends.push({ text })
+      return { message_id: seq++ }
+    },
+    editMessageText: async (_chatId, messageId, text) => {
+      edits.push({ messageId, text })
+      return true
+    },
+  }
+  const feed = createWorkerActivityFeed({
+    bot,
+    now: opts.now,
+    minEditIntervalMs: 0,
+    heartbeatTickMs: 1000,
+    firstPaintMinMs: 0,
+    setInterval: () => 0,
+    clearInterval: () => {},
+    staleWorkerTtlMs: opts.staleWorkerTtlMs,
+    reconcilePin: ({ messageId }) => pins.push({ messageId }),
+  })
+  return { feed, edits, sends, pins }
+}
+async function drain(): Promise<void> {
+  for (let i = 0; i < 10; i++) await new Promise((r) => setImmediate(r))
+}
+
+describe('worker-feed ghost-leak — deterministic terminal removal + backstop', () => {
+  it('finish() on the LAST worker removes its row, collapses to the terminal summary, and UNPINS', async () => {
+    let t = 0
+    const { feed, sends, edits, pins } = ghostHarness({ now: () => t })
+    await feed.update('a', 'chat', view('task a', 'reading files', 0))
+    await drain()
+    expect(sends.length).toBe(1)
+    expect(feed.size).toBe(1)
+    // Painting the group pins the shared message.
+    expect(pins.at(-1)?.messageId).not.toBeNull()
+
+    t = 5000
+    await feed.finish('a', {
+      description: 'task a',
+      lastTool: null,
+      toolCount: 3,
+      latestSummary: 'all done',
+      elapsedMs: 5000,
+      state: 'done',
+    })
+    await drain()
+    // Row gone → the active set empties.
+    expect(feed.size).toBe(0)
+    // Collapsed to a terminal summary (a distinct edit landed, showing 'done').
+    expect(edits.length).toBeGreaterThan(0)
+    expect(edits.at(-1)?.text).toContain('done')
+    // And UNPINNED (group empty → reconcilePin messageId null).
+    expect(pins.at(-1)?.messageId).toBeNull()
+  })
+
+  it('terminate() (authoritative onTerminalCleanup sweep) reaps a worker whose onFinish NEVER fired — collapses + unpins', async () => {
+    let t = 0
+    const { feed, edits, pins } = ghostHarness({ now: () => t })
+    await feed.update('b', 'chat', view('task b', 'running a command', 0))
+    await drain()
+    expect(feed.size).toBe(1)
+    expect(pins.at(-1)?.messageId).not.toBeNull()
+
+    // Simulate the watcher's JSONL-vanished sweep: cleanupTerminalAgent → this,
+    // with NO onFinish ever delivered.
+    t = 3000
+    await feed.terminate('b')
+    await drain()
+    expect(feed.size).toBe(0)
+    expect(pins.at(-1)?.messageId).toBeNull()
+    // The card stopped editing: no further heartbeat edits after termination.
+    const after = edits.length
+    t = 20000
+    feed.heartbeatTick()
+    await drain()
+    expect(edits.length).toBe(after)
+  })
+
+  it('backstop TTL sweep force-reaps a leaked slot (terminal signal never delivered), then the card collapses + unpins', async () => {
+    let t = 0
+    const { feed, edits, pins } = ghostHarness({ staleWorkerTtlMs: 1000, now: () => t })
+    await feed.update('c', 'chat', view('task c', 'thinking', 0))
+    await drain()
+    expect(feed.size).toBe(1)
+
+    // No finish, no terminate — the worker is a pure leak. Advance past the TTL.
+    t = 2500
+    feed.heartbeatTick()
+    await drain()
+    expect(feed.size).toBe(0)
+    expect(pins.at(-1)?.messageId).toBeNull()
+
+    // Immortality closed: subsequent heartbeats produce no further edits.
+    const after = edits.length
+    t = 10000
+    feed.heartbeatTick()
+    await drain()
+    expect(edits.length).toBe(after)
+  })
+
+  it('a still-live worker (fresh update within the TTL) is NOT reaped by the backstop sweep', async () => {
+    let t = 0
+    const { feed } = ghostHarness({ staleWorkerTtlMs: 1000, now: () => t })
+    await feed.update('d', 'chat', view('task d', 's0', 0))
+    await drain()
+    // A fresh cue just before the sweep keeps it live.
+    t = 900
+    await feed.update('d', 'chat', view('task d', 's1', 900))
+    await drain()
+    t = 1500
+    feed.heartbeatTick()
+    await drain()
+    // Still tracked — the sweep only reaps rows silent PAST the TTL.
+    expect(feed.size).toBe(1)
+  })
+
+  it('no-op re-render is skipped (byte-identical body → no redundant edit)', async () => {
+    let t = 0
+    const { feed, edits } = ghostHarness({ now: () => t })
+    await feed.update('e', 'chat', view('task e', 'same step', 0))
+    await drain()
+    const afterPaint = edits.length // first paint is a send, not an edit
+    // Identical view (same elapsed → byte-identical rendered body): dedup skips.
+    await feed.update('e', 'chat', view('task e', 'same step', 0))
+    await drain()
+    expect(edits.length).toBe(afterPaint)
+  })
 })