switchroom 0.13.19 → 0.13.21

package/telegram-plugin/gateway/gateway.ts

@@ -154,6 +154,7 @@ const SILENT_END_FALLBACK_TEXT =
   '⚠️ The agent finished working but didn’t send a reply — your last ' +
   'message may not have been answered. Please try asking again.'
 import { markdownToHtml, splitHtmlChunks, repairEscapedWhitespace, telegramHtmlToPlainText } from '../format.js'
+import { scrubVoice } from '../text-voice-scrub.js'
 import {
   validateInlineKeyboard,
   type AnyButton,
@@ -3083,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
@@ -3578,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`),
     })
   },
@@ -4197,6 +4234,26 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
   const rawText = args.text as string | undefined
   if (rawText == null || rawText === '') throw new Error('reply: text is required and cannot be empty')
   let text = repairEscapedWhitespace(rawText)
+  // Voice scrub (#1683): replace em / en dashes with commas / periods.
+  // Runs BEFORE outboundDedup so retries see the scrubbed key, and
+  // BEFORE markdownToHtml so code-block content is correctly parked
+  // by the scrubber's own placeholder pass (otherwise the html
+  // converter would have already escaped/parked code, and the scrub
+  // would see only the parked placeholders). Kill switch:
+  // `SWITCHROOM_DISABLE_VOICE_SCRUB=1`.
+  {
+    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))}\n`)
 
   // #546 dedup check: was this content just sent via turn-flush or
@@ -4206,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} ` +
@@ -4540,6 +4597,7 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
             threadId,
             decision.mergedText,
             Date.now(),
+            turn?.registryKey ?? null,
           )
 
           silentAnchorEditDone = true
@@ -4864,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 }] }
 }
@@ -4875,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
@@ -4885,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} ` +
@@ -5049,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
@@ -5842,7 +5925,23 @@ async function executeEditMessage(args: Record<string, unknown>): Promise<unknow
   const editAccess = loadAccess()
   const editConfigMode = editAccess.parseMode ?? 'html'
   const editFormat = (args.format as string | undefined) ?? editConfigMode
-  const editRawText = repairEscapedWhitespace(args.text as string)
+  let editRawText = repairEscapedWhitespace(args.text as string)
+  // Voice scrub (#1683): same em-dash scrub as the reply path. Edits
+  // are how silent-anchor and progress-update mutate already-sent
+  // bubbles, so without this an edit can re-introduce dashes the
+  // original send had scrubbed out.
+  {
+    const scrub = scrubVoice(editRawText)
+    if (scrub.replaced > 0) {
+      editRawText = scrub.scrubbed
+      emitRuntimeMetric({
+        kind: 'voice_scrub_applied',
+        chatKey: statusKey(args.chat_id as string, undefined),
+        replaced: scrub.replaced,
+        site: 'edit_message',
+      })
+    }
+  }
   let editParseMode: 'HTML' | 'MarkdownV2' | undefined
   let editText: string
   if (editFormat === 'html') {
@@ -6345,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
@@ -6509,6 +6608,7 @@ function handleSessionEvent(ev: SessionEvent): void {
               turn.sessionThreadId,
               streamedFinalText,
               Date.now(),
+              turn.registryKey ?? null,
             )
           } catch { /* best-effort */ }
           if (HISTORY_ENABLED) {
@@ -6678,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.
@@ -6874,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
@@ -8418,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'
 }

package/telegram-plugin/handoff-continuity.ts

@@ -5,7 +5,7 @@
  * (written by the summarizer Stop hook). On the FIRST assistant reply
  * of the new session the plugin prepends a subtle one-liner:
  *
- *   ↩️ Picked up where we left off — <topic>
+ *   ↩️ Picked up where we left off, <topic>
  *
  * The sidecar is consumed (read + deleted) so the line only fires once.
  * All helpers here are filesystem-only or env-only — no Telegram side
