switchroom 0.21.7 → 0.21.8

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

@@ -22355,7 +22355,7 @@ var init_schema = __esm(() => {
     repos: exports_external.record(exports_external.string().regex(/^[a-z0-9][a-z0-9-]*$/, "Repo slug must be kebab-case ASCII: start with a lowercase letter or digit, contain only lowercase letters, digits, and hyphens"), exports_external.object({
       url: exports_external.string().min(1).describe("Git remote URL for the repo (e.g. 'git@github.com:org/repo.git' or " + "'https://github.com/org/repo.git'). Used verbatim for git clone."),
       branch_default: exports_external.string().optional().describe("Default branch to track (defaults to the remote's HEAD, typically 'main'). " + "The per-agent branch 'agent/<agentName>/main' fast-forwards to this branch " + "when the worktree is clean on session start.")
-    })).optional().describe("Repos this agent operates on. Switchroom provisions a dedicated worktree for each " + "repo at <agentDir>/work/<slug>/ on branch agent/<agentName>/main, backed by a " + "shared bare clone at ~/.switchroom/repos/<slug>.git. The worktree path is injected " + "into the agent's environment as SWITCHROOM_REPO_<SLUG_UPPER>. " + "Agents without this field continue to work unchanged."),
+    })).optional().describe("Repos this agent operates on. Switchroom provisions a dedicated standing tree for " + "each repo at <agentDir>/work/<slug>/ on branch agent/<agentName>/main \u2014 an " + "independent clone (own refs/stash, hardlinked objects) seeded from a shared bare " + "clone at ~/.switchroom/repos/<slug>.git. The tree's path is injected " + "into the agent's environment as SWITCHROOM_REPO_<SLUG_UPPER>. " + "Agents without this field continue to work unchanged."),
     experimental: exports_external.object({
       legacy_pty: exports_external.boolean().optional().describe("Opt out of the default tmux supervisor (#725) and run the agent " + "under the legacy PTY supervisor instead. Default: false."),
       legacy_autoaccept_expect: exports_external.boolean().optional().describe("Opt the autoaccept gateway back into the legacy expect-script " + "behaviour instead of the tmux send-keys path. Default: false.")
@@ -24113,7 +24113,7 @@ var init_approval_card = __esm(() => {
 });
 
 // flood-429-ledger.ts
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync13, mkdirSync as mkdirSync17, chmodSync as chmodSync4, unlinkSync as unlinkSync9 } from "node:fs";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync14, mkdirSync as mkdirSync17, chmodSync as chmodSync4, unlinkSync as unlinkSync10 } from "node:fs";
 import { dirname as dirname9, join as join20 } from "node:path";
 function flood429LedgerPathFromFloodState(floodStatePath) {
   return join20(dirname9(floodStatePath), FLOOD_429_LEDGER_FILE);
@@ -24217,7 +24217,7 @@ function writeFlood429Ledger(path2, episodes, log = (l) => process.stderr.write(
     mkdirSync17(dirname9(path2), { recursive: true });
   } catch {}
   try {
-    writeFileSync13(path2, payload, { mode: FLOOD_429_LEDGER_MODE });
+    writeFileSync14(path2, payload, { mode: FLOOD_429_LEDGER_MODE });
     try {
       chmodSync4(path2, FLOOD_429_LEDGER_MODE);
     } catch {}
@@ -24230,8 +24230,8 @@ function writeFlood429Ledger(path2, episodes, log = (l) => process.stderr.write(
       return;
     }
     try {
-      unlinkSync9(path2);
-      writeFileSync13(path2, payload, { mode: FLOOD_429_LEDGER_MODE });
+      unlinkSync10(path2);
+      writeFileSync14(path2, payload, { mode: FLOOD_429_LEDGER_MODE });
     } catch (err2) {
       log(`telegram gateway: 429-ledger: cannot persist the 429 pressure ledger to ${path2} ` + `(${code2}, recreate failed: ${err2?.message ?? String(err2)}). ` + `Flood-pressure history will be missing from \`switchroom doctor\`
 `);
@@ -24253,11 +24253,11 @@ var init_flood_429_ledger = __esm(() => {
 import {
   existsSync as existsSync14,
   readFileSync as readFileSync16,
-  writeFileSync as writeFileSync14,
+  writeFileSync as writeFileSync15,
   mkdirSync as mkdirSync18,
   chmodSync as chmodSync5,
-  unlinkSync as unlinkSync10,
-  renameSync as renameSync10
+  unlinkSync as unlinkSync11,
+  renameSync as renameSync11
 } from "node:fs";
 import { dirname as dirname10, join as join21 } from "node:path";
 function floodStatePath(stateDir) {
@@ -24313,7 +24313,7 @@ function writeFloodState(path2, state, log = (l) => process.stderr.write(l)) {
     mkdirSync18(dirname10(path2), { recursive: true });
   } catch {}
   try {
-    writeFileSync14(path2, payload, { mode: FLOOD_STATE_MODE });
+    writeFileSync15(path2, payload, { mode: FLOOD_STATE_MODE });
     try {
       chmodSync5(path2, FLOOD_STATE_MODE);
     } catch {}
@@ -24326,8 +24326,8 @@ function writeFloodState(path2, state, log = (l) => process.stderr.write(l)) {
       return;
     }
     try {
-      unlinkSync10(path2);
-      writeFileSync14(path2, payload, { mode: FLOOD_STATE_MODE });
+      unlinkSync11(path2);
+      writeFileSync15(path2, payload, { mode: FLOOD_STATE_MODE });
       log(`telegram gateway: flood-breaker: recreated ${path2} \u2014 it was owned by another uid ` + `and could not be updated (${code2}); the breaker was blind (issue #3106)
 `);
     } catch (err2) {
@@ -30636,7 +30636,7 @@ var init_turn_flush_suppression = () => {};
 
 // ../src/agents/generation-stamp.ts
 import { createHash as createHash6 } from "node:crypto";
-import { existsSync as existsSync36, readFileSync as readFileSync35, writeFileSync as writeFileSync30 } from "node:fs";
+import { existsSync as existsSync36, readFileSync as readFileSync35, writeFileSync as writeFileSync31 } from "node:fs";
 import { join as join44 } from "node:path";
 function sha256Text(s) {
   return createHash6("sha256").update(s, "utf-8").digest("hex");
@@ -36473,7 +36473,7 @@ function renderAuthLine(state7, agentName3, now = Date.now()) {
 }
 
 // gateway/quota-cache.ts
-import { existsSync as existsSync49, readFileSync as readFileSync49, writeFileSync as writeFileSync40, mkdirSync as mkdirSync42 } from "fs";
+import { existsSync as existsSync49, readFileSync as readFileSync49, writeFileSync as writeFileSync41, mkdirSync as mkdirSync42 } from "fs";
 import { join as join59, dirname as dirname25 } from "path";
 function defaultCachePath() {
   return process.env.SWITCHROOM_QUOTA_CACHE_PATH ?? join59(process.env.HOME ?? "/tmp", ".switchroom", "quota-cache.json");
@@ -36512,7 +36512,7 @@ function writeQuotaCache(result, opts = {}) {
   };
   try {
     mkdirSync42(dirname25(path3), { recursive: true });
-    writeFileSync40(path3, JSON.stringify(entry, null, 2), { mode: 384 });
+    writeFileSync41(path3, JSON.stringify(entry, null, 2), { mode: 384 });
   } catch {}
 }
 var DEFAULT_TTL_MS4, RATE_LIMIT_TTL_MS;
@@ -37383,7 +37383,7 @@ var init_boot_probes = __esm(() => {
 });
 
 // gateway/boot-issue-cache.ts
-import { existsSync as existsSync51, readFileSync as readFileSync51, writeFileSync as writeFileSync41, mkdirSync as mkdirSync43, renameSync as renameSync24 } from "fs";
+import { existsSync as existsSync51, readFileSync as readFileSync51, writeFileSync as writeFileSync42, mkdirSync as mkdirSync43, renameSync as renameSync25 } from "fs";
 import { dirname as dirname26 } from "path";
 function fingerprintProbe(key, r) {
   if (r.status === "ok")
@@ -37476,7 +37476,7 @@ function loadCache(path3, now = Date.now) {
     parsed = JSON.parse(raw);
   } catch {
     try {
-      renameSync24(path3, `${path3}.corrupt-${now()}`);
+      renameSync25(path3, `${path3}.corrupt-${now()}`);
     } catch {}
     return { ...EMPTY_CACHE, probes: {} };
   }
@@ -37512,8 +37512,8 @@ function applyAndSave(path3, cache, diff) {
   try {
     mkdirSync43(dirname26(path3), { recursive: true });
     const tmp = `${path3}.tmp`;
-    writeFileSync41(tmp, JSON.stringify(next), { mode: 384 });
-    renameSync24(tmp, path3);
+    writeFileSync42(tmp, JSON.stringify(next), { mode: 384 });
+    renameSync25(tmp, path3);
   } catch {}
   return next;
 }
@@ -37526,7 +37526,7 @@ var init_boot_issue_cache = __esm(() => {
 
 // gateway/config-snapshot.ts
 import { createHash as createHash7 } from "crypto";
-import { existsSync as existsSync52, readFileSync as readFileSync52, writeFileSync as writeFileSync42, mkdirSync as mkdirSync44, renameSync as renameSync25 } from "fs";
+import { existsSync as existsSync52, readFileSync as readFileSync52, writeFileSync as writeFileSync43, mkdirSync as mkdirSync44, renameSync as renameSync26 } from "fs";
 import { dirname as dirname27 } from "path";
 function hashStringArray(items) {
   if (!items || items.length === 0)
@@ -37604,7 +37604,7 @@ function loadSnapshot(path3, now = Date.now) {
     parsed = JSON.parse(raw);
   } catch {
     try {
-      renameSync25(path3, `${path3}.corrupt-${now()}`);
+      renameSync26(path3, `${path3}.corrupt-${now()}`);
     } catch {}
     return null;
   }
@@ -37627,8 +37627,8 @@ function persistSnapshot(path3, snapshot) {
   try {
     mkdirSync44(dirname27(path3), { recursive: true });
     const tmp = `${path3}.tmp`;
-    writeFileSync42(tmp, JSON.stringify(snapshot), { mode: 384 });
-    renameSync25(tmp, path3);
+    writeFileSync43(tmp, JSON.stringify(snapshot), { mode: 384 });
+    renameSync26(tmp, path3);
   } catch {}
 }
 var init_config_snapshot = __esm(() => {
@@ -37636,7 +37636,7 @@ var init_config_snapshot = __esm(() => {
 });
 
 // gateway/boot-card-msgid.ts
-import { readFileSync as readFileSync53, writeFileSync as writeFileSync43 } from "node:fs";
+import { readFileSync as readFileSync53, writeFileSync as writeFileSync44 } from "node:fs";
 function bootCardChatKey(chatId, threadId) {
   return `${chatId}:${threadId ?? ""}`;
 }
@@ -37661,7 +37661,7 @@ function saveBootCardMsgId(path3, chatKey3, messageId) {
     if (store3[chatKey3] === messageId)
       return;
     store3[chatKey3] = messageId;
-    writeFileSync43(path3, JSON.stringify(store3), "utf8");
+    writeFileSync44(path3, JSON.stringify(store3), "utf8");
   } catch {}
 }
 var init_boot_card_msgid = () => {};
@@ -38695,7 +38695,7 @@ __export(exports_tmux2, {
   captureAgentPane: () => captureAgentPane2
 });
 import { execFileSync as execFileSync8 } from "node:child_process";
-import { chmodSync as chmodSync13, mkdirSync as mkdirSync49, readdirSync as readdirSync17, statSync as statSync24, unlinkSync as unlinkSync30, writeFileSync as writeFileSync52 } from "node:fs";
+import { chmodSync as chmodSync13, mkdirSync as mkdirSync49, readdirSync as readdirSync18, statSync as statSync24, unlinkSync as unlinkSync32, writeFileSync as writeFileSync54 } from "node:fs";
 import { resolve as resolve12 } from "node:path";
 function captureAgentPane2(opts) {
   const { agentName: agentName3, agentDir, reason } = opts;
@@ -38746,7 +38746,7 @@ function captureAgentPane2(opts) {
 ` + `
 `;
   try {
-    writeFileSync52(outPath, Buffer.concat([Buffer.from(header, "utf8"), body]), {
+    writeFileSync54(outPath, Buffer.concat([Buffer.from(header, "utf8"), body]), {
       mode: 384
     });
   } catch (err) {
@@ -38816,7 +38816,7 @@ function sleepSync3(ms) {
 function pruneOldReports2(dir, retain) {
   let entries;
   try {
-    entries = readdirSync17(dir);
+    entries = readdirSync18(dir);
   } catch {
     return;
   }
@@ -38830,7 +38830,7 @@ function pruneOldReports2(dir, retain) {
   }).sort((a, b) => b.mtimeMs - a.mtimeMs);
   for (const stale of files.slice(retain)) {
     try {
-      unlinkSync30(stale.full);
+      unlinkSync32(stale.full);
     } catch {}
   }
 }
@@ -39640,7 +39640,7 @@ __export(exports_materialize_bot_token, {
   materializeBotToken: () => materializeBotToken,
   BotTokenMaterializeError: () => BotTokenMaterializeError
 });
-import { existsSync as existsSync63 } from "node:fs";
+import { existsSync as existsSync64 } from "node:fs";
 function pickConfiguredToken(config, agentName3) {
   if (agentName3) {
     const agent = config.agents?.[agentName3];
@@ -39654,7 +39654,7 @@ function tryDirectVaultRead4(ref, config, passphrase) {
   if (!passphrase)
     return null;
   const vaultPath = resolvePath(config.vault?.path ?? "~/.switchroom/vault.enc");
-  if (!existsSync63(vaultPath))
+  if (!existsSync64(vaultPath))
     return null;
   try {
     const secrets = openVault(passphrase, vaultPath);
@@ -39809,19 +39809,19 @@ var import_runner3 = __toESM(require_mod3(), 1);
 import { randomBytes as randomBytes12, createHash as createHash8 } from "crypto";
 import { execFileSync as execFileSync9, execSync as execSync2, spawn as spawn2 } from "child_process";
 import {
-  readFileSync as readFileSync66,
-  writeFileSync as writeFileSync53,
+  readFileSync as readFileSync67,
+  writeFileSync as writeFileSync55,
   mkdirSync as mkdirSync50,
-  readdirSync as readdirSync18,
+  readdirSync as readdirSync19,
   rmSync as rmSync9,
   statSync as statSync25,
-  renameSync as renameSync30,
+  renameSync as renameSync32,
   realpathSync as realpathSync6,
   chmodSync as chmodSync14,
   openSync as openSync18,
   closeSync as closeSync18,
-  existsSync as existsSync64,
-  unlinkSync as unlinkSync31,
+  existsSync as existsSync65,
+  unlinkSync as unlinkSync33,
   appendFileSync as appendFileSync11
 } from "fs";
 
@@ -39839,7 +39839,7 @@ function fsyncPathSync(path) {
 
 // gateway/gateway.ts
 import { homedir as homedir22 } from "os";
-import { join as join76, sep as sep6, basename as basename18 } from "path";
+import { join as join77, sep as sep6, basename as basename19 } from "path";
 
 // plugin-logger.ts
 import { appendFileSync, mkdirSync, renameSync as renameSync2, statSync, existsSync } from "fs";
@@ -50974,7 +50974,7 @@ function createSweepableCardStore(deps) {
 init_rich_send();
 var import_grammy4 = __toESM(require_mod2(), 1);
 import { execFileSync as execFileSync3 } from "child_process";
-import { mkdirSync as mkdirSync15, writeFileSync as writeFileSync10 } from "fs";
+import { mkdirSync as mkdirSync15, writeFileSync as writeFileSync11 } from "fs";
 import { dirname as dirname7 } from "path";
 init_client2();
 
@@ -51754,11 +51754,15 @@ import {
   mkdirSync as mkdirSync14,
   openSync as openSync8,
   readFileSync as readFileSync13,
+  renameSync as renameSync10,
+  unlinkSync as unlinkSync6,
+  writeFileSync as writeFileSync10,
   writeSync as writeSync7
 } from "node:fs";
 import { join as join15 } from "node:path";
 import { randomUUID as randomUUID4 } from "node:crypto";
 var EVAL_CASE_PROPOSALS_FILE = "eval-case-proposals.jsonl";
+var MAX_EVAL_CASE_PROPOSALS = 200;
 function proposalsPath2(stateDir) {
   return join15(stateDir, EVAL_CASE_PROPOSALS_FILE);
 }
@@ -51801,6 +51805,49 @@ function readEvalCaseProposals(stateDir) {
   }
   return [...byId.values()];
 }
+function withinBound(all, now) {
+  const isLiveRejection = (r) => {
+    if (r.status !== "rejected")
+      return false;
+    const age = now - new Date(r.created_at).getTime();
+    return !Number.isFinite(age) || age <= REJECTION_TTL_MS;
+  };
+  const keepTail = (rows) => rows.length > MAX_EVAL_CASE_PROPOSALS ? rows.slice(rows.length - MAX_EVAL_CASE_PROPOSALS) : rows;
+  const keep = new Set([
+    ...keepTail(all.filter(isLiveRejection)).map((r) => r.id),
+    ...keepTail(all.filter((r) => !isLiveRejection(r))).map((r) => r.id)
+  ]);
+  return all.filter((r) => keep.has(r.id));
+}
+function compactIfOversized(stateDir, now) {
+  const path = proposalsPath2(stateDir);
+  let raw;
+  try {
+    raw = readFileSync13(path, "utf-8");
+  } catch {
+    return;
+  }
+  const lines = raw.split(`
+`).filter((l) => l.trim().length > 0);
+  if (lines.length <= MAX_EVAL_CASE_PROPOSALS * 2)
+    return;
+  const kept = withinBound(readEvalCaseProposals(stateDir), now);
+  if (kept.length >= lines.length)
+    return;
+  const tmp = `${path}.tmp.${process.pid}`;
+  try {
+    writeFileSync10(tmp, kept.map((r) => JSON.stringify(r) + `
+`).join(""), {
+      encoding: "utf-8",
+      mode: 420
+    });
+    renameSync10(tmp, path);
+  } catch {
+    try {
+      unlinkSync6(tmp);
+    } catch {}
+  }
+}
 function getEvalCaseProposal(stateDir, id) {
   return readEvalCaseProposals(stateDir).find((p) => p.id === id);
 }
@@ -51814,6 +51861,7 @@ function enqueueEvalCaseProposal(stateDir, input, opts = {}) {
     ...input
   };
   appendLine2(proposalsPath2(stateDir), proposal);
+  compactIfOversized(stateDir, now());
   return proposal;
 }
 function setEvalCaseProposalStatus(stateDir, id, status) {
@@ -51822,8 +51870,94 @@ function setEvalCaseProposalStatus(stateDir, id, status) {
     return;
   const next = { ...cur, status };
   appendLine2(proposalsPath2(stateDir), next);
+  compactIfOversized(stateDir, Date.now());
   return next;
 }
+
+// gateway/eval-case-proposal-inbound-builders.ts
+function commonMeta(opts) {
+  return {
+    agent: opts.ctx.agent,
+    ...opts.ctx.threadId != null ? { message_thread_id: String(opts.ctx.threadId) } : {},
+    proposal_id: opts.proposalId,
+    skill_slug: opts.skillSlug,
+    held_out: String(opts.heldOut),
+    operator_id: opts.operatorId
+  };
+}
+function buildEvalCaseAppliedInbound(opts) {
+  const ts = opts.nowMs ?? Date.now();
+  const sink2 = opts.heldOut ? "the held-out sink" : `\`${opts.skillSlug}\`'s \`evals.json\``;
+  return {
+    type: "inbound",
+    chatId: opts.ctx.chat_id,
+    ...opts.ctx.threadId != null ? { threadId: opts.ctx.threadId } : {},
+    messageId: ts,
+    user: "self-improve",
+    userId: 0,
+    ts,
+    text: `\u2705 Operator approved your proposed eval case for \`${opts.skillSlug}\` ` + `(proposal ${opts.proposalId}). The case was applied DETERMINISTICALLY by ` + `the gateway and is already written to ${sink2} \u2014 do NOT write it yourself ` + `and do NOT re-propose it. Resume whatever you were doing.`,
+    meta: {
+      source: "eval_case_applied",
+      ...commonMeta({
+        ctx: opts.ctx,
+        proposalId: opts.proposalId,
+        skillSlug: opts.skillSlug,
+        heldOut: opts.heldOut,
+        operatorId: opts.operatorId
+      })
+    }
+  };
+}
+function buildEvalCaseRejectedInbound(opts) {
+  const ts = opts.nowMs ?? Date.now();
+  return {
+    type: "inbound",
+    chatId: opts.ctx.chat_id,
+    ...opts.ctx.threadId != null ? { threadId: opts.ctx.threadId } : {},
+    messageId: ts,
+    user: "self-improve",
+    userId: 0,
+    ts,
+    text: `\uD83D\uDEAB Operator dismissed your proposed eval case for \`${opts.skillSlug}\` ` + `(proposal ${opts.proposalId}). NOTHING was written \u2014 no eval case was ` + `added. Carry on with the original task without it. Do NOT re-propose the ` + `same case without first asking the user.`,
+    meta: {
+      source: "eval_case_rejected",
+      ...commonMeta({
+        ctx: opts.ctx,
+        proposalId: opts.proposalId,
+        skillSlug: opts.skillSlug,
+        heldOut: opts.heldOut,
+        operatorId: opts.operatorId
+      })
+    }
+  };
+}
+function buildEvalCaseApplyFailedInbound(opts) {
+  const ts = opts.nowMs ?? Date.now();
+  const tail = opts.applyOut.trim().slice(0, 500);
+  return {
+    type: "inbound",
+    chatId: opts.ctx.chat_id,
+    ...opts.ctx.threadId != null ? { threadId: opts.ctx.threadId } : {},
+    messageId: ts,
+    user: "self-improve",
+    userId: 0,
+    ts,
+    text: `\u26a0\ufe0f The operator approved your proposed eval case for \`${opts.skillSlug}\` ` + `(proposal ${opts.proposalId}) but the applier FAILED. The case was NOT ` + `written \u2014 do NOT assume the regression test exists. Applier output:
+` + `${tail.length > 0 ? tail : "(no output)"}
+` + `Carry on with the original task; report the failure to the operator if it ` + `still matters.`,
+    meta: {
+      source: "eval_case_apply_failed",
+      ...commonMeta({
+        ctx: opts.ctx,
+        proposalId: opts.proposalId,
+        skillSlug: opts.skillSlug,
+        heldOut: opts.heldOut,
+        operatorId: opts.operatorId
+      })
+    }
+  };
+}
 // gateway/callback-query-handlers.ts
 init_auth_snapshot_format();
 
@@ -52003,13 +52137,14 @@ var AgentSmokeRequestSchema = exports_external.object({
     deep: exports_external.boolean().optional()
   })
 });
+var CANONICAL_CONFIG_PATH = "/state/config/switchroom.yaml";
 var ConfigProposeEditRequestSchema = exports_external.object({
   ...RequestEnvelope,
   op: exports_external.literal("config_propose_edit"),
   args: exports_external.object({
     unified_diff: exports_external.string().min(1).max(MAX_FRAME_BYTES3 - 1024),
     reason: exports_external.string().min(1).max(500),
-    target_path: exports_external.literal("/state/config/switchroom.yaml")
+    target_path: exports_external.literal(CANONICAL_CONFIG_PATH)
   })
 });
 var RequestSchema3 = exports_external.discriminatedUnion("op", [
@@ -52335,6 +52470,20 @@ function createCallbackQueryHandlers(deps) {
   const listViaBroker2 = deps.brokerList ?? listViaBroker;
   const listGrantsViaBroker2 = deps.brokerListGrants ?? listGrantsViaBroker;
   const vaultTokenFilePath2 = deps.brokerVaultTokenFilePath ?? vaultTokenFilePath;
+  const runEvalCaseApply = deps.runEvalCaseApply ?? ((id) => {
+    const cli = process.env.SWITCHROOM_CLI_PATH ?? "switchroom";
+    try {
+      const out = execFileSync3(cli, ["self-improve", "apply-eval-case", "--id", id], { encoding: "utf8", timeout: 15000, env: process.env }).trim();
+      return { ok: true, out };
+    } catch (err) {
+      const e = err;
+      return {
+        ok: false,
+        out: [e.stdout, e.stderr, e.message].filter(Boolean).join(`
+`).trim()
+      };
+    }
+  });
   async function handleVaultRecentDenialCallback(ctx, data) {
     const senderId = String(ctx.from?.id ?? "");
     const access = loadAccess();
@@ -52375,7 +52524,7 @@ function createCallbackQueryHandlers(deps) {
     const tokenPath = vaultTokenFilePath2(agentName);
     try {
       mkdirSync15(dirname7(tokenPath), { recursive: true });
-      writeFileSync10(tokenPath, token, { mode: 384 });
+      writeFileSync11(tokenPath, token, { mode: 384 });
     } catch (err) {
       await switchroomReply(ctx, `**Grant created (${escapeHtmlForTg2(id)}) but token write failed:** ` + `${escapeHtmlForTg2(String(err))}
 ` + `_Recover with: \`switchroom vault grant ${escapeHtmlForTg2(agentName)} ` + `--keys ${escapeHtmlForTg2(keyName)} --duration 30d\` on the host._`, { html: true });
@@ -52527,7 +52676,7 @@ function createCallbackQueryHandlers(deps) {
     const tokenPath = vaultTokenFilePath2(pending.agent);
     try {
       mkdirSync15(dirname7(tokenPath), { recursive: true });
-      writeFileSync10(tokenPath, token, { mode: 384 });
+      writeFileSync11(tokenPath, token, { mode: 384 });
     } catch (err) {
       await switchroomReply(ctx, `**Grant created (${escapeHtmlForTg2(id)}) but token write failed:** ` + `${escapeHtmlForTg2(String(err))}
 ` + `_Recover with: \`switchroom vault grant ${escapeHtmlForTg2(pending.agent)} ` + `--keys ${escapeHtmlForTg2(pending.key)} --duration ${Math.round(pending.ttl_seconds / 86400)}d\` on the host._`, { html: true });
@@ -52668,36 +52817,57 @@ _Approver verified by Telegram identity \u2014 broker auto-unlocked at startup._
       }
       return;
     }
+    const cbChatId = String(ctx.chat?.id ?? ctx.from?.id ?? "");
+    const cbThreadId = resolveThreadId(cbChatId, ctx.callbackQuery?.message?.message_thread_id);
+    const inboundCtx = {
+      agent,
+      chat_id: cbChatId,
+      ...cbThreadId != null ? { threadId: cbThreadId } : {}
+    };
     if (parsed.action === "deny") {
       setEvalCaseProposalStatus(stateDir, parsed.id, "rejected");
+      const denied = deliverResumeSyntheticOrBuffer(agent, buildEvalCaseRejectedInbound({
+        ctx: inboundCtx,
+        proposalId: proposal.id,
+        skillSlug: proposal.skill_slug,
+        heldOut: proposal.held_out,
+        operatorId: senderId
+      }));
       await ctx.answerCallbackQuery({ text: "\uD83D\uDEAB Dismissed." }).catch(() => {});
       if (ctx.callbackQuery?.message && "text" in ctx.callbackQuery.message) {
         await ctx.editMessageText(`${escapeHtmlForTg2(ctx.callbackQuery.message.text ?? "")}
 
 \uD83D\uDEAB <i>Dismissed.</i>`, { parse_mode: "HTML", reply_markup: { inline_keyboard: [] } }).catch(() => {});
       }
+      process.stderr.write(`telegram gateway: eval_case_rejected agent=${agent} proposal=${proposal.id} ` + `slug=${proposal.skill_slug} delivered=${denied}
+`);
       return;
     }
     setEvalCaseProposalStatus(stateDir, parsed.id, "approved");
     await ctx.answerCallbackQuery({ text: "\u2705 Adding the eval case\u2026" }).catch(() => {});
-    const cli = process.env.SWITCHROOM_CLI_PATH ?? "switchroom";
-    let applyOk = true;
-    let applyOut = "";
-    try {
-      applyOut = execFileSync3(cli, ["self-improve", "apply-eval-case", "--id", parsed.id], { encoding: "utf8", timeout: 15000, env: process.env }).trim();
-    } catch (err) {
-      applyOk = false;
-      const e = err;
-      applyOut = [e.stdout, e.stderr, e.message].filter(Boolean).join(`
-`).trim();
-    }
+    const { ok: applyOk, out: applyOut } = runEvalCaseApply(parsed.id);
     const footer = applyOk ? "\u2705 <i>Added as a regression test.</i>" : `\u26a0\ufe0f <i>Apply failed:</i> ${escapeHtmlForTg2(applyOut.slice(0, 200))}`;
     if (ctx.callbackQuery?.message && "text" in ctx.callbackQuery.message) {
       await ctx.editMessageText(`${escapeHtmlForTg2(ctx.callbackQuery.message.text ?? "")}
 
 ${footer}`, { parse_mode: "HTML", reply_markup: { inline_keyboard: [] } }).catch(() => {});
     }
-    process.stderr.write(`telegram gateway: eval_case_apply agent=${agent} proposal=${proposal.id} ` + `slug=${proposal.skill_slug} ok=${applyOk}
+    const outcomeInbound = applyOk ? buildEvalCaseAppliedInbound({
+      ctx: inboundCtx,
+      proposalId: proposal.id,
+      skillSlug: proposal.skill_slug,
+      heldOut: proposal.held_out,
+      operatorId: senderId
+    }) : buildEvalCaseApplyFailedInbound({
+      ctx: inboundCtx,
+      proposalId: proposal.id,
+      skillSlug: proposal.skill_slug,
+      heldOut: proposal.held_out,
+      operatorId: senderId,
+      applyOut
+    });
+    const delivered = deliverResumeSyntheticOrBuffer(agent, outcomeInbound);
+    process.stderr.write(`telegram gateway: eval_case_apply agent=${agent} proposal=${proposal.id} ` + `slug=${proposal.skill_slug} ok=${applyOk} delivered=${delivered}
 `);
   }
   async function handleMentalModelProposeCallback(ctx, data) {
@@ -53421,7 +53591,7 @@ ${keyList}`,
     const tokenPath = vaultTokenFilePath2(state.agent);
     try {
       mkdirSync15(dirname7(tokenPath), { recursive: true });
-      writeFileSync10(tokenPath, token, { mode: 384 });
+      writeFileSync11(tokenPath, token, { mode: 384 });
     } catch (err) {
       await switchroomReply(ctx, `**Grant created but token write failed:** ${escapeHtmlForTg2(String(err))}`, { html: true });
       return;
@@ -54480,7 +54650,7 @@ function hangStalenessMs(env = process.env) {
 
 // gateway/missed-approvals-store.ts
 init_state_owner();
-import { unlinkSync as unlinkSync6 } from "node:fs";
+import { unlinkSync as unlinkSync7 } from "node:fs";
 import { join as join17 } from "node:path";
 var MAX_PENDING = 50;
 var MAX_DELIVERED = 20;
@@ -54565,7 +54735,7 @@ function createMissedApprovalsStore(stateDir, log = (l) => process.stderr.write(
     },
     clear() {
       try {
-        unlinkSync6(filePath);
+        unlinkSync7(filePath);
       } catch {}
     }
   };
@@ -54573,7 +54743,7 @@ function createMissedApprovalsStore(stateDir, log = (l) => process.stderr.write(
 
 // gateway/always-allow-persist-queue.ts
 init_state_owner();
-import { unlinkSync as unlinkSync7 } from "node:fs";
+import { unlinkSync as unlinkSync8 } from "node:fs";
 import { join as join18 } from "node:path";
 var MAX_ATTEMPTS = 5;
 var MAX_AGE_MS = 24 * 60 * 60 * 1000;
@@ -54710,7 +54880,7 @@ function createAlwaysAllowPersistQueue(stateDir, writeFileSyncFn = atomicWriteSe
     },
     clear() {
       try {
-        unlinkSync7(filePath);
+        unlinkSync8(filePath);
       } catch {}
     }
   };
@@ -54873,7 +55043,7 @@ function pickRecoveredPermissionOrigin(recentTurns, now, maxAgeMs) {
 }
 
 // gateway/approval-hold.ts
-import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync12, readFileSync as readFileSync14, unlinkSync as unlinkSync8, chmodSync as chmodSync3, lstatSync as lstatSync2 } from "node:fs";
+import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync13, readFileSync as readFileSync14, unlinkSync as unlinkSync9, chmodSync as chmodSync3, lstatSync as lstatSync2 } from "node:fs";
 import { join as join19, dirname as dirname8 } from "node:path";
 var BLOCKED_APPROVAL_FILE_MODE = 420;
 var BLOCKED_APPROVAL_DIR_MODE = 1023;
@@ -54902,7 +55072,8 @@ var ACTION_SAFE_WITH_INPUT2 = new Set([
 function safeActionForRecord(naturalAction2, toolName, inputPreview) {
   return ACTION_SAFE_WITH_INPUT2.has(toolName) ? naturalAction2(toolName, inputPreview) : naturalAction2(toolName, undefined);
 }
-function createBlockedApprovalStore(dir, agent, fallbackDir) {
+function createBlockedApprovalStore(dir, agent, fallbackDir, deps = {}) {
+  const write_ = deps.writeFileSync ?? writeFileSync13;
   const primary = join19(dir, `${agent}.json`);
   const fallback = fallbackDir != null ? join19(fallbackDir, "blocked-approval.json") : null;
   let active = primary;
@@ -54919,7 +55090,7 @@ function createBlockedApprovalStore(dir, agent, fallbackDir) {
           chmodSync3(parent, dirMode);
         } catch {}
       }
-      writeFileSync12(target, body, { encoding: "utf-8", mode: BLOCKED_APPROVAL_FILE_MODE });
+      write_(target, body, { encoding: "utf-8", mode: BLOCKED_APPROVAL_FILE_MODE });
       chmodSync3(target, BLOCKED_APPROVAL_FILE_MODE);
       return true;
     } catch {
@@ -54937,7 +55108,7 @@ function createBlockedApprovalStore(dir, agent, fallbackDir) {
         active = primary;
         if (fallback != null) {
           try {
-            unlinkSync8(fallback);
+            unlinkSync9(fallback);
           } catch {}
         }
         return;
@@ -54956,7 +55127,7 @@ function createBlockedApprovalStore(dir, agent, fallbackDir) {
         if (p == null)
           continue;
         try {
-          unlinkSync8(p);
+          unlinkSync9(p);
         } catch {}
       }
       active = primary;
@@ -67336,11 +67507,11 @@ init_flood_429_ledger();
 import {
   existsSync as existsSync15,
   readFileSync as readFileSync17,
-  writeFileSync as writeFileSync15,
+  writeFileSync as writeFileSync16,
   mkdirSync as mkdirSync19,
   chmodSync as chmodSync6,
-  unlinkSync as unlinkSync11,
-  renameSync as renameSync11
+  unlinkSync as unlinkSync12,
+  renameSync as renameSync12
 } from "node:fs";
 import { dirname as dirname11, join as join22 } from "node:path";
 var FLOOD_STATE_FILE2 = "flood-wait.json";
@@ -67398,7 +67569,7 @@ function writeFloodState2(path2, state, log = (l) => process.stderr.write(l)) {
     mkdirSync19(dirname11(path2), { recursive: true });
   } catch {}
   try {
-    writeFileSync15(path2, payload, { mode: FLOOD_STATE_MODE2 });
+    writeFileSync16(path2, payload, { mode: FLOOD_STATE_MODE2 });
     try {
       chmodSync6(path2, FLOOD_STATE_MODE2);
     } catch {}
@@ -67411,8 +67582,8 @@ function writeFloodState2(path2, state, log = (l) => process.stderr.write(l)) {
       return;
     }
     try {
-      unlinkSync11(path2);
-      writeFileSync15(path2, payload, { mode: FLOOD_STATE_MODE2 });
+      unlinkSync12(path2);
+      writeFileSync16(path2, payload, { mode: FLOOD_STATE_MODE2 });
       log(`telegram gateway: flood-breaker: recreated ${path2} \u2014 it was owned by another uid ` + `and could not be updated (${code2}); the breaker was blind (issue #3106)
 `);
     } catch (err2) {
@@ -67546,8 +67717,8 @@ function writeFloodWindow(path2, record, now) {
     }
     const arr = [...byScope.values()];
     const tmp = `${path2}.tmp-${process.pid}`;
-    writeFileSync15(tmp, JSON.stringify(arr), { mode: FLOOD_STATE_MODE2 });
-    renameSync11(tmp, path2);
+    writeFileSync16(tmp, JSON.stringify(arr), { mode: FLOOD_STATE_MODE2 });
+    renameSync12(tmp, path2);
     try {
       chmodSync6(path2, FLOOD_STATE_MODE2);
     } catch {}
@@ -72144,7 +72315,7 @@ class PostHog extends PostHogBackendClient {
 }
 
 // analytics-posthog.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync20, readFileSync as readFileSync18, writeFileSync as writeFileSync16 } from "node:fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync20, readFileSync as readFileSync18, writeFileSync as writeFileSync17 } from "node:fs";
 import { dirname as dirname13, join as join24 } from "node:path";
 import { randomUUID as randomUUID5 } from "node:crypto";
 var DEFAULT_KEY = "phc_qKY87cKWZm6ZyCtk7LcRd2cU8Sg42u7Ywhui5stYCegd";
@@ -72185,7 +72356,7 @@ function getDistinctId() {
   cachedDistinctId = id;
   try {
     mkdirSync20(dirname13(fallbackPath), { recursive: true });
-    writeFileSync16(fallbackPath, id, "utf-8");
+    writeFileSync17(fallbackPath, id, "utf-8");
   } catch {}
   return id;
 }
@@ -72260,7 +72431,7 @@ import { mkdirSync as mkdirSync22, appendFileSync as appendFileSync4 } from "nod
 import { dirname as dirname15, join as join26 } from "node:path";
 
 // analytics-posthog.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync21, readFileSync as readFileSync19, writeFileSync as writeFileSync17 } from "node:fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync21, readFileSync as readFileSync19, writeFileSync as writeFileSync18 } from "node:fs";
 import { dirname as dirname14, join as join25 } from "node:path";
 import { randomUUID as randomUUID6 } from "node:crypto";
 var DEFAULT_KEY2 = "phc_qKY87cKWZm6ZyCtk7LcRd2cU8Sg42u7Ywhui5stYCegd";
@@ -72300,7 +72471,7 @@ function getDistinctId2() {
   cachedDistinctId2 = id;
   try {
     mkdirSync21(dirname14(fallbackPath), { recursive: true });
-    writeFileSync17(fallbackPath, id, "utf-8");
+    writeFileSync18(fallbackPath, id, "utf-8");
   } catch {}
   return id;
 }
@@ -73036,7 +73207,7 @@ function __resetAllForTests3() {
 }
 
 // silent-end.ts
-import { existsSync as existsSync19, readFileSync as readFileSync20, writeFileSync as writeFileSync18, unlinkSync as unlinkSync12, mkdirSync as mkdirSync23 } from "node:fs";
+import { existsSync as existsSync19, readFileSync as readFileSync20, writeFileSync as writeFileSync19, unlinkSync as unlinkSync13, mkdirSync as mkdirSync23 } from "node:fs";
 import { dirname as dirname16, join as join27 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 var SILENT_END_MAX_RETRIES = 2;
@@ -73081,7 +73252,7 @@ function writeSilentEndState(args, deps) {
   };
   try {
     mkdirSync23(dirname16(statePath), { recursive: true });
-    writeFileSync18(statePath, JSON.stringify(state3), "utf8");
+    writeFileSync19(statePath, JSON.stringify(state3), "utf8");
     emitLog(deps, `silent-end: wrote state file turnKey=${args.turnKey} retryCount=${retryCount}
 `);
   } catch (err) {
@@ -73097,7 +73268,7 @@ function clearSilentEndState(turnKey3, deps) {
     const prev = JSON.parse(readFileSync20(statePath, "utf8"));
     if (prev.turnKey != null && prev.turnKey !== turnKey3)
       return;
-    unlinkSync12(statePath);
+    unlinkSync13(statePath);
     emitLog(deps, `silent-end: cleared state file turnKey=${turnKey3}
 `);
   } catch {}
@@ -74028,7 +74199,7 @@ async function gatewayStartupRetry(fn, opts = {}) {
 }
 
 // gateway/quarantine.ts
-import { mkdirSync as mkdirSync24, writeFileSync as writeFileSync19 } from "node:fs";
+import { mkdirSync as mkdirSync24, writeFileSync as writeFileSync20 } from "node:fs";
 import { join as join30 } from "node:path";
 var QUARANTINE_FILENAME = "quarantine.json";
 function writeQuarantineMarker(telegramStateDir, reason, detail, nowFn = Date.now) {
@@ -74039,7 +74210,7 @@ function writeQuarantineMarker(telegramStateDir, reason, detail, nowFn = Date.no
     ts: nowFn(),
     detail
   };
-  writeFileSync19(join30(telegramStateDir, QUARANTINE_FILENAME), JSON.stringify(marker) + `
+  writeFileSync20(join30(telegramStateDir, QUARANTINE_FILENAME), JSON.stringify(marker) + `
 `, "utf-8");
 }
 
@@ -75512,7 +75683,7 @@ async function materializeSidecarToken2(opts = {}, logger2 = (line) => process.s
 }
 
 // ../src/setup/host-capabilities.ts
-import { mkdirSync as mkdirSync25, readFileSync as readFileSync22, writeFileSync as writeFileSync20 } from "node:fs";
+import { mkdirSync as mkdirSync25, readFileSync as readFileSync22, writeFileSync as writeFileSync21 } from "node:fs";
 init_paths();
 function hostCapabilitiesPath() {
   return resolveStatePath("host-capabilities.json");
@@ -75676,7 +75847,7 @@ function resolveExhaustUntil(resetAtMs, now = Date.now()) {
 
 // gateway/auth-add-flow.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { existsSync as existsSync24, mkdirSync as mkdirSync27, readFileSync as readFileSync24, readdirSync as readdirSync7, rmSync as rmSync6, statSync as statSync10, writeFileSync as writeFileSync22 } from "node:fs";
+import { existsSync as existsSync24, mkdirSync as mkdirSync27, readFileSync as readFileSync24, readdirSync as readdirSync7, rmSync as rmSync6, statSync as statSync10, writeFileSync as writeFileSync23 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
 import { join as join32 } from "node:path";
 import { randomBytes as randomBytes8 } from "node:crypto";
@@ -75686,7 +75857,7 @@ import {
   readFileSync as readFileSync23,
   readdirSync as readdirSync6,
   existsSync as existsSync23,
-  writeFileSync as writeFileSync21,
+  writeFileSync as writeFileSync22,
   mkdirSync as mkdirSync26,
   mkdtempSync as mkdtempSync2,
   rmSync as rmSync5,
@@ -75847,7 +76018,7 @@ async function startAccountAuthSession(label, opts = {}) {
   const tmuxSocket = `switchroom-${agentName3}`;
   const tmuxSession = `auth-add-${label}-${hexSuffix}`.slice(0, 64);
   try {
-    writeFileSync22(join32(scratchDir, AUTH_TMUX_SESSION_FILE), `${tmuxSocket}
+    writeFileSync23(join32(scratchDir, AUTH_TMUX_SESSION_FILE), `${tmuxSocket}
 ${tmuxSession}`, "utf8");
   } catch {}
   const sessionEnv = {
@@ -78836,7 +79007,7 @@ function startRestartWatchdog(config) {
 }
 
 // gateway/access-store.ts
-import { mkdirSync as mkdirSync28, readFileSync as readFileSync25, renameSync as renameSync12, writeFileSync as writeFileSync23 } from "node:fs";
+import { mkdirSync as mkdirSync28, readFileSync as readFileSync25, renameSync as renameSync13, writeFileSync as writeFileSync24 } from "node:fs";
 
 // gateway/access-validator.ts
 function validateStringArray(field, value, tag = "gateway") {
@@ -78900,7 +79071,7 @@ function createAccessStore(deps) {
       if (err.code === "ENOENT")
         return defaultAccess();
       try {
-        renameSync12(accessFile, `${accessFile}.corrupt-${Date.now()}`);
+        renameSync13(accessFile, `${accessFile}.corrupt-${Date.now()}`);
       } catch {}
       process.stderr.write(`telegram gateway: access.json is corrupt, moved aside. Starting fresh.
 `);
@@ -78945,9 +79116,9 @@ function createAccessStore(deps) {
       return;
     mkdirSync28(stateDir, { recursive: true, mode: 448 });
     const tmp = accessFile + ".tmp";
-    writeFileSync23(tmp, JSON.stringify(a, null, 2) + `
+    writeFileSync24(tmp, JSON.stringify(a, null, 2) + `
 `, { mode: 384 });
-    renameSync12(tmp, accessFile);
+    renameSync13(tmp, accessFile);
   }
   function pruneExpired(a) {
     const now = Date.now();
@@ -79784,10 +79955,10 @@ import {
   mkdirSync as mkdirSync29,
   readFileSync as readFileSync26,
   readdirSync as readdirSync8,
-  renameSync as renameSync13,
+  renameSync as renameSync14,
   statSync as statSync11,
-  unlinkSync as unlinkSync13,
-  writeFileSync as writeFileSync24,
+  unlinkSync as unlinkSync14,
+  writeFileSync as writeFileSync25,
   appendFileSync as appendFileSync5
 } from "node:fs";
 import { join as join34 } from "node:path";
@@ -79891,8 +80062,8 @@ function writeOutboxRecordAtomic(record, stateDir) {
     if (existsSync26(finalPath))
       return true;
     const tmpPath = join34(dir, `.${record.turnNonce}.${process.pid}.tmp`);
-    writeFileSync24(tmpPath, JSON.stringify(record), { mode: 384 });
-    renameSync13(tmpPath, finalPath);
+    writeFileSync25(tmpPath, JSON.stringify(record), { mode: 384 });
+    renameSync14(tmpPath, finalPath);
     return true;
   } catch {
     return false;
@@ -79919,7 +80090,7 @@ function claimRecord(nonce, stateDir) {
   const from = join34(dir, `${nonce}.json`);
   const to = join34(dir, `${nonce}.sending`);
   try {
-    renameSync13(from, to);
+    renameSync14(from, to);
     return to;
   } catch {
     return null;
@@ -79928,12 +80099,12 @@ function claimRecord(nonce, stateDir) {
 function releaseClaim(nonce, stateDir) {
   const dir = resolveOutboxDir(stateDir);
   try {
-    renameSync13(join34(dir, `${nonce}.sending`), join34(dir, `${nonce}.json`));
+    renameSync14(join34(dir, `${nonce}.sending`), join34(dir, `${nonce}.json`));
   } catch {}
 }
 function removeClaimed(nonce, stateDir) {
   try {
-    unlinkSync13(join34(resolveOutboxDir(stateDir), `${nonce}.sending`));
+    unlinkSync14(join34(resolveOutboxDir(stateDir), `${nonce}.sending`));
   } catch {}
 }
 function reclaimStaleSending(stateDir, now = Date.now()) {
@@ -79948,7 +80119,7 @@ function reclaimStaleSending(stateDir, now = Date.now()) {
     try {
       const st = statSync11(join34(dir, f));
       if (now - st.mtimeMs > OUTBOX_SENDING_TIMEOUT_MS) {
-        renameSync13(join34(dir, f), join34(dir, f.replace(/\.sending$/, ".json")));
+        renameSync14(join34(dir, f), join34(dir, f.replace(/\.sending$/, ".json")));
       }
     } catch {}
   }
@@ -80019,17 +80190,17 @@ function compactJournalIfLarge(path2) {
       return;
     const kept = lines.slice(lines.length - JOURNAL_KEEP);
     const tmp = `${path2}.${process.pid}.compact`;
-    writeFileSync24(tmp, kept.join(`
+    writeFileSync25(tmp, kept.join(`
 `) + `
 `, { mode: 384 });
-    renameSync13(tmp, path2);
+    renameSync14(tmp, path2);
   } catch {}
 }
 function clearOutboxRecord(nonce, stateDir) {
   const dir = resolveOutboxDir(stateDir);
   for (const suffix of [".json", ".sending"]) {
     try {
-      unlinkSync13(join34(dir, `${nonce}${suffix}`));
+      unlinkSync14(join34(dir, `${nonce}${suffix}`));
     } catch {}
   }
 }
@@ -80097,8 +80268,8 @@ import {
   existsSync as existsSync27,
   mkdirSync as mkdirSync30,
   readFileSync as readFileSync27,
-  renameSync as renameSync14,
-  writeFileSync as writeFileSync25,
+  renameSync as renameSync15,
+  writeFileSync as writeFileSync26,
   appendFileSync as appendFileSync6
 } from "node:fs";
 import { join as join35 } from "node:path";
@@ -80227,10 +80398,10 @@ function compactIfLarge(path2) {
       return;
     const kept = lines.slice(lines.length - SHOWN_LEDGER_KEEP);
     const tmp = `${path2}.${process.pid}.compact`;
-    writeFileSync25(tmp, kept.join(`
+    writeFileSync26(tmp, kept.join(`
 `) + `
 `, { mode: 384 });
-    renameSync14(tmp, path2);
+    renameSync15(tmp, path2);
   } catch {}
 }
 
@@ -80750,6 +80921,10 @@ var INBOUND_SOURCE_CLASSIFICATION = {
   mental_model_proposal_failed: { decoupledCompletion: false },
   webhook: { decoupledCompletion: false },
   linear: { decoupledCompletion: false },
+  eval_case_applied: { decoupledCompletion: false },
+  eval_case_rejected: { decoupledCompletion: false },
+  eval_case_apply_failed: { decoupledCompletion: false },
+  eval_case_suppressed: { decoupledCompletion: false },
   buzz: { decoupledCompletion: false },
   boot_briefing: { decoupledCompletion: false }
 };
@@ -80988,7 +81163,7 @@ function monotonicNowMs2() {
 }
 
 // silent-end.ts
-import { existsSync as existsSync28, readFileSync as readFileSync28, writeFileSync as writeFileSync26, unlinkSync as unlinkSync14, mkdirSync as mkdirSync31 } from "node:fs";
+import { existsSync as existsSync28, readFileSync as readFileSync28, writeFileSync as writeFileSync27, unlinkSync as unlinkSync15, mkdirSync as mkdirSync31 } from "node:fs";
 import { dirname as dirname17, join as join36 } from "node:path";
 import { homedir as homedir10 } from "node:os";
 var SILENT_END_MAX_RETRIES2 = 2;
@@ -81037,7 +81212,7 @@ function writeSilentEndState2(args, deps) {
   };
   try {
     mkdirSync31(dirname17(statePath), { recursive: true });
-    writeFileSync26(statePath, JSON.stringify(state3), "utf8");
+    writeFileSync27(statePath, JSON.stringify(state3), "utf8");
     emitLog2(deps, `silent-end: wrote state file turnKey=${args.turnKey} retryCount=${retryCount}
 `);
   } catch (err) {
@@ -81053,7 +81228,7 @@ function clearSilentEndState2(turnKey3, deps) {
     const prev = JSON.parse(readFileSync28(statePath, "utf8"));
     if (prev.turnKey != null && prev.turnKey !== turnKey3)
       return;
-    unlinkSync14(statePath);
+    unlinkSync15(statePath);
     emitLog2(deps, `silent-end: cleared state file turnKey=${turnKey3}
 `);
   } catch {}
@@ -83416,7 +83591,7 @@ import {
   openSync as openSync10,
   readFileSync as readFileSync29,
   statSync as statSync13,
-  unlinkSync as unlinkSync15,
+  unlinkSync as unlinkSync16,
   utimesSync
 } from "node:fs";
 import { join as join39 } from "node:path";
@@ -83445,7 +83620,7 @@ function touchTurnActiveMarker(stateDir) {
 }
 function removeTurnActiveMarker(stateDir) {
   try {
-    unlinkSync15(join39(stateDir, TURN_ACTIVE_MARKER_FILE));
+    unlinkSync16(join39(stateDir, TURN_ACTIVE_MARKER_FILE));
   } catch {}
 }
 function readTurnActiveMarkerAgeMs(stateDir, now) {
@@ -85770,7 +85945,7 @@ function resolveAgentDirFromEnv() {
 }
 
 // active-reactions.ts
-import { readFileSync as readFileSync30, writeFileSync as writeFileSync27, renameSync as renameSync15, existsSync as existsSync32, unlinkSync as unlinkSync16 } from "node:fs";
+import { readFileSync as readFileSync30, writeFileSync as writeFileSync28, renameSync as renameSync16, existsSync as existsSync32, unlinkSync as unlinkSync17 } from "node:fs";
 import { join as join40 } from "node:path";
 var ACTIVE_REACTIONS_FILENAME = ".active-reactions.json";
 function reactionsPath(agentDir) {
@@ -85808,15 +85983,15 @@ function writeActiveReactions(agentDir, reactions) {
   const p = reactionsPath(agentDir);
   if (reactions.length === 0) {
     try {
-      unlinkSync16(p);
+      unlinkSync17(p);
     } catch {}
     return;
   }
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
   try {
-    writeFileSync27(tmp, JSON.stringify(reactions) + `
+    writeFileSync28(tmp, JSON.stringify(reactions) + `
 `, "utf-8");
-    renameSync15(tmp, p);
+    renameSync16(tmp, p);
   } catch {}
 }
 function addActiveReaction(agentDir, reaction) {
@@ -85833,12 +86008,12 @@ function removeActiveReaction(agentDir, chatId, messageId) {
 }
 function clearActiveReactions(agentDir) {
   try {
-    unlinkSync16(reactionsPath(agentDir));
+    unlinkSync17(reactionsPath(agentDir));
   } catch {}
 }
 
 // active-reactions.ts
-import { readFileSync as readFileSync31, writeFileSync as writeFileSync28, renameSync as renameSync16, existsSync as existsSync33, unlinkSync as unlinkSync17 } from "node:fs";
+import { readFileSync as readFileSync31, writeFileSync as writeFileSync29, renameSync as renameSync17, existsSync as existsSync33, unlinkSync as unlinkSync18 } from "node:fs";
 import { join as join41 } from "node:path";
 var ACTIVE_REACTIONS_FILENAME2 = ".active-reactions.json";
 function reactionsPath2(agentDir) {
@@ -85874,7 +86049,7 @@ function readActiveReactions2(agentDir) {
 }
 function clearActiveReactions2(agentDir) {
   try {
-    unlinkSync17(reactionsPath2(agentDir));
+    unlinkSync18(reactionsPath2(agentDir));
   } catch {}
 }
 
@@ -88116,15 +88291,15 @@ async function menuWithBannerStatic(deps, banner) {
 }
 
 // gateway/session-model-file.ts
-import { readFileSync as readFileSync33, writeFileSync as writeFileSync29, renameSync as renameSync17, rmSync as rmSync7 } from "node:fs";
+import { readFileSync as readFileSync33, writeFileSync as writeFileSync30, renameSync as renameSync18, rmSync as rmSync7 } from "node:fs";
 import { join as join43 } from "node:path";
 var SESSION_MODEL_FILE = ".session-model";
 var CONFIGURED_DEFAULT_MODEL_FILE = ".configured-default-model";
 var SESSION_MODEL_BOOT_ATTEMPTS_FILE = ".session-model-boot-attempts";
 function atomicWrite(path2, content3) {
   const tmp = `${path2}.tmp-${process.pid}-${Date.now()}`;
-  writeFileSync29(tmp, content3, "utf8");
-  renameSync17(tmp, path2);
+  writeFileSync30(tmp, content3, "utf8");
+  renameSync18(tmp, path2);
 }
 function serializeSessionModel(rec) {
   return `${JSON.stringify({
@@ -88652,7 +88827,7 @@ var AUDIT_ROOT = join45(homedir11(), ".switchroom", "audit");
 
 // ../src/agents/profiles.ts
 var import_handlebars = __toESM(require_lib(), 1);
-import { readFileSync as readFileSync36, writeFileSync as writeFileSync31, existsSync as existsSync37, readdirSync as readdirSync9, statSync as statSync14, copyFileSync, mkdirSync as mkdirSync33, realpathSync as realpathSync4 } from "node:fs";
+import { readFileSync as readFileSync36, writeFileSync as writeFileSync32, existsSync as existsSync37, readdirSync as readdirSync9, statSync as statSync14, copyFileSync, mkdirSync as mkdirSync33, realpathSync as realpathSync4 } from "node:fs";
 import { resolve as resolve8, join as join46, sep as pathSep } from "node:path";
 function resolveProfilesRootDetailed() {
   return resolveShippedAsset(PROFILES_ASSET, {
@@ -88670,7 +88845,7 @@ import_handlebars.default.registerHelper("isNumber", (value) => {
   return typeof value === "number" && Number.isFinite(value);
 });
 var SHARED_FRAGMENTS_DIR = resolve8(PROFILES_ROOT, "_shared");
-var SHARED_FRAGMENTS = ["vault-protocol", "agent-self-service", "execution-discipline", "reply-discipline", "dev-protocol"];
+var SHARED_FRAGMENTS = ["vault-protocol", "agent-self-service", "execution-discipline", "reply-discipline", "dev-protocol", "local-time"];
 for (const name of SHARED_FRAGMENTS) {
   const fragPath = join46(SHARED_FRAGMENTS_DIR, `${name}.md.hbs`);
   if (existsSync37(fragPath)) {
@@ -90623,7 +90798,7 @@ function numField(obj, key) {
 }
 
 // gateway/context-occupancy.ts
-import { mkdirSync as mkdirSync34, writeFileSync as writeFileSync32 } from "node:fs";
+import { mkdirSync as mkdirSync34, writeFileSync as writeFileSync33 } from "node:fs";
 import { join as join47 } from "node:path";
 var CONTEXT_OCCUPANCY_FILENAME = "context-occupancy.json";
 var TIGHT_FRACTION = 0.8;
@@ -90649,7 +90824,7 @@ function writeContextOccupancySnapshot(stateDir, snapshot, deps) {
   try {
     const path2 = join47(stateDir, CONTEXT_OCCUPANCY_FILENAME);
     (deps?.mkdir ?? ((p, o) => mkdirSync34(p, o)))(stateDir, { recursive: true });
-    (deps?.writeFile ?? ((p, d) => writeFileSync32(p, d)))(path2, JSON.stringify(snapshot, null, 2) + `
+    (deps?.writeFile ?? ((p, d) => writeFileSync33(p, d)))(path2, JSON.stringify(snapshot, null, 2) + `
 `);
   } catch {}
 }
@@ -92031,7 +92206,7 @@ import {
   openSync as openSync11,
   readdirSync as readdirSync10,
   statSync as statSync15,
-  writeFileSync as writeFileSync33
+  writeFileSync as writeFileSync34
 } from "node:fs";
 import { dirname as dirname21, join as join51, relative as relative2, sep as sep5 } from "node:path";
 var NOFOLLOW2 = constants5.O_NOFOLLOW ?? 0;
@@ -92114,7 +92289,7 @@ function mkdirStateSync2(path2, options = { recursive: true }, log = defaultLog3
 function writeStateFileSync2(path2, data, options, log = defaultLog3) {
   const owner = resolveStateOwner2(dirname21(path2));
   if (!owner) {
-    writeFileSync33(path2, data, options);
+    writeFileSync34(path2, data, options);
     return;
   }
   const mode = options?.mode ?? 438;
@@ -92122,7 +92297,7 @@ function writeStateFileSync2(path2, data, options, log = defaultLog3) {
   let fd = null;
   try {
     fd = openSync11(path2, constants5.O_WRONLY | constants5.O_CREAT | constants5.O_TRUNC | NOFOLLOW2, mode);
-    writeFileSync33(fd, buf);
+    writeFileSync34(fd, buf);
     try {
       fchownSync4(fd, owner.uid, owner.gid);
     } catch (err) {
@@ -92136,7 +92311,7 @@ function writeStateFileSync2(path2, data, options, log = defaultLog3) {
       fd = null;
     }
     noteFailure2("write", path2, err, log);
-    writeFileSync33(path2, data, options);
+    writeFileSync34(path2, data, options);
     return;
   } finally {
     if (fd !== null) {
@@ -92261,7 +92436,7 @@ function adoptAndReport(path2, owner, log) {
 
 // gateway/webhook-ingest-server.ts
 import net4 from "node:net";
-import { chmodSync as chmodSync10, existsSync as existsSync43, unlinkSync as unlinkSync18 } from "node:fs";
+import { chmodSync as chmodSync10, existsSync as existsSync43, unlinkSync as unlinkSync19 } from "node:fs";
 var MAX_REQUEST_BYTES = 1024 * 1024;
 function fdOf(conn) {
   const handle = conn._handle;
@@ -92274,7 +92449,7 @@ function startWebhookIngestServer(opts) {
   const allowed = new Set(opts.allowedUids);
   try {
     if (existsSync43(opts.socketPath))
-      unlinkSync18(opts.socketPath);
+      unlinkSync19(opts.socketPath);
   } catch (err) {
     log(`webhook-ingest-server: could not unlink stale socket: ${err.message}
 `);
@@ -92367,7 +92542,7 @@ function startWebhookIngestServer(opts) {
       } catch {}
       try {
         if (existsSync43(opts.socketPath))
-          unlinkSync18(opts.socketPath);
+          unlinkSync19(opts.socketPath);
       } catch {}
     }
   };
@@ -92379,7 +92554,7 @@ import { join as join55 } from "path";
 import { homedir as homedir16 } from "os";
 
 // ../src/web/webhook-handler.ts
-import { appendFileSync as appendFileSync9, existsSync as existsSync45, mkdirSync as mkdirSync38, readFileSync as readFileSync41, writeFileSync as writeFileSync34 } from "fs";
+import { appendFileSync as appendFileSync9, existsSync as existsSync45, mkdirSync as mkdirSync38, readFileSync as readFileSync41, writeFileSync as writeFileSync35 } from "fs";
 import { join as join53 } from "path";
 
 // ../src/util/log-rotation.ts
@@ -92734,7 +92909,7 @@ function saveDedupFile(path3, deliveries, now) {
   }
   const sorted = Object.entries(pruned).sort((a, b) => b[1] - a[1]).slice(0, DEDUP_MAX);
   const final = Object.fromEntries(sorted);
-  writeFileSync34(path3, JSON.stringify({ deliveries: final }), {
+  writeFileSync35(path3, JSON.stringify({ deliveries: final }), {
     mode: 384
   });
 }
@@ -92764,7 +92939,7 @@ var tokenBuckets = new Map;
 var throttleIssueWindow = new Map;
 
 // ../src/web/webhook-dispatch.ts
-import { existsSync as existsSync46, mkdirSync as mkdirSync39, readFileSync as readFileSync42, writeFileSync as writeFileSync35 } from "fs";
+import { existsSync as existsSync46, mkdirSync as mkdirSync39, readFileSync as readFileSync42, writeFileSync as writeFileSync36 } from "fs";
 import { join as join54 } from "path";
 import { homedir as homedir15 } from "os";
 
@@ -93074,7 +93249,7 @@ function loadCooldownFile(path3) {
 }
 function saveCooldownFile(path3, dispatches) {
   try {
-    writeFileSync35(path3, JSON.stringify({ dispatches }), {
+    writeFileSync36(path3, JSON.stringify({ dispatches }), {
       mode: 384
     });
   } catch {}
@@ -93420,7 +93595,7 @@ function recordWebhookEvent(rec, deps = {}) {
 
 // gateway/ipc-server.ts
 init_format();
-import { renameSync as renameSync19, unlinkSync as unlinkSync20, chmodSync as chmodSync11 } from "fs";
+import { renameSync as renameSync20, unlinkSync as unlinkSync21, chmodSync as chmodSync11 } from "fs";
 var MAX_BUFFER_SIZE = 1024 * 1024;
 var VALID_OPERATOR_KINDS = new Set(OPERATOR_EVENT_KINDS);
 var AGENT_NAME_RE3 = /^[a-z0-9][a-z0-9_-]{0,50}$/;
@@ -93674,10 +93849,10 @@ function createIpcServer(options) {
     return false;
   };
   try {
-    renameSync19(socketPath, socketPath + ".bak");
+    renameSync20(socketPath, socketPath + ".bak");
   } catch {}
   try {
-    unlinkSync20(socketPath + ".bak");
+    unlinkSync21(socketPath + ".bak");
   } catch {}
   const clients = new Set;
   const agentIndex = new Map;
@@ -94131,7 +94306,7 @@ function createIpcServer(options) {
       clientBySocketId.clear();
       server.stop(true);
       try {
-        renameSync19(socketPath, socketPath + ".bak");
+        renameSync20(socketPath, socketPath + ".bak");
       } catch {}
     }
   };
@@ -94705,8 +94880,132 @@ function buildDiffPreviewCard(input) {
   return { text: text4, reply_markup: kb };
 }
 
+// gateway/approval-outcome-sources.ts
+var APPROVAL_OUTCOME_SOURCES = Object.freeze(new Set([
+  "vault_grant_approved",
+  "vault_grant_denied",
+  "vault_grant_timeout",
+  "vault_save_completed",
+  "vault_save_discarded",
+  "vault_save_failed",
+  "vault_save_timeout",
+  "secret_provided",
+  "secret_declined",
+  "secret_provide_failed",
+  "secret_request_timeout",
+  "mental_model_proposal_applied",
+  "mental_model_proposal_denied",
+  "mental_model_proposal_failed",
+  "mental_model_propose_timeout",
+  "skill_proposal_apply",
+  "eval_case_applied",
+  "eval_case_rejected",
+  "eval_case_apply_failed",
+  "eval_case_suppressed"
+]));
+var APPROVAL_OUTCOME_DROPPED_SOURCE = "approval_outcome_dropped";
+function isApprovalOutcome(msg) {
+  const meta = msg.meta;
+  if (meta == null)
+    return false;
+  if (meta.source != null && APPROVAL_OUTCOME_SOURCES.has(meta.source))
+    return true;
+  return meta.button_callback === "true";
+}
+function approvalOutcomeLabel(msg) {
+  const src = msg.meta?.source;
+  if (src != null && src !== "")
+    return src;
+  if (msg.meta?.button_callback === "true")
+    return "button_callback";
+  return "-";
+}
+function buildApprovalOutcomeDroppedInbound(opts) {
+  const ts = opts.nowMs ?? Date.now();
+  const list2 = opts.sources.length > 0 ? opts.sources.join(", ") : "unknown";
+  const plural = opts.sources.length === 1 ? "an approval outcome" : "approval outcomes";
+  const msg = {
+    type: "inbound",
+    chatId: opts.chatId,
+    ...opts.threadId != null ? { threadId: opts.threadId } : {},
+    messageId: ts,
+    user: "gateway",
+    userId: 0,
+    ts,
+    text: `\u26a0\ufe0f Your inbound buffer overflowed while every queued message was ${plural}, ` + `so the oldest had to be dropped: ${list2}. Do NOT keep waiting on it \u2014 ` + `re-check the underlying state directly (e.g. retry the vault read to see ` + `whether the grant exists) and tell the operator plainly what was lost.`,
+    meta: {
+      source: APPROVAL_OUTCOME_DROPPED_SOURCE,
+      agent: opts.agent,
+      ...opts.threadId != null ? { message_thread_id: String(opts.threadId) } : {},
+      dropped_sources: list2,
+      dropped_count: String(opts.sources.length)
+    }
+  };
+  return msg;
+}
+var APPROVAL_OUTCOME_NOTICE_HOPS = 2;
+function createApprovalOutcomeDropNotifier(opts) {
+  const log = opts.log ?? ((line) => process.stderr.write(line));
+  const defer = opts.defer ?? ((fn) => queueMicrotask(fn));
+  const hops = opts.hops ?? APPROVAL_OUTCOME_NOTICE_HOPS;
+  const pending = new Map;
+  const scheduled = new Set;
+  return (agent, evicted) => {
+    const label = approvalOutcomeLabel(evicted);
+    log(`telegram gateway: APPROVAL-OUTCOME-DROPPED agent=${agent} source=${label} ` + `chat=${evicted.chatId} ts=${evicted.ts}
+`);
+    const list2 = pending.get(agent) ?? [];
+    list2.push(label);
+    pending.set(agent, list2);
+    if (scheduled.has(agent))
+      return;
+    scheduled.add(agent);
+    const chatId = evicted.chatId;
+    const threadId = evicted.threadId;
+    const flush = (budget) => {
+      const sources = [...pending.get(agent) ?? []];
+      const before = sources.length;
+      try {
+        opts.push(agent, buildApprovalOutcomeDroppedInbound({
+          agent,
+          chatId,
+          ...threadId != null ? { threadId } : {},
+          sources,
+          ...opts.nowMs != null ? { nowMs: opts.nowMs() } : {}
+        }));
+      } catch (e) {
+        log(`telegram gateway: APPROVAL-OUTCOME-DROPPED notice push failed: ${String(e)}
+`);
+      } finally {
+        scheduled.delete(agent);
+      }
+      if (budget > 0 && (pending.get(agent)?.length ?? 0) > before) {
+        scheduled.add(agent);
+        defer(() => flush(budget - 1));
+      } else {
+        pending.delete(agent);
+      }
+    };
+    defer(() => flush(hops));
+  };
+}
+
 // gateway/pending-inbound-buffer.ts
 var DEFAULT_PENDING_INBOUND_CAP = 32;
+var APPROVAL_OUTCOME_PROTECTION_MS = 15 * 60 * 1000;
+function selectEvictionVictim(q, nowMs3, protectMaxAgeMs = APPROVAL_OUTCOME_PROTECTION_MS) {
+  for (let i = 0;i < q.length; i++) {
+    if (!isApprovalOutcome(q[i]))
+      return { index: i, reason: "non-outcome" };
+  }
+  for (let i = 0;i < q.length; i++) {
+    const ts = q[i].ts;
+    if (typeof ts === "number" && Number.isFinite(ts) && nowMs3 - ts >= protectMaxAgeMs) {
+      return { index: i, reason: "stale-outcome" };
+    }
+  }
+  return { index: 0, reason: "all-outcomes" };
+}
 function redeliverBufferedInbound(buffer, agent, send, spool, onDelivered) {
   const pending = buffer.drain(agent);
   let redelivered = 0;
@@ -94815,8 +95114,10 @@ function createPendingInboundBuffer(opts = {}) {
   const cap = opts.capPerAgent ?? DEFAULT_PENDING_INBOUND_CAP;
   const log = opts.log ?? ((line) => process.stderr.write(line));
   const spool = opts.spool;
+  const now = opts.now ?? (() => Date.now());
+  const protectionMs = opts.approvalOutcomeProtectionMs ?? APPROVAL_OUTCOME_PROTECTION_MS;
   const queues = new Map;
-  return {
+  const buffer = {
     push(agent, msg) {
       let q = queues.get(agent);
       if (q == null) {
@@ -94825,14 +95126,19 @@ function createPendingInboundBuffer(opts = {}) {
       }
       let evicted = false;
       if (q.length >= cap) {
-        const dropped = q.shift();
+        const { index: index2, reason } = selectEvictionVictim(q, now(), protectionMs);
+        const dropped = q.splice(index2, 1)[0];
         evicted = true;
-        log(`pending-inbound-buffer: agent=${agent} cap=${cap} reached \u2014 ` + `dropped oldest entry source=${dropped?.meta?.source ?? "-"} ts=${dropped?.ts ?? "-"}
+        log(`pending-inbound-buffer: agent=${agent} cap=${cap} reached \u2014 ` + `dropped entry idx=${index2} reason=${reason} ` + `source=${dropped?.meta?.source ?? "-"} ts=${dropped?.ts ?? "-"}
 `);
-        if (dropped != null && opts.onEvict != null) {
-          try {
-            opts.onEvict(agent, dropped);
-          } catch {}
+        if (dropped != null) {
+          const critical = reason !== "non-outcome";
+          const cb = critical ? onEvictCritical : opts.onEvict;
+          if (cb != null) {
+            try {
+              cb(agent, dropped);
+            } catch {}
+          }
         }
       }
       q.push(msg);
@@ -94866,6 +95172,13 @@ function createPendingInboundBuffer(opts = {}) {
     },
     beforeRedeliver: opts.beforeRedeliver
   };
+  const onEvictCritical = opts.onEvictCritical ?? createApprovalOutcomeDropNotifier({
+    push: (a, m) => {
+      buffer.push(a, m);
+    },
+    log
+  });
+  return buffer;
 }
 
 // gateway/represent-guard.ts
@@ -94928,6 +95241,7 @@ function makeSessionBusyDrainDeferral(boundMs, staleGapMs = DEFAULT_DRAIN_DEFER_
 }
 
 // gateway/pending-inbound-buffer.ts
+var APPROVAL_OUTCOME_PROTECTION_MS2 = 15 * 60 * 1000;
 function redeliverBufferedInbound2(buffer, agent, send, spool, onDelivered) {
   const pending = buffer.drain(agent);
   let redelivered = 0;
@@ -97832,7 +98146,7 @@ function purgeStaleTurnsForChat(chatId, keys, purger, isStale = () => true) {
 }
 
 // gateway/compaction-marker.ts
-import { statSync as statSync17, unlinkSync as unlinkSync21 } from "node:fs";
+import { statSync as statSync17, unlinkSync as unlinkSync22 } from "node:fs";
 import { homedir as homedir17 } from "node:os";
 import { join as join56 } from "node:path";
 var COMPACTION_MARKER_FILE = "compaction-in-flight.json";
@@ -97849,7 +98163,7 @@ function readCompactionMarkerAgeMs(stateDir, now) {
 }
 function removeCompactionMarker(stateDir) {
   try {
-    unlinkSync21(join56(stateDir, COMPACTION_MARKER_FILE));
+    unlinkSync22(join56(stateDir, COMPACTION_MARKER_FILE));
   } catch {}
 }
 
@@ -98609,6 +98923,26 @@ function maybeFireWarmup(ctx) {
 }
 
 // gateway/self-improve-proposal-wiring.ts
+function buildEvalCaseSuppressedInbound(opts) {
+  const ts = opts.nowMs ?? Date.now();
+  return {
+    type: "inbound",
+    chatId: opts.chatId,
+    ...opts.threadId != null ? { threadId: opts.threadId } : {},
+    messageId: ts,
+    user: "self-improve",
+    userId: 0,
+    ts,
+    text: `\u2139\ufe0f Your proposed eval case for \`${opts.skillSlug}\` was NOT posted as a ` + `card: the operator already dismissed this exact case, and the dismissal ` + `is still in effect. This is EXPECTED and is not an error or a failure on ` + `your part \u2014 nothing was written and no card is pending, so do NOT wait ` + `for an approval tap. Do NOT re-propose this case. Carry on with the ` + `original task without it.`,
+    meta: {
+      source: "eval_case_suppressed",
+      agent: opts.agent,
+      ...opts.threadId != null ? { message_thread_id: String(opts.threadId) } : {},
+      skill_slug: opts.skillSlug,
+      fingerprint: opts.fingerprint
+    }
+  };
+}
 function handlePostSkillProposal(msg, deps) {
   const { bot, assertAllowedChat, swallowingApiCall } = deps;
   const self = process.env.SWITCHROOM_AGENT_NAME;
@@ -98665,8 +98999,28 @@ function handlePostSkillProposal(msg, deps) {
   process.stderr.write(`telegram gateway: post_skill_proposal agent=${msg.agentName} chat=${msg.chatId} ` + `proposal=${proposal.id} slug=${proposal.skill_slug} new=${proposal.is_new}
 `);
 }
+function isEvalCaseProposalSuppressed(stateDir, candidate, opts = {}) {
+  if (typeof candidate.fingerprint !== "string" || candidate.fingerprint.length === 0) {
+    return false;
+  }
+  const now = (opts.now ?? Date.now)();
+  const ttl = opts.ttlMs ?? REJECTION_TTL_MS;
+  for (const p of readEvalCaseProposals(stateDir)) {
+    if (p.status !== "rejected")
+      continue;
+    if (p.skill_slug !== candidate.skillSlug)
+      continue;
+    if (p.fingerprint !== candidate.fingerprint)
+      continue;
+    const age = now - new Date(p.created_at).getTime();
+    if (!Number.isFinite(age) || age > ttl)
+      continue;
+    return true;
+  }
+  return false;
+}
 function handlePostEvalCaseProposal(msg, deps) {
-  const { bot, assertAllowedChat, swallowingApiCall } = deps;
+  const { bot, assertAllowedChat, swallowingApiCall, deliverResumeSyntheticOrBuffer } = deps;
   const self = process.env.SWITCHROOM_AGENT_NAME;
   if (self && msg.agentName !== self) {
     process.stderr.write(`telegram gateway: post_eval_case_proposal rejected \u2014 agent mismatch (${msg.agentName} != ${self})
@@ -98683,6 +99037,21 @@ function handlePostEvalCaseProposal(msg, deps) {
   const stateDir = process.env.TELEGRAM_STATE_DIR;
   if (stateDir == null || stateDir.length === 0) {
     process.stderr.write(`telegram gateway: post_eval_case_proposal: TELEGRAM_STATE_DIR unset, skipping
+`);
+    return;
+  }
+  if (isEvalCaseProposalSuppressed(stateDir, {
+    skillSlug: msg.skillSlug,
+    fingerprint: msg.fingerprint
+  })) {
+    const delivered = deliverResumeSyntheticOrBuffer(msg.agentName, buildEvalCaseSuppressedInbound({
+      agent: msg.agentName,
+      chatId: msg.chatId,
+      ...msg.threadId != null ? { threadId: msg.threadId } : {},
+      skillSlug: msg.skillSlug,
+      fingerprint: msg.fingerprint
+    }));
+    process.stderr.write(`telegram gateway: post_eval_case_proposal suppressed (dismissed before) ` + `slug=${msg.skillSlug} fp=${msg.fingerprint} delivered=${delivered}
 `);
     return;
   }
@@ -99214,15 +99583,15 @@ function escapeBody2(s) {
 }
 
 // gateway/pid-file.ts
-import { writeFileSync as writeFileSync36, readFileSync as readFileSync43, unlinkSync as unlinkSync22, renameSync as renameSync20 } from "node:fs";
+import { writeFileSync as writeFileSync37, readFileSync as readFileSync43, unlinkSync as unlinkSync23, renameSync as renameSync21 } from "node:fs";
 function writePidFile(path3, record) {
   const tmp = `${path3}.tmp-${process.pid}-${Date.now()}`;
-  writeFileSync36(tmp, JSON.stringify(record), "utf-8");
-  renameSync20(tmp, path3);
+  writeFileSync37(tmp, JSON.stringify(record), "utf-8");
+  renameSync21(tmp, path3);
 }
 function clearPidFile(path3) {
   try {
-    unlinkSync22(path3);
+    unlinkSync23(path3);
   } catch {}
 }
 
@@ -99439,11 +99808,11 @@ function safeCount(fn) {
 }
 
 // gateway/session-marker.ts
-import { writeFileSync as writeFileSync37, readFileSync as readFileSync45, renameSync as renameSync21, unlinkSync as unlinkSync23 } from "node:fs";
+import { writeFileSync as writeFileSync38, readFileSync as readFileSync45, renameSync as renameSync22, unlinkSync as unlinkSync24 } from "node:fs";
 function writeSessionMarker(path3, marker) {
   const tmp = `${path3}.tmp-${process.pid}-${Date.now()}`;
-  writeFileSync37(tmp, JSON.stringify(marker), "utf-8");
-  renameSync21(tmp, path3);
+  writeFileSync38(tmp, JSON.stringify(marker), "utf-8");
+  renameSync22(tmp, path3);
 }
 function readSessionMarker(path3) {
   try {
@@ -99469,12 +99838,12 @@ function shouldFireRestartBanner(input) {
 }
 
 // gateway/clean-shutdown-marker.ts
-import { writeFileSync as writeFileSync38, readFileSync as readFileSync46, renameSync as renameSync22, unlinkSync as unlinkSync24 } from "node:fs";
+import { writeFileSync as writeFileSync39, readFileSync as readFileSync46, renameSync as renameSync23, unlinkSync as unlinkSync25 } from "node:fs";
 var DEFAULT_MAX_AGE_MS = 60000;
 function writeCleanShutdownMarker(path3, marker) {
   const tmp = `${path3}.tmp-${process.pid}-${Date.now()}`;
-  writeFileSync38(tmp, JSON.stringify(marker), "utf-8");
-  renameSync22(tmp, path3);
+  writeFileSync39(tmp, JSON.stringify(marker), "utf-8");
+  renameSync23(tmp, path3);
 }
 function readCleanShutdownMarker(path3) {
   try {
@@ -99493,7 +99862,7 @@ function readCleanShutdownMarker(path3) {
 }
 function clearCleanShutdownMarker(path3) {
   try {
-    unlinkSync24(path3);
+    unlinkSync25(path3);
   } catch {}
 }
 function shouldSuppressRecoveryBanner(marker, now, maxAgeMs = DEFAULT_MAX_AGE_MS) {
@@ -101409,31 +101778,31 @@ function startSubagentWatcher(config) {
 // ../src/worktree/registry.ts
 import {
   mkdirSync as mkdirSync41,
-  writeFileSync as writeFileSync39,
+  writeFileSync as writeFileSync40,
   readFileSync as readFileSync48,
   readdirSync as readdirSync13,
-  unlinkSync as unlinkSync25,
+  unlinkSync as unlinkSync26,
   existsSync as existsSync48,
-  renameSync as renameSync23
+  renameSync as renameSync24
 } from "node:fs";
 import { join as join58, resolve as resolve10 } from "node:path";
 import { homedir as homedir18 } from "node:os";
-function registryDir() {
+function registryDir2() {
   return resolve10(process.env.SWITCHROOM_WORKTREE_DIR ?? join58(homedir18(), ".switchroom", "worktrees"));
 }
 function recordPath(id) {
-  return join58(registryDir(), `${id}.json`);
+  return join58(registryDir2(), `${id}.json`);
 }
 function ensureDir4() {
-  mkdirSync41(registryDir(), { recursive: true });
+  mkdirSync41(registryDir2(), { recursive: true });
 }
-function writeRecord(record) {
+function writeRecord2(record) {
   ensureDir4();
   const target = recordPath(record.id);
   const tmp = `${target}.tmp${process.pid}`;
-  writeFileSync39(tmp, JSON.stringify(record, null, 2) + `
+  writeFileSync40(tmp, JSON.stringify(record, null, 2) + `
 `, { mode: 384 });
-  renameSync23(tmp, target);
+  renameSync24(tmp, target);
 }
 function readRecord(id) {
   const path3 = recordPath(id);
@@ -101446,7 +101815,7 @@ function readRecord(id) {
 }
 function listRecords() {
   ensureDir4();
-  const dir = registryDir();
+  const dir = registryDir2();
   const records = [];
   for (const entry of readdirSync13(dir)) {
     if (!entry.endsWith(".json"))
@@ -101465,7 +101834,7 @@ function touchHeartbeat(id, onAfterRead) {
   onAfterRead?.();
   if (!recordExists(id))
     return;
-  writeRecord({ ...rec, heartbeatAt: new Date().toISOString() });
+  writeRecord2({ ...rec, heartbeatAt: new Date().toISOString() });
 }
 function recordExists(id) {
   return existsSync48(recordPath(id));
@@ -101845,7 +102214,7 @@ function maybeRenderUpdateAnnouncement(opts = {}) {
 
 // issues-card.ts
 init_card_format();
-import { readFileSync as readFileSync56, writeFileSync as writeFileSync44 } from "node:fs";
+import { readFileSync as readFileSync56, writeFileSync as writeFileSync45 } from "node:fs";
 var SEVERITY_EMOJI = {
   info: "\u2139\ufe0f",
   warn: "\u26a0\ufe0f",
@@ -101953,7 +102322,7 @@ function readPersistedMessageId(path3, log) {
 }
 function writePersistedMessageId(path3, messageId, log) {
   try {
-    writeFileSync44(path3, JSON.stringify({ messageId }) + `
+    writeFileSync45(path3, JSON.stringify({ messageId }) + `
 `, { mode: 384 });
   } catch (err) {
     log(`issues-card: persist write failed (${err.message})`);
@@ -102057,10 +102426,10 @@ import {
   openSync as openSync15,
   readdirSync as readdirSync15,
   readFileSync as readFileSync57,
-  renameSync as renameSync26,
+  renameSync as renameSync27,
   statSync as statSync20,
-  unlinkSync as unlinkSync26,
-  writeFileSync as writeFileSync45,
+  unlinkSync as unlinkSync27,
+  writeFileSync as writeFileSync46,
   writeSync as writeSync8
 } from "node:fs";
 import { join as join64 } from "node:path";
@@ -102143,8 +102512,8 @@ function writeAll(stateDir, events) {
   const body = events.length === 0 ? "" : events.map((e) => JSON.stringify(e)).join(`
 `) + `
 `;
-  writeFileSync45(tmp, body, "utf-8");
-  renameSync26(tmp, path3);
+  writeFileSync46(tmp, body, "utf-8");
+  renameSync27(tmp, path3);
 }
 var ORPHAN_TMP_TTL_MS = 60000;
 var TMP_PREFIX = `${ISSUES_FILE}.tmp-`;
@@ -102163,7 +102532,7 @@ function sweepOrphanTmpFiles(stateDir) {
     try {
       const stat = statSync20(tmpPath2);
       if (stat.mtimeMs < cutoff) {
-        unlinkSync26(tmpPath2);
+        unlinkSync27(tmpPath2);
       }
     } catch {}
   }
@@ -102199,7 +102568,7 @@ function withLock(stateDir, fn) {
       closeSync15(fd);
     } catch {}
     try {
-      unlinkSync26(lockPath);
+      unlinkSync27(lockPath);
     } catch {}
   }
 }
@@ -102213,13 +102582,13 @@ function tryStealStaleLock(lockPath) {
   const pid = Number(pidStr);
   if (!Number.isFinite(pid) || pid <= 0) {
     try {
-      unlinkSync26(lockPath);
+      unlinkSync27(lockPath);
     } catch {}
     return true;
   }
   if (pid === process.pid) {
     try {
-      unlinkSync26(lockPath);
+      unlinkSync27(lockPath);
     } catch {}
     return true;
   }
@@ -102234,7 +102603,7 @@ function tryStealStaleLock(lockPath) {
       return false;
   }
   try {
-    unlinkSync26(lockPath);
+    unlinkSync27(lockPath);
   } catch {}
   return true;
 }
@@ -103436,7 +103805,7 @@ function isDiffPreApproved(agentName3, unifiedDiff, deps) {
 
 // credits-watch.ts
 init_card_format();
-import { readFileSync as readFileSync58, writeFileSync as writeFileSync46, existsSync as existsSync56, mkdirSync as mkdirSync47 } from "fs";
+import { readFileSync as readFileSync58, writeFileSync as writeFileSync47, existsSync as existsSync56, mkdirSync as mkdirSync47 } from "fs";
 import { join as join67 } from "path";
 var STATE_FILE = "credits-watch.json";
 var DEFAULT_CREDIT_FATAL_REASONS = new Set;
@@ -103560,14 +103929,14 @@ function loadCreditState(stateDir) {
 function saveCreditState(stateDir, state7) {
   mkdirSync47(stateDir, { recursive: true });
   const path3 = join67(stateDir, STATE_FILE);
-  writeFileSync46(path3, JSON.stringify(state7, null, 2) + `
+  writeFileSync47(path3, JSON.stringify(state7, null, 2) + `
 `, { mode: 384 });
 }
 
 // quota-watch.ts
 init_auth_snapshot_format();
 init_card_format();
-import { readFileSync as readFileSync59, writeFileSync as writeFileSync47, existsSync as existsSync57, mkdirSync as mkdirSync48 } from "fs";
+import { readFileSync as readFileSync59, writeFileSync as writeFileSync48, existsSync as existsSync57, mkdirSync as mkdirSync48 } from "fs";
 import { join as join68 } from "path";
 var STATE_FILE2 = "quota-watch.json";
 function emptyQuotaWatchState() {
@@ -103829,7 +104198,7 @@ function loadQuotaWatchState(stateDir) {
 function saveQuotaWatchState(stateDir, state7) {
   mkdirSync48(stateDir, { recursive: true });
   const path3 = join68(stateDir, STATE_FILE2);
-  writeFileSync47(path3, JSON.stringify(state7, null, 2) + `
+  writeFileSync48(path3, JSON.stringify(state7, null, 2) + `
 `, { mode: 384 });
 }
 function patchQuotaWatchState(current, accountLabel, accountState) {
@@ -103882,7 +104251,7 @@ import {
   openSync as openSync16,
   readFileSync as readFileSync60,
   statSync as statSync22,
-  unlinkSync as unlinkSync27,
+  unlinkSync as unlinkSync28,
   utimesSync as utimesSync2
 } from "node:fs";
 import { join as join69 } from "node:path";
@@ -103891,7 +104260,7 @@ var TURN_ACTIVE_HARD_TTL_MS2 = 10 * 60000;
 var TURN_ACTIVE_IDLE_SWEEP_MS = 60000;
 function removeTurnActiveMarker2(stateDir) {
   try {
-    unlinkSync27(join69(stateDir, TURN_ACTIVE_MARKER_FILE2));
+    unlinkSync28(join69(stateDir, TURN_ACTIVE_MARKER_FILE2));
   } catch {}
 }
 function sweepStaleTurnActiveMarker(stateDir, opts) {
@@ -103910,7 +104279,7 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
     try {
       payload = readFileSync60(path3, "utf8");
     } catch {}
-    unlinkSync27(path3);
+    unlinkSync28(path3);
     if (opts.onRemove) {
       try {
         opts.onRemove({
@@ -103972,9 +104341,9 @@ import {
   fsyncSync as fsyncSync6,
   openSync as openSync17,
   readFileSync as readFileSync61,
-  renameSync as renameSync27,
-  unlinkSync as unlinkSync28,
-  writeFileSync as writeFileSync48
+  renameSync as renameSync28,
+  unlinkSync as unlinkSync29,
+  writeFileSync as writeFileSync49
 } from "node:fs";
 import { join as join71 } from "node:path";
 var BOOT_BEACON_FILE = "gateway-beacon.json";
@@ -104081,12 +104450,12 @@ function writeBootBeaconFile(stateDir, beacon) {
   try {
     mkdirStateSync(stateDir, { recursive: true, mode: 448 });
     fd = openSync17(tmp, "w", 384);
-    writeFileSync48(fd, serializeBootBeacon(beacon));
+    writeFileSync49(fd, serializeBootBeacon(beacon));
     adoptStateOwnershipFd(fd, stateDir);
     fsyncSync6(fd);
     closeSync17(fd);
     fd = undefined;
-    renameSync27(tmp, path3);
+    renameSync28(tmp, path3);
     return true;
   } catch {
     if (fd !== undefined) {
@@ -104095,7 +104464,7 @@ function writeBootBeaconFile(stateDir, beacon) {
       } catch {}
     }
     try {
-      unlinkSync28(tmp);
+      unlinkSync29(tmp);
     } catch {}
     return false;
   }
@@ -104467,10 +104836,10 @@ function startOutboxSweep(deps) {
 }
 
 // ../src/build-info.ts
-var VERSION2 = "0.21.7";
-var COMMIT_SHA = "e4e50f84";
-var COMMIT_DATE = "2026-08-11T23:08:27Z";
-var LATEST_PR = 4613;
+var VERSION2 = "0.21.8";
+var COMMIT_SHA = "d778afb6";
+var COMMIT_DATE = "2026-08-13T03:44:10Z";
+var LATEST_PR = 4677;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -105852,7 +106221,7 @@ function selectResumeBuilder(endedVia, opts) {
 }
 
 // gateway/boot-briefing-wiring.ts
-import { existsSync as existsSync60, readFileSync as readFileSync63, writeFileSync as writeFileSync49 } from "node:fs";
+import { existsSync as existsSync60, readFileSync as readFileSync63, writeFileSync as writeFileSync50 } from "node:fs";
 import { join as join74 } from "node:path";
 init_history();
 
@@ -106208,7 +106577,7 @@ async function maybeQueueBootBriefing(opts) {
       if (!bootId)
         return;
       try {
-        writeFileSync49(genMarkerPath, `${bootId}
+        writeFileSync50(genMarkerPath, `${bootId}
 `);
       } catch {}
     };
@@ -106282,7 +106651,7 @@ async function maybeQueueBootBriefing(opts) {
 }
 
 // gateway/pending-turn-env.ts
-import { existsSync as existsSync61, renameSync as renameSync28, rmSync as rmSync8, writeFileSync as writeFileSync50 } from "node:fs";
+import { existsSync as existsSync61, renameSync as renameSync29, rmSync as rmSync8, writeFileSync as writeFileSync51 } from "node:fs";
 import { join as join75 } from "node:path";
 function writePendingTurnEnv(agentDir, pending, log = (l) => process.stderr.write(l)) {
   const pendingEnvPath = join75(agentDir, ".pending-turn.env");
@@ -106299,10 +106668,10 @@ function writePendingTurnEnv(agentDir, pending, log = (l) => process.stderr.writ
         pending.interrupt_reason != null ? `SWITCHROOM_PENDING_INTERRUPT_REASON=${pending.interrupt_reason}` : `SWITCHROOM_PENDING_INTERRUPT_REASON=`
       ];
       const pendingEnvTmp = `${pendingEnvPath}.tmp-${process.pid}`;
-      writeFileSync50(pendingEnvTmp, lines.join(`
+      writeFileSync51(pendingEnvTmp, lines.join(`
 `) + `
 `, { mode: 384 });
-      renameSync28(pendingEnvTmp, pendingEnvPath);
+      renameSync29(pendingEnvTmp, pendingEnvPath);
       log(`telegram gateway: pending-turn env written to ${pendingEnvPath} ` + `turnKey=${pending.turn_key} endedVia=${pending.ended_via ?? "open"}
 `);
     } else if (existsSync61(pendingEnvPath)) {
@@ -106316,8 +106685,184 @@ function writePendingTurnEnv(agentDir, pending, log = (l) => process.stderr.writ
   }
 }
 
+// gateway/agent-process-liveness.ts
+import { existsSync as existsSync62, readFileSync as readFileSync64, writeFileSync as writeFileSync52, renameSync as renameSync30, unlinkSync as unlinkSync30, readdirSync as readdirSync16 } from "node:fs";
+import { join as join76, dirname as dirname28, basename as basename18 } from "node:path";
+var AGENT_PROCESS_RECORD_FILE = "agent-process.json";
+var BOOT_RESUME_DONE_FILE = ".boot-resume-done";
+function parseProcStat(raw) {
+  const close = raw.lastIndexOf(") ");
+  const open = raw.indexOf(" (");
+  if (close < 0 || open < 0 || close < open)
+    return null;
+  const comm = raw.slice(open + 2, close);
+  const rest = raw.slice(close + 2).trim().split(/\s+/);
+  const state7 = rest[0];
+  const starttime = rest[19];
+  if (state7 == null || state7.length === 0)
+    return null;
+  if (starttime == null || !/^\d+$/.test(starttime))
+    return null;
+  return { comm, state: state7, starttime };
+}
+function readProcIdentity(pid, procRoot = "/proc") {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return null;
+  let identity;
+  try {
+    identity = parseProcStat(readFileSync64(join76(procRoot, String(pid), "stat"), "utf8"));
+  } catch {
+    return null;
+  }
+  if (identity != null && identity.state === "Z")
+    return null;
+  return identity;
+}
+function readAgentProcessRecord(path3) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync64(path3, "utf8"));
+  } catch {
+    return null;
+  }
+  if (parsed == null || typeof parsed !== "object")
+    return null;
+  const o = parsed;
+  const pid = typeof o.pid === "number" ? o.pid : Number(o.pid);
+  const starttime = typeof o.starttime === "string" ? o.starttime : String(o.starttime ?? "");
+  if (!Number.isInteger(pid) || pid <= 0)
+    return null;
+  if (!/^\d+$/.test(starttime))
+    return null;
+  const rec = { pid, starttime };
+  if (typeof o.comm === "string" && o.comm.length > 0)
+    rec.comm = o.comm;
+  if (typeof o.boot_at === "number" && Number.isFinite(o.boot_at))
+    rec.boot_at = o.boot_at;
+  return rec;
+}
+function bootResumeDonePath(stateDir) {
+  return join76(stateDir, BOOT_RESUME_DONE_FILE);
+}
+function containerBootIdentity(procRoot = "/proc") {
+  return readProcIdentity(1, procRoot)?.starttime ?? null;
+}
+function readBootResumeSentinel(path3, opts = {}) {
+  let raw;
+  try {
+    if (!existsSync62(path3))
+      return { present: false, stale: false };
+    raw = readFileSync64(path3, "utf8");
+  } catch {
+    return { present: false, stale: false };
+  }
+  let stamped = null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed != null && typeof parsed === "object" && typeof parsed.boot === "string" && parsed.boot.length > 0) {
+      stamped = parsed.boot;
+    }
+  } catch {}
+  const live = containerBootIdentity(opts.procRoot);
+  if (stamped != null && live != null && stamped !== live)
+    return { present: true, stale: true };
+  return { present: true, stale: false };
+}
+function sweepStrayTmps(path3) {
+  const prefix = `${basename18(path3)}.tmp.`;
+  try {
+    for (const name of readdirSync16(dirname28(path3))) {
+      if (!name.startsWith(prefix))
+        continue;
+      try {
+        unlinkSync30(join76(dirname28(path3), name));
+      } catch {}
+    }
+  } catch {}
+}
+function markBootResumeComplete(stateDir, opts = {}) {
+  const path3 = opts.path ?? bootResumeDonePath(stateDir);
+  const tmp = `${path3}.tmp.${process.pid}`;
+  const boot = containerBootIdentity(opts.procRoot);
+  try {
+    const token = { pid: process.pid, at: opts.now ?? Date.now() };
+    if (boot != null)
+      token.boot = boot;
+    writeFileSync52(tmp, JSON.stringify(token) + `
+`);
+    renameSync30(tmp, path3);
+    sweepStrayTmps(path3);
+  } catch (err) {
+    try {
+      unlinkSync30(tmp);
+    } catch {}
+    const log = opts.log ?? ((s) => process.stderr.write(s));
+    log(`telegram gateway: boot: could not stamp ${BOOT_RESUME_DONE_FILE} ` + `(${err.message}) \u2014 a gateway respawn may repeat the boot resume (#4641)
+`);
+  }
+}
+function decideGatewayOnlyRespawn(input) {
+  const { sentinelPresent, sentinelStale, record: record2, live } = input;
+  if (!sentinelPresent) {
+    return { gatewayOnly: false, reason: "no-boot-resume-sentinel", pid: record2?.pid ?? null };
+  }
+  if (sentinelStale === true) {
+    return { gatewayOnly: false, reason: "stale-boot-token", pid: record2?.pid ?? null };
+  }
+  if (record2 == null) {
+    return { gatewayOnly: true, reason: "gateway-only-respawn-no-record", pid: null };
+  }
+  if (live == null)
+    return { gatewayOnly: false, reason: "agent-process-dead", pid: record2.pid };
+  if (live.starttime !== record2.starttime) {
+    return { gatewayOnly: false, reason: "starttime-mismatch", pid: record2.pid };
+  }
+  if (record2.comm != null && record2.comm !== live.comm) {
+    return { gatewayOnly: false, reason: "comm-mismatch", pid: record2.pid };
+  }
+  return { gatewayOnly: true, reason: "gateway-only-respawn", pid: record2.pid };
+}
+function detectGatewayOnlyRespawn(opts) {
+  if (opts.enabled === false)
+    return { gatewayOnly: false, reason: "guard-disabled", pid: null };
+  const procRoot = opts.procRoot ?? "/proc";
+  const sentinel = readBootResumeSentinel(opts.sentinelPath ?? bootResumeDonePath(opts.stateDir), { procRoot });
+  const recordPath2 = opts.recordPath ?? join76(opts.stateDir, AGENT_PROCESS_RECORD_FILE);
+  const record2 = readAgentProcessRecord(recordPath2);
+  const live = record2 == null ? null : readProcIdentity(record2.pid, procRoot);
+  return decideGatewayOnlyRespawn({
+    sentinelPresent: sentinel.present,
+    sentinelStale: sentinel.stale,
+    record: record2,
+    live
+  });
+}
+function shouldSkipBootResumeForGatewayOnlyRespawn(stateDir, opts = {}) {
+  const log = opts.log ?? ((s) => process.stderr.write(s));
+  let decision;
+  try {
+    decision = detectGatewayOnlyRespawn({
+      ...opts,
+      stateDir,
+      enabled: opts.enabled ?? process.env.SWITCHROOM_GATEWAY_RESPAWN_GUARD !== "0"
+    });
+  } catch (err) {
+    log(`telegram gateway: boot: agent-liveness probe failed (${err.message}) \u2014 assuming agent restart
+`);
+    return false;
+  }
+  if (decision.gatewayOnly) {
+    log(`telegram gateway: boot: GATEWAY-ONLY respawn \u2014 this container generation's boot resume is already ` + `done (${BOOT_RESUME_DONE_FILE} present, reason=${decision.reason}, agent pid=${decision.pid ?? "unrecorded"}). ` + `Skipping the orphan-turn reaper, the bridge-dead marker, the resume synthetic, crash-redelivery capture ` + `and .pending-turn.env (#4641): the claude session, its in-flight turn and its sub-agents were never interrupted.
+`);
+    return true;
+  }
+  log(`telegram gateway: boot: agent-liveness probe \u2192 treating as agent restart (reason=${decision.reason})
+`);
+  return false;
+}
+
 // gateway/bridge-dead-watchdog.ts
-import { readFileSync as readFileSync64, writeFileSync as writeFileSync51, renameSync as renameSync29, unlinkSync as unlinkSync29 } from "node:fs";
+import { readFileSync as readFileSync65, writeFileSync as writeFileSync53, renameSync as renameSync31, unlinkSync as unlinkSync31 } from "node:fs";
 
 // gateway/cron-session.ts
 var CRON_IDENTITY_SUFFIX2 = "-cron";
@@ -106350,7 +106895,7 @@ function readFreshCrashLogTail(path3, opts = {}) {
   const nowMs3 = opts.nowMs ?? Date.now();
   const freshWindowMs = opts.freshWindowMs ?? CRASH_LOG_FRESH_WINDOW_MS;
   const maxLines = opts.maxLines ?? CRASH_LOG_TAIL_LINES;
-  const readFile = opts.readFile ?? ((p) => readFileSync64(p, "utf8"));
+  const readFile = opts.readFile ?? ((p) => readFileSync65(p, "utf8"));
   let raw;
   try {
     raw = readFile(path3);
@@ -106371,13 +106916,13 @@ function readFreshCrashLogTail(path3, opts = {}) {
 }
 function writeBridgeDeadEscalationMarker(path3, marker) {
   const tmp = `${path3}.tmp-${process.pid}-${Date.now()}`;
-  writeFileSync51(tmp, JSON.stringify(marker), "utf8");
-  renameSync29(tmp, path3);
+  writeFileSync53(tmp, JSON.stringify(marker), "utf8");
+  renameSync31(tmp, path3);
 }
 function consumeBridgeDeadEscalationMarker(path3, nowMs3 = Date.now(), maxAgeMs = ESCALATION_MARKER_MAX_AGE_MS) {
   let marker = null;
   try {
-    const parsed = JSON.parse(readFileSync64(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync65(path3, "utf8"));
     if (typeof parsed.ts === "number" && Number.isFinite(parsed.ts) && typeof parsed.reason === "string") {
       const age = nowMs3 - parsed.ts;
       if (age >= 0 && age < maxAgeMs) {
@@ -106389,7 +106934,7 @@ function consumeBridgeDeadEscalationMarker(path3, nowMs3 = Date.now(), maxAgeMs
     }
   } catch {}
   try {
-    unlinkSync29(path3);
+    unlinkSync31(path3);
   } catch {}
   return marker;
 }
@@ -106530,7 +107075,7 @@ function createBridgeDeadWatchdog(opts) {
 }
 
 // gateway/boot-probes.ts
-import { readFileSync as readFileSync65, readdirSync as readdirSync16, existsSync as existsSync62 } from "fs";
+import { readFileSync as readFileSync66, readdirSync as readdirSync17, existsSync as existsSync63 } from "fs";
 init_quota_cache();
 init_generation_stamp();
 init_quota_check();
@@ -106538,8 +107083,8 @@ import { execFile as execFileCb2 } from "child_process";
 import { promisify as promisify2 } from "util";
 var execFile2 = promisify2(execFileCb2);
 var realProcFs2 = {
-  readdir: (p) => readdirSync16(p),
-  readFile: (p) => readFileSync65(p, "utf-8")
+  readdir: (p) => readdirSync17(p),
+  readFile: (p) => readFileSync66(p, "utf-8")
 };
 function findAgentProcessInContainer2(fs4 = realProcFs2) {
   let entries;
@@ -106840,7 +107385,7 @@ if (isGatewayMain) {
     shutdownAnalytics();
   });
 }
-var STATE_DIR = process.env.TELEGRAM_STATE_DIR ?? join76(homedir22(), ".claude", "channels", "telegram");
+var STATE_DIR = process.env.TELEGRAM_STATE_DIR ?? join77(homedir22(), ".claude", "channels", "telegram");
 var permCardStore = createPermissionCardStore(STATE_DIR);
 var BLOCKED_APPROVALS_DIR = process.env.SWITCHROOM_BLOCKED_APPROVALS_DIR ?? "/state/blocked-approvals";
 var AGENT_NAME = process.env.SWITCHROOM_AGENT_NAME ?? "agent";
@@ -106879,7 +107424,7 @@ function alwaysAllowDrainDeps() {
   return {
     readConfigText: () => {
       const cfgPath = process.env.SWITCHROOM_CONFIG ?? SWITCHROOM_CONFIG ?? findConfigFile2();
-      return readFileSync66(cfgPath, "utf8");
+      return readFileSync67(cfgPath, "utf8");
     },
     resolveAllowList: (_configText, agentName3) => {
       const cfg = loadConfig2();
@@ -106940,11 +107485,11 @@ function scheduleAlwaysAllowPersistDrain() {
   }, ALWAYS_ALLOW_DRAIN_INTERVAL_MS);
   timer3.unref?.();
 }
-var ACCESS_FILE = join76(STATE_DIR, "access.json");
-var APPROVED_DIR = join76(STATE_DIR, "approved");
-var ENV_FILE = join76(STATE_DIR, ".env");
-var INBOX_DIR = join76(STATE_DIR, "inbox");
-var PEOPLE_FILE = join76(STATE_DIR, "people.json");
+var ACCESS_FILE = join77(STATE_DIR, "access.json");
+var APPROVED_DIR = join77(STATE_DIR, "approved");
+var ENV_FILE = join77(STATE_DIR, ".env");
+var INBOX_DIR = join77(STATE_DIR, "inbox");
+var PEOPLE_FILE = join77(STATE_DIR, "people.json");
 function triggerSelfRestart(targetAgent, reason, delayMs = 300) {
   const isDocker = process.env.SWITCHROOM_RUNTIME === "docker";
   const selfAgent = process.env.SWITCHROOM_AGENT_NAME;
@@ -107009,7 +107554,7 @@ function formatBootVersion() {
 }
 try {
   chmodSync14(ENV_FILE, 384);
-  for (const line of readFileSync66(ENV_FILE, "utf8").split(`
+  for (const line of readFileSync67(ENV_FILE, "utf8").split(`
 `)) {
     const m = line.match(/^(\w+)=(.*)$/);
     if (m && process.env[m[1]] === undefined)
@@ -107030,7 +107575,7 @@ var bot;
 var lastGetUpdatesHeartbeatMs = Date.now();
 var GRAMMY_VERSION = (() => {
   try {
-    const raw = readFileSync66(new URL("../../node_modules/grammy/package.json", import.meta.url), "utf8");
+    const raw = readFileSync67(new URL("../../node_modules/grammy/package.json", import.meta.url), "utf8");
     return JSON.parse(raw).version ?? "unknown";
   } catch {
     return "unknown";
@@ -107071,7 +107616,7 @@ function assertSendable(f) {
   } catch {
     throw new Error(`refusing to send file \u2014 cannot resolve real path: ${f}`);
   }
-  const inbox = join76(stateReal, "inbox");
+  const inbox = join77(stateReal, "inbox");
   if (real.startsWith(stateReal + sep6) && !real.startsWith(inbox + sep6)) {
     throw new Error(`refusing to send channel state: ${f}`);
   }
@@ -107100,7 +107645,7 @@ var HISTORY_ENABLED = HISTORY_ACCESS.historyEnabled !== false;
 if (isGatewayMain && HISTORY_ENABLED) {
   try {
     initHistory(STATE_DIR, HISTORY_ACCESS.historyRetentionDays ?? 30);
-    process.stderr.write(`telegram gateway: history capture enabled at ${join76(STATE_DIR, "history.db")}
+    process.stderr.write(`telegram gateway: history capture enabled at ${join77(STATE_DIR, "history.db")}
 `);
   } catch (err) {
     process.stderr.write(`telegram gateway: history init failed (${err.message}) \u2014 capture disabled
@@ -107111,174 +107656,179 @@ var turnsDb = null;
 var bootResumeInbound = null;
 var pendingRedelivery = null;
 var bridgeDeadPriorStreak = 0;
-if (isGatewayMain)
-  try {
-    const agentDir = STATE_DIR.endsWith("/telegram") ? STATE_DIR.slice(0, -"/telegram".length) : STATE_DIR;
-    turnsDb = openTurnsDb(agentDir);
-    applySubagentsSchema(turnsDb);
-    let markerTurnKey = null;
-    let markerAgeMs = null;
+var bootResumeThrew = false;
+bootResumeInit:
+  if (isGatewayMain)
     try {
-      const markerPath = join76(STATE_DIR, TURN_ACTIVE_MARKER_FILE2);
-      if (existsSync64(markerPath)) {
-        const st = statSync25(markerPath);
-        markerAgeMs = Date.now() - st.mtimeMs;
-        try {
-          const payload = JSON.parse(readFileSync66(markerPath, "utf8"));
-          if (typeof payload.turnKey === "string" && payload.turnKey.length > 0) {
-            markerTurnKey = payload.turnKey;
-          }
-        } catch {}
-      }
-    } catch {}
-    const hangSecs = Number(process.env.TURN_HANG_SECS);
-    const hangThresholdMs = (Number.isFinite(hangSecs) && hangSecs > 0 ? hangSecs : 300) * 1000;
-    const reasonSnapshot = markerAgeMs != null ? JSON.stringify({ idleMs: Math.round(markerAgeMs) }) : null;
-    const { reaped, timeoutTurnKey } = markOrphanedWithTimeoutClassification(turnsDb, {
-      markerTurnKey,
-      markerAgeMs,
-      hangThresholdMs,
-      reasonSnapshot
-    });
-    if (reaped > 0) {
-      process.stderr.write(`telegram gateway: turn-registry boot-reaper stamped ${reaped} orphaned turn(s)` + `${timeoutTurnKey ? ` (turnKey=${timeoutTurnKey} as 'timeout', markerAgeMs=${markerAgeMs})` : " as 'restart'"}
-`);
-    } else {
-      process.stderr.write(`telegram gateway: turn-registry initialized at ${join76(agentDir, "telegram", "registry.db")}
-`);
-    }
-    const bridgeDeadMarker = consumeBridgeDeadEscalationMarker(join76(STATE_DIR, "bridge-dead-escalation.json"));
-    if (bridgeDeadMarker != null) {
-      bridgeDeadPriorStreak = bridgeDeadMarker.count ?? 1;
-      process.stderr.write(`telegram gateway: boot: prior restart was a bridge-dead escalation (reason=${bridgeDeadMarker.reason}` + `, consecutive=${bridgeDeadPriorStreak}` + `${bridgeDeadMarker.crashTail ? `, crashTail=${bridgeDeadMarker.crashTail}` : ""})
-`);
-    }
-    const bridgeDeadRestartCause = bridgeDeadMarker != null ? {
-      reason: bridgeDeadMarker.reason,
-      note: "The framework itself triggered this restart: your Telegram MCP bridge process had died " + "(chat tools were unavailable \u2014 you could not send replies), so the container was bounced " + "to restore the chat surface. This was NOT an operator-initiated restart and NOT a hang-watchdog kill."
-    } : undefined;
-    const pending2 = findLatestTurnIfInterrupted(turnsDb);
-    const selfAgent = process.env.SWITCHROOM_AGENT_NAME ?? "";
-    if (pending2 != null && selfAgent) {
-      const bootResumeMarkerPath = process.env.SWITCHROOM_GATEWAY_CLEAN_SHUTDOWN_MARKER ?? join76(STATE_DIR, "clean-shutdown.json");
-      const bootResumeCleanMarker = readCleanShutdownMarker(bootResumeMarkerPath);
-      const bootResumeForceAlways = process.env.SWITCHROOM_BOOT_RESUME_ALWAYS === "1";
-      const bootResumeMode = parseBootResumeMode(process.env.SWITCHROOM_BOOT_RESUME);
-      const bootResumeSuppressed = shouldSuppressBootResume(bootResumeCleanMarker, Date.now(), {
-        forceAlways: bootResumeForceAlways,
-        mode: bootResumeMode
-      });
-      const RESUME_MAX_AGE_MS = (() => {
-        const v = Number(process.env.SWITCHROOM_RESUME_MAX_AGE_MS);
-        return Number.isFinite(v) && v > 0 ? v : 10800000;
-      })();
-      const bootResumeKind = decideBootResumeKind({
-        pending: pending2,
-        suppressed: bootResumeSuppressed,
-        ageMs: Math.max(0, Date.now() - pending2.started_at),
-        maxAgeMs: RESUME_MAX_AGE_MS
-      });
-      const redeliverCapture = decideRedeliverCapture({
-        willBeResumed: bootResumeKind === "resume",
-        hasSessionId: Boolean(pending2.session_id)
+      const agentDir = STATE_DIR.endsWith("/telegram") ? STATE_DIR.slice(0, -"/telegram".length) : STATE_DIR;
+      turnsDb = openTurnsDb(agentDir);
+      applySubagentsSchema(turnsDb);
+      if (shouldSkipBootResumeForGatewayOnlyRespawn(STATE_DIR))
+        break bootResumeInit;
+      let markerTurnKey = null;
+      let markerAgeMs = null;
+      try {
+        const markerPath = join77(STATE_DIR, TURN_ACTIVE_MARKER_FILE2);
+        if (existsSync65(markerPath)) {
+          const st = statSync25(markerPath);
+          markerAgeMs = Date.now() - st.mtimeMs;
+          try {
+            const payload = JSON.parse(readFileSync67(markerPath, "utf8"));
+            if (typeof payload.turnKey === "string" && payload.turnKey.length > 0) {
+              markerTurnKey = payload.turnKey;
+            }
+          } catch {}
+        }
+      } catch {}
+      const hangSecs = Number(process.env.TURN_HANG_SECS);
+      const hangThresholdMs = (Number.isFinite(hangSecs) && hangSecs > 0 ? hangSecs : 300) * 1000;
+      const reasonSnapshot = markerAgeMs != null ? JSON.stringify({ idleMs: Math.round(markerAgeMs) }) : null;
+      const { reaped, timeoutTurnKey } = markOrphanedWithTimeoutClassification(turnsDb, {
+        markerTurnKey,
+        markerAgeMs,
+        hangThresholdMs,
+        reasonSnapshot
       });
-      if (redeliverCapture.capture) {
-        pendingRedelivery = { turn: pending2, maxAgeMs: RESUME_MAX_AGE_MS };
-      } else if (redeliverCapture.skipReason === "will-be-resumed") {
-        process.stderr.write(`telegram gateway: crash-redelivery suppressed \u2014 interrupted turnKey=${pending2.turn_key} will be ` + `RESUMED (bootResumeKind=resume); the fresh re-answer supersedes the recovered draft (no double-send)
+      if (reaped > 0) {
+        process.stderr.write(`telegram gateway: turn-registry boot-reaper stamped ${reaped} orphaned turn(s)` + `${timeoutTurnKey ? ` (turnKey=${timeoutTurnKey} as 'timeout', markerAgeMs=${markerAgeMs})` : " as 'restart'"}
 `);
       } else {
-        process.stderr.write(`telegram gateway: crash-redelivery skipped \u2014 interrupted turnKey=${pending2.turn_key} has no ` + `pinned session_id (pre-feature turn or no session event seen); cannot resolve exact transcript
+        process.stderr.write(`telegram gateway: turn-registry initialized at ${join77(agentDir, "telegram", "registry.db")}
 `);
       }
-      let interruptedSubagents = [];
-      try {
-        interruptedSubagents = listNonTerminalSubagentsForTurn(turnsDb, pending2.turn_key).map((s) => ({ agentType: s.agent_type, description: s.description, status: s.status }));
-      } catch (err) {
-        process.stderr.write(`telegram gateway: boot-resume subagent lookup failed (${err.message}) \u2014 continuing without worker list
+      const bridgeDeadMarker = consumeBridgeDeadEscalationMarker(join77(STATE_DIR, "bridge-dead-escalation.json"));
+      if (bridgeDeadMarker != null) {
+        bridgeDeadPriorStreak = bridgeDeadMarker.count ?? 1;
+        process.stderr.write(`telegram gateway: boot: prior restart was a bridge-dead escalation (reason=${bridgeDeadMarker.reason}` + `, consecutive=${bridgeDeadPriorStreak}` + `${bridgeDeadMarker.crashTail ? `, crashTail=${bridgeDeadMarker.crashTail}` : ""})
 `);
       }
-      if (bootResumeKind === "resume") {
-        bootResumeInbound = {
-          agent: selfAgent,
-          msg: buildResumeInterruptedInbound({
-            turn: pending2,
-            subagents: interruptedSubagents,
-            restartCause: bridgeDeadRestartCause
-          })
-        };
-      } else if (bootResumeKind === "report") {
-        let idleMs = pending2.turn_key === timeoutTurnKey && markerAgeMs != null ? markerAgeMs : null;
-        if (idleMs == null && pending2.interrupt_reason) {
-          try {
-            const parsed = JSON.parse(pending2.interrupt_reason);
-            if (typeof parsed.idleMs === "number" && Number.isFinite(parsed.idleMs))
-              idleMs = parsed.idleMs;
-          } catch {}
+      const bridgeDeadRestartCause = bridgeDeadMarker != null ? {
+        reason: bridgeDeadMarker.reason,
+        note: "The framework itself triggered this restart: your Telegram MCP bridge process had died " + "(chat tools were unavailable \u2014 you could not send replies), so the container was bounced " + "to restore the chat surface. This was NOT an operator-initiated restart and NOT a hang-watchdog kill."
+      } : undefined;
+      const pending2 = findLatestTurnIfInterrupted(turnsDb);
+      const selfAgent = process.env.SWITCHROOM_AGENT_NAME ?? "";
+      if (pending2 != null && selfAgent) {
+        const bootResumeMarkerPath = process.env.SWITCHROOM_GATEWAY_CLEAN_SHUTDOWN_MARKER ?? join77(STATE_DIR, "clean-shutdown.json");
+        const bootResumeCleanMarker = readCleanShutdownMarker(bootResumeMarkerPath);
+        const bootResumeForceAlways = process.env.SWITCHROOM_BOOT_RESUME_ALWAYS === "1";
+        const bootResumeMode = parseBootResumeMode(process.env.SWITCHROOM_BOOT_RESUME);
+        const bootResumeSuppressed = shouldSuppressBootResume(bootResumeCleanMarker, Date.now(), {
+          forceAlways: bootResumeForceAlways,
+          mode: bootResumeMode
+        });
+        const RESUME_MAX_AGE_MS = (() => {
+          const v = Number(process.env.SWITCHROOM_RESUME_MAX_AGE_MS);
+          return Number.isFinite(v) && v > 0 ? v : 10800000;
+        })();
+        const bootResumeKind = decideBootResumeKind({
+          pending: pending2,
+          suppressed: bootResumeSuppressed,
+          ageMs: Math.max(0, Date.now() - pending2.started_at),
+          maxAgeMs: RESUME_MAX_AGE_MS
+        });
+        const redeliverCapture = decideRedeliverCapture({
+          willBeResumed: bootResumeKind === "resume",
+          hasSessionId: Boolean(pending2.session_id)
+        });
+        if (redeliverCapture.capture) {
+          pendingRedelivery = { turn: pending2, maxAgeMs: RESUME_MAX_AGE_MS };
+        } else if (redeliverCapture.skipReason === "will-be-resumed") {
+          process.stderr.write(`telegram gateway: crash-redelivery suppressed \u2014 interrupted turnKey=${pending2.turn_key} will be ` + `RESUMED (bootResumeKind=resume); the fresh re-answer supersedes the recovered draft (no double-send)
+`);
+        } else {
+          process.stderr.write(`telegram gateway: crash-redelivery skipped \u2014 interrupted turnKey=${pending2.turn_key} has no ` + `pinned session_id (pre-feature turn or no session event seen); cannot resolve exact transcript
+`);
         }
-        if (idleMs == null)
-          idleMs = Math.max(0, Date.now() - pending2.started_at);
-        bootResumeInbound = {
-          agent: selfAgent,
-          msg: buildResumeWatchdogReportInbound({
-            turn: pending2,
-            idleMs,
-            subagents: interruptedSubagents,
-            restartCause: bridgeDeadRestartCause
-          })
-        };
-      } else if (bootResumeKind === "defer-loop" || bootResumeKind === "defer-suppressed") {
-        bootResumeInbound = {
-          agent: selfAgent,
-          msg: buildResumeDeferredReportInbound({
-            turn: pending2,
-            reason: bootResumeKind === "defer-loop" ? "loop-guard" : "clean-restart-suppressed",
-            subagents: interruptedSubagents,
-            restartCause: bridgeDeadRestartCause
-          })
-        };
-      }
-      if (bootResumeKind === "defer-suppressed") {
-        process.stderr.write(`telegram gateway: boot-resume suppressed (clean shutdown` + `${bootResumeCleanMarker?.reason ? ` reason=${JSON.stringify(bootResumeCleanMarker.reason)}` : ""}` + `, mode=${bootResumeMode}) \u2014 passive report delivered for turnKey=${pending2.turn_key}
+        let interruptedSubagents = [];
+        try {
+          interruptedSubagents = listNonTerminalSubagentsForTurn(turnsDb, pending2.turn_key).map((s) => ({ agentType: s.agent_type, description: s.description, status: s.status }));
+        } catch (err) {
+          process.stderr.write(`telegram gateway: boot-resume subagent lookup failed (${err.message}) \u2014 continuing without worker list
 `);
-      } else if (bootResumeKind === "defer-loop") {
-        process.stderr.write(`telegram gateway: boot-resume loop-guard tripped (interrupted turn was itself a resume) ` + `\u2014 passive report delivered instead of re-resuming turnKey=${pending2.turn_key}
+        }
+        if (bootResumeKind === "resume") {
+          bootResumeInbound = {
+            agent: selfAgent,
+            msg: buildResumeInterruptedInbound({
+              turn: pending2,
+              subagents: interruptedSubagents,
+              restartCause: bridgeDeadRestartCause
+            })
+          };
+        } else if (bootResumeKind === "report") {
+          let idleMs = pending2.turn_key === timeoutTurnKey && markerAgeMs != null ? markerAgeMs : null;
+          if (idleMs == null && pending2.interrupt_reason) {
+            try {
+              const parsed = JSON.parse(pending2.interrupt_reason);
+              if (typeof parsed.idleMs === "number" && Number.isFinite(parsed.idleMs))
+                idleMs = parsed.idleMs;
+            } catch {}
+          }
+          if (idleMs == null)
+            idleMs = Math.max(0, Date.now() - pending2.started_at);
+          bootResumeInbound = {
+            agent: selfAgent,
+            msg: buildResumeWatchdogReportInbound({
+              turn: pending2,
+              idleMs,
+              subagents: interruptedSubagents,
+              restartCause: bridgeDeadRestartCause
+            })
+          };
+        } else if (bootResumeKind === "defer-loop" || bootResumeKind === "defer-suppressed") {
+          bootResumeInbound = {
+            agent: selfAgent,
+            msg: buildResumeDeferredReportInbound({
+              turn: pending2,
+              reason: bootResumeKind === "defer-loop" ? "loop-guard" : "clean-restart-suppressed",
+              subagents: interruptedSubagents,
+              restartCause: bridgeDeadRestartCause
+            })
+          };
+        }
+        if (bootResumeKind === "defer-suppressed") {
+          process.stderr.write(`telegram gateway: boot-resume suppressed (clean shutdown` + `${bootResumeCleanMarker?.reason ? ` reason=${JSON.stringify(bootResumeCleanMarker.reason)}` : ""}` + `, mode=${bootResumeMode}) \u2014 passive report delivered for turnKey=${pending2.turn_key}
 `);
-      }
-      if (bootResumeInbound != null) {
-        process.stderr.write(`telegram gateway: boot-resume queued kind=${bootResumeKind} mode=${bootResumeMode} ` + `turnKey=${pending2.turn_key} endedVia=${pending2.ended_via ?? "open"} chat=${pending2.chat_id}
+        } else if (bootResumeKind === "defer-loop") {
+          process.stderr.write(`telegram gateway: boot-resume loop-guard tripped (interrupted turn was itself a resume) ` + `\u2014 passive report delivered instead of re-resuming turnKey=${pending2.turn_key}
 `);
-      }
-    }
-    if (bridgeDeadMarker != null && bootResumeInbound == null && selfAgent) {
-      const idleNoticeChat = (() => {
-        try {
-          return loadAccess().allowFrom[0] ?? null;
-        } catch {
-          return null;
         }
-      })();
-      if (idleNoticeChat != null) {
-        bootResumeInbound = {
-          agent: selfAgent,
-          msg: buildBridgeDeadIdleNoticeInbound({
-            chatId: String(idleNoticeChat),
-            marker: bridgeDeadMarker
-          })
-        };
-        process.stderr.write(`telegram gateway: boot: bridge-dead idle notice queued chat=${idleNoticeChat} (no turn was in flight)
+        if (bootResumeInbound != null) {
+          process.stderr.write(`telegram gateway: boot-resume queued kind=${bootResumeKind} mode=${bootResumeMode} ` + `turnKey=${pending2.turn_key} endedVia=${pending2.ended_via ?? "open"} chat=${pending2.chat_id}
 `);
-      } else {
-        process.stderr.write(`telegram gateway: boot: bridge-dead idle notice skipped \u2014 no allowFrom chat to surface it in
+        }
+      }
+      if (bridgeDeadMarker != null && bootResumeInbound == null && selfAgent) {
+        const idleNoticeChat = (() => {
+          try {
+            return loadAccess().allowFrom[0] ?? null;
+          } catch {
+            return null;
+          }
+        })();
+        if (idleNoticeChat != null) {
+          bootResumeInbound = {
+            agent: selfAgent,
+            msg: buildBridgeDeadIdleNoticeInbound({
+              chatId: String(idleNoticeChat),
+              marker: bridgeDeadMarker
+            })
+          };
+          process.stderr.write(`telegram gateway: boot: bridge-dead idle notice queued chat=${idleNoticeChat} (no turn was in flight)
 `);
+        } else {
+          process.stderr.write(`telegram gateway: boot: bridge-dead idle notice skipped \u2014 no allowFrom chat to surface it in
+`);
+        }
       }
-    }
-    writePendingTurnEnv(agentDir, pending2);
-  } catch (err) {
-    process.stderr.write(`telegram gateway: turn-registry init failed (${err.message}) \u2014 turn tracking disabled
+      writePendingTurnEnv(agentDir, pending2);
+    } catch (err) {
+      process.stderr.write(`telegram gateway: turn-registry init failed (${err.message}) \u2014 turn tracking disabled
 `);
-    turnsDb = null;
-  }
+      turnsDb = null;
+      bootResumeThrew = true;
+    }
 function resolveSubagentOriginChat(agentId) {
   if (turnsDb == null)
     return null;
@@ -107361,12 +107911,12 @@ if (isGatewayMain && !STATIC)
 function checkApprovals() {
   let files;
   try {
-    files = readdirSync18(APPROVED_DIR);
+    files = readdirSync19(APPROVED_DIR);
   } catch {
     return;
   }
   for (const senderId of files) {
-    const file = join76(APPROVED_DIR, senderId);
+    const file = join77(APPROVED_DIR, senderId);
     bot.api.sendMessage(senderId, "Paired! Say hi to Claude.").then(() => rmSync9(file, { force: true }), (err) => {
       process.stderr.write(`telegram gateway: failed to send approval confirm: ${err}
 `);
@@ -107544,15 +108094,15 @@ function noteAgentOutputAt(key, ts) {
       lastAgentOutputAt.delete(oldest);
   }
 }
-var OBLIGATION_STORE_PATH = join76(STATE_DIR, "obligations.json");
+var OBLIGATION_STORE_PATH = join77(STATE_DIR, "obligations.json");
 var obligationStoreFs = {
-  readFileSync: (p) => readFileSync66(p, "utf8"),
+  readFileSync: (p) => readFileSync67(p, "utf8"),
   writeFileSync: (p, d) => writeStateFileSync2(p, d),
-  renameSync: (a, b) => renameSync30(a, b),
-  existsSync: (p) => existsSync64(p),
+  renameSync: (a, b) => renameSync32(a, b),
+  existsSync: (p) => existsSync65(p),
   fsyncFileSync: fsyncPathSync,
   fsyncDirSync: fsyncPathSync,
-  unlinkSync: unlinkSync31
+  unlinkSync: unlinkSync33
 };
 var obligationLedger = new ObligationLedger(OBLIGATION_REPRESENT_MAX, {
   onChange: STATIC || !OBLIGATION_LEDGER_ENABLED ? undefined : (snapshot) => persistObligations(OBLIGATION_STORE_PATH, obligationStoreFs, snapshot)
@@ -108311,7 +108861,7 @@ function emitTurnRecord(turn, endedAt) {
           return;
         }
       },
-      rename: (from, to) => renameSync30(from, to)
+      rename: (from, to) => renameSync32(from, to)
     });
     appendFileSync11(turnsPath, rec);
   } catch {}
@@ -109882,28 +110432,28 @@ var PIN_STATUS_WHILE_WORKING = (() => {
 })();
 var statusPinClaims = new Map;
 var statusPinRightsCache = new PinRightsCache2;
-var STATUS_PIN_STORE_PATH = join76(STATE_DIR, "status-pins.json");
+var STATUS_PIN_STORE_PATH = join77(STATE_DIR, "status-pins.json");
 var statusPinStoreFs = {
-  readFileSync: (p) => readFileSync66(p, "utf8"),
+  readFileSync: (p) => readFileSync67(p, "utf8"),
   writeFileSync: (p, d) => writeStateFileSync2(p, d),
-  renameSync: (a, b) => renameSync30(a, b),
-  existsSync: (p) => existsSync64(p)
+  renameSync: (a, b) => renameSync32(a, b),
+  existsSync: (p) => existsSync65(p)
 };
 var statusPinPersistEnabled = !STATIC && PIN_STATUS_WHILE_WORKING;
-var ACTIVITY_CARD_STORE_PATH = join76(STATE_DIR, "activity-cards-pending.json");
+var ACTIVITY_CARD_STORE_PATH = join77(STATE_DIR, "activity-cards-pending.json");
 var activityCardStoreFs = {
-  readFileSync: (p) => readFileSync66(p, "utf8"),
+  readFileSync: (p) => readFileSync67(p, "utf8"),
   writeFileSync: (p, d) => writeStateFileSync2(p, d),
-  renameSync: (a, b) => renameSync30(a, b),
-  existsSync: (p) => existsSync64(p)
+  renameSync: (a, b) => renameSync32(a, b),
+  existsSync: (p) => existsSync65(p)
 };
 var activityCardPersistEnabled = !STATIC;
-var QUEUED_CARD_STORE_PATH = join76(STATE_DIR, "queued-cards-pending.json");
+var QUEUED_CARD_STORE_PATH = join77(STATE_DIR, "queued-cards-pending.json");
 var queuedCardStoreFs = {
-  readFileSync: (p) => readFileSync66(p, "utf8"),
+  readFileSync: (p) => readFileSync67(p, "utf8"),
   writeFileSync: (p, d) => writeStateFileSync2(p, d),
-  renameSync: (a, b) => renameSync30(a, b),
-  existsSync: (p) => existsSync64(p)
+  renameSync: (a, b) => renameSync32(a, b),
+  existsSync: (p) => existsSync65(p)
 };
 var queuedCardPersistEnabled = !STATIC;
 function persistQueuedCard(key, chatId, threadId, messageId) {
@@ -110186,11 +110736,11 @@ async function unpinAllStatusPins() {
   }
 }
 var stalePinSweepEligible = false;
-var STALE_PIN_SWEEP_STORE_PATH = join76(STATE_DIR, "stale-pin-sweep.json");
+var STALE_PIN_SWEEP_STORE_PATH = join77(STATE_DIR, "stale-pin-sweep.json");
 var sweepStoreFs = {
-  readFileSync: (p) => readFileSync66(p, "utf-8"),
+  readFileSync: (p) => readFileSync67(p, "utf-8"),
   writeFileSync: (p, data) => atomicWriteStateFileSync2(p, data, 384),
-  existsSync: (p) => existsSync64(p)
+  existsSync: (p) => existsSync65(p)
 };
 var stalePinSweeper = createGatewayStalePinSweeper({
   telegram: { handle: () => lockedBot, call: robustApiCall },
@@ -110227,12 +110777,12 @@ var getPinnedProgressCardMessageId = null;
 var completeProgressCardTurn = null;
 var subagentWatcher = null;
 var workerActivityFeed = null;
-var SOCKET_PATH = process.env.SWITCHROOM_GATEWAY_SOCKET ?? join76(STATE_DIR, "gateway.sock");
+var SOCKET_PATH = process.env.SWITCHROOM_GATEWAY_SOCKET ?? join77(STATE_DIR, "gateway.sock");
 if (isGatewayMain)
   mkdirStateSync2(STATE_DIR, { recursive: true, mode: 448 });
-var GATEWAY_PID_PATH = process.env.SWITCHROOM_GATEWAY_PID_FILE ?? join76(STATE_DIR, "gateway.pid.json");
-var GATEWAY_SESSION_MARKER_PATH = process.env.SWITCHROOM_GATEWAY_SESSION_MARKER ?? join76(STATE_DIR, "gateway-session.json");
-var GATEWAY_CLEAN_SHUTDOWN_MARKER_PATH = process.env.SWITCHROOM_GATEWAY_CLEAN_SHUTDOWN_MARKER ?? join76(STATE_DIR, "clean-shutdown.json");
+var GATEWAY_PID_PATH = process.env.SWITCHROOM_GATEWAY_PID_FILE ?? join77(STATE_DIR, "gateway.pid.json");
+var GATEWAY_SESSION_MARKER_PATH = process.env.SWITCHROOM_GATEWAY_SESSION_MARKER ?? join77(STATE_DIR, "gateway-session.json");
+var GATEWAY_CLEAN_SHUTDOWN_MARKER_PATH = process.env.SWITCHROOM_GATEWAY_CLEAN_SHUTDOWN_MARKER ?? join77(STATE_DIR, "clean-shutdown.json");
 var GATEWAY_STARTED_AT_MS = Date.now();
 var BOOT_CARD_ENABLED = process.env.SWITCHROOM_BOOT_CARD !== "false";
 var activeBootCard = null;
@@ -110262,7 +110812,7 @@ function ensureIssuesCard(chatId, threadId) {
     bot: botApi,
     log: (msg) => process.stderr.write(`telegram gateway: ${msg}
 `),
-    persistPath: join76(stateDir, "issues-card.json")
+    persistPath: join77(stateDir, "issues-card.json")
   });
   activeIssuesWatcher = startIssuesWatcher({
     stateDir,
@@ -110467,13 +111017,13 @@ if (isGatewayMain)
 var inboundSpool;
 if (isGatewayMain)
   inboundSpool = STATIC ? undefined : createInboundSpool({
-    path: join76(STATE_DIR, "inbound-spool.jsonl"),
+    path: join77(STATE_DIR, "inbound-spool.jsonl"),
     fs: {
       appendFileSync: (p, d) => appendStateFileSync(p, d),
-      readFileSync: (p) => readFileSync66(p, "utf8"),
+      readFileSync: (p) => readFileSync67(p, "utf8"),
       writeFileSync: (p, d) => writeStateFileSync2(p, d),
-      renameSync: (a, b) => renameSync30(a, b),
-      existsSync: (p) => existsSync64(p),
+      renameSync: (a, b) => renameSync32(a, b),
+      existsSync: (p) => existsSync65(p),
       statSizeSync: (p) => statSync25(p).size,
       fsyncFileSync: fsyncPathSync,
       fsyncDirSync: fsyncPathSync
@@ -110538,13 +111088,13 @@ async function maybeRedeliverUndeliveredAnswer() {
   let transcriptText;
   try {
     const projectsDir = getProjectsDirForCwd();
-    const path3 = join76(projectsDir, `${sessionId}.jsonl`);
-    if (!existsSync64(path3)) {
+    const path3 = join77(projectsDir, `${sessionId}.jsonl`);
+    if (!existsSync65(path3)) {
       process.stderr.write(`telegram gateway: crash-redelivery \u2014 transcript not found for turnKey=${turn.turn_key} session=${sessionId} (${path3}); skipping
 `);
       return;
     }
-    transcriptText = readFileSync66(path3, "utf8");
+    transcriptText = readFileSync67(path3, "utf8");
   } catch (err) {
     process.stderr.write(`telegram gateway: crash-redelivery \u2014 transcript read failed turnKey=${turn.turn_key}: ${err.message}
 `);
@@ -110638,6 +111188,8 @@ if (isGatewayMain && bootResumeInbound != null) {
     }
   }
 }
+if (isGatewayMain && !bootResumeThrew)
+  markBootResumeComplete(STATE_DIR);
 if (isGatewayMain && inboundSpool != null) {
   const replay = inboundSpool.liveEntries();
   for (const e of replay)
@@ -110711,8 +111263,8 @@ var bridgeDeadWatchdog = createBridgeDeadWatchdog({
   isSessionAlive: () => findAgentProcessInContainer2()?.comm === "claude",
   isShuttingDown: () => shuttingDown,
   escalate: (reason) => triggerSelfRestart(process.env.SWITCHROOM_AGENT_NAME ?? "", reason, 1500),
-  crashLogPath: join76(STATE_DIR, "bridge-crash.log"),
-  markerPath: join76(STATE_DIR, "bridge-dead-escalation.json"),
+  crashLogPath: join77(STATE_DIR, "bridge-crash.log"),
+  markerPath: join77(STATE_DIR, "bridge-dead-escalation.json"),
   log: (line) => process.stderr.write(`${line}
 `),
   priorStreak: bridgeDeadPriorStreak,
@@ -110819,8 +111371,8 @@ if (isGatewayMain)
               probeQuotaViaBroker: (t) => probeQuotaForBootCard(agentSlug, t),
               tmuxSupervisor: process.env.SWITCHROOM_TMUX_SUPERVISOR === "1",
               dockerMode: process.env.SWITCHROOM_RUNTIME === "docker",
-              configSnapshotPath: join76(resolvedAgentDirForCard, ".config-snapshot.json"),
-              bootCardStatePath: join76(resolvedAgentDirForCard, ".boot-card-msgid.json"),
+              configSnapshotPath: join77(resolvedAgentDirForCard, ".config-snapshot.json"),
+              bootCardStatePath: join77(resolvedAgentDirForCard, ".boot-card-msgid.json"),
               floodStatePath: FLOOD_STATE_PATH,
               ...updateOutcomeLine ? { updateOutcomeLine } : {}
             }, ackMsgId).then((handle) => {
@@ -110920,7 +111472,7 @@ if (isGatewayMain)
       if (turnsDb != null && msg.activeFile != null) {
         const stampKey = currentTurn?.registryKey ?? null;
         if (stampKey != null && stampKey !== lastSessionStampedTurnKey) {
-          const sessionId = basename18(msg.activeFile).replace(/\.jsonl$/, "");
+          const sessionId = basename19(msg.activeFile).replace(/\.jsonl$/, "");
           if (sessionId) {
             try {
               stampTurnSessionId(turnsDb, stampKey, sessionId);
@@ -111418,10 +111970,10 @@ if (isGatewayMain)
       }
     },
     onPostSkillProposal(_client, msg) {
-      handlePostSkillProposal(msg, { bot, assertAllowedChat, swallowingApiCall });
+      handlePostSkillProposal(msg, { bot, assertAllowedChat, swallowingApiCall, deliverResumeSyntheticOrBuffer });
     },
     onPostEvalCaseProposal(_client, msg) {
-      handlePostEvalCaseProposal(msg, { bot, assertAllowedChat, swallowingApiCall });
+      handlePostEvalCaseProposal(msg, { bot, assertAllowedChat, swallowingApiCall, deliverResumeSyntheticOrBuffer });
     },
     onBuzzPublishResult: (_c, m) => getBuzzMirror()?.onPublishResult(m),
     log: (msg) => process.stderr.write(`telegram gateway: ipc \u2014 ${msg}
@@ -111454,7 +112006,7 @@ if (isGatewayMain)
       const receiverUid = receiverUidRaw ? Number(receiverUidRaw) : NaN;
       if (Number.isInteger(receiverUid))
         allowedUids.push(receiverUid);
-      const socketPath = join76(STATE_DIR, "webhook.sock");
+      const socketPath = join77(STATE_DIR, "webhook.sock");
       const webhookInject = (agentName3, inbound) => {
         const msg = inbound;
         const delivered = ipcServer.sendToAgent(agentName3, msg);
@@ -111706,9 +112258,9 @@ function redactOutboundText(text5, site) {
 var VOICE_OUT_DEFAULT_CHUNK_CHARS = 600;
 var VOICE_OUT_HARD_CHUNK_CAP = 4096;
 var voiceOnDemandCache = new VoiceOnDemandCache({
-  persistPath: join76(STATE_DIR, "voice-ondemand.json")
+  persistPath: join77(STATE_DIR, "voice-ondemand.json")
 });
-var VOICE_CACHE_DIR = join76(STATE_DIR, "voice-cache");
+var VOICE_CACHE_DIR = join77(STATE_DIR, "voice-cache");
 var voicePreSynthQueue = new PreSynthQueue({
   runJob: async (job) => {
     const sidecarToken = await materializeSidecarToken2();
@@ -112116,11 +112668,11 @@ async function executeSendGif(rawArgs) {
   };
 }
 async function publishToTelegraph(text5, shortName, authorName) {
-  const accountPath = join76(STATE_DIR, "telegraph-account.json");
+  const accountPath = join77(STATE_DIR, "telegraph-account.json");
   let account = null;
   try {
-    if (existsSync64(accountPath)) {
-      const raw = readFileSync66(accountPath, "utf-8");
+    if (existsSync65(accountPath)) {
+      const raw = readFileSync67(accountPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.shortName && parsed.accessToken) {
         account = parsed;
@@ -112140,7 +112692,7 @@ async function publishToTelegraph(text5, shortName, authorName) {
     account = created.value;
     try {
       mkdirStateSync2(STATE_DIR, { recursive: true, mode: 448 });
-      writeFileSync53(accountPath, JSON.stringify(account, null, 2), { mode: 384 });
+      writeFileSync55(accountPath, JSON.stringify(account, null, 2), { mode: 384 });
     } catch (err) {
       process.stderr.write(`telegram gateway: telegraph cache write failed: ${err.message}
 `);
@@ -112256,7 +112808,7 @@ _The secret was NOT saved. The agent can re-request with \`request_secret\`._`,
 }
 function readLiveSwitchroomConfigText() {
   const cfgPath = process.env.SWITCHROOM_CONFIG ?? findConfigFile2();
-  return readFileSync66(cfgPath, "utf8");
+  return readFileSync67(cfgPath, "utf8");
 }
 async function executeReact(args) {
   if (!args.chat_id)
@@ -112297,7 +112849,7 @@ async function executeDownloadAttachment(args) {
   });
   mkdirSync50(INBOX_DIR, { recursive: true, mode: 448 });
   assertInsideInbox2(INBOX_DIR, dlPath);
-  writeFileSync53(dlPath, buf, { mode: 384 });
+  writeFileSync55(dlPath, buf, { mode: 384 });
   return { content: [{ type: "text", text: dlPath }] };
 }
 async function executeEditMessage(args) {
@@ -113653,7 +114205,7 @@ function getMyAgentName() {
   const fromEnv = process.env.SWITCHROOM_AGENT_NAME;
   if (fromEnv && fromEnv.trim().length > 0)
     return fromEnv.trim();
-  return basename18(process.cwd());
+  return basename19(process.cwd());
 }
 function isSelfTargetingCommand(name) {
   if (name === "all")
@@ -113666,14 +114218,14 @@ function restartMarkerPath() {
   const agentDir = resolveAgentDirFromEnv();
   if (!agentDir)
     return null;
-  return join76(agentDir, "restart-pending.json");
+  return join77(agentDir, "restart-pending.json");
 }
 function writeRestartMarker(marker) {
   const p = restartMarkerPath();
   if (!p)
     return;
   try {
-    writeFileSync53(p, JSON.stringify(marker));
+    writeFileSync55(p, JSON.stringify(marker));
     lastPlannedRestartAt = Date.now();
     process.stderr.write(`telegram gateway: restart-marker: write chat_id=${marker.chat_id} thread_id=${marker.thread_id ?? "-"} ack=${marker.ack_message_id ?? "-"} path=${p}
 `);
@@ -113692,7 +114244,7 @@ function readRestartMarker() {
   if (!p)
     return null;
   try {
-    return JSON.parse(readFileSync66(p, "utf8"));
+    return JSON.parse(readFileSync67(p, "utf8"));
   } catch {
     return null;
   }
@@ -113841,7 +114393,7 @@ var _dockerReachable;
 function isDockerReachable() {
   if (_dockerReachable !== undefined)
     return _dockerReachable;
-  if (!existsSync64("/var/run/docker.sock")) {
+  if (!existsSync65("/var/run/docker.sock")) {
     _dockerReachable = false;
     return _dockerReachable;
   }
@@ -113858,12 +114410,12 @@ function _resetDockerReachableCache() {
 }
 function spawnSwitchroomDetached(args, onFailure) {
   const fullArgs = SWITCHROOM_CONFIG ? ["--config", SWITCHROOM_CONFIG, ...args] : args;
-  const logPath = join76(STATE_DIR, "detached-spawn.log");
+  const logPath = join77(STATE_DIR, "detached-spawn.log");
   let outFd = null;
   try {
     mkdirStateSync2(STATE_DIR, { recursive: true });
     outFd = openSync18(logPath, "a");
-    writeFileSync53(logPath, `
+    writeFileSync55(logPath, `
 [${new Date().toISOString()}] spawn ${SWITCHROOM_CLI} ${fullArgs.join(" ")}
 `, { flag: "a" });
   } catch {}
@@ -113889,7 +114441,7 @@ function spawnSwitchroomDetached(args, onFailure) {
         return;
       let tail = "";
       try {
-        const full = readFileSync66(logPath, "utf8");
+        const full = readFileSync67(logPath, "utf8");
         tail = full.split(`
 `).slice(-30).join(`
 `).trim();
@@ -114151,10 +114703,10 @@ ${preBlock(formatSwitchroomOutput(detail))}`, { html: true });
 }
 function readRecentDenialsForAgent(agentName3, windowMs, limit) {
   try {
-    const auditPath = join76(homedir22(), ".switchroom", "vault-audit.log");
-    if (!existsSync64(auditPath))
+    const auditPath = join77(homedir22(), ".switchroom", "vault-audit.log");
+    if (!existsSync65(auditPath))
       return [];
-    const raw = readFileSync66(auditPath, "utf8");
+    const raw = readFileSync67(auditPath, "utf8");
     return recentDenialsFromAuditLog(raw, { agentName: agentName3, windowMs, limit });
   } catch {
     return [];
@@ -114205,7 +114757,7 @@ async function buildAgentMetadata(agentName3) {
   try {
     const agentDir = resolveAgentDirFromEnv();
     if (agentDir) {
-      const raw = readFileSync66(join76(agentDir, ".claude", ".claude.json"), "utf8");
+      const raw = readFileSync67(join77(agentDir, ".claude", ".claude.json"), "utf8");
       claudeJson = JSON.parse(raw);
     }
   } catch {}
@@ -114334,7 +114886,7 @@ function buildModelDeps(restartCtx) {
       try {
         const agentDir = resolveAgentDirFromEnv();
         if (agentDir) {
-          const local = await fetchQuota2({ claudeConfigDir: join76(agentDir, ".claude") });
+          const local = await fetchQuota2({ claudeConfigDir: join77(agentDir, ".claude") });
           if (local.ok)
             return formatQuotaLine2(local.data);
         }
@@ -114581,10 +115133,10 @@ function effortMenuReplyMarkup(reply) {
 function flushAgentHandoff(agentDir) {
   let removed = 0;
   for (const fname of [".handoff.md", ".handoff-topic"]) {
-    const p = join76(agentDir, fname);
+    const p = join77(agentDir, fname);
     try {
-      if (existsSync64(p)) {
-        unlinkSync31(p);
+      if (existsSync65(p)) {
+        unlinkSync33(p);
         removed++;
       }
     } catch (err) {
@@ -114639,7 +115191,7 @@ async function handleNewCommand(ctx) {
   writeRestartMarker({ chat_id: chatId, thread_id: threadId ?? null, ack_message_id: ackId, ts: Date.now() });
   if (agentDir != null) {
     try {
-      writeFileSync53(join76(agentDir, ".force-fresh-session"), `${kind} at ${new Date().toISOString()}
+      writeFileSync55(join77(agentDir, ".force-fresh-session"), `${kind} at ${new Date().toISOString()}
 `, "utf8");
     } catch (err) {
       process.stderr.write(`telegram gateway: failed to write force-fresh marker: ${err}
@@ -114752,16 +115304,16 @@ function buildFolderPickerDeps() {
   };
 }
 var lockoutOps = {
-  readFileSync: (p, enc) => readFileSync66(p, enc),
+  readFileSync: (p, enc) => readFileSync67(p, enc),
   writeFileSync: (p, data, opts) => writeStateFileSync2(p, data, opts),
-  existsSync: (p) => existsSync64(p),
+  existsSync: (p) => existsSync65(p),
   mkdirSync: (p, opts) => mkdirStateSync2(p, opts),
-  joinPath: (...parts) => join76(...parts)
+  joinPath: (...parts) => join77(...parts)
 };
 var FLEET_FALLBACK_DEDUP_MS = 30000;
 function isAuthBrokerSocketReachable() {
   try {
-    return existsSync64(resolveAuthBrokerSocketPath2());
+    return existsSync65(resolveAuthBrokerSocketPath2());
   } catch {
     return false;
   }
@@ -115017,7 +115569,7 @@ async function runCreditWatch() {
   if (!agentDir)
     return;
   const agentName3 = getMyAgentName();
-  const claudeConfigDir = join76(agentDir, ".claude");
+  const claudeConfigDir = join77(agentDir, ".claude");
   const stateDir = STATE_DIR;
   const reason = readClaudeJsonOverage(claudeConfigDir);
   const prev = loadCreditState(stateDir);
@@ -116787,7 +117339,7 @@ Send \`/auth ${parsed.provider} cancel\` to abort.`, { html: true });
       await switchroomReply(ctx, "**/usage:** cannot resolve agent dir.", { html: true });
       return;
     }
-    const result = await fetchQuota2({ claudeConfigDir: join76(agentDir, ".claude") });
+    const result = await fetchQuota2({ claudeConfigDir: join77(agentDir, ".claude") });
     if (!result.ok) {
       await switchroomReply(ctx, `**/usage:** ${escapeHtmlForTg2(result.reason)}`, { html: true });
       return;
@@ -117178,7 +117730,7 @@ ${interimLabel}` : interimLabel
           const unifiedDiff = (() => {
             try {
               const cfgPath = process.env.SWITCHROOM_CONFIG ?? SWITCHROOM_CONFIG ?? findConfigFile2();
-              const raw = readFileSync66(cfgPath, "utf8");
+              const raw = readFileSync67(cfgPath, "utf8");
               return synthesizeAllowRuleDiff({ agentName: agentName3, rule: chosen.rule, configText: raw });
             } catch (err) {
               process.stderr.write(`telegram gateway: always-allow diff synth failed: ${err.message}
@@ -118053,7 +118605,7 @@ async function startGateway() {
                         return;
                       }
                     })();
-                    const resolvedAgentDirForBootCard = agentDir ?? join76(homedir22(), ".switchroom", "agents", agentSlug);
+                    const resolvedAgentDirForBootCard = agentDir ?? join77(homedir22(), ".switchroom", "agents", agentSlug);
                     const handle = await startBootCard(chatId, threadId, botApiForCard, {
                       agentName: agentDisplayName,
                       agentSlug,
@@ -118067,8 +118619,8 @@ async function startGateway() {
                       probeQuotaViaBroker: (t) => probeQuotaForBootCard(agentSlug, t),
                       tmuxSupervisor: process.env.SWITCHROOM_TMUX_SUPERVISOR === "1",
                       dockerMode: process.env.SWITCHROOM_RUNTIME === "docker",
-                      configSnapshotPath: join76(resolvedAgentDirForBootCard, ".config-snapshot.json"),
-                      bootCardStatePath: join76(resolvedAgentDirForBootCard, ".boot-card-msgid.json"),
+                      configSnapshotPath: join77(resolvedAgentDirForBootCard, ".config-snapshot.json"),
+                      bootCardStatePath: join77(resolvedAgentDirForBootCard, ".boot-card-msgid.json"),
                       floodStatePath: FLOOD_STATE_PATH,
                       ...updateOutcomeLine ? { updateOutcomeLine } : {}
                     }, ackMsgId);
@@ -118101,7 +118653,7 @@ async function startGateway() {
           if (smAgentDir) {
             const resolutionTimeoutMs = resolveSessionModelResolutionTimeoutMs(process.env.SWITCHROOM_SESSION_MODEL_RESOLUTION_TIMEOUT_MS);
             const resolved = await waitForSessionModelResolution({
-              barrierExists: () => existsSync64(join76(smAgentDir, ".session-model-resolved")),
+              barrierExists: () => existsSync65(join77(smAgentDir, ".session-model-resolved")),
               timeoutMs: resolutionTimeoutMs
             });
             if (!resolved) {
@@ -118109,10 +118661,10 @@ async function startGateway() {
               process.stderr.write(`telegram gateway: gw /model relaunch UNRESOLVED agent=${getMyAgentName()} target=${target} (barrier timeout after ${resolutionTimeoutMs}ms)
 `);
             } else {
-              const activePath = join76(smAgentDir, ".active-session-model");
-              if (existsSync64(activePath)) {
+              const activePath = join77(smAgentDir, ".active-session-model");
+              if (existsSync65(activePath)) {
                 try {
-                  const launched = readFileSync66(activePath, "utf8").trim();
+                  const launched = readFileSync67(activePath, "utf8").trim();
                   const configured = (() => {
                     const d = switchroomExecJson(["agent", "list"]);
                     const raw = d?.agents?.find((a) => a.name === getMyAgentName())?.model ?? null;
@@ -118145,29 +118697,29 @@ async function startGateway() {
                     deliverModelSwitchBootNotice({
                       ...modelBootCardDeps,
                       confirmation,
-                      hasSessionModelAlert: existsSync64(join76(smAgentDir, ".session-model-alert"))
+                      hasSessionModelAlert: existsSync65(join77(smAgentDir, ".session-model-alert"))
                     });
                   }
                 } catch {}
               }
-              const activeEffortPath = join76(smAgentDir, ".active-session-effort");
-              if (existsSync64(activeEffortPath)) {
+              const activeEffortPath = join77(smAgentDir, ".active-session-effort");
+              if (existsSync65(activeEffortPath)) {
                 try {
-                  const launchedEffort = readFileSync66(activeEffortPath, "utf8").trim();
+                  const launchedEffort = readFileSync67(activeEffortPath, "utf8").trim();
                   const configuredEffort = getConfiguredEffortForPersist();
                   sessionEffortOverride = launchedEffort.length > 0 && launchedEffort !== configuredEffort ? launchedEffort : null;
                 } catch {}
               }
-              const alertPath = join76(smAgentDir, ".session-model-alert");
-              if (existsSync64(alertPath)) {
+              const alertPath = join77(smAgentDir, ".session-model-alert");
+              if (existsSync65(alertPath)) {
                 let alertText = null;
                 try {
-                  alertText = readFileSync66(alertPath, "utf8").trim();
+                  alertText = readFileSync67(alertPath, "utf8").trim();
                 } catch {
                   alertText = null;
                 }
                 try {
-                  unlinkSync31(alertPath);
+                  unlinkSync33(alertPath);
                 } catch {}
                 if (alertText && alertText.length > 0) {
                   const operators = loadAccess().allowFrom;