switchroom 0.18.19 → 0.18.21

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

@@ -6824,6 +6824,85 @@ function hardenCardBreaks(text) {
   }
   return restore(pieces.join(""));
 }
+function addParagraphSpacers(text) {
+  if (!text.includes(`
+
+`))
+    return text;
+  const nonce = Math.random().toString(36).slice(2);
+  const { masked, restore, placeholder } = maskCodeRegions(text, nonce);
+  if (!masked.includes(`
+
+`))
+    return restore(masked);
+  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 (isFenceOpenLine(line, placeholder))
+      return "fence";
+    if (isListItemLine(line))
+      return "list";
+    if (isTableRowLine(line) || isTableDelimiterLine(line))
+      return "table";
+    if (isBlockquoteLine(line))
+      return "quote";
+    if (isHeadingLine(line))
+      return "heading";
+    if (/^(-{3,}|\*{3,}|_{3,})\s*$/.test(line.trimStart()))
+      return "divider";
+    return "prose";
+  };
+  const SAME_KIND_TIGHT = new Set([
+    "list",
+    "table",
+    "quote",
+    "fence",
+    "divider"
+  ]);
+  const shouldSpaceGap = (above, below) => {
+    const a = blockKind(above);
+    const b = blockKind(below);
+    if (a === b && SAME_KIND_TIGHT.has(a))
+      return false;
+    return true;
+  };
+  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 < 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);
+    }
+  }
+  return restore(out.join(`
+`));
+}
 function normalizePunctuation(text) {
   if (!/[\u2014\u2013\u2022\u00b7]/.test(text))
     return text;
@@ -7051,10 +7130,11 @@ function splitMarkdownChunks(text, maxLen = RICH_MESSAGE_MAX_CHARS) {
   return chunks.map((c) => stripBoundarySpacers(c, "trailing"));
 }
 function stripBoundarySpacers(chunk, side) {
+  const sp = PARAGRAPH_SPACER;
   if (side === "leading") {
-    return chunk.replace(/^(?:[ \t]*\n)+/, "");
+    return chunk.replace(new RegExp(`^(?:[ \\t]*${sp}?[ \\t]*\\n+)+`), "");
   }
-  return chunk.replace(/(?:\n[ \t]*)+$/, "");
+  return chunk.replace(new RegExp(`(?:\\n+[ \\t]*${sp}?[ \\t]*)+$`), "");
 }
 function backOffOpenFence(text, cut) {
   if (cut <= 0 || cut >= text.length)
@@ -7103,7 +7183,7 @@ function backOffOpenInline(text, cut) {
   }
   return earliest;
 }
-var RICH_MESSAGE_MAX_CHARS = 32768, INLINE_SPAN_PATTERNS;
+var RICH_MESSAGE_MAX_CHARS = 32768, PARAGRAPH_SPACER = "\u00a0", INLINE_SPAN_PATTERNS;
 var init_format = __esm(() => {
   INLINE_SPAN_PATTERNS = [
     /`[^`\n]+`/g,
@@ -40217,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_`);
@@ -40314,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) {
@@ -40332,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 };
@@ -40386,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);
@@ -40487,6 +40584,7 @@ function createWorkerActivityFeed(opts) {
         elapsedMs: elapsedFor(r),
         toolCount: v.toolCount,
         currentStep,
+        historyLines: r.narrative.length > 0 ? [...r.narrative] : undefined,
         model: v.model
       };
     });
@@ -40606,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;
@@ -40693,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] };
@@ -40717,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);
@@ -45037,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();
 }
@@ -45056,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;
@@ -61788,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;
@@ -61805,6 +62025,7 @@ function ensure(key) {
   if (!s) {
     s = {
       pending: false,
+      dispatchedAt: null,
       anchorMessageId: null,
       anchorOriginalText: "",
       anchorLiteralText: false,
@@ -61818,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())
@@ -61848,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;
@@ -62015,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))
@@ -62120,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;
@@ -66523,6 +66831,86 @@ function hardenCardBreaks2(text4) {
   }
   return restore2(pieces.join(""));
 }
