switchroom 0.13.20 → 0.13.22

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.22";
+var COMMIT_SHA = "1706f857";
 
 // src/cli/agent.ts
 init_source();
@@ -48699,6 +48699,8 @@ function applyHindsightSettingsOverrides(pluginDestPath) {
     return;
   }
   settings.retainEveryNTurns = 1;
+  settings.recallMaxMemories = 8;
+  settings.recallMinOverlap = 0.1;
   writeFileSync5(settingsPath, JSON.stringify(settings, null, 2) + `
 `, "utf-8");
 }
@@ -62230,6 +62232,14 @@ var HINDSIGHT_IMAGE = "ghcr.io/switchroom/switchroom-hindsight:latest";
 var HINDSIGHT_DEFAULT_MODEL = "claude-sonnet-4-6";
 var HINDSIGHT_DEFAULT_MCP_STATELESS = true;
 var HINDSIGHT_BROKER_SOCK_VOLUME = `auth-broker-${HINDSIGHT_CONSUMER_NAME}-sock`;
+var HINDSIGHT_DEFAULT_RERANKER_BUCKET_BATCHING = "true";
+var HINDSIGHT_DEFAULT_RERANKER_MAX_CANDIDATES = 150;
+var HINDSIGHT_DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT = 2;
+var HINDSIGHT_DEFAULT_RECALL_MAX_CONCURRENT = 8;
+var HINDSIGHT_DEFAULT_MEM_LIMIT = "4g";
+var HINDSIGHT_DEFAULT_MEM_RESERVATION = "2g";
+var HINDSIGHT_DEFAULT_CPUS = "2.0";
+var HINDSIGHT_DEFAULT_PIDS_LIMIT = 1000;
 function isPortFree(port) {
   return new Promise((resolve25) => {
     const server = createServer3();
@@ -62300,7 +62310,15 @@ function startHindsight(ports) {
     "-e",
     `HINDSIGHT_API_LLM_MODEL=${HINDSIGHT_DEFAULT_MODEL}`,
     "-e",
-    `HINDSIGHT_API_MCP_STATELESS=${HINDSIGHT_DEFAULT_MCP_STATELESS}`
+    `HINDSIGHT_API_MCP_STATELESS=${HINDSIGHT_DEFAULT_MCP_STATELESS}`,
+    "-e",
+    `HINDSIGHT_API_RERANKER_LOCAL_BUCKET_BATCHING=${HINDSIGHT_DEFAULT_RERANKER_BUCKET_BATCHING}`,
+    "-e",
+    `HINDSIGHT_API_RERANKER_MAX_CANDIDATES=${HINDSIGHT_DEFAULT_RERANKER_MAX_CANDIDATES}`,
+    "-e",
+    `HINDSIGHT_API_RERANKER_LOCAL_MAX_CONCURRENT=${HINDSIGHT_DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT}`,
+    "-e",
+    `HINDSIGHT_API_RECALL_MAX_CONCURRENT=${HINDSIGHT_DEFAULT_RECALL_MAX_CONCURRENT}`
   ];
   const args = [
     "run",
@@ -62309,6 +62327,10 @@ function startHindsight(ports) {
     "switchroom-hindsight",
     "--restart",
     "unless-stopped",
+    `--memory=${HINDSIGHT_DEFAULT_MEM_LIMIT}`,
+    `--memory-reservation=${HINDSIGHT_DEFAULT_MEM_RESERVATION}`,
+    `--cpus=${HINDSIGHT_DEFAULT_CPUS}`,
+    `--pids-limit=${HINDSIGHT_DEFAULT_PIDS_LIMIT}`,
     "-p",
     `127.0.0.1:${apiPort}:8888`,
     "-p",
@@ -62355,6 +62377,14 @@ function generateHindsightComposeSnippet() {
     "      - HINDSIGHT_API_LLM_PROVIDER=claude-code",
     `      - HINDSIGHT_API_LLM_MODEL=${HINDSIGHT_DEFAULT_MODEL}`,
     `      - HINDSIGHT_API_MCP_STATELESS=${HINDSIGHT_DEFAULT_MCP_STATELESS}`,
+    `      - HINDSIGHT_API_RERANKER_LOCAL_BUCKET_BATCHING=${HINDSIGHT_DEFAULT_RERANKER_BUCKET_BATCHING}`,
+    `      - HINDSIGHT_API_RERANKER_MAX_CANDIDATES=${HINDSIGHT_DEFAULT_RERANKER_MAX_CANDIDATES}`,
+    `      - HINDSIGHT_API_RERANKER_LOCAL_MAX_CONCURRENT=${HINDSIGHT_DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT}`,
+    `      - HINDSIGHT_API_RECALL_MAX_CONCURRENT=${HINDSIGHT_DEFAULT_RECALL_MAX_CONCURRENT}`,
+    `    mem_limit: ${HINDSIGHT_DEFAULT_MEM_LIMIT}`,
+    `    mem_reservation: ${HINDSIGHT_DEFAULT_MEM_RESERVATION}`,
+    `    cpus: ${HINDSIGHT_DEFAULT_CPUS}`,
+    `    pids_limit: ${HINDSIGHT_DEFAULT_PIDS_LIMIT}`,
     "    volumes:",
     "      - switchroom-hindsight-data:/home/hindsight/.pg0",
     `      - ${HINDSIGHT_BROKER_SOCK_VOLUME}:/run/switchroom/auth-broker`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.13.20",
+  "version": "0.13.22",
   "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/_base/start.sh.hbs

@@ -207,14 +207,15 @@ export HINDSIGHT_AGENT_NAME="{{name}}"
 export HINDSIGHT_RECALL_MAX_MEMORIES={{hindsightRecallMaxMemories}}
 {{/if}}
 # Per-session recall cache (#424 phase 4.1). Identical (prompt, bank)
-# within a session reuses the prior recall result instead of round-
-# tripping to Hindsight. Defaults to 600s (10 min); operators can
-# override via memory.recall.cache_ttl_secs in switchroom.yaml.
-# Setting it to 0 disables caching for that agent.
+# within a session reuses the prior recall result. v0.13.22: the
+# unconditional default-600s export was dropped — the 2026-05-24
+# audit measured 0% hit rate across 430+ Telegram turns (cache key
+# is `(session_id, prompt, bank, extra_banks)`; each Telegram inbound
+# is unique). Operators who run Claude Code interactively (where
+# prompt-repeat happens) can still opt in via memory.recall.cache_ttl_secs
+# in switchroom.yaml. Setting it to 0 disables caching for that agent.
 {{#if (isNumber hindsightRecallCacheTtlSecs)}}
 export HINDSIGHT_RECALL_CACHE_TTL_SECS={{hindsightRecallCacheTtlSecs}}
-{{else}}
-export HINDSIGHT_RECALL_CACHE_TTL_SECS=600
 {{/if}}
 # Lexical-overlap relevance gate (#475). Drops memories whose Jaccard
 # overlap with the user's query is below this threshold (range 0.0–1.0).

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.22";
+var COMMIT_SHA = "1706f857";
+var COMMIT_DATE = "2026-05-23T23:20:14Z";
+var LATEST_PR = 1700;
 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