@@ -175,7 +175,13 @@ export function formatHandoffLine(
   topic: string,
   format: HandoffFormat,
 ): string {
-  const prefix = "↩️ Picked up where we left off — ";
+  // Comma instead of em-dash: the framework-emitted prefix is
+  // concatenated AFTER scrubVoice runs on the model body (gateway.ts
+  // executeReply), so any em-dash here bypasses the v0.13.20 voice
+  // scrub. Replacing at the template source is one mechanical change
+  // that closes the dominant residual em-dash leak (16 of 17 dashed
+  // messages on test-harness were this template per 2026-05-24 audit).
+  const prefix = "↩️ Picked up where we left off, ";
   if (format === "html") {
     return `<i>${prefix}${escapeHtml(topic)}</i>\n\n`;
   }

package/telegram-plugin/recent-outbound-dedup.ts

@@ -57,6 +57,16 @@ interface DedupEntry {
   /** First 80 chars of the original (un-normalized) text — for
    *  operator-facing log lines that show what got deduped. */
   preview: string
+  /** The `currentTurn.registryKey` at record time, or `null` if the
+   *  recording site had no turn context. Threaded through so check()
+   *  can distinguish within-turn retries (#546 bug class — keep
+   *  protecting) from cross-turn coincidences (2026-05-23 audit found
+   *  identical mid-turn + final replies across two turns ~30s apart
+   *  silently swallowing the second turn's answer; the user gets
+   *  no response to their second question). Null on either side
+   *  matches as before, preserving the boot-time / edge-case behaviour
+   *  the original tests pin. */
+  turnKey: string | null
 }
 
 /**
@@ -75,8 +85,21 @@ export class OutboundDedupCache {
   /** Record an outbound message. Caller should invoke this after a
    *  successful send, regardless of which path sent it (turn-flush,
    *  executeReply, executeStreamReply, etc.). Short content is not
-   *  recorded — see DEDUP_MIN_CONTENT_LEN. */
-  record(chatId: string, threadId: number | undefined, text: string, now: number): void {
+   *  recorded — see DEDUP_MIN_CONTENT_LEN.
+   *
+   *  `turnKey` lets check() tell within-turn retries (the #546 race
+   *  this module exists to catch) apart from cross-turn coincidences
+   *  (a user asking similar questions in different turns). Pass
+   *  `null` if the recording site has no turn context — that matches
+   *  legacy behaviour and is what the early-boot / fallback callers
+   *  pass. */
+  record(
+    chatId: string,
+    threadId: number | undefined,
+    text: string,
+    now: number,
+    turnKey: string | null = null,
+  ): void {
     if (text.length < DEDUP_MIN_CONTENT_LEN) return
     const key = makeKey(chatId, threadId)
     const list = this.entries.get(key) ?? []
@@ -85,6 +108,7 @@ export class OutboundDedupCache {
       hash: normalizeForDedup(text),
       ts: now,
       preview: text.slice(0, 80),
+      turnKey,
     })
     this.entries.set(key, list)
   }
@@ -92,12 +116,24 @@ export class OutboundDedupCache {
   /** Check whether the given text was already sent recently to the
    *  same chat. Returns the matched entry's preview + age on hit, or
    *  null on miss. Caller decides what to do with the answer
-   *  (skip-send, log, etc.). */
+   *  (skip-send, log, etc.).
+   *
+   *  Cross-turn carve-out (2026-05-23 fix): when both sides of a hash
+   *  match carry non-null `turnKey` AND those keys differ, treat as
+   *  miss. The duplicate-reply race this module was built for (#546)
+   *  is strictly within-turn (the same turn's buffered text replays
+   *  via a stream_reply retry), so within-turn retries continue to
+   *  hit. A user typing two similar prompts back-to-back used to lose
+   *  the second turn's reply because the hashes collided across
+   *  turns; that no longer happens. Null on EITHER side (legacy /
+   *  no-turn-context callers) still matches — preserves backward
+   *  compatibility with the original test suite + early-boot paths. */
   check(
     chatId: string,
     threadId: number | undefined,
     text: string,
     now: number,
+    turnKey: string | null = null,
   ): { matched: true; preview: string; ageMs: number } | null {
     if (text.length < DEDUP_MIN_CONTENT_LEN) return null
     const key = makeKey(chatId, threadId)
@@ -106,9 +142,19 @@ export 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
+      // Cross-turn carve-out: distinct, non-null turnKeys on both
+      // sides ⇒ different turns ⇒ not a #546 retry. Skip past this
+      // entry and keep scanning (a same-turn match later in the list
+      // should still hit).
+      if (
+        turnKey != null
+        && entry.turnKey != null
+        && entry.turnKey !== turnKey
+      ) {
+        continue
       }
+      return { matched: true, preview: entry.preview, ageMs: now - entry.ts }
     }
     return null
   }

package/telegram-plugin/runtime-metrics.ts

@@ -142,6 +142,28 @@ export type RuntimeMetricEvent =
       key: string
       sinceFirstPingMs: number
     }
+  /**
+   * Voice scrubber engaged: em / en dashes were rewritten to commas /
+   * periods on an outbound reply. Each event is a soft-layer policy
+   * violation the framework caught (SOUL.md.hbs "never use em-dashes"
+   * is the soft layer, this scrub is the hard layer). Fleet-wide
+   * trend over weeks shows whether the soft prompt is gaining or
+   * losing ground; a per-agent spike is prompt drift on that agent.
+   *
+   *   chatKey   → `<chatId>:<threadIdOrEmpty>` (statusKey shape)
+   *   replaced  → count of dashes rewritten in this single message
+   *   site      → which reply path saw the scrub (executeReply / edit / answer-stream)
+   */
+  | {
+      kind: 'voice_scrub_applied'
+      chatKey: string
+      replaced: number
+      // `stream_reply` and `turn_flush` added in v0.13.21 — modern
+      // Claude routes most multi-paragraph replies through the
+      // answer-stream / draft-stream path, bypassing the v0.13.20
+      // executeReply scrub site. The two new sites close that gap.
+      site: 'reply' | 'edit_message' | 'progress_update' | 'answer_stream' | 'stream_reply' | 'turn_flush'
+    }
 
 /**
  * The JSONL sink lives under the runtime state dir so it's per-agent

package/telegram-plugin/subagent-watcher.ts

@@ -459,7 +459,10 @@ function backfillJsonlAgentId(
   log?.(`subagent-watcher: backfill linked ${agentId} → ${candidate.id}`)
 }
 
-function readSubTail(
+// Exported for unit-testing the ENOENT/EACCES deregister path
+// (telegram-plugin/tests/subagent-watcher-enoent-deregister.test.ts).
+// Not intended for consumption by other modules.
+export function readSubTail(
   entry: WorkerEntry,
   tail: SubTail,
   now: number,
@@ -472,6 +475,14 @@ function readSubTail(
    *  previously-stalled entry. Closes the resume edge the schema doc
    *  has always promised. */
   onUnstall?: (agentId: string, description: string) => void,
+  /** Fires when the JSONL file is no longer accessible (ENOENT — file
+   *  reaped by Claude Code when the parent session ends; EACCES —
+   *  permission change mid-poll). The caller deregisters the entry so
+   *  the 1s poll loop stops re-statting a dead path. Without this
+   *  callback, every poll re-emits the error log line — on 2026-05-23
+   *  the clerk agent logged 540k ENOENT lines in 3 days (30/sec
+   *  sustained) AND leaked one fs.watch FD per stranded entry. */
+  onFileVanished?: (agentId: string, code: 'ENOENT' | 'EACCES') => void,
 ): void {
   try {
     const stat = fs.statSync(entry.filePath)
@@ -639,6 +650,17 @@ function readSubTail(
     }
     tail.hasEmittedStart = startState.hasEmittedStart
   } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code
+    if (code === 'ENOENT' || code === 'EACCES') {
+      // JSONL is gone (Claude Code reaped the parent session's
+      // subagents/ dir) or permission flipped under us. Deregister the
+      // entry so the periodic poll stops re-emitting this same line
+      // forever. Logged ONCE per agent — operators can still audit
+      // which entries got reaped without 30 lines/sec of noise.
+      log?.(`subagent-watcher: JSONL vanished for ${entry.agentId} (${code}) — deregistering`)
+      onFileVanished?.(entry.agentId, code)
+      return
+    }
     log?.(`subagent-watcher: read error ${entry.agentId}: ${(err as Error).message}`)
   }
 }
