switchroom 0.18.19 → 0.18.20

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)
+  })
 })

package/telegram-plugin/tests/worker-feed-terminal-cleanup.test.ts

@@ -0,0 +1,254 @@
+/**
+ * Integration guard for the worker-feed ghost-leak fix (PR #3226 review,
+ * Finding 1). The unit tests in `worker-feed-coalesce.test.ts` call
+ * `feed.terminate()` DIRECTLY — they prove the feed collapses/unpins when
+ * asked, but they do NOT prove the two halves of the actual wire that was
+ * broken:
+ *
+ *   (a) the subagent-watcher FIRES `onTerminalCleanup` from its authoritative
+ *       `cleanupTerminalAgent` sweep — on BOTH the JSONL-vanished path
+ *       (`onFileVanished` → `cleanupTerminalAgent`) AND the boot done-at-boot
+ *       orphan path — the exact paths that never fire `onFinish`; and
+ *   (b) wiring that callback to `workerActivityFeed.terminate` removes the row
+ *       and collapses/unpins the shared card end-to-end.
+ *
+ * These drive the REAL `startSubagentWatcher` (with a mock fs) wired to a REAL
+ * `createWorkerActivityFeed` exactly as the gateway wires them
+ * (`onTerminalCleanup: (id) => feed.terminate(id)`). If a future refactor drops
+ * the `config.onTerminalCleanup(agentId)` call in `cleanupTerminalAgent`, the
+ * callback never fires, the feed row survives, and these go RED — the
+ * regression the divergence-based leak represented.
+ */
+import { describe, it, expect, vi } from 'vitest'
+import * as fs from 'fs'
+import { startSubagentWatcher } from '../subagent-watcher.js'
+import {
+  createWorkerActivityFeed,
+  type BotApiForWorkerFeed,
+  type WorkerActivityView,
+} from '../worker-activity-feed.js'
+
+function buildJSONL(...lines: object[]): string {
+  return lines.map((l) => JSON.stringify(l)).join('\n') + '\n'
+}
+const subAgentUserMsg = (t: string) => ({ type: 'user', message: { content: [{ type: 'text', text: t }] } })
+const subAgentTurnEnd = () => ({ type: 'system', subtype: 'turn_duration', duration_ms: 100 })
+
+function view(desc: string, step: string, elapsedMs: number): WorkerActivityView {
+  return { description: desc, lastTool: null, toolCount: 2, latestSummary: step, elapsedMs, state: 'running' }
+}
+
+/** A real feed with a fake bot + reconcilePin capture, driven off `now`. */
+function makeFeed(now: () => number) {
+  const sends: { text: string }[] = []
+  const edits: { messageId: number; text: string }[] = []
+  const pins: { messageId: number | null }[] = []
+  let seq = 700
+  const bot: BotApiForWorkerFeed = {
+    sendMessage: async (_c, text) => {
+      sends.push({ text })
+      return { message_id: seq++ }
+    },
+    editMessageText: async (_c, messageId, text) => {
+      edits.push({ messageId, text })
+      return true
+    },
+  }
+  const feed = createWorkerActivityFeed({
+    bot,
+    now,
+    minEditIntervalMs: 0,
+    heartbeatTickMs: 1000,
+    firstPaintMinMs: 0,
+    setInterval: () => 0,
+    clearInterval: () => {},
+    reconcilePin: ({ messageId }) => pins.push({ messageId }),
+  })
+  return { feed, sends, edits, pins }
+}
+async function drain(): Promise<void> {
+  for (let i = 0; i < 12; i++) await new Promise((r) => setImmediate(r))
+}
+
+/**
+ * A mock fs over a single subagents dir with one worker JSONL. `vanished`
+ * flips the file-read calls to throw ENOENT (Claude Code reaped the parent
+ * session's `subagents/` dir) to exercise the vanished terminal path.
+ */
+function mockWatcherFs(opts: {
+  agentDir: string
+  fileName: string
+  content: Buffer
+  vanished: () => boolean
+}) {
+  const projectsRoot = `${opts.agentDir}/.claude/projects`
+  const projectDir = `${projectsRoot}/mock-cwd`
+  const sessionDir = `${projectDir}/sess`
+  const subagentsDir = `${sessionDir}/subagents`
+  const filePath = `${subagentsDir}/${opts.fileName}`
+  let lastOpened: string | null = null
+  const enoent = (): never => {
+    const e = new Error('ENOENT') as NodeJS.ErrnoException
+    e.code = 'ENOENT'
+    throw e
+  }
+  const mock = {
+    existsSync: ((p: fs.PathLike) => {
+      const ps = String(p)
+      if (ps === projectsRoot || ps === projectDir || ps === sessionDir || ps === subagentsDir) return true
+      return ps === filePath && !opts.vanished()
+    }) 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 opts.vanished() ? [] : [opts.fileName]
+      return []
+    }) as unknown as typeof fs.readdirSync,
+    statSync: ((p: fs.PathLike) => {
+      if (opts.vanished()) return enoent()
+      return { size: opts.content.length, mtimeMs: 0 } as fs.Stats
+    }) as typeof fs.statSync,
+    openSync: ((p: fs.PathLike) => {
+      if (opts.vanished()) return enoent()
+      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 (opts.vanished() || lastOpened == null) return 0
+      const src = opts.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,
+  }
+  return { mock, filePath }
+}
+
+/** Deterministic clock + injectable timers shared by watcher + feed. */
+function makeClock() {
+  let currentTime = 1_000_000
+  const intervals: Array<{ fn: () => void; ms: number; fireAt: number }> = []
+  const timeouts: Array<{ fn: () => void; fireAt: number; ref: number }> = []
+  let nextRef = 1
+  const now = () => currentTime
+  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 timers = {
+    setInterval: (fn: () => void, ms: number) => {
+      intervals.push({ fn, ms, fireAt: currentTime + ms })
+      return { ref: 0 }
+    },
+    clearInterval: () => {},
+    setTimeout: (fn: () => void, ms: number) => {
+      const ref = nextRef++
+      timeouts.push({ fn, fireAt: currentTime + ms, ref })
+      return { ref }
+    },
+    clearTimeout: (handle: { ref: number }) => {
+      const idx = timeouts.findIndex((t) => t.ref === handle.ref)
+      if (idx !== -1) timeouts.splice(idx, 1)
+    },
+  }
+  return { now, advance, timers }
+}
+
+describe('worker-feed ghost-leak — watcher terminal sweep → feed removal (integration)', () => {
+  it('boot done-at-boot orphan: cleanupTerminalAgent fires onTerminalCleanup → feed row removed, card collapsed + unpinned', async () => {
+    const agentDir = '/home/user/.switchroom/agents/x'
+    const { now, advance, timers } = makeClock()
+    const { feed, pins } = makeFeed(now)
+
+    // The worker was live in the feed (its progress had surfaced there).
+    await feed.update('boot1', 'chat', view('task boot1', 'reading', 0))
+    await drain()
+    expect(feed.size).toBe(1)
+    expect(pins.at(-1)?.messageId).not.toBeNull() // pinned
+
+    const { mock } = mockWatcherFs({
+      agentDir,
+      fileName: 'agent-boot1.jsonl',
+      // Already `done` at boot (turn_end present) → registerAgent schedules a
+      // terminal cleanup with NO onFinish (the boot-orphan bypass path).
+      content: Buffer.from(buildJSONL(subAgentUserMsg('done task'), subAgentTurnEnd()), 'utf-8'),
+      vanished: () => false,
+    })
+    const watcher = startSubagentWatcher({
+      agentDir,
+      fs: mock,
+      now,
+      // Wire EXACTLY as the gateway does.
+      onTerminalCleanup: (agentId) => { void feed.terminate(agentId) },
+      ...timers,
+    })
+    expect(watcher.getRegistry().has('boot1')).toBe(true)
+
+    // Fire the scheduled terminal cleanup (30s grace) → onTerminalCleanup.
+    advance(30_000)
+    await drain()
+
+    expect(feed.size).toBe(0)                        // row removed by the sweep
+    expect(pins.at(-1)?.messageId).toBeNull()        // card collapsed + UNPINNED
+    watcher.stop()
+  })
+
+  it('JSONL-vanished path: onFileVanished → cleanupTerminalAgent → onTerminalCleanup → feed row removed + unpinned', async () => {
+    const agentDir = '/home/user/.switchroom/agents/y'
+    const { now, advance, timers } = makeClock()
+    const { feed, pins } = makeFeed(now)
+
+    await feed.update('van1', 'chat', view('task van1', 'running a command', 0))
+    await drain()
+    expect(feed.size).toBe(1)
+
+    let vanished = false
+    const { mock } = mockWatcherFs({
+      agentDir,
+      fileName: 'agent-van1.jsonl',
+      // Running at boot (no turn_end) — stays registered; the poll loop reads
+      // it defensively, so when the file vanishes the read throws ENOENT and
+      // the watcher takes onFileVanished → cleanupTerminalAgent.
+      content: Buffer.from(buildJSONL(subAgentUserMsg('long task')), 'utf-8'),
+      vanished: () => vanished,
+    })
+    const captured: string[] = []
+    const watcher = startSubagentWatcher({
+      agentDir,
+      fs: mock,
+      now,
+      onTerminalCleanup: (agentId) => {
+        captured.push(agentId)
+        void feed.terminate(agentId)
+      },
+      ...timers,
+    })
+    expect(watcher.getRegistry().has('van1')).toBe(true)
+
+    // The parent session ends → Claude Code reaps subagents/ → next poll read
+    // hits ENOENT.
+    vanished = true
+    advance(2_000) // drive the rescan/poll interval
+    await drain()
+
+    expect(captured).toContain('van1')               // vanished path funnels here
+    expect(feed.size).toBe(0)                         // wired removal happened
+    expect(pins.at(-1)?.messageId).toBeNull()         // unpinned
+    watcher.stop()
+  })
+})

