switchroom 0.13.20 → 0.13.21

package/dist/cli/switchroom.js

@@ -47331,8 +47331,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.13.20";
-var COMMIT_SHA = "9962efb4";
+var VERSION = "0.13.21";
+var COMMIT_SHA = "4183c5df";
 
 // src/cli/agent.ts
 init_source();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.13.20",
+  "version": "0.13.21",
   "description": "Run Claude Code 24/7 on your Claude Pro/Max subscription over Telegram. Open-source alternative to OpenClaw and NanoClaw — no API keys.",
   "type": "module",
   "bin": {

package/profiles/_shared/telegram-style.md.hbs

@@ -23,11 +23,11 @@ The 👀→🤔→🔥→👍 status reaction and the typing indicator are *ambi
 
 **Follow-ups while a turn is in flight.** Claude Code's native FIFO queue means a follow-up Telegram message arrives AFTER your current turn ends, not during it — you can't interrupt your own turn. Every follow-up becomes the next prompt you see. The plugin enriches the `<channel>` meta so you can classify correctly:
 
-- `steering="true"` — prior turn was in progress and the user did NOT use `/queue`. Treat as a course-correction or addendum on the next action. Continue the original task, incorporating the new guidance.
-- `queued="true"` — the user typed `/queue ` or `/q ` (the prefix is stripped from the body you see). Treat as a new, independent task. Do NOT reference the in-flight work — start fresh.
+- `queued="true"` — DEFAULT for mid-turn follow-ups (no prefix). Treat as a new, independent task. Do NOT reference the in-flight work — start fresh. Also fires when the user typed `/queue ` or `/q ` (legacy alias; the prefix is stripped from the body you see).
+- `steering="true"` — the user typed `/steer ` or `/s ` (the prefix is stripped from the body you see). Treat as a course-correction or addendum on the in-flight work. Continue the original task, incorporating the new guidance.
 - `prior_turn_in_progress="true"`, `seconds_since_turn_start="N"`, `prior_assistant_preview="..."` — auxiliary context on the prior turn so you can decide which of the above applies when ambiguous. `prior_assistant_preview` is the first ~200 chars of your most recent reply in this chat, HTML tags stripped.
 
-If both `queued` and `steering` are somehow present, `queued` wins (explicit beats inferred). If `prior_turn_in_progress="true"` is set without either flag (shouldn't happen but defensive), treat the message as a follow-up related to your last reply.
+If both `queued` and `steering` are somehow present, `steering` wins (explicit opt-in beats default). If `prior_turn_in_progress="true"` is set without either flag (shouldn't happen but defensive), treat the message as a follow-up related to your last reply.
 
 **Self-narrate the classification.** At the top of your reply for any `steering` or `queued` message, include a brief italic one-liner so the user can correct you — e.g. `_↪️ treating as steer on the prior task_` or `_📥 queued as a new task_`.
 

package/telegram-plugin/dist/gateway/gateway.js

@@ -30563,7 +30563,7 @@ class OutboundDedupCache {
   constructor(opts = {}) {
     this.ttlMs = opts.ttlMs ?? DEFAULT_DEDUP_TTL_MS;
   }
-  record(chatId, threadId, text, now) {
+  record(chatId, threadId, text, now, turnKey = null) {
     if (text.length < DEDUP_MIN_CONTENT_LEN)
       return;
     const key = makeKey(chatId, threadId);
@@ -30572,11 +30572,12 @@ class OutboundDedupCache {
     list.push({
       hash: normalizeForDedup(text),
       ts: now,
-      preview: text.slice(0, 80)
+      preview: text.slice(0, 80),
+      turnKey
     });
     this.entries.set(key, list);
   }
-  check(chatId, threadId, text, now) {
+  check(chatId, threadId, text, now, turnKey = null) {
     if (text.length < DEDUP_MIN_CONTENT_LEN)
       return null;
     const key = makeKey(chatId, threadId);
@@ -30586,9 +30587,12 @@ class OutboundDedupCache {
     this.evict(list, now);
     const candidateHash = normalizeForDedup(text);
     for (const entry of list) {
-      if (entry.hash === candidateHash) {
-        return { matched: true, preview: entry.preview, ageMs: now - entry.ts };
+      if (entry.hash !== candidateHash)
+        continue;
+      if (turnKey != null && entry.turnKey != null && entry.turnKey !== turnKey) {
+        continue;
       }
+      return { matched: true, preview: entry.preview, ageMs: now - entry.ts };
     }
     return null;
   }
@@ -40987,7 +40991,7 @@ function shouldShowHandoffLine() {
   return v.toLowerCase() !== "false";
 }
 function formatHandoffLine(topic, format) {
-  const prefix = "\u21a9\ufe0f Picked up where we left off \u2014 ";
+  const prefix = "\u21a9\ufe0f Picked up where we left off, ";
   if (format === "html") {
     return `<i>${prefix}${escapeHtml6(topic)}</i>
 
@@ -41156,6 +41160,7 @@ function flushOnAgentDisconnect(deps) {
     activeDraftParseModes,
     clearActiveReactions: clearActiveReactions3,
     disposeProgressDriver,
+    onDanglingTurnsSwept,
     log
   } = deps;
   if (agentName3 == null) {
@@ -41169,6 +41174,15 @@ function flushOnAgentDisconnect(deps) {
     activeTurnStartedAt.delete(key);
   }
   clearActiveReactions3();
+  const danglingKeys = [...activeTurnStartedAt.keys()];
+  if (danglingKeys.length > 0) {
+    for (const k of danglingKeys) {
+      activeTurnStartedAt.delete(k);
+      activeReactionMsgIds.delete(k);
+    }
+    log(`telegram gateway: disconnect-flush swept ${danglingKeys.length} dangling turn key(s) ` + `post-bridge-death (controller loop missed \u2014 setDone raced disconnect)`);
+    onDanglingTurnsSwept?.(danglingKeys);
+  }
   disposeProgressDriver();
   for (const [key, stream] of activeDraftStreams.entries()) {
     if (!stream.isFinal())
@@ -44464,7 +44478,11 @@ function purgeStaleTurnsForChat(chatId, keys, purger) {
 
 // gateway/inbound-delivery-gate.ts
 function decideInboundDelivery(input) {
-  if (input.turnInFlight && !input.isSteering)
+  if (input.isSteering)
+    return "deliver";
+  if (input.isInterrupt === true)
+    return "deliver";
+  if (input.turnInFlight)
     return "buffer-until-idle";
   return "deliver";
 }
@@ -46702,7 +46720,7 @@ function backfillJsonlAgentId(db2, jsonlPath, agentId, log) {
   db2.prepare("UPDATE subagents SET jsonl_agent_id = ? WHERE id = ?").run(agentId, candidate.id);
   log?.(`subagent-watcher: backfill linked ${agentId} \u2192 ${candidate.id}`);
 }
-function readSubTail(entry, tail, now, onDescriptionUpdate, fs2, log, db2, parentStateDir, onUnstall) {
+function readSubTail(entry, tail, now, onDescriptionUpdate, fs2, log, db2, parentStateDir, onUnstall, onFileVanished) {
   try {
     const stat = fs2.statSync(entry.filePath);
     if (stat.size < tail.cursor) {
@@ -46807,6 +46825,12 @@ function readSubTail(entry, tail, now, onDescriptionUpdate, fs2, log, db2, paren
     }
     tail.hasEmittedStart = startState.hasEmittedStart;
   } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT" || code === "EACCES") {
+      log?.(`subagent-watcher: JSONL vanished for ${entry.agentId} (${code}) \u2014 deregistering`);
+      onFileVanished?.(entry.agentId, code);
+      return;
+    }
     log?.(`subagent-watcher: read error ${entry.agentId}: ${err.message}`);
   }
 }
@@ -46913,7 +46937,7 @@ function startSubagentWatcher(config) {
           return;
         readSubTail(entry2, t, nowFn(), (desc) => {
           log?.(`subagent-watcher: description updated for ${agentId}: ${desc}`);
-        }, fs2, log, db2, parentStateDir, config.onUnstall);
+        }, fs2, log, db2, parentStateDir, config.onUnstall, cleanupTerminalAgent);
         maybySendStateTransition(agentId);
       });
     } catch (err) {
@@ -47159,7 +47183,7 @@ function startSubagentWatcher(config) {
         continue;
       readSubTail(entry, tail, n, (desc) => {
         log?.(`subagent-watcher: description updated for ${agentId}: ${desc}`);
-      }, fs2, log, db2, parentStateDir, config.onUnstall);
+      }, fs2, log, db2, parentStateDir, config.onUnstall, cleanupTerminalAgent);
       maybySendStateTransition(agentId);
     }
     checkStalls();
@@ -48291,10 +48315,10 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.13.20";
-var COMMIT_SHA = "9962efb4";
-var COMMIT_DATE = "2026-05-23T08:29:36Z";
-var LATEST_PR = 1684;
+var VERSION = "0.13.21";
+var COMMIT_SHA = "4183c5df";
+var COMMIT_DATE = "2026-05-23T21:59:16Z";
+var LATEST_PR = 1692;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -50078,6 +50102,12 @@ startTimer({
     emitRuntimeMetric(event);
   },
   onFrameworkFallback: async (ctx) => {
+    if (activeTurnStartedAt.get(ctx.key) == null && currentTurn == null) {
+      process.stderr.write(`telegram gateway: silence-poke framework-fallback late-fire skipped \u2014 ` + `turn ended cleanly during silence window chat=${ctx.chatId} thread=${ctx.threadId ?? "-"} silence_ms=${ctx.silenceMs}
+`);
+      endTurn(ctx.key);
+      return;
+    }
     let text = null;
     const upd = inFlightUpdate;
     if (upd != null) {
@@ -50344,6 +50374,13 @@ var ipcServer = createIpcServer({
       disposeProgressDriver: () => {
         progressDriver?.dispose?.({ preservePending: true });
       },
+      onDanglingTurnsSwept: () => {
+        if (currentTurn != null) {
+          process.stderr.write(`telegram gateway: disconnect-flush nulled currentTurn (bridge died with turn in flight)
+`);
+          currentTurn = null;
+        }
+      },
       log: (msg) => process.stderr.write(`${msg}
 `)
     });
@@ -50750,7 +50787,7 @@ async function executeReply(args) {
 `);
   {
     const replyThreadId = args.message_thread_id != null ? Number(args.message_thread_id) : undefined;
-    const dup = outboundDedup.check(chat_id, replyThreadId, text, Date.now());
+    const dup = outboundDedup.check(chat_id, replyThreadId, text, Date.now(), currentTurn?.registryKey ?? null);
     if (dup != null) {
       process.stderr.write(`telegram gateway: reply: deduped (#546) chatId=${chat_id} ageMs=${dup.ageMs} preview=${JSON.stringify(dup.preview)}
 `);
@@ -50941,7 +50978,7 @@ ${url}`;
           })) {
             turn2.finalAnswerDelivered = true;
           }
-          outboundDedup.record(chat_id, threadId, decision.mergedText, Date.now());
+          outboundDedup.record(chat_id, threadId, decision.mergedText, Date.now(), turn2?.registryKey ?? null);
           silentAnchorEditDone = true;
         } catch (err) {
           process.stderr.write(`telegram gateway: silent-reply auto-edit failed, falling back to fresh send: ${err instanceof Error ? err.message : String(err)}
@@ -51148,7 +51185,7 @@ ${url}`;
   process.stderr.write(`telegram channel: reply: finalized chatId=${chat_id} messageIds=[${sentIds.join(",")}] chunks=${chunks.length}
 `);
   if (sentIds.length > 0) {
-    outboundDedup.record(chat_id, threadId, text, Date.now());
+    outboundDedup.record(chat_id, threadId, text, Date.now(), currentTurn?.registryKey ?? null);
   }
   return { content: [{ type: "text", text: result }] };
 }
@@ -51158,11 +51195,23 @@ async function executeStreamReply(args) {
     throw new Error("stream_reply: chat_id is required");
   if (args.text == null || args.text === "")
     throw new Error("stream_reply: text is required and cannot be empty");
+  {
+    const scrub = scrubVoice(args.text);
+    if (scrub.replaced > 0) {
+      args.text = scrub.scrubbed;
+      emitRuntimeMetric({
+        kind: "voice_scrub_applied",
+        chatKey: statusKey(args.chat_id, args.message_thread_id != null ? Number(args.message_thread_id) : undefined),
+        replaced: scrub.replaced,
+        site: "stream_reply"
+      });
+    }
+  }
   if (args.done === true) {
     const sChatId = args.chat_id;
     const sThreadId = args.message_thread_id != null ? Number(args.message_thread_id) : undefined;
     const sText = args.text;
-    const dup = outboundDedup.check(sChatId, sThreadId, sText, Date.now());
+    const dup = outboundDedup.check(sChatId, sThreadId, sText, Date.now(), currentTurn?.registryKey ?? null);
     if (dup != null) {
       process.stderr.write(`telegram gateway: stream_reply: deduped (#546) chatId=${sChatId} ageMs=${dup.ageMs} preview=${JSON.stringify(dup.preview)}
 `);
@@ -51254,7 +51303,7 @@ async function executeStreamReply(args) {
   if (args.done === true && result.messageId != null) {
     const sChatId = args.chat_id;
     const sThreadId = args.message_thread_id != null ? Number(args.message_thread_id) : undefined;
-    outboundDedup.record(sChatId, sThreadId, args.text, Date.now());
+    outboundDedup.record(sChatId, sThreadId, args.text, Date.now(), currentTurn?.registryKey ?? null);
     noteOutbound3(statusKey(sChatId, sThreadId), {
       messageId: result.messageId,
       text: args.text
@@ -52166,10 +52215,10 @@ function handleSessionEvent(ev) {
               }
             },
             checkDedup: (text) => {
-              return outboundDedup.check(turn.sessionChatId, turn.sessionThreadId, text, Date.now()) != null;
+              return outboundDedup.check(turn.sessionChatId, turn.sessionThreadId, text, Date.now(), turn.registryKey ?? null) != null;
             },
             recordDedup: (text) => {
-              outboundDedup.record(turn.sessionChatId, turn.sessionThreadId, text, Date.now());
+              outboundDedup.record(turn.sessionChatId, turn.sessionThreadId, text, Date.now(), turn.registryKey ?? null);
             },
             recordOutbound: ({ messageId, text }) => {
               if (!HISTORY_ENABLED)
@@ -52260,7 +52309,7 @@ function handleSessionEvent(ev) {
           streamFinalizedAsAnswer = true;
           turn.finalAnswerDelivered = true;
           try {
-            outboundDedup.record(turn.sessionChatId, turn.sessionThreadId, streamedFinalText, Date.now());
+            outboundDedup.record(turn.sessionChatId, turn.sessionThreadId, streamedFinalText, Date.now(), turn.registryKey ?? null);
           } catch {}
           if (HISTORY_ENABLED) {
             try {
@@ -52360,10 +52409,22 @@ function handleSessionEvent(ev) {
         return;
       }
       if (flushDecision.kind === "flush") {
-        const capturedText = flushDecision.text;
+        let capturedText = flushDecision.text;
         const backstopChatId = chatId;
         const backstopThreadId = threadId;
         const backstopCtrl = ctrl;
+        {
+          const scrub = scrubVoice(capturedText);
+          if (scrub.replaced > 0) {
+            capturedText = scrub.scrubbed;
+            emitRuntimeMetric({
+              kind: "voice_scrub_applied",
+              chatKey: statusKey(backstopChatId, backstopThreadId),
+              replaced: scrub.replaced,
+              site: "turn_flush"
+            });
+          }
+        }
         turn.finalAnswerDelivered = true;
         const cardTakeover = progressDriver?.takeOverCard({
           chatId: backstopChatId,
@@ -52455,7 +52516,7 @@ function handleSessionEvent(ev) {
                 });
               } catch {}
             }
-            outboundDedup.record(backstopChatId, backstopThreadId, capturedText, Date.now());
+            outboundDedup.record(backstopChatId, backstopThreadId, capturedText, Date.now(), currentTurn?.registryKey ?? null);
             if (backstopCtrl)
               backstopCtrl.setDone();
             if (backstopCardTurnKey != null) {
@@ -53345,7 +53406,8 @@ ${preBlock(write.output)}`;
   const selfAgent = process.env.SWITCHROOM_AGENT_NAME ?? "";
   if (decideInboundDelivery({
     turnInFlight: turnInFlightAtReceipt,
-    isSteering
+    isSteering,
+    isInterrupt: interrupt.isInterrupt
   }) === "buffer-until-idle") {
     pendingInboundBuffer.push(selfAgent, inboundMsg);
     process.stderr.write(`telegram gateway: inbound held mid-turn agent=${selfAgent} chat=${chat_id} msg=${msgId ?? "-"} \u2014 will flush on turn-complete

package/telegram-plugin/gateway/disconnect-flush.ts

@@ -48,6 +48,18 @@ export interface DisconnectFlushDeps<Ctrl extends { setDone: () => void }, Strea
   /** Progress driver — disposed with `preservePending: true` for sub-agent JTBDs (#393). */
   disposeProgressDriver: () => void
 
+  /** Optional: called when the registered-agent disconnect found dangling
+   *  `activeTurnStartedAt` entries the controller loop did not clear (i.e.
+   *  `setDone()` already ran on the canonical reply path, leaving
+   *  `activeStatusReactions` empty but `activeTurnStartedAt` populated).
+   *  The gateway uses this to null its module-scope `currentTurn` — the
+   *  bridge that owned that turn just died. Without this, the next
+   *  inbound is "held mid-turn" against a ghost (the 2026-05-23 audit
+   *  found ~14 such events / 3 days / 9 agents).
+   *
+   *  No-op if no dangling keys are found. */
+  onDanglingTurnsSwept?: (purgedKeys: string[]) => void
+
   /** Logger — receives the one-line decision trace. */
   log: (msg: string) => void
 }
@@ -70,6 +82,7 @@ export function flushOnAgentDisconnect<
     activeDraftParseModes,
     clearActiveReactions,
     disposeProgressDriver,
+    onDanglingTurnsSwept,
     log,
   } = deps
 
@@ -91,6 +104,30 @@ export function flushOnAgentDisconnect<
   }
   clearActiveReactions()
 
+  // Defense-in-depth — sweep any `activeTurnStartedAt` keys the controller
+  // loop above did not touch. The bridge has crashed; any turn it owned is
+  // dead by definition, regardless of whether `activeStatusReactions`
+  // still tracks it. The race that motivates this: `setDone()` already
+  // fired on the canonical reply path (clearing the reaction controller)
+  // BUT the disconnect arrived BEFORE `purgeReactionTracking` ran the
+  // `activeTurnStartedAt.delete` line for that key. Without this sweep,
+  // the key orphans, and the next inbound is "held mid-turn" against
+  // a ghost — surfacing as the held-mid-turn / `currentTurn_nulled=true`
+  // wedge symptom documented in feedback_5min_restart_wedge memo and
+  // measured at ~14 events / 3 days / 9 agents (2026-05-23 audit).
+  const danglingKeys = [...activeTurnStartedAt.keys()]
+  if (danglingKeys.length > 0) {
+    for (const k of danglingKeys) {
+      activeTurnStartedAt.delete(k)
+      activeReactionMsgIds.delete(k)
+    }
+    log(
+      `telegram gateway: disconnect-flush swept ${danglingKeys.length} dangling turn key(s) ` +
+      `post-bridge-death (controller loop missed — setDone raced disconnect)`,
+    )
+    onDanglingTurnsSwept?.(danglingKeys)
+  }
+
   // Stop coalesce timers that could emit into a finalized draft stream, but
   // preserve chats with pendingCompletion=true — those have background
   // sub-agents that legitimately outlive the parent bridge disconnect. The

package/telegram-plugin/gateway/gateway.ts

@@ -3084,6 +3084,30 @@ silencePoke.startTimer({
     emitRuntimeMetric(event)
   },
   onFrameworkFallback: async (ctx) => {
+    // Late-fire short-circuit (2026-05-23 audit finding). The fallback
+    // can race a clean turn-end: the model's actual reply lands inside
+    // the silence window's final ~50ms, the canonical turn-end path
+    // clears `activeTurnStartedAt` and nulls `currentTurn`, and then
+    // this handler fires anyway. Without this check we emit a noisy
+    // "still working…" ping to the user (right after they got their
+    // real reply) AND a misleading "ended wedged turn ... currentTurn_
+    // nulled=false drained_buffered=0/0" log line. The 7-day audit
+    // showed this race accounts for ~90% of all framework_fallback log
+    // events (124 of 138 `currentTurn_nulled=false` cases). Distinct
+    // log line so observability still tracks the fact that the silence
+    // crossed threshold; the wedge counter is no longer polluted.
+    if (activeTurnStartedAt.get(ctx.key) == null && currentTurn == null) {
+      process.stderr.write(
+        `telegram gateway: silence-poke framework-fallback late-fire skipped — ` +
+        `turn ended cleanly during silence window ` +
+        `chat=${ctx.chatId} thread=${ctx.threadId ?? '-'} silence_ms=${ctx.silenceMs}\n`,
+      )
+      // Tell silence-poke this chat-thread is finished so the next
+      // arming doesn't carry stale state.
+      silencePoke.endTurn(ctx.key)
+      return
+    }
+
     // Deterministic in-flight update status (klanker incident). If this
     // gateway dispatched an update_apply that's still running, the
     // recurring framework fallback carries hostd's REAL phase + elapsed
@@ -3579,6 +3603,18 @@ const ipcServer: IpcServer = createIpcServer({
         // scripts/check-plugin-references.mjs (TS2722).
         progressDriver?.dispose?.({ preservePending: true })
       },
+      // When dangling activeTurnStartedAt keys were swept (setDone raced
+      // disconnect), the module-scope `currentTurn` may also point at the
+      // dead bridge's turn. Null it so the next inbound starts a fresh
+      // turn instead of inheriting a ghost.
+      onDanglingTurnsSwept: () => {
+        if (currentTurn != null) {
+          process.stderr.write(
+            `telegram gateway: disconnect-flush nulled currentTurn (bridge died with turn in flight)\n`,
+          )
+          currentTurn = null
+        }
+      },
       log: (msg) => process.stderr.write(`${msg}\n`),
     })
   },
@@ -4227,7 +4263,7 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
   // late-replies with different content sail through.
   {
     const replyThreadId = args.message_thread_id != null ? Number(args.message_thread_id) : undefined
-    const dup = outboundDedup.check(chat_id, replyThreadId, text, Date.now())
+    const dup = outboundDedup.check(chat_id, replyThreadId, text, Date.now(), currentTurn?.registryKey ?? null)
     if (dup != null) {
       process.stderr.write(
         `telegram gateway: reply: deduped (#546) chatId=${chat_id} ` +
@@ -4561,6 +4597,7 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
             threadId,
             decision.mergedText,
             Date.now(),
+            turn?.registryKey ?? null,
           )
 
           silentAnchorEditDone = true
@@ -4885,7 +4922,7 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
   // calls with this same content within DEFAULT_DEDUP_TTL_MS will
   // be suppressed.
   if (sentIds.length > 0) {
-    outboundDedup.record(chat_id, threadId, text, Date.now())
+    outboundDedup.record(chat_id, threadId, text, Date.now(), currentTurn?.registryKey ?? null)
   }
   return { content: [{ type: 'text', text: result }] }
 }
@@ -4896,6 +4933,31 @@ async function executeStreamReply(args: Record<string, unknown>): Promise<unknow
   if (!args.chat_id) throw new Error('stream_reply: chat_id is required')
   if (args.text == null || args.text === '') throw new Error('stream_reply: text is required and cannot be empty')
 
+  // Voice scrub (PR #1683 follow-up). Modern Claude on the fleet
+  // uses the answer-stream / draft-stream path for multi-paragraph
+  // replies — the model emits via stream_reply and the original
+  // PR #1683 scrub site (executeReply) never sees the text. klanker's
+  // 2026-05-24 log showed model output with em-dashes routed via
+  // stream_reply done=true, materializing as sendMessage with no
+  // scrub. Mirror the executeReply pattern here: scrub BEFORE the
+  // outbound-dedup check (so retries see the scrubbed key) and
+  // mutate args.text so all downstream consumers (the stream-
+  // controller, dedup record, history record) see the scrubbed
+  // version. Kill switch: SWITCHROOM_DISABLE_VOICE_SCRUB.
+  {
+    const scrub = scrubVoice(args.text as string)
+    if (scrub.replaced > 0) {
+      args.text = scrub.scrubbed
+      emitRuntimeMetric({
+        kind: 'voice_scrub_applied',
+        chatKey: statusKey(args.chat_id as string, args.message_thread_id != null
+          ? Number(args.message_thread_id) : undefined),
+        replaced: scrub.replaced,
+        site: 'stream_reply',
+      })
+    }
+  }
+
   // #546 dedup check: stream_reply done=true is the most-common
   // retry shape — claude-code re-emits the final-text call when
   // the previous bridge missed the ack. If turn-flush already sent
@@ -4906,7 +4968,7 @@ async function executeStreamReply(args: Record<string, unknown>): Promise<unknow
     const sChatId = args.chat_id as string
     const sThreadId = args.message_thread_id != null ? Number(args.message_thread_id) : undefined
     const sText = args.text as string
-    const dup = outboundDedup.check(sChatId, sThreadId, sText, Date.now())
+    const dup = outboundDedup.check(sChatId, sThreadId, sText, Date.now(), currentTurn?.registryKey ?? null)
     if (dup != null) {
       process.stderr.write(
         `telegram gateway: stream_reply: deduped (#546) chatId=${sChatId} ` +
@@ -5070,7 +5132,7 @@ async function executeStreamReply(args: Record<string, unknown>): Promise<unknow
   if (args.done === true && result.messageId != null) {
     const sChatId = args.chat_id as string
     const sThreadId = args.message_thread_id != null ? Number(args.message_thread_id) : undefined
-    outboundDedup.record(sChatId, sThreadId, args.text as string, Date.now())
+    outboundDedup.record(sChatId, sThreadId, args.text as string, Date.now(), currentTurn?.registryKey ?? null)
     // #1445 cross-turn pending-async ambient. The terminal stream_reply
     // (done=true) is the user-visible anchor for any cross-turn wait
     // that follows. Capture it so if this turn ends with a pending
@@ -6382,10 +6444,10 @@ function handleSessionEvent(ev: SessionEvent): void {
             // threadId come from the captured `turn` snapshot, stable for
             // the lifetime of the stream.
             checkDedup: (text: string) => {
-              return outboundDedup.check(turn.sessionChatId, turn.sessionThreadId, text, Date.now()) != null
+              return outboundDedup.check(turn.sessionChatId, turn.sessionThreadId, text, Date.now(), turn.registryKey ?? null) != null
             },
             recordDedup: (text: string) => {
-              outboundDedup.record(turn.sessionChatId, turn.sessionThreadId, text, Date.now())
+              outboundDedup.record(turn.sessionChatId, turn.sessionThreadId, text, Date.now(), turn.registryKey ?? null)
             },
             // #648 — write answer-stream materializations into the SQLite
             // history buffer so get_recent_messages can surface them. Guard
@@ -6546,6 +6608,7 @@ function handleSessionEvent(ev: SessionEvent): void {
               turn.sessionThreadId,
               streamedFinalText,
               Date.now(),
+              turn.registryKey ?? null,
             )
           } catch { /* best-effort */ }
           if (HISTORY_ENABLED) {
@@ -6715,11 +6778,31 @@ function handleSessionEvent(ev: SessionEvent): void {
       }
 
       if (flushDecision.kind === 'flush') {
-        const capturedText = flushDecision.text
+        let capturedText = flushDecision.text
         const backstopChatId = chatId
         const backstopThreadId = threadId
         const backstopCtrl = ctrl
 
+        // Voice scrub (PR #1683 follow-up). Turn-flush is the path
+        // that fires when the model emits raw transcript text WITHOUT
+        // calling reply / stream_reply. That captured text bypasses
+        // PR #1683's executeReply scrub site entirely and is delivered
+        // via sendMessage / editMessageText directly. Scrub the
+        // capturedText before markdownToHtml so em-dashes never reach
+        // the wire. Kill switch: SWITCHROOM_DISABLE_VOICE_SCRUB.
+        {
+          const scrub = scrubVoice(capturedText)
+          if (scrub.replaced > 0) {
+            capturedText = scrub.scrubbed
+            emitRuntimeMetric({
+              kind: 'voice_scrub_applied',
+              chatKey: statusKey(backstopChatId, backstopThreadId),
+              replaced: scrub.replaced,
+              site: 'turn_flush',
+            })
+          }
+        }
+
         // #1664 — turn-flush only fires when !replyCalled (decideTurnFlush
         // returns 'reply-called' otherwise). It legitimately delivers the
         // model's terminal text as the answer, so the turn IS answered.
@@ -6911,6 +6994,7 @@ function handleSessionEvent(ev: SessionEvent): void {
               backstopThreadId,
               capturedText,
               Date.now(),
+              currentTurn?.registryKey ?? null,
             )
             if (backstopCtrl) backstopCtrl.setDone()
             // Unpin the card. completeTurn cleans up pinMgr's per-turn
@@ -8455,6 +8539,15 @@ async function handleInbound(
     decideInboundDelivery({
       turnInFlight: turnInFlightAtReceipt,
       isSteering,
+      // Interrupt-marker carve-out (2026-05-24): the `!`-prefixed body
+      // must bypass the "buffer-until-turn-complete" gate because the
+      // SIGINT'd turn often doesn't emit turn_complete, leaving the
+      // body stranded in pendingInboundBuffer indefinitely. The
+      // `interrupt` const is computed at the start of handleInbound
+      // (line ~7606) and remains in scope here. When the user fires
+      // `!`-with-body, this delivers the body as a fresh inbound to
+      // the freshly-killed bridge.
+      isInterrupt: interrupt.isInterrupt,
     }) === 'buffer-until-idle'
   ) {
     pendingInboundBuffer.push(selfAgent, inboundMsg)

package/telegram-plugin/gateway/inbound-delivery-gate.ts

@@ -53,6 +53,27 @@
  * mid-turn — that is the whole point of the steering feature (redirect
  * the agent while it works). Steering messages keep immediate delivery.
  * The wedge only ever affected the queued-mid-turn default path.
+ *
+ * ## Interrupt-marker is also exempt (2026-05-24 fix)
+ *
+ * An inbound prefixed with `!` invokes the interrupt path
+ * (`gateway.ts:handleInbound` parse + `tmux send-keys C-c` to the
+ * bridge). The SIGINT kills the in-flight turn at the SDK level — but
+ * the killed turn does NOT always emit `turn_complete`. Without that
+ * event, the turn-complete buffer-flush never fires, and the
+ * post-SIGINT inbound body (the `!` replacement instruction) rots in
+ * `pendingInboundBuffer` indefinitely.
+ *
+ * 2026-05-24 live UAT trace: user fires `! actually reply hello`,
+ * SIGINT delivered, killed turn never emits `turn_complete`, buffer
+ * stays full, user sees no response. The Phase-3 audit had this UAT
+ * `describe.skip`'d as "real interrupt-marker wedge or prompt-shape
+ * issue" — confirmed real.
+ *
+ * Resolution: bypass the gate for interrupt inbounds. The interrupt
+ * carve-out is a peer of `isSteering` — both are "intentional
+ * mid-turn delivery" cases. Caller passes the interrupt flag from the
+ * inbound parse; the gate returns `'deliver'` immediately.
  */
 
 export interface InboundDeliveryGateInput {
@@ -63,6 +84,14 @@ export interface InboundDeliveryGateInput {
   /** This inbound carried an explicit `/steer` (`/s`) prefix and is an
    *  intentional mid-turn redirect. */
   isSteering: boolean
+  /** This inbound was parsed by `parseInterruptMarker` as a `!`-prefixed
+   *  interrupt request. The gateway has already (or is about to) deliver
+   *  the SIGINT to claude via tmux send-keys; the body of the message
+   *  (post-`!`) is the user's replacement instruction. Without this
+   *  carve-out, the body rots in pendingInboundBuffer because the
+   *  SIGINT'd turn doesn't reliably emit turn_complete to drain the
+   *  buffer. Optional + defaults false for backward compat. */
+  isInterrupt?: boolean
 }
 
 export type InboundDeliveryDecision =
@@ -73,13 +102,17 @@ export type InboundDeliveryDecision =
   | 'buffer-until-idle'
 
 /**
- * Pure. The ONLY condition that defers delivery is "a turn is in flight
- * AND this is not a steering message". Everything else delivers
- * immediately (idle → submits at once; steering → intentional mid-turn).
+ * Pure. Defers delivery ONLY when a turn is in flight AND this inbound
+ * is neither steering nor an interrupt. Idle → deliver. Steering → deliver
+ * (intentional mid-turn redirect). Interrupt → deliver (the `!`
+ * carve-out — see header doc; the killed turn may never drain the
+ * buffer, so we must not buffer in the first place).
  */
 export function decideInboundDelivery(
   input: InboundDeliveryGateInput,
 ): InboundDeliveryDecision {
-  if (input.turnInFlight && !input.isSteering) return 'buffer-until-idle'
+  if (input.isSteering) return 'deliver'
+  if (input.isInterrupt === true) return 'deliver'
+  if (input.turnInFlight) return 'buffer-until-idle'
   return 'deliver'
 }