switchroom 0.19.14 → 0.19.15

package/telegram-plugin/tests/narration-leak-3513.test.ts

@@ -0,0 +1,352 @@
+/**
+ * narration-leak-3513.test.ts — outcome-asserting regression suite for
+ * switchroom#3513 ("agent intent-narration leaks into the final Telegram reply
+ * as a real chat message").
+ *
+ * The single-surface invariant: every trailing plain-text block is assigned once
+ * to exactly one surface — delivered chat answer / ephemeral progress card /
+ * suppressed — by ONE shared classifier, and NO delivery path (E1 turn-flush,
+ * E2 quiescence, E3 captured-prose bridge, E4 outbox sweep) ever emits a block
+ * classified as structural narration; the one genuine unsent answer still
+ * delivers exactly once.
+ *
+ * Every test here asserts an OUTCOME (was the narration delivered? was the real
+ * answer delivered?), not merely that a code path ran, and each is written to be
+ * RED on the pre-fix code (which had two hand-synced regex classifiers and no
+ * structural/ledger guard).
+ */
+
+import { describe, it, expect, vi } from 'vitest'
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import {
+  isStructuralNarration,
+  isNarrationBlock,
+  ledgerHashHex,
+  SUBSTANTIVE_MIN_CHARS,
+} from '../hooks/narration-classify.mjs'
+import { selectFlushDeliveryText, FLUSH_SUBSTANTIVE_MIN_CHARS } from '../turn-flush-safety.js'
+import { decideOutboxSweep } from '../outbox.js'
+import { decideCapturedProseDelivery } from '../silent-end.js'
+import { appendShownBlock, isShownBlock, readShownHashes } from '../shown-ledger.js'
+import { NarrativeFlushController } from '../narrative-flush.js'
+
+const NARRATION = 'Now let me check the gateway logs to see what happened.'
+const REAL_ANSWER =
+  'The gateway crashed because the outbox sweep tried to deliver a record whose ' +
+  'turnNonce had already been journaled, and the dedup cache had been evicted, so ' +
+  'the exactly-once guard fell back to the text-dedup path which returned false. ' +
+  'The fix is to check the shown-ledger before the quiet window, not after.'
+
+// A substantive real message that the model happens to precede a NON-delivering
+// tool with (react / pin / typing). Must NOT be treated as narration.
+const SUBSTANTIVE_BEFORE_REACT = REAL_ANSWER
+
+describe('shared classifier — the ONE source of truth (correction 2 + 3)', () => {
+  it('short/narration-shaped block followed by a tool IS structural narration', () => {
+    expect(isStructuralNarration(NARRATION, true)).toBe(true)
+    expect(isStructuralNarration('On it — pulling the numbers…', true)).toBe(true)
+    expect(isStructuralNarration('', true)).toBe(true)
+  })
+
+  it('SUBSTANTIVE block followed by a tool is NOT narration (react/pin/typing still delivers)', () => {
+    // The #3237 asymmetry: a real answer preceding react/pin/typing must deliver.
+    expect(SUBSTANTIVE_BEFORE_REACT.length).toBeGreaterThan(SUBSTANTIVE_MIN_CHARS)
+    expect(isStructuralNarration(SUBSTANTIVE_BEFORE_REACT, true)).toBe(false)
+  })
+
+  it('a terminal block (nothing followed it) is NEVER structural narration', () => {
+    // followedByToolUse false OR absent → never structural (could be the answer).
+    expect(isStructuralNarration(NARRATION, false)).toBe(false)
+    expect(isStructuralNarration(NARRATION, undefined)).toBe(false)
+    expect(isStructuralNarration('Yes.', false)).toBe(false)
+  })
+
+  it('FLUSH_SUBSTANTIVE_MIN_CHARS is wired to the shared constant (no drift)', () => {
+    expect(FLUSH_SUBSTANTIVE_MIN_CHARS).toBe(SUBSTANTIVE_MIN_CHARS)
+  })
+})
+
+describe('E1/E2 turn-flush — narration never becomes the delivered answer', () => {
+  it('drops a trailing narration block that a tool followed, keeps the real answer', () => {
+    const out = selectFlushDeliveryText([REAL_ANSWER, NARRATION], [false, true])
+    expect(out).toContain(REAL_ANSWER)
+    expect(out).not.toContain(NARRATION)
+  })
+
+  it('drops a SHORT non-regex block a tool followed (the class the old regex missed)', () => {
+    // "The logs show three errors." matches NO wording heuristic (no opener, no
+    // trailing ellipsis/colon) — the pre-fix regex-only classifier would have
+    // DELIVERED it. It is structural narration only because a tool followed it
+    // AND it is under the substantive floor. This is the core #3513 discriminator.
+    const shortNonRegex = 'The logs show three errors.'
+    expect(isNarrationBlock(shortNonRegex)).toBe(false)
+    expect(shortNonRegex.length).toBeLessThan(SUBSTANTIVE_MIN_CHARS)
+    const out = selectFlushDeliveryText([REAL_ANSWER, shortNonRegex], [false, true])
+    expect(out).toContain(REAL_ANSWER)
+    expect(out).not.toContain(shortNonRegex)
+  })
+
+  it('zero-reply, narration-only turn (all blocks followed by tools) flushes NOTHING', () => {
+    const out = selectFlushDeliveryText(['Let me pull the logs.', NARRATION], [true, true])
+    expect(out).toBe('')
+  })
+
+  it('a genuine terminal answer with no provenance still flushes (fail-open)', () => {
+    // Provenance-less single block — conservative: deliver it.
+    expect(selectFlushDeliveryText(['Here are the results:'])).toBe('Here are the results:')
+  })
+
+  it('a SUBSTANTIVE answer followed by a non-delivering tool STILL flushes', () => {
+    const out = selectFlushDeliveryText([SUBSTANTIVE_BEFORE_REACT], [true])
+    expect(out).toBe(SUBSTANTIVE_BEFORE_REACT)
+  })
+})
+
+describe('E4 outbox sweep — a ledger-marked block is never re-delivered (correction 1)', () => {
+  const base = {
+    now: 10_000_000,
+    deliveredNonces: new Set<string>(),
+    textAlreadyDelivered: false,
+    routable: true,
+    quietMs: 0,
+  }
+
+  it('skips a record whose text was shown on the ephemeral card', () => {
+    const d = decideOutboxSweep({
+      ...base,
+      record: { turnNonce: 'c:_#5', text: NARRATION, createdAt: 0 },
+      shownLedgerHit: true,
+    })
+    expect(d.action).toBe('skip-ephemeral-shown')
+    expect(d.text).toBeUndefined()
+  })
+
+  it('delivers a real answer that was NOT shown on the card', () => {
+    const d = decideOutboxSweep({
+      ...base,
+      record: { turnNonce: 'c:_#5', text: REAL_ANSWER, createdAt: base.now },
+      shownLedgerHit: false,
+    })
+    expect(d.action).toBe('send')
+    expect(d.text).toContain(REAL_ANSWER)
+  })
+
+  it('the ledger hit is checked AFTER journaled (exactly-once wins) but BEFORE quiet', () => {
+    // Already-journaled record short-circuits regardless of ledger state.
+    const journaled = decideOutboxSweep({
+      ...base,
+      deliveredNonces: new Set(['c:_#5']),
+      record: { turnNonce: 'c:_#5', text: NARRATION, createdAt: 0 },
+      shownLedgerHit: true,
+    })
+    expect(journaled.action).toBe('skip-journaled')
+  })
+})
+
+describe('E4 outbox sweep × durable shown-ledger — end-to-end wiring (correction 1 + 4)', () => {
+  // Integration test: exercise the REAL ledger round-trip (append/markShown +
+  // isShownBlock/isBlockShown) keyed by turnNonce THROUGH the outbox-sweep
+  // decision, mirroring the production composition at
+  // gateway/outbox-sweep.ts:122 (`shownLedgerHit: isShownBlock(record.turnNonce,
+  // record.text, deps.stateDir)`). Unlike the unit tests above that pass a
+  // hand-set `shownLedgerHit` boolean, this drives the flag FROM the durable
+  // ledger file — so if the ledger wiring is removed (append becomes a no-op, or
+  // decideOutboxSweep stops consulting the hit), the skip assertion goes RED.
+  const base = {
+    now: 10_000_000,
+    deliveredNonces: new Set<string>(),
+    textAlreadyDelivered: false,
+    routable: true,
+    quietMs: 0,
+  }
+
+  it('a block marked shown for its turnNonce is skipped; a non-shown block delivers', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'outbox-ledger-'))
+    try {
+      const nonce = 'c:_#42'
+      // markShown: the mid-turn narrative paint appended this block to the
+      // durable ledger for THIS turn's nonce.
+      appendShownBlock(nonce, NARRATION, dir)
+
+      // Sweep the SAME (nonce, text): the production wiring derives the flag from
+      // the ledger, so the record must be skipped as ephemeral-shown.
+      const shown = decideOutboxSweep({
+        ...base,
+        record: { turnNonce: nonce, text: NARRATION, createdAt: 0 },
+        shownLedgerHit: isShownBlock(nonce, NARRATION, dir),
+      })
+      expect(isShownBlock(nonce, NARRATION, dir)).toBe(true)
+      expect(shown.action).toBe('skip-ephemeral-shown')
+      expect(shown.text).toBeUndefined()
+
+      // A NON-shown block (the genuine unsent answer, never appended) still
+      // delivers exactly once — the ledger miss falls through to send.
+      const notShown = decideOutboxSweep({
+        ...base,
+        record: { turnNonce: nonce, text: REAL_ANSWER, createdAt: base.now },
+        shownLedgerHit: isShownBlock(nonce, REAL_ANSWER, dir),
+      })
+      expect(isShownBlock(nonce, REAL_ANSWER, dir)).toBe(false)
+      expect(notShown.action).toBe('send')
+      expect(notShown.text).toContain(REAL_ANSWER)
+
+      // Cross-turn isolation: the SAME text under a DIFFERENT turnNonce is not a
+      // ledger hit, so it delivers (no cross-turn suppression through the sweep).
+      const otherTurn = decideOutboxSweep({
+        ...base,
+        record: { turnNonce: 'c:_#43', text: NARRATION, createdAt: base.now },
+        shownLedgerHit: isShownBlock('c:_#43', NARRATION, dir),
+      })
+      expect(otherTurn.action).toBe('send')
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+})
+
+describe('E3 captured-prose bridge — a shown block is refused (correction 1)', () => {
+  /** Write a real silent-end-pending.json into a temp stateDir. */
+  function withState(text: string, run: (deps: { stateDir: string }) => void): void {
+    const dir = mkdtempSync(join(tmpdir(), 'silent-end-'))
+    try {
+      writeFileSync(
+        join(dir, 'silent-end-pending.json'),
+        JSON.stringify({
+          chatId: 'c',
+          threadId: null,
+          turnKey: 'c:_',
+          turnId: 'c:_#5',
+          pendingText: text,
+          retryCount: 0,
+          timestamp: Date.now(),
+        }),
+      )
+      run({ stateDir: dir })
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  }
+
+  it('refuses to bridge prose already surfaced on the card', () => {
+    withState(REAL_ANSWER, ({ stateDir }) => {
+      const d = decideCapturedProseDelivery(
+        { turnKey: 'c:_', turnId: 'c:_#5', minChars: 10 },
+        { stateDir, isBlockShown: () => true },
+      )
+      expect(d.deliver).toBe(false)
+      expect(d.reason).toBe('ephemeral-shown')
+    })
+  })
+
+  it('bridges a genuine unsent answer that was NOT shown (empty-capture divergence)', () => {
+    withState(REAL_ANSWER, ({ stateDir }) => {
+      const d = decideCapturedProseDelivery(
+        { turnKey: 'c:_', turnId: 'c:_#5', minChars: 10 },
+        { stateDir, isBlockShown: () => false },
+      )
+      expect(d.deliver).toBe(true)
+      if (d.deliver) expect(d.text).toContain(REAL_ANSWER)
+    })
+  })
+})
+
+describe('durable shown-ledger — round trip + envelope-less no-op (correction 4)', () => {
+  it('marks then recognises a structural narration block for its turnNonce', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'shown-ledger-'))
+    try {
+      appendShownBlock('c:_#7', NARRATION, dir)
+      expect(isShownBlock('c:_#7', NARRATION, dir)).toBe(true)
+      // A different turn's nonce must NOT match (no cross-turn suppression).
+      expect(isShownBlock('c:_#8', NARRATION, dir)).toBe(false)
+      // The stored hash matches the shared classifier hash.
+      expect(readShownHashes('c:_#7', dir).has(ledgerHashHex(NARRATION))).toBe(true)
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  it('a null turnNonce (envelope-less handback/cron) is never written', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'shown-ledger-'))
+    try {
+      appendShownBlock(null, NARRATION, dir)
+      expect(isShownBlock(null, NARRATION, dir)).toBe(false)
+      expect(readShownHashes(null, dir).size).toBe(0)
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+})
+
+/** Fake at-most-one scheduler mirroring the real unref'd setTimeout wiring. */
+class FakeScheduler {
+  private fn: (() => void) | null = null
+  arm(fn: () => void): void {
+    this.fn = fn
+  }
+  disarm(): void {
+    this.fn = null
+  }
+  fire(): void {
+    const fn = this.fn
+    this.fn = null
+    fn?.()
+  }
+}
+
+describe('narrative controller — durable-mark ONLY mid-turn narration (correction 4)', () => {
+  function make() {
+    const show = vi.fn<[string], void>()
+    const retractShown = vi.fn<[string], void>()
+    const markDurableNarration = vi.fn<[string], void>()
+    const scheduler = new FakeScheduler()
+    const ctrl = new NarrativeFlushController(
+      { show, retractShown, markDurableNarration },
+      scheduler,
+      250,
+    )
+    return { ctrl, show, markDurableNarration, scheduler }
+  }
+
+  it('marks a block SHOWN mid-turn because another narration block followed it (stage)', () => {
+    const { ctrl, show, markDurableNarration } = make()
+    ctrl.stage('First, let me check the logs…')
+    ctrl.stage('Now scanning the outbox…') // lookahead → shows + marks the first
+    expect(show).toHaveBeenCalledWith('First, let me check the logs…')
+    expect(markDurableNarration).toHaveBeenCalledWith('First, let me check the logs…')
+  })
+
+  it('marks a block SHOWN mid-turn because a tool followed it (resolveOnTool)', () => {
+    const { ctrl, markDurableNarration } = make()
+    ctrl.stage(NARRATION)
+    ctrl.resolveOnTool('Bash', { command: 'grep' }) // non-reply tool lookahead
+    expect(markDurableNarration).toHaveBeenCalledWith(NARRATION)
+  })
+
+  it('NEVER marks the timer-painted terminal block (could be the real answer)', () => {
+    const { ctrl, show, markDurableNarration, scheduler } = make()
+    ctrl.stage(REAL_ANSWER)
+    scheduler.fire() // timer paints the LAST block early
+    expect(show).toHaveBeenCalledWith(REAL_ANSWER)
+    expect(markDurableNarration).not.toHaveBeenCalled()
+  })
+
+  it('NEVER marks the turn-end paint (terminal, could be the real answer)', () => {
+    const { ctrl, show, markDurableNarration } = make()
+    ctrl.stage(REAL_ANSWER)
+    ctrl.flushAtTurnEnd('') // no reply delivered → shows trailing prose, but never marks
+    expect(show).toHaveBeenCalledWith(REAL_ANSWER)
+    expect(markDurableNarration).not.toHaveBeenCalled()
+  })
+
+  it('does NOT mark a SUBSTANTIVE block even mid-turn (substance-gated, correction 3)', () => {
+    const { ctrl, markDurableNarration } = make()
+    ctrl.stage(SUBSTANTIVE_BEFORE_REACT)
+    ctrl.resolveOnTool('react', { emoji: '👍' }) // non-delivering tool
+    // Followed by a tool, but substantive → not structural narration → not marked,
+    // so a backstop could still deliver it if it were the genuine unsent answer.
+    expect(markDurableNarration).not.toHaveBeenCalled()
+  })
+})

package/telegram-plugin/tests/silent-end-interrupt-stop-scan.test.ts

@@ -404,10 +404,13 @@ describe('scanTurnForFinalReply — pendingText is a single substantive block, n
   const NARRATION_B = "Now let me query the second source; it is slower than expected, hang tight…" // opener + …
   const NARRATION_C = "I'll cross-reference the last set of figures against the ledger before I summarise…" // opener + …
 
-  it('zero-delivery turn of only NARRATION blocks → block WITHOUT pendingText (#3228 Finding 2 / flush parity)', () => {
-    // Combined length of the three blocks is ≥ 200, so the OLD joined-floor code
-    // would join them and set pendingText (masquerade). The NEW code mirrors the
-    // flush's narration strip: every block is narration → nothing to deliver.
+  it('narration interleaved with work-tools, ending on a terminal narration line → only the terminal block, never the join (#3513 structural coalescer)', () => {
+    // #3513 follow-up — A and B are each followed by a turn-continuing tool_use
+    // (Bash / Read) → structurally intra-turn → UNCONDITIONALLY suppressed.
+    // C is the terminal block (no tool after it), so the deterministic coalescer
+    // delivers C ALONE. The #3228 Finding-2 join-masquerade (concatenating short
+    // narration to cross the 200-char floor) is STILL prevented: the 200-floor
+    // `pendingText` stays undefined, and the delivered text is never the join.
     expect((NARRATION_A + '\n\n' + NARRATION_B + '\n\n' + NARRATION_C).length)
       .toBeGreaterThanOrEqual(200)
     const text = jsonl(
@@ -421,8 +424,12 @@ describe('scanTurnForFinalReply — pendingText is a single substantive block, n
     const r = scanTurnForFinalReply(text)
     expect(r.decided).toBe('block')
     expect(r.reason).toBe('no-final-reply')
-    // The masquerade must NOT happen — no answer to deliver, take the re-prompt.
-    expect(r.pendingText).toBeUndefined()
+    // Never the join of the suppressed A/B blocks (masquerade guard preserved).
+    expect(r.pendingText).not.toContain(NARRATION_A)
+    expect(r.pendingText).not.toContain(NARRATION_B)
+    // The terminal block is the coalescer's selection (delivered via the
+    // zero-reply lowered floor); the 200-char masquerade path yields nothing.
+    expect(r.pendingText).toBe(NARRATION_C)
   })
 
   it('zero-delivery turn of MULTIPLE sub-200 REAL-CONTENT blocks → JOINED pendingText (review item 3 drop fix)', () => {
@@ -445,15 +452,34 @@ describe('scanTurnForFinalReply — pendingText is a single substantive block, n
     expect(r.hasTrailingProse).toBe(true)
   })
 
-  it('leading narration + a real sub-200 answer block → only the answer is delivered (narration stripped)', () => {
+  it('leading narration FOLLOWED BY A TOOL + a real sub-200 answer block → only the answer is delivered (structural strip)', () => {
+    // #3513 follow-up — the narration is stripped by the STRUCTURAL signal (a
+    // work-tool followed it), not by wording. The terminal answer block (no tool
+    // after it) is the coalescer's selection.
     const NARR = 'Let me pull the numbers first…' // narration opener + …
     const ANSWER = 'Revenue was up 12% quarter-over-quarter, driven mostly by the new enterprise tier.' // ~85, real
-    const text = jsonl(ENQUEUE, assistantText(NARR), assistantText(ANSWER))
+    const text = jsonl(
+      ENQUEUE,
+      assistantText(NARR),
+      assistantToolUse('Bash', { command: 'psql -c "select ..."' }),
+      assistantText(ANSWER),
+    )
     const r = scanTurnForFinalReply(text)
     expect(r.decided).toBe('block')
     expect(r.pendingText).toBe(ANSWER)
   })
 
+  it('leading narration with NO tool + a real answer → both delivered joined (fail-open; no wording strip on the backstop path, #3513)', () => {
+    // Without a structural continuation signal the coalescer delivers the full
+    // terminal run — the wording-based strip is gone (it was provably incomplete).
+    const NARR = 'Let me pull the numbers first…'
+    const ANSWER = 'Revenue was up 12% quarter-over-quarter, driven mostly by the new enterprise tier.'
+    const text = jsonl(ENQUEUE, assistantText(NARR), assistantText(ANSWER))
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('block')
+    expect(r.pendingText).toBe(`${NARR}\n\n${ANSWER}`)
+  })
+
   it('trailing narration after a delivered reply, all sub-floor → block only if a real ≥floor block exists; here → allow, no pendingText', () => {
     // Each trailing block is sub-floor, so `sawUndeliveredTextAfterAllow` is
     // false → allow. (The old joined-floor logic never affected the block
@@ -469,18 +495,21 @@ describe('scanTurnForFinalReply — pendingText is a single substantive block, n
     expect(r.pendingText).toBeUndefined()
   })
 
-  it('a genuine ≥floor answer followed by a SHORT closer → pendingText is the answer, not the closer', () => {
-    // "big answer then short closer" — the LAST substantive (≥floor) block is
-    // the answer; the trailing short closer must not displace it.
+  it('a genuine ≥floor answer followed by a SHORT closer → both delivered as the terminal run (answer never dropped, #3513)', () => {
+    // #3513 follow-up — "big answer then short closer", NO tool after either
+    // block, so both are the terminal run and are delivered JOINED. The #3228
+    // concern (a short closer DISPLACING the answer) cannot happen: the coalescer
+    // never drops the answer — it delivers the whole terminal run.
     const answer = 'Here is the real answer you were waiting for: ' + 'A'.repeat(300)
+    const closer = 'Let me know if you need anything else.'
     const text = jsonl(
       ENQUEUE,
       assistantText(answer),
-      assistantText('Let me know if you need anything else.'),
+      assistantText(closer),
     )
     const r = scanTurnForFinalReply(text)
     expect(r.decided).toBe('block')
-    expect(r.pendingText).toBe(answer)
+    expect(r.pendingText).toBe(`${answer}\n\n${closer}`)
   })
 
   it('substance-floor boundary: a single trailing block at 199/200/201 chars', () => {

package/telegram-plugin/tests/silent-end.test.ts

@@ -787,11 +787,17 @@ describe('silent-end-interrupt-stop hook — integration (#1775: transcript-scan
       expect(lowered.text).toBe(joined)
     })
 
-    it('review item 3: NARRATION-only multi-block → still NO pendingText (no masquerade, #3228 Finding 2)', () => {
+    it('review item 3: intra-turn narration blocks each FOLLOWED BY A TOOL → NO pendingText (structural suppression, #3513)', () => {
+      // #3513 follow-up — each narration block is followed by a turn-continuing
+      // tool_use, so the deterministic coalescer suppresses BOTH unconditionally.
+      // The terminal run is empty and the last (tool-followed) block is sub-200 →
+      // the empty-terminal corner returns null → no pendingText, no masquerade.
       const transcript = writeTranscript([
         ENQUEUE,
         { type: 'assistant', message: { content: [{ type: 'text', text: 'Let me check the first source now, scanning the rows…' }] } },
+        { type: 'assistant', message: { content: [{ type: 'tool_use', id: 't1', name: 'Bash', input: { command: 'ls' } }] } },
         { type: 'assistant', message: { content: [{ type: 'text', text: "Now let me query the second source; hang tight…" }] } },
+        { type: 'assistant', message: { content: [{ type: 'tool_use', id: 't2', name: 'Read', input: { file_path: '/tmp/x' } }] } },
       ])
       const r = runHook({ session_id: 's', transcript_path: transcript, hook_event_name: 'Stop' })
       expect(JSON.parse(r.stdout.trim()).decision).toBe('block')

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

@@ -683,13 +683,36 @@ describe('selectFlushDeliveryText — deliver the terminal answer, strip only na
     expect(out).toBe('Here are the results:')
   })
 
-  it('decideTurnFlush delivers the narrowed answer, not the whole blob', () => {
+  // #3513 follow-up — decideTurnFlush now routes through the deterministic
+  // `selectBackstopDelivery` coalescer, NOT the wording heuristic. With NO
+  // structural provenance (no `capturedBlockMeta`, so no block was followed by a
+  // turn-continuing tool_use) EVERY block is part of the terminal run and is
+  // delivered joined — fail OPEN, never drop. The wording-based narration strip
+  // is gone on the backstop path (it was provably incomplete; #3513). When the
+  // structural signal IS present it, and only it, suppresses.
+  it('decideTurnFlush delivers the full terminal run when NO tool-follow provenance is present (fail-open)', () => {
     const decision = decideTurnFlush({
       chatId: 'chat1',
       replyCalled: false,
       capturedText: ['Let me check.', 'Now let me compose the reply.', answer],
     })
     expect(decision.kind).toBe('flush')
+    if (decision.kind === 'flush') {
+      expect(decision.text).toBe(`Let me check.\n\nNow let me compose the reply.\n\n${answer}`)
+    }
+  })
+
+  it('decideTurnFlush suppresses tool-followed blocks UNCONDITIONALLY (structural provenance drives the coalescer)', () => {
+    // The first two blocks were each followed by a turn-continuing tool_use →
+    // intra-turn narration → suppressed with NO length/wording gate. Only the
+    // terminal answer (not tool-followed) survives.
+    const decision = decideTurnFlush({
+      chatId: 'chat1',
+      replyCalled: false,
+      capturedText: ['Let me check.', 'Now let me compose the reply.', answer],
+      capturedBlockMeta: [true, true, false],
+    })
+    expect(decision.kind).toBe('flush')
     if (decision.kind === 'flush') {
       expect(decision.text).toBe(answer)
       expect(decision.text).not.toContain('Let me check')
@@ -832,11 +855,20 @@ describe('selectFlushDeliveryText — structural provenance (followedByToolUse)
     // trailing ellipsis/colon — so only the structural flag could strip it.
     const wrapUp = 'Saved that to memory.'
     // meta[0]=true (a memory tool_use followed the real answer), [1]=false.
+    // The STANDALONE `selectFlushDeliveryText` (the old #3237 substance-gated
+    // function, unchanged and still exported) keeps the substantial block.
     const out = selectFlushDeliveryText([realAnswer, wrapUp], [true, false])
     expect(out).toBe(`${realAnswer}\n\n${wrapUp}`)
     expect(out).toContain('The migration completed cleanly')
 
-    // End-to-end through decideTurnFlush.
+    // #3513 follow-up — decideTurnFlush now routes through
+    // `selectBackstopDelivery`, which suppresses a tool-followed block
+    // UNCONDITIONALLY (no substantive-floor carve-out). This DELIBERATELY
+    // overturns #3237's substance-gate ON THE BACKSTOP PATH: a real answer the
+    // model followed with a turn-continuing tool_use is treated as intra-turn
+    // and excluded; only the terminal (non-tool-followed) block is delivered.
+    // The deterministic contract is "the terminal run wins" — the model keeps
+    // its answer by ending on it or calling the reply tool.
     const decision = decideTurnFlush({
       chatId: 'chat1',
       replyCalled: false,
@@ -845,7 +877,7 @@ describe('selectFlushDeliveryText — structural provenance (followedByToolUse)
     })
     expect(decision.kind).toBe('flush')
     if (decision.kind === 'flush') {
-      expect(decision.text).toBe(`${realAnswer}\n\n${wrapUp}`)
+      expect(decision.text).toBe(wrapUp)
     }
   })