package/telegram-plugin/tests/worker-feed-terminal-state-truthful.test.ts

@@ -0,0 +1,125 @@
+/**
+ * Residual B regression: a worker cleaned up by the TTL / authoritative
+ * `terminate` sweep — i.e. reaped / vanished / crashed WITHOUT ever delivering
+ * a clean `onFinish` result — must render a TRUTHFUL terminal state, NOT "done".
+ *
+ * `terminateWorker` synthesises the recap when NO clean finish arrived (a clean
+ * `onFinish` removes the row first, making `terminate` a no-op; an errored
+ * worker goes through `onFinish(outcome:'failed')`). So a row still present at
+ * terminate time genuinely ended without a result → it must render as the
+ * `incomplete` terminal ("incomplete · …"), never "done".
+ *
+ * OUTCOME assertions on the finalized card body (RED if `terminate` reverts to
+ * `state:'done'`), applied to the generic worker row so the guarantee holds at
+ * every nesting level (the feed keys rows by agentId, depth-agnostic):
+ *   - a solo reaped worker's terminal card reads `incomplete`, never `done`;
+ *   - a genuinely-`finish`ed worker still reads `done` with its result.
+ */
+import { describe, it, expect } from 'vitest'
+import {
+  createWorkerActivityFeed,
+  renderWorkerActivity,
+  type BotApiForWorkerFeed,
+  type WorkerActivityView,
+} from '../worker-activity-feed.js'
+
+function makeFeed(now: () => number) {
+  const sends: { text: string }[] = []
+  const edits: { messageId: number; text: string }[] = []
+  let seq = 900
+  const bot: BotApiForWorkerFeed = {
+    sendMessage: async (_c, text) => { sends.push({ text }); return { message_id: seq++ } },
+    editMessageText: async (_c, messageId, text) => { edits.push({ messageId, text }); return true },
+  }
+  const feed = createWorkerActivityFeed({
+    bot,
+    now,
+    minEditIntervalMs: 0,
+    firstPaintMinMs: 0,
+    setInterval: () => 0,
+    clearInterval: () => {},
+  })
+  return { feed, sends, edits }
+}
+const runningView = (desc: string, step: string, elapsedMs: number): WorkerActivityView => ({
+  description: desc, lastTool: null, toolCount: 3, latestSummary: step, elapsedMs, state: 'running',
+})
+async function drain(): Promise<void> {
+  for (let i = 0; i < 12; i++) await new Promise((r) => setImmediate(r))
+}
+
+describe('worker terminal state is truthful for reaped workers (Residual B)', () => {
+  it('a reaped/vanished worker (terminate, no clean finish) renders `incomplete`, never `done`', async () => {
+    let clock = 1000
+    const { feed, edits } = makeFeed(() => clock)
+    clock = 1000
+    await feed.update('w', 'chat', runningView('background job', 'doing work', 1000))
+    await drain()
+    clock = 5000
+    // Authoritative sweep / TTL backstop: no onFinish ever arrived.
+    await feed.terminate('w')
+    await drain()
+
+    const last = edits[edits.length - 1].text
+    expect(last, 'reaped worker must NOT read as done').not.toMatch(/\bdone\b/)
+    expect(last, 'reaped worker reads the truthful incomplete terminal').toContain('incomplete')
+    expect(feed.size).toBe(0)
+  })
+
+  it('a genuinely finished worker still renders `done` with its result', async () => {
+    let clock = 1000
+    const { feed, edits } = makeFeed(() => clock)
+    await feed.update('w', 'chat', runningView('background job', 'doing work', 1000))
+    await drain()
+    clock = 2000
+    await feed.finish('w', {
+      description: 'background job',
+      lastTool: null,
+      toolCount: 5,
+      latestSummary: 'the delivered result paragraph',
+      elapsedMs: 2000,
+      state: 'done',
+    })
+    await drain()
+    const last = edits[edits.length - 1].text
+    expect(last).toContain('done')
+    expect(last).toContain('the delivered result paragraph')
+    expect(last).not.toContain('incomplete')
+  })
+
+  it('renderWorkerActivity renders the `incomplete` state as a finished card without a fabricated result', () => {
+    const card = renderWorkerActivity({
+      description: 'background job',
+      lastTool: null,
+      toolCount: 3,
+      latestSummary: '', // reaped: no result text
+      elapsedMs: 4000,
+      state: 'incomplete',
+    })
+    expect(card).toContain('incomplete')
+    expect(card).not.toMatch(/\bdone\b/)
+    // No fabricated result paragraph (latestSummary empty) → no ✅ result block.
+    expect(card).not.toContain('✅')
+  })
+
+  it('renderWorkerActivity NEVER renders a result/⚠️ block for `incomplete`, even with a non-empty latestSummary (deterministic guard, not caller-discipline)', () => {
+    // Latent-trap regression guard: the live call site (terminateWorker) always
+    // passes latestSummary:'' for a reaped worker, but a future/direct caller
+    // could pass stray text. The truthful-no-result invariant must be enforced
+    // in the renderer — an `incomplete` worker produced no result, so it must
+    // never fabricate a ⚠️-prefixed result paragraph regardless of the summary.
+    const card = renderWorkerActivity({
+      description: 'background job',
+      lastTool: null,
+      toolCount: 3,
+      latestSummary: 'this looks like a real result but the worker never finished',
+      elapsedMs: 4000,
+      state: 'incomplete',
+    })
+    expect(card).toContain('incomplete')
+    // The renderer maps a non-`done` finished result to the ⚠️ emoji; the guard
+    // must suppress that block entirely for `incomplete`.
+    expect(card).not.toContain('⚠️')
+    expect(card).not.toContain('this looks like a real result')
+  })
+})