switchroom 0.18.19 → 0.18.21

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

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