switchroom 0.18.18 → 0.18.20

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

@@ -6835,12 +6835,13 @@ function addParagraphSpacers(text) {
 
 `))
     return restore(masked);
-  const spacerLine = PARAGRAPH_SPACER;
-  const isBlankLine = (line) => /^[ \t\r\f\v]*$/.test(line);
+  const SP = PARAGRAPH_SPACER;
   const asciiTrim = (line) => line.replace(/^[ \t\r\f\v]+|[ \t\r\f\v]+$/g, "");
+  const isBlankish = (line) => {
+    const t = asciiTrim(line);
+    return t === "" || t === SP;
+  };
   const blockKind = (line) => {
-    if (asciiTrim(line) === spacerLine)
-      return "spacer";
     if (isFenceOpenLine(line, placeholder))
       return "fence";
     if (isListItemLine(line))
@@ -6865,58 +6866,65 @@ function addParagraphSpacers(text) {
   const shouldSpaceGap = (above, below) => {
     const a = blockKind(above);
     const b = blockKind(below);
-    if (a === "spacer" || b === "spacer")
-      return false;
     if (a === b && SAME_KIND_TIGHT.has(a))
       return false;
     return true;
   };
-  const lines = masked.split(`
-`);
+  const toks = [];
+  for (const line of masked.split(`
+`)) {
+    const kind = isBlankish(line) ? "gap" : "content";
+    const last = toks[toks.length - 1];
+    if (last && last.kind === kind)
+      last.lines.push(line);
+    else
+      toks.push({ kind, lines: [line] });
+  }
   const out = [];
-  for (let i = 0;i < lines.length; i++) {
-    const line = lines[i];
-    const isBlank = isBlankLine(line);
-    if (isBlank) {
-      const prevEmitted = out.length > 0 ? out[out.length - 1] : null;
-      const prevIsBlank = prevEmitted != null && isBlankLine(prevEmitted);
-      if (!prevIsBlank) {
-        const above = lastNonBlank(out, isBlankLine);
-        const below = nextNonBlank(lines, i + 1, isBlankLine);
-        const alreadySpaced = above != null && asciiTrim(above) === spacerLine || below != null && asciiTrim(below) === spacerLine;
-        if (!alreadySpaced && above != null && below != null && shouldSpaceGap(above, below)) {
-          out.push("");
-          out.push(spacerLine);
-          out.push("");
-          continue;
-        }
-      }
+  for (let i = 0;i < toks.length; i++) {
+    const tok = toks[i];
+    if (tok.kind === "content") {
+      out.push(...tok.lines);
+      continue;
+    }
+    const prev = toks[i - 1];
+    const next = toks[i + 1];
+    if (prev?.kind === "content" && next?.kind === "content") {
+      const above = prev.lines[prev.lines.length - 1];
+      const below = next.lines[0];
+      if (shouldSpaceGap(above, below))
+        out.push("", SP, "");
+      else
+        out.push("");
+    } else {
+      out.push(...tok.lines);
     }
-    out.push(line);
   }
   return restore(out.join(`
 `));
 }
-function lastNonBlank(arr, isBlank) {
-  for (let i = arr.length - 1;i >= 0; i--) {
-    if (!isBlank(arr[i]))
-      return arr[i];
-  }
-  return null;
-}
-function nextNonBlank(lines, from, isBlank) {
-  for (let i = from;i < lines.length; i++) {
-    if (!isBlank(lines[i]))
-      return lines[i];
-  }
-  return null;
-}
 function normalizePunctuation(text) {
   if (!/[\u2014\u2013\u2022\u00b7]/.test(text))
     return text;
   const nonce = Math.random().toString(36).slice(2);
   const { masked, restore } = maskCodeRegions(text, nonce);
-  let out = masked.replace(/(\S)[ \t][\u2014\u2013][ \t](?=(\S))/g, (_m, a, b) => /\d/.test(a) && /\d/.test(b) ? `${a}-` : `${a}, `).replace(/(\w)\u2014(?=(\w))/g, (_m, a, b) => /\d/.test(a) && /\d/.test(b) ? `${a}-` : `${a}, `).replace(/(\w)\u2013(?=\w)/g, "$1-");
+  const linkMasks = [];
+  const LINK_MASK_PH = `\x00RML${nonce}_`;
+  const maskedLinks = masked.replace(/(\]\()([^)\n]*)(\))/g, (_m, open, href, close) => {
+    const idx = linkMasks.length;
+    linkMasks.push(href);
+    return `${open}${LINK_MASK_PH}${idx}\x00${close}`;
+  });
+  const maskedAutolinks = maskedLinks.replace(/(<)([a-zA-Z][a-zA-Z0-9+.-]*:[^>\s]*)(>)/g, (_m, lt, uri, gt) => {
+    const idx = linkMasks.length;
+    linkMasks.push(uri);
+    return `${lt}${LINK_MASK_PH}${idx}\x00${gt}`;
+  });
+  const escNonce = nonce.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const linkRestoreRe = new RegExp(`\x00RML${escNonce}_(\\d+)\x00`, "g");
+  const restoreLinks = (s) => s.replace(linkRestoreRe, (_m, idx) => linkMasks[Number(idx)] ?? _m);
+  let out = maskedAutolinks.replace(/(\S)[ \t][\u2014\u2013][ \t](?=(\S))/g, (_m, a, b) => /\d/.test(a) && /\d/.test(b) ? `${a}-` : `${a}, `).replace(/(\w)\u2014(?=(\w))/g, (_m, a, b) => /\d/.test(a) && /\d/.test(b) ? `${a}-` : `${a}, `).replace(/(\w)\u2013(?=\w)/g, "$1-");
+  out = restoreLinks(out);
   out = out.split(`
 `).map((line) => line.replace(/^([ \t]*)[\u2022\u00b7][ \t]+/, "$1- ")).join(`
 `);
@@ -7109,6 +7117,7 @@ function splitMarkdownChunks(text, maxLen = RICH_MESSAGE_MAX_CHARS) {
     }
     cut = backOffOpenFence(rest, cut);
     cut = backOffTableRow(rest, cut);
+    cut = backOffOpenInline(rest, cut);
     if (cut <= 0) {
       const sliced = hardSliceToCap(rest, maxLen);
       chunks.push(stripBoundarySpacers(sliced[0], "trailing"));
@@ -7154,7 +7163,38 @@ function backOffTableRow(text, cut) {
   }
   return cut;
 }
-var RICH_MESSAGE_MAX_CHARS = 32768, PARAGRAPH_SPACER = "\u00a0";
+function backOffOpenInline(text, cut) {
+  if (cut <= 0 || cut >= text.length)
+    return cut;
+  let earliest = cut;
+  for (const re of INLINE_SPAN_PATTERNS) {
+    re.lastIndex = 0;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      const start = m.index;
+      const end = start + m[0].length;
+      if (start < cut && cut < end && start < earliest)
+        earliest = start;
+      if (start >= cut)
+        break;
+      if (re.lastIndex === start)
+        re.lastIndex = start + 1;
+    }
+  }
+  return earliest;
+}
+var RICH_MESSAGE_MAX_CHARS = 32768, PARAGRAPH_SPACER = "\u00a0", INLINE_SPAN_PATTERNS;
+var init_format = __esm(() => {
+  INLINE_SPAN_PATTERNS = [
+    /`[^`\n]+`/g,
+    /\*\*\*[^*\n]+\*\*\*/g,
+    /___[^_\n]+___/g,
+    /\*\*[^*\n]+\*\*/g,
+    /__[^_\n]+__/g,
+    /(?<![\w*])_[^_\n]+_(?![\w*])/g,
+    /\[[^\]\n]*\]\([^)\n]*\)/g
+  ];
+});
 
 // text-voice-scrub.ts
 function enabled() {
@@ -7339,6 +7379,7 @@ function cleanWorkerResultParagraph(s) {
   return kept.join(" ").replace(/\s+/g, " ").trim();
 }
 var init_card_format = __esm(() => {
+  init_format();
   init_text_voice_scrub();
 });
 
@@ -7480,6 +7521,7 @@ function ttlMsFromToken(token) {
 }
 var import_grammy3;
 var init_approval_card = __esm(() => {
+  init_format();
   import_grammy3 = __toESM(require_mod2(), 1);
 });
 
@@ -36885,6 +36927,7 @@ function parseConfigApprovalCallback(data) {
 var pending, TELEGRAM_SENDMESSAGE_LIMIT2 = 32768, RENDERED_BODY_CAP2 = 32000, REASON_MAX_CHARS = 500, REASON_ELLIPSIS = "\u2026", DIFF_SENTINEL = `
 [\u2026 diff continues, see attached file]`;
 var init_config_approval_handler = __esm(() => {
+  init_format();
   pending = new Map;
 });
 
@@ -37009,6 +37052,7 @@ ${detail}`)));
   });
 }
 var init_approvals_commands = __esm(() => {
+  init_format();
   init_rich_send();
   init_client3();
 });
@@ -39778,6 +39822,7 @@ class DeferredDoneReactions {
 init_card_format();
 
 // status-no-truncate.ts
+init_format();
 var STATUS_ROLLING_LINES = 5;
 var STATUS_LINE_MAX = 200;
 var STATUS_CARD_CHAR_BUDGET = RICH_MESSAGE_MAX_CHARS;
@@ -40252,27 +40297,43 @@ function renderActivityFeedWithNested(lines, childLines, final = false, liveSuff
   });
 }
 var COMBINED_ROW_DESC_MAX = 72;
+var MAX_COMBINED_BODY_LINES = 13;
+var PER_WORKER_HEADER_COST = 1;
+function combinedHistoryDepth(w) {
+  if (w <= 0)
+    return 1;
+  const raw = Math.floor((MAX_COMBINED_BODY_LINES - PER_WORKER_HEADER_COST * w) / w);
+  return Math.max(1, Math.min(STATUS_ROLLING_LINES, raw));
+}
 function renderCombinedWorkerFeed(rows, opts) {
   if (rows.length === 0)
     return null;
   const maxRows = Math.max(1, Math.floor(opts.maxRows));
-  const rowLines = (r) => {
+  const rowHeader = (r) => {
     const desc = escapeMarkdown(truncate(stripMarkdown(r.description).replace(/\s+/g, " ").trim() || "background task", COMBINED_ROW_DESC_MAX));
     const toolWord = r.toolCount === 1 ? "tool" : "tools";
     const modelLabel = formatModelLabel(r.model);
     const modelPart = modelLabel != null ? ` \u00b7 ${escapeMarkdown(modelLabel)}` : "";
-    const header = `**${desc}** _\u00b7 ${formatFeedElapsed(r.elapsedMs)} \u00b7 ${r.toolCount} ${toolWord}${modelPart}_`;
-    const stepClean = stripMarkdown(r.currentStep).replace(/\s+/g, " ").trim();
-    const step = stepClean.length > 0 ? `\u2192 _${escapeMarkdown(truncate(stepClean, STATUS_LINE_MAX))}_` : `\u2192 _starting\u2026_`;
-    return [header, step];
+    return `**${desc}** _\u00b7 ${formatFeedElapsed(r.elapsedMs)} \u00b7 ${r.toolCount} ${toolWord}${modelPart}_`;
+  };
+  const rowHistory = (r) => {
+    const src = r.historyLines != null && r.historyLines.length > 0 ? r.historyLines : [r.currentStep];
+    return src.filter((s) => s != null && stripMarkdown(s).replace(/\s+/g, " ").trim().length > 0);
   };
   const compose = (visibleCount) => {
     const shown = rows.slice(0, visibleCount);
     const hidden = rows.length - shown.length;
+    const depth = combinedHistoryDepth(shown.length);
     const out = [`\uD83D\uDEE0 **Workers** \u00b7 _${rows.length} running_`];
     for (const r of shown) {
-      const [h, s] = rowLines(r);
-      out.push(h, s);
+      out.push(rowHeader(r));
+      const hist = rowHistory(r);
+      if (hist.length === 0) {
+        out.push("\u2192 _starting\u2026_");
+        continue;
+      }
+      const esc = hist.slice(-depth).map(escapeStepLine);
+      renderStepFeed(out, esc, false);
     }
     if (hidden > 0)
       out.push(`_+${hidden} more working\u2026_`);
@@ -40349,7 +40410,7 @@ function isWorkerActivityFeedEnabled(envVal) {
 var DESC_MAX = 80;
 function renderWorkerActivity(v, liveSuffix = "") {
   const desc = truncate(stripMarkdown(v.description).trim() || "background task", DESC_MAX);
-  const finished = v.state === "done" || v.state === "failed";
+  const finished = v.state === "done" || v.state === "failed" || v.state === "incomplete";
   const rawSteps = (v.narrativeLines ?? []).filter((s) => s != null && s.trim().length > 0);
   let steps = rawSteps;
   if (steps.length === 0 && !finished) {
@@ -40367,7 +40428,7 @@ function renderWorkerActivity(v, liveSuffix = "") {
     model: v.model
   };
   let result;
-  if (finished) {
+  if (finished && v.state !== "incomplete") {
     const text = cleanWorkerResultParagraph(v.latestSummary);
     if (text.length > 0)
       result = { emoji: v.state === "done" ? "\u2705" : "\u26a0\ufe0f", text };
@@ -40421,6 +40482,7 @@ function createWorkerActivityFeed(opts) {
   const firstPaintMin = opts.firstPaintMinMs ?? 8000;
   const heartbeatTickMs = opts.heartbeatTickMs ?? 6000;
   const maxRows = Math.max(1, Math.floor(opts.maxRows ?? 8));
+  const staleWorkerTtlMs = Math.max(1, Math.floor(opts.staleWorkerTtlMs ?? 50 * 60000));
   const reconcilePinFn = opts.reconcilePin ?? (() => {});
   const setIntervalFn = opts.setInterval ?? ((cb, ms) => {
     const t = setInterval(cb, ms);
@@ -40522,6 +40584,7 @@ function createWorkerActivityFeed(opts) {
         elapsedMs: elapsedFor(r),
         toolCount: v.toolCount,
         currentStep,
+        historyLines: r.narrative.length > 0 ? [...r.narrative] : undefined,
         model: v.model
       };
     });
@@ -40641,8 +40704,60 @@ function createWorkerActivityFeed(opts) {
       log(`worker-feed: edit transient error feed=${g.feedKey}: ${err.message}`);
     }
   }
+  function finalizeWorker(group, agentId, row, view) {
+    row.finished = true;
+    row.state = view.state;
+    markFinalized(agentId);
+    group.chain = group.chain.then(() => {
+      const others = runningRows(group).filter((w) => w.agentId !== agentId);
+      if (others.length > 0) {
+        removeWorker(group, agentId);
+        syncPin(group);
+        return doRender(group, { force: true });
+      }
+      const recap = { ...view, narrativeLines: [...row.narrative] };
+      return doRender(group, { force: true, terminalRecap: recap, finishingAgentId: agentId });
+    }).catch((err) => {
+      log(`worker-feed: finalize chain error ${agentId}: ${err.message}`);
+    });
+    return group.chain;
+  }
+  function terminateWorker(agentId) {
+    const g = groupOfAgent(agentId);
+    const row = g?.workers.get(agentId);
+    if (g == null || row == null) {
+      markFinalized(agentId);
+      return Promise.resolve();
+    }
+    if (row.finished) {
+      return g.chain;
+    }
+    const lv = row.lastView;
+    const view = {
+      description: lv?.description ?? "background task",
+      lastTool: null,
+      toolCount: lv?.toolCount ?? 0,
+      latestSummary: "",
+      elapsedMs: liveElapsed(row, nowFn()),
+      state: "incomplete",
+      model: lv?.model
+    };
+    return finalizeWorker(g, agentId, row, view);
+  }
   function heartbeatTick() {
     const now = nowFn();
+    const staleAgentIds = [];
+    for (const g of groups.values()) {
+      for (const row of g.workers.values()) {
+        if (!row.finished && now - row.lastUpdateAt >= staleWorkerTtlMs) {
+          staleAgentIds.push(row.agentId);
+        }
+      }
+    }
+    for (const agentId of staleAgentIds) {
+      log(`worker-feed: TTL reap agent=${agentId} \u2014 no update in ${Math.floor((now - (groupOfAgent(agentId)?.workers.get(agentId)?.lastUpdateAt ?? now)) / 1000)}s (>= ${Math.floor(staleWorkerTtlMs / 1000)}s); force-terminating leaked row`);
+      terminateWorker(agentId);
+    }
     for (const g of [...groups.values()]) {
       if (g.pendingFinalize != null && now >= g.cooldownUntil) {
         const recap = g.pendingFinalize;
@@ -40728,12 +40843,14 @@ function createWorkerActivityFeed(opts) {
           lastView: null,
           state: "running",
           finished: false,
+          lastUpdateAt: nowFn(),
           dispatchAtMs: null,
           stepStartedAtMs: null
         };
         g.workers.set(agentId, row);
         agentIndex.set(agentId, feedKey);
       }
+      row.lastUpdateAt = nowFn();
       accumulateNarrative(row, view);
       row.state = "running";
       row.lastView = { ...view, narrativeLines: [...row.narrative] };
@@ -40752,23 +40869,10 @@ function createWorkerActivityFeed(opts) {
         markFinalized(agentId);
         return Promise.resolve();
       }
-      row.finished = true;
-      row.state = view.state === "failed" ? "failed" : "done";
-      markFinalized(agentId);
-      const group = g;
-      group.chain = group.chain.then(() => {
-        const others = runningRows(group).filter((w) => w.agentId !== agentId);
-        if (others.length > 0) {
-          removeWorker(group, agentId);
-          syncPin(group);
-          return doRender(group, { force: true });
-        }
-        const recap = { ...view, narrativeLines: [...row.narrative] };
-        return doRender(group, { force: true, terminalRecap: recap, finishingAgentId: agentId });
-      }).catch((err) => {
-        log(`worker-feed: finish chain error ${agentId}: ${err.message}`);
-      });
-      return group.chain;
+      return finalizeWorker(g, agentId, row, view);
+    },
+    terminate(agentId) {
+      return terminateWorker(agentId);
     },
     drop(agentId) {
       markFinalized(agentId);
@@ -41247,6 +41351,7 @@ var import_grammy2 = __toESM(require_mod2(), 1);
 var import_runner = __toESM(require_mod4(), 1);
 import { AsyncLocalStorage } from "async_hooks";
 init_flood_circuit_breaker();
+init_format();
 
 // shared/gw-trace-gate.ts
 function computeGwTraceVerbose(flag) {
@@ -41281,6 +41386,7 @@ function escapeHtmlForTg(text) {
 
 // gateway/vault-request-access-card.ts
 init_approval_card();
+init_format();
 function renderVaultRequestAccessCard(req) {
   const lines = [];
   const scopeLabel = req.scope === "write" ? "write" : "read";
@@ -45070,6 +45176,9 @@ function runSilentTurnHeartbeatTick(view, deps) {
 
 // narrative-dedup.ts
 var REPLY_TOOLS = new Set(["reply", "stream_reply"]);
+
+// narrative-dedup.ts
+var REPLY_TOOLS2 = new Set(["reply", "stream_reply"]);
 function normalizeNarrative(s) {
   return s.replace(/[*_`>#~]/g, "").replace(/\s+/g, " ").trim().toLowerCase();
 }
@@ -45089,6 +45198,83 @@ function isDraftOfReply(textBlock, replyText) {
   return prefixSimilarity(textBlock, replyText) >= DRAFT_SUPPRESS_THRESHOLD;
 }
 
+// narrative-flush.ts
+var PENDING_NARRATIVE_FLUSH_MS = 250;
+
+class NarrativeFlushController {
+  effects;
+  scheduler;
+  flushMs;
+  pending = null;
+  timerShown = null;
+  constructor(effects, scheduler, flushMs) {
+    this.effects = effects;
+    this.scheduler = scheduler;
+    this.flushMs = flushMs;
+  }
+  get pendingText() {
+    return this.pending;
+  }
+  get timerShownText() {
+    return this.timerShown;
+  }
+  stage(text) {
+    this.scheduler.disarm();
+    if (this.pending != null) {
+      this.effects.show(this.pending);
+    }
+    this.pending = text;
+    this.scheduler.arm(() => this.onTimerFire(), this.flushMs);
+  }
+  onTimerFire() {
+    if (this.pending == null)
+      return;
+    const text = this.pending;
+    this.pending = null;
+    this.timerShown = text;
+    this.effects.show(text);
+  }
+  resolveOnTool(toolName, input) {
+    this.scheduler.disarm();
+    const replyText = REPLY_TOOLS2.has(toolName) && typeof input?.text === "string" ? input.text : null;
+    if (replyText != null)
+      this.maybeRetract(replyText);
+    const pending = this.pending;
+    if (pending == null)
+      return;
+    this.pending = null;
+    if (replyText != null && isDraftOfReply(pending, replyText))
+      return;
+    this.effects.show(pending);
+  }
+  flushAtTurnEnd(lastReplyText) {
+    this.scheduler.disarm();
+    if (lastReplyText.length > 0)
+      this.maybeRetract(lastReplyText);
+    const pending = this.pending;
+    if (pending == null)
+      return;
+    this.pending = null;
+    if (lastReplyText.length > 0 && isDraftOfReply(pending, lastReplyText))
+      return;
+    this.effects.show(pending);
+  }
+  teardown() {
+    this.scheduler.disarm();
+    this.pending = null;
+    this.timerShown = null;
+  }
+  maybeRetract(replyText) {
+    const shown = this.timerShown;
+    if (shown == null)
+      return;
+    if (!isDraftOfReply(shown, replyText))
+      return;
+    this.timerShown = null;
+    this.effects.retractShown(shown);
+  }
+}
+
 // tool-labels.ts
 var MAX_LABEL_CHARS = 60;
 var MAX_BASH_CHARS = 40;
@@ -54817,6 +55003,7 @@ function parse2(markdown) {
 }
 
 // render/render.ts
+init_format();
 function renderInline(node2, ctx = {}) {
   switch (node2.type) {
     case "plain":
@@ -55022,6 +55209,7 @@ function renderSafe(doc, source, maxLen = RICH_MESSAGE_MAX_CHARS) {
 }
 
 // render/rich-render.ts
+init_format();
 var PLAIN_TEXT_MAX_CHARS = 4096;
 function parseRichRenderEnabled(raw) {
   if (raw == null)
@@ -55307,6 +55495,10 @@ function handlePtyPartialPure(text4, state, deps) {
   stream.update(text4).catch(() => {});
   return created ? "update-new" : "update-existing";
 }
+
+// stream-reply-handler.ts
+init_format();
+
 // chat-lock.ts
 function createChatLock() {
   const chains = new Map;
@@ -56401,6 +56593,7 @@ var import_runner2 = __toESM(require_mod4(), 1);
 import { createHash as createHash2 } from "crypto";
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
 init_flood_circuit_breaker();
+init_format();
 var tgPostTagStore2 = new AsyncLocalStorage2;
 function _getTgPostTags() {
   return tgPostTagStore2.getStore();
@@ -61497,6 +61690,7 @@ function decideOverPing(input) {
 }
 
 // silent-reply-anchor.ts
+init_format();
 var TELEGRAM_MSG_CAP = RICH_MESSAGE_MAX_CHARS;
 function enabled3() {
   const v = process.env.SWITCHROOM_DISABLE_SILENT_REPLY_AUTOEDIT;
@@ -61813,6 +62007,7 @@ function startTimer(deps) {
 var EDIT_INTERVAL_MS = 60000;
 var POLL_INTERVAL_MS = 5000;
 var MAX_LIFETIME_MS = 30 * 60000;
+var BACKGROUND_WORK_SUPPRESS_TTL_MS = MAX_LIFETIME_MS;
 var TELEGRAM_MSG_CAP2 = 32768;
 var SUFFIX_RE = /\n\n(?:\u2014 |_)still working \(\d+m\)( \u00b7 message me anytime, I'll keep you posted)?_?$/;
 var stateByKey = new Map;
@@ -61830,6 +62025,7 @@ function ensure(key) {
   if (!s) {
     s = {
       pending: false,
+      dispatchedAt: null,
       anchorMessageId: null,
       anchorOriginalText: "",
       anchorLiteralText: false,
@@ -61843,7 +62039,9 @@ function ensure(key) {
 function noteAsyncDispatch(key) {
   if (!enabled4())
     return;
-  ensure(key).pending = true;
+  const s = ensure(key);
+  s.pending = true;
+  s.dispatchedAt = nowMs();
 }
 function noteOutbound3(key, opts) {
   if (!enabled4())
@@ -61873,6 +62071,17 @@ function noteTurnEnd(key) {
 function hasPendingAsyncDispatch(key) {
   return stateByKey.get(key)?.pending === true;
 }
+function anyPendingAsyncDispatchWithin(ttlMs) {
+  if (ttlMs <= 0)
+    return false;
+  const now = nowMs();
+  for (const s of stateByKey.values()) {
+    if (s.pending === true && s.dispatchedAt != null && now - s.dispatchedAt < ttlMs) {
+      return true;
+    }
+  }
+  return false;
+}
 function clearPending(key, reason) {
   if (!stateByKey.has(key))
     return;
@@ -62040,6 +62249,30 @@ function clearSilentEndState(turnKey, deps) {
 `);
   } catch {}
 }
+var CAPTURED_PROSE_MIN_CHARS = 200;
+function decideCapturedProseDelivery(args, deps) {
+  const minChars = args.minChars ?? CAPTURED_PROSE_MIN_CHARS;
+  const state3 = readSilentEndState(deps);
+  if (state3 == null)
+    return { deliver: false, reason: "no-state" };
+  if (state3.turnKey !== args.turnKey)
+    return { deliver: false, reason: "turnkey-mismatch" };
+  if (typeof state3.turnId === "string" && state3.turnId !== "" && args.turnId != null && args.turnId !== "" && state3.turnId !== args.turnId) {
+    return { deliver: false, reason: "turnid-mismatch" };
+  }
+  const text4 = typeof state3.pendingText === "string" ? state3.pendingText : "";
+  if (text4.trim().length < minChars)
+    return { deliver: false, reason: "no-substantive-prose" };
+  return { deliver: true, text: text4, reason: "captured-prose" };
+}
+function settleCapturedProseDelivery(outcome, effects) {
+  if (outcome === "failed") {
+    return { exhausted: effects.recordUndelivered().exhausted };
+  }
+  effects.closeObligation();
+  effects.clearState();
+  return { exhausted: false };
+}
 function readSilentEndState(deps) {
   const statePath = resolveStatePath2(deps);
   if (!existsSync14(statePath))
@@ -62145,6 +62378,56 @@ function isSilentFlushMarker(text4) {
   return SILENT_MARKERS.has(trimmed.toUpperCase());
 }
 var TRIVIAL_CONFIRMATIONS = new Set(["SENT", "DONE", "OK", "OKAY", "ACK"]);
+function isTrivialConfirmationLine(line) {
+  let t = line.trim();
+  if (t.length === 0 || t.length > 8)
+    return false;
+  if (/\W$/.test(t))
+    t = t.slice(0, -1);
+  return TRIVIAL_CONFIRMATIONS.has(t.toUpperCase());
+}
+function isCompositeSilentNoise(text4) {
+  if (typeof text4 !== "string")
+    return false;
+  const lines = text4.split(`
+`).map((l) => l.trim()).filter((l) => l.length > 0);
+  if (lines.length === 0)
+    return false;
+  const hasMarker = lines.some((l) => isSilentFlushMarker(l));
+  if (!hasMarker)
+    return false;
+  return lines.every((l) => isSilentFlushMarker(l) || isTrivialConfirmationLine(l));
+}
+function endsWithSilentMarker(text4) {
+  if (typeof text4 !== "string")
+    return false;
+  const lines = text4.split(`
+`).map((l) => l.trim()).filter((l) => l.length > 0);
+  if (lines.length === 0)
+    return false;
+  return isSilentFlushMarker(lines[lines.length - 1]);
+}
+function decideTurnFlush(input) {
+  const flushEnabled = input.flushEnabled !== false;
+  if (!flushEnabled)
+    return { kind: "skip", reason: "flag-disabled" };
+  if (input.replyCalled)
+    return { kind: "skip", reason: "reply-called" };
+  if (input.chatId == null)
+    return { kind: "skip", reason: "no-inbound-chat" };
+  const joined = input.capturedText.join(`
+
+`).trim();
+  if (joined.length === 0)
+    return { kind: "skip", reason: "empty-text" };
+  if (isSilentFlushMarker(joined))
+    return { kind: "skip", reason: "silent-marker" };
+  if (isCompositeSilentNoise(joined))
+    return { kind: "skip", reason: "silent-marker" };
+  if (endsWithSilentMarker(joined))
+    return { kind: "skip", reason: "silent-marker" };
+  return { kind: "flush", text: joined };
+}
 
 // answer-stream.ts
 var MIN_INITIAL_CHARS = 50;
@@ -62634,6 +62917,7 @@ function safeResolvePersonName(directory, opts, rawFallback) {
 }
 
 // gateway/auth-command.ts
+init_format();
 init_auth_snapshot_format();
 init_demo_mask();
 var AUTH_RM_CONFIRM_TTL_MS = 60000;
@@ -64783,6 +65067,10 @@ function autoClassifyMidTurnInbound(i) {
     return { decision: "queue", reason: "cross_topic", sameTopic: false };
   return recent && i.msSinceLastAgentOutput <= i.topicSteerWindowMs ? { decision: "steer", reason: "same_topic_recent", sameTopic: true } : { decision: "queue", reason: "same_topic_stale", sameTopic: true };
 }
+
+// operator-events.ts
+init_format();
+
 // raw-error-scrub.ts
 function stripRawErrorBytes(raw) {
   if (typeof raw !== "string" || raw.length === 0)
@@ -65352,7 +65640,9 @@ function renderThrottleEscalationNotice(opts) {
   return `${head}
 ${tail}`;
 }
+
 // operator-events.ts
+init_format();
 function classifyClaudeError(raw) {
   try {
     return classifyInner(raw);
@@ -65539,6 +65829,26 @@ function formatRelativeTail(deltaMs) {
   const remH = hours % 24;
   return remH > 0 ? `~in ${days}d ${remH}h` : `~in ${days}d`;
 }
+function formatResetClock(resetAt, tz) {
+  if (resetAt == null)
+    return "";
+  const ms = resetAt.getTime();
+  if (!Number.isFinite(ms))
+    return "";
+  return `${fmtLocalClock(ms, tz)} ${tzAbbrev(ms, tz)}`;
+}
+function buildRecommendation(parsed, tz) {
+  switch (parsed.kind) {
+    case "auth":
+      return "\u2192 Re-authenticate this account to continue.";
+    case "quota_wall": {
+      const reset2 = formatResetClock(parsed.resetAt, tz);
+      return reset2 ? `\u2192 Switch to another account, or wait for the quota to reset at ${reset2}.` : "\u2192 Switch to another account, or wait for the quota to reset.";
+    }
+    default:
+      return;
+  }
+}
 function renderLlmError(parsed, agent, tz, now = new Date) {
   const safeAgent = escapeAgent(agent);
   const emoji = kindEmoji(parsed.kind);
@@ -65548,32 +65858,18 @@ function renderLlmError(parsed, agent, tz, now = new Date) {
     lines.push(`_${resetLine}_`);
   if (parsed.model)
     lines.push(`_model: ${escapeAgent(parsed.model)}_`);
-  const text4 = lines.join(`
-`);
-  switch (parsed.kind) {
-    case "auth":
-      return {
-        text: text4,
-        keyboard: {
-          inline_keyboard: [
-            [
-              { text: "\uD83D\uDD10 Reauth now", callback_data: `op:reauth:${encodeURIComponent(agent)}` },
-              { text: "\u274c Dismiss", callback_data: `op:dismiss:${encodeURIComponent(agent)}` }
-            ]
-          ]
-        }
-      };
-    case "quota_wall":
-      return {
-        text: text4,
-        keyboard: {
-          inline_keyboard: [
-            [{ text: "\u23f3 Wait", callback_data: `op:dismiss:${encodeURIComponent(agent)}` }]
-          ]
-        }
-      };
-    default:
-      return { text: text4 };
+  const recommendation2 = buildRecommendation(parsed, tz);
+  if (recommendation2)
+    lines.push(recommendation2);
+  return { text: lines.join(`
+`) };
+}
+function renderLlmErrorSafe(parsed, agent, tz, now = new Date) {
+  try {
+    return renderLlmError(parsed, agent, tz, now);
+  } catch {
+    const safeAgent = escapeAgent(agent);
+    return { text: `${kindEmoji(parsed.kind)} ${parsed.coreText} (**${safeAgent}**)` };
   }
 }
 function kindEmoji(kind) {
@@ -66547,12 +66843,13 @@ function addParagraphSpacers2(text4) {
 
 `))
     return restore2(masked);
-  const spacerLine = PARAGRAPH_SPACER2;
-  const isBlankLine = (line) => /^[ \t\r\f\v]*$/.test(line);
+  const SP = PARAGRAPH_SPACER2;
   const asciiTrim = (line) => line.replace(/^[ \t\r\f\v]+|[ \t\r\f\v]+$/g, "");
+  const isBlankish = (line) => {
+    const t = asciiTrim(line);
+    return t === "" || t === SP;
+  };
   const blockKind = (line) => {
-    if (asciiTrim(line) === spacerLine)
-      return "spacer";
     if (isFenceOpenLine2(line, placeholder))
       return "fence";
     if (isListItemLine2(line))
@@ -66577,58 +66874,65 @@ function addParagraphSpacers2(text4) {
   const shouldSpaceGap = (above, below) => {
     const a = blockKind(above);
     const b = blockKind(below);
-    if (a === "spacer" || b === "spacer")
-      return false;
     if (a === b && SAME_KIND_TIGHT.has(a))
       return false;
     return true;
   };
-  const lines = masked.split(`
-`);
+  const toks = [];
+  for (const line of masked.split(`
+`)) {
+    const kind = isBlankish(line) ? "gap" : "content";
+    const last = toks[toks.length - 1];
+    if (last && last.kind === kind)
+      last.lines.push(line);
+    else
+      toks.push({ kind, lines: [line] });
+  }
   const out = [];
-  for (let i = 0;i < lines.length; i++) {
-    const line = lines[i];
-    const isBlank = isBlankLine(line);
-    if (isBlank) {
-      const prevEmitted = out.length > 0 ? out[out.length - 1] : null;
-      const prevIsBlank = prevEmitted != null && isBlankLine(prevEmitted);
-      if (!prevIsBlank) {
-        const above = lastNonBlank2(out, isBlankLine);
-        const below = nextNonBlank2(lines, i + 1, isBlankLine);
-        const alreadySpaced = above != null && asciiTrim(above) === spacerLine || below != null && asciiTrim(below) === spacerLine;
-        if (!alreadySpaced && above != null && below != null && shouldSpaceGap(above, below)) {
-          out.push("");
-          out.push(spacerLine);
-          out.push("");
-          continue;
-        }
-      }
+  for (let i = 0;i < toks.length; i++) {
+    const tok = toks[i];
+    if (tok.kind === "content") {
+      out.push(...tok.lines);
+      continue;
+    }
+    const prev = toks[i - 1];
+    const next = toks[i + 1];
+    if (prev?.kind === "content" && next?.kind === "content") {
+      const above = prev.lines[prev.lines.length - 1];
+      const below = next.lines[0];
+      if (shouldSpaceGap(above, below))
+        out.push("", SP, "");
+      else
+        out.push("");
+    } else {
+      out.push(...tok.lines);
     }
-    out.push(line);
   }
   return restore2(out.join(`
 `));
 }
-function lastNonBlank2(arr, isBlank) {
-  for (let i = arr.length - 1;i >= 0; i--) {
-    if (!isBlank(arr[i]))
-      return arr[i];
-  }
-  return null;
-}
-function nextNonBlank2(lines, from, isBlank) {
-  for (let i = from;i < lines.length; i++) {
-    if (!isBlank(lines[i]))
-      return lines[i];
-  }
-  return null;
-}
 function normalizePunctuation2(text4) {
   if (!/[\u2014\u2013\u2022\u00b7]/.test(text4))
     return text4;
   const nonce = Math.random().toString(36).slice(2);
   const { masked, restore: restore2 } = maskCodeRegions2(text4, nonce);
-  let out = masked.replace(/(\S)[ \t][\u2014\u2013][ \t](?=(\S))/g, (_m, a, b) => /\d/.test(a) && /\d/.test(b) ? `${a}-` : `${a}, `).replace(/(\w)\u2014(?=(\w))/g, (_m, a, b) => /\d/.test(a) && /\d/.test(b) ? `${a}-` : `${a}, `).replace(/(\w)\u2013(?=\w)/g, "$1-");
+  const linkMasks = [];
+  const LINK_MASK_PH = `\x00RML${nonce}_`;
+  const maskedLinks = masked.replace(/(\]\()([^)\n]*)(\))/g, (_m, open, href, close) => {
+    const idx = linkMasks.length;
+    linkMasks.push(href);
+    return `${open}${LINK_MASK_PH}${idx}\x00${close}`;
+  });
+  const maskedAutolinks = maskedLinks.replace(/(<)([a-zA-Z][a-zA-Z0-9+.-]*:[^>\s]*)(>)/g, (_m, lt, uri, gt) => {
+    const idx = linkMasks.length;
+    linkMasks.push(uri);
+    return `${lt}${LINK_MASK_PH}${idx}\x00${gt}`;
+  });
+  const escNonce = nonce.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const linkRestoreRe = new RegExp(`\x00RML${escNonce}_(\\d+)\x00`, "g");
+  const restoreLinks = (s) => s.replace(linkRestoreRe, (_m, idx) => linkMasks[Number(idx)] ?? _m);
+  let out = maskedAutolinks.replace(/(\S)[ \t][\u2014\u2013][ \t](?=(\S))/g, (_m, a, b) => /\d/.test(a) && /\d/.test(b) ? `${a}-` : `${a}, `).replace(/(\w)\u2014(?=(\w))/g, (_m, a, b) => /\d/.test(a) && /\d/.test(b) ? `${a}-` : `${a}, `).replace(/(\w)\u2013(?=\w)/g, "$1-");
+  out = restoreLinks(out);
   out = out.split(`
 `).map((line) => line.replace(/^([ \t]*)[\u2022\u00b7][ \t]+/, "$1- ")).join(`
 `);
@@ -66821,6 +67125,7 @@ function splitMarkdownChunks2(text4, maxLen = RICH_MESSAGE_MAX_CHARS2) {
     }
     cut = backOffOpenFence2(rest, cut);
     cut = backOffTableRow2(rest, cut);
+    cut = backOffOpenInline2(rest, cut);
     if (cut <= 0) {
       const sliced = hardSliceToCap2(rest, maxLen);
       chunks.push(stripBoundarySpacers2(sliced[0], "trailing"));
@@ -66866,6 +67171,35 @@ function backOffTableRow2(text4, cut) {
   }
   return cut;
 }
+var INLINE_SPAN_PATTERNS2 = [
+  /`[^`\n]+`/g,
+  /\*\*\*[^*\n]+\*\*\*/g,
+  /___[^_\n]+___/g,
+  /\*\*[^*\n]+\*\*/g,
+  /__[^_\n]+__/g,
+  /(?<![\w*])_[^_\n]+_(?![\w*])/g,
+  /\[[^\]\n]*\]\([^)\n]*\)/g
+];
+function backOffOpenInline2(text4, cut) {
+  if (cut <= 0 || cut >= text4.length)
+    return cut;
+  let earliest = cut;
+  for (const re of INLINE_SPAN_PATTERNS2) {
+    re.lastIndex = 0;
+    let m;
+    while ((m = re.exec(text4)) !== null) {
+      const start = m.index;
+      const end = start + m[0].length;
+      if (start < cut && cut < end && start < earliest)
+        earliest = start;
+      if (start >= cut)
+        break;
+      if (re.lastIndex === start)
+        re.lastIndex = start + 1;
+    }
+  }
+  return earliest;
+}
 
 // rich-send.ts
 var import_grammy8 = __toESM(require_mod2(), 1);
@@ -66984,6 +67318,7 @@ function scrubVoice2(text4) {
 }
 
 // gateway/outbound-send-path.ts
+init_format();
 init_text_voice_scrub();
 function normalizeOutboundBody(rawText, site, redact2) {
   let text4 = normalizeParagraphBreaks(repairEscapedWhitespace(rawText));
@@ -67666,7 +68001,7 @@ function isSilentFlushMarker2(text4) {
   return SILENT_MARKERS2.has(trimmed.toUpperCase());
 }
 var TRIVIAL_CONFIRMATIONS2 = new Set(["SENT", "DONE", "OK", "OKAY", "ACK"]);
-function isTrivialConfirmationLine(line) {
+function isTrivialConfirmationLine2(line) {
   let t = line.trim();
   if (t.length === 0 || t.length > 8)
     return false;
@@ -67674,7 +68009,7 @@ function isTrivialConfirmationLine(line) {
     t = t.slice(0, -1);
   return TRIVIAL_CONFIRMATIONS2.has(t.toUpperCase());
 }
-function isCompositeSilentNoise(text4) {
+function isCompositeSilentNoise2(text4) {
   if (typeof text4 !== "string")
     return false;
   const lines = text4.split(`
@@ -67684,9 +68019,9 @@ function isCompositeSilentNoise(text4) {
   const hasMarker = lines.some((l) => isSilentFlushMarker2(l));
   if (!hasMarker)
     return false;
-  return lines.every((l) => isSilentFlushMarker2(l) || isTrivialConfirmationLine(l));
+  return lines.every((l) => isSilentFlushMarker2(l) || isTrivialConfirmationLine2(l));
 }
-function endsWithSilentMarker(text4) {
+function endsWithSilentMarker2(text4) {
   if (typeof text4 !== "string")
     return false;
   const lines = text4.split(`
@@ -67695,7 +68030,7 @@ function endsWithSilentMarker(text4) {
     return false;
   return isSilentFlushMarker2(lines[lines.length - 1]);
 }
-function decideTurnFlush(input) {
+function decideTurnFlush2(input) {
   const flushEnabled = input.flushEnabled !== false;
   if (!flushEnabled)
     return { kind: "skip", reason: "flag-disabled" };
@@ -67710,9 +68045,9 @@ function decideTurnFlush(input) {
     return { kind: "skip", reason: "empty-text" };
   if (isSilentFlushMarker2(joined))
     return { kind: "skip", reason: "silent-marker" };
-  if (isCompositeSilentNoise(joined))
+  if (isCompositeSilentNoise2(joined))
     return { kind: "skip", reason: "silent-marker" };
-  if (endsWithSilentMarker(joined))
+  if (endsWithSilentMarker2(joined))
     return { kind: "skip", reason: "silent-marker" };
   return { kind: "flush", text: joined };
 }
@@ -67726,6 +68061,72 @@ function isTurnFlushSafetyEnabled(env = process.env) {
   return true;
 }
 
+// answer-ready-flush.ts
+var ANSWER_READY_FLUSH_MS = 1000;
+function resolveAnswerReadyFlushMs(env) {
+  const raw = env.SWITCHROOM_ANSWER_READY_FLUSH_MS;
+  if (raw == null || raw.trim() === "")
+    return ANSWER_READY_FLUSH_MS;
+  const n = Number(raw);
+  if (!Number.isFinite(n))
+    return ANSWER_READY_FLUSH_MS;
+  if (n <= 0)
+    return 0;
+  return Math.floor(n);
+}
+function shouldArmAnswerReadyFlush(input) {
+  if (input.flushWindowMs <= 0)
+    return false;
+  if (input.inFlightToolCount > 0)
+    return false;
+  if (input.hasPendingAsyncDispatch)
+    return false;
+  return decideTurnFlush(input.flush).kind === "flush";
+}
+
+class AnswerReadyFlushController {
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  get setTimeoutFn() {
+    return this.deps.setTimeoutFn ?? ((fn, ms) => setTimeout(fn, ms));
+  }
+  get clearTimeoutFn() {
+    return this.deps.clearTimeoutFn ?? ((h) => clearTimeout(h));
+  }
+  clear(turn) {
+    if (turn == null)
+      return;
+    const handle = this.deps.getTimerHandle(turn);
+    if (handle != null) {
+      this.clearTimeoutFn(handle);
+      this.deps.setTimerHandle(turn, null);
+    }
+  }
+  reset() {
+    const turn = this.deps.getCurrentTurn();
+    this.clear(turn);
+    if (turn == null)
+      return;
+    const armInput = this.deps.getArmInput(turn);
+    if (!shouldArmAnswerReadyFlush(armInput))
+      return;
+    const handle = this.setTimeoutFn(() => this.onExpiry(turn), armInput.flushWindowMs);
+    this.deps.setTimerHandle(turn, handle);
+  }
+  onExpiry(armedTurn) {
+    const live = this.deps.getCurrentTurn();
+    if (live == null || live !== armedTurn)
+      return;
+    this.deps.setTimerHandle(live, null);
+    if (!shouldArmAnswerReadyFlush(this.deps.getArmInput(live)))
+      return;
+    this.deps.log?.("answer-ready quiescence flush \u2014 delivering composed terminal answer");
+    this.deps.onFlush(live);
+  }
+}
+
 // gateway/turn-end-gate.ts
 function decideTurnEndGate(snapshot) {
   const { flushDecision, finalAnswerDelivered } = snapshot;
@@ -69152,11 +69553,12 @@ async function injectSlashCommand(agentName3, command, opts = {}) {
     session,
     command: command.trim(),
     settleMs,
-    timeoutMs
+    timeoutMs,
+    precondition: opts.precondition
   }));
 }
 async function injectSlashCommandWith(runner, args) {
-  const { socket, session, command, settleMs, timeoutMs } = args;
+  const { socket, session, command, settleMs, timeoutMs, precondition } = args;
   let bareVerb;
   try {
     bareVerb = validateInjectCommand(command);
@@ -69186,6 +69588,17 @@ async function injectSlashCommandWith(runner, args) {
       errorMessage: `tmux session "${session}" on socket "${socket}" not found. ` + `Is the agent running under the tmux supervisor (the default)? ` + `If experimental.legacy_pty=true is set, inject is unsupported.`
     };
   }
+  if (precondition && !precondition()) {
+    return {
+      outcome: "skipped",
+      output: "",
+      truncated: false,
+      command: bareVerb,
+      meta,
+      errorCode: "precondition_failed",
+      errorMessage: "inject precondition returned false at write time; send aborted " + "(no keys sent)."
+    };
+  }
   const before = runner.capture(socket, session) ?? "";
   try {
     runner.send(socket, session, ["send-keys", "-l", command]);
@@ -69339,7 +69752,9 @@ function makeTmuxRunner2(tmuxBin) {
     }
   };
 }
+
 // stream-reply-handler.ts
+init_format();
 function buildAccentHeader(accent) {
   switch (accent) {
     case "in-progress":
@@ -69388,6 +69803,12 @@ _truncated_`;
     }
     return { body: verbHtml, accent: "done" };
   }
+  if (result.outcome === "skipped") {
+    return {
+      body: `${verbHtml} \u2014 skipped (precondition not met at send time)`,
+      accent: "issue"
+    };
+  }
   const code2 = result.errorCode ?? "tmux_failed";
   const msg = result.errorMessage ?? "unknown error";
   if (code2 === "blocked") {
@@ -72070,6 +72491,8 @@ function decideIdleClear(state3, now) {
     return { clear: false };
   if (state3.turnInFlight)
     return { clear: false };
+  if (state3.backgroundWorkInFlight)
+    return { clear: false };
   if (state3.alreadyCleared)
     return { clear: false };
   if (now - lastEventAt(state3) < state3.idleClearMs)
@@ -72081,6 +72504,67 @@ function classifyIdleEvent(kind, durationMs) {
   const synthetic = turnEnded && durationMs === -1;
   return { activity: !synthetic, turnEnded };
 }
+
+class IdleTracker {
+  lastActivityAt;
+  lastTurnEndedAt = null;
+  alreadyCleared = false;
+  dispatching = false;
+  constructor(startedAt) {
+    this.lastActivityAt = startedAt;
+  }
+  get activityAt() {
+    return this.lastActivityAt;
+  }
+  get turnEndedAt() {
+    return this.lastTurnEndedAt;
+  }
+  get cleared() {
+    return this.alreadyCleared;
+  }
+  get isDispatching() {
+    return this.dispatching;
+  }
+  noteInbound(now) {
+    this.lastActivityAt = now;
+    this.alreadyCleared = false;
+  }
+  noteEvent(kind, now, durationMs) {
+    const signal = classifyIdleEvent(kind, durationMs);
+    if (signal.activity)
+      this.noteInbound(now);
+    if (signal.turnEnded)
+      this.lastTurnEndedAt = now;
+  }
+  stateFor(inputs, alreadyCleared) {
+    return {
+      lastActivityAt: this.lastActivityAt,
+      lastTurnEndedAt: this.lastTurnEndedAt,
+      idleClearMs: inputs.idleClearMs,
+      alreadyCleared,
+      turnInFlight: inputs.turnInFlight,
+      backgroundWorkInFlight: inputs.backgroundWorkInFlight
+    };
+  }
+  decide(now, inputs) {
+    return decideIdleClear(this.stateFor(inputs, this.alreadyCleared), now);
+  }
+  decideIgnoringLatch(now, inputs) {
+    return decideIdleClear(this.stateFor(inputs, false), now);
+  }
+  markClearFired() {
+    this.alreadyCleared = true;
+  }
+  reArm() {
+    this.alreadyCleared = false;
+  }
+  beginDispatch() {
+    this.dispatching = true;
+  }
+  endDispatch() {
+    this.dispatching = false;
+  }
+}
 function idleDurationToMs(raw) {
   const m = /^(\d+)([smh])$/.exec(raw.trim());
   if (!m)
@@ -73169,6 +73653,7 @@ function recordWebhookEvent(rec, deps = {}) {
 }
 
 // gateway/ipc-server.ts
+init_format();
 import { renameSync as renameSync11, unlinkSync as unlinkSync14, chmodSync as chmodSync9 } from "fs";
 var MAX_BUFFER_SIZE = 1024 * 1024;
 var VALID_OPERATOR_KINDS = new Set([
@@ -73874,6 +74359,7 @@ function validateInput(input) {
 }
 
 // gateway/drive-write-approval.ts
+init_format();
 var DEFAULT_TTL_MS = 5 * 60 * 1000;
 var MAX_TTL_MS = 30 * 60 * 1000;
 var MIN_TTL_MS = 30 * 1000;
@@ -74004,6 +74490,7 @@ function clampTtl(requested, fallback, min, max) {
 }
 
 // gateway/ms365-write-approval.ts
+init_format();
 function validateMs365Preview(input) {
   if (!input || typeof input !== "object")
     return null;
@@ -74182,6 +74669,7 @@ async function handleRequestMs365Approval(client3, msg, deps) {
 }
 
 // gateway/diff-preview-card.ts
+init_format();
 var import_grammy10 = __toESM(require_mod2(), 1);
 var REQUEST_ID_RE = /^[0-9a-f]{32}$/;
 var PENDING_FILE_ID_SENTINEL = "pending-create";
@@ -74398,6 +74886,9 @@ function cronIdentity(agent) {
 function isCronIdentity(name) {
   return typeof name === "string" && name.endsWith(CRON_IDENTITY_SUFFIX);
 }
+function isCronInjectFire(meta) {
+  return meta?.source === "cron" || meta?.session === "cron";
+}
 function resolveInjectTarget(agentName3, meta) {
   return meta?.session === "cron" ? cronIdentity(agentName3) : agentName3;
 }
@@ -75660,6 +76151,44 @@ function maybeRotate(path2, fs2, maxBytes = TURNS_JSONL_MAX_BYTES) {
   return true;
 }
 
+// gateway/turn-record-status.ts
+function computeTurnStatus(turn) {
+  switch (turn.deliveryOutcome) {
+    case "failed":
+      return "send_failed";
+    case "delivered":
+      return "complete";
+    case "suppressed":
+      return turn.finalAnswerDelivered ? "complete" : "no_reply";
+    default:
+      return turn.finalAnswerDelivered ? "complete" : "no_reply";
+  }
+}
+function backstopSendOutcome(args) {
+  if (args.threw)
+    return "failed";
+  if (args.chunkCount === 0)
+    return "failed";
+  if (args.sentCount < args.chunkCount)
+    return "failed";
+  return "delivered";
+}
+function finalizeBackstopSend(turn, send) {
+  const outcome = backstopSendOutcome(send);
+  turn.deliveryOutcome = outcome;
+  return outcome;
+}
+function buildTurnRecord(turn, endedAt) {
+  return {
+    ts: Math.floor(endedAt / 1000),
+    agent: turn.agent,
+    duration_ms: turn.startedAt > 0 ? endedAt - turn.startedAt : 0,
+    tools: turn.toolCallCount ?? 0,
+    status: computeTurnStatus(turn),
+    turn_id: turn.turnId
+  };
+}
+
 // gateway/inbound-delivery-confirm.ts
 function createDeliveryQueue() {
   return { pending: new Map };
@@ -76340,6 +76869,7 @@ function maybeFireWarmup(ctx) {
 
 // gateway/mental-model-propose-card.ts
 init_approval_card();
+init_format();
 function renderMentalModelProposeCard(req) {
   const lines = [];
   lines.push(`\uD83E\uDDE0 **${escapeHtmlForTg(req.agent)}** proposes a mental model`);
@@ -78257,25 +78787,81 @@ function redactSecrets(text4) {
   return out;
 }
 
-// narrative-dedup.ts
-var REPLY_TOOLS2 = new Set(["reply", "stream_reply"]);
-function normalizeNarrative2(s) {
-  return s.replace(/[*_`>#~]/g, "").replace(/\s+/g, " ").trim().toLowerCase();
-}
-function prefixSimilarity2(a, b) {
-  const x = normalizeNarrative2(a);
-  const y = normalizeNarrative2(b);
-  if (x.length === 0 || y.length === 0)
-    return 0;
-  const n = Math.min(x.length, y.length);
-  let i = 0;
-  while (i < n && x[i] === y[i])
-    i++;
-  return i / n;
-}
-var DRAFT_SUPPRESS_THRESHOLD2 = 0.8;
-function isDraftOfReply2(textBlock, replyText) {
-  return prefixSimilarity2(textBlock, replyText) >= DRAFT_SUPPRESS_THRESHOLD2;
+// narrative-flush.ts
+var PENDING_NARRATIVE_FLUSH_MS2 = 250;
+
+class NarrativeFlushController2 {
+  effects;
+  scheduler;
+  flushMs;
+  pending = null;
+  timerShown = null;
+  constructor(effects, scheduler, flushMs) {
+    this.effects = effects;
+    this.scheduler = scheduler;
+    this.flushMs = flushMs;
+  }
+  get pendingText() {
+    return this.pending;
+  }
+  get timerShownText() {
+    return this.timerShown;
+  }
+  stage(text4) {
+    this.scheduler.disarm();
+    if (this.pending != null) {
+      this.effects.show(this.pending);
+    }
+    this.pending = text4;
+    this.scheduler.arm(() => this.onTimerFire(), this.flushMs);
+  }
+  onTimerFire() {
+    if (this.pending == null)
+      return;
+    const text4 = this.pending;
+    this.pending = null;
+    this.timerShown = text4;
+    this.effects.show(text4);
+  }
+  resolveOnTool(toolName, input) {
+    this.scheduler.disarm();
+    const replyText = REPLY_TOOLS2.has(toolName) && typeof input?.text === "string" ? input.text : null;
+    if (replyText != null)
+      this.maybeRetract(replyText);
+    const pending = this.pending;
+    if (pending == null)
+      return;
+    this.pending = null;
+    if (replyText != null && isDraftOfReply(pending, replyText))
+      return;
+    this.effects.show(pending);
+  }
+  flushAtTurnEnd(lastReplyText) {
+    this.scheduler.disarm();
+    if (lastReplyText.length > 0)
+      this.maybeRetract(lastReplyText);
+    const pending = this.pending;
+    if (pending == null)
+      return;
+    this.pending = null;
+    if (lastReplyText.length > 0 && isDraftOfReply(pending, lastReplyText))
+      return;
+    this.effects.show(pending);
+  }
+  teardown() {
+    this.scheduler.disarm();
+    this.pending = null;
+    this.timerShown = null;
+  }
+  maybeRetract(replyText) {
+    const shown = this.timerShown;
+    if (shown == null)
+      return;
+    if (!isDraftOfReply(shown, replyText))
+      return;
+    this.timerShown = null;
+    this.effects.retractShown(shown);
+  }
 }
 
 // subagent-watcher.ts
@@ -78412,6 +78998,9 @@ var DEFAULT_STALL_THRESHOLD_MS = 60000;
 var DEFAULT_SILENT_SYNTHESIS_STALL_THRESHOLD_MS = 300000;
 var DEFAULT_SILENT_STALL_TERMINAL_MS = 300000;
 var DEFAULT_INFLIGHT_TERMINAL_CAP_MS = 45 * 60000;
+function resolveInflightTerminalCapMs(configVal) {
+  return configVal ?? parseEnvMs("SWITCHROOM_SUBAGENT_INFLIGHT_TERMINAL_CAP_MS") ?? DEFAULT_INFLIGHT_TERMINAL_CAP_MS;
+}
 var DEFAULT_DEFERRAL_LOG_INTERVAL_MS = 60000;
 var LONG_RUNNING_TOOLS = new Set(["Bash"]);
 var MAX_RESURRECTIONS = 1;
@@ -78525,6 +79114,8 @@ function backfillJsonlAgentId(db2, jsonlPath, agentId, log) {
 }
 function readSubTail(entry, tail, now, onDescriptionUpdate, fs2, log, db2, parentStateDir, onUnstall, onFileVanished, onProgress) {
   try {
+    if (entry.narrativeGate != null)
+      entry.narrativeGate.tick(now);
     const stat = fs2.statSync(entry.filePath);
     if (stat.size < tail.cursor) {
       tail.cursor = 0;
@@ -78585,43 +79176,87 @@ function readSubTail(entry, tail, now, onDescriptionUpdate, fs2, log, db2, paren
           entry.errorDetail = errInfo.detail.slice(0, SUBAGENT_RESULT_TEXT_MAX);
       }
       const events = projectSubagentLine(line, entry.agentId, startState);
-      const fireNarrativeProgress = () => {
-        if (onProgress == null || entry.state !== "running" || entry.historical)
-          return false;
-        try {
-          onProgress({
-            agentId: entry.agentId,
-            description: entry.description,
-            latestSummary: entry.lastResultText,
-            elapsedMs: now - entry.dispatchedAt,
-            prevBucketIdx: entry.lastProgressBucketIdx,
-            setBucketIdx: (b) => {
-              entry.lastProgressBucketIdx = b;
-            },
-            lastTool: entry.lastTool,
-            toolCount: entry.toolCount,
-            model: entry.currentModel
-          });
-          return true;
-        } catch (cbErr) {
-          log?.(`subagent-watcher: onProgress callback error ${entry.agentId}: ${cbErr.message}`);
-          return false;
-        }
+      const buildNarrativeGate = () => {
+        const nowRef = { value: now };
+        let cueFired = false;
+        const fireCue = () => {
+          if (onProgress == null || entry.state !== "running" || entry.historical)
+            return false;
+          try {
+            onProgress({
+              agentId: entry.agentId,
+              description: entry.description,
+              latestSummary: entry.lastResultText,
+              elapsedMs: nowRef.value - entry.dispatchedAt,
+              prevBucketIdx: entry.lastProgressBucketIdx,
+              setBucketIdx: (b) => {
+                entry.lastProgressBucketIdx = b;
+              },
+              lastTool: entry.lastTool,
+              toolCount: entry.toolCount,
+              model: entry.currentModel
+            });
+            return true;
+          } catch (cbErr) {
+            log?.(`subagent-watcher: onProgress callback error ${entry.agentId}: ${cbErr.message}`);
+            return false;
+          }
+        };
+        const scheduler = {
+          armedFn: null,
+          deadline: 0
+        };
+        const controller = new NarrativeFlushController2({
+          show: () => {
+            cueFired = fireCue();
+          },
+          retractShown: () => {
+            log?.(`subagent-watcher: narrative early-paint retract (no-op on replace-on-write worker card) ${entry.agentId}`);
+          }
+        }, {
+          arm: (fn, ms) => {
+            scheduler.armedFn = fn;
+            scheduler.deadline = nowRef.value + ms;
+          },
+          disarm: () => {
+            scheduler.armedFn = null;
+          }
+        }, PENDING_NARRATIVE_FLUSH_MS2);
+        return {
+          tick: (n) => {
+            nowRef.value = n;
+            if (scheduler.armedFn != null && n >= scheduler.deadline) {
+              const fn = scheduler.armedFn;
+              scheduler.armedFn = null;
+              fn();
+            }
+          },
+          stage: (text5) => {
+            controller.stage(text5);
+          },
+          resolveOnTool: (toolName, input) => {
+            cueFired = false;
+            controller.resolveOnTool(toolName ?? "", input);
+            return cueFired;
+          },
+          resolveAtTurnEnd: (lastReplyText) => {
+            cueFired = false;
+            controller.flushAtTurnEnd(lastReplyText);
+            return cueFired;
+          },
+          reset: () => {
+            controller.teardown();
+            scheduler.armedFn = null;
+          }
+        };
       };
       const resolvePendingSubNarrative = (toolName, toolInput) => {
-        if (entry.pendingNarrative == null)
+        if (entry.narrativeGate == null)
           return false;
-        const pending = entry.pendingNarrative;
-        entry.pendingNarrative = null;
-        if (toolName != null && REPLY_TOOLS2.has(toolName)) {
-          const replyText = typeof toolInput?.text === "string" ? toolInput.text : "";
-          if (isDraftOfReply2(pending.text, replyText))
-            return false;
-        } else if (toolName == null && entry.lastReplyText != null && entry.lastReplyText.length > 0) {
-          if (isDraftOfReply2(pending.text, entry.lastReplyText))
-            return false;
+        if (toolName == null) {
+          return entry.narrativeGate.resolveAtTurnEnd(entry.lastReplyText ?? "");
         }
-        return fireNarrativeProgress();
+        return entry.narrativeGate.resolveOnTool(toolName, toolInput);
       };
       for (const ev of events) {
         const idleSecBeforeBump = Math.round((now - entry.lastActivityAt) / 1000);
@@ -78728,10 +79363,9 @@ function readSubTail(entry, tail, now, onDescriptionUpdate, fs2, log, db2, paren
         } else if (ev.kind === "sub_agent_text") {
           entry.lastSummaryLine = clipNarrative(ev.text);
           entry.lastResultText = ev.text.trim().slice(0, SUBAGENT_RESULT_TEXT_MAX);
-          if (entry.pendingNarrative != null) {
-            fireNarrativeProgress();
-          }
-          entry.pendingNarrative = { text: ev.text };
+          if (entry.narrativeGate == null)
+            entry.narrativeGate = buildNarrativeGate();
+          entry.narrativeGate.stage(ev.text);
         } else if (ev.kind === "sub_agent_tool_result") {
           if (ev.toolUseId != null && ev.toolUseId !== "") {
             entry.inflightToolUseIds.delete(ev.toolUseId);
@@ -78778,7 +79412,7 @@ function startSubagentWatcher(config) {
   const stallThresholdMs = config.stallThresholdMs ?? parseEnvMs("SWITCHROOM_SUBAGENT_STALL_MS") ?? DEFAULT_STALL_THRESHOLD_MS;
   const silentSynthesisStallThresholdMs = config.silentSynthesisStallThresholdMs ?? parseEnvMs("SWITCHROOM_SUBAGENT_SILENT_SYNTH_STALL_MS") ?? DEFAULT_SILENT_SYNTHESIS_STALL_THRESHOLD_MS;
   const silentStallTerminalMs = config.silentStallTerminalMs ?? parseEnvMs("SWITCHROOM_SUBAGENT_STALL_TERMINAL_MS") ?? DEFAULT_SILENT_STALL_TERMINAL_MS;
-  const inflightTerminalCapMs = config.inflightTerminalCapMs ?? parseEnvMs("SWITCHROOM_SUBAGENT_INFLIGHT_TERMINAL_CAP_MS") ?? DEFAULT_INFLIGHT_TERMINAL_CAP_MS;
+  const inflightTerminalCapMs = resolveInflightTerminalCapMs(config.inflightTerminalCapMs);
   const deferralLogIntervalMs = config.deferralLogIntervalMs ?? parseEnvMs("SWITCHROOM_SUBAGENT_DEFERRAL_LOG_INTERVAL_MS") ?? DEFAULT_DEFERRAL_LOG_INTERVAL_MS;
   const inflightPromoteMaxAgeMs = config.inflightPromoteMaxAgeMs ?? parseEnvMs("SWITCHROOM_SUBAGENT_INFLIGHT_MAX_AGE_MS") ?? DEFAULT_INFLIGHT_PROMOTE_MAX_AGE_MS;
   const terminatedAgentIdsCap = config.terminatedAgentIdsCap ?? TERMINATED_AGENT_IDS_CAP;
@@ -78939,7 +79573,8 @@ function startSubagentWatcher(config) {
       }
       entry.toolCount = 0;
       entry.lastTool = null;
-      entry.pendingNarrative = null;
+      entry.narrativeGate?.reset();
+      entry.narrativeGate = null;
       tail.cursor = 0;
       tail.pendingPartial = "";
       tail.hasEmittedStart = false;
@@ -79038,6 +79673,13 @@ function startSubagentWatcher(config) {
     }
     terminatedAgentIds.add(agentId);
     log?.(`subagent-watcher: cleaned up terminal agent ${agentId}`);
+    if (config.onTerminalCleanup) {
+      try {
+        config.onTerminalCleanup(agentId);
+      } catch (cbErr) {
+        log?.(`subagent-watcher: onTerminalCleanup callback error ${agentId}: ${cbErr.message}`);
+      }
+    }
   }
   function recordFalseFinish(agentId, filePath, n) {
     let size = 0;
@@ -82081,10 +82723,10 @@ function readTurnActiveMarkerAgeMs(stateDir, now) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.18.18";
-var COMMIT_SHA = "a256b3b1";
-var COMMIT_DATE = "2026-07-13T03:10:38Z";
-var LATEST_PR = 3210;
+var VERSION = "0.18.20";
+var COMMIT_SHA = "f82e440f";
+var COMMIT_DATE = "2026-07-13T22:44:46+10:00";
+var LATEST_PR = 3230;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -82341,6 +82983,7 @@ async function listGrantsViaBroker2(agent, opts) {
 }
 
 // gateway/linear-activity.ts
+init_format();
 init_client();
 
 // ../src/linear/oauth-refresh.ts
@@ -84508,6 +85151,7 @@ function resolveSubagentOriginChat(agentId) {
   }
 }
 var WORKER_FEED_FALLBACK_LOG_CAP = 256;
+var WORKER_FEED_STALE_TTL_MARGIN_MS = 300000;
 var workerFeedOwnerDmFallbackLogged = new Set;
 function resolveWorkerFeedChat(agentId, fleetChatId) {
   const origin = resolveSubagentOriginChat(agentId);
@@ -85405,14 +86049,14 @@ function releaseTurnBufferGate(key, endingTurn) {
 }
 function emitTurnRecord(turn, endedAt) {
   try {
-    const rec = JSON.stringify({
-      ts: Math.floor(endedAt / 1000),
+    const rec = JSON.stringify(buildTurnRecord({
       agent: process.env.SWITCHROOM_AGENT_NAME ?? "unknown",
-      duration_ms: turn.startedAt > 0 ? endedAt - turn.startedAt : 0,
-      tools: turn.toolCallCount ?? 0,
-      status: turn.finalAnswerDelivered ? "complete" : "no_reply",
-      turn_id: turn.turnId
-    }) + `
+      startedAt: turn.startedAt,
+      toolCallCount: turn.toolCallCount ?? 0,
+      turnId: turn.turnId,
+      finalAnswerDelivered: turn.finalAnswerDelivered,
+      deliveryOutcome: turn.deliveryOutcome
+    }, endedAt)) + `
 `;
     const turnsPath = "/state/agent/turns.jsonl";
     maybeRotate(turnsPath, {
@@ -85428,15 +86072,18 @@ function emitTurnRecord(turn, endedAt) {
     appendFileSync6(turnsPath, rec);
   } catch {}
 }
-function endCurrentTurnAtomic(turn) {
+function endCurrentTurnAtomic(turn, opts) {
   const key = statusKey(turn.sessionChatId, turn.sessionThreadId);
   if (!turnLiveForItsTopic(turn))
-    return;
+    return null;
+  clearAnswerReadyFlushTimeout(turn);
   endCurrentTurnForKey(turn, key);
   const turnEndedAt = Date.now();
   process.stderr.write(`telegram gateway: ${formatTurnLifecycle("clear", "turn_end", turn, turnEndedAt)}
 `);
-  emitTurnRecord(turn, turnEndedAt);
+  if (opts?.deferRecord !== true) {
+    emitTurnRecord(turn, turnEndedAt);
+  }
   const degraded = detectStatusSurfaceDegraded(turn);
   if (degraded != null) {
     process.stderr.write(`telegram gateway: status-surface DEGRADED reason=${degraded.reason} turnId=${turn.turnId} chat=${turn.sessionChatId} thread=${turn.sessionThreadId ?? "-"} ${degraded.detail}
@@ -85453,8 +86100,10 @@ function endCurrentTurnAtomic(turn) {
     clearTimeout(turn.noReplyDrainTimer);
     turn.noReplyDrainTimer = null;
   }
+  turn.narrativeGate?.teardown();
   purgeReactionTracking(statusKey(turn.sessionChatId, turn.sessionThreadId), turn);
   armNoReplyDrainTimer(turn);
+  return turnEndedAt;
 }
 function maybeProactiveCompact() {
   if (compactDispatching)
@@ -85514,16 +86163,9 @@ function maybeProactiveCompact() {
     compactDispatching = false;
   });
 }
-var lastIdleActivityAt = Date.now();
-var lastIdleTurnEndAt = null;
-var idleAutoCleared = false;
-var idleClearDispatching = false;
+var idleTracker = new IdleTracker(Date.now());
 function markIdleActivity() {
-  lastIdleActivityAt = Date.now();
-  idleAutoCleared = false;
-}
-function markIdleTurnEnd() {
-  lastIdleTurnEndAt = Date.now();
+  idleTracker.noteInbound(Date.now());
 }
 function resolveIdleClearMs() {
   const env = process.env.SWITCHROOM_IDLE_CLEAR_MS;
@@ -85548,30 +86190,39 @@ function resolveIdleClearMs() {
   }
 }
 function maybeIdleClear() {
-  if (idleClearDispatching)
+  if (idleTracker.isDispatching)
     return;
   const agentName3 = process.env.SWITCHROOM_AGENT_NAME;
   if (!agentName3)
     return;
   const idleClearMs = resolveIdleClearMs();
-  const decision = decideIdleClear({
-    lastActivityAt: lastIdleActivityAt,
-    lastTurnEndedAt: lastIdleTurnEndAt,
+  const decision = idleTracker.decide(Date.now(), {
     idleClearMs,
-    alreadyCleared: idleAutoCleared,
-    turnInFlight: turnInFlightForGate()
-  }, Date.now());
+    turnInFlight: turnInFlightForGate(),
+    backgroundWorkInFlight: anyPendingAsyncDispatchWithin(BACKGROUND_WORK_SUPPRESS_TTL_MS)
+  });
   if (!decision.clear)
     return;
-  idleAutoCleared = true;
-  idleClearDispatching = true;
+  idleTracker.markClearFired();
+  idleTracker.beginDispatch();
   process.stderr.write(`telegram gateway: idle auto-/clear for ${agentName3} (idle >= ${Math.round(idleClearMs / 60000)}m)
 `);
-  injectSlashCommand(agentName3, "/clear").catch((err) => {
+  const stillIdleAtWrite = () => idleTracker.decideIgnoringLatch(Date.now(), {
+    idleClearMs: resolveIdleClearMs(),
+    turnInFlight: turnInFlightForGate(),
+    backgroundWorkInFlight: anyPendingAsyncDispatchWithin(BACKGROUND_WORK_SUPPRESS_TTL_MS)
+  }).clear;
+  injectSlashCommand(agentName3, "/clear", { precondition: stillIdleAtWrite }).then((result) => {
+    if (result.outcome === "skipped") {
+      idleTracker.reArm();
+      process.stderr.write(`telegram gateway: idle /clear suppressed for ${agentName3} (activity in check-to-send gap)
+`);
+    }
+  }).catch((err) => {
     process.stderr.write(`telegram gateway: idle /clear inject failed for ${agentName3}: ${err instanceof Error ? err.message : String(err)}
 `);
   }).finally(() => {
-    idleClearDispatching = false;
+    idleTracker.endDispatch();
   });
 }
 async function postCompactCard(occ, cap) {
@@ -86768,6 +87419,7 @@ var inboundCoalescer = createInboundCoalescer({
 });
 function emitGatewayOperatorEvent(event) {
   const { agent, kind } = event;
+  event = { ...event, detail: redactOutboundText(event.detail, "operator_event") };
   let throttleEscalation = null;
   let escalationFired = false;
   let rateLimitedCooldownConsulted = false;
@@ -86872,9 +87524,9 @@ function emitGatewayOperatorEvent(event) {
       return;
     }
     const tz = process.env.SWITCHROOM_TIMEZONE ?? process.env.TZ ?? "UTC";
-    const r = renderLlmError(parsed, agent, tz, new Date(now));
+    const r = renderLlmErrorSafe(parsed, agent, tz, new Date(now));
     renderedText = r.text;
-    renderedKeyboard = r.keyboard;
+    renderedKeyboard = undefined;
   } else {
     try {
       const r = renderOperatorEvent(event);
@@ -86950,6 +87602,7 @@ var STREAM_THROTTLE_MS_OVERRIDE = (() => {
   return Number.isFinite(n) && n >= 0 ? n : undefined;
 })();
 var TURN_FLUSH_SAFETY_ENABLED = isTurnFlushSafetyEnabled();
+var ANSWER_READY_FLUSH_MS2 = resolveAnswerReadyFlushMs(process.env);
 var ANSWER_STREAM_VISIBLE_ENABLED = parseVisibleAnswerStreamEnabled(process.env.SWITCHROOM_VISIBLE_ANSWER_STREAM);
 var ANSWER_LANE = resolveAnswerLaneConfig({
   visibleEnabled: ANSWER_STREAM_VISIBLE_ENABLED
@@ -87429,6 +88082,7 @@ var SILENCE_FALLBACK_MS = parsePositiveMsEnv("SWITCHROOM_SILENCE_FALLBACK_MS", 3
 var SILENCE_FALLBACK_HARD_MS = parsePositiveMsEnv("SWITCHROOM_SILENCE_FALLBACK_HARD_MS", 900000);
 var SILENCE_FLOOR_MS = parsePositiveMsEnv("SWITCHROOM_SILENCE_FLOOR_MS", 45000);
 var LIVENESS_TERMINAL_HONESTY = process.env.SWITCHROOM_TG_TERMINAL_HONESTY !== "0";
+var CAPTURED_PROSE_DELIVERY_ENABLED = process.env.SWITCHROOM_TG_CAPTURED_PROSE_DELIVERY !== "0";
 var SILENCE_DEFER_INFLIGHT_TOOLS = process.env.SWITCHROOM_SILENCE_DEFER_INFLIGHT_TOOLS === "1";
 var SILENCE_LIVENESS_PRODUCTION = process.env.SWITCHROOM_SILENCE_LIVENESS_PRODUCTION !== "0";
 var MEMORY_LEGIBILITY_ENABLED = isMemoryLegibilityEnabled(process.env.SWITCHROOM_MEMORY_LEGIBILITY);
@@ -87743,6 +88397,103 @@ function agentHasInFlightBackgroundWork(now) {
   return ageMs != null && ageMs < TURN_ACTIVE_MARKER_FRESH_MS;
 }
 var lastBgWorkDeferLogMs = 0;
+async function deliverCapturedProse(args) {
+  const { chatId, threadId, statusKeyStr, registryKey, originTurnId, text: text5, turnDurationMs } = args;
+  const now = Date.now();
+  let outcome;
+  const already = outboundDedup.check(chatId, threadId, text5, now, registryKey);
+  if (already == null) {
+    let out = normalizeParagraphBreaks2(repairEscapedWhitespace2(text5));
+    out = redactOutboundText(out, "captured_prose");
+    const chunks = splitMarkdownChunks2(out, RICH_MESSAGE_MAX_CHARS2);
+    const sentIds = [];
+    try {
+      let liveThreadId = threadId;
+      for (const c of chunks) {
+        const sent = await retryWithThreadFallback2(robustApiCall, (tid) => {
+          const opts = {
+            link_preview_options: { is_disabled: true },
+            ...tid != null ? { message_thread_id: tid } : {}
+          };
+          return bot.api.sendRichMessage(chatId, richMessage2(c), opts);
+        }, { threadId: liveThreadId, chat_id: chatId, verb: "captured-prose.sendMessage" });
+        if (liveThreadId != null && sent.message_thread_id == null) {
+          liveThreadId = undefined;
+        }
+        sentIds.push(sent.message_id);
+      }
+      if (HISTORY_ENABLED && sentIds.length > 0) {
+        try {
+          recordOutbound({
+            chat_id: chatId,
+            thread_id: threadId ?? null,
+            message_ids: sentIds,
+            texts: chunks
+          });
+        } catch {}
+      }
+      outboundDedup.record(chatId, threadId, text5, now, registryKey);
+      process.stderr.write(`telegram gateway: captured-prose delivery \u2014 sent ${out.length} chars recovered from transcript scan (chat=${chatId} origin=${originTurnId})
+`);
+      outcome = "sent";
+    } catch (err) {
+      process.stderr.write(`telegram gateway: captured-prose delivery failed: ${err.message} \u2014 ` + `arming the silent-end re-prompt net (recordUndeliveredTurnEnd) so the answer is recoverable (chat=${chatId} origin=${originTurnId})
+`);
+      outcome = "failed";
+    }
+  } else {
+    process.stderr.write(`telegram gateway: captured-prose delivery skipped \u2014 this answer already went out ` + `(dedup age=${already.ageMs}ms chat=${chatId} origin=${originTurnId}); settling bookkeeping
+`);
+    outcome = "skipped-dedup";
+  }
+  const settlement = settleCapturedProseDelivery(outcome, {
+    closeObligation: () => {
+      if (OBLIGATION_LEDGER_ENABLED) {
+        try {
+          obligationLedger.close(originTurnId);
+        } catch {}
+      }
+    },
+    clearState: () => clearSilentEndState(statusKeyStr),
+    recordUndelivered: () => {
+      try {
+        const silentEndDeps = HISTORY_ENABLED ? {
+          hasOutboundDeliveredSince: (cid, sinceMs, tid) => hasOutboundDeliveredSince(cid, sinceMs, tid, 1)
+        } : undefined;
+        return recordUndeliveredTurnEnd({ chatId, threadId: threadId ?? null, turnKey: statusKeyStr }, silentEndDeps);
+      } catch (netErr) {
+        process.stderr.write(`telegram gateway: captured-prose recovery-net arm failed: ${netErr.message} (chat=${chatId} origin=${originTurnId})
+`);
+        return { exhausted: false };
+      }
+    }
+  });
+  if (outcome === "failed" && settlement.exhausted) {
+    process.stderr.write(`telegram gateway: WARN captured-prose exhausted-boundary fallback \u2014 rich send ` + `failed with the re-prompt budget already spent; attempting a plain-text delivery of the recovered answer before the generic apology (chat=${chatId} origin=${originTurnId})
+`);
+    const plain = redactOutboundText(text5, "captured_prose");
+    const plainChunks = splitMarkdownChunks2(plain, RICH_MESSAGE_MAX_CHARS2);
+    try {
+      let liveThreadId = threadId;
+      for (const c of plainChunks) {
+        const sent = await retryWithThreadFallback2(robustApiCall, (tid) => bot.api.sendMessage(chatId, c, tid != null ? { message_thread_id: tid } : {}), { threadId: liveThreadId, chat_id: chatId, verb: "captured-prose-plain-fallback.sendMessage" });
+        if (liveThreadId != null && sent.message_thread_id == null) {
+          liveThreadId = undefined;
+        }
+      }
+      outboundDedup.record(chatId, threadId, text5, Date.now(), registryKey);
+      process.stderr.write(`telegram gateway: captured-prose recovered via plain-text fallback (chat=${chatId} origin=${originTurnId})
+`);
+    } catch (plainErr) {
+      process.stderr.write(`telegram gateway: captured-prose plain-text fallback ALSO failed: ${plainErr.message} \u2014 posting the generic silent-end apology (chat=${chatId} origin=${originTurnId})
+`);
+      retryWithThreadFallback2(robustApiCall, (tid) => bot.api.sendMessage(chatId, silentEndFallbackText(turnDurationMs), tid != null ? { message_thread_id: tid } : {}), { threadId, chat_id: chatId, verb: "captured-prose-apology-fallback.sendMessage" }).catch((err) => {
+        process.stderr.write(`telegram gateway: captured-prose apology fallback send failed: ${err instanceof Error ? err.message : String(err)}
+`);
+      });
+    }
+  }
+}
 function obligationSweep() {
   if (!OBLIGATION_LEDGER_ENABLED)
     return;
@@ -88520,7 +89271,8 @@ var ipcServer = createIpcServer({
     swallowingApiCall(() => bot.api.editMessageText(operator, msg.messageId, richMessage2(msg.text), {}), { chat_id: String(operator), verb: "rollout-status-edit" });
   },
   onInjectInbound(_client, msg) {
-    markIdleActivity();
+    if (!isCronInjectFire(msg.inbound.meta))
+      markIdleActivity();
     const promptKey = typeof msg.inbound.meta?.prompt_key === "string" ? msg.inbound.meta.prompt_key : "unknown";
     const source = typeof msg.inbound.meta?.source === "string" ? msg.inbound.meta.source : "unknown";
     const isDurableReplay = inboundSpool != null && typeof msg.inbound.meta?.replay_fire_ms === "string" && msg.inbound.meta.replay_fire_ms.length > 0;
@@ -90748,6 +91500,33 @@ function resetOrphanedReplyTimeout() {
     }, ORPHANED_REPLY_TIMEOUT_MS);
   }
 }
+var answerReadyFlush = new AnswerReadyFlushController({
+  getCurrentTurn: () => currentTurn,
+  getArmInput: (turn) => ({
+    flush: {
+      chatId: turn.sessionChatId,
+      replyCalled: turn.replyCalled,
+      capturedText: turn.capturedText,
+      flushEnabled: TURN_FLUSH_SAFETY_ENABLED
+    },
+    inFlightToolCount: toolFlightTracker.inFlightCount(),
+    hasPendingAsyncDispatch: hasPendingAsyncDispatch(statusKey(turn.sessionChatId, turn.sessionThreadId)),
+    flushWindowMs: ANSWER_READY_FLUSH_MS2
+  }),
+  getTimerHandle: (turn) => turn.answerReadyFlushTimeoutId,
+  setTimerHandle: (turn, handle) => {
+    turn.answerReadyFlushTimeoutId = handle;
+  },
+  onFlush: () => handleSessionEvent({ kind: "turn_end", durationMs: -1, reason: "answer-ready-quiescence" }),
+  log: (msg) => process.stderr.write(`telegram gateway: ${msg}
+`)
+});
+function clearAnswerReadyFlushTimeout(turn) {
+  answerReadyFlush.clear(turn);
+}
+function resetAnswerReadyFlushTimeout() {
+  answerReadyFlush.reset();
+}
 function closeActivityLane(chatId, threadId) {
   const key = chatKeyWithSuffix2(chatId, threadId, "activity");
   const stream = activeDraftStreams.get(key);
@@ -90781,6 +91560,45 @@ function composeTurnActivity(turn, final = false, liveSuffix = "") {
   };
   return renderActivityFeedWithNested2(turn.mirrorLines, childLines, final, liveSuffix, stepCount, header);
 }
+function retractNarrativeLine(turn, text5) {
+  const clipped = clipNarrative2(text5);
+  const idx = turn.mirrorLines.lastIndexOf(clipped);
+  if (idx === -1)
+    return;
+  turn.mirrorLines.splice(idx, 1);
+  const rerender = composeTurnActivity(turn);
+  if (rerender == null)
+    return;
+  turn.activityPendingRender = rerender;
+  const ea = emissionAuthorityFor(turn);
+  cardDrainGate(turn, ea, () => {
+    if (ea.mayDrain(turn)) {
+      ea.openOrEditCard("narrative", () => {
+        turn.activityInFlight = drainActivitySummary(turn, "narrative");
+      });
+    }
+  });
+}
+function makeNarrativeGate(turn) {
+  let handle = null;
+  return new NarrativeFlushController({
+    show: (text5) => showNarrativeStep(turn, text5),
+    retractShown: (text5) => retractNarrativeLine(turn, text5)
+  }, {
+    arm: (fn, ms) => {
+      if (handle != null)
+        clearTimeout(handle);
+      handle = setTimeout(fn, ms);
+      handle.unref?.();
+    },
+    disarm: () => {
+      if (handle != null) {
+        clearTimeout(handle);
+        handle = null;
+      }
+    }
+  }, PENDING_NARRATIVE_FLUSH_MS);
+}
 function showNarrativeStep(turn, text5) {
   const rendered = appendActivityLabel(turn.mirrorLines, clipNarrative2(text5));
   if (rendered == null)
@@ -90796,31 +91614,13 @@ function showNarrativeStep(turn, text5) {
   });
 }
 function resolvePendingNarrativeOnTool(turn, toolName, input) {
-  const pending2 = turn.pendingNarrative;
-  if (pending2 == null)
-    return;
-  turn.pendingNarrative = null;
-  if (REPLY_TOOLS.has(toolName)) {
-    const replyText = typeof input?.text === "string" ? input.text : "";
-    if (isDraftOfReply(pending2.text, replyText))
-      return;
-  }
-  showNarrativeStep(turn, pending2.text);
+  turn.narrativeGate.resolveOnTool(toolName, input);
 }
 function stagePendingNarrative(turn, text5) {
-  if (turn.pendingNarrative != null) {
-    showNarrativeStep(turn, turn.pendingNarrative.text);
-  }
-  turn.pendingNarrative = { text: text5 };
+  turn.narrativeGate.stage(text5);
 }
 function flushPendingNarrativeAtTurnEnd(turn, lastReplyText) {
-  const pending2 = turn.pendingNarrative;
-  if (pending2 == null)
-    return;
-  turn.pendingNarrative = null;
-  if (lastReplyText.length > 0 && isDraftOfReply(pending2.text, lastReplyText))
-    return;
-  showNarrativeStep(turn, pending2.text);
+  turn.narrativeGate.flushAtTurnEnd(lastReplyText);
 }
 async function drainActivitySummary(turn, producer = "tool", openFlags) {
   try {
@@ -91160,11 +91960,7 @@ function handleSessionEvent(ev) {
   }
   {
     const durationMs = ev.kind === "turn_end" ? ev.durationMs : undefined;
-    const signal = classifyIdleEvent(ev.kind, durationMs);
-    if (signal.activity)
-      markIdleActivity();
-    if (signal.turnEnded)
-      markIdleTurnEnd();
+    idleTracker.noteEvent(ev.kind, Date.now(), durationMs);
   }
   switch (ev.kind) {
     case "enqueue": {
@@ -91184,6 +91980,7 @@ function handleSessionEvent(ev) {
           clearTimeout(prior.orphanedReplyTimeoutId);
           prior.orphanedReplyTimeoutId = null;
         }
+        prior?.narrativeGate?.teardown();
         const startedAt = Date.now();
         const enqThreadIdNum = ev.threadId != null ? Number(ev.threadId) : undefined;
         const turnId = deriveTurnId(ev.chatId, enqThreadIdNum ?? null, ev.messageId) ?? `${chatKey2(ev.chatId, enqThreadIdNum ?? null)}#synthetic-${startedAt}`;
@@ -91209,6 +92006,7 @@ function handleSessionEvent(ev) {
           silentAnchorText: "",
           capturedText: [],
           orphanedReplyTimeoutId: null,
+          answerReadyFlushTimeoutId: null,
           liveness: new LivenessTracker(startedAt),
           turnId,
           registryKey: null,
@@ -91224,13 +92022,14 @@ function handleSessionEvent(ev) {
           activityEverOpened: false,
           activityDrainFailures: 0,
           mirrorLines: [],
-          pendingNarrative: null,
+          narrativeGate: undefined,
           lastReplyText: "",
           foregroundSubAgents: new Map,
           answerStream: null,
           isDm: isDmChatId2(ev.chatId),
           emissionAuthority: new EmissionAuthority(statusKey(ev.chatId, enqThreadIdNum))
         };
+        next.narrativeGate = makeNarrativeGate(next);
         setCurrentTurn(next, statusKey(ev.chatId, enqThreadIdNum));
         scheduleEarlyLivenessOpen(next);
         process.stderr.write(`telegram gateway: ${formatTurnLifecycle("set", "enqueue", next, startedAt)}
@@ -91302,6 +92101,7 @@ function handleSessionEvent(ev) {
       const turn = currentTurn;
       if (turn == null)
         return;
+      clearAnswerReadyFlushTimeout(turn);
       resolvePendingNarrativeOnTool(turn, ev.toolName, ev.input);
       turn.toolCallCount++;
       touchTurnActiveMarker2(STATE_DIR);
@@ -91336,6 +92136,7 @@ function handleSessionEvent(ev) {
       const turn = currentTurn;
       if (turn == null)
         return;
+      clearAnswerReadyFlushTimeout(turn);
       resetOrphanedReplyTimeout();
       if (isTelegramSurfaceTool2(ev.toolName))
         return;
@@ -91445,6 +92246,7 @@ function handleSessionEvent(ev) {
         preambleSuppressor.onText(ev.text);
       }
       resetOrphanedReplyTimeout();
+      resetAnswerReadyFlushTimeout();
       if (isContextExhaustionText(ev.text) && turn != null) {
         const chatId = turn.sessionChatId;
         const threadId = turn.sessionThreadId;
@@ -91496,7 +92298,7 @@ function handleSessionEvent(ev) {
       return;
     }
     case "turn_end": {
-      if (ev.durationMs === -1) {
+      if (ev.durationMs === -1 && ev.reason !== "answer-ready-quiescence") {
         const turn = currentTurn;
         const key = turn != null ? statusKey(turn.sessionChatId, turn.sessionThreadId) : "";
         const recentlyStreaming = turn != null && turn.liveness.recentlyStreaming(Date.now(), ORPHANED_REPLY_STREAM_WINDOW_MS);
@@ -91570,7 +92372,7 @@ function handleSessionEvent(ev) {
         const chatId = turn.sessionChatId;
         const threadId = turn.sessionThreadId;
         const ctrl = activeStatusReactions.get(statusKey(chatId, threadId));
-        const flushDecision = streamFinalizedAsAnswer ? { kind: "skip", reason: "reply-called" } : decideTurnFlush({
+        const flushDecision = streamFinalizedAsAnswer ? { kind: "skip", reason: "reply-called" } : decideTurnFlush2({
           chatId: turn.sessionChatId,
           replyCalled: turn.replyCalled,
           capturedText: turn.capturedText,
@@ -91680,7 +92482,7 @@ function handleSessionEvent(ev) {
           }) ?? { wasEmitted: false, turnKey: null };
           const backstopCardMessageId = cardTakeover.wasEmitted && cardTakeover.turnKey != null ? getPinnedProgressCardMessageId?.(cardTakeover.turnKey) ?? null : null;
           const backstopCardTurnKey = cardTakeover.turnKey;
-          endCurrentTurnAtomic(turn);
+          const backstopTurnEndedAt = endCurrentTurnAtomic(turn, { deferRecord: true });
           preambleSuppressor.dropNow();
           {
             const tKey = statusKey(chatId, threadId);
@@ -91697,6 +92499,10 @@ function handleSessionEvent(ev) {
                 if (recentCount > 0) {
                   process.stderr.write(`telegram gateway: turn-flush suppressed \u2014 reply tool sent ${recentCount} message(s) within 2s
 `);
+                  if (backstopTurnEndedAt != null) {
+                    turn.deliveryOutcome = "suppressed";
+                    emitTurnRecord(turn, backstopTurnEndedAt);
+                  }
                   return;
                 }
               } catch {}
@@ -91708,10 +92514,12 @@ function handleSessionEvent(ev) {
               link_preview_options: { is_disabled: true }
             };
             const limit = RICH_MESSAGE_MAX_CHARS2;
-            const renderedText = addParagraphSpacers2(capturedText);
-            const htmlChunks = splitMarkdownChunks2(renderedText, limit);
+            let htmlChunks = [];
             const sentIds = [];
+            let sendThrew = false;
             try {
+              const renderedText = addParagraphSpacers2(capturedText);
+              htmlChunks = splitMarkdownChunks2(renderedText, limit);
               let firstSendUsedEdit = false;
               let liveThreadId = backstopThreadId;
               if (backstopCardMessageId != null && htmlChunks.length > 0) {
@@ -91774,10 +92582,20 @@ function handleSessionEvent(ev) {
                 unpinProgressCardForChat?.(backstopChatId, backstopThreadId);
               }
             } catch (err) {
+              sendThrew = true;
               process.stderr.write(`telegram gateway: turn-flush send failed: ${err.message}
 `);
               if (backstopCtrl)
                 backstopCtrl.finalize("error");
+            } finally {
+              if (backstopTurnEndedAt != null) {
+                finalizeBackstopSend(turn, {
+                  threw: sendThrew,
+                  sentCount: sentIds.length,
+                  chunkCount: htmlChunks.length
+                });
+                emitTurnRecord(turn, backstopTurnEndedAt);
+              }
             }
           })();
           return;
@@ -91819,21 +92637,40 @@ function handleSessionEvent(ev) {
             ended_via: outboundMetrics.outboundCount > 0 ? "reply" : "silent"
           });
           if (turnEndDecision === "reprompt") {
-            const silentEndDeps = HISTORY_ENABLED ? {
-              hasOutboundDeliveredSince: (cid, sinceMs, tid) => hasOutboundDeliveredSince(cid, sinceMs, tid, 1)
-            } : undefined;
-            const silentEnd = recordUndeliveredTurnEnd({
-              chatId,
-              threadId: threadId ?? null,
-              turnKey: tKey
-            }, silentEndDeps);
-            if (silentEnd.exhausted) {
-              process.stderr.write(`telegram gateway: WARN silent-end fallback \u2014 agent stayed ` + `silent after the Stop-hook re-prompt; delivering fallback message chat=${chatId} turnKey=${tKey} (#1161)
-`);
-              retryWithThreadFallback2(robustApiCall, (tid) => bot.api.sendMessage(chatId, silentEndFallbackText(turnDurationMs), tid != null ? { message_thread_id: tid } : {}), { threadId, chat_id: chatId, verb: "silent-end-fallback.sendMessage" }).catch((err) => {
-                process.stderr.write(`telegram gateway: silent-end fallback send failed: ${err instanceof Error ? err.message : String(err)}
+            const proseDecision = CAPTURED_PROSE_DELIVERY_ENABLED ? decideCapturedProseDelivery({
+              turnKey: tKey,
+              turnId: turn.turnId,
+              minChars: CAPTURED_PROSE_MIN_CHARS
+            }) : { deliver: false, reason: "no-state" };
+            if (proseDecision.deliver && proseDecision.text != null) {
+              process.stderr.write(`telegram gateway: captured-prose delivery engaged on first silent-end chat=${chatId} turnKey=${tKey} (#3227)
 `);
+              deliverCapturedProse({
+                chatId,
+                threadId,
+                statusKeyStr: tKey,
+                registryKey: turn.registryKey ?? null,
+                originTurnId: turn.turnId,
+                text: proseDecision.text,
+                turnDurationMs
               });
+            } else {
+              const silentEndDeps = HISTORY_ENABLED ? {
+                hasOutboundDeliveredSince: (cid, sinceMs, tid) => hasOutboundDeliveredSince(cid, sinceMs, tid, 1)
+              } : undefined;
+              const silentEnd = recordUndeliveredTurnEnd({
+                chatId,
+                threadId: threadId ?? null,
+                turnKey: tKey
+              }, silentEndDeps);
+              if (silentEnd.exhausted) {
+                process.stderr.write(`telegram gateway: WARN silent-end fallback \u2014 agent stayed ` + `silent after the Stop-hook re-prompt; delivering fallback message chat=${chatId} turnKey=${tKey} (#1161)
+`);
+                retryWithThreadFallback2(robustApiCall, (tid) => bot.api.sendMessage(chatId, silentEndFallbackText(turnDurationMs), tid != null ? { message_thread_id: tid } : {}), { threadId, chat_id: chatId, verb: "silent-end-fallback.sendMessage" }).catch((err) => {
+                  process.stderr.write(`telegram gateway: silent-end fallback send failed: ${err instanceof Error ? err.message : String(err)}
+`);
+                });
+              }
             }
           }
           clear(tKey);
@@ -98314,6 +99151,7 @@ var didOneTimeSetup = false;
               },
               floodWaitRemainingMs: probeFloodWaitRemainingMs,
               maxRows: workerFeedMaxRows,
+              staleWorkerTtlMs: resolveInflightTerminalCapMs() + WORKER_FEED_STALE_TTL_MARGIN_MS,
               reconcilePin: ({ feedKey, chatId, messageId }) => {
                 if (!PIN_STATUS_WHILE_WORKING)
                   return;
@@ -98359,6 +99197,14 @@ var didOneTimeSetup = false;
                 process.stderr.write(`telegram gateway: worker ${agentId} NAMED AS LOST \u2014 falsely finalised twice, resurrection chain bound reached (issue #3023)
 `);
               },
+              onTerminalCleanup: (agentId) => {
+                try {
+                  workerActivityFeed?.terminate(agentId);
+                } catch (err) {
+                  process.stderr.write(`telegram gateway: worker terminal-cleanup feed removal error agent=${agentId}: ${err.message}
+`);
+                }
+              },
               onFinish: ({ agentId, outcome, description, resultText, toolCount, durationMs, background: entryBackground }) => {
                 deferredDoneReactions.promote();
                 let fleetChatId = "";