switchroom 0.21.10 → 0.21.11

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

@@ -6769,6 +6769,20 @@ function escapeMarkdown(text) {
 function codeSpanSafe(s) {
   return s.replace(/`/g, "`\u200b");
 }
+function codeFenceFor(text) {
+  let longestRun = 0;
+  let current = 0;
+  for (let i = 0;i < text.length; i++) {
+    if (text[i] === "`") {
+      current++;
+      if (current > longestRun)
+        longestRun = current;
+    } else {
+      current = 0;
+    }
+  }
+  return "`".repeat(Math.max(3, longestRun + 1));
+}
 function escapeLinkHref(href) {
   return href.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)").replace(/[\x00-\x20\x7f]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")}`);
 }
@@ -30565,12 +30579,16 @@ function getRecentOutboundCount(chatId, withinSeconds) {
   const row = prep2("SELECT COUNT(*) as cnt FROM messages WHERE chat_id = ? AND role = ? AND ts >= ?").get(chatId, "assistant", cutoff);
   return row?.cnt ?? 0;
 }
-function hasOutboundDeliveredSince2(chatId, sinceMs, threadId, minChars = 200) {
+function hasOutboundDeliveredSince2(chatId, sinceMs, threadId, minChars = 200, untilMs) {
   try {
     const cutoffSec = Math.floor(sinceMs / 1000);
     const minLen = Math.max(1, Math.floor(minChars));
     const params = [chatId, cutoffSec, minLen];
     let sql = "SELECT 1 FROM messages WHERE chat_id = ? AND role = 'assistant' AND ts >= ? AND LENGTH(text) >= ?";
+    if (untilMs != null && Number.isFinite(untilMs)) {
+      sql += " AND ts <= ?";
+      params.push(Math.ceil(untilMs / 1000));
+    }
     if (threadId !== undefined) {
       if (threadId === null) {
         sql += " AND thread_id IS NULL";
@@ -65182,6 +65200,7 @@ function tokenizeHtml(raw, base) {
 }
 
 // render/parse.ts
+init_format();
 function pos(node2) {
   const p = node2.position;
   return {
@@ -65488,7 +65507,7 @@ function buildPreBlock(innerItems, ctx, span) {
   if (ctx.noBreaks === true) {
     return [{ type: "code", text: text4.replace(/\s*\r?\n\s*/g, " "), ...span }];
   }
-  const fence = "```";
+  const fence = codeFenceFor(text4);
   return [
     mkSeparator(ctx, span.start, span.start),
     {
@@ -65722,8 +65741,7 @@ function renderBlockquote(node2) {
 }
 function renderCodeBlock(node2) {
   const lang = node2.language ?? "";
-  const longestRun = Math.max(0, ...(node2.text.match(/`+/g) ?? []).map((run2) => run2.length));
-  const fence = "`".repeat(Math.max(3, longestRun + 1));
+  const fence = codeFenceFor(node2.text);
   return `${fence}${lang}
 ${node2.text}
 ${fence}`;
@@ -65823,8 +65841,7 @@ function tableDegradationReason(node2) {
 }
 function degradeToCodeFence(source, node2) {
   const raw = source.slice(node2.start, node2.end);
-  const longestRun = Math.max(0, ...(raw.match(/`+/g) ?? []).map((run2) => run2.length));
-  const fence = "`".repeat(Math.max(3, longestRun + 1));
+  const fence = codeFenceFor(raw);
   return `${fence}
 ${raw}
 ${fence}`;
@@ -77239,12 +77256,16 @@ function lookupMessageRoleAndText(chatId, messageId, opts) {
     return null;
   return { role: row.role, text: row.text ?? "", kind: row.kind ?? null };
 }
-function hasOutboundDeliveredSince(chatId, sinceMs, threadId, minChars = 200) {
+function hasOutboundDeliveredSince(chatId, sinceMs, threadId, minChars = 200, untilMs) {
   try {
     const cutoffSec = Math.floor(sinceMs / 1000);
     const minLen = Math.max(1, Math.floor(minChars));
     const params = [chatId, cutoffSec, minLen];
     let sql = "SELECT 1 FROM messages WHERE chat_id = ? AND role = 'assistant' AND ts >= ? AND LENGTH(text) >= ?";
+    if (untilMs != null && Number.isFinite(untilMs)) {
+      sql += " AND ts <= ?";
+      params.push(Math.ceil(untilMs / 1000));
+    }
     if (threadId !== undefined) {
       if (threadId === null) {
         sql += " AND thread_id IS NULL";
@@ -81148,6 +81169,33 @@ function journalExternalDelivery(args, stateDir, now = Date.now()) {
   clearOutboxRecord(nonce, stateDir);
 }
 
+// gateway/answer-thread-resolve.ts
+function isCrossChatAnchor(targetChatId, anchorChatId) {
+  if (targetChatId == null || targetChatId === "")
+    return false;
+  if (anchorChatId == null || anchorChatId === "")
+    return false;
+  return String(anchorChatId) !== String(targetChatId);
+}
+
+// gateway/reply-route-log.ts
+function formatReplyRouteLog(i) {
+  const originCrossChat = isCrossChatAnchor(i.chatId, i.originTurn?.sessionChatId);
+  const liveCrossChat = isCrossChatAnchor(i.chatId, i.liveTurn?.sessionChatId);
+  const crossChatDropped = originCrossChat || liveCrossChat;
+  const originAnchor = originCrossChat ? null : i.originTurn;
+  const liveAnchor = liveCrossChat ? null : i.liveTurn;
+  const explicit = i.explicitThreadId;
+  const via = i.frameworkTopicAuthority ? originAnchor != null ? i.originVia === "quoted" ? "quoted" : "origin" : liveAnchor != null ? "live" : explicit != null ? "explicit" : i.recovered != null ? "recovered" : "none" : explicit != null ? "explicit" : originAnchor != null ? i.originVia === "quoted" ? "quoted" : "origin" : liveAnchor?.sessionThreadId != null ? "live" : i.recovered != null ? "recovered" : "none";
+  const explicitOverridden = i.frameworkTopicAuthority && explicit != null && (originAnchor != null || liveAnchor != null) && i.threadId !== explicit;
+  const ownerTurn = originAnchor ?? i.recovered ?? liveAnchor;
+  const isSupergroup = i.chatId.startsWith("-100");
+  const unrouted = isSupergroup && i.threadId == null && ownerTurn == null && !crossChatDropped;
+  const misrouteRisk = isSupergroup && via === "live" && i.hasDifferentThreadedRecentTurn(liveAnchor?.sessionThreadId);
+  return `telegram gateway: reply-route surface=${i.surface} chat=${i.chatId} ` + `resolved_thread=${i.threadId ?? "-"} via=${via} late=${liveAnchor == null} ` + `originTurn=${ownerTurn?.turnId ?? "-"} origin_thread=${ownerTurn?.sessionThreadId ?? "-"}` + (via === "recovered" ? " RECOVERED" : "") + (via === "quoted" ? " QUOTED(framework-origin)" : "") + (unrouted ? " UNROUTED(supergroup\u2192no-topic)" : "") + (misrouteRisk ? " MISROUTE_RISK(no-echo\u2192live-successor)" : "") + (crossChatDropped ? ` CROSS_CHAT_ANCHOR_DROPPED(target=${i.chatId}` + (originCrossChat ? `,origin_chat=${i.originTurn?.sessionChatId},origin_thread=${i.originTurn?.sessionThreadId ?? "-"}` : "") + (liveCrossChat ? `,live_chat=${i.liveTurn?.sessionChatId},live_thread=${i.liveTurn?.sessionThreadId ?? "-"}` : "") + `,routed\u2192${i.threadId ?? "-"})` : "") + (explicitOverridden ? ` EXPLICIT_OVERRIDDEN(model\u2192${explicit},routed\u2192${i.threadId ?? "-"})` : "") + `
+`;
+}
+
 // gateway/flood-reply-queue.ts
 var FLOOD_QUEUED_SOURCE = "flood-deferred-reply";
 function isFloodRejection(err) {
@@ -82357,7 +82405,24 @@ ${url}`;
     replyRoutedOriginTurn = originTurn ?? null;
     threadId = resolveAnswerThreadWithLog(chat_id, Number.isFinite(explicit) ? explicit : undefined, originTurn, originTurn == null ? null : echoedTurn != null ? "echo" : "quoted", turn, "reply");
   } else {
-    threadId = resolveThreadId(chat_id, args.message_thread_id ?? (turn?.sessionThreadId != null ? turn.sessionThreadId : undefined));
+    const anchorCrossChat = isCrossChatAnchor(chat_id, turn?.sessionChatId);
+    const anchorThreadId = anchorCrossChat ? undefined : turn?.sessionThreadId;
+    threadId = resolveThreadId(chat_id, args.message_thread_id ?? (anchorThreadId != null ? anchorThreadId : undefined));
+    if (anchorCrossChat) {
+      const explicitRaw = args.message_thread_id != null ? Number(args.message_thread_id) : undefined;
+      process.stderr.write(formatReplyRouteLog({
+        surface: "reply",
+        chatId: chat_id,
+        threadId,
+        explicitThreadId: Number.isFinite(explicitRaw) ? explicitRaw : undefined,
+        originTurn: null,
+        originVia: null,
+        liveTurn: turn,
+        recovered: null,
+        frameworkTopicAuthority: false,
+        hasDifferentThreadedRecentTurn: () => false
+      }));
+    }
   }
   let antecedentFromQuoteOptInDefault = false;
   if (reply_to == null && quoteOptIn && HISTORY_ENABLED) {
@@ -97095,27 +97160,120 @@ class CurrentTurnMap {
 }
 
 // gateway/answer-thread-resolve.ts
+function isCrossChatAnchor2(targetChatId, anchorChatId) {
+  if (targetChatId == null || targetChatId === "")
+    return false;
+  if (anchorChatId == null || anchorChatId === "")
+    return false;
+  return String(anchorChatId) !== String(targetChatId);
+}
 function resolveAnswerThreadId(input) {
+  const originCrossChat = isCrossChatAnchor2(input.targetChatId, input.originChatId);
+  const liveCrossChat = isCrossChatAnchor2(input.targetChatId, input.liveChatId);
+  const originResolved = input.originResolved && !originCrossChat;
+  const originThreadId = originCrossChat ? undefined : input.originThreadId;
+  const liveTurnPresent = input.liveTurnPresent === true && !liveCrossChat;
+  const liveThreadId = liveCrossChat ? undefined : input.liveThreadId;
   if (input.frameworkTopicAuthority === false) {
     if (input.explicitThreadId != null)
       return input.explicitThreadId;
-    if (input.originResolved)
-      return input.originThreadId;
-    if (input.liveThreadId != null)
-      return input.liveThreadId;
+    if (originResolved)
+      return originThreadId;
+    if (liveThreadId != null)
+      return liveThreadId;
     if (input.lastEndedResolvedForChat)
       return input.lastEndedThreadIdForChat;
-    return input.liveThreadId;
+    return liveThreadId;
   }
-  if (input.originResolved)
-    return input.originThreadId;
-  if (input.liveTurnPresent)
-    return input.liveThreadId;
+  if (originResolved)
+    return originThreadId;
+  if (liveTurnPresent)
+    return liveThreadId;
   if (input.explicitThreadId != null)
     return input.explicitThreadId;
   if (input.lastEndedResolvedForChat)
     return input.lastEndedThreadIdForChat;
-  return input.liveThreadId;
+  return liveThreadId;
+}
+
+// gateway/answer-route-overrides.ts
+function keyFor(chatId, threadId) {
+  return `${chatId}:${threadId ?? "_"}`;
+}
+function createAnswerRouteOverrides(maxKeys = 64, maxPerKey = 8) {
+  const byKey = new Map;
+  return {
+    note(args) {
+      const overridden = args.enabled && args.explicitThreadId != null && args.anchored && args.routedThreadId !== args.explicitThreadId;
+      if (!overridden)
+        return false;
+      const key = keyFor(args.chatId, args.explicitThreadId);
+      const list2 = byKey.get(key) ?? [];
+      list2.push({ routedThreadId: args.routedThreadId ?? null, atMs: args.nowMs });
+      while (list2.length > maxPerKey)
+        list2.shift();
+      byKey.set(key, list2);
+      while (byKey.size > maxKeys) {
+        const oldest = byKey.keys().next().value;
+        if (oldest === undefined)
+          break;
+        byKey.delete(oldest);
+      }
+      return true;
+    },
+    routedOverridesSince(chatId, intendedThreadId, notBeforeMs) {
+      const list2 = byKey.get(keyFor(chatId, intendedThreadId));
+      if (list2 == null)
+        return [];
+      const out = [];
+      for (const e of list2) {
+        if (e.atMs < notBeforeMs)
+          continue;
+        if (out.some((seen) => seen.routedThreadId === e.routedThreadId))
+          continue;
+        out.push({ ...e });
+      }
+      return out;
+    },
+    newestOverrideSince(chatId, intendedThreadId, notBeforeMs) {
+      const list2 = byKey.get(keyFor(chatId, intendedThreadId));
+      if (list2 == null)
+        return;
+      let newest;
+      for (const e of list2) {
+        if (e.atMs < notBeforeMs)
+          continue;
+        if (newest == null || e.atMs > newest.atMs)
+          newest = e;
+      }
+      return newest == null ? undefined : { ...newest };
+    },
+    size() {
+      return byKey.size;
+    },
+    clear() {
+      byKey.clear();
+    }
+  };
+}
+var answerRouteOverrides = createAnswerRouteOverrides();
+
+// gateway/reply-route-log.ts
+function formatReplyRouteLog2(i) {
+  const originCrossChat = isCrossChatAnchor(i.chatId, i.originTurn?.sessionChatId);
+  const liveCrossChat = isCrossChatAnchor(i.chatId, i.liveTurn?.sessionChatId);
+  const crossChatDropped = originCrossChat || liveCrossChat;
+  const originAnchor = originCrossChat ? null : i.originTurn;
+  const liveAnchor = liveCrossChat ? null : i.liveTurn;
+  const explicit = i.explicitThreadId;
+  const via = i.frameworkTopicAuthority ? originAnchor != null ? i.originVia === "quoted" ? "quoted" : "origin" : liveAnchor != null ? "live" : explicit != null ? "explicit" : i.recovered != null ? "recovered" : "none" : explicit != null ? "explicit" : originAnchor != null ? i.originVia === "quoted" ? "quoted" : "origin" : liveAnchor?.sessionThreadId != null ? "live" : i.recovered != null ? "recovered" : "none";
+  const explicitOverridden = i.frameworkTopicAuthority && explicit != null && (originAnchor != null || liveAnchor != null) && i.threadId !== explicit;
+  const ownerTurn = originAnchor ?? i.recovered ?? liveAnchor;
+  const isSupergroup = i.chatId.startsWith("-100");
+  const unrouted = isSupergroup && i.threadId == null && ownerTurn == null && !crossChatDropped;
+  const misrouteRisk = isSupergroup && via === "live" && i.hasDifferentThreadedRecentTurn(liveAnchor?.sessionThreadId);
+  return `telegram gateway: reply-route surface=${i.surface} chat=${i.chatId} ` + `resolved_thread=${i.threadId ?? "-"} via=${via} late=${liveAnchor == null} ` + `originTurn=${ownerTurn?.turnId ?? "-"} origin_thread=${ownerTurn?.sessionThreadId ?? "-"}` + (via === "recovered" ? " RECOVERED" : "") + (via === "quoted" ? " QUOTED(framework-origin)" : "") + (unrouted ? " UNROUTED(supergroup\u2192no-topic)" : "") + (misrouteRisk ? " MISROUTE_RISK(no-echo\u2192live-successor)" : "") + (crossChatDropped ? ` CROSS_CHAT_ANCHOR_DROPPED(target=${i.chatId}` + (originCrossChat ? `,origin_chat=${i.originTurn?.sessionChatId},origin_thread=${i.originTurn?.sessionThreadId ?? "-"}` : "") + (liveCrossChat ? `,live_chat=${i.liveTurn?.sessionChatId},live_thread=${i.liveTurn?.sessionThreadId ?? "-"}` : "") + `,routed\u2192${i.threadId ?? "-"})` : "") + (explicitOverridden ? ` EXPLICIT_OVERRIDDEN(model\u2192${explicit},routed\u2192${i.threadId ?? "-"})` : "") + `
+`;
 }
 
 // gateway/latest-turn-lookup.ts
@@ -98532,6 +98690,153 @@ function shouldDeferEscalationForBridge(deps) {
   return !deps.bridgeAlive;
 }
 
+// gateway/escalation-staleness.ts
+var OBLIGATION_ESCALATE_SETTLE_MS_DEFAULT = 8500;
+var OBLIGATION_ESCALATE_SETTLE_MS_MAX = 60000;
+var REROUTE_MATCH_GRACE_MS = 1e4;
+var OBLIGATION_REROUTE_MATCH_MS_MAX = OBLIGATION_ESCALATE_SETTLE_MS_MAX + REROUTE_MATCH_GRACE_MS;
+function resolveRerouteMatchWindowMs(settleMs, env = process.env) {
+  const derived = Math.max(settleMs, 0) + REROUTE_MATCH_GRACE_MS;
+  const raw = env.SWITCHROOM_OBLIGATION_REROUTE_MATCH_MS;
+  if (raw == null || raw.trim() === "")
+    return derived;
+  const n = Number(raw);
+  if (!(Number.isFinite(n) && n >= 0))
+    return derived;
+  return Math.min(n, OBLIGATION_REROUTE_MATCH_MS_MAX);
+}
+function resolveEscalateSettleMs(env = process.env) {
+  const raw = env.SWITCHROOM_OBLIGATION_ESCALATE_SETTLE_MS;
+  if (raw == null || raw.trim() === "")
+    return OBLIGATION_ESCALATE_SETTLE_MS_DEFAULT;
+  const n = Number(raw);
+  if (!(Number.isFinite(n) && n >= 0))
+    return OBLIGATION_ESCALATE_SETTLE_MS_DEFAULT;
+  return Math.min(n, OBLIGATION_ESCALATE_SETTLE_MS_MAX);
+}
+function answeredSinceOpen(o, deps) {
+  const NOT_ANSWERED = { answered: false, via: null };
+  if (!deps.historyEnabled)
+    return NOT_ANSWERED;
+  if (deps.hasOutboundDeliveredSince(o.chatId, o.openedAt, o.threadId)) {
+    return { answered: true, via: "thread" };
+  }
+  if (!(deps.rerouteMatchWindowMs > 0))
+    return NOT_ANSWERED;
+  const notBefore = Math.max(o.openedAt, deps.anchorMs - deps.rerouteMatchWindowMs);
+  for (const ovr of deps.routeOverrides.routedOverridesSince(o.chatId, o.threadId, notBefore)) {
+    const since = Math.max(ovr.atMs, o.openedAt);
+    const until = ovr.atMs + deps.rerouteMatchWindowMs;
+    if (deps.hasOutboundDeliveredBetween(o.chatId, since, until, ovr.routedThreadId)) {
+      return { answered: true, via: "reroute", routedThreadId: ovr.routedThreadId };
+    }
+  }
+  const newest = deps.routeOverrides.newestOverrideSince(o.chatId, o.threadId, o.openedAt);
+  if (newest != null && newest.atMs < notBefore) {
+    return { answered: false, via: null, staleOverrideAgeMs: Math.max(0, deps.anchorMs - newest.atMs) };
+  }
+  return NOT_ANSWERED;
+}
+function createEscalationSettleGate(settleMs, maxKeys = 256) {
+  const entries = new Map;
+  return {
+    shouldDefer(id, now, openedAt) {
+      if (!(settleMs > 0))
+        return false;
+      const prev = entries.get(id);
+      if (prev == null || prev.openedAt !== openedAt) {
+        entries.set(id, { firstAt: now, openedAt });
+        while (entries.size > maxKeys) {
+          const oldest = entries.keys().next().value;
+          if (oldest === undefined)
+            break;
+          entries.delete(oldest);
+        }
+        return true;
+      }
+      if (now < prev.firstAt) {
+        entries.set(id, { firstAt: now, openedAt });
+        return true;
+      }
+      return now - prev.firstAt < settleMs;
+    },
+    firstAt(id, openedAt) {
+      const prev = entries.get(id);
+      if (prev == null || prev.openedAt !== openedAt)
+        return;
+      return prev.firstAt;
+    },
+    clear(id) {
+      entries.delete(id);
+    },
+    size() {
+      return entries.size;
+    }
+  };
+}
+
+// gateway/answer-route-overrides.ts
+function keyFor2(chatId, threadId) {
+  return `${chatId}:${threadId ?? "_"}`;
+}
+function createAnswerRouteOverrides2(maxKeys = 64, maxPerKey = 8) {
+  const byKey = new Map;
+  return {
+    note(args) {
+      const overridden = args.enabled && args.explicitThreadId != null && args.anchored && args.routedThreadId !== args.explicitThreadId;
+      if (!overridden)
+        return false;
+      const key = keyFor2(args.chatId, args.explicitThreadId);
+      const list2 = byKey.get(key) ?? [];
+      list2.push({ routedThreadId: args.routedThreadId ?? null, atMs: args.nowMs });
+      while (list2.length > maxPerKey)
+        list2.shift();
+      byKey.set(key, list2);
+      while (byKey.size > maxKeys) {
+        const oldest = byKey.keys().next().value;
+        if (oldest === undefined)
+          break;
+        byKey.delete(oldest);
+      }
+      return true;
+    },
+    routedOverridesSince(chatId, intendedThreadId, notBeforeMs) {
+      const list2 = byKey.get(keyFor2(chatId, intendedThreadId));
+      if (list2 == null)
+        return [];
+      const out = [];
+      for (const e of list2) {
+        if (e.atMs < notBeforeMs)
+          continue;
+        if (out.some((seen) => seen.routedThreadId === e.routedThreadId))
+          continue;
+        out.push({ ...e });
+      }
+      return out;
+    },
+    newestOverrideSince(chatId, intendedThreadId, notBeforeMs) {
+      const list2 = byKey.get(keyFor2(chatId, intendedThreadId));
+      if (list2 == null)
+        return;
+      let newest;
+      for (const e of list2) {
+        if (e.atMs < notBeforeMs)
+          continue;
+        if (newest == null || e.atMs > newest.atMs)
+          newest = e;
+      }
+      return newest == null ? undefined : { ...newest };
+    },
+    size() {
+      return byKey.size;
+    },
+    clear() {
+      byKey.clear();
+    }
+  };
+}
+var answerRouteOverrides2 = createAnswerRouteOverrides2();
+
 // gateway/stream-render.ts
 init_history();
 init_rich_send();
@@ -98570,14 +98875,19 @@ function createObligationWiring(deps) {
     bridgeAlive,
     sendEscalationNudge
   } = deps;
+  const escalateSettleMs = resolveEscalateSettleMs();
+  const escalateSettleGate = createEscalationSettleGate(escalateSettleMs);
+  const rerouteMatchWindowMs = resolveRerouteMatchWindowMs(escalateSettleMs);
   function closeObligationOnSubstantiveReply(args, liveTurn, routedOriginTurn) {
     if (!OBLIGATION_LEDGER_ENABLED)
       return;
     const echoed = findTurnByOriginId(args.origin_turn_id);
     const routedOriginId = routedOriginTurn != null && echoed == null ? routedOriginTurn.turnId : null;
     const target = obligationLedger.resolveCloseTarget(echoed?.turnId, liveTurn?.turnId, routedOriginId);
-    if (target != null)
+    if (target != null) {
       obligationLedger.close(target);
+      escalateSettleGate.clear(target);
+    }
   }
   function openObligationFromInbound(inboundMsg, gate) {
     if (!OBLIGATION_LEDGER_ENABLED)
@@ -98609,6 +98919,7 @@ function createObligationWiring(deps) {
     if (turn == null)
       return;
     if (obligationLedger.close(turn.turnId)) {
+      escalateSettleGate.clear(turn.turnId);
       process.stderr.write(`telegram gateway: obligation cancelled by interrupt origin=${turn.turnId}
 `);
     }
@@ -98649,6 +98960,7 @@ function createObligationWiring(deps) {
       })) {
         process.stderr.write(`telegram gateway: obligation closed silently \u2014 reply delivered since last represent (no re-fire) origin=${o.originTurnId}
 `);
+        escalateSettleGate.clear(o.originTurnId);
         obligationLedger.close(o.originTurnId);
         return;
       }
@@ -98670,12 +98982,31 @@ function createObligationWiring(deps) {
 `);
       return;
     }
-    if (HISTORY_ENABLED && hasOutboundDeliveredSince3(o.chatId, o.openedAt, o.threadId)) {
-      process.stderr.write(`telegram gateway: obligation closed silently \u2014 outbound delivered since open origin=${o.originTurnId}
+    const answered = answeredSinceOpen(o, {
+      historyEnabled: HISTORY_ENABLED,
+      hasOutboundDeliveredSince: hasOutboundDeliveredSince3,
+      hasOutboundDeliveredBetween: (chatId, sinceMs, untilMs, threadId) => hasOutboundDeliveredSince3(chatId, sinceMs, threadId, undefined, untilMs),
+      routeOverrides: answerRouteOverrides2,
+      anchorMs: escalateSettleGate.firstAt(o.originTurnId, o.openedAt) ?? now,
+      rerouteMatchWindowMs
+    });
+    if (answered.answered) {
+      const scope = answered.via === "reroute" ? `via=reroute routed_thread=${answered.routedThreadId ?? "-"}` : "via=thread";
+      process.stderr.write(`telegram gateway: obligation closed silently \u2014 outbound delivered since open ${scope} origin=${o.originTurnId}
 `);
+      escalateSettleGate.clear(o.originTurnId);
       obligationLedger.close(o.originTurnId);
       return;
     }
+    if (answered.staleOverrideAgeMs != null) {
+      process.stderr.write(`telegram gateway: obligation reroute record rejected age=${answered.staleOverrideAgeMs}ms ` + `window=${rerouteMatchWindowMs}ms origin=${o.originTurnId}
+`);
+    }
+    if (escalateSettleGate.shouldDefer(o.originTurnId, now, o.openedAt)) {
+      process.stderr.write(`telegram gateway: obligation escalation deferred \u2014 settling (re-checking for an in-flight answer) origin=${o.originTurnId}
+`);
+      return;
+    }
     driveEscalation({
       escId: o.originTurnId,
       inFlight: obligationEscalateInFlight,
@@ -98684,6 +99015,7 @@ function createObligationWiring(deps) {
       maxAttempts: OBLIGATION_ESCALATE_MAX,
       deadlineMs: OBLIGATION_ESCALATE_SEND_DEADLINE_MS
     });
+    escalateSettleGate.clear(o.originTurnId);
   }
   return {
     closeObligationOnSubstantiveReply,
@@ -105407,10 +105739,10 @@ function startOutboxSweep(deps) {
 }
 
 // ../src/build-info.ts
-var VERSION2 = "0.21.10";
-var COMMIT_SHA = "fd1650e7";
-var COMMIT_DATE = "2026-08-14T03:50:00Z";
-var LATEST_PR = 4698;
+var VERSION2 = "0.21.11";
+var COMMIT_SHA = "7a80af9d";
+var COMMIT_DATE = "2026-08-14T09:19:49Z";
+var LATEST_PR = 4713;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -108939,7 +109271,9 @@ function resolveReplyOwnerTurn(liveTurn, chatId, args) {
   return resolveReplyOwnerTurnWith({ findTurnByOriginId, findTurnByQuotedMessageId, findLatestTurnForChat, now: Date.now }, liveTurn, chatId, args);
 }
 function resolveAnswerThreadWithLog(chatId, explicitThreadId, originTurn, originVia, liveTurn, surface) {
-  const recovered = LATE_REPLY_TOPIC_RECOVERY_ENABLED && explicitThreadId == null && originTurn == null && liveTurn == null ? findLatestTurnForChat(chatId, { endedOnly: false }) : null;
+  const originAnchor = isCrossChatAnchor2(chatId, originTurn?.sessionChatId) ? null : originTurn;
+  const liveAnchor = isCrossChatAnchor2(chatId, liveTurn?.sessionChatId) ? null : liveTurn;
+  const recovered = LATE_REPLY_TOPIC_RECOVERY_ENABLED && explicitThreadId == null && originAnchor == null && liveAnchor == null ? findLatestTurnForChat(chatId, { endedOnly: false }) : null;
   const threadId = resolveAnswerThreadId({
     explicitThreadId,
     originResolved: originTurn != null,
@@ -108948,16 +109282,31 @@ function resolveAnswerThreadWithLog(chatId, explicitThreadId, originTurn, origin
     liveTurnPresent: liveTurn != null,
     lastEndedResolvedForChat: recovered != null,
     lastEndedThreadIdForChat: recovered?.sessionThreadId,
-    frameworkTopicAuthority: REPLY_TOPIC_AUTHORITY_ENABLED
+    frameworkTopicAuthority: REPLY_TOPIC_AUTHORITY_ENABLED,
+    targetChatId: chatId,
+    originChatId: originTurn?.sessionChatId,
+    liveChatId: liveTurn?.sessionChatId
   });
-  const via = REPLY_TOPIC_AUTHORITY_ENABLED ? originTurn != null ? originVia === "quoted" ? "quoted" : "origin" : liveTurn != null ? "live" : explicitThreadId != null ? "explicit" : recovered != null ? "recovered" : "none" : explicitThreadId != null ? "explicit" : originTurn != null ? originVia === "quoted" ? "quoted" : "origin" : liveTurn?.sessionThreadId != null ? "live" : recovered != null ? "recovered" : "none";
-  const explicitOverridden = REPLY_TOPIC_AUTHORITY_ENABLED && explicitThreadId != null && (originTurn != null || liveTurn != null) && threadId !== explicitThreadId;
-  const ownerTurn = originTurn ?? recovered ?? liveTurn;
-  const isSupergroup = chatId.startsWith("-100");
-  const unrouted = isSupergroup && threadId == null && ownerTurn == null;
-  const misrouteRisk = isSupergroup && via === "live" && hasDifferentThreadedRecentTurn(chatId, liveTurn?.sessionThreadId);
-  process.stderr.write(`telegram gateway: reply-route surface=${surface} chat=${chatId} resolved_thread=${threadId ?? "-"} via=${via} late=${liveTurn == null} originTurn=${ownerTurn?.turnId ?? "-"} origin_thread=${ownerTurn?.sessionThreadId ?? "-"}` + (via === "recovered" ? " RECOVERED" : "") + (via === "quoted" ? " QUOTED(framework-origin)" : "") + (unrouted ? " UNROUTED(supergroup\u2192no-topic)" : "") + (misrouteRisk ? " MISROUTE_RISK(no-echo\u2192live-successor)" : "") + (explicitOverridden ? ` EXPLICIT_OVERRIDDEN(model\u2192${explicitThreadId},routed\u2192${threadId ?? "-"})` : "") + `
-`);
+  answerRouteOverrides.note({
+    chatId,
+    enabled: REPLY_TOPIC_AUTHORITY_ENABLED,
+    explicitThreadId,
+    anchored: originAnchor != null || liveAnchor != null,
+    routedThreadId: threadId,
+    nowMs: Date.now()
+  });
+  process.stderr.write(formatReplyRouteLog2({
+    surface,
+    chatId,
+    threadId,
+    explicitThreadId,
+    originTurn,
+    originVia,
+    liveTurn,
+    recovered,
+    frameworkTopicAuthority: REPLY_TOPIC_AUTHORITY_ENABLED,
+    hasDifferentThreadedRecentTurn: (liveThreadId) => hasDifferentThreadedRecentTurn(chatId, liveThreadId)
+  }));
   return threadId;
 }
 function hasDifferentThreadedRecentTurn(chatId, liveThreadId) {
@@ -119823,6 +120172,7 @@ async function startGateway() {
 if (isGatewayMain)
   startGateway();
 export {
+  resolveAnswerThreadWithLog,
   initVaultApprovalPosture,
   handleInboundCoalesced,
   handleInbound,

package/telegram-plugin/format.ts

@@ -85,6 +85,62 @@ export function codeSpanSafe(s: string): string {
   return s.replace(/`/g, '`​')
 }
 
+/**
+ * Compute the delimiter for a fenced code block whose body is `text`.
+ *
+ * Fenced content is verbatim per the formatting guide; the only hazard is a
+ * backtick run inside the body CLOSING the fence early. A hardcoded ``` around
+ * a body that carries its own ``` ships three delimiters instead of two: the
+ * wire opens at the first, closes at the embedded one, reads the remainder as
+ * prose, and the trailing delimiter opens a fence that never terminates —
+ * `can't find end of Pre entity`, a 400, and a whole-message plain-text
+ * resend. Widening the delimiter to one backtick longer than the longest run
+ * already present makes the open/close pair the only runs of that width, so
+ * nothing in the body can match them.
+ *
+ * This is the canonical home for the rule (as `codeSpanSafe` is for the code
+ * SPAN hazard above): the markdown fence (`renderCodeBlock`), the degraded
+ * table fence (`degradeToCodeFence`) and the raw-HTML `<pre>` fold
+ * (`buildPreBlock`, render/parse.ts) all call it, so there is exactly ONE
+ * implementation of the width rule rather than a copy per call site.
+ *
+ * The scan is a LOOP, not `Math.max(0, ...runs.map(…))`. The spread form
+ * (which both former copies of this rule used) passes one argument per run,
+ * so a body with enough separate backtick runs blows the argument limit with
+ * `RangeError: Maximum call stack size exceeded`, throwing out of the render
+ * path entirely.
+ *
+ * The limit is ENGINE-DEPENDENT, so no single number describes it. The
+ * shipping runtime is Bun (`telegram-plugin/package.json` `start`,
+ * docker/Dockerfile.agent), where it measures at ~639k runs (~1.9 MB body);
+ * this file is also collected by the vitest/Node runner, where it is ~125k
+ * (~375 KB). Both measured on the pinned toolchain (Bun 1.3.13 — the CI
+ * default in .github/actions/setup-switchroom/action.yml — and Node 22), and
+ * both move with an engine upgrade.
+ *
+ * We deliberately do NOT rely on that threshold. Input here is unbounded:
+ * `renderOutboundChunks` renders the WHOLE raw body before any
+ * `splitMarkdownChunks` (render/rich-render.ts:146), so the fence scan is not
+ * bounded by the 32768-character rich cap. Being honest about the size: on
+ * Bun a ~1.9 MB single message is an unlikely body, so there this is a latent
+ * crash rather than a routine one. The loop is O(n) either way and cannot
+ * throw, so correctness costs nothing and the reachability argument does not
+ * have to be won.
+ */
+export function codeFenceFor(text: string): string {
+  let longestRun = 0
+  let current = 0
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] === '`') {
+      current++
+      if (current > longestRun) longestRun = current
+    } else {
+      current = 0
+    }
+  }
+  return '`'.repeat(Math.max(3, longestRun + 1))
+}
+
 /**
  * Make a URL safe to interpolate as the destination of a `[label](href)`
  * inline link.