switchroom 0.19.13 → 0.19.15

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

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

@@ -19,6 +19,13 @@
  * and can be set to `0` / `false` / `off` to disable without a rebuild.
  */
 
+import {
+  isNarrationBlock,
+  isStructuralNarration,
+  selectBackstopDelivery,
+  SUBSTANTIVE_MIN_CHARS,
+} from './hooks/narration-classify.mjs'
+
 const SILENT_MARKERS = new Set(['NO_REPLY', 'HEARTBEAT_OK'])
 // Small buffer so `NO_REPLY.` with a stray period still counts as silent.
 const SILENT_MARKER_MAX_LEN = Math.max(
@@ -134,7 +141,7 @@ export function endsWithSilentMarker(text: string | undefined): boolean {
  * `hooks/silent-end-scan.mjs` — the same bar the codebase uses everywhere to
  * recognise "this text block is a real answer, not a short narration/closer".
  */
-export const FLUSH_SUBSTANTIVE_MIN_CHARS = 200
+export const FLUSH_SUBSTANTIVE_MIN_CHARS = SUBSTANTIVE_MIN_CHARS
 
 /**
  * Pick the text a turn-flush should actually DELIVER from the captured
@@ -203,9 +210,33 @@ export function selectFlushDeliveryText(
     .map((b, i) => ({ text: b.trim(), followedByToolUse: followedByToolUse?.[i] }))
     .filter(c => c.text.length > 0)
   if (candidates.length === 0) return ''
-  if (candidates.length === 1) return candidates[0].text
-  const answer = candidates[candidates.length - 1].text
-  const preceding = candidates.slice(0, -1)
+
+  // #3513 — the STRUCTURAL rule now applies to the TERMINAL block too, not only
+  // preceding blocks. A lone trailing block that a `tool_use` FOLLOWED (the
+  // model kept acting after writing it) is intra-turn narration by construction,
+  // never the terminal answer — so it must not be delivered as one. This is the
+  // primary fix for the observed leak ("Now checking the gateway logs…"),
+  // wording-independent where the opener regex fails. It stays substance-gated
+  // (correction 3): only a SHORT or narration-shaped block that a tool followed
+  // is suppressed — a SUBSTANTIVE, non-narration block followed by a
+  // non-delivering tool (react / pin / typing / edit) is NOT structural
+  // narration and still delivers.
+  //
+  // Only the STRUCTURAL signal (`followedByToolUse === true`) may strip the
+  // terminal block; the opener/trailer heuristic remains a residual tie-breaker
+  // for PRECEDING blocks only, so a provenance-less single block still delivers
+  // verbatim (#3276 finding 7 — a colon-terminated line that IS the whole answer
+  // is never dropped).
+  let cs = candidates
+  while (cs.length > 1 && isStructuralNarration(cs[cs.length - 1].text, cs[cs.length - 1].followedByToolUse)) {
+    cs = cs.slice(0, -1)
+  }
+  if (cs.length === 1) {
+    return isStructuralNarration(cs[0].text, cs[0].followedByToolUse) ? '' : cs[0].text
+  }
+
+  const answer = cs[cs.length - 1].text
+  const preceding = cs.slice(0, -1)
   // Deliver only the terminal answer when every earlier block is
   // intent-narration. Per block:
   //   - structural flag TRUE ⇒ a tool_use followed this block, but that alone
@@ -228,50 +259,15 @@ export function selectFlushDeliveryText(
         ? false
         : isNarrationBlock(c.text),
   )
-  return allNarration ? answer : candidates.map(c => c.text).join('\n\n')
+  return allNarration ? answer : cs.map(c => c.text).join('\n\n')
 }
 
-/**
- * Narration heuristic: a block that opens with a first-person "about to do X"
- * phrase the model emits BEFORE composing its real answer ("Let me check…",
- * "I'll look it up…", "Now let me…"). Deliberately NOT length-based — the
- * narration that shadowed the real answer in the observed bug was a LONG
- * (≥200-char) "Let me pull the numbers…" block, and short blocks are frequently
- * legitimate multi-paragraph answer content — so gating on length either drops a
- * short real answer or keeps a long narration. When earlier blocks don't match
- * this opener we keep the full joined text (never drop content we can't
- * confidently attribute to narration).
- */
-const NARRATION_OPENER =
-  /^(let me\b|lemme\b|i'?ll\b|i will\b|i am going to\b|i'?m going to\b|i'?m about to\b|going to\b|first,?\s+(?:let me|i'?ll|i will)\b|now,?\s+(?:let me|i'?ll|i will)\b|next,?\s+(?:let me|i'?ll|i will)\b|let'?s\b)/i
-
-/**
- * #3276 guard 8 — the `NARRATION_OPENER` regex alone misses common progress
- * narration that opens with a gerund/present-continuous verb and trails off
- * into an ellipsis or colon: "Checking now…", "Pulling the numbers:",
- * "Looking into that…". Relying on the opener regex leaked those blocks into
- * the delivered answer. This recognises a NON-terminal narration line
- * deterministically, WITHOUT re-gating on a min-char floor (a short real
- * answer like "Yes, done." must still deliver): a single short line that ends
- * with an ellipsis or a colon is progress narration, not the terminal answer.
- *
- * Kept conservative on purpose — only a SINGLE-line block (no internal
- * paragraph) under the substantive floor, ending in `…` / `...` / `:`, so a
- * genuine multi-paragraph answer that happens to end a paragraph with a colon
- * is never mistaken for narration.
- */
-const NARRATION_TRAILER = /(?:\.{3}|…|:)\s*$/
-
-function isTrailingNarrationLine(block: string): boolean {
-  const t = block.trim()
-  if (t.length === 0 || t.length >= FLUSH_SUBSTANTIVE_MIN_CHARS) return false
-  if (t.includes('\n')) return false
-  return NARRATION_TRAILER.test(t)
-}
-
-function isNarrationBlock(block: string): boolean {
-  return NARRATION_OPENER.test(block.trimStart()) || isTrailingNarrationLine(block)
-}
+// The narration heuristic (`isNarrationBlock` / openers / trailer) and the
+// structural rule (`isStructuralNarration`) now live in the ONE shared
+// classifier `hooks/narration-classify.mjs`, imported at the top of this file
+// and by the unbundled Stop hook (`hooks/silent-end-scan.mjs`) alike — so the
+// TS gateway side and the `.mjs` side can never drift (switchroom#3513
+// correction 2; retires the old "MUST stay in sync" hand-synced copies).
 
 export type FlushDecision =
   | { kind: 'flush'; text: string }
@@ -283,6 +279,11 @@ export type FlushSkipReason =
   | 'no-inbound-chat'
   | 'empty-text'
   | 'silent-marker'
+  // A prior BACKSTOP (E2 answer-ready flush, or an out-of-process E3/E4 machine
+  // across a crash/restart) already delivered this turn's answer — the durable
+  // exactly-once-among-backstops guard (#3513 follow-up, MF2). Set by the
+  // caller, not `decideTurnFlush`.
+  | 'already-delivered'
 
 export interface FlushDecisionInput {
   /** Inbound chat the turn was servicing. `null` means system-initiated /
@@ -375,14 +376,26 @@ export function decideTurnFlush(input: FlushDecisionInput): FlushDecision {
   // sentinel — treat the whole turn as intentionally silent rather than
   // flush the prose with the sentinel glued on.
   if (endsWithSilentMarker(joined)) return { kind: 'skip', reason: 'silent-marker' }
-  // Deliver only the substantive answer block, never the whole narration+answer
-  // blob (see `selectFlushDeliveryText`). The silent-marker / empty guards above
-  // still run on the full `joined` string so a partly-silent turn is classified
-  // correctly; only the DELIVERED text is narrowed to the answer.
-  return {
-    kind: 'flush',
-    text: selectFlushDeliveryText(input.capturedText, input.capturedBlockMeta),
+  // #3513 follow-up — deterministic, model-discipline-free coalescing. The
+  // DELIVERED text is the TERMINAL RUN (the suffix of blocks NOT followed by a
+  // turn-continuing tool_use); every tool-followed block is suppressed
+  // UNCONDITIONALLY (no length/wording gate), replacing #3515's substance-gated
+  // heuristic on this backstop path. `selectBackstopDelivery` returns null when
+  // nothing terminal survives (a short tool-followed fragment) — treat that as
+  // 'empty-text' so the turn routes to the Stop-hook re-prompt ladder rather
+  // than delivering an interim narration line. The silent-marker / empty guards
+  // above still run on the full `joined` string so a partly-silent turn is
+  // classified correctly.
+  const selected = selectBackstopDelivery(
+    input.capturedText.map((text, i) => ({
+      text,
+      followedByToolUse: input.capturedBlockMeta?.[i],
+    })),
+  )
+  if (selected == null || selected.text.trim().length === 0) {
+    return { kind: 'skip', reason: 'empty-text' }
   }
+  return { kind: 'flush', text: selected.text }
 }
 
 /**