switchroom 0.13.19 → 0.13.21

package/dist/cli/switchroom.js

@@ -47331,8 +47331,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.13.19";
-var COMMIT_SHA = "de154395";
+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.19",
+  "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;
   }
@@ -40355,6 +40359,90 @@ function getOpenTags(html) {
   return tagStack;
 }
 
+// text-voice-scrub.ts
+var NULL = "\x00";
+var FENCE_PH = `${NULL}VS_FENCE`;
+var INLINE_PH = `${NULL}VS_INLINE`;
+var HTML_CODE_PH = `${NULL}VS_HTMLCODE`;
+var HTML_PRE_PH = `${NULL}VS_HTMLPRE`;
+var URL_PH = `${NULL}VS_URL`;
+var URL_RE = /https?:\/\/\S+/g;
+function enabled4() {
+  const v = process.env.SWITCHROOM_DISABLE_VOICE_SCRUB;
+  return !(v === "1" || v === "true");
+}
+function park(text) {
+  const parts = [];
+  let parked = text;
+  parked = parked.replace(/```[\s\S]*?```/g, (m) => {
+    const idx = parts.length;
+    parts.push({ prefix: FENCE_PH, idx, raw: m });
+    return `${FENCE_PH}${idx}${NULL}`;
+  });
+  parked = parked.replace(/<pre>[\s\S]*?<\/pre>/gi, (m) => {
+    const idx = parts.length;
+    parts.push({ prefix: HTML_PRE_PH, idx, raw: m });
+    return `${HTML_PRE_PH}${idx}${NULL}`;
+  });
+  parked = parked.replace(/<code[^>]*>[\s\S]*?<\/code>/gi, (m) => {
+    const idx = parts.length;
+    parts.push({ prefix: HTML_CODE_PH, idx, raw: m });
+    return `${HTML_CODE_PH}${idx}${NULL}`;
+  });
+  parked = parked.replace(/`[^`\n]+`/g, (m) => {
+    const idx = parts.length;
+    parts.push({ prefix: INLINE_PH, idx, raw: m });
+    return `${INLINE_PH}${idx}${NULL}`;
+  });
+  parked = parked.replace(URL_RE, (m) => {
+    const idx = parts.length;
+    parts.push({ prefix: URL_PH, idx, raw: m });
+    return `${URL_PH}${idx}${NULL}`;
+  });
+  return { parked, parts };
+}
+function restore(text, parts) {
+  let restored = text;
+  for (let i = parts.length - 1;i >= 0; i--) {
+    const p = parts[i];
+    restored = restored.replace(`${p.prefix}${p.idx}${NULL}`, () => p.raw);
+  }
+  return restored;
+}
+function replaceDashes(text) {
+  let replaced = 0;
+  let out = text;
+  out = out.replace(/(\S) [\u2014\u2013] (\S)/g, (_m, before, after) => {
+    replaced++;
+    const sentenceStart = /[A-Z]/.test(after);
+    return sentenceStart ? `${before}. ${after}` : `${before}, ${after}`;
+  });
+  out = out.replace(/ [\u2014\u2013](\s*\n)/g, (_m, ws) => {
+    replaced++;
+    return `.${ws}`;
+  });
+  out = out.replace(/(\w)[\u2014\u2013](\w)/g, (_m, before, after) => {
+    replaced++;
+    return `${before}, ${after}`;
+  });
+  out = out.replace(/[\u2014\u2013]/g, () => {
+    replaced++;
+    return "-";
+  });
+  return { out, replaced };
+}
+function scrubVoice(text) {
+  if (!enabled4() || text.length === 0) {
+    return { scrubbed: text, replaced: 0 };
+  }
+  const { parked, parts } = park(text);
+  const { out, replaced } = replaceDashes(parked);
+  if (replaced === 0) {
+    return { scrubbed: text, replaced: 0 };
+  }
+  return { scrubbed: restore(out, parts), replaced };
+}
+
 // telegram-button-constraints.ts
 var TELEGRAM_BUTTON_LIMITS = {
   TEXT_MAX: 64,
@@ -40903,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>
 
@@ -41072,6 +41160,7 @@ function flushOnAgentDisconnect(deps) {
     activeDraftParseModes,
     clearActiveReactions: clearActiveReactions3,
     disposeProgressDriver,
+    onDanglingTurnsSwept,
     log
   } = deps;
   if (agentName3 == null) {
@@ -41085,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())
@@ -44380,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";
 }
@@ -44639,9 +44741,9 @@ function transition(state3, event) {
 
 // gateway/inbound-delivery-machine-shadow.ts
 var state3 = initialState();
-var enabled4 = process.env.SWITCHROOM_DELIVERY_MACHINE_SHADOW !== "0";
+var enabled5 = process.env.SWITCHROOM_DELIVERY_MACHINE_SHADOW !== "0";
 function shadowEmit(event) {
-  if (!enabled4)
+  if (!enabled5)
     return [];
   try {
     const result = transition(state3, event);
@@ -44699,12 +44801,12 @@ function redeliverBufferedInbound2(buffer, agent, send, spool) {
 }
 
 // gateway/inbound-delivery-machine-dispatch.ts
-var enabled5 = process.env.SWITCHROOM_DELIVERY_MACHINE_CUTOVER !== "0";
+var enabled6 = process.env.SWITCHROOM_DELIVERY_MACHINE_CUTOVER !== "0";
 function isDispatchEnabled() {
-  return enabled5;
+  return enabled6;
 }
 function dispatchEffects(effects, ctx) {
-  if (!enabled5)
+  if (!enabled6)
     return;
   for (const effect of effects) {
     dispatchOne(effect, ctx);
@@ -46618,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) {
@@ -46723,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}`);
   }
 }
