switchroom 0.15.10 → 0.15.11

package/dist/agent-scheduler/index.js

@@ -12313,88 +12313,10 @@ function resolveEscalationRouting(input, opts) {
   return resolveCronRouting({ ...input, kind: "prompt" }, opts);
 }
 
-// src/scheduler/cron-cadence.ts
-function csvSmallestGap(field) {
-  if (!field.includes(","))
-    return null;
-  const parts = field.split(",").map((s) => Number(s)).filter((n) => Number.isInteger(n) && n >= 0);
-  if (parts.length < 2)
-    return null;
-  const sorted = [...parts].sort((a, b) => a - b);
-  let smallest = Infinity;
-  for (let i = 1;i < sorted.length; i++) {
-    const gap = sorted[i] - sorted[i - 1];
-    if (gap > 0 && gap < smallest)
-      smallest = gap;
-  }
-  return Number.isFinite(smallest) ? smallest : null;
-}
-function estimateCronGapMin(expr) {
-  const fields = expr.trim().split(/\s+/);
-  if (fields.length < 5)
-    return Infinity;
-  const [min, hour] = fields;
-  if (min === "*")
-    return 1;
-  const minStep = min.match(/^\*\/(\d+)$/);
-  if (minStep) {
-    const n = Number(minStep[1]);
-    return n > 0 ? n : Infinity;
-  }
-  const minCsv = csvSmallestGap(min);
-  if (minCsv !== null)
-    return minCsv;
-  if (!/^\d+$/.test(min))
-    return Infinity;
-  if (hour === "*")
-    return 60;
-  const hourStep = hour.match(/^\*\/(\d+)$/);
-  if (hourStep) {
-    const n = Number(hourStep[1]);
-    return n > 0 ? n * 60 : Infinity;
-  }
-  const hourCsv = csvSmallestGap(hour);
-  if (hourCsv !== null)
-    return hourCsv * 60;
-  if (/^\d+$/.test(hour))
-    return 1440;
-  return Infinity;
-}
-
 // src/scheduler/tier-selector.ts
 var DEFAULT_FREQUENT_GAP_MIN = 60;