+var PARAGRAPH_SPACER2 = "\u00a0";
+function addParagraphSpacers2(text4) {
+  if (!text4.includes(`
+
+`))
+    return text4;
+  const nonce = Math.random().toString(36).slice(2);
+  const { masked, restore: restore2, placeholder } = maskCodeRegions2(text4, nonce);
+  if (!masked.includes(`
+
+`))
+    return restore2(masked);
+  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 (isFenceOpenLine2(line, placeholder))
+      return "fence";
+    if (isListItemLine2(line))
+      return "list";
+    if (isTableRowLine2(line) || isTableDelimiterLine2(line))
+      return "table";
+    if (isBlockquoteLine2(line))
+      return "quote";
+    if (isHeadingLine2(line))
+      return "heading";
+    if (/^(-{3,}|\*{3,}|_{3,})\s*$/.test(line.trimStart()))
+      return "divider";
+    return "prose";
+  };
+  const SAME_KIND_TIGHT = new Set([
+    "list",
+    "table",
+    "quote",
+    "fence",
+    "divider"
+  ]);
+  const shouldSpaceGap = (above, below) => {
+    const a = blockKind(above);
+    const b = blockKind(below);
+    if (a === b && SAME_KIND_TIGHT.has(a))
+      return false;
+    return true;
+  };
+  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 < 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);
+    }
+  }
+  return restore2(out.join(`
+`));
+}
 function normalizePunctuation2(text4) {
   if (!/[\u2014\u2013\u2022\u00b7]/.test(text4))
     return text4;
@@ -66750,10 +67138,11 @@ function splitMarkdownChunks2(text4, maxLen = RICH_MESSAGE_MAX_CHARS2) {
   return chunks.map((c) => stripBoundarySpacers2(c, "trailing"));
 }
 function stripBoundarySpacers2(chunk2, side) {
+  const sp = PARAGRAPH_SPACER2;
   if (side === "leading") {
-    return chunk2.replace(/^(?:[ \t]*\n)+/, "");
+    return chunk2.replace(new RegExp(`^(?:[ \\t]*${sp}?[ \\t]*\\n+)+`), "");
   }
-  return chunk2.replace(/(?:\n[ \t]*)+$/, "");
+  return chunk2.replace(new RegExp(`(?:\\n+[ \\t]*${sp}?[ \\t]*)+$`), "");
 }
 function backOffOpenFence2(text4, cut) {
   if (cut <= 0 || cut >= text4.length)
@@ -66943,8 +67332,8 @@ function normalizeOutboundBody(rawText, site, redact2) {
   }
   return { text: text4, voiceReplaced };
 }
-function computeEffectiveText(text4, _literalText) {
-  return text4;
+function computeEffectiveText(text4, literalText) {
+  return literalText ? text4 : addParagraphSpacers(text4);
 }
 function computeReplyChunks(args) {
   const { effectiveText, literalText, limit, chunkMode } = args;
@@ -67612,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;
@@ -67620,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(`
@@ -67630,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(`
@@ -67641,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" };
@@ -67656,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 };
 }
@@ -67672,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;
@@ -69098,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);
@@ -69132,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]);
@@ -69336,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") {
@@ -72018,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)
@@ -72029,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)
@@ -74350,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;
 }
@@ -75612,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 };
@@ -76682,6 +77259,9 @@ function decideSubagentProgress(input) {
   if (isEnvFlagOn(input.disableEnvValue)) {
     return { deliver: false, reason: "env-disabled" };
   }
+  if (input.skeleton === true) {
+    return { deliver: false, reason: "skeleton-liveness" };
+  }
   if (!input.isBackground) {
     return { deliver: false, reason: "foreground" };
   }
@@ -78210,25 +78790,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
@@ -78365,6 +79001,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;
@@ -78478,13 +79117,47 @@ 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;
       tail.pendingPartial = "";
     }
-    if (stat.size === tail.cursor)
+    if (stat.size === tail.cursor) {
+      if (onProgress != null && entry.state === "running" && !entry.historical) {
+        let hasChild = false;
+        if (db2 != null) {
+          try {
+            const kid = db2.prepare("SELECT 1 FROM subagents WHERE parent_agent_id = ? LIMIT 1").get(entry.agentId);
+            hasChild = kid != null;
+          } catch (kidErr) {
+            log?.(`subagent-watcher: skeleton child-check error ${entry.agentId}: ${kidErr.message}`);
+          }
+        }
+        if (!hasChild) {
+          try {
+            onProgress({
+              agentId: entry.agentId,
+              description: entry.description,
+              latestSummary: "",
+              elapsedMs: now - entry.dispatchedAt,
+              prevBucketIdx: entry.lastProgressBucketIdx,
+              setBucketIdx: (b) => {
+                entry.lastProgressBucketIdx = b;
+              },
+              lastTool: entry.lastTool,
+              toolCount: entry.toolCount,
+              model: entry.currentModel,
+              skeleton: true
+            });
+          } catch (cbErr) {
+            log?.(`subagent-watcher: onProgress (skeleton) callback error ${entry.agentId}: ${cbErr.message}`);
+          }
+        }
+      }
       return;
+    }
     const buf = Buffer.alloc(stat.size - tail.cursor);
     const fd = fs2.openSync(entry.filePath, "r");
     try {
@@ -78538,43 +79211,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);
@@ -78681,10 +79398,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);
@@ -78731,7 +79447,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;
@@ -78892,7 +79608,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;
@@ -78991,6 +79708,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;
@@ -82034,10 +82758,10 @@ function readTurnActiveMarkerAgeMs(stateDir, now) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.18.19";
-var COMMIT_SHA = "34c72776";
-var COMMIT_DATE = "2026-07-13T14:06:25+10:00";
-var LATEST_PR = 3212;
+var VERSION = "0.18.21";
+var COMMIT_SHA = "c237ff59";
+var COMMIT_DATE = "2026-07-14T01:11:18+10:00";
+var LATEST_PR = 3234;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -83725,6 +84449,7 @@ function applySubagentsSchema(db2) {
     db2.exec("ALTER TABLE subagents ADD COLUMN model TEXT");
   }
   db2.exec("CREATE INDEX IF NOT EXISTS subagents_jsonl_id ON subagents(jsonl_agent_id)");
