switchroom 0.19.4 → 0.19.6

package/telegram-plugin/tests/send-reply-golden.test.ts

@@ -46,6 +46,8 @@ import {
 } from '../gateway/outbound-send-path.js'
 import { OutboundDedupCache } from '../recent-outbound-dedup.js'
 import { FlushedTurnSupersedeRegistry } from '../flushed-turn-supersede.js'
+import { SubagentHandbackMarker } from '../gateway/subagent-handback-marker.js'
+import { createPendingInboundBuffer } from '../gateway/pending-inbound-buffer.js'
 import { redact } from '../secret-detect/redact.js'
 import type { CurrentTurn, Access } from '../gateway/gateway.js'
 
@@ -209,7 +211,8 @@ function makeHarness(opts?: {
     assertSendable: () => {},
     statusKey: key,
     streamKey: key,
-    resolveReplyOwnerTurn: () => null,
+    resolveReplyOwnerTurn: () => ({ turn: null, tier: 'none' as const }),
+    getLastSubagentHandbackAt: () => null,
     findTurnByOriginId: () => null,
     findTurnByQuotedMessageId: () => null,
     resolveAnswerThreadWithLog: (_c, explicit) => explicit,
@@ -633,8 +636,11 @@ describe('#3429 — post-turn-end handback vs flush-delivered supersede (real se
       Date.now(),
     )
     // The late reply resolves the ENDED flush-delivered turn as its owner
-    // (latest-ended tier — no live turn, no origin echo, no quote in a DM).
-    h.deps.resolveReplyOwnerTurn = () => owner
+    // (latest-ended tier — no live turn, no origin echo, no quote in a DM). This
+    // is the AMBIGUOUS fallback tier: the content gate applies here, so a
+    // genuinely-new handback sends fresh while the turn's own contained answer
+    // still supersedes.
+    h.deps.resolveReplyOwnerTurn = () => ({ turn: owner, tier: 'latest-ended' })
   }
 
   it('CORE REGRESSION (red pre-fix): a handback with genuinely NEW content sends a ' +
@@ -642,6 +648,11 @@ describe('#3429 — post-turn-end handback vs flush-delivered supersede (real se
     const h = makeHarness()
     const owner = makeFlushDeliveredEndedTurn()
     seedFlushRecord(h, owner)
+    // A background sub-agent handback WAS enqueued for this chat after the
+    // flushed turn ended and within the supersede TTL — so this late reply might
+    // BE that handback. The marker keeps the #3429 content gate. (owner.endedAt
+    // = now-30s; handback at now-15s is after it and within the 60s TTL.)
+    h.deps.getLastSubagentHandbackAt = () => Date.now() - 15_000
 
     // The handback lands LATE: req.turn = null (no live gateway turn — a
     // sub-agent completion is not a new inbound).
@@ -700,8 +711,8 @@ describe('#3429 — post-turn-end handback vs flush-delivered supersede (real se
     const h = makeHarness()
     const owner = makeFlushDeliveredEndedTurn()
     // NO registry record (the post-fire pre-record window); owner resolution
-    // still recovers the ended flush-armed turn.
-    h.deps.resolveReplyOwnerTurn = () => owner
+    // still recovers the ended flush-armed turn via the latest-ended tier.
+    h.deps.resolveReplyOwnerTurn = () => ({ turn: owner, tier: 'latest-ended' })
 
     const res = await sendReply(h.deps, req(HANDBACK))
 
@@ -715,11 +726,215 @@ describe('#3429 — post-turn-end handback vs flush-delivered supersede (real se
     'window is still suppressed (the #2996 Part 2 backstop holds)', async () => {
     const h = makeHarness()
     const owner = makeFlushDeliveredEndedTurn()
-    h.deps.resolveReplyOwnerTurn = () => owner
+    h.deps.resolveReplyOwnerTurn = () => ({ turn: owner, tier: 'latest-ended' })
 
     const res = await sendReply(h.deps, req(FLUSHED_TEXT))
 
     expect(h.calls).toHaveLength(0) // nothing sent, nothing edited
     expect(res.content[0]!.text).toContain('deduped')
   })
+
+  // ─── The REAL marko DM incident (fix/backstop-duplicate-reply) ───
+  //
+  // The dominant real duplicate: the model narrates its answer as prose (flushed
+  // as message A), then fires the `reply` tool with a RE-WORDED version of the
+  // same answer. On a DM this late reply has NO live turn, NO `origin_turn_id`
+  // echo, and NO explicit `reply_to`, so it resolves its owner via the ambiguous
+  // `latest-ended` tier — the #3429 content gate then declines (reworded text ⊄
+  // flushed blob) and a fresh SECOND bubble ships = the visible duplicate
+  // (agent:marko 2026-07-20: turns #1177/#1182/#1201 double-sent; 11/11 declines
+  // were own-replies with NO handback in flight).
+  //
+  // The two cases are indistinguishable by tier (both latest-ended) and by
+  // content (rewording). The deterministic discriminator is the gateway-
+  // synthesized `subagent_handback` marker: case A has NONE enqueued after the
+  // flushed turn ended; a genuine background handback (case B) does. These two
+  // tests drive the REAL send path with the REAL supersede registry over the
+  // SAME reworded text and the SAME latest-ended tier, differing ONLY in the
+  // handback marker — proving it is the marker that flips the outcome.
+  const REWORDED_SAME_TURN_ANSWER =
+    'Good news on the fleet: every one of the twelve agents is running fine right now. ' +
+    'The gateway, the vault broker and the approval kernel are all green, and nothing has ' +
+    'restarted in the past day — so there is nothing you need to do.'
+
+  function seedRecord(h: ReturnType<typeof makeHarness>, owner: CurrentTurn): void {
+    h.deps.flushedTurnSupersede.record(
+      CHAT,
+      undefined,
+      { turnId: owner.turnId, messageIds: [FLUSH_MSG_ID], text: FLUSHED_TEXT },
+      Date.now(),
+    )
+  }
+
+  it('CASE A — REAL marko DM incident: reworded own reply, latest-ended tier, ' +
+    'NO handback in flight → supersedes the flushed draft, collapses to ONE message', async () => {
+    const h = makeHarness()
+    const owner = makeFlushDeliveredEndedTurn()
+    seedRecord(h, owner)
+    // Late DM reply: latest-ended tier (the path the tier discriminator MISSES),
+    // and crucially NO subagent_handback was enqueued for this chat after the
+    // turn ended — so the reply is the flushed turn's OWN answer.
+    h.deps.resolveReplyOwnerTurn = () => ({ turn: owner, tier: 'latest-ended' })
+    h.deps.getLastSubagentHandbackAt = () => null
+
+    const res = await sendReply(h.deps, req(REWORDED_SAME_TURN_ANSWER))
+
+    // Exactly ONE client-visible message: the flushed message edited in place
+    // into the reworded reply — NO fresh second bubble (duplicate closed).
+    const edits = h.calls.filter((c) => c.method === 'editMessageText')
+    expect(edits).toHaveLength(1)
+    expect(edits[0]!.message_id).toBe(FLUSH_MSG_ID)
+    expect(edits[0]!.text).toContain('every one of the twelve agents')
+    expect(h.calls.filter((c) => c.method === 'sendRichMessage')).toHaveLength(0)
+    expect(res.content[0]!.text).toMatch(/^sent/)
+    // Record consumed.
+    expect(
+      h.deps.flushedTurnSupersede.peek(CHAT, undefined, {
+        liveTurnId: OWNER_TURN_ID,
+        now: Date.now(),
+      }).reason,
+    ).toBe('no-record')
+  })
+
+  it('CASE B — genuine background handback: SAME reworded text, SAME latest-ended tier, ' +
+    'but a handback WAS enqueued in-window → keeps the gate, sends FRESH (TWO messages)', async () => {
+    const h = makeHarness()
+    const owner = makeFlushDeliveredEndedTurn()
+    seedRecord(h, owner)
+    h.deps.resolveReplyOwnerTurn = () => ({ turn: owner, tier: 'latest-ended' })
+    // A background sub-agent handback was enqueued for this chat AFTER the turn
+    // ended (now-30s) and within the 60s TTL (now-15s) — this reply might BE it.
+    h.deps.getLastSubagentHandbackAt = () => Date.now() - 15_000
+
+    const res = await sendReply(h.deps, req(REWORDED_SAME_TURN_ANSWER))
+
+    // A fresh notifying bubble ships; the flushed message is NEITHER edited nor
+    // deleted — flush (A) + fresh (B) = two surfaced messages (#3429 preserved).
+    const fresh = h.calls.filter((c) => c.method === 'sendRichMessage')
+    expect(fresh).toHaveLength(1)
+    expect(fresh[0]!.message_id).not.toBe(FLUSH_MSG_ID)
+    expect(h.calls.filter((c) => c.method === 'editMessageText')).toHaveLength(0)
+    expect(h.calls.filter((c) => c.method === 'deleteMessage')).toHaveLength(0)
+    expect(res.content[0]!.text).toMatch(/^sent \(id: \d+\)$/)
+    // Record NOT consumed.
+    expect(
+      h.deps.flushedTurnSupersede.peek(CHAT, undefined, {
+        liveTurnId: OWNER_TURN_ID,
+        replyText: CANONICAL_REPLY,
+        now: Date.now(),
+      }).supersede,
+    ).toBe(true)
+  })
+
+  it('MUST-FIX 1 (silent-data-loss): a handback reply model-STEERED to the quoted ' +
+    'tier (reply_to = the flushed turn\'s source msg) must NOT edit/delete the flushed ' +
+    'answer while a handback is in flight — sends FRESH (two messages)', async () => {
+    const h = makeHarness()
+    const owner = makeFlushDeliveredEndedTurn()
+    seedRecord(h, owner)
+    // The `quoted` tier is derived from the MODEL-SUPPLIED `args.reply_to`, so a
+    // background handback turn can point reply_to at the user's original message
+    // (which the prior turn's flush is recorded against) to resolve THAT turn via
+    // `quoted`. A handback IS in flight, so a positive tier must NOT override the
+    // #3429 content gate — else the reworded handback text silently edits over
+    // the flushed turn's DELIVERED answer (Telegram edits don't re-notify).
+    h.deps.resolveReplyOwnerTurn = () => ({ turn: owner, tier: 'quoted' })
+    h.deps.getLastSubagentHandbackAt = () => Date.now() - 15_000
+
+    const res = await sendReply(h.deps, req(REWORDED_SAME_TURN_ANSWER))
+
+    // Fresh notifying send; the flushed answer is NEITHER edited nor deleted.
+    const fresh = h.calls.filter((c) => c.method === 'sendRichMessage')
+    expect(fresh).toHaveLength(1)
+    expect(fresh[0]!.message_id).not.toBe(FLUSH_MSG_ID)
+    expect(h.calls.filter((c) => c.method === 'editMessageText')).toHaveLength(0)
+    expect(h.calls.filter((c) => c.method === 'deleteMessage')).toHaveLength(0)
+    expect(res.content[0]!.text).toMatch(/^sent \(id: \d+\)$/)
+    // Flush record NOT consumed — the flushed answer stands.
+    expect(
+      h.deps.flushedTurnSupersede.peek(CHAT, undefined, {
+        liveTurnId: OWNER_TURN_ID,
+        replyText: CANONICAL_REPLY,
+        now: Date.now(),
+      }).supersede,
+    ).toBe(true)
+  })
+
+  it('the framework-owned `live` tier MAY still bypass a handback window (a live ' +
+    'currentTurn is not model-derived and cannot collide with an ended turn\'s record)', async () => {
+    const h = makeHarness()
+    const owner = makeFlushDeliveredEndedTurn()
+    seedRecord(h, owner)
+    h.deps.resolveReplyOwnerTurn = () => ({ turn: owner, tier: 'live' })
+    h.deps.getLastSubagentHandbackAt = () => Date.now() - 15_000
+
+    const res = await sendReply(h.deps, req(REWORDED_SAME_TURN_ANSWER))
+
+    // Live tier bypasses → supersede via edit-in-place (one message).
+    const edits = h.calls.filter((c) => c.method === 'editMessageText')
+    expect(edits).toHaveLength(1)
+    expect(edits[0]!.message_id).toBe(FLUSH_MSG_ID)
+    expect(h.calls.filter((c) => c.method === 'sendRichMessage')).toHaveLength(0)
+    expect(res.content[0]!.text).toMatch(/^sent/)
+  })
+
+  it('MUST-FIX 2 (boot-replay): a handback re-pushed through the buffer chokepoint ' +
+    'stamps the marker (with the envelope ts) → gate preserved → FRESH send, no silent edit', async () => {
+    // Real marker + real buffer wired exactly as the gateway wires them. The
+    // boot-replay loop re-pushes un-acked spooled inbounds — including handback
+    // envelopes — through this SAME push(); the chokepoint stamp is what makes a
+    // replayed handback populate the (post-restart empty) marker.
+    const marker = new SubagentHandbackMarker()
+    const buffer = createPendingInboundBuffer({
+      log: () => {},
+      onHandbackEnqueue: (chatId, ts) => marker.record(chatId, ts),
+    })
+
+    // Simulate the boot-replay re-push of an un-acked spooled handback envelope.
+    // The envelope carries its own ms `ts` (after the flushed turn ended, within
+    // TTL) — owner.endedAt below is now-30s, this handback is now-15s.
+    const handbackTs = Date.now() - 15_000
+    buffer.push('marko', {
+      type: 'inbound',
+      chatId: CHAT,
+      messageId: handbackTs,
+      user: 'subagent-watcher',
+      userId: 0,
+      ts: handbackTs,
+      text: 'handback result',
+      meta: { source: 'subagent_handback' },
+    })
+    // The chokepoint stamped the marker from the replay push (pre-fix: empty).
+    expect(marker.lastAt(CHAT)).toBe(handbackTs)
+
+    const h = makeHarness()
+    const owner = makeFlushDeliveredEndedTurn()
+    seedRecord(h, owner)
+    h.deps.resolveReplyOwnerTurn = () => ({ turn: owner, tier: 'latest-ended' })
+    // The gateway reads the marker the boot-replay stamped.
+    h.deps.getLastSubagentHandbackAt = (chatId) => marker.lastAt(chatId)
+
+    const res = await sendReply(h.deps, req(HANDBACK))
+
+    // Gate preserved → the replayed handback delivers FRESH; the post-boot
+    // flushed answer is NEITHER edited nor deleted (no silent #3429 on restart).
+    const fresh = h.calls.filter((c) => c.method === 'sendRichMessage')
+    expect(fresh).toHaveLength(1)
+    expect(h.calls.filter((c) => c.method === 'editMessageText')).toHaveLength(0)
+    expect(h.calls.filter((c) => c.method === 'deleteMessage')).toHaveLength(0)
+    expect(res.content[0]!.text).toMatch(/^sent \(id: \d+\)$/)
+  })
+
+  it('the buffer chokepoint stamps ONLY handback envelopes (a normal inbound does not)', () => {
+    const marker = new SubagentHandbackMarker()
+    const buffer = createPendingInboundBuffer({
+      log: () => {},
+      onHandbackEnqueue: (chatId, ts) => marker.record(chatId, ts),
+    })
+    buffer.push('marko', {
+      type: 'inbound', chatId: CHAT, messageId: 5, user: 'ken', userId: 1,
+      ts: Date.now(), text: 'hi', meta: {},
+    })
+    expect(marker.lastAt(CHAT)).toBe(null)
+  })
 })

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

@@ -296,4 +296,67 @@ describe('silent-end-interrupt-stop.mjs — integration', () => {
     expect(r.status).toBe(0)
     expect(r.stdout.trim()).toBe('')
   })
+
+  // ── Single-writer election (duplicate-message fix) ─────────────────
+  describe('single-writer election end-to-end', () => {
+    function writeFreshHeartbeat() {
+      writeFileSync(join(stateDir, 'gateway-heartbeat'), String(Date.now()), 'utf8')
+    }
+
+    it('zero-reply ≥200 + FRESH gateway heartbeat → ALLOW (no block re-prompt), state file still written for the flush', () => {
+      // The duplicate repro: today this BLOCKS *and* the gateway flush fires →
+      // two messages. With a fresh heartbeat the election ALLOWS the stop so
+      // the gateway flush is the single writer.
+      writeFreshHeartbeat()
+      const transcript = writeTranscript(tmp, [
+        ENQUEUE,
+        { type: 'assistant', message: { content: [{ type: 'text', text: 'A'.repeat(300) }] } },
+      ])
+      const r = runHook({ event: { session_id: 's1', transcript_path: transcript }, stateDir })
+      expect(r.status).toBe(0)
+      // ALLOW → no block JSON on stdout.
+      expect(r.stdout.trim()).toBe('')
+      expect(r.stderr).toMatch(/single-writer election ALLOWED/)
+      // State file IS written so the gateway's captured-prose bridge has its
+      // input (turnKey/turnId/pendingText); retryCount stays 0 (not a re-prompt).
+      const statePath = join(stateDir, 'silent-end-pending.json')
+      expect(existsSync(statePath)).toBe(true)
+      const state = JSON.parse(readFileSync(statePath, 'utf8'))
+      expect(state.retryCount).toBe(0)
+      expect(state.turnKey).toBe('111:_')
+      expect(state.pendingText).toBe('A'.repeat(300))
+    })
+
+    it('zero-reply ≥200 + STALE/missing heartbeat → BLOCK (never allow into a possibly-dead gateway)', () => {
+      // No heartbeat file → the liveness gate forces today's BLOCK behaviour.
+      const transcript = writeTranscript(tmp, [
+        ENQUEUE,
+        { type: 'assistant', message: { content: [{ type: 'text', text: 'A'.repeat(300) }] } },
+      ])
+      const r = runHook({ event: { session_id: 's1', transcript_path: transcript }, stateDir })
+      expect(r.status).toBe(0)
+      expect(JSON.parse(r.stdout).decision).toBe('block')
+      const state = JSON.parse(readFileSync(join(stateDir, 'silent-end-pending.json'), 'utf8'))
+      expect(state.retryCount).toBe(1)
+    })
+
+    it('retryCount>0 (prior failed delivery) + fresh heartbeat → BLOCK (preserve #3228 send-failure net)', () => {
+      writeFreshHeartbeat()
+      // Seed a prior state file with retryCount=1 (a delivery already failed).
+      writeFileSync(
+        join(stateDir, 'silent-end-pending.json'),
+        JSON.stringify({ chatId: '111', threadId: null, turnKey: '111:_', retryCount: 1, timestamp: Date.now() }),
+        'utf8',
+      )
+      const transcript = writeTranscript(tmp, [
+        ENQUEUE,
+        { type: 'assistant', message: { content: [{ type: 'text', text: 'A'.repeat(300) }] } },
+      ])
+      const r = runHook({ event: { session_id: 's1', transcript_path: transcript }, stateDir })
+      expect(r.status).toBe(0)
+      // retryCount was 1 → not the exhaustion boundary (MAX=2) → still blocks,
+      // and the election does NOT allow (retry-ladder-in-flight).
+      expect(JSON.parse(r.stdout).decision).toBe('block')
+    })
+  })
 })

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

