switchroom 0.20.7 → 0.20.8

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

@@ -22593,6 +22593,20 @@ var init_overlay_schema = __esm(() => {
 // ../src/config/overlay-loader.ts
 import { existsSync as existsSync5, readFileSync as readFileSync5, readdirSync as readdirSync3, statSync as statSync5 } from "node:fs";
 import { basename as basename4, resolve as resolve4 } from "node:path";
+function recordReadFailure(agentCfg, failure) {
+  const node = agentCfg;
+  const existing = node[OVERLAY_READ_FAILURES];
+  if (Array.isArray(existing)) {
+    existing.push(failure);
+    return;
+  }
+  Object.defineProperty(agentCfg, OVERLAY_READ_FAILURES, {
+    value: [failure],
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+}
 function deriveOverlayTitle(raw, fileName) {
   const titleFromComment = raw.match(/^#[^\S\n]*name:[^\S\n]*(\S.*?)[^\S\n]*$/m)?.[1];
   if (titleFromComment)
@@ -22602,17 +22616,39 @@ function deriveOverlayTitle(raw, fileName) {
     return;
   return base.length > 0 ? base : undefined;
 }
+function readOverlayFile(agentName, file, agentCfg, warnings) {
+  try {
+    return readFileSync5(file, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT")
+      return;
+    const w = {
+      agent: agentName,
+      file,
+      reason: `read error: ${err.message}`,
+      code: code ?? "EUNKNOWN"
+    };
+    recordReadFailure(agentCfg, { file, code: w.code });
+    warnings.push(w);
+    console.warn(`[switchroom] overlay-loader: agent='${agentName}' file='${file}': ${w.reason}`);
+    return;
+  }
+}
 function overlayDirFor(agentName, subdir) {
   const base = resolveDualPath(`~/.switchroom/agents/${agentName}/${subdir}`);
   return resolve4(base);
 }
-function listYamlFiles(dir) {
+function listYamlFiles(dir, onUnreadableDir) {
   if (!existsSync5(dir))
     return [];
   let entries;
   try {
     entries = readdirSync3(dir);
-  } catch {
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT")
+      onUnreadableDir?.(code ?? "EUNKNOWN");
     return [];
   }
   const out = [];
@@ -22650,12 +22686,24 @@ function applyAgentOverlays(config) {
   for (const [agentName, agentCfg] of Object.entries(agents)) {
     try {
       const scheduleDir = overlayDirFor(agentName, "schedule.d");
-      const files = listYamlFiles(scheduleDir);
+      const files = listYamlFiles(scheduleDir, (code) => {
+        const w = {
+          agent: agentName,
+          file: scheduleDir,
+          reason: `read error: cannot list overlay directory (${code})`,
+          code
+        };
+        recordReadFailure(agentCfg, { file: scheduleDir, code });
+        warnings.push(w);
+        console.warn(`[switchroom] overlay-loader: agent='${agentName}' file='${scheduleDir}': ${w.reason}`);
+      });
       if (files.length > 0) {
         const merged = [...agentCfg.schedule ?? []];
         for (const file of files) {
+          const raw = readOverlayFile(agentName, file, agentCfg, warnings);
+          if (raw === undefined)
+            continue;
           try {
-            const raw = readFileSync5(file, "utf-8");
             const parsed = import_yaml.parse(raw);
             const doc = OverlayDocSchema.parse(parsed);
             const title = deriveOverlayTitle(raw, basename4(file));
@@ -22690,13 +22738,25 @@ function applyAgentOverlays(config) {
     }
     try {
       const skillsDir = overlayDirFor(agentName, "skills.d");
-      const skillFiles = listYamlFiles(skillsDir);
+      const skillFiles = listYamlFiles(skillsDir, (code) => {
+        const w = {
+          agent: agentName,
+          file: skillsDir,
+          reason: `read error: cannot list overlay directory (${code})`,
+          code
+        };
+        recordReadFailure(agentCfg, { file: skillsDir, code });
+        warnings.push(w);
+        console.warn(`[switchroom] overlay-loader: agent='${agentName}' file='${skillsDir}': ${w.reason}`);
+      });
       if (skillFiles.length === 0) {} else {
         const merged = [...agentCfg.skills ?? []];
         const seen = new Set(merged);
         for (const file of skillFiles) {
+          const raw = readOverlayFile(agentName, file, agentCfg, warnings);
+          if (raw === undefined)
+            continue;
           try {
-            const raw = readFileSync5(file, "utf-8");
             const parsed = import_yaml.parse(raw);
             const doc = OverlayDocSchema.parse(parsed);
             for (const skillName of doc.skills ?? []) {
@@ -22724,7 +22784,7 @@ function applyAgentOverlays(config) {
   }
   return { config, warnings };
 }
-var import_yaml, OVERLAY_SOURCE, OVERLAY_TITLE;
+var import_yaml, OVERLAY_SOURCE, OVERLAY_TITLE, OVERLAY_READ_FAILURES;
 var init_overlay_loader = __esm(() => {
   init_zod();
   init_overlay_schema();
@@ -22732,6 +22792,7 @@ var init_overlay_loader = __esm(() => {
   import_yaml = __toESM(require_dist(), 1);
   OVERLAY_SOURCE = Symbol.for("switchroom.config.overlay-source");
   OVERLAY_TITLE = Symbol.for("switchroom.config.overlay-title");
+  OVERLAY_READ_FAILURES = Symbol.for("switchroom.config.overlay-read-failures");
 });
 
 // ../src/config/merge.ts
@@ -80949,6 +81010,22 @@ function endsWithSilentMarker(text4) {
     return false;
   return isSilentFlushMarker(lines[lines.length - 1]);
 }
+function isSilentSentinelCardOutcome(input) {
+  if (input.finalAnswerEverDelivered)
+    return false;
+  if (isSilentFlushMarker(input.lastReplyText) || isCompositeSilentNoise(input.lastReplyText)) {
+    return true;
+  }
+  if (!input.replyCalled) {
+    const joined = input.capturedText.join(`
+
+`).trim();
+    if (joined.length > 0 && (isSilentFlushMarker(joined) || isCompositeSilentNoise(joined) || endsWithSilentMarker(joined))) {
+      return true;
+    }
+  }
+  return false;
+}
 function decideTurnFlush(input) {
   const flushEnabled = input.flushEnabled !== false;
   if (!flushEnabled)
@@ -82614,8 +82691,7 @@ function handleSessionEvent(deps, ev) {
       }
       if (QUEUED_CARD_ENABLED && !handbackOwnsSurface) {
         const cardChatId = ev.chatId;
-        const replyToRaw = ev.messageId != null ? Number(ev.messageId) : null;
-        const replyTo = replyToRaw != null && Number.isFinite(replyToRaw) ? replyToRaw : null;
+        const replyTo = parseSourceMessageId(ev.messageId);
         openQueuedCard(deps, cardChatId, enqThreadIdNum ?? null, replyTo).then((cardId) => {
           if (cardId == null)
             return;
@@ -83899,7 +83975,13 @@ function createNarrativeLane(deps) {
         clearActivityCardRecord(ACTIVITY_CARD_STORE_PATH, activityCardStoreFs, statusKey(chat, thread), id);
       }
       await reconcileStatusPin(`fg:${statusKey(chat, thread)}`, chat, { pinned: false });
-      if (CLEAR_STATUS_ON_COMPLETION) {
+      const silentSentinelTurn = isSilentSentinelCardOutcome({
+        replyCalled: turn.replyCalled,
+        lastReplyText: turn.lastReplyText,
+        capturedText: turn.capturedText,
+        finalAnswerEverDelivered: turn.finalAnswerEverDelivered
+      });
+      if (CLEAR_STATUS_ON_COMPLETION || silentSentinelTurn) {
         try {
           await robustApiCall(() => bot.api.deleteMessage(chat, id), { chat_id: chat, ...thread != null ? { threadId: thread } : {}, verb: "activity-summary.delete" });
         } catch (err) {
@@ -92982,19 +93064,121 @@ function makeRepresentRedeliveryGuard(deps) {
     return true;
   };
 }
-function makeSessionBusyDrainDeferral(boundMs) {
+var DEFAULT_DRAIN_DEFER_STALE_GAP_MS = 15000;
+function makeSessionBusyDrainDeferral(boundMs, staleGapMs = DEFAULT_DRAIN_DEFER_STALE_GAP_MS) {
   let deferringSince = null;
+  let lastCallAt = null;
   return (busy, now) => {
+    const gapSinceLastCall = lastCallAt == null ? null : now - lastCallAt;
+    lastCallAt = now;
     if (!busy || boundMs <= 0) {
       deferringSince = null;
       return false;
     }
-    if (deferringSince == null)
+    if (deferringSince == null || staleGapMs > 0 && gapSinceLastCall != null && gapSinceLastCall > staleGapMs) {
       deferringSince = now;
+    }
     return now - deferringSince < boundMs;
   };
 }
 
+// gateway/pending-inbound-buffer.ts
+function redeliverBufferedInbound2(buffer, agent, send, spool, onDelivered) {
+  const pending = buffer.drain(agent);
+  let redelivered = 0;
+  let rebuffered = 0;
+  let retracted = 0;
+  for (const { merged, originals } of planBufferedRedelivery2(pending)) {
+    let proceed = true;
+    if (buffer.beforeRedeliver != null) {
+      try {
+        proceed = buffer.beforeRedeliver(merged);
+      } catch (e) {
+        proceed = true;
+        process.stderr.write(`redeliver beforeRedeliver threw \u2014 failing open (deliver): ${String(e)}
+`);
+      }
+    }
+    if (!proceed) {
+      for (const o of originals)
+        spool?.ack(o);
+      retracted += originals.length;
+      continue;
+    }
+    let delivered = false;
+    try {
+      delivered = send(merged);
+    } catch {
+      delivered = false;
+    }
+    if (delivered) {
+      for (const o of originals)
+        spool?.ack(o);
+      redelivered += originals.length;
+      onDelivered?.(merged, originals);
+    } else {
+      for (const o of originals)
+        buffer.push(agent, o);
+      rebuffered += originals.length;
+    }
+  }
+  return { drained: pending.length, redelivered, rebuffered, retracted };
+}
+function isMergeableUserInbound2(msg) {
+  return msg.type === "inbound" && (msg.meta == null || msg.meta.source == null && msg.meta.button_callback == null);
+}
+function inboundHasMedia2(msg) {
+  return msg.imagePath != null || msg.attachment != null;
+}
+function planBufferedRedelivery2(pending) {
+  const out = [];
+  let run3 = [];
+  let runHasMedia = false;
+  const sameTarget = (a, b) => a.chatId === b.chatId && (a.threadId ?? null) === (b.threadId ?? null) && a.userId === b.userId;
+  const flush = () => {
+    if (run3.length === 0)
+      return;
+    out.push({ merged: run3.length === 1 ? run3[0] : mergeRun2(run3), originals: run3 });
+    run3 = [];
+    runHasMedia = false;
+  };
+  for (const msg of pending) {
+    const msgHasMedia = inboundHasMedia2(msg);
+    const canJoin = run3.length > 0 && isMergeableUserInbound2(msg) && isMergeableUserInbound2(run3[run3.length - 1]) && sameTarget(run3[run3.length - 1], msg) && !(runHasMedia && msgHasMedia);
+    if (!canJoin)
+      flush();
+    run3.push(msg);
+    runHasMedia = runHasMedia || msgHasMedia;
+  }
+  flush();
+  return out;
+}
+var ATTACHMENT_META_RE2 = /^(image_path|attachment_)/;
+function mergeRun2(run3) {
+  const last = run3[run3.length - 1];
+  const mediaEntry = run3.find(inboundHasMedia2);
+  const merged = {
+    ...last,
+    text: run3.map((m) => m.text).join(`
+`)
+  };
+  delete merged.imagePath;
+  delete merged.attachment;
+  if (mediaEntry != null && mediaEntry !== last) {
+    const splicedMeta = { ...merged.meta };
+    for (const [k, v] of Object.entries(mediaEntry.meta)) {
+      if (ATTACHMENT_META_RE2.test(k))
+        splicedMeta[k] = v;
+    }
+    merged.meta = splicedMeta;
+  }
+  if (mediaEntry?.imagePath != null)
+    merged.imagePath = mediaEntry.imagePath;
+  if (mediaEntry?.attachment != null)
+    merged.attachment = mediaEntry.attachment;
+  return merged;
+}
+
 // gateway/cron-session.ts
 var CRON_IDENTITY_SUFFIX = "-cron";
 function cronIdentity(agent) {
@@ -93024,6 +93208,23 @@ function deliverInjectWithFallback(agentName3, meta, send) {
   }
   return { target, delivered: false, fellBackToMain: false };
 }
+function drainCronBridgeOnRegister(client3, buffer, spool, log) {
+  client3.send({ type: "status", status: "agent_connected" });
+  const send = (msg) => {
+    try {
+      client3.send(msg);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const result = redeliverBufferedInbound2(buffer, client3.agentName ?? "", send, spool);
+  if (result.drained > 0 && log != null) {
+    log(`telegram gateway: cron-bridge drain agent=${client3.agentName} ` + `drained=${result.drained} redelivered=${result.redelivered} ` + `rebuffered=${result.rebuffered}
+`);
+  }
+  return result;
+}
 
 // gateway/obligation-ledger.ts
 class ObligationLedger {
@@ -94586,103 +94787,6 @@ function formatEventDetail2(event) {
   }
 }
 
-// gateway/pending-inbound-buffer.ts
-function redeliverBufferedInbound2(buffer, agent, send, spool, onDelivered) {
-  const pending = buffer.drain(agent);
-  let redelivered = 0;
-  let rebuffered = 0;
-  let retracted = 0;
-  for (const { merged, originals } of planBufferedRedelivery2(pending)) {
-    let proceed = true;
-    if (buffer.beforeRedeliver != null) {
-      try {
-        proceed = buffer.beforeRedeliver(merged);
-      } catch (e) {
-        proceed = true;
-        process.stderr.write(`redeliver beforeRedeliver threw \u2014 failing open (deliver): ${String(e)}
-`);
-      }
-    }
-    if (!proceed) {
-      for (const o of originals)
-        spool?.ack(o);
-      retracted += originals.length;
-      continue;
-    }
-    let delivered = false;
-    try {
-      delivered = send(merged);
-    } catch {
-      delivered = false;
-    }
-    if (delivered) {
-      for (const o of originals)
-        spool?.ack(o);
-      redelivered += originals.length;
-      onDelivered?.(merged, originals);
-    } else {
-      for (const o of originals)
-        buffer.push(agent, o);
-      rebuffered += originals.length;
-    }
-  }
-  return { drained: pending.length, redelivered, rebuffered, retracted };
-}
-function isMergeableUserInbound2(msg) {
-  return msg.type === "inbound" && (msg.meta == null || msg.meta.source == null && msg.meta.button_callback == null);
-}
-function inboundHasMedia2(msg) {
-  return msg.imagePath != null || msg.attachment != null;
-}
-function planBufferedRedelivery2(pending) {
-  const out = [];
-  let run3 = [];
-  let runHasMedia = false;
-  const sameTarget = (a, b) => a.chatId === b.chatId && (a.threadId ?? null) === (b.threadId ?? null) && a.userId === b.userId;
-  const flush = () => {
-    if (run3.length === 0)
-      return;
-    out.push({ merged: run3.length === 1 ? run3[0] : mergeRun2(run3), originals: run3 });
-    run3 = [];
-    runHasMedia = false;
-  };
-  for (const msg of pending) {
-    const msgHasMedia = inboundHasMedia2(msg);
-    const canJoin = run3.length > 0 && isMergeableUserInbound2(msg) && isMergeableUserInbound2(run3[run3.length - 1]) && sameTarget(run3[run3.length - 1], msg) && !(runHasMedia && msgHasMedia);
-    if (!canJoin)
-      flush();
-    run3.push(msg);
-    runHasMedia = runHasMedia || msgHasMedia;
-  }
-  flush();
-  return out;
-}
-var ATTACHMENT_META_RE2 = /^(image_path|attachment_)/;
-function mergeRun2(run3) {
-  const last = run3[run3.length - 1];
-  const mediaEntry = run3.find(inboundHasMedia2);
-  const merged = {
-    ...last,
-    text: run3.map((m) => m.text).join(`
-`)
-  };
-  delete merged.imagePath;
-  delete merged.attachment;
-  if (mediaEntry != null && mediaEntry !== last) {
-    const splicedMeta = { ...merged.meta };
-    for (const [k, v] of Object.entries(mediaEntry.meta)) {
-      if (ATTACHMENT_META_RE2.test(k))
-        splicedMeta[k] = v;
-    }
-    merged.meta = splicedMeta;
-  }
-  if (mediaEntry?.imagePath != null)
-    merged.imagePath = mediaEntry.imagePath;
-  if (mediaEntry?.attachment != null)
-    merged.attachment = mediaEntry.attachment;
-  return merged;
-}
-
 // gateway/obligation-turn-end.ts
 function decideObligationTurnEnd(finalAnswerDelivered, replyCalled) {
   return finalAnswerDelivered || replyCalled ? "close" : "note-ended";
@@ -99732,6 +99836,14 @@ function determineRestartReason(opts) {
     return "crash";
   return "fresh";
 }
+var BOOT_REASON_REUSE_WINDOW_MS = 5 * 60000;
+function determineBridgeReconnectReason(opts) {
+  const { gatewayStartedAtMs, bootReason, bootReasonReuseWindowMs = BOOT_REASON_REUSE_WINDOW_MS } = opts;
+  if (opts.marker == null && opts.cleanMarker == null && bootReason != null && opts.now - gatewayStartedAtMs < bootReasonReuseWindowMs) {
+    return bootReason;
+  }
+  return determineRestartReason(opts);
+}
 
 // gateway/update-announce.ts
 import { existsSync as existsSync50, mkdirSync as mkdirSync44, openSync as openSync12, closeSync as closeSync12, readFileSync as readFileSync53 } from "node:fs";
@@ -102581,10 +102693,10 @@ function startOutboxSweep(deps) {
 }
 
 // ../src/build-info.ts
-var VERSION2 = "0.20.7";
-var COMMIT_SHA = "bc107185";
-var COMMIT_DATE = "2026-08-04T10:20:28Z";
-var LATEST_PR = 4343;
+var VERSION2 = "0.20.8";
+var COMMIT_SHA = "a6efc10f";
+var COMMIT_DATE = "2026-08-04T21:38:16Z";
+var LATEST_PR = 4374;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -108342,6 +108454,7 @@ var GATEWAY_STARTED_AT_MS = Date.now();
 var BOOT_CARD_ENABLED = process.env.SWITCHROOM_BOOT_CARD !== "false";
 var activeBootCard = null;
 var bootCardPending = false;
+var bootReasonAtStartup = null;
 var ISSUES_CARD_ENABLED = process.env.SWITCHROOM_ISSUES_CARD !== "false";
 var activeIssuesCard = null;
 var activeIssuesWatcher = null;
@@ -108835,13 +108948,7 @@ if (isGatewayMain)
       process.stderr.write(`telegram gateway: bridge registered \u2014 agent=${client3.agentName}
 `);
       if (isCronIdentity(client3.agentName)) {
-        client3.send({ type: "status", status: "agent_connected" });
-        const pending2 = pendingInboundBuffer.drain(client3.agentName ?? "");
-        for (const m of pending2) {
-          try {
-            client3.send(m);
-          } catch {}
-        }
+        drainCronBridgeOnRegister(client3, pendingInboundBuffer, inboundSpool ?? undefined, (l) => process.stderr.write(l));
         return;
       }
       const bridgeUpEffects = client3.agentName != null ? shadowEmit2({ kind: "bridgeUp", at: Date.now() }) : [];
@@ -108888,7 +108995,14 @@ if (isGatewayMain)
 `);
           clearRestartMarker();
         }
-        const reason = determineRestartReason({ marker, cleanMarker, sessionMarker: storedSession, now: nowMs3 });
+        const reason = determineBridgeReconnectReason({
+          marker,
+          cleanMarker,
+          sessionMarker: storedSession,
+          now: nowMs3,
+          gatewayStartedAtMs: GATEWAY_STARTED_AT_MS,
+          bootReason: bootReasonAtStartup
+        });
         const target = resolveBootChatId(marker, markerAgeMs);
         if (target) {
           const { chatId, threadId, ackMsgId } = target;
@@ -109635,7 +109749,7 @@ if (isGatewayMain)
     }
   })();
 var IDLE_DRAIN_INTERVAL_MS = 5000;
-var idleDrainBusyDefer = makeSessionBusyDrainDeferral(OBLIGATION_BACKGROUND_WORK_GRACE_MS);
+var idleDrainBusyDefer = makeSessionBusyDrainDeferral(OBLIGATION_BACKGROUND_WORK_GRACE_MS, IDLE_DRAIN_INTERVAL_MS * 3);
 if (isGatewayMain && !STATIC) {
   setInterval(() => {
     const selfAgent = process.env.SWITCHROOM_AGENT_NAME ?? "";
@@ -116154,6 +116268,7 @@ async function startGateway() {
           } else {
             const markerAgeMs = marker ? nowMs3 - marker.ts : undefined;
             const reason = determineRestartReason({ marker, cleanMarker, sessionMarker: storedSession, now: nowMs3 });
+            bootReasonAtStartup = reason;
             const target = resolveBootChatId(marker, markerAgeMs);
             if (reason === "crash") {
               const cleanMarkerStale = cleanMarker ? !shouldSuppressRecoveryBanner(cleanMarker, nowMs3, DEFAULT_MAX_AGE_MS) : false;

package/telegram-plugin/dist/server.js

@@ -24317,11 +24317,14 @@ function createIpcClient(options) {
   function scheduleReconnect() {
     if (closed)
       return;
+    if (reconnectTimer)
+      return;
     log(`reconnecting in ${currentDelay}ms`);
     reconnectTimer = setTimeout(() => {
       reconnectTimer = null;
-      if (!closed)
-        doConnect();
+      if (!closed) {
+        doConnect().catch(() => {});
+      }
     }, currentDelay);
     currentDelay = Math.min(currentDelay * 2, maxReconnectDelayMs);
   }

package/telegram-plugin/gateway/boot-reason.ts

@@ -83,3 +83,64 @@ export function determineRestartReason(opts: {
   if (sessionMarker != null) return 'crash'
   return 'fresh'
 }
+
+/**
+ * Boot-reason window during which a bridge re-register reuses the reason
+ * the boot path already determined. Matches the restart-marker and
+ * operator-marker freshness windows (5 min) — a bridge that survived a
+ * gateway restart reconnects within seconds of the new gateway's boot,
+ * comfortably inside it.
+ */
+export const BOOT_REASON_REUSE_WINDOW_MS = 5 * 60_000
+
+/**
+ * Determine the restart reason for a BRIDGE RE-REGISTER (gateway.ts
+ * `onClientRegistered`, the `bridge-reconnect` path) — as opposed to the
+ * gateway's own boot path.
+ *
+ * Why this exists (fleet-audit B2, kdogg 2026-08-02 06:27 trace): on a
+ * planned gateway restart (`cli: restart` SIGTERM), the bridge — living
+ * inside the separate claude process — survives and reconnects a few
+ * seconds after the new gateway boots. By then the boot path has already
+ * READ AND CLEARED the restart / clean-shutdown markers (the 2026-05-25
+ * GC, gateway.ts boot path), so re-deriving the reason from disk falls
+ * through to the sessionMarker branch and every such re-register logs —
+ * and, when a chat is resolvable, POSTS a boot card claiming —
+ * `reason=crash` for a perfectly graceful restart. Hundreds of these per
+ * agent fleet-wide (lawgpt 310, reggie 179, ziggy 175, kdogg 174).
+ *
+ * Decision:
+ *   1. Any on-disk marker still present → normal `determineRestartReason`
+ *      (in-gateway /restart flows where the gateway never went down write
+ *      a marker the boot path never consumed — keep honoring it).
+ *   2. No markers, but the gateway booted recently (<5 min) and recorded
+ *      the reason it determined at boot → reuse that reason. The bridge
+ *      is re-registering into the SAME restart episode the boot path
+ *      already classified.
+ *   3. Otherwise (gateway long-lived, markers absent) → fall through to
+ *      `determineRestartReason` — a marker-less bridge re-register hours
+ *      into a gateway's life still classifies conservatively as 'crash'
+ *      (the claude/bridge side genuinely died and came back).
+ */
+export function determineBridgeReconnectReason(opts: {
+  marker: { ts: number } | null
+  cleanMarker: CleanShutdownMarker | null
+  sessionMarker: SessionMarker | null
+  now: number
+  /** `GATEWAY_STARTED_AT_MS` of the running gateway process. */
+  gatewayStartedAtMs: number
+  /** Reason the gateway's own boot path determined (null if it never ran). */
+  bootReason: RestartReason | null
+  bootReasonReuseWindowMs?: number
+  cleanMaxAgeMs?: number
+  markerMaxAgeMs?: number
+  operatorMaxAgeMs?: number
+}): RestartReason {
+  const { gatewayStartedAtMs, bootReason, bootReasonReuseWindowMs = BOOT_REASON_REUSE_WINDOW_MS } = opts
+  if (opts.marker == null && opts.cleanMarker == null
+    && bootReason != null
+    && opts.now - gatewayStartedAtMs < bootReasonReuseWindowMs) {
+    return bootReason
+  }
+  return determineRestartReason(opts)
+}

package/telegram-plugin/gateway/cron-session.ts

@@ -17,6 +17,10 @@
  * target via `cronIdentity()`. Pure string fns — pinned in cron-session.test.ts.
  */
 
+import type { InboundMessage, GatewayToClient } from './ipc-protocol.js'
+import type { InboundSpool } from './inbound-spool.js'
+import { redeliverBufferedInbound, type PendingInboundBuffer } from './pending-inbound-buffer.js'
+
 /** Suffix that distinguishes a cron-session bridge from the main agent bridge. */
 export const CRON_IDENTITY_SUFFIX = "-cron";
 
@@ -140,3 +144,65 @@ export function deliverInjectWithFallback(
   }
   return { target, delivered: false, fellBackToMain: false };
 }
+
+/** Minimal view of the IPC client the cron-bridge register handler needs.
+ *  A structural subset of `IpcClient` so this stays unit-testable without the
+ *  gateway's module-load side effects. */
+export interface CronBridgeRegisterClient {
+  agentName: string | null | undefined;
+  send: (msg: GatewayToClient) => void;
+}
+
+/**
+ * Drain a cheap-cron (`<agent>-cron`) bridge's buffered fires when it
+ * registers — the Tier-1 §2.4/§3.3 status-silent path (#4348).
+ *
+ * The cron bridge is STATUS-SILENT: it must NOT drive the gateway's singleton
+ * machinery (shadow bridge-state, warmup, boot card). But it MUST still flush
+ * any cron fire buffered+spooled during the boot window — a due tick that
+ * arrived before the cron bridge registered.
+ *
+ * THE BUG (#4348): the pre-fix path did a raw `pendingInboundBuffer.drain()` +
+ * `client.send()` loop and returned early WITHOUT ever reaching `spool.ack`.
+ * `spool.ack` lives ONLY inside `redeliverBufferedInbound` — the one chokepoint
+ * every other drain path (bridgeUp, idle-drain, silence-poke, turn-end) routes
+ * through. So the durable spool entry stayed live, boot-replay re-pushed it on
+ * the next restart, and the SAME cron fire re-fired: a duplicate delivery
+ * bounded only by the 15-min escalation sweep. This was the ONLY drain that
+ * bypassed the chokepoint.
+ *
+ * THE FIX: route the drain through `redeliverBufferedInbound` too, so each
+ * delivered fire is spool-acked exactly once and cannot re-fire after a
+ * restart. `beforeRedeliver` (the represent-veto) rides along by construction;
+ * it self-gates and is a no-op for cron-sourced fires. A `send` throw now
+ * re-buffers the fire (lossless) instead of dropping it — strictly safer than
+ * the pre-fix best-effort drop and identical to every sibling drain path.
+ *
+ * Returns the `redeliverBufferedInbound` counts for observability.
+ */
+export function drainCronBridgeOnRegister(
+  client: CronBridgeRegisterClient,
+  buffer: PendingInboundBuffer,
+  spool?: InboundSpool,
+  log?: (line: string) => void,
+): { drained: number; redelivered: number; rebuffered: number; retracted: number } {
+  // Status-silent handshake ack (unchanged from the pre-fix path).
+  client.send({ type: "status", status: "agent_connected" });
+  const send = (msg: InboundMessage): boolean => {
+    try {
+      client.send(msg);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const result = redeliverBufferedInbound(buffer, client.agentName ?? "", send, spool);
+  if (result.drained > 0 && log != null) {
+    log(
+      `telegram gateway: cron-bridge drain agent=${client.agentName} ` +
+        `drained=${result.drained} redelivered=${result.redelivered} ` +
+        `rebuffered=${result.rebuffered}\n`,
+    );
+  }
+  return result;
+}