switchroom 0.18.19 → 0.18.21

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

@@ -137,6 +137,62 @@ describe('scanTurnForFinalReply — final-reply detection', () => {
     expect(r.reason).toBe('no-final-reply')
   })
 
+  it('Option A: block result carries pendingText = the undelivered answer prose (#3227)', () => {
+    // The transcript-prose bridge: a turn that ends with a substantive answer
+    // written as plain text (no reply tool) must surface that prose so the
+    // gateway can deliver it directly on the first silent-end.
+    const answer = 'That was actually your FY25 NOA, not Bloomfield. ' + 'A'.repeat(2200)
+    const text = jsonl(
+      ENQUEUE,
+      assistantToolUse('mcp__switchroom-telegram__reply', {
+        text: "On it — checking…",
+        disable_notification: true,
+      }),
+      assistantToolUse('Bash', { command: 'ls' }),
+      assistantText(answer),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('block')
+    expect(r.reason).toBe('no-final-reply')
+    expect(r.pendingText).toBe(answer)
+  })
+
+  it('Option A: zero-outbound turn with a long plain-text answer → pendingText set', () => {
+    const answer = 'Here is the whole answer the model forgot to send. ' + 'Z'.repeat(400)
+    const text = jsonl(ENQUEUE, assistantText(answer))
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('block')
+    expect(r.reason).toBe('no-final-reply')
+    expect(r.pendingText).toBe(answer)
+  })
+
+  it('Option A: trailing-text-after-reply block carries only the trailing prose (#3227)', () => {
+    const trailing = 'The real verdict the model wrote but never re-sent. ' + 'T'.repeat(400)
+    const text = jsonl(
+      ENQUEUE,
+      assistantText('some narration before the delivered answer'),
+      assistantToolUse('mcp__switchroom-telegram__reply', {
+        text: 'delivered answer, notification-bearing',
+        disable_notification: false,
+      }),
+      assistantText(trailing),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('block')
+    expect(r.reason).toBe('trailing-text-after-reply')
+    // Only the prose AFTER the last delivery event — not the pre-reply narration.
+    expect(r.pendingText).toBe(trailing)
+  })
+
+  it('Option A: a SHORT trailing/only fragment does NOT set pendingText (substance floor)', () => {
+    // A genuinely empty-ish turn: a short plain-text closer under the 200-char
+    // floor must not be re-delivered as if it were the answer.
+    const text = jsonl(ENQUEUE, assistantText('ok done, let me know if you need anything else'))
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('block')
+    expect(r.pendingText).toBeUndefined()
+  })
+
   it('notification-bearing reply → allow', () => {
     const text = jsonl(
       ENQUEUE,
@@ -322,6 +378,144 @@ it('early qualifying reply + trailing SUBSTANTIVE undelivered text (≥ floor)
   })
 })
 
+// ── Finding 2 (#3228): concatenated inter-tool narration must NOT masquerade
+//    as a final answer via the joined-prose floor ───────────────────────────
+
+describe('scanTurnForFinalReply — pendingText is a single substantive block, not joined narration (#3228 Finding 2)', () => {
+  // Each narration block is well under FINAL_ANSWER_MIN_CHARS (200) on its own.
+  // Pre-fix the scan JOINED every post-delivery text block and surfaced the
+  // join whenever the COMBINED length hit the floor — so a run of short
+  // "Let me check…" / "Still querying…" narration crossed 200 and was delivered
+  // as if it were the answer. Post-fix only a single block that clears the floor
+  // ON ITS OWN becomes pendingText.
+  const NARRATION_A = 'Let me check the first data source now — pulling the records and scanning for the relevant rows.' // ~95
+  const NARRATION_B = 'Still querying; the second source is slower than expected, so hang tight while it finishes loading.' // ~98
+  const NARRATION_C = 'Almost there, cross-referencing the last set of figures against the ledger before I summarise it.' // ~96
+
+  it('zero-delivery turn of only short narration blocks → block WITHOUT pendingText (fails on the old joined-floor code)', () => {
+    // Combined length of the three blocks is ≥ 200, so the OLD code would join
+    // them and set pendingText (masquerade). The NEW code sets nothing because
+    // no single block clears the floor.
+    expect((NARRATION_A + '\n\n' + NARRATION_B + '\n\n' + NARRATION_C).length)
+      .toBeGreaterThanOrEqual(200)
+    const text = jsonl(
+      ENQUEUE,
+      assistantText(NARRATION_A),
+      assistantToolUse('Bash', { command: 'ls' }),
+      assistantText(NARRATION_B),
+      assistantToolUse('Read', { file_path: '/tmp/x' }),
+      assistantText(NARRATION_C),
+    )
+    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()
+  })
+
+  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
+    // decision here, only pendingText; this pins the two stay consistent.)
+    const text = jsonl(
+      ENQUEUE,
+      assistantToolUse('mcp__switchroom-telegram__reply', { text: 'ok', disable_notification: false }),
+      assistantText(NARRATION_A),
+      assistantText(NARRATION_B),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('allow')
+    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.
+    const answer = 'Here is the real answer you were waiting for: ' + 'A'.repeat(300)
+    const text = jsonl(
+      ENQUEUE,
+      assistantText(answer),
+      assistantText('Let me know if you need anything else.'),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('block')
+    expect(r.pendingText).toBe(answer)
+  })
+
+  it('substance-floor boundary: a single trailing block at 199/200/201 chars', () => {
+    const at = (n: number) => {
+      const text = jsonl(ENQUEUE, assistantText('X'.repeat(n)))
+      return scanTurnForFinalReply(text)
+    }
+    // 199 → under floor, no pendingText (block still fires for the zero-delivery
+    // turn, but there is nothing substantive to deliver).
+    expect(at(199).pendingText).toBeUndefined()
+    // 200 → exactly the floor, delivered.
+    expect(at(200).pendingText).toBe('X'.repeat(200))
+    // 201 → over floor, delivered.
+    expect(at(201).pendingText).toBe('X'.repeat(201))
+  })
+})
+
+// ── Finding 3 (#3228): the block result carries a per-turn nonce (turnId) ────
+
+describe('scanTurnForFinalReply — per-turn nonce in block result (#3228 Finding 3)', () => {
+  it('block carries turnId = ${chatKey}#${messageId} derived from the enqueue envelope', () => {
+    const enq = JSON.stringify({
+      type: 'queue-operation',
+      operation: 'enqueue',
+      content: '<channel source="switchroom-telegram" chat_id="abc" message_thread_id="42" message_id="9">hi</channel>',
+    })
+    const text = jsonl(
+      enq,
+      assistantToolUse('mcp__switchroom-telegram__reply', { text: 'ack', disable_notification: true }),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('block')
+    expect(r.turnKey).toBe('abc:42')
+    // Matches gateway deriveTurnId: `${chatKey(chatId, threadId)}#${messageId}`.
+    expect(r.turnId).toBe('abc:42#9')
+  })
+
+  it("DM (no thread) still derives the turnId with the '_' sentinel", () => {
+    // ENQUEUE has chat_id="111" message_id="42", no thread.
+    const text = jsonl(
+      ENQUEUE,
+      assistantToolUse('mcp__switchroom-telegram__reply', { text: 'ack', disable_notification: true }),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.turnKey).toBe('111:_')
+    expect(r.turnId).toBe('111:_#42')
+  })
+
+  it('no derivable message_id → turnId omitted (gateway falls back to turnKey match)', () => {
+    const enq = JSON.stringify({
+      type: 'queue-operation',
+      operation: 'enqueue',
+      content: '<channel source="subagent_handback" chat_id="c7">work is done</channel>',
+    })
+    const text = jsonl(enq, assistantText('a plain-text answer never sent ' + 'Q'.repeat(300)))
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('block')
+    expect(r.turnKey).toBe('c7:_')
+    expect(r.turnId).toBeUndefined()
+  })
+
+  it('a same-suffix sibling attribute (target_message_id) does NOT leak into turnId', () => {
+    // Left-anchored match: `target_message_id` must not be mistaken for the
+    // real `message_id`. Envelope carries the sibling FIRST to prove ordering
+    // does not confuse the parser.
+    const enq = JSON.stringify({
+      type: 'queue-operation',
+      operation: 'enqueue',
+      content: '<channel source="reaction" target_message_id="777" chat_id="c" message_id="5">x</channel>',
+    })
+    const text = jsonl(enq, assistantToolUse('mcp__switchroom-telegram__reply', { text: 'ack', disable_notification: true }))
+    const r = scanTurnForFinalReply(text)
+    expect(r.turnId).toBe('c:_#5')
+  })
+})
+
 describe('scanTurnForFinalReply — silent-marker carve-out', () => {
   it('NO_REPLY → allow', () => {
     const text = jsonl(

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

@@ -9,10 +9,14 @@ import {
   readSilentEndState,
   recordSilentTurnEnd,
   recordUndeliveredTurnEnd,
+  decideCapturedProseDelivery,
+  settleCapturedProseDelivery,
+  CAPTURED_PROSE_MIN_CHARS,
   SILENT_END_MAX_RETRIES,
   SILENT_END_STALE_RECORD_MAX_AGE_MS,
 } from '../silent-end.js'
 import { isFinalAnswerReply } from '../final-answer-detect.js'
+import { OutboundDedupCache } from '../recent-outbound-dedup.js'
 
 let stateDir: string
 const ORIG_ENV = process.env.TELEGRAM_STATE_DIR
@@ -683,4 +687,296 @@ describe('silent-end-interrupt-stop hook — integration (#1775: transcript-scan
     const r = runHook({}) // serialised as `{}` — but the hook also tolerates empty
     expect(r.exit).toBe(0)
   })
+
+  // ── Option A transcript-prose bridge (#3227) — end-to-end scan → hook →
+  //    state → gateway decision. Proves the gateway would deliver the model's
+  //    real answer directly on the FIRST silent-end.
+  describe('captured-prose delivery bridge (#3227)', () => {
+    const ANSWER = 'That was actually your FY25 NOA, not Bloomfield. ' + 'A'.repeat(2200)
+
+    it('FIRST silent-end with a genuine plain-text answer → hook persists pendingText and decide → deliver', () => {
+      // A turn that ended with a substantive answer written as plain text
+      // (never sent via the reply tool). The Stop hook scans, blocks, and now
+      // persists the answer prose into silent-end-pending.json.
+      const transcript = writeTranscript([
+        ENQUEUE,
+        replyToolUse('on it — checking now', { disable_notification: true }),
+        { type: 'assistant', message: { content: [{ type: 'tool_use', name: 'Bash', input: {} }] } },
+        { type: 'assistant', message: { content: [{ type: 'text', text: ANSWER }] } },
+      ])
+      const r = runHook({ session_id: 's', transcript_path: transcript, hook_event_name: 'Stop' })
+      expect(r.exit).toBe(0)
+      expect(JSON.parse(r.stdout.trim()).decision).toBe('block')
+
+      // The bridge: the hook wrote the answer prose into the state file...
+      const state = readSilentEndState()!
+      expect(state.pendingText).toBe(ANSWER)
+      expect(state.turnKey).toBe('c:_')
+
+      // ...and the gateway's pure decision core reads it back and decides to
+      // deliver directly on this FIRST silent-end (retryCount just went to 1).
+      const decision = decideCapturedProseDelivery({ turnKey: 'c:_' })
+      expect(decision.deliver).toBe(true)
+      expect(decision.text).toBe(ANSWER)
+      expect(decision.reason).toBe('captured-prose')
+      // FIRST silent-end: this is the retry-budget's first block, not exhaustion.
+      expect(state.retryCount).toBe(1)
+    })
+
+    it('a turn that DID call a final reply → no state, no pendingText, decide → no synthetic send', () => {
+      const transcript = writeTranscript([
+        ENQUEUE,
+        replyToolUse('here is the answer, notification-bearing', { disable_notification: false }),
+      ])
+      const r = runHook({ session_id: 's', transcript_path: transcript, hook_event_name: 'Stop' })
+      expect(r.stdout.trim()).toBe('')
+      expect(readSilentEndState()).toBeNull()
+      const decision = decideCapturedProseDelivery({ turnKey: 'c:_' })
+      expect(decision.deliver).toBe(false)
+      expect(decision.reason).toBe('no-state')
+    })
+
+    it('a genuinely empty turn (no substantive prose) → hook blocks WITHOUT pendingText → decide falls through', () => {
+      // Short closer under the substance floor: not a dropped answer. The hook
+      // still blocks (re-prompt), but writes NO pendingText, so the gateway
+      // takes the existing recordUndeliveredTurnEnd / represent path unchanged.
+      const transcript = writeTranscript([
+        ENQUEUE,
+        { type: 'assistant', message: { content: [{ type: 'text', text: 'ok done' }] } },
+      ])
+      const r = runHook({ session_id: 's', transcript_path: transcript, hook_event_name: 'Stop' })
+      expect(JSON.parse(r.stdout.trim()).decision).toBe('block')
+      const state = readSilentEndState()!
+      expect(state.pendingText).toBeUndefined()
+      const decision = decideCapturedProseDelivery({ turnKey: 'c:_' })
+      expect(decision.deliver).toBe(false)
+      expect(decision.reason).toBe('no-substantive-prose')
+    })
+
+    it('a stale pendingText for a DIFFERENT turn is never delivered (turnKey guard)', () => {
+      const path = join(stateDir, 'silent-end-pending.json')
+      mkdirSync(stateDir, { recursive: true })
+      writeFileSync(path, JSON.stringify({
+        chatId: 'c', threadId: null, turnKey: 'OTHER:_',
+        retryCount: 1, timestamp: Date.now(), pendingText: ANSWER,
+      }))
+      const decision = decideCapturedProseDelivery({ turnKey: 'c:_' })
+      expect(decision.deliver).toBe(false)
+      expect(decision.reason).toBe('turnkey-mismatch')
+    })
+
+    it('double-send guard: once the captured prose is recorded in the dedup cache, a late reply-tool retry is suppressed', () => {
+      // The gateway records what it delivered in the #546 dedup cache. This is
+      // the airtight guard: the re-prompted model's reply (same answer) hits
+      // the same cache at its send site and is dropped — the represent + the
+      // captured-prose delivery are mutually exclusive by construction.
+      const dedup = new OutboundDedupCache()
+      const t0 = 1_000_000
+      // Gateway captured-prose delivery records the answer.
+      dedup.record('c', undefined, ANSWER, t0, 'reg-1')
+      // Model re-prompt then calls reply with the same answer moments later.
+      const hit = dedup.check('c', undefined, ANSWER, t0 + 5_000, 'reg-1')
+      expect(hit).not.toBeNull()
+      // A genuinely different later answer is NOT suppressed.
+      const miss = dedup.check('c', undefined, 'a completely different answer ' + 'X'.repeat(50), t0 + 5_000, 'reg-1')
+      expect(miss).toBeNull()
+    })
+
+    it('CAPTURED_PROSE_MIN_CHARS matches the scan/final-answer substance floor', () => {
+      expect(CAPTURED_PROSE_MIN_CHARS).toBe(200)
+    })
+  })
+})
+
+// ── Finding 3 (#3228): per-turn nonce guards decideCapturedProseDelivery ─────
+
+describe('decideCapturedProseDelivery — per-turn nonce (turnId) guard (#3228 Finding 3)', () => {
+  const ANSWER = 'A recovered final answer written as plain text. ' + 'A'.repeat(300)
+  const statePath = () => join(stateDir, 'silent-end-pending.json')
+  function writeState(partial: Record<string, unknown>) {
+    mkdirSync(stateDir, { recursive: true })
+    writeFileSync(statePath(), JSON.stringify({
+      chatId: 'c', threadId: null, turnKey: 'c:_', retryCount: 1, timestamp: Date.now(),
+      pendingText: ANSWER, ...partial,
+    }))
+  }
+
+  it('turnKey matches AND turnId matches → deliver', () => {
+    writeState({ turnId: 'c:_#100' })
+    const d = decideCapturedProseDelivery({ turnKey: 'c:_', turnId: 'c:_#100' })
+    expect(d.deliver).toBe(true)
+    expect(d.text).toBe(ANSWER)
+    expect(d.reason).toBe('captured-prose')
+  })
+
+  it('STALE record: same chat turnKey but a DIFFERENT turnId → NOT delivered (the carryover the finding describes)', () => {
+    // Turn A wrote pendingText+turnId=A. Turn B (same chat → same turnKey)
+    // ends in reprompt with its OWN turnId=B. The stale answer must not deliver.
+    writeState({ turnId: 'c:_#AAA' }) // turn A's record survived (hook overwrite bypassed)
+    const d = decideCapturedProseDelivery({ turnKey: 'c:_', turnId: 'c:_#BBB' })
+    expect(d.deliver).toBe(false)
+    expect(d.reason).toBe('turnid-mismatch')
+  })
+
+  it('record has NO turnId (synthetic inbound) → falls back to turnKey match, delivers', () => {
+    writeState({}) // no turnId field
+    const d = decideCapturedProseDelivery({ turnKey: 'c:_', turnId: 'c:_#123' })
+    expect(d.deliver).toBe(true)
+    expect(d.reason).toBe('captured-prose')
+  })
+
+  it('caller passes no turnId → falls back to turnKey match, delivers (never suppress on doubt)', () => {
+    writeState({ turnId: 'c:_#100' })
+    const d = decideCapturedProseDelivery({ turnKey: 'c:_' })
+    expect(d.deliver).toBe(true)
+    expect(d.reason).toBe('captured-prose')
+  })
+
+  it('substance-floor boundary at 199/200/201 (min-chars gate is unchanged by the nonce)', () => {
+    const check = (n: number) => {
+      writeState({ turnId: 'c:_#100', pendingText: 'X'.repeat(n) })
+      return decideCapturedProseDelivery({ turnKey: 'c:_', turnId: 'c:_#100' })
+    }
+    expect(check(199).deliver).toBe(false)
+    expect(check(199).reason).toBe('no-substantive-prose')
+    expect(check(200).deliver).toBe(true)
+    expect(check(201).deliver).toBe(true)
+  })
+})
+
+// ── Finding 1 (#3228): captured-prose send-failure arms the recovery net ─────
+
+describe('settleCapturedProseDelivery — send-failure posture (#3228 Finding 1)', () => {
+  function spies(exhausted = false) {
+    const calls = { close: 0, clear: 0, undelivered: 0 }
+    const effects = {
+      closeObligation: () => { calls.close++ },
+      clearState: () => { calls.clear++ },
+      recordUndelivered: () => { calls.undelivered++; return { exhausted } },
+    }
+    return { calls, effects }
+  }
+
+  it("outcome 'failed' → arms the Stop-hook re-prompt net; does NOT close obligation or clear state", () => {
+    // THIS is the regression fix: in the interim-ack case the shared teardown
+    // has already closed the obligation (replyCalled=true), so "leave it open"
+    // is a myth — the net MUST be recordUndelivered. A pre-fix deliverCapturedProse
+    // catch that merely `return`ed (no recordUndelivered) would leave calls
+    // all-zero here → the answer is permanently lost.
+    const { calls, effects } = spies()
+    const r = settleCapturedProseDelivery('failed', effects)
+    expect(calls.undelivered).toBe(1)
+    expect(calls.close).toBe(0)
+    expect(calls.clear).toBe(0)
+    expect(r.exhausted).toBe(false)
+  })
+
+  it("outcome 'failed' with budget SPENT → threads exhausted:true out so the caller can fire the fallback (#3228 exhaustion-boundary)", () => {
+    // The exhaustion-boundary gap: recordUndeliveredTurnEnd took its exhausted
+    // branch (cleared state, returned exhausted:true). The settlement MUST
+    // surface that so the gateway delivers the plain-text/apology fallback —
+    // the obligation was already closed by the interim-ack teardown, so the
+    // re-prompt is gone AND the represent is gone. Pre-fix the return type was
+    // void, so this signal could not exist and the fallback never fired.
+    const { calls, effects } = spies(true)
+    const r = settleCapturedProseDelivery('failed', effects)
+    expect(calls.undelivered).toBe(1)
+    expect(r.exhausted).toBe(true)
+  })
+
+  it("outcome 'sent' → closes obligation + clears state; does NOT re-arm the re-prompt; exhausted:false", () => {
+    const { calls, effects } = spies()
+    const r = settleCapturedProseDelivery('sent', effects)
+    expect(calls.close).toBe(1)
+    expect(calls.clear).toBe(1)
+    expect(calls.undelivered).toBe(0)
+    expect(r.exhausted).toBe(false)
+  })
+
+  it("outcome 'skipped-dedup' → closes obligation + clears state (answer already went out); exhausted:false", () => {
+    const { calls, effects } = spies()
+    const r = settleCapturedProseDelivery('skipped-dedup', effects)
+    expect(calls.close).toBe(1)
+    expect(calls.clear).toBe(1)
+    expect(calls.undelivered).toBe(0)
+    expect(r.exhausted).toBe(false)
+  })
+
+  it('end-to-end failure net (budget remaining): a failed send leaves an undelivered-turn record armed, exhausted:false', () => {
+    // Simulate the gateway's `failed` settlement wiring against the REAL
+    // recordUndeliveredTurnEnd effect. The interim-ack teardown already closed
+    // the obligation; only the silent-end state can recover the turn now.
+    expect(readSilentEndState()).toBeNull()
+    const r = settleCapturedProseDelivery('failed', {
+      closeObligation: () => { throw new Error('must not be called on failure') },
+      clearState: () => { throw new Error('must not be called on failure') },
+      recordUndelivered: () =>
+        recordUndeliveredTurnEnd({ chatId: 'c', threadId: null, turnKey: 'c:_' }),
+    })
+    // The recovery net is armed: the Stop hook will find this and re-prompt.
+    expect(readSilentEndState()).toMatchObject({ turnKey: 'c:_' })
+    expect(r.exhausted).toBe(false)
+  })
+
+  it('end-to-end exhaustion boundary: a failed send AT the retry cap returns exhausted:true and clears state (the gateway must then fire the fallback)', () => {
+    // On-disk record already at the cap (the Stop hook blocked twice; the
+    // re-prompted turn's captured-prose send is now THROWING). The REAL
+    // recordUndeliveredTurnEnd takes its exhausted branch: clears state,
+    // returns exhausted:true. Pin that the settlement surfaces it — this is the
+    // signal the gateway uses to fire the plain-text/apology fallback so the
+    // user is never left with neither the answer nor the apology.
+    const path = join(stateDir, 'silent-end-pending.json')
+    mkdirSync(stateDir, { recursive: true })
+    writeFileSync(path, JSON.stringify({
+      chatId: 'c', threadId: null, turnKey: 'c:_',
+      retryCount: SILENT_END_MAX_RETRIES, timestamp: Date.now(),
+    }))
+    const r = settleCapturedProseDelivery('failed', {
+      closeObligation: () => { throw new Error('must not be called on failure') },
+      clearState: () => { throw new Error('must not be called on failure') },
+      recordUndelivered: () =>
+        recordUndeliveredTurnEnd({ chatId: 'c', threadId: null, turnKey: 'c:_' }),
+    })
+    expect(r.exhausted).toBe(true)
+    // recordUndeliveredTurnEnd's exhausted branch cleared the state — the
+    // Stop-hook re-prompt can no longer recover, so the caller owns delivery.
+    expect(readSilentEndState()).toBeNull()
+  })
+})
+
+// ── Finding 4/5 (#3228): honest documentation of the dedup divergence boundary ─
+
+describe('recent-outbound-dedup — divergent-content double-send boundary (#3228 Finding 4/5)', () => {
+  it('divergent reply text vs captured prose under a different registryKey → NOT deduped (a real double-send vector)', () => {
+    // Documents the boundary the "airtight by construction" claim overstated:
+    // captured-prose records content C under registryKey K1. A re-present that
+    // lands REWORDED content C' under a DIFFERENT registryKey K2 has both a
+    // different hash AND a different turnKey — the cross-turn carve-out treats
+    // it as a miss, so it is NOT suppressed. Content-hash dedup cannot catch a
+    // divergent-content re-send; the obligation close + state clear are what
+    // make them mutually exclusive for the common case.
+    const dedup = new OutboundDedupCache()
+    const t0 = 1_000_000
+    const proseAnswer = 'The answer is 42, computed from the ledger. ' + 'A'.repeat(60)
+    dedup.record('c', undefined, proseAnswer, t0, 'reg-1')
+
+    // Same content, same key → suppressed (the common double-send).
+    expect(dedup.check('c', undefined, proseAnswer, t0 + 1_000, 'reg-1')).not.toBeNull()
+
+    // Reworded content under a different registryKey → NOT suppressed.
+    const reworded = 'To answer your question: it is 42 (per the ledger). ' + 'B'.repeat(60)
+    expect(dedup.check('c', undefined, reworded, t0 + 1_000, 'reg-2')).toBeNull()
+  })
+
+  it('identical content under two DIFFERENT non-null turnKeys → miss (cross-turn carve-out, documented boundary)', () => {
+    const dedup = new OutboundDedupCache()
+    const t0 = 2_000_000
+    const content = 'Identical answer text delivered in two separate turns. ' + 'C'.repeat(60)
+    dedup.record('c', undefined, content, t0, 'turnA')
+    // A later, genuinely different turn re-sending the SAME text is NOT a #546
+    // within-turn retry → not suppressed.
+    expect(dedup.check('c', undefined, content, t0 + 1_000, 'turnB')).toBeNull()
+    // But the SAME turnKey (a true within-turn retry) IS suppressed.
+    expect(dedup.check('c', undefined, content, t0 + 1_000, 'turnA')).not.toBeNull()
+  })
 })

package/telegram-plugin/tests/stream-reply-handler.test.ts

@@ -120,12 +120,13 @@ describe('handleStreamReply', () => {
     expect(bot.api.sendMessage.mock.calls[0][2]?.parse_mode).toBeUndefined()
   })
 
-  it('rich path sends the multi-paragraph `\\n\\n` gap byte-exact (no NBSP spacer)', async () => {
-    // The NBSP paragraph-spacer pass was removed in the #2669 follow-up — the
-    // rich renderer shows a plain `\n\n` gap as one blank line, so the handler
-    // passes the text through unchanged.
+  it('applies addParagraphSpacers on the rich path (multi-paragraph gap spaced)', async () => {
     const state = makeState()
-    const deps = makeDeps(bot)
+    // Spacer dep replaces every `\n\n` gap with a visible marker so we can
+    // assert the rich path ran it (mirrors the real gateway wiring).
+    const deps = makeDeps(bot, {
+      addParagraphSpacers: (t) => t.replace(/\n\n/g, '\n\nSPACER\n\n'),
+    })
 
     const pending = handleStreamReply(
       { chat_id: '1', text: 'Para one.\n\nPara two.', done: true },
@@ -136,13 +137,14 @@ describe('handleStreamReply', () => {
     await pending
 
     expect(bot.api.sendRichMessage).toHaveBeenCalledTimes(1)
-    expect(richSendMarkdown(bot)).toBe('Para one.\n\nPara two.')
-    expect(richSendMarkdown(bot)).not.toContain(String.fromCharCode(0xa0))
+    expect(richSendMarkdown(bot)).toBe('Para one.\n\nSPACER\n\nPara two.')
   })
 
-  it('literal format=text path is byte-exact too', async () => {
+  it('does NOT apply addParagraphSpacers on the literal format=text path', async () => {
     const state = makeState()
-    const deps = makeDeps(bot)
+    const deps = makeDeps(bot, {
+      addParagraphSpacers: (t) => t.replace(/\n\n/g, '\n\nSPACER\n\n'),
+    })
 
     const pending = handleStreamReply(
       { chat_id: '1', text: 'Para one.\n\nPara two.', format: 'text', done: true },
@@ -153,6 +155,7 @@ describe('handleStreamReply', () => {
     await pending
 
     expect(bot.api.sendMessage).toHaveBeenCalledTimes(1)
+    // Literal path is byte-exact — no spacer injected.
     expect(bot.api.sendMessage.mock.calls[0][1]).toBe('Para one.\n\nPara two.')
   })
 

package/telegram-plugin/tests/subagent-progress-inbound-builder.test.ts

@@ -264,6 +264,36 @@ describe('decideSubagentProgress', () => {
     if (!d.deliver) expect(d.reason).toBe('foreground')
   })
 
+  // #3233 — worker-feed-DISABLED legacy path: a contentless skeleton liveness
+  // cue must NOT be relayed as a synthesized "still working" inbound (that
+  // would be a blank card). It degrades to a no-op, deterministically, BEFORE
+  // bucketing so it can never advance the bucket tracker.
+  it('skeleton liveness cue is dropped (no blank card) even when every other gate would pass', () => {
+    // Same input that DELIVERS in the happy-path test above (bucket 1, chat
+    // resolves) — only `skeleton` flips it off. Empty summary mirrors the real
+    // skeleton cue.
+    const d = decideSubagentProgress(baseInput({ skeleton: true, latestSummary: '' }))
+    expect(d.deliver).toBe(false)
+    if (!d.deliver) expect(d.reason).toBe('skeleton-liveness')
+  })
+
+  it('skeleton suppression fires before bucketing — a background skeleton at bucket>=1 never delivers', () => {
+    // ≤1 relay per interval is trivially satisfied: skeleton cues deliver ZERO
+    // inbounds regardless of how many no-growth polls fire within a bucket.
+    for (const elapsedMs of [7 * 60 * 1000, 8 * 60 * 1000, 9 * 60 * 1000]) {
+      const d = decideSubagentProgress(baseInput({ skeleton: true, latestSummary: '', elapsedMs }))
+      expect(d.deliver, `elapsedMs=${elapsedMs}`).toBe(false)
+    }
+  })
+
+  it('a NON-skeleton cue with identical inputs still delivers (guard is skeleton-scoped, not summary-scoped)', () => {
+    // Red-on-regression companion: proves the drop keys on `skeleton`, not on
+    // the empty summary — a real tool-only cue (empty prose summary) still
+    // delivers, so the guard cannot silently swallow genuine progress.
+    const d = decideSubagentProgress(baseInput({ skeleton: false, latestSummary: '' }))
+    expect(d.deliver).toBe(true)
+  })
+
   it('falls back to owner chat when fleet chat is empty', () => {
     const d = decideSubagentProgress(baseInput({ fleetChatId: '' }))
     expect(d.deliver).toBe(true)