-function recommendCronTier(input, frequentGapMin = DEFAULT_FREQUENT_GAP_MIN) {
-  if (input.kind === "poll") {
-    return { tier: "poll", source: "explicit", reason: "declared kind: poll (model-free check)" };
-  }
-  if (input.context === "fresh") {
-    return { tier: "cheap", source: "explicit", reason: "declared context: fresh (cheap cron session)" };
-  }
-  if (input.context === "agent") {
-    return { tier: "main", source: "explicit", reason: "declared context: agent (full live session)" };
-  }
-  if (input.model !== undefined) {
-    return isKnownCheapModel(input.model) ? { tier: "cheap", source: "explicit", reason: `cheap model '${input.model}' → cheap cron session` } : { tier: "main", source: "explicit", reason: `model '${input.model}' is not a known-cheap id → full live session` };
-  }
-  if (input.smallestGapMin <= frequentGapMin) {
-    return {
-      tier: "cheap",
-      source: "cadence-default",
-      reason: `fires every ~${input.smallestGapMin}min (≤ ${frequentGapMin}min) — defaulting to a cheap ` + `session; set context: agent (or an Opus/custom model) if this needs the agent's full context`
-    };
-  }
-  return {
-    tier: "main",
-    source: "cadence-default",
-    reason: `fires every ~${input.smallestGapMin}min (> ${frequentGapMin}min) — defaulting to the agent's ` + `full session; set model: sonnet (or context: fresh) to run it cheaply`
-  };
-}
-function applyDefaultTier(entry, frequentGapMin = DEFAULT_FREQUENT_GAP_MIN) {
-  if (entry.kind === "poll" || entry.context !== undefined || entry.model !== undefined) {
-    return entry;
-  }
-  const rec = recommendCronTier({ smallestGapMin: estimateCronGapMin(entry.cron) }, frequentGapMin);
-  return rec.tier === "cheap" ? { ...entry, context: "fresh" } : entry;
+function applyDefaultTier(entry, _frequentGapMin = DEFAULT_FREQUENT_GAP_MIN) {
+  return entry;
 }
 
 // src/agent-scheduler/cheap-cron-wiring.ts

package/dist/cli/switchroom.js

@@ -15435,87 +15435,9 @@ var init_cron_routing = __esm(() => {
   OPUS_MODEL_RE = /opus/i;
 });
 
-// src/scheduler/cron-cadence.ts
-function csvSmallestGap(field) {
-  if (!field.includes(","))
-    return null;
-  const parts = field.split(",").map((s) => Number(s)).filter((n) => Number.isInteger(n) && n >= 0);
-  if (parts.length < 2)
-    return null;
-  const sorted = [...parts].sort((a, b) => a - b);
-  let smallest = Infinity;
-  for (let i = 1;i < sorted.length; i++) {
-    const gap = sorted[i] - sorted[i - 1];
-    if (gap > 0 && gap < smallest)
-      smallest = gap;
-  }
-  return Number.isFinite(smallest) ? smallest : null;
-}
-function estimateCronGapMin(expr) {
-  const fields = expr.trim().split(/\s+/);
-  if (fields.length < 5)
-    return Infinity;
-  const [min, hour] = fields;
-  if (min === "*")
-    return 1;
-  const minStep = min.match(/^\*\/(\d+)$/);
-  if (minStep) {
-    const n = Number(minStep[1]);
-    return n > 0 ? n : Infinity;
-  }
-  const minCsv = csvSmallestGap(min);
-  if (minCsv !== null)
-    return minCsv;
-  if (!/^\d+$/.test(min))
-    return Infinity;
-  if (hour === "*")
-    return 60;
-  const hourStep = hour.match(/^\*\/(\d+)$/);
-  if (hourStep) {
-    const n = Number(hourStep[1]);
-    return n > 0 ? n * 60 : Infinity;
-  }
-  const hourCsv = csvSmallestGap(hour);
-  if (hourCsv !== null)
-    return hourCsv * 60;
-  if (/^\d+$/.test(hour))
-    return 1440;
-  return Infinity;
-}
-
 // src/scheduler/tier-selector.ts
-function recommendCronTier(input, frequentGapMin = DEFAULT_FREQUENT_GAP_MIN) {
-  if (input.kind === "poll") {
-    return { tier: "poll", source: "explicit", reason: "declared kind: poll (model-free check)" };
-  }
-  if (input.context === "fresh") {
-    return { tier: "cheap", source: "explicit", reason: "declared context: fresh (cheap cron session)" };
-  }
-  if (input.context === "agent") {
-    return { tier: "main", source: "explicit", reason: "declared context: agent (full live session)" };
-  }
-  if (input.model !== undefined) {
-    return isKnownCheapModel(input.model) ? { tier: "cheap", source: "explicit", reason: `cheap model '${input.model}' \u2192 cheap cron session` } : { tier: "main", source: "explicit", reason: `model '${input.model}' is not a known-cheap id \u2192 full live session` };
-  }
-  if (input.smallestGapMin <= frequentGapMin) {
-    return {
-      tier: "cheap",
-      source: "cadence-default",
-      reason: `fires every ~${input.smallestGapMin}min (\u2264 ${frequentGapMin}min) \u2014 defaulting to a cheap ` + `session; set context: agent (or an Opus/custom model) if this needs the agent's full context`
-    };
-  }
-  return {
-    tier: "main",
-    source: "cadence-default",
-    reason: `fires every ~${input.smallestGapMin}min (> ${frequentGapMin}min) \u2014 defaulting to the agent's ` + `full session; set model: sonnet (or context: fresh) to run it cheaply`
-  };
-}
-function applyDefaultTier(entry, frequentGapMin = DEFAULT_FREQUENT_GAP_MIN) {
-  if (entry.kind === "poll" || entry.context !== undefined || entry.model !== undefined) {
-    return entry;
-  }
-  const rec = recommendCronTier({ smallestGapMin: estimateCronGapMin(entry.cron) }, frequentGapMin);
-  return rec.tier === "cheap" ? { ...entry, context: "fresh" } : entry;
+function applyDefaultTier(entry, _frequentGapMin = DEFAULT_FREQUENT_GAP_MIN) {
+  return entry;
 }
 var DEFAULT_FREQUENT_GAP_MIN = 60;
 var init_tier_selector = __esm(() => {
@@ -50325,8 +50247,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.15.10";
-var COMMIT_SHA = "bb9182e1";
+var VERSION = "0.15.11";
+var COMMIT_SHA = "43331954";
 
 // src/cli/agent.ts
 init_source();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.15.10",
+  "version": "0.15.11",
   "description": "Run Claude Code 24/7 on your Claude Pro/Max subscription over Telegram. Open-source alternative to OpenClaw and NanoClaw — no API keys.",
   "type": "module",
   "bin": {

package/profiles/_base/cron-session.sh.hbs

@@ -17,15 +17,19 @@
 set -u
 
 # Runtime kill-switch. The fork is baked into start.sh whenever {{name}} has a
-# context:fresh cron entry (a config property), but the session only actually
-# runs when SWITCHROOM_CHEAP_CRON is on at runtime. Exit 78 (EX_CONFIG) so the
-# supervisor does NOT respawn-loop when the feature is off — a clean idle.
+# cron entry the value-gate routes to a cheap session, but the session only
+# actually runs when cheap-cron is enabled at runtime. Cheap-cron is ON by
+# DEFAULT (matches isCheapCronEnabled in src/scheduler/cron-routing.ts — only
+# SWITCHROOM_CHEAP_CRON=0/false/off disables it); the old "off unless =1" gate
+# here meant the cron session quarantined itself even with cheap-by-default on,
+# so every Tier-1 fire fell back to the main session and saved nothing. Exit 78
+# (EX_CONFIG) on the explicit kill-switch so the supervisor cleanly idles.
 case "${SWITCHROOM_CHEAP_CRON:-}" in
-  1 | true | on | ON) : ;;
-  *)
-    echo "cron-session: SWITCHROOM_CHEAP_CRON off — not starting (exit 78, no respawn)" >&2
+  0 | false | off | OFF | False | FALSE)
+    echo "cron-session: SWITCHROOM_CHEAP_CRON disabled (=0) — not starting (exit 78, no respawn)" >&2
     exit 78
     ;;
+  *) : ;;
 esac
 
 CRON_NAME="{{name}}-cron"

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

@@ -28268,6 +28268,7 @@ __export(exports_history, {
   pruneMessagesOlderThanDays: () => pruneMessagesOlderThanDays,
   lookupMessageRoleAndText: () => lookupMessageRoleAndText,
   initHistory: () => initHistory,
+  hasOutboundDeliveredSince: () => hasOutboundDeliveredSince,
   getRecentOutboundCount: () => getRecentOutboundCount,
   getLatestInboundMessageId: () => getLatestInboundMessageId,
   deleteFromHistory: () => deleteFromHistory,
@@ -28462,6 +28463,26 @@ function getRecentOutboundCount(chatId, withinSeconds) {
   const row = requireDb().prepare("SELECT COUNT(*) as cnt FROM messages WHERE chat_id = ? AND role = ? AND ts >= ?").get(chatId, "assistant", cutoff);
   return row?.cnt ?? 0;
 }
+function hasOutboundDeliveredSince(chatId, sinceMs, threadId) {
+  try {
+    const cutoffSec = Math.floor(sinceMs / 1000);
+    const params = [chatId, cutoffSec];
+    let sql = "SELECT 1 FROM messages WHERE chat_id = ? AND role = 'assistant' AND ts >= ? AND LENGTH(text) >= 200";
+    if (threadId !== undefined) {
+      if (threadId === null) {
+        sql += " AND thread_id IS NULL";
+      } else {
+        sql += " AND thread_id = ?";
+        params.push(threadId);
+      }
+    }
+    sql += " LIMIT 1";
+    const row = requireDb().prepare(sql).get(...params);
+    return row != null;
+  } catch {
+    return false;
+  }
+}
 function query(opts) {
   const limit = Math.min(MAX_LIMIT, Math.max(1, opts.limit ?? DEFAULT_LIMIT));
   const params = [opts.chat_id];
@@ -48305,21 +48326,23 @@ class ObligationLedger {
     return best;
   }
   decideAtIdle(opts) {
-    const useEligible = opts != null && (opts.graceMs > 0 || opts.backgroundWorkActive === true);
-    const o = useEligible ? this.oldestEligible(opts.now, opts.graceMs, opts.backgroundWorkActive === true, opts.backgroundGraceMs ?? 0) : this.oldest();
+    const useEligible = opts != null && (opts.graceMs > 0 || opts.backgroundWorkActive === true || (opts.representGraceMs ?? 0) > 0);
+    const o = useEligible ? this.oldestEligible(opts.now, opts.graceMs, opts.backgroundWorkActive === true, opts.backgroundGraceMs ?? 0, opts.representGraceMs ?? 0) : this.oldest();
     if (o === undefined)
       return { action: "none" };
     if (o.representCount >= this.maxRepresents)
       return { action: "escalate", obligation: o };
     return { action: "represent", obligation: o };
   }
-  oldestEligible(now, graceMs, backgroundWorkActive, backgroundGraceMs) {
+  oldestEligible(now, graceMs, backgroundWorkActive, backgroundGraceMs, representGraceMs) {
     let best;
     for (const o of this.open.values()) {
       if (o.lastTurnEndedAt != null && now - o.lastTurnEndedAt < graceMs)
         continue;
       if (backgroundWorkActive && backgroundGraceMs > 0 && now - o.openedAt < backgroundGraceMs)
         continue;
+      if (representGraceMs > 0 && o.lastRepresentedAt != null && now - o.lastRepresentedAt < representGraceMs)
+        continue;
       if (best === undefined || o.openedAt < best.openedAt)
         best = o;
     }
@@ -48332,18 +48355,21 @@ class ObligationLedger {
     o.lastTurnEndedAt = ts;
     this.persist();
   }
-  resolveCloseTarget(echoedTurnId, liveTurnId) {
+  resolveCloseTarget(echoedTurnId, liveTurnId, routedOriginId) {
     if (echoedTurnId != null)
       return echoedTurnId;
-    if (liveTurnId != null && this.open.size === 1 && this.open.has(liveTurnId))
+    if (routedOriginId != null)
+      return routedOriginId;
+    if (liveTurnId != null && this.open.has(liveTurnId))
       return liveTurnId;
     return null;
   }
-  markRepresented(originTurnId) {
+  markRepresented(originTurnId, now = Date.now()) {
     const o = this.open.get(originTurnId);
     if (o === undefined)
       return 0;
     o.representCount += 1;
+    o.lastRepresentedAt = now;
     this.persist();
     return o.representCount;
   }
@@ -53767,10 +53793,10 @@ function readTurnActiveMarkerAgeMs(stateDir, now) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.15.10";
-var COMMIT_SHA = "bb9182e1";
-var COMMIT_DATE = "2026-06-13T01:33:32Z";
-var LATEST_PR = 2302;
+var VERSION = "0.15.11";
+var COMMIT_SHA = "43331954";
+var COMMIT_DATE = "2026-06-13T03:24:01Z";
+var LATEST_PR = 2308;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -55003,6 +55029,13 @@ var OBLIGATION_BACKGROUND_WORK_GRACE_MS = (() => {
   const n = Number(raw);
   return Number.isFinite(n) && n >= 0 ? n : 1200000;
 })();
+var OBLIGATION_REPRESENT_GRACE_MS = (() => {
+  const raw = process.env.SWITCHROOM_OBLIGATION_REPRESENT_GRACE_MS;
+  if (raw == null || raw === "")
+    return 120000;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? n : 120000;
+})();
 var TURN_ACTIVE_MARKER_FRESH_MS = 90000;
 var AUTOCLASSIFY_MIDTURN_SHADOW = process.env.SWITCHROOM_AUTOCLASSIFY_MIDTURN_SHADOW !== "0";
 var lastAgentOutputAt = new Map;
@@ -55158,11 +55191,12 @@ function hasDifferentThreadedRecentTurn(chatId, liveThreadId) {
   }
   return false;
 }
-function closeObligationOnSubstantiveReply(args, liveTurn) {
+function closeObligationOnSubstantiveReply(args, liveTurn, routedOriginTurn) {
   if (!OBLIGATION_LEDGER_ENABLED)
     return;
   const echoed = findTurnByOriginId(args.origin_turn_id);
-  const target = obligationLedger.resolveCloseTarget(echoed?.turnId, liveTurn?.turnId);
+  const routedOriginId = routedOriginTurn != null && echoed == null ? routedOriginTurn.turnId : null;
+  const target = obligationLedger.resolveCloseTarget(echoed?.turnId, liveTurn?.turnId, routedOriginId);
   if (target != null)
     obligationLedger.close(target);
 }
@@ -56538,11 +56572,12 @@ function obligationSweep() {
   const agent = process.env.SWITCHROOM_AGENT_NAME ?? "";
   const now = Date.now();
   const backgroundWorkActive = OBLIGATION_BACKGROUND_WORK_GRACE_MS > 0 && agentHasInFlightBackgroundWork(now);
-  const decision = obligationLedger.decideAtIdle(OBLIGATION_ESCALATE_GRACE_MS > 0 || backgroundWorkActive ? {
+  const decision = obligationLedger.decideAtIdle(OBLIGATION_ESCALATE_GRACE_MS > 0 || backgroundWorkActive || OBLIGATION_REPRESENT_GRACE_MS > 0 ? {
     now,
     graceMs: OBLIGATION_ESCALATE_GRACE_MS,
     backgroundWorkActive,
-    backgroundGraceMs: OBLIGATION_BACKGROUND_WORK_GRACE_MS
+    backgroundGraceMs: OBLIGATION_BACKGROUND_WORK_GRACE_MS,
+    representGraceMs: OBLIGATION_REPRESENT_GRACE_MS
   } : undefined);
   const o = decision.obligation;
   if (decision.action === "none" || o == null) {
@@ -56562,6 +56597,12 @@ function obligationSweep() {
 `);
     return;
   }
+  if (HISTORY_ENABLED && hasOutboundDeliveredSince(o.chatId, o.openedAt, o.threadId)) {
+    process.stderr.write(`telegram gateway: obligation closed silently \u2014 outbound delivered since open origin=${o.originTurnId}
+`);
+    obligationLedger.close(o.originTurnId);
+    return;
+  }
   driveEscalation({
     escId: o.originTurnId,
     inFlight: obligationEscalateInFlight,
@@ -57444,12 +57485,14 @@ ${url}`;
     effectiveText = text;
   }
   assertAllowedChat(chat_id);
+  let replyRoutedOriginTurn = null;
   let threadId;
   if (TURN_ORIGIN_ROUTING_ENABLED) {
     const explicit = args.message_thread_id != null ? Number(args.message_thread_id) : undefined;
     const echoedTurn = findTurnByOriginId(args.origin_turn_id);
     const quotedTurn = echoedTurn == null ? findTurnByQuotedMessageId(chat_id, args.reply_to) : null;
     const originTurn = echoedTurn ?? quotedTurn;
+    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));
@@ -57583,7 +57626,7 @@ ${url}`;
               disableNotification
             });
             if (turn2.finalAnswerSubstantive)
-              closeObligationOnSubstantiveReply(args, turn2);
+              closeObligationOnSubstantiveReply(args, turn2, replyRoutedOriginTurn);
           }
           outboundDedup.record(chat_id, threadId, decision.mergedText, Date.now(), turn2?.registryKey ?? null);
           silentAnchorEditDone = true;
@@ -57786,7 +57829,7 @@ ${url}`;
       turn.finalAnswerSubstantive = isSubstantiveFinalReply({ text: rawText, disableNotification });
       finalizeStatusReaction(chat_id, threadId, "done");
       if (turn.finalAnswerSubstantive)
-        closeObligationOnSubstantiveReply(args, turn);
+        closeObligationOnSubstantiveReply(args, turn, replyRoutedOriginTurn);
     }
     releaseTurnBufferGate(statusKey(chat_id, threadId), turn ?? undefined);
     if (turn?.finalAnswerDelivered === true) {
@@ -57806,13 +57849,19 @@ async function executeStreamReply(args) {
     throw new Error("stream_reply: chat_id is required");
   if (args.text == null || args.text === "")
     throw new Error("stream_reply: text is required and cannot be empty");
+  let streamRoutedOriginTurn = null;
+  let streamOriginVia = null;
+  if (TURN_ORIGIN_ROUTING_ENABLED) {
+    const echoedTurn = findTurnByOriginId(args.origin_turn_id);
+    const quotedTurn = echoedTurn == null ? findTurnByQuotedMessageId(String(args.chat_id), args.reply_to) : null;
+    const originTurn = echoedTurn ?? quotedTurn;
+    streamRoutedOriginTurn = originTurn ?? null;
+    streamOriginVia = originTurn == null ? null : echoedTurn != null ? "echo" : "quoted";
+  }
   if (args.message_thread_id == null) {
     let injected;
     if (TURN_ORIGIN_ROUTING_ENABLED) {
-      const echoedTurn = findTurnByOriginId(args.origin_turn_id);
-      const quotedTurn = echoedTurn == null ? findTurnByQuotedMessageId(String(args.chat_id), args.reply_to) : null;
-      const originTurn = echoedTurn ?? quotedTurn;
-      injected = resolveAnswerThreadWithLog(String(args.chat_id), undefined, originTurn, originTurn == null ? null : echoedTurn != null ? "echo" : "quoted", turn, "stream_reply");
+      injected = resolveAnswerThreadWithLog(String(args.chat_id), undefined, streamRoutedOriginTurn, streamOriginVia, turn, "stream_reply");
     } else {
       injected = turn?.sessionThreadId;
     }
@@ -57955,7 +58004,7 @@ async function executeStreamReply(args) {
       done: args.done === true
     });
     if (turn.finalAnswerSubstantive)
-      closeObligationOnSubstantiveReply(args, turn);
+      closeObligationOnSubstantiveReply(args, turn, streamRoutedOriginTurn);
     const streamThreadIdForClear = args.message_thread_id != null ? Number(args.message_thread_id) : undefined;
     clearSilentEndState(statusKey(streamChatId, streamThreadIdForClear));
   }

package/telegram-plugin/gateway/gateway.ts

@@ -139,6 +139,7 @@ import {
   recordReaction, lookupMessageRoleAndText,
   checkpointWal as checkpointHistoryWal,
   pruneMessagesOlderThanDays,
+  hasOutboundDeliveredSince,
 } from '../history.js'
 import {
   runRegistryReaper,
@@ -1506,6 +1507,20 @@ const OBLIGATION_BACKGROUND_WORK_GRACE_MS = (() => {
   const n = Number(raw)
   return Number.isFinite(n) && n >= 0 ? n : 20 * 60_000
 })()
+// Per-represent grace window. After a re-present fires, the obligation is
+// ineligible for the next represent/escalate until at least this many ms have
+// elapsed since markRepresented. Without this the 5s sweep can fire again
+// before the re-presented turn even reaches the agent, burning the represent
+// budget and producing back-to-back re-presents or a premature escalation.
+// Default 120s — generous enough for a turn to start + deliver an answer;
+// small enough not to delay genuine unanswered re-presents.
+// Kill switch: SWITCHROOM_OBLIGATION_REPRESENT_GRACE_MS=0 → no per-represent grace.
+const OBLIGATION_REPRESENT_GRACE_MS = (() => {
+  const raw = process.env.SWITCHROOM_OBLIGATION_REPRESENT_GRACE_MS
+  if (raw == null || raw === '') return 120_000
+  const n = Number(raw)
+  return Number.isFinite(n) && n >= 0 ? n : 120_000
+})()
 // Marker-freshness window for the orphaned-foreground signal. The turn-active
 // marker is touched on every foreground tool_use and on foreground sub-agent
 // JSONL growth, so an mtime younger than this means a sub-agent is touching it
@@ -2175,23 +2190,38 @@ function hasDifferentThreadedRecentTurn(
  * PR2 obligation-ledger CLOSE. Called when a SUBSTANTIVE final answer lands
  * (not a bare interim ack — using finalAnswerSubstantive, the #2141 signal): the
  * obligation discharged is the one for the SAME origin the answer routes to
- * (origin_turn_id the model echoed, else the live turn). So 713's reply closes
- * 713's obligation even after currentTurn flipped to 715, and 715 stays open
- * until ITS own substantive answer. An ack does NOT close (so ack-then-ghost is
- * re-presented, not re-dropped). turn.turnId === the obligation's origin id
- * (both deriveTurnId(chat,thread,messageId) of the same inbound). No-op unless
- * the flag is on. NOTE residual: a genuinely SHORT answer (<200 chars, not a
- * stream-done) reads as non-substantive and won't close → a bounded re-ask
- * (≤2) then one operator-visible nudge — the accepted double-ask tradeoff,
- * measured in the canary.
+ * (origin_turn_id the model echoed, else the routed origin the gateway resolved,
+ * else the live turn). So 713's reply closes 713's obligation even after
+ * currentTurn flipped to 715, and 715 stays open until ITS own substantive
+ * answer. Answers to re-presented obligations (via=quoted, no model echo) close
+ * via the gateway-resolved routedOriginTurn. An ack does NOT close (so
+ * ack-then-ghost is re-presented, not re-dropped). The live-turn fallback fires
+ * only for the live turn's OWN obligation (it was the turn delivering this
+ * reply), preserving the 713/715 invariant. No-op unless the flag is on.
+ *
+ * @param routedOriginTurn — the origin the reply router already resolved
+ *   (echoedTurn ?? quotedTurn); pass whenever the TURN_ORIGIN_ROUTING path ran.
+ *   Skipped when null/undefined (pre-routing paths, or DM with no quote).
  */
 function closeObligationOnSubstantiveReply(
   args: Record<string, unknown>,
   liveTurn: CurrentTurn | null | undefined,
+  routedOriginTurn?: CurrentTurn | null,
 ): void {
   if (!OBLIGATION_LEDGER_ENABLED) return
   const echoed = findTurnByOriginId(args.origin_turn_id as string | undefined)
-  const target = obligationLedger.resolveCloseTarget(echoed?.turnId, liveTurn?.turnId)
+  // routedOriginTurn is the gateway-resolved origin (echoedTurn ?? quotedTurn).
+  // Only pass it as routedOriginId when it DIFFERS from the echoed turn (if
+  // echoed is present, resolveCloseTarget's first branch already handles it),
+  // and only when it is NOT the live turn (live-turn is the fallback, not the
+  // routed origin — passing live turn here would bypass the live-turn fallback
+  // logic and still close correctly, but naming matters for the 713/715 case:
+  // the routed origin on a via=quoted reply IS the origin, not "live fallback").
+  const routedOriginId =
+    routedOriginTurn != null && echoed == null
+      ? routedOriginTurn.turnId
+      : null
+  const target = obligationLedger.resolveCloseTarget(echoed?.turnId, liveTurn?.turnId, routedOriginId)
   if (target != null) obligationLedger.close(target)
 }
 
@@ -5414,13 +5444,16 @@ function obligationSweep(): void {
     OBLIGATION_BACKGROUND_WORK_GRACE_MS > 0 && agentHasInFlightBackgroundWork(now)
   // Grace window: skip an obligation whose handling turn ended < grace ago — its
   // trailing slow/worker answer may still be landing (over-escalation fix).
+  // Per-represent grace: skip an obligation re-presented < grace ago — prevents
+  // the 5s sweep from immediately firing again before the re-present even lands.
   const decision = obligationLedger.decideAtIdle(
-    OBLIGATION_ESCALATE_GRACE_MS > 0 || backgroundWorkActive
+    OBLIGATION_ESCALATE_GRACE_MS > 0 || backgroundWorkActive || OBLIGATION_REPRESENT_GRACE_MS > 0
       ? {
           now,
           graceMs: OBLIGATION_ESCALATE_GRACE_MS,
           backgroundWorkActive,
           backgroundGraceMs: OBLIGATION_BACKGROUND_WORK_GRACE_MS,
+          representGraceMs: OBLIGATION_REPRESENT_GRACE_MS,
         }
       : undefined,
   )
@@ -5449,8 +5482,22 @@ function obligationSweep(): void {
     )
     return
   }
-  // escalate — re-present ladder exhausted. Send ONE operator-visible nudge and
-  // close the obligation ONLY AFTER it actually lands. This inverts the old
+  // escalate — re-present ladder exhausted. Before sending the user-visible
+  // apology, check whether the agent has ALREADY delivered an outbound reply
+  // to this chat since the obligation was opened. If yes, the obligation is
+  // stale (the agent did answer, just without closing the obligation via the
+  // normal close path) — close silently instead of alarming the user with a
+  // false "I may have missed this". This is Fix 4: escalate only on knowledge,
+  // not doubt. Fall back to false (safe: never suppresses) if history unavailable.
+  if (HISTORY_ENABLED && hasOutboundDeliveredSince(o.chatId, o.openedAt, o.threadId)) {
+    process.stderr.write(
+      `telegram gateway: obligation closed silently — outbound delivered since open origin=${o.originTurnId}\n`,
+    )
+    obligationLedger.close(o.originTurnId)
+    return
+  }
+  // Proceed with escalation: send ONE operator-visible nudge and close the
+  // obligation ONLY AFTER it actually lands. This inverts the old
   // close-before-send (which silently dropped the terminal whenever the send
   // failed): the close is now itself an observable terminal. A transient send
   // failure leaves the obligation OPEN → retried next sweep; a PERMANENT one
@@ -6970,6 +7017,10 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
   // heuristic is what mis-routed a late reply to whichever topic most
   // recently received a message. DM: every tier is undefined → unchanged.
   // Kill switch off → exact legacy resolveThreadId precedence.
+  // Hoist the resolved origin turn so the obligation-close path (below) can
+  // pass it into resolveCloseTarget as routedOriginId, closing re-presented
+  // obligations even when the model omitted origin_turn_id (Fix 1/2).
+  let replyRoutedOriginTurn: CurrentTurn | null = null
   let threadId: number | undefined
   if (TURN_ORIGIN_ROUTING_ENABLED) {
     const explicit = args.message_thread_id != null ? Number(args.message_thread_id) : undefined
@@ -6979,6 +7030,7 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
     const echoedTurn = findTurnByOriginId(args.origin_turn_id as string | undefined)
     const quotedTurn = echoedTurn == null ? findTurnByQuotedMessageId(chat_id, args.reply_to) : null
     const originTurn = echoedTurn ?? quotedTurn
+    replyRoutedOriginTurn = originTurn ?? null
     threadId = resolveAnswerThreadWithLog(
       chat_id,
       Number.isFinite(explicit as number) ? (explicit as number) : undefined,
@@ -7220,7 +7272,7 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
               text: decision.mergedText,
               disableNotification,
             })
-            if (turn.finalAnswerSubstantive) closeObligationOnSubstantiveReply(args, turn)
+            if (turn.finalAnswerSubstantive) closeObligationOnSubstantiveReply(args, turn, replyRoutedOriginTurn)
           }
           outboundDedup.record(
             chat_id,
@@ -7573,7 +7625,7 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
       finalizeStatusReaction(chat_id, threadId, 'done')
       // PR2: close this origin's obligation on a SUBSTANTIVE final answer
       // (after finalize so the reaction guard test's anchor window is stable).
-      if (turn.finalAnswerSubstantive) closeObligationOnSubstantiveReply(args, turn)
+      if (turn.finalAnswerSubstantive) closeObligationOnSubstantiveReply(args, turn, replyRoutedOriginTurn)
     }
     // v0.13.30 follow-up — release the buffer gate on EVERY reply
     // finalize, not just on `isFinalAnswerReply`. The narrow
@@ -7633,20 +7685,36 @@ async function executeStreamReply(args: Record<string, unknown>): Promise<unknow
   // topic and a late stream-reply can't be stolen by a successor turn. DM:
   // every tier undefined → unchanged. Kill switch off → legacy live-turn
   // injection only.
+  // Origin resolution is hoisted UNCONDITIONALLY (outside the
+  // message_thread_id==null guard below) so the obligation-close path has
+  // the correct routedOriginTurn even when the model explicitly passes
+  // message_thread_id (forum-topic streams). Without this hoist, Fix 1
+  // is a no-op for forum-topic streams — the origin is never resolved and
+  // closeObligationOnSubstantiveReply falls through to the live-turn
+  // fallback. Matches executeReply's unconditional resolution. Thread
+  // injection still stays scoped to the message_thread_id==null branch —
+  // only the obligation-close input changes.
+  let streamRoutedOriginTurn: CurrentTurn | null = null
+  // Track whether the origin was found via echo (for the routing log below).
+  let streamOriginVia: 'echo' | 'quoted' | null = null
+  if (TURN_ORIGIN_ROUTING_ENABLED) {
+    // Origin precedence: model echo first, then the framework-owned quoted
+    // message_id as a deterministic fallback (mirrors executeReply).
+    const echoedTurn = findTurnByOriginId(args.origin_turn_id as string | undefined)
+    const quotedTurn =
+      echoedTurn == null ? findTurnByQuotedMessageId(String(args.chat_id), args.reply_to) : null
+    const originTurn = echoedTurn ?? quotedTurn
+    streamRoutedOriginTurn = originTurn ?? null
+    streamOriginVia = originTurn == null ? null : echoedTurn != null ? 'echo' : 'quoted'
+  }
   if (args.message_thread_id == null) {
     let injected: number | undefined
     if (TURN_ORIGIN_ROUTING_ENABLED) {
-      // Origin precedence: model echo first, then the framework-owned quoted
-      // message_id as a deterministic fallback (mirrors executeReply).
-      const echoedTurn = findTurnByOriginId(args.origin_turn_id as string | undefined)
-      const quotedTurn =
-        echoedTurn == null ? findTurnByQuotedMessageId(String(args.chat_id), args.reply_to) : null
-      const originTurn = echoedTurn ?? quotedTurn
       injected = resolveAnswerThreadWithLog(
         String(args.chat_id),
         undefined,
-        originTurn,
-        originTurn == null ? null : echoedTurn != null ? 'echo' : 'quoted',
+        streamRoutedOriginTurn,
+        streamOriginVia,
         turn,
         'stream_reply',
       )
@@ -7925,7 +7993,7 @@ async function executeStreamReply(args: Record<string, unknown>): Promise<unknow
       disableNotification: args.disable_notification === true,
       done: args.done === true,
     })
-    if (turn.finalAnswerSubstantive) closeObligationOnSubstantiveReply(args, turn)
+    if (turn.finalAnswerSubstantive) closeObligationOnSubstantiveReply(args, turn, streamRoutedOriginTurn)
     // #1744 follow-up — stream_reply edge case. The first-emit gate at
     // L5178 only clears silent-end state on the FIRST emit of a stream.
     // If a stream's first emit was ack-shaped (disable_notification:true,

package/telegram-plugin/gateway/obligation-ledger.ts

@@ -55,6 +55,12 @@ export interface Obligation {
    *  that re-stamps this once, and representCount is capped, so the ladder still
    *  terminates. Durable (part of the snapshot) so the grace survives restart. */
   lastTurnEndedAt?: number
+  /** Wall-clock ms this obligation was most recently re-presented. Drives the
+   *  per-represent grace: a freshly re-presented obligation is skipped until
+   *  at least `representGraceMs` has elapsed, preventing immediate second
+   *  re-present/escalate when the sweep fires < 5s later. Durable (part of the
+   *  snapshot) so the grace window survives a restart. */
+  lastRepresentedAt?: number
 }
 
 /** What the gateway should do for the oldest open obligation at an idle boundary. */
@@ -202,20 +208,30 @@ export class ObligationLedger {
    * pathologically-stuck/leaked worker cannot suppress the escalation forever —
    * once openedAt+backgroundGraceMs passes, the obligation is acted on regardless
    * of work state, and the FSM still terminates.
+   *
+   * PER-REPRESENT GRACE (opts.representGraceMs > 0): an obligation that was just
+   * re-presented is ineligible until at least `representGraceMs` ms have elapsed
+   * since `lastRepresentedAt`. Without this, the 5s sweep can fire again before
+   * the re-presented turn even reaches the agent, burning the represent budget
+   * immediately and producing back-to-back escalations on the same message.
    */
   decideAtIdle(opts?: {
     now: number
     graceMs: number
     backgroundWorkActive?: boolean
     backgroundGraceMs?: number
+    representGraceMs?: number
   }): LedgerDecision {
-    const useEligible = opts != null && (opts.graceMs > 0 || opts.backgroundWorkActive === true)
+    const useEligible =
+      opts != null &&
+      (opts.graceMs > 0 || opts.backgroundWorkActive === true || (opts.representGraceMs ?? 0) > 0)
     const o = useEligible
       ? this.oldestEligible(
           opts!.now,
           opts!.graceMs,
           opts!.backgroundWorkActive === true,
           opts!.backgroundGraceMs ?? 0,
+          opts!.representGraceMs ?? 0,
         )
       : this.oldest()
     if (o === undefined) return { action: 'none' }
@@ -224,24 +240,30 @@ export class ObligationLedger {
   }
 
   /** The oldest open obligation that is currently ELIGIBLE to act on — i.e. NOT
-   *  within either grace window:
+   *  within any grace window:
    *   - trailing-answer grace: its handling turn ended < `graceMs` ago (a queued
    *     obligation with no lastTurnEndedAt can't have a trailing answer, so it is
-   *     always eligible on this axis); AND
+   *     always eligible on this axis);
    *   - background-work grace: when `backgroundWorkActive`, it was opened <
    *     `backgroundGraceMs` ago (genuine in-flight autonomous work — bounded by
-   *     the ceiling so a stale/leaked worker can't suppress escalation forever). */
+   *     the ceiling so a stale/leaked worker can't suppress escalation forever);
+   *   - per-represent grace: it was re-presented < `representGraceMs` ago (prevents
+   *     a 5s sweep tick from immediately firing again on the same obligation before
+   *     the re-presented turn even reaches the agent). */
   private oldestEligible(
     now: number,
     graceMs: number,
     backgroundWorkActive: boolean,
     backgroundGraceMs: number,
+    representGraceMs: number,
   ): Obligation | undefined {
     let best: Obligation | undefined
     for (const o of this.open.values()) {
       if (o.lastTurnEndedAt != null && now - o.lastTurnEndedAt < graceMs) continue // trailing-answer grace
       if (backgroundWorkActive && backgroundGraceMs > 0 && now - o.openedAt < backgroundGraceMs)
         continue // in-flight autonomous work, bounded by the ceiling
+      if (representGraceMs > 0 && o.lastRepresentedAt != null && now - o.lastRepresentedAt < representGraceMs)
+        continue // per-represent grace: sweep fired before re-presented turn landed
       if (best === undefined || o.openedAt < best.openedAt) best = o
     }
     return best
@@ -259,29 +281,48 @@ export class ObligationLedger {
   /**
    * Decide which obligation a substantive reply discharges — DETERMINISTICALLY,
    * holding for any model behavior:
-   *  - `echoedTurnId` (the model echoed origin_turn_id back) → authoritative;
-   *    close exactly that (a no-op via close() if it isn't actually open).
-   *  - else, close the live turn's obligation ONLY when UNAMBIGUOUS — exactly
-   *    one obligation open. With >1 open and no echo we cannot tell which one
-   *    the reply answered; closing the live turn's would silently drop the other
-   *    (713's un-echoed reply landing while currentTurn=715 must NOT close 715).
-   *    So we close nothing → the real target stays open and is re-presented (a
-   *    bounded double-ask), never wrong-closed. Returns the id to close, or null.
+   *
+   *  1. `echoedTurnId` (model echoed origin_turn_id back) → authoritative; close
+   *     exactly that (a no-op via close() if it isn't actually open).
+   *  2. `routedOriginId` (gateway-resolved origin from quote/via=quoted or
+   *     via=live routing) → treat as the definitive target when present; this
+   *     makes answers to re-presented messages close their obligation even when
+   *     no model echo was provided and even with >1 open obligation (the routed
+   *     origin IS the answer's origin — this is deterministic, not a guess).
+   *     The 713/715 invariant still holds: the gateway only passes a routedOriginId
+   *     that it has positively resolved as the reply's origin (quote resolution,
+   *     via=quoted); it never passes the LIVE turn id here when a different
+   *     obligation is the resolved origin.
+   *  3. else, close the live turn's own obligation when that turn itself is open —
+   *     this is unambiguous (the reply happened IN that turn, so the turn's own
+   *     obligation IS the right target). The 713/715 wrong-close protection is
+   *     preserved by ordering: routed/echoed origin (steps 1/2) wins first;
+   *     live-turn fallback (step 3) only fires when no routed origin resolved, AND
+   *     only for the live turn's OWN obligation (not another open obligation). A
+   *     reply answering message A landing while currentTurn=B must STILL not close B
+   *     — only steps 1/2 can close A in that case. With multiple open obligations
+   *     and no routed origin, the LIVE turn's own obligation is the safe default
+   *     (relaxed from size==1 which wrongly blocked it when a second message arrived
+   *     meanwhile). Returns the id to close, or null.
    */
   resolveCloseTarget(
     echoedTurnId: string | null | undefined,
     liveTurnId: string | null | undefined,
+    routedOriginId?: string | null,
   ): string | null {
     if (echoedTurnId != null) return echoedTurnId
-    if (liveTurnId != null && this.open.size === 1 && this.open.has(liveTurnId)) return liveTurnId
+    if (routedOriginId != null) return routedOriginId
+    if (liveTurnId != null && this.open.has(liveTurnId)) return liveTurnId
     return null
   }
 
-  /** Record that an obligation was just re-presented (bumps representCount). */
-  markRepresented(originTurnId: string): number {
+  /** Record that an obligation was just re-presented (bumps representCount, stamps
+   *  lastRepresentedAt for the per-represent grace window). */
+  markRepresented(originTurnId: string, now = Date.now()): number {
     const o = this.open.get(originTurnId)
     if (o === undefined) return 0
     o.representCount += 1
+    o.lastRepresentedAt = now
     this.persist()
     return o.representCount
   }

package/telegram-plugin/history.ts

@@ -546,6 +546,63 @@ export function getRecentOutboundCount(
   return row?.cnt ?? 0
 }
 
+/**
+ * Returns true if at least one SUBSTANTIVE outbound (bot → user, role='assistant')
+ * message was delivered to `chatId` (and optionally `threadId`) AFTER `sinceMs`
+ * (wall-clock epoch milliseconds). Used by the obligation sweep to suppress a false
+ * "I may have missed this" escalation when the agent visibly answered: if a
+ * substantive outbound landed since the obligation was opened, the obligation is
+ * stale — close it silently rather than alarming the user.
+ *
+ * SUBSTANTIVE: we never suppress escalation on a bare ack ("on it", "give me a
+ * sec") — an agent that acks then ghosts must still escalate. The history schema
+ * does not store a done/substantive flag, so we approximate: a row counts only
+ * when LENGTH(text) >= 200 (the FINAL_ANSWER_MIN_CHARS constant from
+ * final-answer-detect.ts). This is false-negative-safe: a genuine substantive
+ * answer that happens to be < 200 chars will still fire an escalation, which is
+ * the conservative (safe) outcome. A schema column would be more precise but is
+ * disproportionate for this predicate; the reviewer accepted this approach.
+ *
+ * `threadId` semantics:
+ *   - undefined → any message in the chat regardless of thread (DMs + supergroups)
+ *   - explicit number → only that thread (precise for supergroups with topics)
+ *   - explicit null → only chat-root (non-thread) messages
+ *
+ * Falls back to false (safe: never suppresses escalation) if history is not yet
+ * initialised or the query fails.
+ */
+export function hasOutboundDeliveredSince(
+  chatId: string,
+  sinceMs: number,
+  threadId?: number | null,
+): boolean {
+  try {
+    const cutoffSec = Math.floor(sinceMs / 1000)
+    const params: unknown[] = [chatId, cutoffSec]
+    // LENGTH(text) >= 200 scopes to substantive replies only — never suppress
+    // escalation on a mere ack. Mirrors FINAL_ANSWER_MIN_CHARS (200) from
+    // final-answer-detect.ts; the `done` flag is not stored in the history
+    // schema, so length is the closest available proxy.
+    let sql =
+      "SELECT 1 FROM messages WHERE chat_id = ? AND role = 'assistant' AND ts >= ? AND LENGTH(text) >= 200"
+    if (threadId !== undefined) {
+      if (threadId === null) {
+        sql += ' AND thread_id IS NULL'
+      } else {
+        sql += ' AND thread_id = ?'
+        params.push(threadId)
+      }
+    }
+    sql += ' LIMIT 1'
+    const row = requireDb()
+      .prepare(sql)
+      .get(...(params as [unknown, ...unknown[]])) as Record<string, unknown> | undefined
+    return row != null
+  } catch {
+    return false
+  }
+}
+
 export function query(opts: QueryOptions): RecordedMessage[] {
   const limit = Math.min(MAX_LIMIT, Math.max(1, opts.limit ?? DEFAULT_LIMIT))
   const params: unknown[] = [opts.chat_id]

package/telegram-plugin/tests/history.test.ts

@@ -10,6 +10,7 @@ import {
   query,
   getRecentOutboundCount,
   getLatestInboundMessageId,
+  hasOutboundDeliveredSince,
   _resetForTests,
 } from '../history.js'
 
@@ -363,6 +364,88 @@ describe('getRecentOutboundCount (backstop dedup helper)', () => {
   })
 })
 
+// A substantive reply: 200+ chars (the FINAL_ANSWER_MIN_CHARS threshold).
+const SUBSTANTIVE = 'A'.repeat(200)
+// A non-substantive ack: short (<200 chars).
+const ACK = 'On it.'
+
+describe('hasOutboundDeliveredSince', () => {
+  beforeEach(() => initHistory(stateDir, 30))
+
+  it('returns true when a substantive outbound exists after openedAt', () => {
+    const openedAt = 1_000_000 * 1000 // ms
+    recordOutbound({
+      chat_id: '-100',
+      thread_id: null,
+      message_ids: [10],
+      texts: [SUBSTANTIVE],
+      ts: 1_000_001, // sec — 1s after openedAt
+    })
+    expect(hasOutboundDeliveredSince('-100', openedAt)).toBe(true)
+  })
+
+  it('returns false when the only outbound is BEFORE openedAt', () => {
+    const openedAt = 1_000_002 * 1000 // ms — after the message
+    recordOutbound({
+      chat_id: '-100',
+      thread_id: null,
+      message_ids: [10],
+      texts: [SUBSTANTIVE],
+      ts: 1_000_001, // sec — before openedAt
+    })
+    expect(hasOutboundDeliveredSince('-100', openedAt)).toBe(false)
+  })
+
+  it('returns false for a non-substantive ack after openedAt (blocker regression)', () => {
+    // An agent that sends a short ack ("on it") then ghosts must NOT have
+    // its escalation suppressed. The predicate must never match a bare ack.
+    const openedAt = 1_000_000 * 1000
+    recordOutbound({
+      chat_id: '-100',
+      thread_id: null,
+      message_ids: [10],
+      texts: [ACK],          // < 200 chars — non-substantive
+      ts: 1_000_001,
+    })
+    expect(hasOutboundDeliveredSince('-100', openedAt)).toBe(false)
+  })
+
+  it('thread_id=undefined matches any thread (DM semantics)', () => {
+    const openedAt = 1_000_000 * 1000
+    recordOutbound({
+      chat_id: '-100',
+      thread_id: 5,
+      message_ids: [10],
+      texts: [SUBSTANTIVE],
+      ts: 1_000_001,
+    })
+    // No thread filter → should find it
+    expect(hasOutboundDeliveredSince('-100', openedAt, undefined)).toBe(true)
+  })
+
+  it('thread_id=number scopes to that thread only', () => {
+    const openedAt = 1_000_000 * 1000
+    recordOutbound({ chat_id: '-100', thread_id: 5, message_ids: [10], texts: [SUBSTANTIVE], ts: 1_000_001 })
+    expect(hasOutboundDeliveredSince('-100', openedAt, 5)).toBe(true)
+    expect(hasOutboundDeliveredSince('-100', openedAt, 6)).toBe(false)
+  })
+
+  it('thread_id=null matches only chat-root (non-thread) messages', () => {
+    const openedAt = 1_000_000 * 1000
+    recordOutbound({ chat_id: '-100', thread_id: null, message_ids: [10], texts: [SUBSTANTIVE], ts: 1_000_001 })
+    expect(hasOutboundDeliveredSince('-100', openedAt, null)).toBe(true)
+    // A thread-scoped message should NOT match the root filter
+    recordOutbound({ chat_id: '-100', thread_id: 3, message_ids: [11], texts: [SUBSTANTIVE], ts: 1_000_002 })
+    expect(hasOutboundDeliveredSince('-100', openedAt, null)).toBe(true) // root still there
+    expect(hasOutboundDeliveredSince('-100', openedAt, 3)).toBe(true)    // thread 3 also there
+    expect(hasOutboundDeliveredSince('-100', openedAt, 9)).toBe(false)   // thread 9 not there
+  })
+
+  it('returns false when no history is present for the chat', () => {
+    expect(hasOutboundDeliveredSince('-999', 0)).toBe(false)
+  })
+})
+
 describe('secret redaction at persistence (both directions)', () => {
   beforeEach(() => initHistory(stateDir, 30))
 

package/telegram-plugin/tests/obligation-ledger.test.ts

@@ -105,14 +105,26 @@ describe("ObligationLedger", () => {
       expect(L.resolveCloseTarget(undefined, "c:3#715")).toBe("c:3#715");
     });
 
-    it("no echo + MULTIPLE open → close NOTHING (never wrong-close/drop)", () => {
+    it("no echo + MULTIPLE open + live turn IS open → close the live turn's OWN obligation (Fix 2)", () => {
       const L = new ObligationLedger();
       L.openIfAbsent(input("c:635#713", 1000));
       L.openIfAbsent(input("c:3#715", 1100));
-      // the marko race: 713's un-echoed reply lands while currentTurn=715.
-      // Closing 715 would silently drop it → resolveCloseTarget refuses.
-      expect(L.resolveCloseTarget(undefined, "c:3#715")).toBeNull();
-      expect(L.isOpen("c:3#715")).toBe(true); // 715 stays open → re-presented
+      // A substantive reply delivered during currentTurn=715 (no model echo, no
+      // routed origin) closes 715's own obligation. 713 stays open and is
+      // re-presented. The 713/715 invariant holds: this does NOT close 713.
+      expect(L.resolveCloseTarget(undefined, "c:3#715")).toBe("c:3#715");
+      expect(L.isOpen("c:635#713")).toBe(true); // 713 stays open
+    });
+
+    it("no echo + MULTIPLE open + live turn NOT one of them → close nothing (713/715 invariant preserved)", () => {
+      const L = new ObligationLedger();
+      L.openIfAbsent(input("c:635#713", 1000));
+      L.openIfAbsent(input("c:3#715", 1100));
+      // currentTurn=999 is NOT an open obligation. We can't identify the right
+      // target → refuse to close anything (a re-present is safer than a wrong close).
+      expect(L.resolveCloseTarget(undefined, "c:9#999")).toBeNull();
+      expect(L.isOpen("c:635#713")).toBe(true);
+      expect(L.isOpen("c:3#715")).toBe(true);
     });
 
     it("no echo + live turn not an open obligation → null", () => {
@@ -120,6 +132,35 @@ describe("ObligationLedger", () => {
       L.openIfAbsent(input("c:3#715", 1100));
       expect(L.resolveCloseTarget(undefined, "c:9#999")).toBeNull();
     });
+
+    it("routedOriginId (Fix 1) closes the routed target even with multiple open + no model echo", () => {
+      // Simulate the clerk incident: two obligations open, agent answers #14057
+      // via a quoted reply (via=quoted), no model echo. The gateway resolves
+      // routedOriginId=#14057 from the quote. That obligation closes; #14059 stays.
+      const L = new ObligationLedger();
+      L.openIfAbsent(input("c:0#14057", 1000));
+      L.openIfAbsent(input("c:0#14059", 1100));
+      expect(L.resolveCloseTarget(undefined, "c:0#14059", "c:0#14057")).toBe("c:0#14057");
+      // Close it to confirm only #14057 closes
+      L.close("c:0#14057");
+      expect(L.isOpen("c:0#14057")).toBe(false);
+      expect(L.isOpen("c:0#14059")).toBe(true);
+    });
+
+    it("echoedTurnId wins over routedOriginId when both present (echoed is authoritative)", () => {
+      const L = new ObligationLedger();
+      L.openIfAbsent(input("c:635#713", 1000));
+      L.openIfAbsent(input("c:3#715", 1100));
+      // Model explicitly echoed 713 AND router resolved 715 as routed origin.
+      // The echo is authoritative — close 713.
+      expect(L.resolveCloseTarget("c:635#713", "c:3#715", "c:3#715")).toBe("c:635#713");
+    });
+
+    it("routedOriginId=null falls through to live-turn fallback", () => {
+      const L = new ObligationLedger();
+      L.openIfAbsent(input("c:3#715", 1100));
+      expect(L.resolveCloseTarget(undefined, "c:3#715", null)).toBe("c:3#715");
+    });
   });
 });
 
@@ -411,3 +452,170 @@ describe("ObligationLedger — background-work grace (extended-autonomous fix, g
     ).toBe("represent");
   });
 });
+
+describe("ObligationLedger — per-represent grace (Fix 3: clerk 2026-06-13 incident)", () => {
+  function input(id: string, openedAt: number) {
+    return { originTurnId: id, chatId: "-100123", threadId: 3, messageId: Number(id.split("#").pop() ?? 0), text: "x", openedAt };
+  }
+
+  const REPR_GRACE = 120_000; // 2 min, mirroring the default
+
+  it("a freshly re-presented obligation is ineligible until representGraceMs elapses", () => {
+    const L = new ObligationLedger(2);
+    L.openIfAbsent(input("c:3#1", 1000));
+    // Re-present fires at t=5000; markRepresented stamps lastRepresentedAt.
+    L.markRepresented("c:3#1", 5000);
+    // 10s later — still within 120s represent grace → ineligible → none.
+    expect(
+      L.decideAtIdle({ now: 15000, graceMs: 45000, representGraceMs: REPR_GRACE }).action,
+    ).toBe("none");
+    // 120s + 1ms after re-present → grace expired → act.
+    expect(
+      L.decideAtIdle({ now: 5000 + REPR_GRACE + 1, graceMs: 45000, representGraceMs: REPR_GRACE }).action,
+    ).toBe("represent");
+  });
+
+  it("markRepresented stamps lastRepresentedAt and persists", () => {
+    const snapshots: Obligation[][] = [];
+    const L = new ObligationLedger(2, { onChange: (s) => snapshots.push(s) });
+    L.openIfAbsent(input("c:3#1", 1000));
+    L.markRepresented("c:3#1", 9000);
+    const snap = L.list()[0];
+    expect(snap.lastRepresentedAt).toBe(9000);
+    expect(snap.representCount).toBe(1);
+    // Persisted: onChange fired for open + markRepresented = 2 snapshots
+    expect(snapshots.length).toBe(2);
+    expect(snapshots[1][0].lastRepresentedAt).toBe(9000);
+  });
+
+  it("representGraceMs=0 (kill switch) → no per-represent grace, acts immediately", () => {
+    const L = new ObligationLedger(2);
+    L.openIfAbsent(input("c:3#1", 1000));
+    L.markRepresented("c:3#1", 5000);
+    // Kill switch: representGraceMs=0 → the freshly-represented obligation is still eligible.
+    expect(
+      L.decideAtIdle({ now: 5001, graceMs: 45000, representGraceMs: 0 }).action,
+    ).toBe("represent");
+  });
+
+  it("an obligation that was NEVER re-presented has no per-represent grace (no lastRepresentedAt)", () => {
+    const L = new ObligationLedger(2);
+    L.openIfAbsent(input("c:3#1", 1000));
+    // No markRepresented call → no lastRepresentedAt → always eligible on this axis.
+    expect(
+      L.decideAtIdle({ now: 2000, graceMs: 45000, representGraceMs: REPR_GRACE }).action,
+    ).toBe("represent");
+  });
+
+  it("per-represent grace survives hydration (durable snapshot)", () => {
+    const L = new ObligationLedger(2);
+    const now = 10_000;
+    L.hydrate([
+      {
+        originTurnId: "c:3#1",
+        chatId: "-100123",
+        threadId: 3,
+        messageId: 1,
+        text: "x",
+        openedAt: 1000,
+        representCount: 1,
+        lastRepresentedAt: now - 5000, // represented 5s ago
+      },
+    ]);
+    // 5s after re-present, grace=120s → still within grace → none.
+    expect(
+      L.decideAtIdle({ now, graceMs: 0, representGraceMs: REPR_GRACE }).action,
+    ).toBe("none");
+    // 120s + 1ms after re-present → grace expired → escalate (count=1 < max=2 → represent).
+    expect(
+      L.decideAtIdle({ now: now - 5000 + REPR_GRACE + 1, graceMs: 0, representGraceMs: REPR_GRACE }).action,
+    ).toBe("represent");
+  });
+
+  it("per-represent grace composes with trailing-answer grace: both must clear", () => {
+    const L = new ObligationLedger(2);
+    L.openIfAbsent(input("c:3#1", 1000));
+    L.noteTurnEnded("c:3#1", 5000);
+    L.markRepresented("c:3#1", 5000);
+    // Both graces active; trailing: turn ended 5s ago (grace=45s → in grace);
+    // per-represent: re-presented 5s ago (grace=120s → in grace) → none.
+    expect(
+      L.decideAtIdle({ now: 10000, graceMs: 45000, representGraceMs: REPR_GRACE }).action,
+    ).toBe("none");
+    // Trailing grace cleared (50s after turn-end), per-represent NOT yet (only 45s after re-present).
+    expect(
+      L.decideAtIdle({ now: 5000 + 50000, graceMs: 45000, representGraceMs: REPR_GRACE }).action,
+    ).toBe("none");
+    // Both cleared (125s after re-present at t=5000 → t=130000).
+    expect(
+      L.decideAtIdle({ now: 5000 + REPR_GRACE + 5000, graceMs: 45000, representGraceMs: REPR_GRACE }).action,
+    ).toBe("represent");
+  });
+
+  it("the clerk incident: two messages arrive, re-present fires at T; the sweep ticks again at T+5s → grace prevents premature escalation", () => {
+    // This is the exact sequence from clerk 2026-06-13: obligation re-presented
+    // at T, sweep fires at T+5s before the re-present turn has even landed, would
+    // immediately fire AGAIN (burning representCount to 2 → escalate in 5 more
+    // seconds). With per-represent grace, the T+5s tick is a no-op.
+    const L = new ObligationLedger(2);
+    const T = 1_000_000;
+    L.openIfAbsent(input("c:0#14057", T));
+    // First represent at T
+    L.markRepresented("c:0#14057", T);
+    expect(L.list()[0].representCount).toBe(1);
+    // Sweep at T+5s: MUST be "none" (within per-represent grace)
+    expect(
+      L.decideAtIdle({ now: T + 5000, graceMs: 45000, representGraceMs: REPR_GRACE }).action,
+    ).toBe("none");
+    // Sweep at T+10s: still within grace
+    expect(
+      L.decideAtIdle({ now: T + 10000, graceMs: 45000, representGraceMs: REPR_GRACE }).action,
+    ).toBe("none");
+    // Sweep after grace: eligible for second represent (not escalate — count=1 < max=2)
+    expect(
+      L.decideAtIdle({ now: T + REPR_GRACE + 1000, graceMs: 45000, representGraceMs: REPR_GRACE }).action,
+    ).toBe("represent");
+    expect(L.list()[0].representCount).toBe(1); // still 1 — decideAtIdle is pure
+  });
+});
+
+describe("ObligationLedger — escalation suppression predicate (Fix 4)", () => {
+  // Fix 4 is implemented in the gateway (obligationSweep checks
+  // hasOutboundDeliveredSince before calling driveEscalation). We test the
+  // predicate seam via the pattern the sweep uses: if an outbound was delivered
+  // since openedAt, the obligation should be closed silently, not escalated.
+  // This suite tests the ledger behaviour that enables that path: after a
+  // silent close the ledger is empty and the next sweep sees 'none'.
+  function input(id: string, openedAt: number) {
+    return { originTurnId: id, chatId: "-100123", threadId: 3, messageId: Number(id.split("#").pop() ?? 0), text: "x", openedAt };
+  }
+
+  it("a silently-closed obligation (gateway closed on outbound-delivered check) leaves ledger empty", () => {
+    const L = new ObligationLedger(2);
+    L.openIfAbsent(input("c:3#1", 1000));
+    // Gateway's Fix 4 path: outbound delivered since openedAt → close silently
+    expect(L.close("c:3#1")).toBe(true);
+    expect(L.hasOpen()).toBe(false);
+    expect(L.decideAtIdle().action).toBe("none");
+  });
+
+  it("an escalation that reaches maxRepresents WITHOUT any known outbound still proceeds (escalate action)", () => {
+    const L = new ObligationLedger(2);
+    L.openIfAbsent(input("c:3#1", 1000));
+    L.markRepresented("c:3#1");
+    L.markRepresented("c:3#1");
+    // hasOutboundDeliveredSince returns false (no outbound recorded) → escalate
+    const d = L.decideAtIdle({ now: 9_999_999, graceMs: 0, representGraceMs: 0 });
+    expect(d.action).toBe("escalate");
+    expect(d.obligation?.originTurnId).toBe("c:3#1");
+  });
+
+  it("silent close fires onChange (persists the empty set)", () => {
+    const snapshots: Obligation[][] = [];
+    const L = new ObligationLedger(2, { onChange: (s) => snapshots.push(s) });
+    L.openIfAbsent(input("c:3#1", 1000)); // snapshot[0]
+    L.close("c:3#1"); // snapshot[1] = []
+    expect(snapshots.length).toBe(2);
+    expect(snapshots[1]).toEqual([]);
+  });
+});

package/telegram-plugin/tests/obligation-store.test.ts

@@ -101,6 +101,23 @@ describe("obligation-store", () => {
     expect(loaded.map((o) => o.originTurnId)).toEqual(["c:3#715", "c:5#900"]);
   });
 
+  it("round-trips lastRepresentedAt through parse → isObligationRow filter → hydrate", () => {
+    // Regression: isObligationRow only checks required fields; optional fields
+    // (lastRepresentedAt, lastTurnEndedAt, escalateAttempts) must survive the
+    // filter without being stripped. A missing check would silently drop the field
+    // and break the per-represent grace window across restarts.
+    const { fs } = memFs();
+    const snap: Obligation[] = [
+      ob("c:3#715", { representCount: 1, lastRepresentedAt: 1_700_000_000_000, lastTurnEndedAt: 1_700_000_001_000 }),
+    ];
+    persistObligations(PATH, fs, snap);
+    const loaded = loadObligations(PATH, fs);
+    expect(loaded).toHaveLength(1);
+    expect(loaded[0]!.lastRepresentedAt).toBe(1_700_000_000_000);
+    expect(loaded[0]!.lastTurnEndedAt).toBe(1_700_000_001_000);
+    expect(loaded[0]!.representCount).toBe(1);
+  });
+
   it("never throws on a write failure — degrades to in-memory (logs)", () => {
     const logs: string[] = [];
     const fs: ObligationStoreFsSeam = {