+  db2.exec("CREATE INDEX IF NOT EXISTS subagents_parent_agent ON subagents(parent_agent_id)");
 }
 function mapSubagentRow(row) {
   return {
@@ -84462,6 +85187,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);
@@ -85359,14 +86085,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, {
@@ -85382,15 +86108,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}
@@ -85407,8 +86136,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)
@@ -85468,16 +86199,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;
@@ -85502,30 +86226,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) {
@@ -86905,6 +87638,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
@@ -87384,6 +88118,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);
@@ -87698,6 +88433,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;
@@ -88475,7 +89307,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;
@@ -90488,7 +91321,7 @@ async function executeEditMessage(args) {
     editRawText = normalizeParagraphBreaks2(editRawText);
   editRawText = redactOutboundText(editRawText, "edit_message");
   if (!editLiteralText)
-    editRawText = stripExcessBold2(normalizePunctuation2(editRawText));
+    editRawText = addParagraphSpacers2(stripExcessBold2(normalizePunctuation2(editRawText)));
   {
     const scrub = scrubVoice2(editRawText);
     if (scrub.replaced > 0) {
@@ -90703,6 +91536,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);
@@ -90736,6 +91596,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)
@@ -90751,31 +91650,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 {
@@ -91115,11 +91996,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": {
@@ -91139,6 +92016,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}`;
@@ -91164,6 +92042,7 @@ function handleSessionEvent(ev) {
           silentAnchorText: "",
           capturedText: [],
           orphanedReplyTimeoutId: null,
+          answerReadyFlushTimeoutId: null,
           liveness: new LivenessTracker(startedAt),
           turnId,
           registryKey: null,
@@ -91179,13 +92058,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)}
@@ -91257,6 +92137,7 @@ function handleSessionEvent(ev) {
       const turn = currentTurn;
       if (turn == null)
         return;
+      clearAnswerReadyFlushTimeout(turn);
       resolvePendingNarrativeOnTool(turn, ev.toolName, ev.input);
       turn.toolCallCount++;
       touchTurnActiveMarker2(STATE_DIR);
@@ -91291,6 +92172,7 @@ function handleSessionEvent(ev) {
       const turn = currentTurn;
       if (turn == null)
         return;
+      clearAnswerReadyFlushTimeout(turn);
       resetOrphanedReplyTimeout();
       if (isTelegramSurfaceTool2(ev.toolName))
         return;
@@ -91400,6 +92282,7 @@ function handleSessionEvent(ev) {
         preambleSuppressor.onText(ev.text);
       }
       resetOrphanedReplyTimeout();
+      resetAnswerReadyFlushTimeout();
       if (isContextExhaustionText(ev.text) && turn != null) {
         const chatId = turn.sessionChatId;
         const threadId = turn.sessionThreadId;
@@ -91451,7 +92334,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);
@@ -91525,7 +92408,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,
@@ -91635,7 +92518,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);
@@ -91652,6 +92535,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 {}
@@ -91663,10 +92550,12 @@ function handleSessionEvent(ev) {
               link_preview_options: { is_disabled: true }
             };
             const limit = RICH_MESSAGE_MAX_CHARS2;
-            const renderedText = 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) {
@@ -91729,10 +92618,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;
@@ -91774,21 +92673,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);
@@ -98269,6 +99187,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;
@@ -98314,6 +99233,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 = "";
@@ -98442,7 +99369,7 @@ var didOneTimeSetup = false;
                 process.stderr.write(`telegram gateway: subagent-handback queued agent=${agentId} outcome=${outcome} chat=${decision.chatId} resultChars=${resultText.length}
 `);
               },
-              onProgress: ({ agentId, description, latestSummary, elapsedMs, prevBucketIdx, setBucketIdx, lastTool, toolCount, progressLine, model }) => {
+              onProgress: ({ agentId, description, latestSummary, elapsedMs, prevBucketIdx, setBucketIdx, lastTool, toolCount, progressLine, model, skeleton }) => {
                 let fleetChatId = "";
                 try {
                   const fleets = progressDriver?.peekAllFleets() ?? [];
@@ -98485,6 +99412,8 @@ var didOneTimeSetup = false;
                   }
                   if (surface !== "nest")
                     return;
+                  if (skeleton)
+                    return;
                   const turn = currentTurn;
                   if (turn == null)
                     return;
@@ -98544,6 +99473,7 @@ var didOneTimeSetup = false;
                 }
                 const progressOrigin = resolveSubagentOriginChat(agentId);
                 const decision = decideSubagentProgress({
+                  skeleton: skeleton === true,
                   disableEnvValue: process.env.SWITCHROOM_DISABLE_SUBAGENT_PROGRESS,
                   isBackground,
                   fleetChatId: progressOrigin?.chatId || fleetChatId,