@@ -841,7 +863,7 @@ export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWat
         if (!entry || !t) return
         readSubTail(entry, t, nowFn(), (desc) => {
           log?.(`subagent-watcher: description updated for ${agentId}: ${desc}`)
-        }, fs, log, db, parentStateDir, config.onUnstall)
+        }, fs, log, db, parentStateDir, config.onUnstall, cleanupTerminalAgent)
         maybySendStateTransition(agentId)
       })
     } catch (err) {
@@ -1179,7 +1201,7 @@ export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWat
       if (!tail) continue
       readSubTail(entry, tail, n, (desc) => {
         log?.(`subagent-watcher: description updated for ${agentId}: ${desc}`)
-      }, fs, log, db, parentStateDir, config.onUnstall)
+      }, fs, log, db, parentStateDir, config.onUnstall, cleanupTerminalAgent)
       maybySendStateTransition(agentId)
     }
 

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

@@ -142,3 +142,117 @@ describe('flushOnAgentDisconnect — registered agent disconnects (existing beha
     expect(deps.activeDraftParseModes.size).toBe(0)
   })
 })
+
+describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)', () => {
+  // The race that motivates this: the canonical reply path fires
+  // `setDone()` on the StatusReactionController BEFORE purgeReactionTracking
+  // runs `activeTurnStartedAt.delete(key)`. If the bridge crashes between
+  // those two steps, the controller loop sees an EMPTY activeStatusReactions
+  // (already cleared by setDone) but activeTurnStartedAt still has the key.
+  // Without the sweep, that key orphans and the next inbound is "held mid-
+  // turn" against a ghost.
+
+  it('sweeps activeTurnStartedAt keys the controller loop missed', () => {
+    // Construct the exact race: activeStatusReactions is EMPTY (setDone
+    // already cleared it on the reply path) but activeTurnStartedAt still
+    // has an entry.
+    const onDanglingTurnsSwept = vi.fn()
+    const clearActiveReactions = vi.fn()
+    const disposeProgressDriver = vi.fn()
+    const log = vi.fn()
+    const deps = {
+      agentName: 'clerk',
+      activeStatusReactions: new Map<string, FakeCtrl>(),
+      activeReactionMsgIds: new Map<string, { chatId: string; messageId: number }>([
+        ['ghost:thr:msg', { chatId: 'ghost', messageId: 42 }],
+      ]),
+      activeTurnStartedAt: new Map<string, number>([['ghost:thr:msg', 100]]),
+      activeDraftStreams: new Map<string, FakeStream>(),
+      activeDraftParseModes: new Map<string, 'HTML' | 'MarkdownV2' | undefined>(),
+      clearActiveReactions,
+      disposeProgressDriver,
+      onDanglingTurnsSwept,
+      log,
+    }
+
+    flushOnAgentDisconnect(deps)
+
+    // The sweep fired and cleared the dangling entry.
+    expect(deps.activeTurnStartedAt.size).toBe(0)
+    expect(deps.activeReactionMsgIds.size).toBe(0)
+    expect(onDanglingTurnsSwept).toHaveBeenCalledTimes(1)
+    expect(onDanglingTurnsSwept.mock.calls[0][0]).toEqual(['ghost:thr:msg'])
+    // The log line names what happened so the operator can audit.
+    expect(
+      log.mock.calls.some((c: unknown[]) =>
+        typeof c[0] === 'string' && /swept .* dangling turn/.test(c[0]),
+      ),
+    ).toBe(true)
+  })
+
+  it('does not fire the sweep when the controller loop already cleaned up everything', () => {
+    // Normal-path disconnect: activeStatusReactions had entries, the
+    // controller loop ran setDone + delete on each, activeTurnStartedAt
+    // is already empty by the end of the loop. No dangling to sweep.
+    const { spies, deps } = makeDeps('clerk')
+    const onDanglingTurnsSwept = vi.fn()
+    const depsWithCallback = { ...deps, onDanglingTurnsSwept }
+
+    flushOnAgentDisconnect(depsWithCallback)
+
+    // Controller loop already cleaned both entries.
+    expect(deps.activeTurnStartedAt.size).toBe(0)
+    // Callback NOT fired — nothing left to sweep after the loop.
+    expect(onDanglingTurnsSwept).not.toHaveBeenCalled()
+    // Regression: the existing setDone path still works.
+    expect(spies.setDoneA).toHaveBeenCalledTimes(1)
+    expect(spies.setDoneB).toHaveBeenCalledTimes(1)
+  })
+
+  it('does NOT sweep for anonymous disconnects (no agent registered)', () => {
+    // Critical regression guard: the sweep MUST be gated by the
+    // agentName-null early-return. Anonymous one-shot IPC clients
+    // (recall.py, etc.) disconnect constantly and must never touch
+    // turn state.
+    const onDanglingTurnsSwept = vi.fn()
+    const deps = {
+      agentName: null,
+      activeStatusReactions: new Map<string, FakeCtrl>(),
+      activeReactionMsgIds: new Map<string, { chatId: string; messageId: number }>(),
+      activeTurnStartedAt: new Map<string, number>([['real-turn:thr:msg', 100]]),
+      activeDraftStreams: new Map<string, FakeStream>(),
+      activeDraftParseModes: new Map<string, 'HTML' | 'MarkdownV2' | undefined>(),
+      clearActiveReactions: vi.fn(),
+      disposeProgressDriver: vi.fn(),
+      onDanglingTurnsSwept,
+      log: vi.fn(),
+    }
+
+    flushOnAgentDisconnect(deps)
+
+    // Anonymous disconnect: turn state preserved, sweep callback not fired.
+    expect(deps.activeTurnStartedAt.size).toBe(1)
+    expect(onDanglingTurnsSwept).not.toHaveBeenCalled()
+  })
+
+  it('omitting onDanglingTurnsSwept is safe (optional callback)', () => {
+    // Backward-compat guard — existing callers that don't pass the new
+    // callback still work without runtime error.
+    const deps = {
+      agentName: 'clerk',
+      activeStatusReactions: new Map<string, FakeCtrl>(),
+      activeReactionMsgIds: new Map<string, { chatId: string; messageId: number }>(),
+      activeTurnStartedAt: new Map<string, number>([['ghost:thr:msg', 100]]),
+      activeDraftStreams: new Map<string, FakeStream>(),
+      activeDraftParseModes: new Map<string, 'HTML' | 'MarkdownV2' | undefined>(),
+      clearActiveReactions: vi.fn(),
+      disposeProgressDriver: vi.fn(),
+      // onDanglingTurnsSwept intentionally omitted.
+      log: vi.fn(),
+    }
+
+    expect(() => flushOnAgentDisconnect(deps)).not.toThrow()
+    // The sweep still happens, just without the callback observation.
+    expect(deps.activeTurnStartedAt.size).toBe(0)
+  })
+})