switchroom 0.18.8 → 0.18.10

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

@@ -0,0 +1,398 @@
+/**
+ * Tests for SubagentWatcher card resurrection (issue #3023).
+ *
+ * PR #3019 makes false terminal synthesis far less likely (in-flight tool
+ * gate + 45min cap), but can't eliminate it. This suite locks the second
+ * half of the operator invariant — "active work must always be visible":
+ *
+ *  (a) When a worker's card is FALSELY finalised (silent-stall synthesis
+ *      fires) and its JSONL later resumes growing, the watcher resurrects it
+ *      exactly once — fires `onResurrect`, re-registers it LIVE, emits a
+ *      resurrection log line. A further growth tick does NOT re-fire.
+ *  (b) A worker resurrected once and then falsely finalised AGAIN is
+ *      named-as-lost (`onWorkerLost`), NOT resurrected a second time — the
+ *      resurrection chain is bounded.
+ *  (c) A genuine boot-time historical rediscovery of an old completed worker
+ *      stays historical/suppressed — it never records a false finish, so it
+ *      can never be resurrected even if its file were to grow.
+ */
+
+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: 1234 }
+}
+
+interface Harness {
+  resurrectCalls: Array<{ agentId: string; description: string }>
+  lostCalls: Array<{ agentId: string; description: string }>
+  stallTerminalCalls: Array<{ agentId: string }>
+  finishCalls: Array<{ agentId: string; outcome: string }>
+  logs: string[]
+  advance: (ms: number) => void
+  watcher: ReturnType<typeof startSubagentWatcher>
+  fileContents: Map<string, Buffer>
+  jsonlPath: string
+  appendActivity: () => void
+  appendTurnEnd: () => void
+  presentAtBoot: (content: string) => void
+}
+
+function makeHarness(opts: {
+  agentId?: string
+  stallThresholdMs?: number
+  silentStallTerminalMs?: number
+  rescanMs?: number
+  bootContent?: string
+} = {}): Harness {
+  const {
+    agentId = 'resurrect-agent',
+    stallThresholdMs = 60_000,
+    silentStallTerminalMs = 300_000,
+    rescanMs = 500,
+    bootContent,
+  } = opts
+
+  let currentTime = 1000
+  const resurrectCalls: Array<{ agentId: string; description: string }> = []
+  const lostCalls: Array<{ agentId: string; description: string }> = []
+  const stallTerminalCalls: Array<{ agentId: string }> = []
+  const finishCalls: Array<{ agentId: string; outcome: string }> = []
+  const logs: string[] = []
+
+  const agentDir = '/home/user/.switchroom/agents/myagent'
+  const sessionId = 'mock-session'
+  const projectsRoot = `${agentDir}/.claude/projects`
+  const projectDir = `${projectsRoot}/mock-cwd`
+  const sessionDir = `${projectDir}/${sessionId}`
+  const subagentsDir = `${sessionDir}/subagents`
+  const jsonlPath = `${subagentsDir}/agent-${agentId}.jsonl`
+
+  const fileContents = new Map<string, Buffer>()
+  fileContents.set(
+    jsonlPath,
+    Buffer.from(bootContent ?? buildJSONL(subAgentUserMsg('bg task')), 'utf-8'),
+  )
+
+  let lastOpenedPath: string | null = null
+  const mockFs = {
+    existsSync: ((p: fs.PathLike) => {
+      const ps = String(p)
+      if (ps === projectsRoot || ps === projectDir || ps === sessionDir || ps === subagentsDir) return true
+      if (fileContents.has(ps)) return true
+      return false
+    }) as typeof fs.existsSync,
+    readdirSync: ((p: fs.PathLike) => {
+      const ps = String(p)
+      if (ps === projectsRoot) return ['mock-cwd']
+      if (ps === projectDir) return [sessionId]
+      if (ps === sessionDir) return ['subagents']
+      if (ps === subagentsDir) return [`agent-${agentId}.jsonl`]
+      return []
+    }) as unknown as typeof fs.readdirSync,
+    statSync: ((p: fs.PathLike) =>
+      ({ size: fileContents.get(String(p))?.length ?? 0, mtimeMs: currentTime }) as fs.Stats) as typeof fs.statSync,
+    openSync: ((p: fs.PathLike) => {
+      lastOpenedPath = String(p)
+      return 42
+    }) as unknown as typeof fs.openSync,
+    closeSync: (() => { lastOpenedPath = null }) as typeof fs.closeSync,
+    readSync: ((
+      _fd: number,
+      buf: NodeJS.ArrayBufferView,
+      offset: number,
+      length: number,
+      position: number | null,
+    ): number => {
+      const content = lastOpenedPath != null ? fileContents.get(lastOpenedPath) : undefined
+      if (!content) return 0
+      const pos = position ?? 0
+      const src = content.slice(pos, pos + length)
+      ;(src as Buffer).copy(buf as Buffer, offset)
+      return src.length
+    }) as unknown as typeof fs.readSync,
+    watch: (() => ({ close: vi.fn() }) as unknown as fs.FSWatcher) as unknown as typeof fs.watch,
+  }
+
+  const intervals: Array<{ fn: () => void; ms: number; ref: number; fireAt: number }> = []
+  const timeouts: Array<{ fn: () => void; ref: number; fireAt: number }> = []
+  let nextRef = 1
+
+  const watcher = startSubagentWatcher({
+    agentDir,
+    stallThresholdMs,
+    silentSynthesisStallThresholdMs: stallThresholdMs,
+    silentStallTerminalMs,
+    rescanMs,
+    onStallTerminal: (id) => stallTerminalCalls.push({ agentId: id }),
+    onResurrect: (id, desc) => resurrectCalls.push({ agentId: id, description: desc }),
+    onWorkerLost: (id, desc) => lostCalls.push({ agentId: id, description: desc }),
+    onFinish: ({ agentId: id, outcome }) => finishCalls.push({ agentId: id, outcome }),
+    now: () => currentTime,
+    setInterval: (fn, ms) => {
+      const ref = nextRef++
+      intervals.push({ fn, ms, ref, fireAt: currentTime + ms })
+      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: (fn, ms) => {
+      const ref = nextRef++
+      timeouts.push({ fn, ref, fireAt: currentTime + ms })
+      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)
+    },
+    fs: mockFs,
+    log: (msg) => logs.push(msg),
+  })
+
+  const advance = (ms: number): void => {
+    currentTime += ms
+    for (;;) {
+      intervals.sort((a, b) => a.fireAt - b.fireAt)
+      timeouts.sort((a, b) => a.fireAt - b.fireAt)
+      const nextI = intervals[0]
+      const nextT = timeouts[0]
+      const iReady = nextI && nextI.fireAt <= currentTime
+      const tReady = nextT && nextT.fireAt <= currentTime
+      if (!iReady && !tReady) break
+      if (tReady && (!iReady || nextT!.fireAt <= nextI!.fireAt)) {
+        timeouts.shift()
+        nextT!.fn()
+      } else {
+        nextI!.fireAt += nextI!.ms
+        nextI!.fn()
+      }
+    }
+  }
+
+  const appendActivity = (): void => {
+    const cur = fileContents.get(jsonlPath) ?? Buffer.alloc(0)
+    const more = buildJSONL({
+      type: 'assistant',
+      message: { content: [{ type: 'text', text: 'still working' }] },
+    })
+    fileContents.set(jsonlPath, Buffer.concat([cur, Buffer.from(more, 'utf-8')]))
+  }
+
+  const appendTurnEnd = (): void => {
+    const cur = fileContents.get(jsonlPath) ?? Buffer.alloc(0)
+    const more = buildJSONL(subAgentTurnEnd())
+    fileContents.set(jsonlPath, Buffer.concat([cur, Buffer.from(more, 'utf-8')]))
+  }
+
+  const presentAtBoot = (content: string): void => {
+    fileContents.set(jsonlPath, Buffer.from(content, 'utf-8'))
+  }
+
+  return {
+    resurrectCalls,
+    lostCalls,
+    stallTerminalCalls,
+    finishCalls,
+    logs,
+    advance,
+    watcher,
+    fileContents,
+    jsonlPath,
+    appendActivity,
+    appendTurnEnd,
+    presentAtBoot,
+  }
+}
+
+function unmarkHistorical(harness: Harness, agentId: string): void {
+  const entry = harness.watcher.getRegistry().get(agentId)
+  if (entry) entry.historical = false
+}
+
+/** Drive a running worker through stall → silent-stall terminal synthesis. */
+function driveToFalseFinish(h: Harness, agentId: string): void {
+  h.advance(62_000) // stall notification fires
+  h.advance(302_000) // past silentStallTerminalMs — synthesis fires
+}
+
+describe('subagent-watcher card resurrection (issue #3023)', () => {
+  it('(a) resurrects a falsely-finalised worker exactly once when its JSONL resumes', () => {
+    const agentId = 'resurrect-once'
+    const h = makeHarness({ agentId })
+
+    h.advance(500) // register
+    unmarkHistorical(h, agentId)
+
+    driveToFalseFinish(h, agentId)
+    expect(h.stallTerminalCalls).toHaveLength(1)
+    expect(h.finishCalls).toHaveLength(1)
+    expect(h.resurrectCalls).toHaveLength(0)
+
+    // The worker was NOT actually dead — its JSONL resumes growing.
+    h.appendActivity()
+    h.advance(500) // poll → checkResurrections detects the growth
+
+    expect(h.resurrectCalls).toHaveLength(1)
+    expect(h.resurrectCalls[0].agentId).toBe(agentId)
+    expect(h.lostCalls).toHaveLength(0)
+    expect(h.logs.some((l) => l.includes('RESURRECTING worker') && l.includes(agentId))).toBe(true)
+
+    // The revived entry is LIVE again (running, non-historical).
+    const entry = h.watcher.getRegistry().get(agentId)
+    expect(entry).toBeDefined()
+    expect(entry!.state).toBe('running')
+    expect(entry!.historical).toBe(false)
+
+    // A further growth tick for the SAME false finish does NOT re-resurrect.
+    h.appendActivity()
+    h.advance(500)
+    expect(h.resurrectCalls).toHaveLength(1)
+  })
+
+  it('(b) names a twice-falsely-finalised worker LOST instead of resurrecting again', () => {
+    const agentId = 'resurrect-bound'
+    const h = makeHarness({ agentId })
+
+    h.advance(500)
+    unmarkHistorical(h, agentId)
+
+    // First false finish + resurrection.
+    driveToFalseFinish(h, agentId)
+    h.appendActivity()
+    h.advance(500) // poll → checkResurrections resurrects the entry
+    h.advance(500) // poll → the revived entry reads its resumed JSONL (settles)
+    expect(h.resurrectCalls).toHaveLength(1)
+    expect(h.lostCalls).toHaveLength(0)
+
+    // The revived worker goes silent AGAIN and is falsely finalised a second
+    // time (no fresh activity → stall → synthesis).
+    driveToFalseFinish(h, agentId)
+    expect(h.stallTerminalCalls.length).toBeGreaterThanOrEqual(2)
+
+    // Its JSONL resumes once more — but the chain bound is spent.
+    h.appendActivity()
+    h.advance(500)
+
+    expect(h.resurrectCalls).toHaveLength(1) // NOT resurrected a second time
+    expect(h.lostCalls).toHaveLength(1)
+    expect(h.lostCalls[0].agentId).toBe(agentId)
+    expect(h.logs.some((l) => l.includes('NAMED AS LOST') && l.includes(agentId))).toBe(true)
+
+    // Further growth stays lost — no more resurrections, no more lost fires.
+    h.appendActivity()
+    h.advance(500)
+    expect(h.resurrectCalls).toHaveLength(1)
+    expect(h.lostCalls).toHaveLength(1)
+  })
+
+  it('(c) a genuine boot-time historical completed worker is never resurrected', () => {
+    const agentId = 'old-completed'
+    // Present at boot, already finished (turn_end in the file). This is the
+    // "old completed worker rediscovered at boot" population — it must stay
+    // historical/suppressed and never enter the resurrection path.
+    const h = makeHarness({
+      agentId,
+      bootContent: buildJSONL(subAgentUserMsg('done long ago'), subAgentTurnEnd()),
+    })
+
+    h.advance(500) // boot scan already ran at construction; register historical
+
+    const entry = h.watcher.getRegistry().get(agentId)
+    // Historical done-at-boot entries are short-circuited (completionNotified).
+    if (entry) expect(entry.historical).toBe(true)
+
+    // Even if the file grows post-boot, there is no false-finish record for it,
+    // so it can never be resurrected.
+    h.appendActivity()
+    h.advance(500)
+    h.advance(500)
+
+    expect(h.resurrectCalls).toHaveLength(0)
+    expect(h.lostCalls).toHaveLength(0)
+    expect(h.stallTerminalCalls).toHaveLength(0)
+  })
+
+  it('(d) late trailing turn_end flush → bounded resurrect→immediate-refinish flicker (N1)', () => {
+    // Accepted false positive: the silent-stall synthesis fires, then Claude
+    // Code finally flushes the worker's REAL buffered `turn_end` line. The
+    // byte growth trips resurrection (we can't distinguish it from live
+    // resumption without fragile tail parsing), the revived entry immediately
+    // reads the terminal line and re-finishes, and the chain stays bounded —
+    // no loop, no further resurrections.
+    const agentId = 'late-flush'
+    const h = makeHarness({ agentId })
+
+    h.advance(500)
+    unmarkHistorical(h, agentId)
+
+    driveToFalseFinish(h, agentId)
+    expect(h.finishCalls).toHaveLength(1) // the synthesized false finish
+
+    // The worker was genuinely done — its buffered turn_end flushes late.
+    h.appendTurnEnd()
+    h.advance(500) // poll → growth trips the (false-positive) resurrection
+
+    expect(h.resurrectCalls).toHaveLength(1) // budget burned, by design
+    h.advance(500) // revived entry reads the terminal line → immediate re-finish
+
+    expect(h.finishCalls).toHaveLength(2) // corrected real finish delivered
+    expect(h.finishCalls[1].agentId).toBe(agentId)
+    const entry = h.watcher.getRegistry().get(agentId)
+    expect(entry?.state).toBe('done')
+
+    // Chain stays bounded: nothing further fires without new growth, and a
+    // genuine turn_end never records a new false finish, so no loop.
+    h.advance(500)
+    h.advance(500)
+    expect(h.resurrectCalls).toHaveLength(1)
+    expect(h.finishCalls).toHaveLength(2)
+    expect(h.lostCalls).toHaveLength(0)
+  })
+
+  it('(e) a resurrected worker\'s genuine turn_end re-fires onFinish — corrected result supersedes the false one (N2)', () => {
+    // Intent (documented at the completionNotified reset in resurrectAgent):
+    // the false synthesized finish already delivered a possibly-wrong handback;
+    // when the resurrected worker later REALLY completes, onFinish MUST fire a
+    // second time so the corrected real result reaches the parent. The gateway
+    // spool dedups only concurrently-live handback envelopes, so this second
+    // delivery lands as a fresh turn.
+    const agentId = 'refire-finish'
+    const h = makeHarness({ agentId })
+
+    h.advance(500)
+    unmarkHistorical(h, agentId)
+
+    driveToFalseFinish(h, agentId)
+    expect(h.finishCalls).toHaveLength(1) // synthesized (false) finish
+
+    // Worker was alive: real activity resumes → resurrection.
+    h.appendActivity()
+    h.advance(500)
+    expect(h.resurrectCalls).toHaveLength(1)
+    h.advance(500) // revived entry settles reading the resumed JSONL
+
+    // Now the worker GENUINELY completes.
+    h.appendTurnEnd()
+    h.advance(500)
+
+    expect(h.finishCalls).toHaveLength(2) // real finish fired again — intended
+    expect(h.finishCalls[1].agentId).toBe(agentId)
+    expect(h.finishCalls[1].outcome).toBe('completed')
+    // A genuine turn_end never records a false finish → no further resurrection.
+    h.appendActivity()
+    h.advance(500)
+    expect(h.resurrectCalls).toHaveLength(1)
+  })
+})

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