@@ -184,13 +184,20 @@ describe('scanTurnForFinalReply — final-reply detection', () => {
     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'))
+  it('Option A: a SHORT single trailing fragment (zero-reply) IS persisted for the lowered-floor corner', () => {
+    // Post duplicate-message fix: a single short plain-text block in the
+    // ZERO-reply case is the real short-answer shape, so the scan persists it
+    // as pendingText for the capture-divergence corner (gateway captured empty →
+    // the bridge delivers with a lowered floor). Under the gateway's DEFAULT
+    // 200-char floor it is still NOT delivered, so the substance guard holds at
+    // the delivery layer.
+    const short = 'ok done, let me know if you need anything else'
+    const text = jsonl(ENQUEUE, assistantText(short))
     const r = scanTurnForFinalReply(text)
     expect(r.decided).toBe('block')
-    expect(r.pendingText).toBeUndefined()
+    expect(r.reason).toBe('no-final-reply')
+    expect(r.pendingText).toBe(short)
+    expect(r.hasTrailingProse).toBe(true)
   })
 
   it('notification-bearing reply → allow', () => {
@@ -388,14 +395,19 @@ describe('scanTurnForFinalReply — pendingText is a single substantive block, n
   // "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.
+  // Genuinely-narration blocks: each matches the opener/trailer heuristic
+  // (`isNarrationBlock`) the flush's `selectFlushDeliveryText` uses, so a pure
+  // run of them is delivered as NOTHING by the flush — and the scan must agree
+  // (no pendingText) so the capture-divergence bridge never masquerades a
+  // narration run as an answer (#3228 Finding 2).
+  const NARRATION_A = 'Let me check the first data source now, pulling the records and scanning the rows…' // opener + …
+  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.
     expect((NARRATION_A + '\n\n' + NARRATION_B + '\n\n' + NARRATION_C).length)
       .toBeGreaterThanOrEqual(200)
     const text = jsonl(
@@ -413,6 +425,35 @@ describe('scanTurnForFinalReply — pendingText is a single substantive block, n
     expect(r.pendingText).toBeUndefined()
   })
 
+  it('zero-delivery turn of MULTIPLE sub-200 REAL-CONTENT blocks → JOINED pendingText (review item 3 drop fix)', () => {
+    // A real answer split as two ~150-char paragraphs, each individually under
+    // the 200-char substance floor. Pre-fix the scan set NO pendingText — and in
+    // the capture-divergence-empty corner (gateway captured nothing → flush
+    // skips 'empty-text') the bridge then had nothing to deliver and the hook
+    // had already allowed the stop → DROPPED ANSWER. Post-fix the scan mirrors
+    // the flush's join so the bridge delivers the joined prose.
+    const PARA_1 = 'The root cause is a stale cache entry that survives the reload because the invalidation key is derived from the wrong field.' // ~150, real content
+    const PARA_2 = 'The fix is to key invalidation off the canonical id so the entry is dropped on every write; I have verified it against the repro.' // ~150, real content
+    expect(PARA_1.length).toBeLessThan(200)
+    expect(PARA_2.length).toBeLessThan(200)
+    const text = jsonl(ENQUEUE, assistantText(PARA_1), assistantText(PARA_2))
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('block')
+    expect(r.reason).toBe('no-final-reply')
+    // Joined prose, mirroring the flush's selectFlushDeliveryText.
+    expect(r.pendingText).toBe(`${PARA_1}\n\n${PARA_2}`)
+    expect(r.hasTrailingProse).toBe(true)
+  })
+
+  it('leading narration + a real sub-200 answer block → only the answer is delivered (narration stripped)', () => {
+    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 r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('block')
+    expect(r.pendingText).toBe(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
@@ -447,9 +488,12 @@ describe('scanTurnForFinalReply — pendingText is a single substantive block, n
       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()
+    // 199 → under the 200-char SUBSTANCE floor, but a SINGLE trailing block is
+    // the real short-answer shape: post duplicate-message fix the scan persists
+    // it as pendingText so the capture-divergence corner can deliver it with a
+    // lowered floor. The gateway's default-floor decide still won't deliver it,
+    // so the #3228 masquerade guard is unchanged at the delivery layer.
+    expect(at(199).pendingText).toBe('X'.repeat(199))
     // 200 → exactly the floor, delivered.
     expect(at(200).pendingText).toBe('X'.repeat(200))
     // 201 → over floor, delivered.

package/telegram-plugin/tests/silent-end-single-writer-election.test.ts

@@ -0,0 +1,193 @@
+/**
+ * Regression tests for the single-writer election (duplicate-message fix).
+ *
+ * RCA: when a turn ends with its final answer as PLAIN TRANSCRIPT TEXT (no
+ * `reply` tool call), two uncoordinated recovery paths both fired — (A) the
+ * gateway turn-end flush (`decideTurnFlush`) delivered the captured prose, and
+ * (B) this Stop hook blocked and re-prompted, regenerating a REWORDED reply
+ * that defeated the exact-match dedup. The user got two near-identical
+ * messages.
+ *
+ * Fix: the Stop hook is the single elector (`decideStopHookDisposition`). On a
+ * would-BLOCK scan it ALLOWS the stop — handing delivery to the gateway's
+ * flush / captured-prose bridge — IFF four never-drop gates all hold; otherwise
+ * it BLOCKS exactly as today. These tests pin the whole verdict matrix and
+ * prove every allow path has a delivery machine and every guard forces BLOCK.
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  decideStopHookDisposition,
+  isTurnFlushSafetyEnabledEnv,
+  isCapturedProseDeliveryEnabledEnv,
+  isGatewayHeartbeatFresh,
+  GATEWAY_HEARTBEAT_FRESH_MS,
+} from '../hooks/silent-end-scan.mjs'
+import {
+  mkdtempSync,
+  writeFileSync,
+  utimesSync,
+  rmSync,
+} from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+// Scan fixtures — the shapes `scanTurnForFinalReply` returns on a would-block.
+const ZERO_REPLY_LONG = {
+  decided: 'block' as const,
+  reason: 'no-final-reply',
+  turnKey: 'c:_',
+  hasTrailingProse: true,
+  pendingText: 'A'.repeat(300),
+}
+const ZERO_REPLY_SHORT = {
+  decided: 'block' as const,
+  reason: 'no-final-reply',
+  turnKey: 'c:_',
+  hasTrailingProse: true,
+  pendingText: 'ok done',
+}
+const ZERO_REPLY_NO_PROSE = {
+  decided: 'block' as const,
+  reason: 'no-final-reply',
+  turnKey: 'c:_',
+  // hasTrailingProse absent — tool-calls-only turn, nothing for a machine to send.
+}
+const INTERIM_ACK_LONG = {
+  decided: 'block' as const,
+  reason: 'trailing-text-after-reply',
+  turnKey: 'c:_',
+  hasTrailingProse: true,
+  pendingText: 'B'.repeat(300),
+}
+const INTERIM_ACK_SHORT = {
+  decided: 'block' as const,
+  reason: 'trailing-text-after-reply',
+  turnKey: 'c:_',
+  hasTrailingProse: true,
+  pendingText: 'thanks!',
+}
+
+const ALL_ON = {
+  retryCount: 0,
+  turnFlushSafetyEnabled: true,
+  capturedProseDeliveryEnabled: true,
+  gatewayLive: true,
+}
+
+describe('decideStopHookDisposition — duplicate repro (#1: zero-reply ≥200)', () => {
+  it('zero-reply long answer, flags on, retry 0, live → ALLOW-elected (today it blocks → duplicate)', () => {
+    const d = decideStopHookDisposition({ scan: ZERO_REPLY_LONG, ...ALL_ON })
+    expect(d.action).toBe('allow-elected')
+    expect(d.reason).toBe('flush-will-deliver')
+  })
+})
+
+describe('decideStopHookDisposition — short-answer repro (#2: zero-reply <200)', () => {
+  it('zero-reply SHORT answer, flags on, retry 0, live → ALLOW-elected (flush has no length floor)', () => {
+    // Today this BLOCKS *and* the flush fires → duplicate. Exactly one machine
+    // must win: the flush. The election allows the stop so the hook does not
+    // also re-prompt.
+    const d = decideStopHookDisposition({ scan: ZERO_REPLY_SHORT, ...ALL_ON })
+    expect(d.action).toBe('allow-elected')
+  })
+})
+
+describe('decideStopHookDisposition — never-drop matrix (#3)', () => {
+  it('every ALLOW verdict is backed by a delivery machine', () => {
+    // Zero-reply → the turn-flush delivers (no length floor); interim-ack ≥200 →
+    // the captured-prose bridge delivers. Both are allow.
+    expect(decideStopHookDisposition({ scan: ZERO_REPLY_LONG, ...ALL_ON }).action).toBe('allow-elected')
+    expect(decideStopHookDisposition({ scan: ZERO_REPLY_SHORT, ...ALL_ON }).action).toBe('allow-elected')
+    expect(decideStopHookDisposition({ scan: INTERIM_ACK_LONG, ...ALL_ON }).action).toBe('allow-elected')
+  })
+
+  it('turn-flush flag OFF (zero-reply) → BLOCK (the flush will not fire)', () => {
+    const d = decideStopHookDisposition({ scan: ZERO_REPLY_LONG, ...ALL_ON, turnFlushSafetyEnabled: false })
+    expect(d.action).toBe('block')
+    expect(d.reason).toBe('turn-flush-flag-disabled')
+  })
+
+  it('captured-prose flag OFF (interim-ack) → BLOCK (the bridge will not fire)', () => {
+    const d = decideStopHookDisposition({ scan: INTERIM_ACK_LONG, ...ALL_ON, capturedProseDeliveryEnabled: false })
+    expect(d.action).toBe('block')
+    expect(d.reason).toBe('captured-prose-flag-disabled')
+  })
+
+  it('captured-prose flag OFF (zero-reply) → BLOCK (bridge is the capture-divergence backstop)', () => {
+    const d = decideStopHookDisposition({ scan: ZERO_REPLY_LONG, ...ALL_ON, capturedProseDeliveryEnabled: false })
+    expect(d.action).toBe('block')
+    expect(d.reason).toBe('captured-prose-flag-disabled')
+  })
+
+  it('retryCount > 0 → BLOCK (a prior failed delivery keeps the #3228 recovery net)', () => {
+    const d = decideStopHookDisposition({ scan: ZERO_REPLY_LONG, ...ALL_ON, retryCount: 1 })
+    expect(d.action).toBe('block')
+    expect(d.reason).toBe('retry-ladder-in-flight')
+  })
+
+  it('gateway NOT live → BLOCK (never allow into a possibly-dead gateway)', () => {
+    const d = decideStopHookDisposition({ scan: ZERO_REPLY_LONG, ...ALL_ON, gatewayLive: false })
+    expect(d.action).toBe('block')
+    expect(d.reason).toBe('gateway-liveness-not-fresh')
+  })
+
+  it('interim-ack SHORT (<200) → BLOCK (bridge floor is 200; no duplicate exists today)', () => {
+    const d = decideStopHookDisposition({ scan: INTERIM_ACK_SHORT, ...ALL_ON })
+    expect(d.action).toBe('block')
+    expect(d.reason).toBe('short-trailing-after-reply')
+  })
+
+  it('zero-reply with NO trailing prose (tool-calls only) → BLOCK (nothing to deliver)', () => {
+    const d = decideStopHookDisposition({ scan: ZERO_REPLY_NO_PROSE, ...ALL_ON })
+    expect(d.action).toBe('block')
+    expect(d.reason).toBe('no-trailing-prose')
+  })
+
+  it('a non-block scan (allow/unknown) is passed straight through as allow-scan', () => {
+    expect(decideStopHookDisposition({ scan: { decided: 'allow', reason: 'final-reply' }, ...ALL_ON }).action).toBe('allow-scan')
+    expect(decideStopHookDisposition({ scan: { decided: 'unknown', reason: 'no-turn-start' }, ...ALL_ON }).action).toBe('allow-scan')
+  })
+
+  it('gateway-liveness gate is checked BEFORE the flag/prose gates (dead gateway always blocks)', () => {
+    // Even with an otherwise-perfect zero-reply allow, a dead gateway forces block.
+    const d = decideStopHookDisposition({ scan: ZERO_REPLY_LONG, ...ALL_ON, gatewayLive: false, retryCount: 0 })
+    expect(d.action).toBe('block')
+    expect(d.reason).toBe('gateway-liveness-not-fresh')
+  })
+})
+
+describe('env-flag mirrors stay in sync with the TS source', () => {
+  it('turn-flush-safety: default ON; 0/false/off/no disable', () => {
+    expect(isTurnFlushSafetyEnabledEnv({})).toBe(true)
+    for (const v of ['0', 'false', 'off', 'no', 'FALSE', 'Off']) {
+      expect(isTurnFlushSafetyEnabledEnv({ SWITCHROOM_TG_TURN_FLUSH_SAFETY: v })).toBe(false)
+    }
+    expect(isTurnFlushSafetyEnabledEnv({ SWITCHROOM_TG_TURN_FLUSH_SAFETY: '1' })).toBe(true)
+  })
+  it('captured-prose: default ON; only exact "0" disables', () => {
+    expect(isCapturedProseDeliveryEnabledEnv({})).toBe(true)
+    expect(isCapturedProseDeliveryEnabledEnv({ SWITCHROOM_TG_CAPTURED_PROSE_DELIVERY: '0' })).toBe(false)
+    expect(isCapturedProseDeliveryEnabledEnv({ SWITCHROOM_TG_CAPTURED_PROSE_DELIVERY: '1' })).toBe(true)
+  })
+})
+
+describe('isGatewayHeartbeatFresh — liveness gate IO', () => {
+  it('fresh heartbeat → true; stale → false; missing → false', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'gw-hb-'))
+    try {
+      // Missing file → not fresh.
+      expect(isGatewayHeartbeatFresh(dir)).toBe(false)
+      const path = join(dir, 'gateway-heartbeat')
+      writeFileSync(path, 'x')
+      // Just-written → fresh.
+      expect(isGatewayHeartbeatFresh(dir)).toBe(true)
+      // Age it past the freshness bound → stale.
+      const old = new Date(Date.now() - GATEWAY_HEARTBEAT_FRESH_MS - 10_000)
+      utimesSync(path, old, old)
+      expect(isGatewayHeartbeatFresh(dir)).toBe(false)
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+})