switchroom 0.14.48 → 0.14.49

package/dist/cli/switchroom.js

@@ -49462,8 +49462,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.14.48";
-var COMMIT_SHA = "a6517652";
+var VERSION = "0.14.49";
+var COMMIT_SHA = "df84be56";
 
 // src/cli/agent.ts
 init_source();

package/package.json

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

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

@@ -29493,6 +29493,37 @@ function persistSnapshot(path, snapshot) {
 }
 var init_config_snapshot = () => {};
 
+// gateway/boot-card-msgid.ts
+import { readFileSync as readFileSync27, writeFileSync as writeFileSync17 } from "node:fs";
+function bootCardChatKey(chatId, threadId) {
+  return `${chatId}:${threadId ?? ""}`;
+}
+function readStore(path) {
+  try {
+    const parsed = JSON.parse(readFileSync27(path, "utf8"));
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {}
+  return {};
+}
+function loadBootCardMsgId(path, chatKey3) {
+  const id = readStore(path)[chatKey3];
+  return typeof id === "number" && Number.isFinite(id) && id > 0 ? id : null;
+}
+function saveBootCardMsgId(path, chatKey3, messageId) {
+  if (!(Number.isFinite(messageId) && messageId > 0))
+    return;
+  try {
+    const store2 = readStore(path);
+    if (store2[chatKey3] === messageId)
+      return;
+    store2[chatKey3] = messageId;
+    writeFileSync17(path, JSON.stringify(store2), "utf8");
+  } catch {}
+}
+var init_boot_card_msgid = () => {};
+
 // gateway/boot-card.ts
 var exports_boot_card = {};
 __export(exports_boot_card, {
@@ -29640,22 +29671,46 @@ async function startBootCard(chatId, threadId, bot, opts, ackMessageId, log) {
     ...opts.updateOutcomeLine ? { updateOutcomeLine: opts.updateOutcomeLine } : {}
   });
   const silentBootCard = true;
-  let messageId;
-  try {
-    const sent = await bot.sendMessage(chatId, ackText, {
-      parse_mode: "HTML",
-      link_preview_options: { is_disabled: true },
-      ...threadId != null ? { message_thread_id: threadId } : {},
-      ...ackMessageId != null ? { reply_parameters: { message_id: ackMessageId } } : {},
-      ...silentBootCard ? { disable_notification: true } : {}
-    });
-    messageId = sent.message_id;
-    logger2(`telegram gateway: boot-card: posted msgId=${messageId} chatId=${chatId} reason=${opts.restartReason ?? "-"} reason_detail=${opts.restartReasonDetail ?? "-"} silent=${silentBootCard}
+  const chatKey3 = bootCardChatKey(chatId, threadId);
+  const reuseId = ackMessageId == null && opts.bootCardStatePath != null && bot.editMessageTextStrict != null ? loadBootCardMsgId(opts.bootCardStatePath, chatKey3) : null;
+  let messageId = -1;
+  if (reuseId != null && bot.editMessageTextStrict != null) {
+    try {
+      const outcome = await bot.editMessageTextStrict(chatId, reuseId, ackText, {
+        parse_mode: "HTML",
+        link_preview_options: { is_disabled: true },
+        ...threadId != null ? { message_thread_id: threadId } : {}
+      });
+      if (outcome === "edited") {
+        messageId = reuseId;
+        logger2(`telegram gateway: boot-card: reused msgId=${messageId} chatId=${chatId} reason=${opts.restartReason ?? "-"} reason_detail=${opts.restartReasonDetail ?? "-"} edit_in_place=true notify=none
 `);
-  } catch (err) {
-    logger2(`telegram gateway: boot-card: failed to post ack: ${err?.message ?? String(err)}
+      }
+    } catch (err) {
+      logger2(`telegram gateway: boot-card: edit-in-place probe failed (${err?.message ?? String(err)}) \u2014 sending fresh
 `);
-    return { messageId: -1, complete: () => {} };
+    }
+  }
+  if (messageId < 0) {
+    try {
+      const sent = await bot.sendMessage(chatId, ackText, {
+        parse_mode: "HTML",
+        link_preview_options: { is_disabled: true },
+        ...threadId != null ? { message_thread_id: threadId } : {},
+        ...ackMessageId != null ? { reply_parameters: { message_id: ackMessageId } } : {},
+        ...silentBootCard ? { disable_notification: true } : {}
+      });
+      messageId = sent.message_id;
+      logger2(`telegram gateway: boot-card: posted msgId=${messageId} chatId=${chatId} reason=${opts.restartReason ?? "-"} reason_detail=${opts.restartReasonDetail ?? "-"} silent=${silentBootCard}
+`);
+    } catch (err) {
+      logger2(`telegram gateway: boot-card: failed to post ack: ${err?.message ?? String(err)}
+`);
+      return { messageId: -1, complete: () => {} };
+    }
+  }
+  if (opts.bootCardStatePath != null && messageId > 0) {
+    saveBootCardMsgId(opts.bootCardStatePath, chatKey3, messageId);
   }
   const liveWindowMs = opts.agentLiveWindowMs ?? AGENT_LIVE_WINDOW_MS;
   setTimeoutFn(() => {
@@ -29822,6 +29877,7 @@ var init_boot_card = __esm(() => {
   init_boot_probes();
   init_boot_issue_cache();
   init_config_snapshot();
+  init_boot_card_msgid();
   init_loader();
   init_merge();
   DOT = {
@@ -30211,8 +30267,8 @@ var init_flock = () => {};
 // ../src/vault/vault.ts
 import { randomBytes as randomBytes5, scryptSync, createCipheriv, createDecipheriv } from "node:crypto";
 import {
-  readFileSync as readFileSync34,
-  writeFileSync as writeFileSync22,
+  readFileSync as readFileSync35,
+  writeFileSync as writeFileSync23,
   existsSync as existsSync36,
   renameSync as renameSync11,
   mkdirSync as mkdirSync23,
@@ -30256,7 +30312,7 @@ function openVault(passphrase, vaultPath) {
   }
   let vaultFile;
   try {
-    vaultFile = JSON.parse(readFileSync34(vaultPath, "utf8"));
+    vaultFile = JSON.parse(readFileSync35(vaultPath, "utf8"));
   } catch {
     throw new VaultError(`Failed to read vault file: ${vaultPath}`);
   }
@@ -30637,7 +30693,7 @@ __export(exports_tmux, {
   captureAgentPane: () => captureAgentPane
 });
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { mkdirSync as mkdirSync25, readdirSync as readdirSync6, statSync as statSync12, unlinkSync as unlinkSync13, writeFileSync as writeFileSync23 } from "node:fs";
+import { mkdirSync as mkdirSync25, readdirSync as readdirSync6, statSync as statSync12, unlinkSync as unlinkSync13, writeFileSync as writeFileSync24 } from "node:fs";
 import { resolve as resolve7 } from "node:path";
 function captureAgentPane(opts) {
   const { agentName: agentName3, agentDir, reason } = opts;
@@ -30683,7 +30739,7 @@ function captureAgentPane(opts) {
 ` + `
 `;
   try {
-    writeFileSync23(outPath, Buffer.concat([Buffer.from(header, "utf8"), body]), {
+    writeFileSync24(outPath, Buffer.concat([Buffer.from(header, "utf8"), body]), {
       mode: 420
     });
   } catch (err) {
@@ -31259,8 +31315,8 @@ var import_runner2 = __toESM(require_mod3(), 1);
 import { randomBytes as randomBytes6 } from "crypto";
 import { execFileSync as execFileSync5, execSync as execSync2, spawn as spawn2 } from "child_process";
 import {
-  readFileSync as readFileSync35,
-  writeFileSync as writeFileSync24,
+  readFileSync as readFileSync36,
+  writeFileSync as writeFileSync25,
   mkdirSync as mkdirSync26,
   readdirSync as readdirSync7,
   rmSync as rmSync4,
@@ -50439,7 +50495,7 @@ function determineRestartReason(opts) {
 init_boot_card();
 
 // gateway/update-announce.ts
-import { existsSync as existsSync29, mkdirSync as mkdirSync17, openSync as openSync3, closeSync as closeSync3, readFileSync as readFileSync27 } from "node:fs";
+import { existsSync as existsSync29, mkdirSync as mkdirSync17, openSync as openSync3, closeSync as closeSync3, readFileSync as readFileSync28 } from "node:fs";
 import { join as join26 } from "node:path";
 import { homedir as homedir12 } from "node:os";
 
@@ -50554,7 +50610,7 @@ var DEFAULT_LOOKBACK_MS = 10 * 60 * 1000;
 function readLastTerminalUpdateAudit(opts = {}) {
   const path = opts.auditLogPath ?? defaultAuditLogPath();
   const exists = opts.exists ?? existsSync29;
-  const readFile = opts.readFile ?? ((p) => readFileSync27(p, "utf-8"));
+  const readFile = opts.readFile ?? ((p) => readFileSync28(p, "utf-8"));
   if (!exists(path))
     return null;
   let raw;
@@ -50642,7 +50698,7 @@ function maybeRenderUpdateAnnouncement(opts = {}) {
 }
 
 // issues-card.ts
-import { readFileSync as readFileSync28, writeFileSync as writeFileSync17 } from "node:fs";
+import { readFileSync as readFileSync29, writeFileSync as writeFileSync18 } from "node:fs";
 var SEVERITY_EMOJI = {
   info: "\u2139\ufe0f",
   warn: "\u26a0\ufe0f",
@@ -50734,7 +50790,7 @@ function extractRetryAfterSecs2(err) {
 var COOLDOWN_JITTER_MS2 = 500;
 function readPersistedMessageId(path, log) {
   try {
-    const raw = readFileSync28(path, "utf8");
+    const raw = readFileSync29(path, "utf8");
     const parsed = JSON.parse(raw);
     const v = parsed.messageId;
     if (typeof v === "number" && Number.isInteger(v) && v > 0)
@@ -50750,7 +50806,7 @@ function readPersistedMessageId(path, log) {
 }
 function writePersistedMessageId(path, messageId, log) {
   try {
-    writeFileSync17(path, JSON.stringify({ messageId }) + `
+    writeFileSync18(path, JSON.stringify({ messageId }) + `
 `, { mode: 384 });
   } catch (err) {
     log(`issues-card: persist write failed (${err.message})`);
@@ -50853,11 +50909,11 @@ import {
   mkdirSync as mkdirSync18,
   openSync as openSync4,
   readdirSync as readdirSync5,
-  readFileSync as readFileSync29,
+  readFileSync as readFileSync30,
   renameSync as renameSync10,
   statSync as statSync7,
   unlinkSync as unlinkSync10,
-  writeFileSync as writeFileSync18,
+  writeFileSync as writeFileSync19,
   writeSync
 } from "node:fs";
 import { join as join27 } from "node:path";
@@ -50884,7 +50940,7 @@ function readAll(stateDir) {
     return [];
   let raw;
   try {
-    raw = readFileSync29(path, "utf-8");
+    raw = readFileSync30(path, "utf-8");
   } catch {
     return [];
   }
@@ -50940,7 +50996,7 @@ function writeAll(stateDir, events) {
   const body = events.length === 0 ? "" : events.map((e) => JSON.stringify(e)).join(`
 `) + `
 `;
-  writeFileSync18(tmp, body, "utf-8");
+  writeFileSync19(tmp, body, "utf-8");
   renameSync10(tmp, path);
 }
 var ORPHAN_TMP_TTL_MS = 60000;
@@ -51003,7 +51059,7 @@ function withLock(stateDir, fn) {
 function tryStealStaleLock(lockPath) {
   let pidStr;
   try {
-    pidStr = readFileSync29(lockPath, "utf-8").trim();
+    pidStr = readFileSync30(lockPath, "utf-8").trim();
   } catch {
     return true;
   }
@@ -51781,7 +51837,7 @@ function extractFlowItems(line) {
 }
 
 // credits-watch.ts
-import { readFileSync as readFileSync30, writeFileSync as writeFileSync19, existsSync as existsSync32, mkdirSync as mkdirSync19 } from "fs";
+import { readFileSync as readFileSync31, writeFileSync as writeFileSync20, existsSync as existsSync32, mkdirSync as mkdirSync19 } from "fs";
 import { join as join29 } from "path";
 var STATE_FILE = "credits-watch.json";
 var FATAL_REASONS = new Set([
@@ -51799,7 +51855,7 @@ function readClaudeJsonOverage(claudeConfigDir) {
     return null;
   let raw;
   try {
-    raw = readFileSync30(path, "utf-8");
+    raw = readFileSync31(path, "utf-8");
   } catch {
     return null;
   }
@@ -51883,7 +51939,7 @@ function loadCreditState(stateDir) {
   if (!existsSync32(path))
     return emptyCreditState();
   try {
-    const raw = readFileSync30(path, "utf-8");
+    const raw = readFileSync31(path, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && (parsed.lastNotifiedReason === null || typeof parsed.lastNotifiedReason === "string") && typeof parsed.lastNotifiedAt === "number" && Number.isFinite(parsed.lastNotifiedAt)) {
       return {
@@ -51897,12 +51953,12 @@ function loadCreditState(stateDir) {
 function saveCreditState(stateDir, state4) {
   mkdirSync19(stateDir, { recursive: true });
   const path = join29(stateDir, STATE_FILE);
-  writeFileSync19(path, JSON.stringify(state4, null, 2) + `
+  writeFileSync20(path, JSON.stringify(state4, null, 2) + `
 `, { mode: 384 });
 }
 
 // quota-watch.ts
-import { readFileSync as readFileSync31, writeFileSync as writeFileSync20, existsSync as existsSync33, mkdirSync as mkdirSync20 } from "fs";
+import { readFileSync as readFileSync32, writeFileSync as writeFileSync21, existsSync as existsSync33, mkdirSync as mkdirSync20 } from "fs";
 import { join as join30 } from "path";
 var STATE_FILE2 = "quota-watch.json";
 function emptyQuotaWatchState() {
@@ -51997,7 +52053,7 @@ function loadQuotaWatchState(stateDir) {
   if (!existsSync33(path))
     return emptyQuotaWatchState();
   try {
-    const raw = readFileSync31(path, "utf-8");
+    const raw = readFileSync32(path, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
       return emptyQuotaWatchState();
@@ -52016,7 +52072,7 @@ function loadQuotaWatchState(stateDir) {
 function saveQuotaWatchState(stateDir, state4) {
   mkdirSync20(stateDir, { recursive: true });
   const path = join30(stateDir, STATE_FILE2);
-  writeFileSync20(path, JSON.stringify(state4, null, 2) + `
+  writeFileSync21(path, JSON.stringify(state4, null, 2) + `
 `, { mode: 384 });
 }
 function patchQuotaWatchState(current, accountLabel, accountState) {
@@ -52032,18 +52088,18 @@ import {
   existsSync as existsSync34,
   mkdirSync as mkdirSync21,
   openSync as openSync5,
-  readFileSync as readFileSync32,
+  readFileSync as readFileSync33,
   statSync as statSync9,
   unlinkSync as unlinkSync11,
   utimesSync as utimesSync2,
-  writeFileSync as writeFileSync21
+  writeFileSync as writeFileSync22
 } from "node:fs";
 import { join as join31 } from "node:path";
 var TURN_ACTIVE_MARKER_FILE2 = "turn-active.json";
 function writeTurnActiveMarker(stateDir, marker) {
   try {
     mkdirSync21(stateDir, { recursive: true });
-    writeFileSync21(join31(stateDir, TURN_ACTIVE_MARKER_FILE2), JSON.stringify(marker, null, 2) + `
+    writeFileSync22(join31(stateDir, TURN_ACTIVE_MARKER_FILE2), JSON.stringify(marker, null, 2) + `
 `, { mode: 384 });
   } catch {}
 }
@@ -52080,7 +52136,7 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
       return false;
     let payload = null;
     try {
-      payload = readFileSync32(path, "utf8");
+      payload = readFileSync33(path, "utf8");
     } catch {}
     unlinkSync11(path);
     if (opts.onRemove) {
@@ -52099,10 +52155,10 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.48";
-var COMMIT_SHA = "a6517652";
-var COMMIT_DATE = "2026-06-03T07:57:29Z";
-var LATEST_PR = 2120;
+var VERSION = "0.14.49";
+var COMMIT_SHA = "df84be56";
+var COMMIT_DATE = "2026-06-03T09:45:46Z";
+var LATEST_PR = 2123;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -52849,7 +52905,7 @@ function formatBootVersion() {
 }
 try {
   chmodSync6(ENV_FILE, 384);
-  for (const line of readFileSync35(ENV_FILE, "utf8").split(`
+  for (const line of readFileSync36(ENV_FILE, "utf8").split(`
 `)) {
     const m = line.match(/^(\w+)=(.*)$/);
     if (m && process.env[m[1]] === undefined)
@@ -52902,7 +52958,7 @@ installTgPostLogger(bot);
 var _rawSendMessageDraft = bot.api.raw.sendMessageDraft;
 var GRAMMY_VERSION = (() => {
   try {
-    const raw = readFileSync35(new URL("../../node_modules/grammy/package.json", import.meta.url), "utf8");
+    const raw = readFileSync36(new URL("../../node_modules/grammy/package.json", import.meta.url), "utf8");
     return JSON.parse(raw).version ?? "unknown";
   } catch {
     return "unknown";
@@ -52994,7 +53050,7 @@ function assertSendable(f) {
 }
 function readAccessFile() {
   try {
-    const raw = readFileSync35(ACCESS_FILE, "utf8");
+    const raw = readFileSync36(ACCESS_FILE, "utf8");
     const parsed = JSON.parse(raw);
     const allowFrom = validateStringArray("allowFrom", parsed.allowFrom ?? []);
     const groups = {};
@@ -53064,7 +53120,7 @@ function saveAccess(a) {
     return;
   mkdirSync26(STATE_DIR, { recursive: true, mode: 448 });
   const tmp = ACCESS_FILE + ".tmp";
-  writeFileSync24(tmp, JSON.stringify(a, null, 2) + `
+  writeFileSync25(tmp, JSON.stringify(a, null, 2) + `
 `, { mode: 384 });
   renameSync12(tmp, ACCESS_FILE);
 }
@@ -53105,7 +53161,7 @@ try {
       const st = statSync13(markerPath);
       markerAgeMs = Date.now() - st.mtimeMs;
       try {
-        const payload = JSON.parse(readFileSync35(markerPath, "utf8"));
+        const payload = JSON.parse(readFileSync36(markerPath, "utf8"));
         if (typeof payload.turnKey === "string" && payload.turnKey.length > 0) {
           markerTurnKey = payload.turnKey;
         }
@@ -53176,7 +53232,7 @@ try {
         pending2.interrupt_reason != null ? `SWITCHROOM_PENDING_INTERRUPT_REASON=${pending2.interrupt_reason}` : `SWITCHROOM_PENDING_INTERRUPT_REASON=`
       ];
       const pendingEnvTmp = `${pendingEnvPath}.tmp-${process.pid}`;
-      writeFileSync24(pendingEnvTmp, lines.join(`
+      writeFileSync25(pendingEnvTmp, lines.join(`
 `) + `
 `, { mode: 384 });
       renameSync12(pendingEnvTmp, pendingEnvPath);
@@ -53798,7 +53854,18 @@ function wrapBootCardApi(threadId) {
       const sent = await robustApiCall(() => lockedBot.api.sendMessage(cid, text, sendOpts), opts(cid));
       return sent;
     },
-    editMessageText: (cid, mid, text, editOpts) => robustApiCall(() => lockedBot.api.editMessageText(cid, mid, text, editOpts), opts(cid))
+    editMessageText: (cid, mid, text, editOpts) => robustApiCall(() => lockedBot.api.editMessageText(cid, mid, text, editOpts), opts(cid)),
+    editMessageTextStrict: async (cid, mid, text, editOpts) => {
+      try {
+        await lockedBot.api.editMessageText(cid, mid, text, editOpts);
+        return "edited";
+      } catch (err) {
+        const desc = err instanceof import_grammy9.GrammyError ? err.description : err instanceof Error ? err.message : String(err);
+        if (typeof desc === "string" && desc.toLowerCase().includes("not modified"))
+          return "edited";
+        return "gone";
+      }
+    }
   };
 }
 function wrapIssuesCardApi(threadId) {
@@ -54496,8 +54563,8 @@ var inboundSpool = STATIC ? undefined : createInboundSpool({
   path: join35(STATE_DIR, "inbound-spool.jsonl"),
   fs: {
     appendFileSync: (p, d) => appendFileSync5(p, d),
-    readFileSync: (p) => readFileSync35(p, "utf8"),
-    writeFileSync: (p, d) => writeFileSync24(p, d),
+    readFileSync: (p) => readFileSync36(p, "utf8"),
+    writeFileSync: (p, d) => writeFileSync25(p, d),
     renameSync: (a, b) => renameSync12(a, b),
     existsSync: (p) => existsSync38(p),
     statSizeSync: (p) => statSync13(p).size
@@ -54642,6 +54709,7 @@ var ipcServer = createIpcServer({
             tmuxSupervisor: process.env.SWITCHROOM_TMUX_SUPERVISOR === "1",
             dockerMode: process.env.SWITCHROOM_RUNTIME === "docker",
             configSnapshotPath: join35(resolvedAgentDirForCard, ".config-snapshot.json"),
+            bootCardStatePath: join35(resolvedAgentDirForCard, ".boot-card-msgid.json"),
             ...updateOutcomeLine ? { updateOutcomeLine } : {}
           }, ackMsgId).then((handle) => {
             activeBootCard = handle;
@@ -56081,7 +56149,7 @@ async function publishToTelegraph(text, shortName, authorName) {
   let account = null;
   try {
     if (existsSync38(accountPath)) {
-      const raw = readFileSync35(accountPath, "utf-8");
+      const raw = readFileSync36(accountPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.shortName && parsed.accessToken) {
         account = parsed;
@@ -56101,7 +56169,7 @@ async function publishToTelegraph(text, shortName, authorName) {
     account = created.value;
     try {
       mkdirSync26(STATE_DIR, { recursive: true, mode: 448 });
-      writeFileSync24(accountPath, JSON.stringify(account, null, 2), { mode: 384 });
+      writeFileSync25(accountPath, JSON.stringify(account, null, 2), { mode: 384 });
     } catch (err) {
       process.stderr.write(`telegram gateway: telegraph cache write failed: ${err.message}
 `);
@@ -56575,7 +56643,7 @@ async function executeDownloadAttachment(args) {
   });
   mkdirSync26(INBOX_DIR, { recursive: true, mode: 448 });
   assertInsideInbox(INBOX_DIR, dlPath);
-  writeFileSync24(dlPath, buf, { mode: 384 });
+  writeFileSync25(dlPath, buf, { mode: 384 });
   return { content: [{ type: "text", text: dlPath }] };
 }
 async function executeEditMessage(args) {
@@ -58464,7 +58532,7 @@ function writeRestartMarker(marker) {
   if (!p)
     return;
   try {
-    writeFileSync24(p, JSON.stringify(marker));
+    writeFileSync25(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}
 `);
@@ -58483,7 +58551,7 @@ function readRestartMarker() {
   if (!p)
     return null;
   try {
-    return JSON.parse(readFileSync35(p, "utf8"));
+    return JSON.parse(readFileSync36(p, "utf8"));
   } catch {
     return null;
   }
@@ -58620,7 +58688,7 @@ function spawnSwitchroomDetached(args, onFailure) {
   try {
     mkdirSync26(STATE_DIR, { recursive: true });
     outFd = openSync8(logPath, "a");
-    writeFileSync24(logPath, `
+    writeFileSync25(logPath, `
 [${new Date().toISOString()}] spawn ${SWITCHROOM_CLI} ${fullArgs.join(" ")}
 `, { flag: "a" });
   } catch {}
@@ -58646,7 +58714,7 @@ function spawnSwitchroomDetached(args, onFailure) {
         return;
       let tail = "";
       try {
-        const full = readFileSync35(logPath, "utf8");
+        const full = readFileSync36(logPath, "utf8");
         tail = full.split(`
 `).slice(-30).join(`
 `).trim();
@@ -58991,7 +59059,7 @@ function readRecentDenialsForAgent(agentName3, windowMs, limit) {
     const auditPath = join35(homedir14(), ".switchroom", "vault-audit.log");
     if (!existsSync38(auditPath))
       return [];
-    const raw = readFileSync35(auditPath, "utf8");
+    const raw = readFileSync36(auditPath, "utf8");
     return recentDenialsFromAuditLog(raw, { agentName: agentName3, windowMs, limit });
   } catch {
     return [];
@@ -59042,7 +59110,7 @@ async function buildAgentMetadata(agentName3) {
   try {
     const agentDir = resolveAgentDirFromEnv();
     if (agentDir) {
-      const raw = readFileSync35(join35(agentDir, ".claude", ".claude.json"), "utf8");
+      const raw = readFileSync36(join35(agentDir, ".claude", ".claude.json"), "utf8");
       claudeJson = JSON.parse(raw);
     }
   } catch {}
@@ -59314,7 +59382,7 @@ async function handleNewOrResetCommand(ctx, kind) {
   writeRestartMarker({ chat_id: chatId, thread_id: threadId ?? null, ack_message_id: ackId, ts: Date.now() });
   if (agentDir != null) {
     try {
-      writeFileSync24(join35(agentDir, ".force-fresh-session"), `${kind} at ${new Date().toISOString()}
+      writeFileSync25(join35(agentDir, ".force-fresh-session"), `${kind} at ${new Date().toISOString()}
 `, "utf8");
     } catch (err) {
       process.stderr.write(`telegram gateway: failed to write force-fresh marker: ${err}
@@ -59678,8 +59746,8 @@ bot.command("interrupt", async (ctx) => {
   await runSwitchroomCommand(ctx, ["agent", "interrupt", name], `interrupt ${name}`);
 });
 var lockoutOps = {
-  readFileSync: (p, enc) => readFileSync35(p, enc),
-  writeFileSync: (p, data, opts) => writeFileSync24(p, data, opts),
+  readFileSync: (p, enc) => readFileSync36(p, enc),
+  writeFileSync: (p, data, opts) => writeFileSync25(p, data, opts),
   existsSync: (p) => existsSync38(p),
   mkdirSync: (p, opts) => mkdirSync26(p, opts),
   joinPath: (...parts) => join35(...parts)
@@ -60054,7 +60122,7 @@ async function handleVaultRecentDenialCallback(ctx, data) {
   const tokenPath = join35(homedir14(), ".switchroom", "agents", agentName3, ".vault-token");
   try {
     mkdirSync26(join35(homedir14(), ".switchroom", "agents", agentName3), { recursive: true });
-    writeFileSync24(tokenPath, token, { mode: 384 });
+    writeFileSync25(tokenPath, token, { mode: 384 });
   } catch (err) {
     await switchroomReply(ctx, `<b>Grant created (${escapeHtmlForTg(id)}) but token write failed:</b> ${escapeHtmlForTg(String(err))}
 <i>Recover with: <code>switchroom vault grant ${escapeHtmlForTg(agentName3)} --keys ${escapeHtmlForTg(keyName)} --duration 30d</code> on the host.</i>`, { html: true });
@@ -60133,7 +60201,7 @@ async function performVaultAccessApproval(ctx, pending2, stageId, senderId, atte
   const tokenPath = join35(homedir14(), ".switchroom", "agents", pending2.agent, ".vault-token");
   try {
     mkdirSync26(join35(homedir14(), ".switchroom", "agents", pending2.agent), { recursive: true });
-    writeFileSync24(tokenPath, token, { mode: 384 });
+    writeFileSync25(tokenPath, token, { mode: 384 });
   } catch (err) {
     await switchroomReply(ctx, `<b>Grant created (${escapeHtmlForTg(id)}) but token write failed:</b> ${escapeHtmlForTg(String(err))}
 <i>Recover with: <code>switchroom vault grant ${escapeHtmlForTg(pending2.agent)} --keys ${escapeHtmlForTg(pending2.key)} --duration ${Math.round(pending2.ttl_seconds / 86400)}d</code> on the host.</i>`, { html: true });
@@ -60637,7 +60705,7 @@ async function executeGrantWizard(ctx, chatId, state4) {
   const tokenPath = join35(homedir14(), ".switchroom", "agents", state4.agent, ".vault-token");
   try {
     mkdirSync26(join35(homedir14(), ".switchroom", "agents", state4.agent), { recursive: true });
-    writeFileSync24(tokenPath, token, { mode: 384 });
+    writeFileSync25(tokenPath, token, { mode: 384 });
   } catch (err) {
     await switchroomReply(ctx, `<b>Grant created but token write failed:</b> ${escapeHtmlForTg(String(err))}`, { html: true });
     return;
@@ -61933,7 +62001,7 @@ ${preBlock(formatSwitchroomOutput(err.message ?? "unknown error"))}`, { html: tr
     const unifiedDiff = (() => {
       try {
         const cfgPath = process.env.SWITCHROOM_CONFIG ?? SWITCHROOM_CONFIG ?? findConfigFile2();
-        const raw = readFileSync35(cfgPath, "utf8");
+        const raw = readFileSync36(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}
@@ -62081,7 +62149,7 @@ bot.on("message:photo", async (ctx) => {
       });
       mkdirSync26(INBOX_DIR, { recursive: true, mode: 448 });
       assertInsideInbox(INBOX_DIR, dlPath);
-      writeFileSync24(dlPath, buf, { mode: 384 });
+      writeFileSync25(dlPath, buf, { mode: 384 });
       return dlPath;
     } catch (err) {
       const msg = err instanceof Error ? err.message : "unknown error";
@@ -62122,7 +62190,7 @@ async function maybeTranscribeVoice(fileId, mimeType, language) {
   try {
     const path = __require("path").join(__require("os").homedir(), ".switchroom", "openai-api-key");
     if (existsSync38(path)) {
-      apiKey = readFileSync35(path, "utf-8").trim();
+      apiKey = readFileSync36(path, "utf-8").trim();
     }
   } catch (err) {
     process.stderr.write(`telegram gateway: voice-in: failed to read api key: ${err.message}
@@ -62992,6 +63060,7 @@ var didOneTimeSetup = false;
                       tmuxSupervisor: process.env.SWITCHROOM_TMUX_SUPERVISOR === "1",
                       dockerMode: process.env.SWITCHROOM_RUNTIME === "docker",
                       configSnapshotPath: join35(resolvedAgentDirForBootCard, ".config-snapshot.json"),
+                      bootCardStatePath: join35(resolvedAgentDirForBootCard, ".boot-card-msgid.json"),
                       ...updateOutcomeLine ? { updateOutcomeLine } : {}
                     }, ackMsgId);
                     activeBootCard = handle;

package/telegram-plugin/gateway/boot-card-msgid.ts

@@ -0,0 +1,70 @@
+/**
+ * Cross-reboot persistence for the boot card's Telegram message id.
+ *
+ * Why: a freshly *sent* Telegram message always bumps the chat's unread
+ * badge — `disable_notification: true` removes the sound/banner but not the
+ * badge (there is no Bot API flag for that). To make routine reboots produce
+ * ZERO notification (operator request, 2026-06-03), the gateway reuses the
+ * PRIOR boot card's message and EDITS it in place instead of sending a new
+ * one — and edits never touch the badge.
+ *
+ * That requires remembering the last boot card's `message_id` across gateway
+ * restarts, keyed by the chat (+ forum topic) it lives in. This module is the
+ * tiny JSON store for that, mirroring `config-snapshot.ts` /
+ * `boot-issue-cache.ts`: one file under the agent's (bind-mounted, reboot-
+ * surviving) state dir, read once on boot, written once after the id is
+ * established. All failures are non-fatal — a missing/corrupt file just means
+ * "no prior card", so the boot path falls back to a fresh (silent) send.
+ */
+
+import { readFileSync, writeFileSync } from 'node:fs'
+
+/** Stable key for a boot-card target: chat id + optional forum topic. A DM
+ *  agent always boots to the same `<chatId>:` key; a supergroup agent keys by
+ *  `<chatId>:<threadId>` so a topic change starts a fresh card. */
+export function bootCardChatKey(chatId: string, threadId: number | undefined): string {
+  return `${chatId}:${threadId ?? ''}`
+}
+
+type Store = Record<string, number>
+
+function readStore(path: string): Store {
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf8')) as unknown
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      return parsed as Store
+    }
+  } catch {
+    /* missing / corrupt → treat as empty */
+  }
+  return {}
+}
+
+/** The persisted message id for this chat+topic, or null when there's no
+ *  prior boot card to reuse (first boot, corrupt file, different chat). */
+export function loadBootCardMsgId(
+  path: string,
+  chatKey: string,
+): number | null {
+  const id = readStore(path)[chatKey]
+  return typeof id === 'number' && Number.isFinite(id) && id > 0 ? id : null
+}
+
+/** Record the current boot card's message id for this chat+topic. Merges into
+ *  the existing store (other chats' ids survive). Non-fatal on write failure —
+ *  the worst case is the next reboot sends a fresh card (one badge). */
+export function saveBootCardMsgId(
+  path: string,
+  chatKey: string,
+  messageId: number,
+): void {
+  if (!(Number.isFinite(messageId) && messageId > 0)) return
+  try {
+    const store = readStore(path)
+    if (store[chatKey] === messageId) return // idempotent — no rewrite
+    store[chatKey] = messageId
+    writeFileSync(path, JSON.stringify(store), 'utf8')
+  } catch {
+    /* non-fatal */
+  }
+}

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

@@ -67,6 +67,7 @@ import {
   type ConfigDiff,
 } from './config-snapshot.js'
 import { join } from 'path'
+import { bootCardChatKey, loadBootCardMsgId, saveBootCardMsgId } from './boot-card-msgid.js'
 import { loadConfig as _loadSwitchroomConfig } from '../../src/config/loader.js'
 import { resolveAgentConfig as _resolveAgentConfig } from '../../src/config/merge.js'
 
@@ -134,6 +135,21 @@ export interface BotApiForBootCard {
     text: string,
     opts?: Record<string, unknown>,
   ): Promise<unknown>
+  /**
+   * Like `editMessageText`, but reports whether the target message still
+   * exists rather than swallowing a "message to edit not found" the way the
+   * shared retry policy does (retry-api-call.ts) — the boot path needs to
+   * know so it can fall back to a fresh send when the prior card was deleted.
+   * `'edited'` = the edit landed (or content was identical → message exists);
+   * `'gone'` = the message is missing (or any other error → send fresh).
+   * Optional so existing callers/tests without it fall back to always-send.
+   */
+  editMessageTextStrict?(
+    chatId: string,
+    messageId: number,
+    text: string,
+    opts?: Record<string, unknown>,
+  ): Promise<'edited' | 'gone'>
 }
 
 export interface BootCardHandle {
@@ -568,6 +584,17 @@ export interface RunProbesOpts {
    * resolve the default memory collection label.
    */
   configSnapshotPath?: string
+  /**
+   * Cross-reboot store for the boot card's Telegram message id (JSON,
+   * typically `<agentDir>/.boot-card-msgid.json`). When set AND the bot
+   * supports `editMessageTextStrict`, a routine reboot (no `ackMessageId`)
+   * EDITS the prior boot card in place instead of sending a new one — edits
+   * never bump the unread badge, so reboots produce zero notification
+   * (operator request 2026-06-03). Falls back to a fresh silent send when
+   * there's no prior card or it was deleted. Omit to keep the always-send
+   * behaviour.
+   */
+  bootCardStatePath?: string
 }
 
 /** Run all six probes concurrently with their own per-probe timeouts.
@@ -641,20 +668,60 @@ export async function startBootCard(
   // the chat is where you look, and nothing here warrants a push.
   const silentBootCard = true
 
-  let messageId: number
-  try {
-    const sent = await bot.sendMessage(chatId, ackText, {
-      parse_mode: 'HTML',
-      link_preview_options: { is_disabled: true },
-      ...(threadId != null ? { message_thread_id: threadId } : {}),
-      ...(ackMessageId != null ? { reply_parameters: { message_id: ackMessageId } } : {}),
-      ...(silentBootCard ? { disable_notification: true } : {}),
-    })
-    messageId = sent.message_id
-    logger(`telegram gateway: boot-card: posted msgId=${messageId} chatId=${chatId} reason=${opts.restartReason ?? '-'} reason_detail=${opts.restartReasonDetail ?? '-'} silent=${silentBootCard}\n`)
-  } catch (err: unknown) {
-    logger(`telegram gateway: boot-card: failed to post ack: ${(err as Error)?.message ?? String(err)}\n`)
-    return { messageId: -1, complete: () => {} }
+  // Edit-in-place to produce ZERO notification (operator request 2026-06-03).
+  // A sent message always bumps the unread badge — `disable_notification`
+  // only kills the sound/banner. So for a ROUTINE reboot (no `ackMessageId`:
+  // operator update / cli rollout / crash / fresh) we EDIT the prior boot
+  // card in place — edits never touch the badge — instead of sending a new
+  // one. We only do this when the bot can tell us the prior message still
+  // exists (`editMessageTextStrict`); if it's gone, or this is a
+  // Telegram-initiated `/restart` (ackMessageId set — the operator asked and
+  // is watching, and the card should reply to their command), we fall back to
+  // a fresh silent send.
+  const chatKey = bootCardChatKey(chatId, threadId)
+  const reuseId =
+    ackMessageId == null && opts.bootCardStatePath != null && bot.editMessageTextStrict != null
+      ? loadBootCardMsgId(opts.bootCardStatePath, chatKey)
+      : null
+
+  let messageId = -1
+  if (reuseId != null && bot.editMessageTextStrict != null) {
+    try {
+      const outcome = await bot.editMessageTextStrict(chatId, reuseId, ackText, {
+        parse_mode: 'HTML',
+        link_preview_options: { is_disabled: true },
+        ...(threadId != null ? { message_thread_id: threadId } : {}),
+      })
+      if (outcome === 'edited') {
+        messageId = reuseId
+        logger(`telegram gateway: boot-card: reused msgId=${messageId} chatId=${chatId} reason=${opts.restartReason ?? '-'} reason_detail=${opts.restartReasonDetail ?? '-'} edit_in_place=true notify=none\n`)
+      }
+    } catch (err: unknown) {
+      logger(`telegram gateway: boot-card: edit-in-place probe failed (${(err as Error)?.message ?? String(err)}) — sending fresh\n`)
+    }
+  }
+
+  if (messageId < 0) {
+    try {
+      const sent = await bot.sendMessage(chatId, ackText, {
+        parse_mode: 'HTML',
+        link_preview_options: { is_disabled: true },
+        ...(threadId != null ? { message_thread_id: threadId } : {}),
+        ...(ackMessageId != null ? { reply_parameters: { message_id: ackMessageId } } : {}),
+        ...(silentBootCard ? { disable_notification: true } : {}),
+      })
+      messageId = sent.message_id
+      logger(`telegram gateway: boot-card: posted msgId=${messageId} chatId=${chatId} reason=${opts.restartReason ?? '-'} reason_detail=${opts.restartReasonDetail ?? '-'} silent=${silentBootCard}\n`)
+    } catch (err: unknown) {
+      logger(`telegram gateway: boot-card: failed to post ack: ${(err as Error)?.message ?? String(err)}\n`)
+      return { messageId: -1, complete: () => {} }
+    }
+  }
+
+  // Remember this card's id so the NEXT reboot can edit it in place (no
+  // notification). Idempotent on reuse; non-fatal on write failure.
+  if (opts.bootCardStatePath != null && messageId > 0) {
+    saveBootCardMsgId(opts.bootCardStatePath, chatKey, messageId)
   }
 
   // Determine the live window for agent-service status updates. Callers

package/telegram-plugin/gateway/gateway.ts

@@ -9,7 +9,7 @@
  * is connected, inbound LLM messages get a "⏳ Agent is restarting…" reply.
  */
 
-import { Bot, GrammyError, InlineKeyboard, InputFile, type Context } from 'grammy'
+import { Bot, GrammyError, InlineKeyboard, InputFile, type Context, type Api } from 'grammy'
 import { run, type RunnerHandle } from '@grammyjs/runner'
 import type { ReactionTypeEmoji } from 'grammy/types'
 import { randomBytes } from 'crypto'
@@ -2603,6 +2603,26 @@ function wrapBootCardApi(
           ),
         opts(cid),
       ) as Promise<unknown>,
+    // Strict edit for the boot-card edit-in-place probe: distinguishes
+    // "message gone" (→ 'gone', caller sends fresh) from a landed/identical
+    // edit (→ 'edited'). robustApiCall SWALLOWS "message to edit not found"
+    // to undefined (retry-api-call.ts), so this can't go through it — a
+    // deliberate single-attempt raw edit that classifies the error itself.
+    editMessageTextStrict: async (cid, mid, text, editOpts) => {
+      type EditOpts = Parameters<Api['editMessageText']>[3]
+      try {
+        // allow-raw-bot-api: boot-card edit-in-place probe — must detect a deleted target, which the shared retry policy swallows.
+        await lockedBot.api.editMessageText(cid, mid, text, editOpts as EditOpts)
+        return 'edited'
+      } catch (err) {
+        const desc =
+          err instanceof GrammyError ? err.description : err instanceof Error ? err.message : String(err)
+        // Content identical → message still exists; reuse it.
+        if (typeof desc === 'string' && desc.toLowerCase().includes('not modified')) return 'edited'
+        // Not found, or any other error → fall back to a fresh silent send.
+        return 'gone'
+      }
+    },
   }
 }
 
@@ -4578,6 +4598,7 @@ const ipcServer: IpcServer = createIpcServer({
             tmuxSupervisor: process.env.SWITCHROOM_TMUX_SUPERVISOR === '1',
             dockerMode: process.env.SWITCHROOM_RUNTIME === 'docker',
             configSnapshotPath: join(resolvedAgentDirForCard, '.config-snapshot.json'),
+            bootCardStatePath: join(resolvedAgentDirForCard, '.boot-card-msgid.json'),
             ...(updateOutcomeLine ? { updateOutcomeLine } : {}),
           }, ackMsgId).then(handle => {
             activeBootCard = handle
@@ -18469,6 +18490,7 @@ void (async () => {
                       tmuxSupervisor: process.env.SWITCHROOM_TMUX_SUPERVISOR === '1',
                       dockerMode: process.env.SWITCHROOM_RUNTIME === 'docker',
                       configSnapshotPath: join(resolvedAgentDirForBootCard, '.config-snapshot.json'),
+                      bootCardStatePath: join(resolvedAgentDirForBootCard, '.boot-card-msgid.json'),
                       ...(updateOutcomeLine ? { updateOutcomeLine } : {}),
                     }, ackMsgId)
                     activeBootCard = handle

package/telegram-plugin/tests/boot-card-edit-in-place.test.ts

@@ -0,0 +1,139 @@
+/**
+ * Edit-in-place boot card (zero-notification reboots, operator request
+ * 2026-06-03). A routine reboot must EDIT the prior boot card rather than
+ * send a new one — a sent message bumps the unread badge even with
+ * `disable_notification: true`; an edit never does.
+ *
+ * Pins the startBootCard contract:
+ *   - first boot (no persisted id) → SEND + persist the id
+ *   - next routine boot (persisted id exists) → EDIT in place, NO send
+ *   - persisted id but message deleted ('gone') → fall back to SEND
+ *   - Telegram-initiated /restart (ackMessageId set) → SEND fresh (replies to
+ *     the operator's command; they asked and are watching)
+ *   - no bootCardStatePath → always SEND (back-compat)
+ *
+ * State is an isolated mkdtemp file — NEVER ~/.switchroom (test discipline).
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { startBootCard } from '../gateway/boot-card.js'
+import type { BotApiForBootCard } from '../gateway/boot-card.js'
+
+let dir: string
+let statePath: string
+
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), 'boot-card-eip-'))
+  statePath = join(dir, '.boot-card-msgid.json')
+})
+afterEach(() => {
+  rmSync(dir, { recursive: true, force: true })
+})
+
+/** Capturing bot with a configurable strict-edit outcome. */
+function makeBot(strictOutcome: 'edited' | 'gone' | null) {
+  const sends: Array<{ chatId: string; opts: Record<string, unknown> }> = []
+  const strictEdits: Array<{ chatId: string; messageId: number }> = []
+  let nextId = 1000
+  const bot: BotApiForBootCard = {
+    sendMessage: async (chatId, _text, opts) => {
+      sends.push({ chatId, opts: opts ?? {} })
+      return { message_id: ++nextId }
+    },
+    editMessageText: async () => ({}),
+    ...(strictOutcome != null
+      ? {
+          editMessageTextStrict: async (chatId: string, messageId: number) => {
+            strictEdits.push({ chatId, messageId })
+            return strictOutcome
+          },
+        }
+      : {}),
+  }
+  return { bot, sends, strictEdits }
+}
+
+function mkOpts(overrides: Record<string, unknown> = {}) {
+  return {
+    agentName: 'TestAgent',
+    agentSlug: 'test-agent',
+    version: 'v0.0.0-test',
+    agentDir: dir,
+    gatewayInfo: { pid: 1, startedAtMs: Date.now() },
+    restartReason: 'graceful' as const,
+    agentLiveWindowMs: 0, // disable the live loop — we assert the initial post/edit only
+    settleWindowMs: 1_000_000,
+    bootCardStatePath: statePath,
+    ...overrides,
+  }
+}
+
+describe('boot card — edit-in-place (zero-notification reboots)', () => {
+  it('first boot with no persisted id → sends, and persists the id', async () => {
+    const { bot, sends, strictEdits } = makeBot('edited')
+    await startBootCard('chat1', undefined, bot, mkOpts())
+    expect(sends).toHaveLength(1) // first boot must send (one badge, ever)
+    expect(strictEdits).toHaveLength(0)
+    expect(sends[0]!.opts.disable_notification).toBe(true) // still silent
+  })
+
+  it('second routine boot → edits the prior card in place, NO new send', async () => {
+    // Boot 1 sends + persists.
+    const first = makeBot('edited')
+    await startBootCard('chat1', undefined, first.bot, mkOpts())
+    expect(first.sends).toHaveLength(1)
+
+    // Boot 2 (same state file) → reuse via strict edit, no send.
+    const second = makeBot('edited')
+    await startBootCard('chat1', undefined, second.bot, mkOpts())
+    expect(second.sends).toHaveLength(0) // ← zero notification: no new message
+    expect(second.strictEdits).toHaveLength(1)
+    // Boot 1's send returned message_id 1001 (nextId starts at 1000, ++ first);
+    // boot 2 must edit exactly that persisted id.
+    expect(second.strictEdits[0]!.messageId).toBe(1001)
+  })
+
+  it('persisted id but message was deleted (gone) → falls back to a fresh send', async () => {
+    const first = makeBot('edited')
+    await startBootCard('chat1', undefined, first.bot, mkOpts())
+
+    const second = makeBot('gone')
+    await startBootCard('chat1', undefined, second.bot, mkOpts())
+    expect(second.strictEdits).toHaveLength(1) // probed the old id
+    expect(second.sends).toHaveLength(1) // and fell back to a fresh send
+    expect(second.sends[0]!.opts.disable_notification).toBe(true)
+  })
+
+  it('Telegram-initiated /restart (ackMessageId set) → sends fresh, never edits', async () => {
+    // Seed a persisted id from a routine boot.
+    const seed = makeBot('edited')
+    await startBootCard('chat1', undefined, seed.bot, mkOpts())
+
+    // A /restart passes ackMessageId → must reply with a fresh card, not edit.
+    const restart = makeBot('edited')
+    await startBootCard('chat1', undefined, restart.bot, mkOpts(), 555)
+    expect(restart.strictEdits).toHaveLength(0) // no reuse on user-initiated restart
+    expect(restart.sends).toHaveLength(1)
+    expect(restart.sends[0]!.opts.reply_parameters).toEqual({ message_id: 555 })
+  })
+
+  it('no bootCardStatePath → always sends (back-compat, unchanged)', async () => {
+    const { bot, sends, strictEdits } = makeBot('edited')
+    await startBootCard('chat1', undefined, bot, mkOpts({ bootCardStatePath: undefined }))
+    expect(sends).toHaveLength(1)
+    expect(strictEdits).toHaveLength(0)
+  })
+
+  it('bot without editMessageTextStrict → always sends (graceful degrade)', async () => {
+    const { bot, sends } = makeBot(null) // no strict method
+    await startBootCard('chat1', undefined, bot, mkOpts())
+    const second = makeBot(null)
+    await startBootCard('chat1', undefined, second.bot, mkOpts())
+    // Both boots send — no strict method means no in-place reuse path.
+    expect(sends).toHaveLength(1)
+    expect(second.sends).toHaveLength(1)
+  })
+})

package/telegram-plugin/tests/boot-card-msgid.test.ts

@@ -0,0 +1,88 @@
+/**
+ * Unit tests for the cross-reboot boot-card message-id store
+ * (gateway/boot-card-msgid.ts) — the persistence that lets a routine reboot
+ * EDIT the prior boot card in place (zero notification) instead of sending a
+ * new one.
+ *
+ * All I/O is to an isolated mkdtemp dir — NEVER ~/.switchroom (test discipline).
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, rmSync, writeFileSync, existsSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import {
+  bootCardChatKey,
+  loadBootCardMsgId,
+  saveBootCardMsgId,
+} from '../gateway/boot-card-msgid.js'
+
+let dir: string
+let path: string
+
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), 'boot-card-msgid-'))
+  path = join(dir, '.boot-card-msgid.json')
+})
+afterEach(() => {
+  rmSync(dir, { recursive: true, force: true })
+})
+
+describe('bootCardChatKey', () => {
+  it('keys a DM (no topic) distinctly from a supergroup topic', () => {
+    expect(bootCardChatKey('12345', undefined)).toBe('12345:')
+    expect(bootCardChatKey('-1001234567890', 4)).toBe('-1001234567890:4')
+    // Different topics in the same supergroup are distinct cards.
+    expect(bootCardChatKey('-100', 3)).not.toBe(bootCardChatKey('-100', 4))
+  })
+})
+
+describe('loadBootCardMsgId / saveBootCardMsgId', () => {
+  it('returns null when the file does not exist (first boot)', () => {
+    expect(loadBootCardMsgId(path, 'dm:')).toBeNull()
+  })
+
+  it('round-trips a saved id', () => {
+    saveBootCardMsgId(path, 'dm:', 353)
+    expect(loadBootCardMsgId(path, 'dm:')).toBe(353)
+  })
+
+  it('keeps ids for different chats independent', () => {
+    saveBootCardMsgId(path, 'dm:', 100)
+    saveBootCardMsgId(path, '-100:4', 200)
+    expect(loadBootCardMsgId(path, 'dm:')).toBe(100)
+    expect(loadBootCardMsgId(path, '-100:4')).toBe(200)
+    // Updating one leaves the other intact.
+    saveBootCardMsgId(path, 'dm:', 101)
+    expect(loadBootCardMsgId(path, 'dm:')).toBe(101)
+    expect(loadBootCardMsgId(path, '-100:4')).toBe(200)
+  })
+
+  it('returns null for an unknown chat key', () => {
+    saveBootCardMsgId(path, 'dm:', 1)
+    expect(loadBootCardMsgId(path, 'other:')).toBeNull()
+  })
+
+  it('rejects non-positive / non-finite ids on save and load', () => {
+    saveBootCardMsgId(path, 'dm:', 0)
+    saveBootCardMsgId(path, 'dm:', -5)
+    saveBootCardMsgId(path, 'dm:', Number.NaN)
+    expect(loadBootCardMsgId(path, 'dm:')).toBeNull()
+  })
+
+  it('treats a corrupt file as empty (falls back to fresh send)', () => {
+    writeFileSync(path, 'not json{', 'utf8')
+    expect(loadBootCardMsgId(path, 'dm:')).toBeNull()
+    // And a subsequent save still works (overwrites the garbage).
+    saveBootCardMsgId(path, 'dm:', 7)
+    expect(loadBootCardMsgId(path, 'dm:')).toBe(7)
+  })
+
+  it('does not rewrite the file when the id is unchanged (idempotent)', () => {
+    saveBootCardMsgId(path, 'dm:', 42)
+    expect(existsSync(path)).toBe(true)
+    // Saving the same value again is a no-op; the value is still readable.
+    saveBootCardMsgId(path, 'dm:', 42)
+    expect(loadBootCardMsgId(path, 'dm:')).toBe(42)
+  })
+})