switchroom 0.18.19 → 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

@@ -19,6 +19,8 @@ import {
   repairEscapedWhitespace,
   escapeMarkdown,
   splitMarkdownChunks,
+  addParagraphSpacers,
+  PARAGRAPH_SPACER,
   RICH_MESSAGE_MAX_CHARS,
 } from '../format.js'
 
@@ -185,56 +187,67 @@ describe('splitMarkdownChunks', () => {
   })
 
   // -------------------------------------------------------------------------
-  // Chunk-boundary blank-line hygiene. Paragraph gaps are now plain `\n\n`
-  // (the NBSP spacer was removed in the #2669 follow-up). When a cut lands in
-  // a gap, the boundary must not leave a chunk that opens or ends with a bare
-  // blank line, and no visible content may be dropped.
+  // Chunk-boundary spacer hygiene. addParagraphSpacers injects a
+  // `\n\n${PARAGRAPH_SPACER}\n\n` gap between prose paragraphs. When a cut
+  // lands inside that gap, the boundary must not leave a chunk that opens or
+  // ends with a bare U+00A0 spacer line (a stray blank bubble line).
   // -------------------------------------------------------------------------
 
-  test('no chunk starts or ends with a bare blank line at a `\\n\\n` gap cut', () => {
+  test('no chunk starts or ends with a bare U+00A0 spacer line (reviewer repro)', () => {
+    // The exact reviewer repro: a spacer gap straddling a small cap.
     const A = 'Alpha sentence one'
     const B = 'Bravo sentence two'
-    const text = `${A}.\n\n${B}.`
-    const chunks = splitMarkdownChunks(text, 33)
+    const spaced = addParagraphSpacers(`${A}.\n\n${B}.`)
+    const chunks = splitMarkdownChunks(spaced, 33)
     expect(chunks.length).toBeGreaterThan(1)
-    const blankOnly = /^[ \t]*$/
+    const spacerOnly = new RegExp(`^[ \\t]*${PARAGRAPH_SPACER}[ \\t]*$`)
     for (const c of chunks) {
       const lines = c.split('\n')
-      expect(blankOnly.test(lines[0])).toBe(false)
-      expect(blankOnly.test(lines[lines.length - 1])).toBe(false)
+      expect(spacerOnly.test(lines[0])).toBe(false)
+      expect(spacerOnly.test(lines[lines.length - 1])).toBe(false)
     }
   })
 
   test('visible paragraph content survives the boundary (no text dropped)', () => {
     const A = 'Alpha sentence one'
     const B = 'Bravo sentence two'
-    const text = `${A}.\n\n${B}.`
-    const chunks = splitMarkdownChunks(text, 33)
+    const spaced = addParagraphSpacers(`${A}.\n\n${B}.`)
+    const chunks = splitMarkdownChunks(spaced, 33)
     const rejoined = chunks.join('\n')
     expect(rejoined).toContain(`${A}.`)
     expect(rejoined).toContain(`${B}.`)
   })
 
-  test('blank-line-boundary strip is robust across several gaps and small caps', () => {
+  test('spacer-boundary strip is robust across several gaps and small caps', () => {
     const paras = Array.from({ length: 6 }, (_, i) => `Paragraph ${i} body text here.`)
-    const text = paras.join('\n\n')
-    const blankOnly = /^[ \t]*$/
+    const spaced = addParagraphSpacers(paras.join('\n\n'))
+    const spacerOnly = new RegExp(`^[ \\t]*${PARAGRAPH_SPACER}[ \\t]*$`)
     for (const cap of [20, 31, 40, 64]) {
-      const chunks = splitMarkdownChunks(text, cap)
+      const chunks = splitMarkdownChunks(spaced, cap)
       for (const c of chunks) {
         const lines = c.split('\n')
-        expect(blankOnly.test(lines[0])).toBe(false)
-        expect(blankOnly.test(lines[lines.length - 1])).toBe(false)
+        expect(spacerOnly.test(lines[0])).toBe(false)
+        expect(spacerOnly.test(lines[lines.length - 1])).toBe(false)
       }
-      // No visible word is dropped: concatenating the chunks' non-blank tokens
-      // reproduces the original word sequence. (Word-level, not line-level,
-      // because a small cap may split mid-word — the chunker's normal
-      // space-boundary behaviour.)
-      const words = (s: string): string[] => s.split(/\s+/).filter((w) => w.length > 0)
+      // No visible word is dropped: concatenating the chunks' non-blank,
+      // non-spacer tokens reproduces the original word sequence. (Word-level,
+      // not line-level, because a small cap may split mid-word — that's the
+      // 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)
       expect(words(chunks.join(' '))).toEqual(words(paras.join(' ')))
     }
   })
 
+  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'))
+  })
+
   // -------------------------------------------------------------------------
   // Entity-aware chunking (#finding-3): a cut must never bisect an inline
   // span (`**bold**`, `` `code` ``, `_italic_`, `[label](href)`), which would

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

@@ -31,7 +31,9 @@ import {
   normalizeParagraphBreaks,
   normalizePunctuation,
   stripExcessBold,
+  addParagraphSpacers,
   splitMarkdownChunks,
+  PARAGRAPH_SPACER,
   RICH_MESSAGE_MAX_CHARS,
 } from '../format.js'
 
@@ -128,9 +130,7 @@ describe('decideTurnFlush — prose+trailing-sentinel is suppressed, not leaked
 // the real gateway turn-flush render pipeline (post-#2669 rich-markdown path):
 //   decideTurnFlush -> join('\n\n')
 //   -> repairEscapedWhitespace -> normalizeParagraphBreaks
-//   -> splitMarkdownChunks -> sendRichMessage
-// (no paragraph-spacer pass — the NBSP spacer was removed in the #2669
-//  follow-up; gaps are plain `\n\n`, one visible blank line)
+//   -> addParagraphSpacers -> splitMarkdownChunks -> sendRichMessage
 // so it pins the end-to-end fix, not just the pure decision. The corpus is a
 // REAL captured-transcript shape (three separate content[i].text blocks, one
 // stored UNTRIMMED with a trailing '\n' exactly as session-tail.ts pushes
@@ -156,7 +156,8 @@ describe('#2798 turn-flush block separation — real multi-block transcript shap
     const d = decideTurnFlush({ chatId: '12345', replyCalled: false, capturedText: blocks })
     expect(d.kind).toBe('flush')
     const joined = (d as { kind: 'flush'; text: string }).text
-    return normalizeParagraphBreaks(repairEscapedWhitespace(joined))
+    const normalized = normalizeParagraphBreaks(repairEscapedWhitespace(joined))
+    return addParagraphSpacers(normalized)
   }
 
   it('separates whole blocks with a visible paragraph gap, not a wall-of-text', () => {
@@ -166,29 +167,32 @@ describe('#2798 turn-flush block separation — real multi-block transcript shap
     expect(out).toContain('The `auth` handler looks correct')
     expect(out).toContain('Want me to open a PR')
     // The wall-of-text failure mode glues two blocks one '\n' apart. Assert the
-    // boundary carries a real paragraph break (plain `\n\n`, one blank line —
-    // no NBSP spacer), and NOT a single-newline join.
-    expect(out).toContain('flagged.\n\nThe `auth`')
+    // boundary carries a real paragraph break with the injected visible spacer
+    // line (#2692 rich-path spacer), and NOT a single-newline join.
+    expect(out).toContain(`\n\n${PARAGRAPH_SPACER}\n\n`)
     expect(out).not.toContain('flagged.\nThe `auth`')
-    // No U+00A0 anywhere.
-    expect(out).not.toContain(String.fromCharCode(0xa0))
+    // A spacer sits specifically between block 1 and block 2.
+    const b1 = out.indexOf('flagged.')
+    const b2 = out.indexOf('The `auth` handler')
+    expect(out.slice(b1, b2)).toContain(PARAGRAPH_SPACER)
   })
 
   it('collapses the untrimmed-trailing-newline stack — no 3+ newline run reaches the wire', () => {
     const out = renderLikeTurnFlush(realBlocks)
     // Block 2's trailing '\n' + the '\n\n' join = 3 newlines; normalize
-    // collapses 3+ runs to '\n\n', so no doubled/stacked blank run survives.
+    // collapses 3+ runs to '\n\n' and addParagraphSpacers wedges exactly one
+    // spacer, so no doubled/stacked blank run survives.
     expect(out).not.toMatch(/\n{3,}/)
-    // One blank-line gap per block transition: 3 blocks → 2 gaps.
-    const gapCount = (out.match(/\n\n/g) ?? []).length
-    expect(gapCount).toBe(2)
+    // One spacer per block transition: 3 blocks → 2 gaps → 2 spacers.
+    const spacerCount = out.split(PARAGRAPH_SPACER).length - 1
+    expect(spacerCount).toBe(2)
   })
 
   it('the whole separated answer stays in one rich chunk here (well under 32768)', () => {
     const out = renderLikeTurnFlush(realBlocks)
     const chunks = splitMarkdownChunks(out, RICH_MESSAGE_MAX_CHARS)
     expect(chunks.length).toBe(1)
-    expect(chunks[0]).toContain('\n\n')
+    expect(chunks[0]).toContain(PARAGRAPH_SPACER)
   })
 
   it('still SUPPRESSES a real transcript that deliberately terminates with a bare NO_REPLY (#2053 guard intact)', () => {
@@ -224,9 +228,9 @@ describe('#2798 turn-flush block separation — real multi-block transcript shap
 // runs (gateway executeReply):
 //   repairEscapedWhitespace -> normalizeParagraphBreaks -> redactOutboundText
 //   -> stripExcessBold(normalizePunctuation) -> scrubVoice
-// (no send-side paragraph-spacer pass — removed in the #2669 follow-up).
+//   -> addParagraphSpacers (send side)
 // The original #2798 change gave turn-flush the paragraph steps + redact +
-// scrub but OMITTED `stripExcessBold(normalizePunctuation(...))`.
+// scrub + spacers but OMITTED `stripExcessBold(normalizePunctuation(...))`.
 // This suite reconstructs the deterministic format chain of BOTH paths (the
 // runtime-only redact + voice-scrub steps are literally the same calls on both
 // paths and are out of scope here) and pins that turn-flush now matches reply
@@ -308,7 +312,7 @@ describe('#2798 turn-flush punctuation/bold parity with reply', () => {
   function formatChain(text: string): string {
     let t = normalizeParagraphBreaks(repairEscapedWhitespace(text))
     t = stripExcessBold(normalizePunctuation(t))
-    return t
+    return addParagraphSpacers(t)
   }
 
   const input =

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