@@ -46829,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) {
@@ -47075,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();
@@ -48207,10 +48315,10 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.13.19";
-var COMMIT_SHA = "de154395";
-var COMMIT_DATE = "2026-05-23T07:08:03Z";
-var LATEST_PR = 1682;
+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
@@ -49994,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) {
@@ -50260,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}
 `)
     });
@@ -50650,11 +50771,23 @@ async function executeReply(args) {
   if (rawText == null || rawText === "")
     throw new Error("reply: text is required and cannot be empty");
   let text = repairEscapedWhitespace(rawText);
+  {
+    const scrub = scrubVoice(text);
+    if (scrub.replaced > 0) {
+      text = scrub.scrubbed;
+      emitRuntimeMetric({
+        kind: "voice_scrub_applied",
+        chatKey: statusKey(chat_id, args.message_thread_id != null ? Number(args.message_thread_id) : undefined),
+        replaced: scrub.replaced,
+        site: "reply"
+      });
+    }
+  }
   process.stderr.write(`telegram channel: reply: invoked chatId=${chat_id} charCount=${text.length} preview=${JSON.stringify(text.slice(0, 80))}
 `);
   {
     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)}
 `);
@@ -50845,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)}
@@ -51052,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 }] };
 }
@@ -51062,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)}
 `);
@@ -51158,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
@@ -51710,7 +51855,19 @@ async function executeEditMessage(args) {
   const editAccess = loadAccess();
   const editConfigMode = editAccess.parseMode ?? "html";
   const editFormat = args.format ?? editConfigMode;
-  const editRawText = repairEscapedWhitespace(args.text);
+  let editRawText = repairEscapedWhitespace(args.text);
+  {
+    const scrub = scrubVoice(editRawText);
+    if (scrub.replaced > 0) {
+      editRawText = scrub.scrubbed;
+      emitRuntimeMetric({
+        kind: "voice_scrub_applied",
+        chatKey: statusKey(args.chat_id, undefined),
+        replaced: scrub.replaced,
+        site: "edit_message"
+      });
+    }
+  }
   let editParseMode;
   let editText;
   if (editFormat === "html") {
@@ -52058,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)
@@ -52152,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 {
@@ -52252,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,
@@ -52347,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) {
@@ -53237,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