@@ -31,6 +31,25 @@ function subAgentUserMsg(promptText: string) {
 function subAgentTurnEnd() {
   return { type: 'system', subtype: 'turn_duration', duration_ms: 1234 }
 }
+// An assistant message that STARTS a tool call (e.g. a long-running Bash
+// loop). A tool-using turn's stop_reason is 'tool_use', never 'end_turn',
+// so this does NOT terminalise the worker.
+function subAgentToolUse(toolUseId: string, name = 'Bash') {
+  return {
+    type: 'assistant',
+    message: {
+      stop_reason: 'tool_use',
+      content: [{ type: 'tool_use', id: toolUseId, name, input: { command: 'sleep 600' } }],
+    },
+  }
+}
+// A user message carrying the matching tool_result — the tool call is done.
+function subAgentToolResult(toolUseId: string) {
+  return {
+    type: 'user',
+    message: { content: [{ type: 'tool_result', tool_use_id: toolUseId, content: 'ok' }] },
+  }
+}
 
 interface Harness {
   stallCalls: Array<{ agentId: string; idleMs: number }>
@@ -43,18 +62,21 @@ interface Harness {
   fileContents: Map<string, Buffer>
   jsonlPath: string
   appendActivity: () => void
+  appendLines: (...lines: object[]) => void
 }
 
 function makeHarness(opts: {
   agentId?: string
   stallThresholdMs?: number
   silentStallTerminalMs?: number
+  inflightTerminalCapMs?: number
   rescanMs?: number
 } = {}): Harness {
   const {
     agentId = 'bug6-agent',
     stallThresholdMs = 60_000,
     silentStallTerminalMs = 300_000,
+    inflightTerminalCapMs,
     rescanMs = 500,
   } = opts
 
@@ -126,6 +148,7 @@ function makeHarness(opts: {
     stallThresholdMs,
     silentSynthesisStallThresholdMs: stallThresholdMs,
     silentStallTerminalMs,
+    inflightTerminalCapMs,
     rescanMs,
     onStall: (id, idleMs) => stallCalls.push({ agentId: id, idleMs }),
     onUnstall: (id) => unstallCalls.push({ agentId: id }),
@@ -168,6 +191,12 @@ function makeHarness(opts: {
     fileContents.set(jsonlPath, Buffer.concat([cur, Buffer.from(more, 'utf-8')]))
   }
 
+  const appendLines = (...lines: object[]): void => {
+    const cur = fileContents.get(jsonlPath) ?? Buffer.alloc(0)
+    const more = buildJSONL(...lines)
+    fileContents.set(jsonlPath, Buffer.concat([cur, Buffer.from(more, 'utf-8')]))
+  }
+
   return {
     stallCalls,
     stallTerminalCalls,
@@ -179,6 +208,7 @@ function makeHarness(opts: {
     fileContents,
     jsonlPath,
     appendActivity,
+    appendLines,
   }
 }
 
@@ -313,3 +343,145 @@ describe('subagent-watcher post-stall terminal synthesis (RFC §Bug 6)', () => {
     expect(h.finishCalls).toHaveLength(1) // unchanged
   })
 })
+
+describe('subagent-watcher in-flight tool-call gate (incident 2026-07-10)', () => {
+  it('does NOT synthesise terminal while a tool call is still in flight, even past silentStallTerminalMs', () => {
+    const agentId = 'inflight-no-synth'
+    const h = makeHarness({
+      agentId,
+      stallThresholdMs: 60_000,
+      silentStallTerminalMs: 300_000,
+      rescanMs: 500,
+    })
+
+    h.advance(500) // register
+    unmarkHistorical(h, agentId)
+
+    // Worker starts a long-running Bash tool call (a frame-capture loop).
+    // The transcript ends in a tool_use with NO matching tool_result — the
+    // JSONL then goes silent for the entire duration of the tool call.
+    h.appendLines(subAgentToolUse('toolu_longbash'))
+    h.advance(1_000) // poll reads the tool_use → in-flight set has 1 id
+
+    // Idle far past the stall threshold: the stall badge still fires (the
+    // worker IS quiet), but the entry is inside a legal long tool call.
+    h.advance(62_000)
+    expect(h.stallCalls).toHaveLength(1)
+
+    // Idle well past silentStallTerminalMs — with the OLD code this would
+    // finalise the live worker's card. The in-flight gate must suppress it.
+    h.advance(400_000)
+    expect(h.stallTerminalCalls).toHaveLength(0)
+    expect(h.finishCalls).toHaveLength(0)
+    expect(h.logs.some((l) => l.includes('terminal synthesis deferred'))).toBe(true)
+  })
+
+  it('synthesises terminal once the tool_result lands and idle persists', () => {
+    const agentId = 'inflight-then-synth'
+    const h = makeHarness({
+      agentId,
+      stallThresholdMs: 60_000,
+      silentStallTerminalMs: 300_000,
+      rescanMs: 500,
+    })
+
+    h.advance(500)
+    unmarkHistorical(h, agentId)
+
+    // In-flight tool call, then a long silent window — no synthesis.
+    h.appendLines(subAgentToolUse('toolu_longbash'))
+    h.advance(1_000)
+    h.advance(62_000) // stall fires
+    h.advance(400_000) // gated — no synthesis
+    expect(h.stallTerminalCalls).toHaveLength(0)
+
+    // The tool call finally completes: the matching tool_result lands.
+    // This is JSONL growth, so the un-stall path fires and the in-flight
+    // set drains — the gate re-opens.
+    h.appendLines(subAgentToolResult('toolu_longbash'))
+    h.advance(1_000)
+    expect(h.unstallCalls).toHaveLength(1)
+    expect(h.stallTerminalCalls).toHaveLength(0)
+
+    // Now the worker goes genuinely silent with nothing in flight: re-stall,
+    // then cross the terminal window — synthesis fires exactly as designed.
+    h.advance(62_000) // re-stall
+    h.advance(302_000) // past silentStallTerminalMs from the new stall
+    expect(h.stallTerminalCalls).toHaveLength(1)
+    expect(h.stallTerminalCalls[0].agentId).toBe(agentId)
+    expect(h.finishCalls).toHaveLength(1)
+    expect(h.finishCalls[0].outcome).toBe('completed')
+  })
+
+  it('releases terminal synthesis at inflightTerminalCapMs even with the tool call still unresolved (died-mid-tool)', () => {
+    // A worker killed mid-tool never writes the tool_result: without the
+    // cap it would defer forever AND the reaper's isLive cross-check would
+    // shield its DB row — wedged for the life of the gateway. The cap is
+    // the reconciliation with the #2777/#2782 completion-gate contract.
+    const agentId = 'inflight-cap-release'
+    const h = makeHarness({
+      agentId,
+      stallThresholdMs: 60_000,
+      silentStallTerminalMs: 300_000,
+      inflightTerminalCapMs: 600_000, // compressed 10-min cap
+      rescanMs: 500,
+    })
+
+    h.advance(500)
+    unmarkHistorical(h, agentId)
+    h.appendLines(subAgentToolUse('toolu_killed_midtool'))
+    h.advance(1_000) // in-flight set has 1 id
+    h.advance(62_000) // stall fires
+    expect(h.stallCalls).toHaveLength(1)
+
+    // Past silentStallTerminalMs but under the cap → deferred.
+    h.advance(400_000) // ~463s total idle < 600s cap
+    expect(h.stallTerminalCalls).toHaveLength(0)
+
+    // Cross the cap with the tool_result still missing → released.
+    h.advance(150_000) // ~613s total idle >= 600s cap
+    expect(h.stallTerminalCalls).toHaveLength(1)
+    expect(h.finishCalls).toHaveLength(1)
+    expect(h.logs.some((l) => l.includes('in-flight deferral cap reached'))).toBe(true)
+  })
+
+  it('gates on a nested Agent/Task dispatch the same as a plain tool call', () => {
+    // A FOREGROUND nested Agent/Task dispatch blocks this worker with the
+    // same frozen-JSONL shape as a long Bash — its tool_use routes to
+    // sub_agent_nested_spawn (not sub_agent_tool_use), so it needs its own
+    // add into the in-flight set. Cleared by the same tool_result handler.
+    const agentId = 'inflight-nested-spawn'
+    const h = makeHarness({
+      agentId,
+      stallThresholdMs: 60_000,
+      silentStallTerminalMs: 300_000,
+      rescanMs: 500,
+    })
+
+    h.advance(500)
+    unmarkHistorical(h, agentId)
+    h.appendLines({
+      type: 'assistant',
+      message: {
+        stop_reason: 'tool_use',
+        content: [{ type: 'tool_use', id: 'toolu_nested', name: 'Agent', input: { description: 'child task' } }],
+      },
+    })
+    h.advance(1_000)
+    h.advance(62_000) // stall fires (nested child is quiet in OUR jsonl)
+    expect(h.stallCalls).toHaveLength(1)
+
+    // Past silentStallTerminalMs — nested dispatch in flight → deferred.
+    h.advance(400_000)
+    expect(h.stallTerminalCalls).toHaveLength(0)
+
+    // Child returns: tool_result clears the id; after a fresh stall +
+    // terminal window with nothing in flight, synthesis proceeds.
+    h.appendLines(subAgentToolResult('toolu_nested'))
+    h.advance(1_000)
+    h.advance(62_000) // re-stall
+    h.advance(302_000)
+    expect(h.stallTerminalCalls).toHaveLength(1)
+    expect(h.finishCalls).toHaveLength(1)
+  })
+})

package/telegram-plugin/tests/turn-flush-safety.test.ts

@@ -261,10 +261,24 @@ describe('#2798 turn-flush punctuation/bold parity with reply', () => {
   )
 
   it('reply path: normalizes AFTER redact and BEFORE the voice scrub', () => {
-    const start = gatewaySrc.indexOf('async function executeReply(')
-    const redactIdx = gatewaySrc.indexOf(`redactOutboundText(text, 'reply')`, start)
-    const normIdx = gatewaySrc.indexOf('stripExcessBold(normalizePunctuation(text))', start)
-    const scrubIdx = gatewaySrc.indexOf('scrubVoice(text)', start)
+    // #2996: the reply-path entry pipeline moved into outbound-send-path.ts
+    // (`normalizeOutboundBody`). The reply path delegates to it via
+    // `normalizeOutboundBody(rawText, 'reply', redactOutboundText)`; the
+    // redact→normalize→scrub ordering is now pinned in the module source.
+    const replyDelegates = gatewaySrc.indexOf(
+      `normalizeOutboundBody(rawText, 'reply', redactOutboundText)`,
+      gatewaySrc.indexOf('async function executeReply('),
+    )
+    expect(replyDelegates).toBeGreaterThan(0)
+
+    const moduleSrc = readFileSync(
+      new URL('../gateway/outbound-send-path.ts', import.meta.url),
+      'utf8',
+    )
+    const start = moduleSrc.indexOf('export function normalizeOutboundBody(')
+    const redactIdx = moduleSrc.indexOf('redact(text, site)', start)
+    const normIdx = moduleSrc.indexOf('stripExcessBold(normalizePunctuation(text))', start)
+    const scrubIdx = moduleSrc.indexOf('scrubVoice(text)', start)
     expect(start).toBeGreaterThan(0)
     expect(redactIdx).toBeGreaterThan(start)
     expect(normIdx).toBeGreaterThan(redactIdx) // normalize AFTER the reply redact