switchroom 0.19.29 → 0.19.31

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

@@ -13658,7 +13658,7 @@ import {
   mkdirSync as mkdirSync6,
   chmodSync as chmodSync2,
   unlinkSync as unlinkSync3,
-  renameSync as renameSync5
+  renameSync as renameSync6
 } from "node:fs";
 import { dirname as dirname5, join as join5 } from "node:path";
 function floodStatePath(stateDir) {
@@ -23318,17 +23318,17 @@ var init_loader = __esm(() => {
 var init_flock = () => {};
 
 // ../src/vault/vault.ts
-import { randomBytes as randomBytes3, scryptSync, createCipheriv, createDecipheriv } from "node:crypto";
+import { randomBytes as randomBytes4, scryptSync, createCipheriv, createDecipheriv } from "node:crypto";
 import {
   readFileSync as readFileSync8,
-  writeSync,
+  writeSync as writeSync2,
   existsSync as existsSync7,
-  renameSync as renameSync6,
+  renameSync as renameSync7,
   mkdirSync as mkdirSync9,
   unlinkSync as unlinkSync5,
-  fsyncSync,
-  openSync,
-  closeSync,
+  fsyncSync as fsyncSync2,
+  openSync as openSync2,
+  closeSync as closeSync2,
   lstatSync,
   realpathSync
 } from "node:fs";
@@ -23414,13 +23414,13 @@ var init_vault = __esm(() => {
 // ../src/vault/resolver.ts
 import {
   chmodSync as chmodSync4,
-  closeSync as closeSync2,
+  closeSync as closeSync3,
   mkdirSync as mkdirSync10,
   mkdtempSync,
-  openSync as openSync2,
-  rmSync,
+  openSync as openSync3,
+  rmSync as rmSync2,
   statSync as statSync6,
-  writeSync as writeSync2
+  writeSync as writeSync3
 } from "node:fs";
 import { join as join8 } from "node:path";
 import { tmpdir } from "node:os";
@@ -23448,13 +23448,13 @@ function registerCleanupHook() {
   const cleanup = () => {
     for (const dir of materializedDirs) {
       try {
-        rmSync(dir, { recursive: true, force: true });
+        rmSync2(dir, { recursive: true, force: true });
       } catch {}
     }
     materializedDirs.clear();
     if (cachedRoot) {
       try {
-        rmSync(cachedRoot, { recursive: true, force: true });
+        rmSync2(cachedRoot, { recursive: true, force: true });
       } catch {}
       cachedRoot = null;
     }
@@ -23485,18 +23485,18 @@ function materializationRoot() {
 }
 function writeFileExclusive(filePath, content) {
   const buf = typeof content === "string" ? Buffer.from(content, "utf8") : content;
-  const fd = openSync2(filePath, fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL, 384);
+  const fd = openSync3(filePath, fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL, 384);
   try {
-    writeSync2(fd, buf);
+    writeSync3(fd, buf);
   } finally {
-    closeSync2(fd);
+    closeSync3(fd);
   }
 }
 function materializeFilesEntry(key, files) {
   const dir = join8(materializationRoot(), key);
   if (materializedDirs.has(dir)) {
     try {
-      rmSync(dir, { recursive: true, force: true });
+      rmSync2(dir, { recursive: true, force: true });
     } catch {}
   }
   mkdirSync10(dir, { recursive: true, mode: 448 });
@@ -23637,21 +23637,21 @@ var init_resolver = __esm(() => {
 });
 
 // ../src/util/atomic.ts
-import { randomBytes as randomBytes4 } from "node:crypto";
-import { closeSync as closeSync3, constants, fchmodSync, fchownSync, fsyncSync as fsyncSync2, openSync as openSync3, renameSync as renameSync7, rmSync as rmSync2, writeSync as writeSync3 } from "node:fs";
-function atomicWriteFileSync(destPath, contents, modeOrOpts = 384) {
+import { randomBytes as randomBytes5 } from "node:crypto";
+import { closeSync as closeSync4, constants as constants2, fchmodSync as fchmodSync2, fchownSync as fchownSync2, fsyncSync as fsyncSync3, openSync as openSync4, renameSync as renameSync8, rmSync as rmSync3, writeSync as writeSync4 } from "node:fs";
+function atomicWriteFileSync2(destPath, contents, modeOrOpts = 384) {
   const opts = typeof modeOrOpts === "number" ? { mode: modeOrOpts } : modeOrOpts;
   const mode = opts.mode ?? 384;
-  const tmp = `${destPath}.tmp-${process.pid}-${randomBytes4(4).toString("hex")}`;
+  const tmp = `${destPath}.tmp-${process.pid}-${randomBytes5(4).toString("hex")}`;
   const buf = typeof contents === "string" ? Buffer.from(contents, "utf-8") : contents;
   let fd = null;
   try {
-    fd = openSync3(tmp, TMP_OPEN_FLAGS, mode);
-    writeSync3(fd, buf, 0, buf.length, 0);
-    fchmodSync(fd, mode);
+    fd = openSync4(tmp, TMP_OPEN_FLAGS2, mode);
+    writeSync4(fd, buf, 0, buf.length, 0);
+    fchmodSync2(fd, mode);
     if (opts.uid !== undefined) {
       try {
-        fchownSync(fd, opts.uid, opts.gid ?? opts.uid);
+        fchownSync2(fd, opts.uid, opts.gid ?? opts.uid);
       } catch (chownErr) {
         if (opts.onChownError)
           opts.onChownError(chownErr);
@@ -23659,25 +23659,25 @@ function atomicWriteFileSync(destPath, contents, modeOrOpts = 384) {
           throw chownErr;
       }
     }
-    fsyncSync2(fd);
-    closeSync3(fd);
+    fsyncSync3(fd);
+    closeSync4(fd);
     fd = null;
-    renameSync7(tmp, destPath);
+    renameSync8(tmp, destPath);
   } catch (err) {
     if (fd !== null) {
       try {
-        closeSync3(fd);
+        closeSync4(fd);
       } catch {}
     }
     try {
-      rmSync2(tmp, { force: true });
+      rmSync3(tmp, { force: true });
     } catch {}
     throw err;
   }
 }
-var TMP_OPEN_FLAGS;
+var TMP_OPEN_FLAGS2;
 var init_atomic = __esm(() => {
-  TMP_OPEN_FLAGS = constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW ?? 0);
+  TMP_OPEN_FLAGS2 = constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | (constants2.O_NOFOLLOW ?? 0);
 });
 
 // gateway/approval-card.ts
@@ -35701,7 +35701,7 @@ function renderAuthLine(state7, agentName3, now = Date.now()) {
 
 // gateway/quota-cache.ts
 import { existsSync as existsSync44, readFileSync as readFileSync44, writeFileSync as writeFileSync37, mkdirSync as mkdirSync39 } from "fs";
-import { join as join53, dirname as dirname20 } from "path";
+import { join as join53, dirname as dirname22 } from "path";
 function defaultCachePath() {
   return process.env.SWITCHROOM_QUOTA_CACHE_PATH ?? join53(process.env.HOME ?? "/tmp", ".switchroom", "quota-cache.json");
 }
@@ -35738,7 +35738,7 @@ function writeQuotaCache(result, opts = {}) {
     result
   };
   try {
-    mkdirSync39(dirname20(path3), { recursive: true });
+    mkdirSync39(dirname22(path3), { recursive: true });
     writeFileSync37(path3, JSON.stringify(entry, null, 2), { mode: 384 });
   } catch {}
 }
@@ -36610,8 +36610,8 @@ var init_boot_probes = __esm(() => {
 });
 
 // gateway/boot-issue-cache.ts
-import { existsSync as existsSync46, readFileSync as readFileSync46, writeFileSync as writeFileSync38, mkdirSync as mkdirSync40, renameSync as renameSync21 } from "fs";
-import { dirname as dirname21 } from "path";
+import { existsSync as existsSync46, readFileSync as readFileSync46, writeFileSync as writeFileSync38, mkdirSync as mkdirSync40, renameSync as renameSync22 } from "fs";
+import { dirname as dirname23 } from "path";
 function fingerprintProbe(key, r) {
   if (r.status === "ok")
     return `${key}:ok`;
@@ -36703,7 +36703,7 @@ function loadCache(path3, now = Date.now) {
     parsed = JSON.parse(raw);
   } catch {
     try {
-      renameSync21(path3, `${path3}.corrupt-${now()}`);
+      renameSync22(path3, `${path3}.corrupt-${now()}`);
     } catch {}
     return { ...EMPTY_CACHE, probes: {} };
   }
@@ -36737,10 +36737,10 @@ function applyAndSave(path3, cache, diff) {
     }
   }
   try {
-    mkdirSync40(dirname21(path3), { recursive: true });
+    mkdirSync40(dirname23(path3), { recursive: true });
     const tmp = `${path3}.tmp`;
     writeFileSync38(tmp, JSON.stringify(next), { mode: 384 });
-    renameSync21(tmp, path3);
+    renameSync22(tmp, path3);
   } catch {}
   return next;
 }
@@ -36753,8 +36753,8 @@ var init_boot_issue_cache = __esm(() => {
 
 // gateway/config-snapshot.ts
 import { createHash as createHash7 } from "crypto";
-import { existsSync as existsSync47, readFileSync as readFileSync47, writeFileSync as writeFileSync39, mkdirSync as mkdirSync41, renameSync as renameSync22 } from "fs";
-import { dirname as dirname22 } from "path";
+import { existsSync as existsSync47, readFileSync as readFileSync47, writeFileSync as writeFileSync39, mkdirSync as mkdirSync41, renameSync as renameSync23 } from "fs";
+import { dirname as dirname24 } from "path";
 function hashStringArray(items) {
   if (!items || items.length === 0)
     return null;
@@ -36831,7 +36831,7 @@ function loadSnapshot(path3, now = Date.now) {
     parsed = JSON.parse(raw);
   } catch {
     try {
-      renameSync22(path3, `${path3}.corrupt-${now()}`);
+      renameSync23(path3, `${path3}.corrupt-${now()}`);
     } catch {}
     return null;
   }
@@ -36852,10 +36852,10 @@ function loadSnapshot(path3, now = Date.now) {
 }
 function persistSnapshot(path3, snapshot) {
   try {
-    mkdirSync41(dirname22(path3), { recursive: true });
+    mkdirSync41(dirname24(path3), { recursive: true });
     const tmp = `${path3}.tmp`;
     writeFileSync39(tmp, JSON.stringify(snapshot), { mode: 384 });
-    renameSync22(tmp, path3);
+    renameSync23(tmp, path3);
   } catch {}
 }
 var init_config_snapshot = __esm(() => {
@@ -37920,7 +37920,7 @@ __export(exports_tmux2, {
   captureAgentPane: () => captureAgentPane2
 });
 import { execFileSync as execFileSync8 } from "node:child_process";
-import { chmodSync as chmodSync13, mkdirSync as mkdirSync49, readdirSync as readdirSync15, statSync as statSync21, unlinkSync as unlinkSync28, writeFileSync as writeFileSync48 } from "node:fs";
+import { chmodSync as chmodSync13, mkdirSync as mkdirSync50, readdirSync as readdirSync15, statSync as statSync21, unlinkSync as unlinkSync29, writeFileSync as writeFileSync49 } from "node:fs";
 import { resolve as resolve12 } from "node:path";
 function captureAgentPane2(opts) {
   const { agentName: agentName3, agentDir, reason } = opts;
@@ -37932,7 +37932,7 @@ function captureAgentPane2(opts) {
   const reasonSlug = sanitizeReason2(reason);
   const outPath = resolve12(outDir, `${ts}-${reasonSlug}.txt`);
   try {
-    mkdirSync49(outDir, { recursive: true, mode: 448 });
+    mkdirSync50(outDir, { recursive: true, mode: 448 });
   } catch (err) {
     const msg = `mkdir crash-reports failed: ${err.message}`;
     console.error(`[tmux-capture] ${agentName3}: ${msg}`);
@@ -37971,7 +37971,7 @@ function captureAgentPane2(opts) {
 ` + `
 `;
   try {
-    writeFileSync48(outPath, Buffer.concat([Buffer.from(header, "utf8"), body]), {
+    writeFileSync49(outPath, Buffer.concat([Buffer.from(header, "utf8"), body]), {
       mode: 384
     });
   } catch (err) {
@@ -38055,7 +38055,7 @@ function pruneOldReports2(dir, retain) {
   }).sort((a, b) => b.mtimeMs - a.mtimeMs);
   for (const stale of files.slice(retain)) {
     try {
-      unlinkSync28(stale.full);
+      unlinkSync29(stale.full);
     } catch {}
   }
 }
@@ -38078,9 +38078,9 @@ __export(exports_config_approval_handler, {
   _peekPendingConfigApprovalForTest: () => _peekPendingConfigApprovalForTest,
   DIFF_SENTINEL: () => DIFF_SENTINEL
 });
-import { randomBytes as randomBytes11 } from "node:crypto";
+import { randomBytes as randomBytes12 } from "node:crypto";
 function defaultEpoch() {
-  return randomBytes11(4).toString("hex");
+  return randomBytes12(4).toString("hex");
 }
 function truncateDiffForCard(unifiedDiff, maxLines = 50, maxChars = 3000) {
   const sentinel = `
@@ -39021,29 +39021,80 @@ var init_approvals_commands = __esm(() => {
 // gateway/gateway.ts
 var import_grammy16 = __toESM(require_mod(), 1);
 var import_runner3 = __toESM(require_mod3(), 1);
-import { randomBytes as randomBytes12, createHash as createHash8 } from "crypto";
+import { randomBytes as randomBytes13, createHash as createHash8 } from "crypto";
 import { execFileSync as execFileSync9, execSync as execSync2, spawn as spawn2 } from "child_process";
 import {
-  readFileSync as readFileSync59,
-  writeFileSync as writeFileSync49,
-  mkdirSync as mkdirSync50,
+  readFileSync as readFileSync60,
+  writeFileSync as writeFileSync50,
+  mkdirSync as mkdirSync51,
   readdirSync as readdirSync16,
-  rmSync as rmSync7,
+  rmSync as rmSync8,
   statSync as statSync22,
-  renameSync as renameSync25,
+  renameSync as renameSync27,
   realpathSync as realpathSync4,
   chmodSync as chmodSync14,
-  openSync as openSync13,
-  closeSync as closeSync13,
+  openSync as openSync15,
+  closeSync as closeSync15,
   existsSync as existsSync57,
-  unlinkSync as unlinkSync29,
+  unlinkSync as unlinkSync30,
   appendFileSync as appendFileSync9
 } from "fs";
+
+// ../src/util/atomic.ts
+import { randomBytes } from "node:crypto";
+import { closeSync, constants, fchmodSync, fchownSync, fsyncSync, openSync, renameSync, rmSync, writeSync } from "node:fs";
+var TMP_OPEN_FLAGS = constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW ?? 0);
+function atomicWriteFileSync(destPath, contents, modeOrOpts = 384) {
+  const opts = typeof modeOrOpts === "number" ? { mode: modeOrOpts } : modeOrOpts;
+  const mode = opts.mode ?? 384;
+  const tmp = `${destPath}.tmp-${process.pid}-${randomBytes(4).toString("hex")}`;
+  const buf = typeof contents === "string" ? Buffer.from(contents, "utf-8") : contents;
+  let fd = null;
+  try {
+    fd = openSync(tmp, TMP_OPEN_FLAGS, mode);
+    writeSync(fd, buf, 0, buf.length, 0);
+    fchmodSync(fd, mode);
+    if (opts.uid !== undefined) {
+      try {
+        fchownSync(fd, opts.uid, opts.gid ?? opts.uid);
+      } catch (chownErr) {
+        if (opts.onChownError)
+          opts.onChownError(chownErr);
+        else
+          throw chownErr;
+      }
+    }
+    fsyncSync(fd);
+    closeSync(fd);
+    fd = null;
+    renameSync(tmp, destPath);
+  } catch (err) {
+    if (fd !== null) {
+      try {
+        closeSync(fd);
+      } catch {}
+    }
+    try {
+      rmSync(tmp, { force: true });
+    } catch {}
+    throw err;
+  }
+}
+function fsyncPathSync(path) {
+  const fd = openSync(path, constants.O_RDONLY);
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+
+// gateway/gateway.ts
 import { homedir as homedir19 } from "os";
-import { join as join67, sep as sep4, basename as basename17 } from "path";
+import { join as join68, sep as sep4, basename as basename17 } from "path";
 
 // plugin-logger.ts
-import { appendFileSync, mkdirSync, renameSync, statSync, existsSync } from "fs";
+import { appendFileSync, mkdirSync, renameSync as renameSync2, statSync, existsSync } from "fs";
 import { homedir } from "os";
 import { dirname, join } from "path";
 var DEFAULT_LOG_PATH = join(homedir(), ".switchroom", "logs", "telegram-plugin.log");
@@ -39071,11 +39122,11 @@ function rotateIfNeeded(path) {
       const dst = `${path}.${i + 1}`;
       try {
         if (existsSync(src))
-          renameSync(src, dst);
+          renameSync2(src, dst);
       } catch {}
     }
     const backup = `${path}.1`;
-    renameSync(path, backup);
+    renameSync2(path, backup);
   } catch {}
 }
 function installPluginLogger(env = process.env) {
@@ -39182,7 +39233,7 @@ function redactAuthCodeMessage(api, chatId, messageId, log) {
 }
 
 // ask-user.ts
-import { randomBytes } from "crypto";
+import { randomBytes as randomBytes2 } from "crypto";
 var ASK_USER_DEFAULT_TIMEOUT_MS = 300000;
 var ASK_USER_MAX_TIMEOUT_MS = 1800000;
 var ASK_USER_MIN_TIMEOUT_MS = 5000;
@@ -39244,7 +39295,7 @@ function validateAskUserArgs(args) {
   };
 }
 function generateAskId() {
-  return randomBytes(4).toString("hex");
+  return randomBytes2(4).toString("hex");
 }
 function encodeAskCallback(askId, idx) {
   if (!/^[0-9a-f]{8}$/.test(askId)) {
@@ -39791,7 +39842,7 @@ async function synthesizeViaSidecar(args) {
 }
 
 // voice-ondemand.ts
-import { readFileSync, writeFileSync, renameSync as renameSync2, mkdirSync as mkdirSync2 } from "fs";
+import { readFileSync, writeFileSync, renameSync as renameSync3, mkdirSync as mkdirSync2 } from "fs";
 import { dirname as dirname2 } from "path";
 var VOICE_ONDEMAND_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 var VOICE_ONDEMAND_MAX_ENTRIES = 500;
@@ -39915,7 +39966,7 @@ class VoiceOnDemandCache {
     try {
       mkdirSync2(dirname2(this.persistPath), { recursive: true });
       writeFileSync(tmp, JSON.stringify(doc), "utf8");
-      renameSync2(tmp, this.persistPath);
+      renameSync3(tmp, this.persistPath);
     } catch (err) {
       process.stderr.write(`voice-ondemand: failed to persist cache ${this.persistPath}: ${String(err)}
 `);
@@ -39924,8 +39975,8 @@ class VoiceOnDemandCache {
 }
 
 // voice-ondemand.ts
-import { randomBytes as randomBytes2 } from "crypto";
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, renameSync as renameSync3, mkdirSync as mkdirSync3 } from "fs";
+import { randomBytes as randomBytes3 } from "crypto";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, renameSync as renameSync4, mkdirSync as mkdirSync3 } from "fs";
 import { dirname as dirname3 } from "path";
 var VOICE_ONDEMAND_CALLBACK_PREFIX = "voice:";
 var VOICE_ONDEMAND_TTL_MS2 = 7 * 24 * 60 * 60 * 1000;
@@ -40050,7 +40101,7 @@ class VoiceOnDemandCache2 {
     try {
       mkdirSync3(dirname3(this.persistPath), { recursive: true });
       writeFileSync2(tmp, JSON.stringify(doc), "utf8");
-      renameSync3(tmp, this.persistPath);
+      renameSync4(tmp, this.persistPath);
     } catch (err) {
       process.stderr.write(`voice-ondemand: failed to persist cache ${this.persistPath}: ${String(err)}
 `);
@@ -40058,7 +40109,7 @@ class VoiceOnDemandCache2 {
   }
 }
 function mintVoiceOnDemandToken() {
-  return randomBytes2(4).toString("hex");
+  return randomBytes3(4).toString("hex");
 }
 function isVoiceOnDemandCallback(data) {
   return data.startsWith(VOICE_ONDEMAND_CALLBACK_PREFIX);
@@ -40124,7 +40175,7 @@ function makeOutboxListenMarkupResolver(deps) {
 }
 
 // voice-presynth.ts
-import { readdirSync, statSync as statSync2, unlinkSync, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3, renameSync as renameSync4 } from "fs";
+import { readdirSync, statSync as statSync2, unlinkSync, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3, renameSync as renameSync5 } from "fs";
 import { join as join2 } from "path";
 var VOICE_FILE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 var VOICE_CACHE_MAX_BYTES = 500 * 1024 * 1024;
@@ -40190,7 +40241,7 @@ function writeVoiceCacheFile(dir, token, audio) {
   const final = voiceCacheFilePath(dir, token);
   const tmp = `${final}.tmp`;
   writeFileSync3(tmp, audio);
-  renameSync4(tmp, final);
+  renameSync5(tmp, final);
   return final;
 }
 function sweepVoiceCacheDir(options) {
@@ -42779,6 +42830,18 @@ import { AsyncLocalStorage } from "async_hooks";
 
 // retry-api-call.ts
 var import_grammy2 = __toESM(require_mod2(), 1);
+function classifyBenignTelegram400(errorCode, description) {
+  if (errorCode !== 400)
+    return null;
+  const desc = (description ?? "").toLowerCase();
+  if (desc.includes("not modified"))
+    return "not_modified";
+  if (desc.includes("message to edit not found"))
+    return "message_not_found";
+  if (desc.includes("message to delete not found"))
+    return "delete_not_found";
+  return null;
+}
 function isLocalResourceError(err) {
   const code = err?.code;
   if (typeof code === "string" && ["ENOSPC", "EDQUOT", "EIO", "ENOMEM"].includes(code)) {
@@ -42863,14 +42926,9 @@ function createRetryApiCall(config = {}) {
           await sleep(delayMs);
           continue;
         }
-        if (isGrammyErr && err.error_code === 400 && desc.includes("not modified")) {
-          observer?.onBenign?.({ kind: "not_modified" });
-          return;
-        }
-        if (isGrammyErr && err.error_code === 400 && (desc.includes("message to edit not found") || desc.includes("message to delete not found"))) {
-          observer?.onBenign?.({
-            kind: desc.includes("edit") ? "message_not_found" : "delete_not_found"
-          });
+        const benignKind = isGrammyErr ? classifyBenignTelegram400(err.error_code, desc) : null;
+        if (benignKind !== null) {
+          observer?.onBenign?.({ kind: benignKind });
           return;
         }
         if (isGrammyErr && err.error_code === 400 && desc.includes("thread not found") && opts?.threadId && opts?.chat_id) {
@@ -44674,12 +44732,12 @@ async function handleVoiceMessage(ctx, deps) {
 }
 
 // gateway/status-pin-store.ts
-var SNAPSHOT_VERSIONS = new Set([1, 2, 3]);
+var SNAPSHOT_VERSIONS = new Set([1, 2, 3, 4]);
 function isPinRow(x) {
   if (x == null || typeof x !== "object")
     return false;
   const o = x;
-  return typeof o.pinKey === "string" && o.pinKey.length > 0 && typeof o.chatId === "string" && o.chatId.length > 0 && typeof o.messageId === "number" && (o.pending === undefined || typeof o.pending === "boolean") && (o.expiresAt === undefined || typeof o.expiresAt === "number") && (o.attempts === undefined || typeof o.attempts === "number") && (o.pinnedAt === undefined || typeof o.pinnedAt === "number");
+  return typeof o.pinKey === "string" && o.pinKey.length > 0 && typeof o.chatId === "string" && o.chatId.length > 0 && (o.threadId === undefined || typeof o.threadId === "number") && typeof o.messageId === "number" && (o.pending === undefined || typeof o.pending === "boolean") && (o.expiresAt === undefined || typeof o.expiresAt === "number") && (o.attempts === undefined || typeof o.attempts === "number") && (o.pinnedAt === undefined || typeof o.pinnedAt === "number");
 }
 function loadStatusPins(path, fs2) {
   if (!fs2.existsSync(path))
@@ -44704,7 +44762,7 @@ function loadStatusPins(path, fs2) {
   return env.pins.filter(isPinRow);
 }
 function persistStatusPins(path, fs2, snapshot, log = (l) => process.stderr.write(l)) {
-  const env = { v: 3, pins: [...snapshot] };
+  const env = { v: 4, pins: [...snapshot] };
   const tmp = path + ".tmp";
   try {
     fs2.writeFileSync(tmp, JSON.stringify(env));
@@ -44740,7 +44798,7 @@ function applyStatusPinRow(path, fs2, pinKey, row, log) {
   persistStatusPins(path, fs2, next, log);
 }
 function reconcileAndPersistStatusPin(args) {
-  const { path, fs: fs2, pinKey, chatId, op } = args;
+  const { path, fs: fs2, pinKey, chatId, threadId, op } = args;
   const log = args.log ?? ((l) => process.stderr.write(l));
   const now = args.now ?? Date.now();
   const claimAge = (messageId) => {
@@ -44750,20 +44808,20 @@ function reconcileAndPersistStatusPin(args) {
   return withStoreLock(path, async () => {
     if (op.kind === "pin") {
       const pinnedAt = claimAge(op.messageId);
-      applyStatusPinRow(path, fs2, pinKey, { pinKey, chatId, messageId: op.messageId, pending: true, pinnedAt }, log);
+      applyStatusPinRow(path, fs2, pinKey, { pinKey, chatId, threadId, messageId: op.messageId, pending: true, pinnedAt }, log);
       const next2 = await args.applyPin();
       if (next2 == null) {
         applyStatusPinRow(path, fs2, pinKey, null, log);
         return null;
       }
-      applyStatusPinRow(path, fs2, pinKey, { pinKey, chatId, messageId: next2.messageId, pinnedAt: claimAge(next2.messageId) }, log);
+      applyStatusPinRow(path, fs2, pinKey, { pinKey, chatId, threadId, messageId: next2.messageId, pinnedAt: claimAge(next2.messageId) }, log);
       return next2;
     }
     const next = await args.applyPin();
     if (next == null) {
       applyStatusPinRow(path, fs2, pinKey, null, log);
     } else {
-      applyStatusPinRow(path, fs2, pinKey, { pinKey, chatId, messageId: next.messageId, pinnedAt: claimAge(next.messageId) }, log);
+      applyStatusPinRow(path, fs2, pinKey, { pinKey, chatId, threadId, messageId: next.messageId, pinnedAt: claimAge(next.messageId) }, log);
     }
     return next;
   });
@@ -47361,6 +47419,7 @@ if (isMain)
 
 // tool-activity-summary.ts
 init_card_format();
+init_redact();
 
 // tool-names.ts
 var TELEGRAM_TOOL_PREFIX_RE = /^mcp__[^_].*?telegram__/;
@@ -47491,12 +47550,21 @@ function renderStatusCard(opts) {
 }
 var WORKER_RESULT_RULE = "\u2500\u2500\u2500\u2500\u2500";
 var WORKER_RESULT_MAX = 320;
-function renderActivityFeed(lines, final = false, liveSuffix = "", stepCount, header) {
-  if (lines.length === 0 && header == null)
+function deriveCardResult(state, summary) {
+  if (state !== "done" && state !== "failed")
+    return;
+  const text = cleanWorkerResultParagraph(redact(summary ?? ""));
+  if (text.length === 0)
+    return;
+  return { emoji: state === "done" ? "\u2705" : "\u26a0\ufe0f", text };
+}
+var AGENT_CARD_EMOJI = "\uD83E\uDD16";
+function renderAgentCard(lines, children, final, liveSuffix, stepCount, header) {
+  if (lines.length === 0 && children.length === 0 && header == null)
     return null;
   return renderStatusCard({
     header: header != null ? {
-      emoji: "\uD83E\uDD16",
+      emoji: AGENT_CARD_EMOJI,
       label: header.label,
       elapsedMs: header.elapsedMs,
       toolCount: header.toolCount,
@@ -47505,31 +47573,19 @@ function renderActivityFeed(lines, final = false, liveSuffix = "", stepCount, he
       totalTokens: header.totalTokens
     } : undefined,
     steps: lines,
+    ...children.length > 0 ? { childSteps: children } : {},
     final,
     liveSuffix,
-    stepCount
+    stepCount,
+    result: final && header != null ? deriveCardResult(header.state, header.resultText) : undefined
   });
 }
+function renderActivityFeed(lines, final = false, liveSuffix = "", stepCount, header) {
+  return renderAgentCard(lines, [], final, liveSuffix, stepCount, header);
+}
 function renderActivityFeedWithNested(lines, childLines, final = false, liveSuffix = "", stepCount, header) {
   const children = childLines.map((s) => s.trim()).filter((s) => s.length > 0);
-  if (children.length === 0)
-    return renderActivityFeed(lines, final, liveSuffix, stepCount, header);
-  return renderStatusCard({
-    header: header != null ? {
-      emoji: "\uD83E\uDD16",
-      label: header.label,
-      elapsedMs: header.elapsedMs,
-      toolCount: header.toolCount,
-      state: header.state,
-      model: header.model,
-      totalTokens: header.totalTokens
-    } : undefined,
-    steps: lines,
-    childSteps: children,
-    final,
-    liveSuffix,
-    stepCount
-  });
+  return renderAgentCard(lines, children, final, liveSuffix, stepCount, header);
 }
 var COMBINED_ROW_DESC_MAX = 72;
 var PER_WORKER_HEADER_COST = 1;
@@ -47651,12 +47707,7 @@ function renderWorkerActivity(v, liveSuffix = "") {
     model: v.model,
     totalTokens: v.totalTokens
   };
-  let result;
-  if (finished && v.state !== "incomplete") {
-    const text = cleanWorkerResultParagraph(v.latestSummary);
-    if (text.length > 0)
-      result = { emoji: v.state === "done" ? "\u2705" : "\u26a0\ufe0f", text };
-  }
+  const result = deriveCardResult(v.state, v.latestSummary);
   const card = renderStatusCard({
     header,
     steps,
@@ -47734,7 +47785,7 @@ function createWorkerActivityFeed(opts) {
   }
   let heartbeatTimer = null;
   function feedKeyOf(chatId, threadId) {
-    return `${chatId} ${threadId ?? ""}`;
+    return `${chatId}:${threadId ?? "-"}`;
   }
   function groupOfAgent(agentId) {
     const key = agentIndex.get(agentId);
@@ -48768,8 +48819,8 @@ import { unlinkSync as unlinkSync7 } from "node:fs";
 import { join as join12 } from "node:path";
 
 // gateway/store-file.ts
-import { randomBytes as randomBytes5 } from "node:crypto";
-import { readFileSync as readFileSync12, readdirSync as readdirSync4, renameSync as renameSync8, rmSync as rmSync3, statSync as statSync7 } from "node:fs";
+import { randomBytes as randomBytes6 } from "node:crypto";
+import { readFileSync as readFileSync12, readdirSync as readdirSync4, renameSync as renameSync9, rmSync as rmSync4, statSync as statSync7 } from "node:fs";
 import { basename as basename6, dirname as dirname6, join as join11 } from "node:path";
 var defaultLog = (line) => {
   process.stderr.write(line);
@@ -48778,7 +48829,7 @@ var MAX_QUARANTINED_COPIES = 5;
 var quarantineSeq = 0;
 function quarantinePath(filePath) {
   const seq = String(quarantineSeq++).padStart(6, "0");
-  return `${filePath}.corrupt-${Date.now()}-${seq}-${randomBytes5(4).toString("hex")}`;
+  return `${filePath}.corrupt-${Date.now()}-${seq}-${randomBytes6(4).toString("hex")}`;
 }
 function reapOldQuarantines(filePath, log) {
   const dir = dirname6(filePath);
@@ -48792,7 +48843,7 @@ function reapOldQuarantines(filePath, log) {
       return { name, mtimeNs };
     }).sort((a, b) => a.mtimeNs === b.mtimeNs ? a.name.localeCompare(b.name) : a.mtimeNs < b.mtimeNs ? -1 : 1);
     for (const stale of copies.slice(0, Math.max(0, copies.length - MAX_QUARANTINED_COPIES))) {
-      rmSync3(join11(dir, stale.name), { force: true });
+      rmSync4(join11(dir, stale.name), { force: true });
     }
   } catch (err) {
     log(`telegram gateway: quarantine reap failed dir=${dir}: ${err.message}
@@ -48803,7 +48854,7 @@ function quarantineCorruptStoreFile(filePath, store2, reason, log = defaultLog)
   const target = quarantinePath(filePath);
   let preserved = target;
   try {
-    renameSync8(filePath, target);
+    renameSync9(filePath, target);
   } catch (err) {
     preserved = `NOT preserved (${err.message})`;
   }
@@ -48814,7 +48865,7 @@ function quarantineCorruptStoreFile(filePath, store2, reason, log = defaultLog)
 function preserveUnreadableStoreFile(filePath, store2, log = defaultLog) {
   const target = quarantinePath(filePath);
   try {
-    renameSync8(filePath, target);
+    renameSync9(filePath, target);
   } catch (err) {
     if (err.code === "ENOENT") {
       return;
@@ -48867,7 +48918,7 @@ function createPendingCardStore(stateDir, log = (l) => process.stderr.write(l))
         preserveUnreadableStoreFile(filePath, "pending-card-store", log);
         unreadable = false;
       }
-      atomicWriteFileSync(filePath, JSON.stringify(entries), 384);
+      atomicWriteFileSync2(filePath, JSON.stringify(entries), 384);
     } catch (err) {
       log(`telegram gateway: pending-card-store write failed: ${err.message}
 `);
@@ -49517,12 +49568,12 @@ function buildSkillProposalApplyInbound(opts) {
 
 // ../src/self-improve/skill-proposals.ts
 import {
-  closeSync as closeSync4,
+  closeSync as closeSync5,
   existsSync as existsSync10,
   mkdirSync as mkdirSync13,
-  openSync as openSync4,
+  openSync as openSync5,
   readFileSync as readFileSync13,
-  writeSync as writeSync4
+  writeSync as writeSync5
 } from "node:fs";
 import { join as join14 } from "node:path";
 var PROPOSALS_FILE = "skill-proposals.jsonl";
@@ -49540,12 +49591,12 @@ function ensureDir2(stateDir) {
   }
 }
 function appendLine(path, obj) {
-  const fd = openSync4(path, "a");
+  const fd = openSync5(path, "a");
   try {
-    writeSync4(fd, JSON.stringify(obj) + `
+    writeSync5(fd, JSON.stringify(obj) + `
 `);
   } finally {
-    closeSync4(fd);
+    closeSync5(fd);
   }
 }
 function readLines(path, isValid2) {
@@ -49696,7 +49747,7 @@ async function addAccountViaBroker(label, credentials, opts = {}) {
 
 // gateway/hostd-dispatch.ts
 import { existsSync as existsSync11 } from "node:fs";
-import { randomBytes as randomBytes6 } from "node:crypto";
+import { randomBytes as randomBytes7 } from "node:crypto";
 
 // ../src/host-control/client.ts
 import { connect } from "node:net";
@@ -50042,7 +50093,7 @@ async function tryHostdDispatch(agentName, req, timeoutMs = 5000) {
   }
 }
 function hostdRequestId(prefix) {
-  return `${prefix}-${Date.now()}-${randomBytes6(4).toString("hex")}`;
+  return `${prefix}-${Date.now()}-${randomBytes7(4).toString("hex")}`;
 }
 async function hostdGetStatusOnce(agentName, targetRequestId) {
   if (!isHostdEnabled())
@@ -51684,7 +51735,7 @@ ${trimmed.replace(/```/g, "`\u200b``")}
 
 // gateway/card-tool-handlers.ts
 init_rich_send();
-import { randomBytes as randomBytes7 } from "crypto";
+import { randomBytes as randomBytes8 } from "crypto";
 
 // gateway/vault-request-access-card.ts
 init_approval_card();
@@ -51819,7 +51870,7 @@ function createCardToolHandlers(deps) {
       throw new Error(`vault_request_save: key must match ${VAULT_KEY_REGEX_LABEL}`);
     }
     const agentSlug = process.env.SWITCHROOM_AGENT_NAME || "agent";
-    const stageId = randomBytes7(4).toString("hex");
+    const stageId = randomBytes8(4).toString("hex");
     const pending = {
       agent: agentSlug,
       chat_id,
@@ -51909,7 +51960,7 @@ function createCardToolHandlers(deps) {
         }
       } catch {}
     }
-    const stageId = randomBytes7(4).toString("hex");
+    const stageId = randomBytes8(4).toString("hex");
     const pending = {
       agent: agentSlug,
       chat_id,
@@ -51971,7 +52022,7 @@ function createCardToolHandlers(deps) {
         pendingCardStore.remove(sid);
       }
     }
-    const stageId = randomBytes7(4).toString("hex");
+    const stageId = randomBytes8(4).toString("hex");
     const pending = { agent: agentSlug, chat_id, key, reason, staged_at: Date.now() };
     pendingSecretRequests.set(stageId, pending);
     sweepSecretRequests();
@@ -52070,7 +52121,7 @@ function createCardToolHandlers(deps) {
       process.stderr.write(`telegram gateway: mental_model_propose dup pre-check read failed: ${err.message}
 `);
     }
-    const stageId = randomBytes7(4).toString("hex");
+    const stageId = randomBytes8(4).toString("hex");
     const pending = {
       agent: agentSlug,
       chat_id,
@@ -52271,7 +52322,7 @@ function createMissedApprovalsStore(stateDir, log = (l) => process.stderr.write(
         preserveUnreadableStoreFile(filePath, "missed-approvals-store", log);
         unreadable = false;
       }
-      atomicWriteFileSync(filePath, JSON.stringify(f), 384);
+      atomicWriteFileSync2(filePath, JSON.stringify(f), 384);
     } catch (err) {
       log(`telegram gateway: missed-approvals-store write failed: ${err.message}
 `);
@@ -52351,7 +52402,7 @@ function computeBackoffMs(attempts, retryAfterMs) {
 }
 var atomicWriteSeam = (path, data, opts) => {
   const mode = typeof opts === "object" && opts !== null && typeof opts.mode === "number" ? opts.mode : 384;
-  atomicWriteFileSync(path, data, mode);
+  atomicWriteFileSync2(path, data, mode);
 };
 function createAlwaysAllowPersistQueue(stateDir, writeFileSyncFn = atomicWriteSeam, log = (l) => process.stderr.write(l)) {
   const filePath = join17(stateDir, "always-allow-persist-queue.json");
@@ -52802,6 +52853,7 @@ function isTelegramSurfaceTool2(toolName) {
 
 // tool-activity-summary.ts
 init_card_format();
+init_redact();
 function clipNarrative2(s) {
   return s.split(`
 `)[0].trim().slice(0, STATUS_LINE_MAX);
@@ -55860,7 +55912,7 @@ var codes = {
   replacementCharacter: 65533
 };
 // ../node_modules/.bun/micromark-util-symbol@2.0.1/node_modules/micromark-util-symbol/lib/constants.js
-var constants2 = {
+var constants3 = {
   attentionSideAfter: 2,
   attentionSideBefore: 1,
   atxHeadingOpeningFenceSizeMax: 6,
@@ -56116,7 +56168,7 @@ function splice(list, start, remove, items) {
     start = start > end ? end : start;
   }
   remove = remove > 0 ? remove : 0;
-  if (items.length < constants2.v8MaxSafeChunkSize) {
+  if (items.length < constants3.v8MaxSafeChunkSize) {
     parameters = Array.from(items);
     parameters.unshift(start, remove);
     list.splice(...parameters);
@@ -56124,11 +56176,11 @@ function splice(list, start, remove, items) {
     if (remove)
       list.splice(start, remove);
     while (chunkStart < items.length) {
-      parameters = items.slice(chunkStart, chunkStart + constants2.v8MaxSafeChunkSize);
+      parameters = items.slice(chunkStart, chunkStart + constants3.v8MaxSafeChunkSize);
       parameters.unshift(start, 0);
       list.splice(...parameters);
-      chunkStart += constants2.v8MaxSafeChunkSize;
-      start += constants2.v8MaxSafeChunkSize;
+      chunkStart += constants3.v8MaxSafeChunkSize;
+      start += constants3.v8MaxSafeChunkSize;
     }
   }
 }
@@ -56264,7 +56316,7 @@ function initializeContent(effects) {
   }
   function lineStart(code) {
     const token = effects.enter(types2.chunkText, {
-      contentType: constants2.contentTypeText,
+      contentType: constants3.contentTypeText,
       previous
     });
     if (previous) {
@@ -56386,7 +56438,7 @@ function initializeDocument(effects) {
     childFlow = childFlow || self.parser.flow(self.now());
     effects.enter(types2.chunkFlow, {
       _tokenizer: childFlow,
-      contentType: constants2.contentTypeFlow,
+      contentType: constants3.contentTypeFlow,
       previous: childToken
     });
     return flowContinue(code);
@@ -56471,16 +56523,16 @@ function initializeDocument(effects) {
 }
 function tokenizeContainer(effects, ok2, nok) {
   ok(this.parser.constructs.disable.null, "expected `disable.null` to be populated");
-  return factorySpace(effects, effects.attempt(this.parser.constructs.document, ok2, nok), types2.linePrefix, this.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants2.tabSize);
+  return factorySpace(effects, effects.attempt(this.parser.constructs.document, ok2, nok), types2.linePrefix, this.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants3.tabSize);
 }
 
 // ../node_modules/.bun/micromark-util-classify-character@2.0.1/node_modules/micromark-util-classify-character/dev/index.js
 function classifyCharacter(code) {
   if (code === codes.eof || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {
-    return constants2.characterGroupWhitespace;
+    return constants3.characterGroupWhitespace;
   }
   if (unicodePunctuation(code)) {
-    return constants2.characterGroupPunctuation;
+    return constants3.characterGroupPunctuation;
   }
 }
 
@@ -56614,8 +56666,8 @@ function tokenizeAttention(effects, ok2) {
     const token = effects.exit("attentionSequence");
     const after = classifyCharacter(code);
     ok(attentionMarkers, "expected `attentionMarkers` to be populated");
-    const open = !after || after === constants2.characterGroupPunctuation && before || attentionMarkers.includes(code);
-    const close = !before || before === constants2.characterGroupPunctuation && after || attentionMarkers.includes(previous);
+    const open = !after || after === constants3.characterGroupPunctuation && before || attentionMarkers.includes(code);
+    const close = !before || before === constants3.characterGroupPunctuation && after || attentionMarkers.includes(previous);
     token._open = Boolean(marker === codes.asterisk ? open : open && (before || !close));
     token._close = Boolean(marker === codes.asterisk ? close : close && (after || !open));
     return ok2(code);
@@ -56663,7 +56715,7 @@ function tokenizeAutolink(effects, ok2, nok) {
       size = 0;
       return urlInside;
     }
-    if ((code === codes.plusSign || code === codes.dash || code === codes.dot || asciiAlphanumeric(code)) && size++ < constants2.autolinkSchemeSizeMax) {
+    if ((code === codes.plusSign || code === codes.dash || code === codes.dot || asciiAlphanumeric(code)) && size++ < constants3.autolinkSchemeSizeMax) {
       effects.consume(code);
       return schemeInsideOrEmailAtext;
     }
@@ -56716,7 +56768,7 @@ function tokenizeAutolink(effects, ok2, nok) {
     return emailValue(code);
   }
   function emailValue(code) {
-    if ((code === codes.dash || asciiAlphanumeric(code)) && size++ < constants2.autolinkDomainSizeMax) {
+    if ((code === codes.dash || asciiAlphanumeric(code)) && size++ < constants3.autolinkDomainSizeMax) {
       const next = code === codes.dash ? emailValue : emailLabel;
       effects.consume(code);
       return next;
@@ -56779,7 +56831,7 @@ function tokenizeBlockQuoteContinuation(effects, ok2, nok) {
   function contStart(code) {
     if (markdownSpace(code)) {
       ok(self.parser.constructs.disable.null, "expected `disable.null` to be populated");
-      return factorySpace(effects, contBefore, types2.linePrefix, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants2.tabSize)(code);
+      return factorySpace(effects, contBefore, types2.linePrefix, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants3.tabSize)(code);
     }
     return contBefore(code);
   }
@@ -56843,7 +56895,7 @@ function tokenizeCharacterReference(effects, ok2, nok) {
       return numeric;
     }
     effects.enter(types2.characterReferenceValue);
-    max = constants2.characterReferenceNamedSizeMax;
+    max = constants3.characterReferenceNamedSizeMax;
     test = asciiAlphanumeric;
     return value(code);
   }
@@ -56853,12 +56905,12 @@ function tokenizeCharacterReference(effects, ok2, nok) {
       effects.consume(code);
       effects.exit(types2.characterReferenceMarkerHexadecimal);
       effects.enter(types2.characterReferenceValue);
-      max = constants2.characterReferenceHexadecimalSizeMax;
+      max = constants3.characterReferenceHexadecimalSizeMax;
       test = asciiHexDigit;
       return value;
     }
     effects.enter(types2.characterReferenceValue);
-    max = constants2.characterReferenceDecimalSizeMax;
+    max = constants3.characterReferenceDecimalSizeMax;
     test = asciiDigit;
     return value(code);
   }
@@ -56917,7 +56969,7 @@ function tokenizeCodeFenced(effects, ok2, nok) {
       effects.consume(code);
       return sequenceOpen;
     }
-    if (sizeOpen < constants2.codeFencedSequenceSizeMin) {
+    if (sizeOpen < constants3.codeFencedSequenceSizeMin) {
       return nok(code);
     }
     effects.exit(types2.codeFencedFenceSequence);
@@ -56929,7 +56981,7 @@ function tokenizeCodeFenced(effects, ok2, nok) {
       return self.interrupt ? ok2(code) : effects.check(nonLazyContinuation, atNonLazyBreak, after)(code);
     }
     effects.enter(types2.codeFencedFenceInfo);
-    effects.enter(types2.chunkString, { contentType: constants2.contentTypeString });
+    effects.enter(types2.chunkString, { contentType: constants3.contentTypeString });
     return info(code);
   }
   function info(code) {
@@ -56954,7 +57006,7 @@ function tokenizeCodeFenced(effects, ok2, nok) {
       return infoBefore(code);
     }
     effects.enter(types2.codeFencedFenceMeta);
-    effects.enter(types2.chunkString, { contentType: constants2.contentTypeString });
+    effects.enter(types2.chunkString, { contentType: constants3.contentTypeString });
     return meta(code);
   }
   function meta(code) {
@@ -57015,7 +57067,7 @@ function tokenizeCodeFenced(effects, ok2, nok) {
     function start2(code) {
       ok(self.parser.constructs.disable.null, "expected `disable.null` to be populated");
       effects2.enter(types2.codeFencedFence);
-      return markdownSpace(code) ? factorySpace(effects2, beforeSequenceClose, types2.linePrefix, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants2.tabSize)(code) : beforeSequenceClose(code);
+      return markdownSpace(code) ? factorySpace(effects2, beforeSequenceClose, types2.linePrefix, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants3.tabSize)(code) : beforeSequenceClose(code);
     }
     function beforeSequenceClose(code) {
       if (code === marker) {
@@ -57074,11 +57126,11 @@ function tokenizeCodeIndented(effects, ok2, nok) {
   function start(code) {
     ok(markdownSpace(code));
     effects.enter(types2.codeIndented);
-    return factorySpace(effects, afterPrefix, types2.linePrefix, constants2.tabSize + 1)(code);
+    return factorySpace(effects, afterPrefix, types2.linePrefix, constants3.tabSize + 1)(code);
   }
   function afterPrefix(code) {
     const tail = self.events[self.events.length - 1];
-    return tail && tail[1].type === types2.linePrefix && tail[2].sliceSerialize(tail[1], true).length >= constants2.tabSize ? atBreak(code) : nok(code);
+    return tail && tail[1].type === types2.linePrefix && tail[2].sliceSerialize(tail[1], true).length >= constants3.tabSize ? atBreak(code) : nok(code);
   }
   function atBreak(code) {
     if (code === codes.eof) {
@@ -57116,11 +57168,11 @@ function tokenizeFurtherStart(effects, ok2, nok) {
       effects.exit(types2.lineEnding);
       return furtherStart2;
     }
-    return factorySpace(effects, afterPrefix, types2.linePrefix, constants2.tabSize + 1)(code);
+    return factorySpace(effects, afterPrefix, types2.linePrefix, constants3.tabSize + 1)(code);
   }
   function afterPrefix(code) {
     const tail = self.events[self.events.length - 1];
-    return tail && tail[1].type === types2.linePrefix && tail[2].sliceSerialize(tail[1], true).length >= constants2.tabSize ? ok2(code) : markdownLineEnding(code) ? furtherStart2(code) : nok(code);
+    return tail && tail[1].type === types2.linePrefix && tail[2].sliceSerialize(tail[1], true).length >= constants3.tabSize ? ok2(code) : markdownLineEnding(code) ? furtherStart2(code) : nok(code);
   }
 }
 // ../node_modules/.bun/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/dev/lib/code-text.js
@@ -57312,12 +57364,12 @@ class SpliceBuffer {
 }
 function chunkedPush(list, right) {
   let chunkStart = 0;
-  if (right.length < constants2.v8MaxSafeChunkSize) {
+  if (right.length < constants3.v8MaxSafeChunkSize) {
     list.push(...right);
   } else {
     while (chunkStart < right.length) {
-      list.push(...right.slice(chunkStart, chunkStart + constants2.v8MaxSafeChunkSize));
-      chunkStart += constants2.v8MaxSafeChunkSize;
+      list.push(...right.slice(chunkStart, chunkStart + constants3.v8MaxSafeChunkSize));
+      chunkStart += constants3.v8MaxSafeChunkSize;
     }
   }
 }
@@ -57489,7 +57541,7 @@ function tokenizeContent(effects, ok2) {
     ok(code !== codes.eof && !markdownLineEnding(code), "expected no eof or eol");
     effects.enter(types2.content);
     previous2 = effects.enter(types2.chunkContent, {
-      contentType: constants2.contentTypeContent
+      contentType: constants3.contentTypeContent
     });
     return chunkInside(code);
   }
@@ -57514,7 +57566,7 @@ function tokenizeContent(effects, ok2) {
     effects.exit(types2.chunkContent);
     ok(previous2, "expected previous token");
     previous2.next = effects.enter(types2.chunkContent, {
-      contentType: constants2.contentTypeContent,
+      contentType: constants3.contentTypeContent,
       previous: previous2
     });
     previous2 = previous2.next;
@@ -57538,7 +57590,7 @@ function tokenizeContinuation(effects, ok2, nok) {
     }
     ok(self.parser.constructs.disable.null, "expected `disable.null` to be populated");
     const tail = self.events[self.events.length - 1];
-    if (!self.parser.constructs.disable.null.includes("codeIndented") && tail && tail[1].type === types2.linePrefix && tail[2].sliceSerialize(tail[1], true).length >= constants2.tabSize) {
+    if (!self.parser.constructs.disable.null.includes("codeIndented") && tail && tail[1].type === types2.linePrefix && tail[2].sliceSerialize(tail[1], true).length >= constants3.tabSize) {
       return ok2(code);
     }
     return effects.interrupt(self.parser.constructs.flow, nok, ok2)(code);
@@ -57564,7 +57616,7 @@ function factoryDestination(effects, ok2, nok, type, literalType2, literalMarker
     effects.enter(type);
     effects.enter(rawType);
     effects.enter(stringType2);
-    effects.enter(types2.chunkString, { contentType: constants2.contentTypeString });
+    effects.enter(types2.chunkString, { contentType: constants3.contentTypeString });
     return raw(code);
   }
   function enclosedBefore(code) {
@@ -57577,7 +57629,7 @@ function factoryDestination(effects, ok2, nok, type, literalType2, literalMarker
       return ok2;
     }
     effects.enter(stringType2);
-    effects.enter(types2.chunkString, { contentType: constants2.contentTypeString });
+    effects.enter(types2.chunkString, { contentType: constants3.contentTypeString });
     return enclosed(code);
   }
   function enclosed(code) {
@@ -57648,7 +57700,7 @@ function factoryLabel(effects, ok2, nok, type, markerType, stringType2) {
     return atBreak;
   }
   function atBreak(code) {
-    if (size > constants2.linkReferenceSizeMax || code === codes.eof || code === codes.leftSquareBracket || code === codes.rightSquareBracket && !seen || code === codes.caret && !size && "_hiddenFootnoteSupport" in self.parser.constructs) {
+    if (size > constants3.linkReferenceSizeMax || code === codes.eof || code === codes.leftSquareBracket || code === codes.rightSquareBracket && !seen || code === codes.caret && !size && "_hiddenFootnoteSupport" in self.parser.constructs) {
       return nok(code);
     }
     if (code === codes.rightSquareBracket) {
@@ -57665,11 +57717,11 @@ function factoryLabel(effects, ok2, nok, type, markerType, stringType2) {
       effects.exit(types2.lineEnding);
       return atBreak;
     }
-    effects.enter(types2.chunkString, { contentType: constants2.contentTypeString });
+    effects.enter(types2.chunkString, { contentType: constants3.contentTypeString });
     return labelInside(code);
   }
   function labelInside(code) {
-    if (code === codes.eof || code === codes.leftSquareBracket || code === codes.rightSquareBracket || markdownLineEnding(code) || size++ > constants2.linkReferenceSizeMax) {
+    if (code === codes.eof || code === codes.leftSquareBracket || code === codes.rightSquareBracket || markdownLineEnding(code) || size++ > constants3.linkReferenceSizeMax) {
       effects.exit(types2.chunkString);
       return atBreak(code);
     }
@@ -57728,7 +57780,7 @@ function factoryTitle(effects, ok2, nok, type, markerType, stringType2) {
       effects.exit(types2.lineEnding);
       return factorySpace(effects, atBreak, types2.linePrefix);
     }
-    effects.enter(types2.chunkString, { contentType: constants2.contentTypeString });
+    effects.enter(types2.chunkString, { contentType: constants3.contentTypeString });
     return inside(code);
   }
   function inside(code) {
@@ -57879,7 +57931,7 @@ function resolveHeadingAtx(events, context) {
       type: types2.chunkText,
       start: events[contentStart][1].start,
       end: events[contentEnd][1].end,
-      contentType: constants2.contentTypeText
+      contentType: constants3.contentTypeText
     };
     splice(events, contentStart, contentEnd - contentStart + 1, [
       ["enter", content3, context],
@@ -57903,7 +57955,7 @@ function tokenizeHeadingAtx(effects, ok2, nok) {
     return sequenceOpen(code);
   }
   function sequenceOpen(code) {
-    if (code === codes.numberSign && size++ < constants2.atxHeadingOpeningFenceSizeMax) {
+    if (code === codes.numberSign && size++ < constants3.atxHeadingOpeningFenceSizeMax) {
       effects.consume(code);
       return sequenceOpen;
     }
@@ -58068,7 +58120,7 @@ function tokenizeHtmlFlow(effects, ok2, nok) {
     }
     if (code === codes.questionMark) {
       effects.consume(code);
-      marker = constants2.htmlInstruction;
+      marker = constants3.htmlInstruction;
       return self.interrupt ? ok2 : continuationDeclarationInside;
     }
     if (asciiAlpha(code)) {
@@ -58082,18 +58134,18 @@ function tokenizeHtmlFlow(effects, ok2, nok) {
   function declarationOpen(code) {
     if (code === codes.dash) {
       effects.consume(code);
-      marker = constants2.htmlComment;
+      marker = constants3.htmlComment;
       return commentOpenInside;
     }
     if (code === codes.leftSquareBracket) {
       effects.consume(code);
-      marker = constants2.htmlCdata;
+      marker = constants3.htmlCdata;
       index = 0;
       return cdataOpenInside;
     }
     if (asciiAlpha(code)) {
       effects.consume(code);
-      marker = constants2.htmlDeclaration;
+      marker = constants3.htmlDeclaration;
       return self.interrupt ? ok2 : continuationDeclarationInside;
     }
     return nok(code);
@@ -58106,7 +58158,7 @@ function tokenizeHtmlFlow(effects, ok2, nok) {
     return nok(code);
   }
   function cdataOpenInside(code) {
-    const value = constants2.cdataOpeningString;
+    const value = constants3.cdataOpeningString;
     if (code === value.charCodeAt(index++)) {
       effects.consume(code);
       if (index === value.length) {
@@ -58130,18 +58182,18 @@ function tokenizeHtmlFlow(effects, ok2, nok) {
       const slash = code === codes.slash;
       const name = buffer.toLowerCase();
       if (!slash && !closingTag && htmlRawNames.includes(name)) {
-        marker = constants2.htmlRaw;
+        marker = constants3.htmlRaw;
         return self.interrupt ? ok2(code) : continuation(code);
       }
       if (htmlBlockNames.includes(buffer.toLowerCase())) {
-        marker = constants2.htmlBasic;
+        marker = constants3.htmlBasic;
         if (slash) {
           effects.consume(code);
           return basicSelfClosing;
         }
         return self.interrupt ? ok2(code) : continuation(code);
       }
-      marker = constants2.htmlComplete;
+      marker = constants3.htmlComplete;
       return self.interrupt && !self.parser.lazy[self.now().line] ? nok(code) : closingTag ? completeClosingTagAfter(code) : completeAttributeNameBefore(code);
     }
     if (code === codes.dash || asciiAlphanumeric(code)) {
@@ -58256,27 +58308,27 @@ function tokenizeHtmlFlow(effects, ok2, nok) {
     return nok(code);
   }
   function continuation(code) {
-    if (code === codes.dash && marker === constants2.htmlComment) {
+    if (code === codes.dash && marker === constants3.htmlComment) {
       effects.consume(code);
       return continuationCommentInside;
     }
-    if (code === codes.lessThan && marker === constants2.htmlRaw) {
+    if (code === codes.lessThan && marker === constants3.htmlRaw) {
       effects.consume(code);
       return continuationRawTagOpen;
     }
-    if (code === codes.greaterThan && marker === constants2.htmlDeclaration) {
+    if (code === codes.greaterThan && marker === constants3.htmlDeclaration) {
       effects.consume(code);
       return continuationClose;
     }
-    if (code === codes.questionMark && marker === constants2.htmlInstruction) {
+    if (code === codes.questionMark && marker === constants3.htmlInstruction) {
       effects.consume(code);
       return continuationDeclarationInside;
     }
-    if (code === codes.rightSquareBracket && marker === constants2.htmlCdata) {
+    if (code === codes.rightSquareBracket && marker === constants3.htmlCdata) {
       effects.consume(code);
       return continuationCdataInside;
     }
-    if (markdownLineEnding(code) && (marker === constants2.htmlBasic || marker === constants2.htmlComplete)) {
+    if (markdownLineEnding(code) && (marker === constants3.htmlBasic || marker === constants3.htmlComplete)) {
       effects.exit(types2.htmlFlowData);
       return effects.check(blankLineBefore, continuationAfter, continuationStart)(code);
     }
@@ -58328,7 +58380,7 @@ function tokenizeHtmlFlow(effects, ok2, nok) {
       }
       return continuation(code);
     }
-    if (asciiAlpha(code) && buffer.length < constants2.htmlRawSizeMax) {
+    if (asciiAlpha(code) && buffer.length < constants3.htmlRawSizeMax) {
       ok(code !== null);
       effects.consume(code);
       buffer += String.fromCharCode(code);
@@ -58348,7 +58400,7 @@ function tokenizeHtmlFlow(effects, ok2, nok) {
       effects.consume(code);
       return continuationClose;
     }
-    if (code === codes.dash && marker === constants2.htmlComment) {
+    if (code === codes.dash && marker === constants3.htmlComment) {
       effects.consume(code);
       return continuationDeclarationInside;
     }
@@ -58476,7 +58528,7 @@ function tokenizeHtmlText(effects, ok2, nok) {
     return code === codes.greaterThan ? end(code) : code === codes.dash ? commentClose(code) : comment(code);
   }
   function cdataOpenInside(code) {
-    const value = constants2.cdataOpeningString;
+    const value = constants3.cdataOpeningString;
     if (code === value.charCodeAt(index++)) {
       effects.consume(code);
       return index === value.length ? cdata : cdataOpenInside;
@@ -58692,7 +58744,7 @@ function tokenizeHtmlText(effects, ok2, nok) {
   }
   function lineEndingAfter(code) {
     ok(self.parser.constructs.disable.null, "expected `disable.null` to be populated");
-    return markdownSpace(code) ? factorySpace(effects, lineEndingAfterPrefix, types2.linePrefix, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants2.tabSize)(code) : lineEndingAfterPrefix(code);
+    return markdownSpace(code) ? factorySpace(effects, lineEndingAfterPrefix, types2.linePrefix, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants3.tabSize)(code) : lineEndingAfterPrefix(code);
   }
   function lineEndingAfterPrefix(code) {
     effects.enter(types2.htmlTextData);
@@ -58855,7 +58907,7 @@ function tokenizeResource(effects, ok2, nok) {
     if (code === codes.rightParenthesis) {
       return resourceEnd(code);
     }
-    return factoryDestination(effects, resourceDestinationAfter, resourceDestinationMissing, types2.resourceDestination, types2.resourceDestinationLiteral, types2.resourceDestinationLiteralMarker, types2.resourceDestinationRaw, types2.resourceDestinationString, constants2.linkResourceDestinationBalanceMax)(code);
+    return factoryDestination(effects, resourceDestinationAfter, resourceDestinationMissing, types2.resourceDestination, types2.resourceDestinationLiteral, types2.resourceDestinationLiteralMarker, types2.resourceDestinationRaw, types2.resourceDestinationString, constants3.linkResourceDestinationBalanceMax)(code);
   }
   function resourceDestinationAfter(code) {
     return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceBetween)(code) : resourceEnd(code);
@@ -59006,7 +59058,7 @@ function tokenizeThematicBreak(effects, ok2, nok) {
       effects.enter(types2.thematicBreakSequence);
       return sequence(code);
     }
-    if (size >= constants2.thematicBreakMarkerCountMin && (code === codes.eof || markdownLineEnding(code))) {
+    if (size >= constants3.thematicBreakMarkerCountMin && (code === codes.eof || markdownLineEnding(code))) {
       effects.exit(types2.thematicBreak);
       return ok2(code);
     }
@@ -59063,7 +59115,7 @@ function tokenizeListStart(effects, ok2, nok) {
   }
   function inside(code) {
     ok(self.containerState, "expected state");
-    if (asciiDigit(code) && ++size < constants2.listItemValueSizeMax) {
+    if (asciiDigit(code) && ++size < constants3.listItemValueSizeMax) {
       effects.consume(code);
       return inside;
     }
@@ -59130,7 +59182,7 @@ function tokenizeListContinuation(effects, ok2, nok) {
     self.containerState._closeFlow = true;
     self.interrupt = undefined;
     ok(self.parser.constructs.disable.null, "expected `disable.null` to be populated");
-    return factorySpace(effects, effects.attempt(list, ok2, nok), types2.linePrefix, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants2.tabSize)(code);
+    return factorySpace(effects, effects.attempt(list, ok2, nok), types2.linePrefix, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants3.tabSize)(code);
   }
 }
 function tokenizeIndent(effects, ok2, nok) {
@@ -59152,7 +59204,7 @@ function tokenizeListEnd(effects) {
 function tokenizeListItemPrefixWhitespace(effects, ok2, nok) {
   const self = this;
   ok(self.parser.constructs.disable.null, "expected `disable.null` to be populated");
-  return factorySpace(effects, afterPrefix, types2.listItemPrefixWhitespace, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants2.tabSize + 1);
+  return factorySpace(effects, afterPrefix, types2.listItemPrefixWhitespace, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants3.tabSize + 1);
   function afterPrefix(code) {
     const tail = self.events[self.events.length - 1];
     return !markdownSpace(code) && tail && tail[1].type === types2.listItemPrefixWhitespace ? ok2(code) : nok(code);
@@ -59390,7 +59442,7 @@ function resolveAllLineSuffixes(events, context) {
       }
       if (size) {
         const token = {
-          type: eventIndex === events.length || tabs || size < constants2.hardBreakPrefixSizeMin ? types2.lineSuffix : types2.hardBreakTrailing,
+          type: eventIndex === events.length || tabs || size < constants3.hardBreakPrefixSizeMin ? types2.lineSuffix : types2.hardBreakTrailing,
           start: {
             _bufferIndex: index ? bufferIndex : data.start._bufferIndex + bufferIndex,
             _index: data.start._index + index,
@@ -59880,7 +59932,7 @@ function preprocess() {
             break;
           }
           case codes.ht: {
-            next = Math.ceil(column / constants2.tabSize) * constants2.tabSize;
+            next = Math.ceil(column / constants3.tabSize) * constants3.tabSize;
             chunks.push(codes.horizontalTab);
             while (column++ < next)
               chunks.push(codes.virtualSpace);
@@ -59922,7 +59974,7 @@ function decode($0, $1, $2) {
   if (head === codes.numberSign) {
     const head2 = $2.charCodeAt(1);
     const hex = head2 === codes.lowercaseX || head2 === codes.uppercaseX;
-    return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? constants2.numericBaseHexadecimal : constants2.numericBaseDecimal);
+    return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? constants3.numericBaseHexadecimal : constants3.numericBaseDecimal);
   }
   return decodeNamedCharacterReference($2) || $0;
 }
@@ -60259,7 +60311,7 @@ function compiler(options) {
       const ancestor = this.stack[this.stack.length - 2];
       ok(ancestor, "expected nodes on stack");
       ok(ancestor.type === "list", "expected list on stack");
-      ancestor.start = Number.parseInt(this.sliceSerialize(token), constants2.numericBaseDecimal);
+      ancestor.start = Number.parseInt(this.sliceSerialize(token), constants3.numericBaseDecimal);
       this.data.expectingFirstListItemValue = undefined;
     }
   }
@@ -60500,7 +60552,7 @@ function compiler(options) {
     const type = this.data.characterReferenceType;
     let value;
     if (type) {
-      value = decodeNumericCharacterReference(data2, type === types2.characterReferenceMarkerNumeric ? constants2.numericBaseDecimal : constants2.numericBaseHexadecimal);
+      value = decodeNumericCharacterReference(data2, type === types2.characterReferenceMarkerNumeric ? constants3.numericBaseDecimal : constants3.numericBaseHexadecimal);
       this.data.characterReferenceType = undefined;
     } else {
       const result = decodeNamedCharacterReference(data2);
@@ -61116,7 +61168,7 @@ function tokenizeGfmFootnoteCall(effects, ok2, nok) {
     return callData;
   }
   function callData(code2) {
-    if (size > constants2.linkReferenceSizeMax || code2 === codes.rightSquareBracket && !data || code2 === codes.eof || code2 === codes.leftSquareBracket || markdownLineEndingOrSpace(code2)) {
+    if (size > constants3.linkReferenceSizeMax || code2 === codes.rightSquareBracket && !data || code2 === codes.eof || code2 === codes.leftSquareBracket || markdownLineEndingOrSpace(code2)) {
       return nok(code2);
     }
     if (code2 === codes.rightSquareBracket) {
@@ -61175,7 +61227,7 @@ function tokenizeDefinitionStart(effects, ok2, nok) {
     return nok(code2);
   }
   function labelInside(code2) {
-    if (size > constants2.linkReferenceSizeMax || code2 === codes.rightSquareBracket && !data || code2 === codes.eof || code2 === codes.leftSquareBracket || markdownLineEndingOrSpace(code2)) {
+    if (size > constants3.linkReferenceSizeMax || code2 === codes.rightSquareBracket && !data || code2 === codes.eof || code2 === codes.leftSquareBracket || markdownLineEndingOrSpace(code2)) {
       return nok(code2);
     }
     if (code2 === codes.rightSquareBracket) {
@@ -61227,10 +61279,10 @@ function gfmFootnoteDefinitionEnd(effects) {
 }
 function tokenizeIndent2(effects, ok2, nok) {
   const self = this;
-  return factorySpace(effects, afterPrefix, "gfmFootnoteDefinitionIndent", constants2.tabSize + 1);
+  return factorySpace(effects, afterPrefix, "gfmFootnoteDefinitionIndent", constants3.tabSize + 1);
   function afterPrefix(code2) {
     const tail = self.events[self.events.length - 1];
-    return tail && tail[1].type === "gfmFootnoteDefinitionIndent" && tail[2].sliceSerialize(tail[1], true).length === constants2.tabSize ? ok2(code2) : nok(code2);
+    return tail && tail[1].type === "gfmFootnoteDefinitionIndent" && tail[2].sliceSerialize(tail[1], true).length === constants3.tabSize ? ok2(code2) : nok(code2);
   }
 }
 // ../node_modules/.bun/micromark-extension-gfm-strikethrough@2.1.0/node_modules/micromark-extension-gfm-strikethrough/dev/lib/syntax.js
@@ -61326,8 +61378,8 @@ function gfmStrikethrough(options) {
         return nok(code2);
       const token = effects.exit("strikethroughSequenceTemporary");
       const after = classifyCharacter(code2);
-      token._open = !after || after === constants2.attentionSideAfter && Boolean(before);
-      token._close = !before || before === constants2.attentionSideAfter && Boolean(after);
+      token._open = !after || after === constants3.attentionSideAfter && Boolean(before);
+      token._close = !before || before === constants3.attentionSideAfter && Boolean(after);
       return ok2(code2);
     }
   }
@@ -61511,7 +61563,7 @@ function tokenizeTable(effects, ok2, nok) {
     seen = false;
     if (markdownSpace(code2)) {
       ok(self.parser.constructs.disable.null, "expected `disabled.null`");
-      return factorySpace(effects, headDelimiterBefore, types2.linePrefix, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants2.tabSize)(code2);
+      return factorySpace(effects, headDelimiterBefore, types2.linePrefix, self.parser.constructs.disable.null.includes("codeIndented") ? undefined : constants3.tabSize)(code2);
     }
     return headDelimiterBefore(code2);
   }
@@ -61762,7 +61814,7 @@ function flushCell(map, context, range, rowKind, rowEnd, previousCell) {
       const end = context.events[range[3]];
       start[1].end = Object.assign({}, end[1].end);
       start[1].type = types2.chunkText;
-      start[1].contentType = constants2.contentTypeText;
+      start[1].contentType = constants3.contentTypeText;
       if (range[3] > range[2] + 1) {
         const a = range[2] + 1;
         const b = range[3] - range[2] - 1;
@@ -63186,6 +63238,18 @@ function createChatLock() {
 
 // retry-api-call.ts
 var import_grammy6 = __toESM(require_mod2(), 1);
+function classifyBenignTelegram4002(errorCode, description) {
+  if (errorCode !== 400)
+    return null;
+  const desc = (description ?? "").toLowerCase();
+  if (desc.includes("not modified"))
+    return "not_modified";
+  if (desc.includes("message to edit not found"))
+    return "message_not_found";
+  if (desc.includes("message to delete not found"))
+    return "delete_not_found";
+  return null;
+}
 function isLocalResourceError2(err) {
   const code2 = err?.code;
   if (typeof code2 === "string" && ["ENOSPC", "EDQUOT", "EIO", "ENOMEM"].includes(code2)) {
@@ -63270,14 +63334,9 @@ function createRetryApiCall2(config = {}) {
           await sleep(delayMs);
           continue;
         }
-        if (isGrammyErr && err.error_code === 400 && desc.includes("not modified")) {
-          observer?.onBenign?.({ kind: "not_modified" });
-          return;
-        }
-        if (isGrammyErr && err.error_code === 400 && (desc.includes("message to edit not found") || desc.includes("message to delete not found"))) {
-          observer?.onBenign?.({
-            kind: desc.includes("edit") ? "message_not_found" : "delete_not_found"
-          });
+        const benignKind = isGrammyErr ? classifyBenignTelegram4002(err.error_code, desc) : null;
+        if (benignKind !== null) {
+          observer?.onBenign?.({ kind: benignKind });
           return;
         }
         if (isGrammyErr && err.error_code === 400 && desc.includes("thread not found") && opts?.threadId && opts?.chat_id) {
@@ -63425,7 +63484,7 @@ function editFloodFuseConfigFromEnv(env) {
   }
   return cfg;
 }
-var DROPPED_RESULT = true;
+var DROPPED_RESULT = { ok: true, result: true };
 function createEditFloodFuse(config = {}) {
   const enabled2 = config.enabled ?? true;
   const clock = config.clock ?? systemClock;
@@ -63683,12 +63742,12 @@ function createEditFloodFuse(config = {}) {
       const msgKey = `m:${chat}:${msg}`;
       const mw = win(msgKey);
       mw.inflight++;
+      const dropGuard = () => mw.inflight > 1;
+      const lateKey = cls === "cosmetic" ? `lr:${chat}` : undefined;
       try {
-        const msgSlot = await awaitRoom(msgKey, perMessageWindowMs, cls === "cosmetic" ? (t) => ceiling(cosmeticPerMessageMax, t) : (t) => classCeiling(perMessageMax, cls, t), method, "supersede", cls, undefined, deadline);
+        const msgSlot = await awaitRoom(msgKey, perMessageWindowMs, cls === "cosmetic" ? (t) => ceiling(cosmeticPerMessageMax, t) : (t) => classCeiling(perMessageMax, cls, t), method, "supersede", cls, dropGuard, deadline, lateKey);
         if (msgSlot === null)
           return DROPPED_RESULT;
-        const dropGuard = () => mw.inflight > 1;
-        const lateKey = cls === "cosmetic" ? `lr:${chat}` : undefined;
         const reserved = [[msgKey, msgSlot]];
         const giveBack = () => {
           for (const [k, at] of reserved)
@@ -64607,6 +64666,11 @@ function formatTgPostTags(tags) {
   }
   return parts.length > 0 ? " " + parts.join(" ") : "";
 }
+function shortDesc(raw) {
+  if (!raw)
+    return "-";
+  return raw.replace(/\s+/g, " ").slice(0, 80).replace(/[\r\n]/g, " ") || "-";
+}
 function installTgPostLogger(bot) {
   bot.api.config.use(async (prev, method, payload, signal) => {
     const p = payload ?? {};
@@ -64617,20 +64681,28 @@ function installTgPostLogger(bot) {
     const bytes = text4.length;
     const hash = bytes > 0 ? createHash3("sha1").update(text4).digest("hex").slice(0, 12) : "-";
     const tagSuffix = formatTgPostTags(_getTgPostTags());
+    const emit = (status, errClass, code2, desc) => {
+      if (!shouldEmitTgPost(method, status))
+        return;
+      process.stderr.write(`tg-post method=${method} chat=${chat} thread=${thread} parse_mode=${parseMode} bytes=${bytes} hash=${hash} status=${status} err=${errClass} code=${code2} desc=${desc}${tagSuffix}
+`);
+    };
     try {
       const res = await prev(method, payload, signal);
-      if (shouldEmitTgPost(method, "ok")) {
-        process.stderr.write(`tg-post method=${method} chat=${chat} thread=${thread} parse_mode=${parseMode} bytes=${bytes} hash=${hash} status=ok err=- code=- desc=-${tagSuffix}
-`);
+      const r = res;
+      if (r != null && typeof r === "object" && r.ok === false) {
+        const code2 = r.error_code;
+        const benign = classifyBenignTelegram400(code2, r.description);
+        emit(benign !== null ? "benign" : "err", `telegram_${code2 ?? "unknown"}`, code2 != null ? String(code2) : "-", shortDesc(r.description));
+        return res;
       }
+      emit("ok", "-", "-", "-");
       return res;
     } catch (err) {
       const errClass = err instanceof import_grammy7.GrammyError ? `grammy_${err.error_code}` : err?.constructor?.name ?? "Error";
       const code2 = err instanceof import_grammy7.GrammyError ? String(err.error_code) : "-";
       const rawDesc = err instanceof import_grammy7.GrammyError ? err.description : err instanceof Error ? err.message : "";
-      const desc = rawDesc ? rawDesc.replace(/\s+/g, " ").slice(0, 80).replace(/[\r\n]/g, " ") || "-" : "-";
-      process.stderr.write(`tg-post method=${method} chat=${chat} thread=${thread} parse_mode=${parseMode} bytes=${bytes} hash=${hash} status=err err=${errClass} code=${code2} desc=${desc}${tagSuffix}
-`);
+      emit("err", errClass, code2, shortDesc(rawDesc));
       throw err;
     }
   });
@@ -64660,7 +64732,7 @@ import {
   mkdirSync as mkdirSync16,
   chmodSync as chmodSync6,
   unlinkSync as unlinkSync11,
-  renameSync as renameSync9
+  renameSync as renameSync10
 } from "node:fs";
 import { dirname as dirname9, join as join19 } from "node:path";
 var FLOOD_STATE_FILE2 = "flood-wait.json";
@@ -64867,7 +64939,7 @@ function writeFloodWindow(path2, record, now) {
     const arr = [...byScope.values()];
     const tmp = `${path2}.tmp-${process.pid}`;
     writeFileSync13(tmp, JSON.stringify(arr), { mode: FLOOD_STATE_MODE2 });
-    renameSync9(tmp, path2);
+    renameSync10(tmp, path2);
     try {
       chmodSync6(path2, FLOOD_STATE_MODE2);
     } catch {}
@@ -72946,10 +73018,10 @@ function resolveExhaustUntil(resetAtMs, now = Date.now()) {
 
 // gateway/auth-add-flow.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { existsSync as existsSync21, mkdirSync as mkdirSync24, readFileSync as readFileSync22, readdirSync as readdirSync6, rmSync as rmSync5, statSync as statSync9, writeFileSync as writeFileSync20 } from "node:fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync24, readFileSync as readFileSync22, readdirSync as readdirSync6, rmSync as rmSync6, statSync as statSync9, writeFileSync as writeFileSync20 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
 import { join as join29 } from "node:path";
-import { randomBytes as randomBytes8 } from "node:crypto";
+import { randomBytes as randomBytes9 } from "node:crypto";
 
 // ../src/auth/manager.ts
 import {
@@ -72959,7 +73031,7 @@ import {
   writeFileSync as writeFileSync19,
   mkdirSync as mkdirSync23,
   mkdtempSync as mkdtempSync2,
-  rmSync as rmSync4,
+  rmSync as rmSync5,
   chmodSync as chmodSync7,
   statSync as statSync8
 } from "node:fs";
@@ -73054,12 +73126,12 @@ function makeAuthAddTmuxOps(tmuxBin = "tmux") {
 }
 var pendingAuthAddFlows = new Map;
 function pickScratchDir(label, home2 = homedir8()) {
-  const suffix = randomBytes8(8).toString("hex");
+  const suffix = randomBytes9(8).toString("hex");
   return join29(home2, ".switchroom", "accounts", ".in-progress", `${label}-${suffix}`);
 }
 function cleanScratchDir(scratchDir) {
   try {
-    rmSync5(scratchDir, { recursive: true, force: true });
+    rmSync6(scratchDir, { recursive: true, force: true });
   } catch {}
 }
 var AUTH_TMUX_SESSION_FILE = ".auth-tmux-session";
@@ -76377,7 +76449,7 @@ import {
   mkdirSync as mkdirSync26,
   readFileSync as readFileSync23,
   readdirSync as readdirSync7,
-  renameSync as renameSync10,
+  renameSync as renameSync11,
   statSync as statSync10,
   unlinkSync as unlinkSync13,
   writeFileSync as writeFileSync21,
@@ -76413,7 +76485,7 @@ function writeOutboxRecordAtomic(record, stateDir) {
       return true;
     const tmpPath = join31(dir, `.${record.turnNonce}.${process.pid}.tmp`);
     writeFileSync21(tmpPath, JSON.stringify(record), { mode: 384 });
-    renameSync10(tmpPath, finalPath);
+    renameSync11(tmpPath, finalPath);
     return true;
   } catch {
     return false;
@@ -76440,7 +76512,7 @@ function claimRecord(nonce, stateDir) {
   const from = join31(dir, `${nonce}.json`);
   const to = join31(dir, `${nonce}.sending`);
   try {
-    renameSync10(from, to);
+    renameSync11(from, to);
     return to;
   } catch {
     return null;
@@ -76449,7 +76521,7 @@ function claimRecord(nonce, stateDir) {
 function releaseClaim(nonce, stateDir) {
   const dir = resolveOutboxDir(stateDir);
   try {
-    renameSync10(join31(dir, `${nonce}.sending`), join31(dir, `${nonce}.json`));
+    renameSync11(join31(dir, `${nonce}.sending`), join31(dir, `${nonce}.json`));
   } catch {}
 }
 function removeClaimed(nonce, stateDir) {
@@ -76469,7 +76541,7 @@ function reclaimStaleSending(stateDir, now = Date.now()) {
     try {
       const st = statSync10(join31(dir, f));
       if (now - st.mtimeMs > OUTBOX_SENDING_TIMEOUT_MS) {
-        renameSync10(join31(dir, f), join31(dir, f.replace(/\.sending$/, ".json")));
+        renameSync11(join31(dir, f), join31(dir, f.replace(/\.sending$/, ".json")));
       }
     } catch {}
   }
@@ -76543,7 +76615,7 @@ function compactJournalIfLarge(path2) {
     writeFileSync21(tmp, kept.join(`
 `) + `
 `, { mode: 384 });
-    renameSync10(tmp, path2);
+    renameSync11(tmp, path2);
   } catch {}
 }
 function clearOutboxRecord(nonce, stateDir) {
@@ -76607,7 +76679,7 @@ import {
   existsSync as existsSync24,
   mkdirSync as mkdirSync27,
   readFileSync as readFileSync24,
-  renameSync as renameSync11,
+  renameSync as renameSync12,
   writeFileSync as writeFileSync22,
   appendFileSync as appendFileSync5
 } from "node:fs";
@@ -76741,7 +76813,7 @@ function compactIfLarge(path2) {
     writeFileSync22(tmp, kept.join(`
 `) + `
 `, { mode: 384 });
-    renameSync11(tmp, path2);
+    renameSync12(tmp, path2);
   } catch {}
 }
 
@@ -77198,7 +77270,7 @@ function eagerVoiceEnabled2() {
 }
 
 // photo-precheck.ts
-import { closeSync as closeSync5, fstatSync, openSync as openSync5, readSync } from "node:fs";
+import { closeSync as closeSync6, fstatSync, openSync as openSync6, readSync } from "node:fs";
 var PHOTO_MAX_DIMENSION_SUM = 1e4;
 var PHOTO_MAX_ASPECT_RATIO = 10;
 var PHOTO_MAX_BYTES = 10 * 1024 * 1024;
@@ -77279,7 +77351,7 @@ var JPEG_PROBE_BYTES = 64 * 1024;
 function probeImageFile(path2) {
   let fd;
   try {
-    fd = openSync5(path2, "r");
+    fd = openSync6(path2, "r");
     const bytes = fstatSync(fd).size;
     const headBuf = Buffer.alloc(HEADER_PROBE_BYTES);
     const headRead = readSync(fd, headBuf, 0, HEADER_PROBE_BYTES, 0);
@@ -77298,7 +77370,7 @@ function probeImageFile(path2) {
   } finally {
     if (fd !== undefined) {
       try {
-        closeSync5(fd);
+        closeSync6(fd);
       } catch {}
     }
   }
@@ -79526,10 +79598,10 @@ function detectStatusSurfaceDegraded(t) {
 
 // gateway/turn-active-marker.ts
 import {
-  closeSync as closeSync6,
+  closeSync as closeSync7,
   existsSync as existsSync28,
   mkdirSync as mkdirSync31,
-  openSync as openSync6,
+  openSync as openSync7,
   readFileSync as readFileSync26,
   statSync as statSync12,
   unlinkSync as unlinkSync15,
@@ -79555,8 +79627,8 @@ function touchTurnActiveMarker(stateDir) {
     utimesSync(path2, now, now);
   } catch {
     try {
-      const fd = openSync6(path2, "r+");
-      closeSync6(fd);
+      const fd = openSync7(path2, "r+");
+      closeSync7(fd);
     } catch {}
   }
 }
@@ -80882,7 +80954,8 @@ function createNarrativeLane(deps) {
       toolCount: turn.labeledToolCount,
       state: final ? "done" : "running",
       model: turn.currentModel,
-      totalTokens: turn.totalTokens
+      totalTokens: turn.totalTokens,
+      resultText: final ? turn.lastReplyText : undefined
     };
     return renderActivityFeedWithNested(turn.mirrorLines, childLines, final, liveSuffix, stepCount, header);
   }
@@ -81199,7 +81272,8 @@ function createNarrativeLane(deps) {
           elapsedMs: livenessElapsed,
           toolCount: turn.labeledToolCount,
           state: "done",
-          model: turn.currentModel
+          model: turn.currentModel,
+          resultText: turn.lastReplyText
         };
         finalHtml = renderActivityFeedWithNested(["Working\u2026"], [], true, "", undefined, livenessHeader);
       }
@@ -81569,7 +81643,7 @@ function resolveAgentDirFromEnv() {
 }
 
 // active-reactions.ts
-import { readFileSync as readFileSync27, writeFileSync as writeFileSync25, renameSync as renameSync12, existsSync as existsSync29, unlinkSync as unlinkSync16 } from "node:fs";
+import { readFileSync as readFileSync27, writeFileSync as writeFileSync25, renameSync as renameSync13, existsSync as existsSync29, unlinkSync as unlinkSync16 } from "node:fs";
 import { join as join37 } from "node:path";
 var ACTIVE_REACTIONS_FILENAME = ".active-reactions.json";
 function reactionsPath(agentDir) {
@@ -81615,7 +81689,7 @@ function writeActiveReactions(agentDir, reactions) {
   try {
     writeFileSync25(tmp, JSON.stringify(reactions) + `
 `, "utf-8");
-    renameSync12(tmp, p);
+    renameSync13(tmp, p);
   } catch {}
 }
 function addActiveReaction(agentDir, reaction) {
@@ -81637,7 +81711,7 @@ function clearActiveReactions(agentDir) {
 }
 
 // active-reactions.ts
-import { readFileSync as readFileSync28, writeFileSync as writeFileSync26, renameSync as renameSync13, existsSync as existsSync30, unlinkSync as unlinkSync17 } from "node:fs";
+import { readFileSync as readFileSync28, writeFileSync as writeFileSync26, renameSync as renameSync14, existsSync as existsSync30, unlinkSync as unlinkSync17 } from "node:fs";
 import { join as join38 } from "node:path";
 var ACTIVE_REACTIONS_FILENAME2 = ".active-reactions.json";
 function reactionsPath2(agentDir) {
@@ -83866,7 +83940,7 @@ async function menuWithBannerStatic(deps, banner) {
 }
 
 // gateway/session-model-file.ts
-import { readFileSync as readFileSync30, writeFileSync as writeFileSync27, renameSync as renameSync14, rmSync as rmSync6 } from "node:fs";
+import { readFileSync as readFileSync30, writeFileSync as writeFileSync27, renameSync as renameSync15, rmSync as rmSync7 } from "node:fs";
 import { join as join40 } from "node:path";
 var SESSION_MODEL_FILE = ".session-model";
 var CONFIGURED_DEFAULT_MODEL_FILE = ".configured-default-model";
@@ -83874,7 +83948,7 @@ var SESSION_MODEL_BOOT_ATTEMPTS_FILE = ".session-model-boot-attempts";
 function atomicWrite(path2, content3) {
   const tmp = `${path2}.tmp-${process.pid}-${Date.now()}`;
   writeFileSync27(tmp, content3, "utf8");
-  renameSync14(tmp, path2);
+  renameSync15(tmp, path2);
 }
 function serializeSessionModel(rec) {
   return `${JSON.stringify({
@@ -83889,7 +83963,7 @@ function writeSessionModelFile(agentDir, model, configuredDefaultAtWrite) {
     throw new Error(`refusing to persist non-canonical session model token: ${JSON.stringify(model)}`);
   }
   try {
-    rmSync6(join40(agentDir, SESSION_MODEL_BOOT_ATTEMPTS_FILE), { force: true });
+    rmSync7(join40(agentDir, SESSION_MODEL_BOOT_ATTEMPTS_FILE), { force: true });
   } catch {}
   atomicWrite(join40(agentDir, SESSION_MODEL_FILE), serializeSessionModel({ model, configuredDefaultAtWrite, ts: Date.now() }));
 }
@@ -83902,15 +83976,15 @@ function readSessionModelFileRaw(agentDir) {
 }
 function clearSessionModelFile(agentDir) {
   try {
-    rmSync6(join40(agentDir, SESSION_MODEL_FILE), { force: true });
+    rmSync7(join40(agentDir, SESSION_MODEL_FILE), { force: true });
   } catch {}
 }
 function consumeSessionModelCarrierOnHealthyBoot(agentDir) {
   try {
-    rmSync6(join40(agentDir, SESSION_MODEL_FILE), { force: true });
+    rmSync7(join40(agentDir, SESSION_MODEL_FILE), { force: true });
   } catch {}
   try {
-    rmSync6(join40(agentDir, SESSION_MODEL_BOOT_ATTEMPTS_FILE), { force: true });
+    rmSync7(join40(agentDir, SESSION_MODEL_BOOT_ATTEMPTS_FILE), { force: true });
   } catch {}
 }
 function restoreSessionModelFileRaw(agentDir, raw) {
@@ -83941,7 +84015,7 @@ function writeSessionEffortFile(agentDir, level, configuredDefaultAtWrite) {
 }
 function clearSessionEffortFile(agentDir) {
   try {
-    rmSync6(join40(agentDir, SESSION_EFFORT_FILE), { force: true });
+    rmSync7(join40(agentDir, SESSION_EFFORT_FILE), { force: true });
   } catch {}
 }
 var PREMIUM_RECOVERY_FILE = ".premium-recovery";
@@ -83983,7 +84057,7 @@ function readPremiumRecoveryFile(agentDir) {
 }
 function clearPremiumRecoveryFile(agentDir) {
   try {
-    rmSync6(join40(agentDir, PREMIUM_RECOVERY_FILE), { force: true });
+    rmSync7(join40(agentDir, PREMIUM_RECOVERY_FILE), { force: true });
   } catch {}
 }
 
@@ -86239,7 +86313,7 @@ function nextCompactNotify(state6, ev) {
 
 // gateway/hostd-dispatch.ts
 import { existsSync as existsSync36 } from "node:fs";
-import { randomBytes as randomBytes9 } from "node:crypto";
+import { randomBytes as randomBytes10 } from "node:crypto";
 init_loader();
 var _hostdEnabled2;
 function isHostdEnabled2() {
@@ -86286,7 +86360,7 @@ async function tryHostdDispatch2(agentName3, req, timeoutMs = 5000) {
   }
 }
 function hostdRequestId2(prefix) {
-  return `${prefix}-${Date.now()}-${randomBytes9(4).toString("hex")}`;
+  return `${prefix}-${Date.now()}-${randomBytes10(4).toString("hex")}`;
 }
 function withOperatorAttestation(req, passphrase) {
   if (!passphrase)
@@ -86348,6 +86422,56 @@ function shouldSweepChatAtBoot(chatId) {
   return n < 0;
 }
 
+// gateway/stale-pin-sweep-store.ts
+var SWEEP_MAX_ATTEMPTS = 8;
+var SWEEP_ENVELOPE_VERSIONS = new Set([1]);
+function sweepTargetKey(chatId, threadId) {
+  return `${chatId}:${threadId ?? "-"}`;
+}
+function isCursorRow(x) {
+  if (x == null || typeof x !== "object")
+    return false;
+  const o = x;
+  return typeof o.chatId === "string" && o.chatId.length > 0 && (o.threadId === undefined || typeof o.threadId === "number") && (o.kind === "dm" || o.kind === "forum-topic" || o.kind === "supergroup") && typeof o.popped === "number" && typeof o.done === "boolean" && typeof o.attempts === "number" && (o.doneIds === undefined || Array.isArray(o.doneIds) && o.doneIds.every((n) => typeof n === "number")) && (o.lastStatus === undefined || typeof o.lastStatus === "string") && typeof o.updatedAt === "number";
+}
+function loadSweepCursors(path2, fs2) {
+  if (!fs2.existsSync(path2))
+    return [];
+  let raw = "";
+  try {
+    raw = fs2.readFileSync(path2);
+  } catch {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (parsed == null || typeof parsed !== "object")
+    return [];
+  const env = parsed;
+  if (typeof env.v !== "number" || !SWEEP_ENVELOPE_VERSIONS.has(env.v) || !Array.isArray(env.cursors)) {
+    return [];
+  }
+  return env.cursors.filter(isCursorRow);
+}
+function persistSweepCursors(path2, fs2, cursors, log = (l) => process.stderr.write(l)) {
+  const env = { v: 1, cursors: [...cursors] };
+  try {
+    fs2.writeFileSync(path2, JSON.stringify(env));
+  } catch (err) {
+    log(`stale-pin-sweep-store: persist FAILED path=${path2}: ${err.message} \u2014 ` + `durability degraded; a restart mid-sweep will re-seed instead of resume
+`);
+  }
+}
+function upsertSweepCursor(path2, fs2, cursor, log = (l) => process.stderr.write(l)) {
+  const key = sweepTargetKey(cursor.chatId, cursor.threadId);
+  const others = loadSweepCursors(path2, fs2).filter((c) => sweepTargetKey(c.chatId, c.threadId) !== key);
+  persistSweepCursors(path2, fs2, [...others, cursor], log);
+}
+
 // gateway/boot-sweep-gate.ts
 function createBootSweepGate(args) {
   let armed = false;
@@ -86392,21 +86516,22 @@ async function step(name, fn, log) {
 }
 async function runBootPinSweepSteps(deps) {
   const log = deps.log ?? ((l) => process.stderr.write(l));
-  let dmChatIds = [];
-  await step("dm-chat-scan", async () => {
-    dmChatIds = deps.scanDmChatIds();
+  let targets = [];
+  await step("sweep-target-scan", async () => {
+    targets = deps.scanSweepTargets();
   }, log);
   await step("status-pin-cleanup", deps.statusPinCleanup, log);
   await step("activity-card-reaper", deps.activityCardReaper, log);
   await step("queued-card-reaper", deps.queuedCardReaper, log);
-  await step("enable-dm-sweep", async () => deps.enableDmSweep(), log);
-  for (const id of dmChatIds)
-    await step(`dm-sweep:${id}`, () => deps.sweepDm(id), log);
+  await step("enable-sweep", async () => deps.enableSweep(), log);
+  for (const t of targets) {
+    await step(`stale-pin-sweep:${sweepTargetKey(t.chatId, t.threadId)}`, () => deps.sweepTarget(t), log);
+  }
 }
 
 // gateway/status-pin-retarget.ts
 async function runStatusPinReconcile(args) {
-  const { pinKey, chatId, prev, desired, persist, runPin, claims } = args;
+  const { pinKey, chatId, threadId, prev, desired, persist, runPin, claims } = args;
   const now = args.now ?? Date.now;
   const commit = (next) => {
     if (next == null) {
@@ -86414,7 +86539,7 @@ async function runStatusPinReconcile(args) {
       return;
     }
     const pinnedAt = claims.get(pinKey)?.pinnedAt ?? now();
-    claims.set(pinKey, { messageId: next.messageId, chatId, pinnedAt });
+    claims.set(pinKey, { messageId: next.messageId, chatId, threadId, pinnedAt });
   };
   const runLeg = (legAction, from) => {
     if (persist == null)
@@ -86425,6 +86550,7 @@ async function runStatusPinReconcile(args) {
       fs: persist.fs,
       pinKey,
       chatId,
+      threadId,
       op,
       applyPin: () => runPin(legAction, from),
       now: now()
@@ -86524,24 +86650,77 @@ function createStatusPinApi(getBot, robust) {
   };
 }
 
-// gateway/dm-pin-sweep.ts
-function isDmChatId(chatId) {
-  const n = Number(chatId);
-  return Number.isFinite(n) && Number.isInteger(n) && n > 0;
-}
-function collectDmChatIdsFromStores(input) {
-  const out = new Set;
+// gateway/stale-pin-sweep.ts
+var GROUP_SWEEP_GATE = {
+  minCallDelayMs: 6000,
+  maxPopsPerChatPerSweep: Number.POSITIVE_INFINITY,
+  maxPinOpsPerMinute: 10
+};
+function collectSweepTargets(input) {
+  const out = new Map;
   const add = (rows) => {
     if (rows == null)
       return;
-    for (const r of rows)
-      if (isDmChatId(r.chatId))
-        out.add(r.chatId);
+    for (const r of rows) {
+      if (typeof r.chatId !== "string" || r.chatId.length === 0)
+        continue;
+      const threadId = r.threadId ?? undefined;
+      const key = sweepTargetKey(r.chatId, threadId);
+      let target = out.get(key);
+      if (target == null) {
+        target = { chatId: r.chatId, threadId, messageIds: [] };
+        out.set(key, target);
+      }
+      const id = r.messageId ?? (r.pinned === true ? r.activityMessageId : undefined);
+      if (typeof id === "number" && !target.messageIds.includes(id))
+        target.messageIds.push(id);
+    }
   };
   add(input.statusPins);
   add(input.activityCards);
   add(input.queuedCards);
-  return [...out];
+  return [...out.values()];
+}
+
+// gateway/stale-pin-sweep.ts
+var DM_SWEEP_GATE = {
+  minCallDelayMs: 1500,
+  maxPopsPerChatPerSweep: 40,
+  maxPinOpsPerMinute: 30
+};
+var GROUP_SWEEP_GATE2 = {
+  minCallDelayMs: 6000,
+  maxPopsPerChatPerSweep: Number.POSITIVE_INFINITY,
+  maxPinOpsPerMinute: 10
+};
+var FLOOD_BACKOFF_FACTOR = 2;
+var MAX_CONSECUTIVE_FLOOD_WAITS = 3;
+var MAX_IDENTICAL_RETRY_AFTER_NO_PROGRESS = 2;
+var CIRCUIT_BREAKER_RETRY_AFTER_SEC = 60;
+var VERIFY_READ_GAP_MS = 1800;
+var VERIFY_READ_MAX_PAIRS = 3;
+var UNPIN_ALL_FORUM_TOPIC_ENABLED = false;
+function mayUnpinAllForumTopic(kind, override) {
+  if (kind !== "forum-topic")
+    return false;
+  return override ?? UNPIN_ALL_FORUM_TOPIC_ENABLED;
+}
+function gateFor(kind) {
+  return kind === "dm" ? DM_SWEEP_GATE : GROUP_SWEEP_GATE2;
+}
+function budgetClassFor(kind) {
+  return kind === "dm" ? "dm" : "group";
+}
+function isDmChatId(chatId) {
+  const n = Number(chatId);
+  return Number.isFinite(n) && Number.isInteger(n) && n > 0;
+}
+function classifyChatForSweep(args) {
+  if (isDmChatId(args.chatId))
+    return "dm";
+  if (args.isForum === true && args.threadId != null)
+    return "forum-topic";
+  return "supergroup";
 }
 function unexpiredStoreRepinIds(rows, chatId, now) {
   const out = [];
@@ -86553,41 +86732,571 @@ function unexpiredStoreRepinIds(rows, chatId, now) {
   }
   return out;
 }
-function createDmPinSweeper(deps) {
-  const swept = new Set;
+function description(err) {
+  if (err != null && typeof err === "object") {
+    const o = err;
+    if (typeof o.description === "string" && o.description.length > 0) {
+      return o.description.toLowerCase();
+    }
+    if (typeof o.message === "string" && o.message.length > 0)
+      return o.message.toLowerCase();
+  }
+  return String(err).toLowerCase();
+}
+function retryAfterSeconds(err) {
+  if (err == null || typeof err !== "object")
+    return null;
+  const o = err;
+  const fromParams = o.parameters?.retry_after;
+  if (typeof fromParams === "number" && fromParams >= 0)
+    return fromParams;
+  if (o.error_code === 429) {
+    const m = /retry after (\d+)/.exec(description(err));
+    if (m != null)
+      return Number(m[1]);
+    return 0;
+  }
+  return null;
+}
+function isPeerFloodError(err) {
+  return description(err).includes("peer_flood");
+}
+function isPinRightsError2(err) {
+  return description(err).includes("not enough rights");
+}
+function isNothingToUnpinError(err) {
+  return description(err).includes("message to unpin not found");
+}
+function createPinOpBudget(now) {
+  const windows = { dm: [], group: [] };
+  const limits = {
+    dm: DM_SWEEP_GATE.maxPinOpsPerMinute,
+    group: GROUP_SWEEP_GATE2.maxPinOpsPerMinute
+  };
+  const prune = (cls, t) => {
+    const w = windows[cls];
+    while (w.length > 0 && t - w[0] >= 60000)
+      w.shift();
+  };
   return {
-    hasSwept: (chatId) => swept.has(chatId),
-    async sweep(chatId) {
-      if (!isDmChatId(chatId))
-        return;
-      if (!deps.eligible())
-        return;
-      if (swept.has(chatId))
-        return;
-      swept.add(chatId);
-      const liveIds = [...new Set(deps.liveTrackedMessageIds(chatId))];
+    waitMs(cls) {
+      const t = now();
+      prune(cls, t);
+      const w = windows[cls];
+      if (w.length < limits[cls])
+        return 0;
+      return Math.max(0, 60000 - (t - w[0]));
+    },
+    record(cls) {
+      windows[cls].push(now());
+    }
+  };
+}
+function createStalePinSweeper(deps) {
+  const log = deps.log ?? ((l) => process.stderr.write(l));
+  const budget = createPinOpBudget(deps.now);
+  let circuitOpen = false;
+  let lastWriteAt = 0;
+  const commit = (cursor) => {
+    try {
+      upsertSweepCursor(deps.store.path, deps.store.fs, cursor, log);
+    } catch (err) {
+      log(`stale-pin-sweep: cursor persist failed: ${err.message}
+`);
+    }
+  };
+  const loadCursor = (t, kind) => {
+    const key = sweepTargetKey(t.chatId, t.threadId);
+    let rows = [];
+    try {
+      rows = loadSweepCursors(deps.store.path, deps.store.fs);
+    } catch {
+      rows = [];
+    }
+    const existing = rows.find((c) => sweepTargetKey(c.chatId, c.threadId) === key);
+    if (existing != null)
+      return { ...existing, kind };
+    return {
+      chatId: t.chatId,
+      threadId: t.threadId,
+      kind,
+      popped: 0,
+      done: false,
+      attempts: 0,
+      updatedAt: deps.now()
+    };
+  };
+  const awaitWriteSlot = async (kind) => {
+    const cls = budgetClassFor(kind);
+    const wait = budget.waitMs(cls);
+    if (wait > 0)
+      return false;
+    const gate = gateFor(kind);
+    const since = deps.now() - lastWriteAt;
+    if (lastWriteAt > 0 && since < gate.minCallDelayMs) {
+      await deps.sleep(gate.minCallDelayMs - since);
+    }
+    lastWriteAt = deps.now();
+    budget.record(cls);
+    return true;
+  };
+  const readTopVerified = async (chatId) => {
+    const read = async () => {
       try {
-        await deps.unpinAll(chatId);
+        return { v: await deps.getTopPinnedMessageId(chatId) };
+      } catch {
+        return null;
+      }
+    };
+    let prev = await read();
+    if (prev == null)
+      return null;
+    for (let i = 0;i < VERIFY_READ_MAX_PAIRS; i++) {
+      await deps.sleep(VERIFY_READ_GAP_MS);
+      const next = await read();
+      if (next == null)
+        return null;
+      if (next.v === prev.v)
+        return { top: next.v };
+      prev = next;
+    }
+    return null;
+  };
+  const classify = (err) => {
+    if (isPeerFloodError(err))
+      return { kind: "breaker", detail: "PEER_FLOOD" };
+    const retry = retryAfterSeconds(err);
+    if (retry != null) {
+      if (retry > CIRCUIT_BREAKER_RETRY_AFTER_SEC) {
+        return { kind: "breaker", detail: `retry_after=${retry}s > ${CIRCUIT_BREAKER_RETRY_AFTER_SEC}s` };
+      }
+      return { kind: "flood", seconds: retry };
+    }
+    if (isPinRightsError2(err))
+      return { kind: "rights" };
+    return { kind: "other", detail: err?.message ?? String(err) };
+  };
+  const repinUnpinLoop = async (target, kind, cursor) => {
+    const gate = gateFor(kind);
+    let popped = 0;
+    let consecutiveFloods = 0;
+    let lastRetryAfter = null;
+    let noProgressAtSameRetryAfter = 0;
+    let lastObservedTop = null;
+    let unverifiedPop = false;
+    const creditPop = () => {
+      popped++;
+      cursor.popped++;
+      cursor.updatedAt = deps.now();
+      commit(cursor);
+    };
+    for (let i = 0;i < gate.maxPopsPerChatPerSweep; i++) {
+      if (circuitOpen) {
+        return { status: "aborted-circuit-breaker", popped, detail: "breaker open" };
+      }
+      const observed = await readTopVerified(target.chatId);
+      if (observed == null) {
+        return { status: "incomplete", popped, detail: "pin-stack read unverifiable" };
+      }
+      if (unverifiedPop) {
+        if (observed.top != null && observed.top === lastObservedTop) {
+          return {
+            status: "incomplete",
+            popped,
+            detail: `no progress: message ${observed.top} still on top after a repin+unpin`
+          };
+        }
+        creditPop();
+        unverifiedPop = false;
+      }
+      if (observed.top == null) {
+        return { status: "drained", popped };
+      }
+      lastObservedTop = observed.top;
+      if (!await awaitWriteSlot(kind)) {
+        return { status: "deferred-budget", popped, detail: "per-minute pin-op budget spent" };
+      }
+      try {
+        await deps.pinSilent(target.chatId, observed.top);
       } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        deps.log?.(`telegram gateway: dm-pin-sweep: unpin-all failed (chat=${chatId}): ${msg}
-`);
+        const d = classify(err);
+        if (d.kind === "breaker") {
+          circuitOpen = true;
+          return { status: "aborted-circuit-breaker", popped, detail: d.detail };
+        }
+        if (d.kind === "rights")
+          return { status: "skipped-no-rights", popped };
+        if (d.kind === "flood") {
+          consecutiveFloods++;
+          if (lastRetryAfter === d.seconds)
+            noProgressAtSameRetryAfter++;
+          else
+            noProgressAtSameRetryAfter = 1;
+          lastRetryAfter = d.seconds;
+          if (consecutiveFloods >= MAX_CONSECUTIVE_FLOOD_WAITS || noProgressAtSameRetryAfter >= MAX_IDENTICAL_RETRY_AFTER_NO_PROGRESS) {
+            return {
+              status: "deferred-flood",
+              popped,
+              detail: `flood: ${consecutiveFloods} consecutive 429s, retry_after=${d.seconds}s`
+            };
+          }
+          await deps.sleep(d.seconds * 1000 * Math.pow(FLOOD_BACKOFF_FACTOR, consecutiveFloods - 1));
+          continue;
+        }
+        return { status: "error", popped, detail: d.detail };
+      }
+      if (!await awaitWriteSlot(kind)) {
+        return { status: "deferred-budget", popped, detail: "per-minute pin-op budget spent" };
+      }
+      try {
+        await deps.unpin(target.chatId, observed.top);
+      } catch (err) {
+        const d = classify(err);
+        if (d.kind === "breaker") {
+          circuitOpen = true;
+          return { status: "aborted-circuit-breaker", popped, detail: d.detail };
+        }
+        if (d.kind === "rights")
+          return { status: "skipped-no-rights", popped };
+        if (isNothingToUnpinError(err))
+          return { status: "drained", popped };
+        if (d.kind === "flood") {
+          consecutiveFloods++;
+          if (lastRetryAfter === d.seconds)
+            noProgressAtSameRetryAfter++;
+          else
+            noProgressAtSameRetryAfter = 1;
+          lastRetryAfter = d.seconds;
+          if (consecutiveFloods >= MAX_CONSECUTIVE_FLOOD_WAITS || noProgressAtSameRetryAfter >= MAX_IDENTICAL_RETRY_AFTER_NO_PROGRESS) {
+            return {
+              status: "deferred-flood",
+              popped,
+              detail: `flood: ${consecutiveFloods} consecutive 429s, retry_after=${d.seconds}s`
+            };
+          }
+          await deps.sleep(d.seconds * 1000 * Math.pow(FLOOD_BACKOFF_FACTOR, consecutiveFloods - 1));
+          continue;
+        }
+        return { status: "error", popped, detail: d.detail };
+      }
+      consecutiveFloods = 0;
+      unverifiedPop = true;
+    }
+    const finalRead = await readTopVerified(target.chatId);
+    if (unverifiedPop && finalRead != null && finalRead.top !== lastObservedTop)
+      creditPop();
+    if (finalRead != null && finalRead.top == null)
+      return { status: "drained", popped };
+    return {
+      status: "deferred-budget",
+      popped,
+      detail: `hit the ${gate.maxPopsPerChatPerSweep}-pop cap for this chat; yielding to next boot`
+    };
+  };
+  const targetedUnpinDrain = async (target, kind, cursor, ids) => {
+    const alreadyDone = new Set(cursor.doneIds ?? []);
+    const pending = ids.filter((id) => !alreadyDone.has(id));
+    if (pending.length === 0) {
+      return { status: "drained", popped: 0, issued: 0, detail: "every recorded id already unpinned" };
+    }
+    const before = await readTopVerified(target.chatId);
+    let issued = 0;
+    let deferred = null;
+    for (const id of pending) {
+      if (circuitOpen) {
+        deferred = { status: "aborted-circuit-breaker", popped: 0, issued, detail: "breaker open" };
+        break;
+      }
+      if (!await awaitWriteSlot(kind)) {
+        deferred = {
+          status: "deferred-budget",
+          popped: 0,
+          issued,
+          detail: `per-minute pin-op budget spent with ${pending.length - issued} ids left`
+        };
+        break;
+      }
+      try {
+        await deps.unpin(target.chatId, id);
+      } catch (err) {
+        const d = classify(err);
+        if (d.kind === "breaker") {
+          circuitOpen = true;
+          deferred = { status: "aborted-circuit-breaker", popped: 0, issued, detail: d.detail };
+          break;
+        }
+        if (d.kind === "rights") {
+          deferred = { status: "skipped-no-rights", popped: 0, issued };
+          break;
+        }
+        if (d.kind === "flood") {
+          deferred = {
+            status: "deferred-flood",
+            popped: 0,
+            issued,
+            detail: `flood: retry_after=${d.seconds}s`
+          };
+          break;
+        }
+        if (!isNothingToUnpinError(err)) {
+          deferred = { status: "error", popped: 0, issued, detail: d.detail };
+          break;
+        }
+      }
+      issued++;
+      alreadyDone.add(id);
+      cursor.doneIds = [...alreadyDone];
+      cursor.updatedAt = deps.now();
+      commit(cursor);
+    }
+    const after = await readTopVerified(target.chatId);
+    if (after == null) {
+      return {
+        status: deferred?.status ?? "incomplete",
+        popped: 0,
+        issued,
+        detail: "pin-stack read unverifiable after the unpin pass"
+      };
+    }
+    if (after.top == null) {
+      const popped2 = issued;
+      cursor.popped += popped2;
+      commit(cursor);
+      return { status: "drained", popped: popped2, issued };
+    }
+    if (deferred != null)
+      return { ...deferred, popped: 0 };
+    const ours = new Set(ids);
+    if (ours.has(after.top)) {
+      return {
+        status: "incomplete",
+        popped: 0,
+        issued,
+        detail: `recorded pin ${after.top} is still on top after a targeted unpin`
+      };
+    }
+    const popped = before != null && before.top !== after.top ? 1 : 0;
+    cursor.popped += popped;
+    commit(cursor);
+    return {
+      status: "drained",
+      popped,
+      issued,
+      detail: `unpinned ${issued} recorded id(s); top ${after.top} is not ours and was left alone`
+    };
+  };
+  const forumTopicDrain = async (target, cursor) => {
+    const threadId = target.threadId;
+    if (threadId == null) {
+      return { status: "skipped-nothing-recorded", popped: 0, detail: "no message_thread_id" };
+    }
+    if (!await awaitWriteSlot("forum-topic")) {
+      return { status: "deferred-budget", popped: 0, detail: "per-minute pin-op budget spent" };
+    }
+    try {
+      await deps.unpinAllForumTopicMessages(target.chatId, threadId);
+    } catch (err) {
+      const d = classify(err);
+      if (d.kind === "breaker") {
+        circuitOpen = true;
+        return { status: "aborted-circuit-breaker", popped: 0, detail: d.detail };
+      }
+      if (d.kind === "rights")
+        return { status: "skipped-no-rights", popped: 0 };
+      if (d.kind === "flood") {
+        return {
+          status: "deferred-flood",
+          popped: 0,
+          detail: `unpinAllForumTopicMessages pegged at retry_after=${d.seconds}s; not looping`
+        };
+      }
+      return { status: "error", popped: 0, detail: d.detail };
+    }
+    cursor.popped++;
+    cursor.updatedAt = deps.now();
+    commit(cursor);
+    const observed = await readTopVerified(target.chatId);
+    if (observed != null && observed.top == null)
+      return { status: "drained", popped: 1 };
+    return { status: "drained", popped: 1, detail: "topic drained; chat-wide stack may hold other topics" };
+  };
+  const sweepOnce = async (target) => {
+    if (!deps.eligible())
+      return { status: "skipped-not-eligible", popped: 0 };
+    if (circuitOpen) {
+      return { status: "aborted-circuit-breaker", popped: 0, detail: "breaker already open" };
+    }
+    const kind = classifyChatForSweep(target);
+    const cursor = loadCursor(target, kind);
+    if (cursor.done)
+      return { status: "already-drained", popped: 0 };
+    if (cursor.attempts >= SWEEP_MAX_ATTEMPTS) {
+      return { status: "forfeited", popped: 0, detail: `${cursor.attempts} attempts exhausted` };
+    }
+    if (kind !== "dm") {
+      let allowed = false;
+      try {
+        allowed = await deps.canPinInChat(target.chatId);
+      } catch {
+        allowed = false;
       }
-      for (const messageId of liveIds) {
+      if (!allowed) {
+        cursor.attempts++;
+        cursor.lastStatus = "skipped-no-rights";
+        cursor.updatedAt = deps.now();
+        commit(cursor);
+        return { status: "skipped-no-rights", popped: 0 };
+      }
+    }
+    cursor.attempts++;
+    cursor.updatedAt = deps.now();
+    commit(cursor);
+    const protectedIds = [...new Set(deps.protectedMessageIds(target.chatId))];
+    let result;
+    try {
+      if (kind === "dm") {
+        result = await repinUnpinLoop(target, kind, cursor);
+      } else if (mayUnpinAllForumTopic(kind, deps.allowUnpinAllForumTopic)) {
+        result = await forumTopicDrain(target, cursor);
+      } else {
+        const keep = new Set(protectedIds);
+        const ids = [
+          ...new Set([
+            ...target.messageIds ?? [],
+            ...deps.recordedPinIds(target.chatId, target.threadId)
+          ])
+        ].filter((id) => !keep.has(id));
+        result = ids.length === 0 ? {
+          status: "skipped-nothing-recorded",
+          popped: 0,
+          issued: 0,
+          detail: "no recorded pin ids for this target \u2014 nothing this gateway may remove"
+        } : await targetedUnpinDrain(target, kind, cursor, ids);
+      }
+    } catch (err) {
+      result = { status: "error", popped: 0, detail: err.message };
+    }
+    if (result.status === "drained" || result.status === "skipped-nothing-recorded") {
+      cursor.done = true;
+    }
+    cursor.lastStatus = result.status;
+    cursor.updatedAt = deps.now();
+    commit(cursor);
+    if (kind === "dm" && (result.status === "drained" || result.popped > 0)) {
+      for (const messageId of protectedIds) {
+        if (circuitOpen)
+          break;
+        if (!await awaitWriteSlot(kind))
+          break;
         try {
-          await deps.pinSilent(chatId, messageId);
+          await deps.pinSilent(target.chatId, messageId);
         } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          deps.log?.(`telegram gateway: dm-pin-sweep: re-pin failed ` + `(chat=${chatId} msg=${messageId}): ${msg}
+          log(`telegram gateway: stale-pin-sweep: re-pin of protected message failed ` + `(chat=${target.chatId} msg=${messageId}): ${err.message}
 `);
         }
       }
-      if (liveIds.length > 0) {
-        deps.log?.(`telegram gateway: dm-pin-sweep: cleared stacked pins in DM ${chatId}, ` + `re-pinned ${liveIds.length} live card(s)
-`);
-      }
     }
+    log(`telegram gateway: stale-pin-sweep: chat=${target.chatId} ` + `thread=${target.threadId ?? "-"} kind=${kind} status=${result.status} ` + `popped=${result.popped} issued=${result.issued ?? 0} total=${cursor.popped}` + (result.detail != null ? ` (${result.detail})` : "") + `
+`);
+    return result;
+  };
+  const attempted = new Set;
+  const inFlight = new Map;
+  const sweepTarget = (target) => {
+    const key = sweepTargetKey(target.chatId, target.threadId);
+    const running = inFlight.get(key);
+    if (running != null)
+      return running;
+    if (!deps.eligible())
+      return Promise.resolve({ status: "skipped-not-eligible", popped: 0 });
+    if (attempted.has(key))
+      return Promise.resolve({ status: "already-attempted", popped: 0 });
+    attempted.add(key);
+    const p = sweepOnce(target).finally(() => inFlight.delete(key));
+    inFlight.set(key, p);
+    return p;
   };
+  return { sweepTarget, isCircuitOpen: () => circuitOpen };
+}
+
+// gateway/stale-pin-sweep-wiring.ts
+function protectedPinIds(args) {
+  const ids = [];
+  for (const claim of args.claims) {
+    if (claim.chatId === args.chatId)
+      ids.push(claim.messageId);
+  }
+  try {
+    ids.push(...unexpiredStoreRepinIds(args.loadPinRows(), args.chatId, args.now));
+  } catch (err) {
+    args.log(`telegram gateway: stale-pin-sweep: store repin scan failed ` + `(chat=${args.chatId}): ${err.message}
+`);
+  }
+  return ids;
+}
+function recordedPinIdsFor(rows, chatId, threadId) {
+  const out = [];
+  for (const r of rows) {
+    if (r.chatId !== chatId)
+      continue;
+    if ((r.threadId ?? undefined) !== threadId)
+      continue;
+    if (typeof r.messageId === "number" && !out.includes(r.messageId))
+      out.push(r.messageId);
+  }
+  return out;
+}
+function createGatewayStalePinSweeper(w) {
+  const log = w.log ?? ((line) => process.stderr.write(line));
+  const now = w.now ?? Date.now;
+  const { handle: bot, call } = w.telegram;
+  return createStalePinSweeper({
+    getTopPinnedMessageId: async (chatId) => {
+      const chat = await call(() => bot().api.getChat(chatId), {
+        chat_id: chatId,
+        verb: "stale-pin-sweep.get-chat"
+      });
+      return chat?.pinned_message?.message_id ?? null;
+    },
+    pinSilent: (chatId, messageId) => call(() => bot().api.pinChatMessage(chatId, messageId, { disable_notification: true }), { chat_id: chatId, verb: "stale-pin-sweep.repin" }),
+    unpin: (chatId, messageId) => call(() => bot().api.unpinChatMessage(chatId, messageId), { chat_id: chatId, verb: "stale-pin-sweep.unpin" }),
+    unpinAllForumTopicMessages: (chatId, threadId) => call(() => bot().api.unpinAllForumTopicMessages(chatId, threadId), {
+      chat_id: chatId,
+      verb: "stale-pin-sweep.unpin-all-topic"
+    }),
+    canPinInChat: async (chatId) => {
+      const self = bot().botInfo?.id;
+      if (self == null)
+        return false;
+      const member = await call(() => bot().api.getChatMember(chatId, self), {
+        chat_id: chatId,
+        verb: "stale-pin-sweep.get-chat-member"
+      });
+      return member?.status === "administrator" && member.can_pin_messages === true;
+    },
+    recordedPinIds: (chatId, threadId) => {
+      try {
+        return recordedPinIdsFor(w.loadPinRows(), chatId, threadId);
+      } catch (err) {
+        log(`telegram gateway: stale-pin-sweep: recorded-pin scan failed ` + `(chat=${chatId}): ${err.message}
+`);
+        return [];
+      }
+    },
+    protectedMessageIds: (chatId) => protectedPinIds({
+      chatId,
+      claims: w.claims(),
+      loadPinRows: w.loadPinRows,
+      now: now(),
+      log
+    }),
+    eligible: w.eligible,
+    sleep: w.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms))),
+    now,
+    store: w.store,
+    allowUnpinAllForumTopic: w.allowUnpinAllForumTopic,
+    log
+  });
 }
 
 // gateway/webhook-ingest-server.ts
@@ -87751,7 +88460,7 @@ function recordWebhookEvent(rec, deps = {}) {
 
 // gateway/ipc-server.ts
 init_format();
-import { renameSync as renameSync16, unlinkSync as unlinkSync20, chmodSync as chmodSync11 } from "fs";
+import { renameSync as renameSync17, unlinkSync as unlinkSync20, chmodSync as chmodSync11 } from "fs";
 var MAX_BUFFER_SIZE = 1024 * 1024;
 var VALID_OPERATOR_KINDS = new Set([
   "credentials-expired",
@@ -87962,7 +88671,7 @@ function createIpcServer(options) {
     heartbeatTimeoutMs = 30000
   } = options;
   try {
-    renameSync16(socketPath, socketPath + ".bak");
+    renameSync17(socketPath, socketPath + ".bak");
   } catch {}
   try {
     unlinkSync20(socketPath + ".bak");
@@ -88352,7 +89061,7 @@ function createIpcServer(options) {
       clientBySocketId.clear();
       server.stop(true);
       try {
-        renameSync16(socketPath, socketPath + ".bak");
+        renameSync17(socketPath, socketPath + ".bak");
       } catch {}
     }
   };
@@ -89256,6 +89965,7 @@ function obligationEscalationText(o) {
 }
 
 // gateway/obligation-store.ts
+import { dirname as dirname20 } from "node:path";
 function isObligationRow(x) {
   if (x == null || typeof x !== "object")
     return false;
@@ -89311,9 +90021,17 @@ function persistObligations(path3, fs3, snapshot, log = (l) => process.stderr.wr
   const tmp = path3 + ".tmp";
   try {
     fs3.writeFileSync(tmp, JSON.stringify(env));
+    fs3.fsyncFileSync(tmp);
     fs3.renameSync(tmp, path3);
   } catch (err) {
     log(`obligation-store: persist FAILED path=${path3}: ${err.message} \u2014 ` + `durability degraded to in-memory
+`);
+    return;
+  }
+  try {
+    fs3.fsyncDirSync(dirname20(path3));
+  } catch (err) {
+    log(`obligation-store: directory fsync FAILED path=${path3}: ${err.message} \u2014 ` + `snapshot written but the rename may not survive a power cut
 `);
   }
 }
@@ -89397,12 +90115,12 @@ function createCapturedResumeDispatcher(ports) {
 
 // gateway/status-pin-store.ts
 var BOOT_UNPIN_MAX_ATTEMPTS = 5;
-var SNAPSHOT_VERSIONS2 = new Set([1, 2, 3]);
+var SNAPSHOT_VERSIONS2 = new Set([1, 2, 3, 4]);
 function isPinRow2(x) {
   if (x == null || typeof x !== "object")
     return false;
   const o = x;
-  return typeof o.pinKey === "string" && o.pinKey.length > 0 && typeof o.chatId === "string" && o.chatId.length > 0 && typeof o.messageId === "number" && (o.pending === undefined || typeof o.pending === "boolean") && (o.expiresAt === undefined || typeof o.expiresAt === "number") && (o.attempts === undefined || typeof o.attempts === "number") && (o.pinnedAt === undefined || typeof o.pinnedAt === "number");
+  return typeof o.pinKey === "string" && o.pinKey.length > 0 && typeof o.chatId === "string" && o.chatId.length > 0 && (o.threadId === undefined || typeof o.threadId === "number") && typeof o.messageId === "number" && (o.pending === undefined || typeof o.pending === "boolean") && (o.expiresAt === undefined || typeof o.expiresAt === "number") && (o.attempts === undefined || typeof o.attempts === "number") && (o.pinnedAt === undefined || typeof o.pinnedAt === "number");
 }
 function loadStatusPins2(path3, fs3) {
   if (!fs3.existsSync(path3))
@@ -89427,7 +90145,7 @@ function loadStatusPins2(path3, fs3) {
   return env.pins.filter(isPinRow2);
 }
 function persistStatusPins2(path3, fs3, snapshot, log = (l) => process.stderr.write(l)) {
-  const env = { v: 3, pins: [...snapshot] };
+  const env = { v: 4, pins: [...snapshot] };
   const tmp = path3 + ".tmp";
   try {
     fs3.writeFileSync(tmp, JSON.stringify(env));
@@ -89775,6 +90493,7 @@ function decideWorkerPinReaps(args) {
 }
 
 // gateway/inbound-spool.ts
+import { dirname as dirname21 } from "node:path";
 function spoolId(msg) {
   if (msg.meta?.source === "subagent_handback" && typeof msg.meta?.subagent_jsonl_id === "string" && msg.meta.subagent_jsonl_id.length > 0) {
     return `s:handback:${msg.meta.subagent_jsonl_id}`;
@@ -89878,6 +90597,7 @@ function createInboundSpool(opts) {
     try {
       fs3.appendFileSync(path3, JSON.stringify(rec) + `
 `);
+      fs3.fsyncFileSync(path3);
       if (consecutiveAppendFailures > 0) {
         log(`inbound-spool: append recovered path=${path3} after ` + `${consecutiveAppendFailures} failure(s) \u2014 durability restored
 `);
@@ -89936,11 +90656,19 @@ function createInboundSpool(opts) {
       fs3.writeFileSync(tmp, lines.length ? lines.join(`
 `) + `
 ` : "");
+      fs3.fsyncFileSync(tmp);
       fs3.renameSync(tmp, path3);
       log(`inbound-spool: compacted path=${path3} live=${live.size}
 `);
     } catch (err) {
       log(`inbound-spool: compact FAILED path=${path3}: ${err.message}
+`);
+      return;
+    }
+    try {
+      fs3.fsyncDirSync(dirname21(path3));
+    } catch (err) {
+      log(`inbound-spool: compact directory fsync FAILED path=${path3}: ` + `${err.message} \u2014 compacted log written but the rename ` + `may not survive a power cut
 `);
     }
   }
@@ -92163,9 +92891,9 @@ function toolLabel(tool, input, preamble, precomputedLabel) {
     }
     case "Bash":
     case "BashOutput": {
-      const description = str("description");
-      if (description)
-        return truncate4(firstLine(description), MAX_DESCRIPTION_CHARS);
+      const description2 = str("description");
+      if (description2)
+        return truncate4(firstLine(description2), MAX_DESCRIPTION_CHARS);
       const pre = preambleLabel();
       if (pre)
         return pre;
@@ -92227,9 +92955,9 @@ function toolLabel(tool, input, preamble, precomputedLabel) {
     }
     default:
       if (tool.startsWith("mcp__")) {
-        const description = str("description");
-        if (description)
-          return truncate4(firstLine(stripHtml(description)), MAX_DESCRIPTION_CHARS);
+        const description2 = str("description");
+        if (description2)
+          return truncate4(firstLine(stripHtml(description2)), MAX_DESCRIPTION_CHARS);
         const label = mcpBaseLabel(tool);
         const query3 = str("query") ?? str("text") ?? str("name");
         if (label && query3) {
@@ -92596,12 +93324,12 @@ function skillProposalKeyboard(id) {
 
 // ../src/self-improve/skill-proposals.ts
 import {
-  closeSync as closeSync8,
+  closeSync as closeSync9,
   existsSync as existsSync41,
   mkdirSync as mkdirSync37,
-  openSync as openSync8,
+  openSync as openSync9,
   readFileSync as readFileSync37,
-  writeSync as writeSync5
+  writeSync as writeSync6
 } from "node:fs";
 import { join as join50 } from "node:path";
 import { randomUUID as randomUUID5 } from "node:crypto";
@@ -92621,12 +93349,12 @@ function ensureDir3(stateDir) {
   }
 }
 function appendLine2(path3, obj) {
-  const fd = openSync8(path3, "a");
+  const fd = openSync9(path3, "a");
   try {
-    writeSync5(fd, JSON.stringify(obj) + `
+    writeSync6(fd, JSON.stringify(obj) + `
 `);
   } finally {
-    closeSync8(fd);
+    closeSync9(fd);
   }
 }
 function readLines2(path3, isValid2) {
@@ -93231,11 +93959,11 @@ function escapeBody2(s) {
 }
 
 // gateway/pid-file.ts
-import { writeFileSync as writeFileSync33, readFileSync as readFileSync38, unlinkSync as unlinkSync21, renameSync as renameSync17 } from "node:fs";
+import { writeFileSync as writeFileSync33, readFileSync as readFileSync38, unlinkSync as unlinkSync21, renameSync as renameSync18 } from "node:fs";
 function writePidFile(path3, record) {
   const tmp = `${path3}.tmp-${process.pid}-${Date.now()}`;
   writeFileSync33(tmp, JSON.stringify(record), "utf-8");
-  renameSync17(tmp, path3);
+  renameSync18(tmp, path3);
 }
 function clearPidFile(path3) {
   try {
@@ -93456,11 +94184,11 @@ function safeCount(fn) {
 }
 
 // gateway/session-marker.ts
-import { writeFileSync as writeFileSync34, readFileSync as readFileSync40, renameSync as renameSync18, unlinkSync as unlinkSync22 } from "node:fs";
+import { writeFileSync as writeFileSync34, readFileSync as readFileSync40, renameSync as renameSync19, unlinkSync as unlinkSync22 } from "node:fs";
 function writeSessionMarker(path3, marker) {
   const tmp = `${path3}.tmp-${process.pid}-${Date.now()}`;
   writeFileSync34(tmp, JSON.stringify(marker), "utf-8");
-  renameSync18(tmp, path3);
+  renameSync19(tmp, path3);
 }
 function readSessionMarker(path3) {
   try {
@@ -93486,12 +94214,12 @@ function shouldFireRestartBanner(input) {
 }
 
 // gateway/clean-shutdown-marker.ts
-import { writeFileSync as writeFileSync35, readFileSync as readFileSync41, renameSync as renameSync19, unlinkSync as unlinkSync23 } from "node:fs";
+import { writeFileSync as writeFileSync35, readFileSync as readFileSync41, renameSync as renameSync20, unlinkSync as unlinkSync23 } from "node:fs";
 var DEFAULT_MAX_AGE_MS = 60000;
 function writeCleanShutdownMarker(path3, marker) {
   const tmp = `${path3}.tmp-${process.pid}-${Date.now()}`;
   writeFileSync35(tmp, JSON.stringify(marker), "utf-8");
-  renameSync19(tmp, path3);
+  renameSync20(tmp, path3);
 }
 function readCleanShutdownMarker(path3) {
   try {
@@ -93868,10 +94596,10 @@ function classifyAdminGate(text4, myAgentName) {
 // subagent-watcher.ts
 import {
   existsSync as existsSync42,
-  openSync as openSync9,
+  openSync as openSync10,
   readSync as readSync2,
   statSync as statSync15,
-  closeSync as closeSync9,
+  closeSync as closeSync10,
   watch,
   readdirSync as readdirSync10,
   readFileSync as readFileSync42
@@ -94684,8 +95412,8 @@ function startSubagentWatcher(config) {
     existsSync: existsSync42,
     readdirSync: readdirSync10,
     statSync: statSync15,
-    openSync: openSync9,
-    closeSync: closeSync9,
+    openSync: openSync10,
+    closeSync: closeSync10,
     readSync: readSync2,
     watch
   };
@@ -95060,13 +95788,13 @@ function startSubagentWatcher(config) {
       if (size <= rec.sizeAtSynthesis)
         continue;
       const entry = registry.get(agentId);
-      const description = entry?.description ?? "sub-agent";
+      const description2 = entry?.description ?? "sub-agent";
       if (rec.resurrectionCount >= MAX_RESURRECTIONS) {
         rec.lost = true;
         log?.(`subagent-watcher: worker ${agentId} FALSELY finalised again after a prior resurrection (resurrectionCount=${rec.resurrectionCount} >= ${MAX_RESURRECTIONS}) \u2014 NAMED AS LOST, not resurrecting again (bounded resurrection chain, issue #3023)`);
         if (config.onWorkerLost != null) {
           try {
-            config.onWorkerLost(agentId, description);
+            config.onWorkerLost(agentId, description2);
           } catch (cbErr) {
             log?.(`subagent-watcher: onWorkerLost callback error ${agentId}: ${cbErr.message}`);
           }
@@ -95078,7 +95806,7 @@ function startSubagentWatcher(config) {
       log?.(`subagent-watcher: RESURRECTING worker ${agentId} \u2014 JSONL resumed growing (${rec.sizeAtSynthesis} \u2192 ${size} bytes) after a false terminal synthesis; the worker is still alive, reviving its card (resurrection #${rec.resurrectionCount}, issue #3023)`);
       if (config.onResurrect != null) {
         try {
-          config.onResurrect(agentId, description);
+          config.onResurrect(agentId, description2);
         } catch (cbErr) {
           log?.(`subagent-watcher: onResurrect callback error ${agentId}: ${cbErr.message}`);
         }
@@ -95431,7 +96159,7 @@ import {
   readdirSync as readdirSync11,
   unlinkSync as unlinkSync24,
   existsSync as existsSync43,
-  renameSync as renameSync20
+  renameSync as renameSync21
 } from "node:fs";
 import { join as join52, resolve as resolve10 } from "node:path";
 import { homedir as homedir15 } from "node:os";
@@ -95450,7 +96178,7 @@ function writeRecord(record) {
   const tmp = `${target}.tmp${process.pid}`;
   writeFileSync36(tmp, JSON.stringify(record, null, 2) + `
 `, { mode: 384 });
-  renameSync20(tmp, target);
+  renameSync21(tmp, target);
 }
 function readRecord(id) {
   const path3 = recordPath(id);
@@ -95613,11 +96341,8 @@ function determineRestartReason(opts) {
   return "fresh";
 }
 
-// gateway/gateway.ts
-init_boot_card();
-
 // gateway/update-announce.ts
-import { existsSync as existsSync48, mkdirSync as mkdirSync42, openSync as openSync10, closeSync as closeSync10, readFileSync as readFileSync50 } from "node:fs";
+import { existsSync as existsSync48, mkdirSync as mkdirSync42, openSync as openSync11, closeSync as closeSync11, readFileSync as readFileSync50 } from "node:fs";
 import { join as join57 } from "node:path";
 import { homedir as homedir17 } from "node:os";
 
@@ -95710,6 +96435,9 @@ function parseAuditLine(line) {
     entry.failed_step = o.failed_step;
   if (typeof o.failed_agent === "string")
     entry.failed_agent = o.failed_agent;
+  if (Array.isArray(o.drifted) && o.drifted.every((x) => typeof x === "string")) {
+    entry.drifted = o.drifted;
+  }
   if (typeof o.agent === "string")
     entry.agent = o.agent;
   if (typeof o.n === "number")
@@ -95826,8 +96554,8 @@ function claimUpdateAnnouncement(requestId, opts = {}) {
   const safeId = requestId.replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 200);
   const path3 = join57(dir, safeId);
   try {
-    const fd = openSync10(path3, "wx");
-    closeSync10(fd);
+    const fd = openSync11(path3, "wx");
+    closeSync11(fd);
     return true;
   } catch {
     return false;
@@ -96050,20 +96778,20 @@ import { join as join59 } from "node:path";
 
 // ../src/issues/store.ts
 import {
-  closeSync as closeSync11,
+  closeSync as closeSync12,
   existsSync as existsSync49,
   mkdirSync as mkdirSync43,
-  openSync as openSync11,
+  openSync as openSync12,
   readdirSync as readdirSync13,
   readFileSync as readFileSync52,
-  renameSync as renameSync23,
+  renameSync as renameSync24,
   statSync as statSync17,
   unlinkSync as unlinkSync25,
   writeFileSync as writeFileSync42,
-  writeSync as writeSync6
+  writeSync as writeSync7
 } from "node:fs";
 import { join as join58 } from "node:path";
-import { randomBytes as randomBytes10 } from "node:crypto";
+import { randomBytes as randomBytes11 } from "node:crypto";
 import { execSync } from "node:child_process";
 
 // ../src/issues/types.ts
@@ -96138,12 +96866,12 @@ function resolve11(stateDir, fingerprint, nowFn = Date.now) {
 function writeAll(stateDir, events) {
   const path3 = join58(stateDir, ISSUES_FILE);
   sweepOrphanTmpFiles(stateDir);
-  const tmp = `${path3}.tmp-${process.pid}-${randomBytes10(4).toString("hex")}`;
+  const tmp = `${path3}.tmp-${process.pid}-${randomBytes11(4).toString("hex")}`;
   const body = events.length === 0 ? "" : events.map((e) => JSON.stringify(e)).join(`
 `) + `
 `;
   writeFileSync42(tmp, body, "utf-8");
-  renameSync23(tmp, path3);
+  renameSync24(tmp, path3);
 }
 var ORPHAN_TMP_TTL_MS = 60000;
 var TMP_PREFIX = `${ISSUES_FILE}.tmp-`;
@@ -96175,9 +96903,9 @@ function withLock(stateDir, fn) {
   let fd = null;
   while (fd === null) {
     try {
-      fd = openSync11(lockPath, "wx");
+      fd = openSync12(lockPath, "wx");
       try {
-        writeSync6(fd, String(process.pid));
+        writeSync7(fd, String(process.pid));
       } catch {}
     } catch (err) {
       const e = err;
@@ -96195,7 +96923,7 @@ function withLock(stateDir, fn) {
     return fn();
   } finally {
     try {
-      closeSync11(fd);
+      closeSync12(fd);
     } catch {}
     try {
       unlinkSync25(lockPath);
@@ -97087,7 +97815,7 @@ function createScopedGrantStore(stateDir, env = process.env, log = (l) => proces
           preserveUnreadableStoreFile(filePath, "scoped-grant-store", log);
           unreadable = false;
         }
-        atomicWriteFileSync(filePath, JSON.stringify(serializeScopedGrants(store3)), 384);
+        atomicWriteFileSync2(filePath, JSON.stringify(serializeScopedGrants(store3)), 384);
       } catch (err) {
         log(`telegram gateway: scoped-grant-store write failed: ${err.message}
 `);
@@ -97875,10 +98603,10 @@ init_auth_snapshot_format2();
 
 // gateway/turn-active-marker.ts
 import {
-  closeSync as closeSync12,
+  closeSync as closeSync13,
   existsSync as existsSync53,
   mkdirSync as mkdirSync46,
-  openSync as openSync12,
+  openSync as openSync13,
   readFileSync as readFileSync55,
   statSync as statSync19,
   unlinkSync as unlinkSync26,
@@ -97963,6 +98691,163 @@ function startGatewayHeartbeat(stateDir, intervalMs = GATEWAY_HEARTBEAT_INTERVAL
   return timer3;
 }
 
+// gateway/boot-beacon.ts
+import { randomUUID as randomUUID6 } from "node:crypto";
+import {
+  closeSync as closeSync14,
+  fsyncSync as fsyncSync5,
+  mkdirSync as mkdirSync48,
+  openSync as openSync14,
+  readFileSync as readFileSync56,
+  renameSync as renameSync25,
+  unlinkSync as unlinkSync27,
+  writeFileSync as writeFileSync47
+} from "node:fs";
+import { join as join65 } from "node:path";
+var BOOT_BEACON_FILE = "gateway-beacon.json";
+var HOST_BOOT_ID_PATH = "/proc/sys/kernel/random/boot_id";
+var CGROUP_MEMORY_EVENTS_PATH = "/sys/fs/cgroup/memory.events";
+var CGROUP_MEMORY_CURRENT_PATH = "/sys/fs/cgroup/memory.current";
+var CGROUP_MEMORY_MAX_PATH = "/sys/fs/cgroup/memory.max";
+var MAX_FIELD_CHARS = 256;
+function parseHostBootId(raw) {
+  if (typeof raw !== "string")
+    return;
+  const trimmed = raw.trim();
+  if (trimmed.length === 0 || trimmed.length > MAX_FIELD_CHARS)
+    return;
+  if (/\s/.test(trimmed))
+    return;
+  return trimmed;
+}
+function parseOomKillCount(raw) {
+  if (typeof raw !== "string")
+    return;
+  for (const line of raw.split(`
+`)) {
+    const parts = line.trim().split(/\s+/);
+    if (parts.length !== 2 || parts[0] !== "oom_kill")
+      continue;
+    return parseNonNegativeInt2(parts[1]);
+  }
+  return;
+}
+function parseMemoryBytes(raw) {
+  if (typeof raw !== "string")
+    return;
+  return parseNonNegativeInt2(raw.trim());
+}
+function parseMemoryMax(raw) {
+  if (typeof raw !== "string")
+    return;
+  const trimmed = raw.trim();
+  if (trimmed === "max")
+    return "max";
+  return parseNonNegativeInt2(trimmed);
+}
+function parseNonNegativeInt2(text4) {
+  if (typeof text4 !== "string")
+    return;
+  const trimmed = text4.trim();
+  if (trimmed.length === 0 || trimmed.length > MAX_FIELD_CHARS)
+    return;
+  if (!/^\d+$/.test(trimmed))
+    return;
+  const value = Number(trimmed);
+  return Number.isSafeInteger(value) ? value : undefined;
+}
+function buildBootBeacon(input) {
+  const beacon = {
+    bootId: input.bootId,
+    pid: input.pid,
+    wallMs: input.wallMs,
+    monotonicMs: input.monotonicMs
+  };
+  const sample3 = input.sample ?? {};
+  if (sample3.hostBootId !== undefined)
+    beacon.hostBootId = sample3.hostBootId;
+  if (sample3.oomKillCount !== undefined)
+    beacon.oomKillCount = sample3.oomKillCount;
+  if (sample3.memCurrent !== undefined)
+    beacon.memCurrent = sample3.memCurrent;
+  if (sample3.memMax !== undefined)
+    beacon.memMax = sample3.memMax;
+  return beacon;
+}
+function serializeBootBeacon(beacon) {
+  return `${JSON.stringify(beacon)}
+`;
+}
+function readTextOrNull(path3) {
+  try {
+    return readFileSync56(path3, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function sampleBeaconHost(paths = {}) {
+  const sample3 = {};
+  const hostBootId = parseHostBootId(readTextOrNull(paths.hostBootId ?? HOST_BOOT_ID_PATH));
+  if (hostBootId !== undefined)
+    sample3.hostBootId = hostBootId;
+  const oomKillCount = parseOomKillCount(readTextOrNull(paths.memoryEvents ?? CGROUP_MEMORY_EVENTS_PATH));
+  if (oomKillCount !== undefined)
+    sample3.oomKillCount = oomKillCount;
+  const memCurrent = parseMemoryBytes(readTextOrNull(paths.memoryCurrent ?? CGROUP_MEMORY_CURRENT_PATH));
+  if (memCurrent !== undefined)
+    sample3.memCurrent = memCurrent;
+  const memMax = parseMemoryMax(readTextOrNull(paths.memoryMax ?? CGROUP_MEMORY_MAX_PATH));
+  if (memMax !== undefined)
+    sample3.memMax = memMax;
+  return sample3;
+}
+function writeBootBeaconFile(stateDir, beacon) {
+  const path3 = join65(stateDir, BOOT_BEACON_FILE);
+  const tmp = `${path3}.tmp-${process.pid}`;
+  let fd;
+  try {
+    mkdirSync48(stateDir, { recursive: true, mode: 448 });
+    fd = openSync14(tmp, "w", 384);
+    writeFileSync47(fd, serializeBootBeacon(beacon));
+    fsyncSync5(fd);
+    closeSync14(fd);
+    fd = undefined;
+    renameSync25(tmp, path3);
+    return true;
+  } catch {
+    if (fd !== undefined) {
+      try {
+        closeSync14(fd);
+      } catch {}
+    }
+    try {
+      unlinkSync27(tmp);
+    } catch {}
+    return false;
+  }
+}
+var GATEWAY_BOOT_ID = randomUUID6();
+function tickBootBeacon(stateDir, bootId = GATEWAY_BOOT_ID) {
+  try {
+    return writeBootBeaconFile(stateDir, buildBootBeacon({
+      bootId,
+      pid: process.pid,
+      wallMs: Date.now(),
+      monotonicMs: Math.round(performance.now()),
+      sample: sampleBeaconHost()
+    }));
+  } catch {
+    return false;
+  }
+}
+function attachBootBeacon(stateDir, next) {
+  tickBootBeacon(stateDir);
+  return () => {
+    tickBootBeacon(stateDir);
+    next();
+  };
+}
+
 // gateway/outbox-sweep.ts
 init_flood_circuit_breaker();
 async function sweepOutbox(deps) {
@@ -98185,10 +99070,10 @@ function startOutboxSweep(deps) {
 }
 
 // ../src/build-info.ts
-var VERSION2 = "0.19.29";
-var COMMIT_SHA = "c618451c";
-var COMMIT_DATE = "2026-07-28T17:39:27Z";
-var LATEST_PR = 3918;
+var VERSION2 = "0.19.31";
+var COMMIT_SHA = "d24ee3cc";
+var COMMIT_DATE = "2026-07-28T23:06:42Z";
+var LATEST_PR = 3961;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -98266,11 +99151,11 @@ init_peercred();
 import * as net5 from "node:net";
 import * as fs3 from "node:fs";
 import { homedir as homedir18 } from "node:os";
-import { join as join65 } from "node:path";
+import { join as join66 } from "node:path";
 var DEFAULT_TIMEOUT_MS4 = 2000;
 var UNLOCK_TIMEOUT_MS = 30000;
-var LEGACY_SOCKET_PATH2 = join65(homedir18(), ".switchroom", "vault-broker.sock");
-var OPERATOR_SOCKET_PATH2 = join65(homedir18(), ".switchroom", "broker-operator", "sock");
+var LEGACY_SOCKET_PATH2 = join66(homedir18(), ".switchroom", "vault-broker.sock");
+var OPERATOR_SOCKET_PATH2 = join66(homedir18(), ".switchroom", "broker-operator", "sock");
 function defaultBrokerSocketPath2() {
   if (fs3.existsSync(OPERATOR_SOCKET_PATH2))
     return OPERATOR_SOCKET_PATH2;
@@ -98871,8 +99756,8 @@ async function createLinearIssue(args, deps = {}) {
     }
     teamId = nodes[0].id;
   }
-  const description = dedupKey ? `${body}${captureDedupMarker(dedupKey)}` : body;
-  const input = { teamId, title, description };
+  const description2 = dedupKey ? `${body}${captureDedupMarker(dedupKey)}` : body;
+  const input = { teamId, title, description: description2 };
   if (priority !== undefined)
     input.priority = priority;
   const create = await gql("mutation($input: IssueCreateInput!) { issueCreate(input: $input) { success issue { id identifier url } } }", { input });
@@ -99152,8 +100037,8 @@ function resolveVaultApprovalPosture(broker) {
 }
 
 // registry/turns-schema.ts
-import { chmodSync as chmodSync12, mkdirSync as mkdirSync48 } from "fs";
-import { join as join66 } from "path";
+import { chmodSync as chmodSync12, mkdirSync as mkdirSync49 } from "fs";
+import { join as join67 } from "path";
 var DatabaseClass3 = null;
 function loadDatabaseClass3() {
   if (DatabaseClass3 != null)
@@ -99210,7 +100095,7 @@ var PHASE4_MIGRATIONS = [
 ];
 function applySchema(db3) {
   db3.exec("PRAGMA journal_mode = WAL");
-  db3.exec("PRAGMA synchronous = NORMAL");
+  db3.exec("PRAGMA synchronous = FULL");
   db3.exec("PRAGMA busy_timeout = 5000");
   db3.exec(SCHEMA_SQL);
   for (const sql of [...PHASE1_MIGRATIONS, ...PHASE2_MIGRATIONS, ...PHASE3_MIGRATIONS, ...PHASE4_MIGRATIONS]) {
@@ -99225,9 +100110,9 @@ function applySchema(db3) {
 }
 function openTurnsDb(agentDir) {
   const Database = loadDatabaseClass3();
-  const dir = join66(agentDir, "telegram");
-  mkdirSync48(dir, { recursive: true, mode: 448 });
-  const path3 = join66(dir, "registry.db");
+  const dir = join67(agentDir, "telegram");
+  mkdirSync49(dir, { recursive: true, mode: 448 });
+  const path3 = join67(dir, "registry.db");
   const db3 = new Database(path3, { create: true });
   applySchema(db3);
   try {
@@ -99572,7 +100457,7 @@ function selectResumeBuilder(endedVia, opts) {
 }
 
 // gateway/bridge-dead-watchdog.ts
-import { readFileSync as readFileSync57, writeFileSync as writeFileSync47, renameSync as renameSync24, unlinkSync as unlinkSync27 } from "node:fs";
+import { readFileSync as readFileSync58, writeFileSync as writeFileSync48, renameSync as renameSync26, unlinkSync as unlinkSync28 } from "node:fs";
 
 // gateway/cron-session.ts
 var CRON_IDENTITY_SUFFIX2 = "-cron";
@@ -99605,7 +100490,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) => readFileSync57(p, "utf8"));
+  const readFile = opts.readFile ?? ((p) => readFileSync58(p, "utf8"));
   let raw;
   try {
     raw = readFile(path3);
@@ -99626,13 +100511,13 @@ function readFreshCrashLogTail(path3, opts = {}) {
 }
 function writeBridgeDeadEscalationMarker(path3, marker) {
   const tmp = `${path3}.tmp-${process.pid}-${Date.now()}`;
-  writeFileSync47(tmp, JSON.stringify(marker), "utf8");
-  renameSync24(tmp, path3);
+  writeFileSync48(tmp, JSON.stringify(marker), "utf8");
+  renameSync26(tmp, path3);
 }
 function consumeBridgeDeadEscalationMarker(path3, nowMs3 = Date.now(), maxAgeMs = ESCALATION_MARKER_MAX_AGE_MS) {
   let marker = null;
   try {
-    const parsed = JSON.parse(readFileSync57(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync58(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) {
@@ -99644,7 +100529,7 @@ function consumeBridgeDeadEscalationMarker(path3, nowMs3 = Date.now(), maxAgeMs
     }
   } catch {}
   try {
-    unlinkSync27(path3);
+    unlinkSync28(path3);
   } catch {}
   return marker;
 }
@@ -99785,7 +100670,7 @@ function createBridgeDeadWatchdog(opts) {
 }
 
 // gateway/boot-probes.ts
-import { readFileSync as readFileSync58, readdirSync as readdirSync14, existsSync as existsSync55 } from "fs";
+import { readFileSync as readFileSync59, readdirSync as readdirSync14, existsSync as existsSync55 } from "fs";
 init_quota_cache();
 init_generation_stamp();
 init_quota_check();
@@ -99794,7 +100679,7 @@ import { promisify as promisify2 } from "util";
 var execFile2 = promisify2(execFileCb2);
 var realProcFs2 = {
   readdir: (p) => readdirSync14(p),
-  readFile: (p) => readFileSync58(p, "utf-8")
+  readFile: (p) => readFileSync59(p, "utf-8")
 };
 function findAgentProcessInContainer2(fs4 = realProcFs2) {
   let entries;
@@ -100044,7 +100929,7 @@ if (isGatewayMain) {
     shutdownAnalytics();
   });
 }
-var STATE_DIR = process.env.TELEGRAM_STATE_DIR ?? join67(homedir19(), ".claude", "channels", "telegram");
+var STATE_DIR = process.env.TELEGRAM_STATE_DIR ?? join68(homedir19(), ".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";
@@ -100083,7 +100968,7 @@ function alwaysAllowDrainDeps() {
   return {
     readConfigText: () => {
       const cfgPath = process.env.SWITCHROOM_CONFIG ?? SWITCHROOM_CONFIG ?? findConfigFile2();
-      return readFileSync59(cfgPath, "utf8");
+      return readFileSync60(cfgPath, "utf8");
     },
     resolveAllowList: (_configText, agentName3) => {
       const cfg = loadConfig2();
@@ -100144,11 +101029,11 @@ function scheduleAlwaysAllowPersistDrain() {
   }, ALWAYS_ALLOW_DRAIN_INTERVAL_MS);
   timer3.unref?.();
 }
-var ACCESS_FILE = join67(STATE_DIR, "access.json");
-var APPROVED_DIR = join67(STATE_DIR, "approved");
-var ENV_FILE = join67(STATE_DIR, ".env");
-var INBOX_DIR = join67(STATE_DIR, "inbox");
-var PEOPLE_FILE = join67(STATE_DIR, "people.json");
+var ACCESS_FILE = join68(STATE_DIR, "access.json");
+var APPROVED_DIR = join68(STATE_DIR, "approved");
+var ENV_FILE = join68(STATE_DIR, ".env");
+var INBOX_DIR = join68(STATE_DIR, "inbox");
+var PEOPLE_FILE = join68(STATE_DIR, "people.json");
 function triggerSelfRestart(targetAgent, reason, delayMs = 300) {
   const isDocker = process.env.SWITCHROOM_RUNTIME === "docker";
   const selfAgent = process.env.SWITCHROOM_AGENT_NAME;
@@ -100213,7 +101098,7 @@ function formatBootVersion() {
 }
 try {
   chmodSync14(ENV_FILE, 384);
-  for (const line of readFileSync59(ENV_FILE, "utf8").split(`
+  for (const line of readFileSync60(ENV_FILE, "utf8").split(`
 `)) {
     const m = line.match(/^(\w+)=(.*)$/);
     if (m && process.env[m[1]] === undefined)
@@ -100234,7 +101119,7 @@ var bot;
 var lastGetUpdatesHeartbeatMs = Date.now();
 var GRAMMY_VERSION = (() => {
   try {
-    const raw = readFileSync59(new URL("../../node_modules/grammy/package.json", import.meta.url), "utf8");
+    const raw = readFileSync60(new URL("../../node_modules/grammy/package.json", import.meta.url), "utf8");
     return JSON.parse(raw).version ?? "unknown";
   } catch {
     return "unknown";
@@ -100297,7 +101182,7 @@ function assertSendable(f) {
   } catch {
     throw new Error(`refusing to send file \u2014 cannot resolve real path: ${f}`);
   }
-  const inbox = join67(stateReal, "inbox");
+  const inbox = join68(stateReal, "inbox");
   if (real.startsWith(stateReal + sep4) && !real.startsWith(inbox + sep4)) {
     throw new Error(`refusing to send channel state: ${f}`);
   }
@@ -100316,7 +101201,7 @@ function assertSendable(f) {
 }
 function readAccessFile() {
   try {
-    const raw = readFileSync59(ACCESS_FILE, "utf8");
+    const raw = readFileSync60(ACCESS_FILE, "utf8");
     const parsed = JSON.parse(raw);
     const allowFrom = validateStringArray("allowFrom", parsed.allowFrom ?? []);
     const groups = {};
@@ -100356,7 +101241,7 @@ function readAccessFile() {
     if (err.code === "ENOENT")
       return defaultAccess();
     try {
-      renameSync25(ACCESS_FILE, `${ACCESS_FILE}.corrupt-${Date.now()}`);
+      renameSync27(ACCESS_FILE, `${ACCESS_FILE}.corrupt-${Date.now()}`);
     } catch {}
     process.stderr.write(`telegram gateway: access.json is corrupt, moved aside. Starting fresh.
 `);
@@ -100378,7 +101263,7 @@ function loadAccess() {
 }
 function readPeopleFile() {
   try {
-    const raw = readFileSync59(PEOPLE_FILE, "utf8");
+    const raw = readFileSync60(PEOPLE_FILE, "utf8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.entries))
       return [];
@@ -100400,11 +101285,11 @@ function assertAllowedChat(chat_id) {
 function saveAccess(a) {
   if (STATIC)
     return;
-  mkdirSync50(STATE_DIR, { recursive: true, mode: 448 });
+  mkdirSync51(STATE_DIR, { recursive: true, mode: 448 });
   const tmp = ACCESS_FILE + ".tmp";
-  writeFileSync49(tmp, JSON.stringify(a, null, 2) + `
+  writeFileSync50(tmp, JSON.stringify(a, null, 2) + `
 `, { mode: 384 });
-  renameSync25(tmp, ACCESS_FILE);
+  renameSync27(tmp, ACCESS_FILE);
 }
 function pruneExpired(a) {
   const now = Date.now();
@@ -100422,7 +101307,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 ${join67(STATE_DIR, "history.db")}
+    process.stderr.write(`telegram gateway: history capture enabled at ${join68(STATE_DIR, "history.db")}
 `);
   } catch (err) {
     process.stderr.write(`telegram gateway: history init failed (${err.message}) \u2014 capture disabled
@@ -100441,12 +101326,12 @@ if (isGatewayMain)
     let markerTurnKey = null;
     let markerAgeMs = null;
     try {
-      const markerPath = join67(STATE_DIR, TURN_ACTIVE_MARKER_FILE2);
+      const markerPath = join68(STATE_DIR, TURN_ACTIVE_MARKER_FILE2);
       if (existsSync57(markerPath)) {
         const st = statSync22(markerPath);
         markerAgeMs = Date.now() - st.mtimeMs;
         try {
-          const payload = JSON.parse(readFileSync59(markerPath, "utf8"));
+          const payload = JSON.parse(readFileSync60(markerPath, "utf8"));
           if (typeof payload.turnKey === "string" && payload.turnKey.length > 0) {
             markerTurnKey = payload.turnKey;
           }
@@ -100466,10 +101351,10 @@ if (isGatewayMain)
       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 ${join67(agentDir, "telegram", "registry.db")}
+      process.stderr.write(`telegram gateway: turn-registry initialized at ${join68(agentDir, "telegram", "registry.db")}
 `);
     }
-    const bridgeDeadMarker = consumeBridgeDeadEscalationMarker(join67(STATE_DIR, "bridge-dead-escalation.json"));
+    const bridgeDeadMarker = consumeBridgeDeadEscalationMarker(join68(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}` : ""})
@@ -100482,7 +101367,7 @@ if (isGatewayMain)
     const pending2 = findLatestTurnIfInterrupted(turnsDb);
     const selfAgent = process.env.SWITCHROOM_AGENT_NAME ?? "";
     if (pending2 != null && selfAgent) {
-      const bootResumeMarkerPath = process.env.SWITCHROOM_GATEWAY_CLEAN_SHUTDOWN_MARKER ?? join67(STATE_DIR, "clean-shutdown.json");
+      const bootResumeMarkerPath = process.env.SWITCHROOM_GATEWAY_CLEAN_SHUTDOWN_MARKER ?? join68(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);
@@ -100595,7 +101480,7 @@ if (isGatewayMain)
 `);
       }
     }
-    const pendingEnvPath = join67(agentDir, ".pending-turn.env");
+    const pendingEnvPath = join68(agentDir, ".pending-turn.env");
     try {
       if (pending2 != null) {
         const lines = [
@@ -100609,14 +101494,14 @@ if (isGatewayMain)
           pending2.interrupt_reason != null ? `SWITCHROOM_PENDING_INTERRUPT_REASON=${pending2.interrupt_reason}` : `SWITCHROOM_PENDING_INTERRUPT_REASON=`
         ];
         const pendingEnvTmp = `${pendingEnvPath}.tmp-${process.pid}`;
-        writeFileSync49(pendingEnvTmp, lines.join(`
+        writeFileSync50(pendingEnvTmp, lines.join(`
 `) + `
 `, { mode: 384 });
-        renameSync25(pendingEnvTmp, pendingEnvPath);
+        renameSync27(pendingEnvTmp, pendingEnvPath);
         process.stderr.write(`telegram gateway: pending-turn env written to ${pendingEnvPath} turnKey=${pending2.turn_key} endedVia=${pending2.ended_via ?? "open"}
 `);
       } else if (existsSync57(pendingEnvPath)) {
-        rmSync7(pendingEnvPath, { force: true });
+        rmSync8(pendingEnvPath, { force: true });
         process.stderr.write(`telegram gateway: pending-turn env cleared (clean previous shutdown)
 `);
       }
@@ -100723,16 +101608,16 @@ function checkApprovals() {
     return;
   }
   for (const senderId of files) {
-    const file = join67(APPROVED_DIR, senderId);
-    bot.api.sendMessage(senderId, "Paired! Say hi to Claude.").then(() => rmSync7(file, { force: true }), (err) => {
+    const file = join68(APPROVED_DIR, senderId);
+    bot.api.sendMessage(senderId, "Paired! Say hi to Claude.").then(() => rmSync8(file, { force: true }), (err) => {
       process.stderr.write(`telegram gateway: failed to send approval confirm: ${err}
 `);
-      rmSync7(file, { force: true });
+      rmSync8(file, { force: true });
     });
   }
 }
 if (isGatewayMain && !STATIC)
-  setInterval(checkApprovals, 5000).unref();
+  setInterval(attachBootBeacon(STATE_DIR, checkApprovals), 5000).unref();
 if (isGatewayMain && !STATIC)
   startGatewayHeartbeat(STATE_DIR);
 var IDLE_CLEAR_CHECK_MS = Number(process.env.SWITCHROOM_IDLE_CLEAR_CHECK_MS ?? 60000);
@@ -100897,12 +101782,14 @@ function noteAgentOutputAt(key, ts) {
       lastAgentOutputAt.delete(oldest);
   }
 }
-var OBLIGATION_STORE_PATH = join67(STATE_DIR, "obligations.json");
+var OBLIGATION_STORE_PATH = join68(STATE_DIR, "obligations.json");
 var obligationStoreFs = {
-  readFileSync: (p) => readFileSync59(p, "utf8"),
-  writeFileSync: (p, d) => writeFileSync49(p, d),
-  renameSync: (a, b) => renameSync25(a, b),
-  existsSync: (p) => existsSync57(p)
+  readFileSync: (p) => readFileSync60(p, "utf8"),
+  writeFileSync: (p, d) => writeFileSync50(p, d),
+  renameSync: (a, b) => renameSync27(a, b),
+  existsSync: (p) => existsSync57(p),
+  fsyncFileSync: fsyncPathSync,
+  fsyncDirSync: fsyncPathSync
 };
 var obligationLedger = new ObligationLedger(OBLIGATION_REPRESENT_MAX, {
   onChange: STATIC || !OBLIGATION_LEDGER_ENABLED ? undefined : (snapshot) => persistObligations(OBLIGATION_STORE_PATH, obligationStoreFs, snapshot)
@@ -101677,7 +102564,7 @@ function emitTurnRecord(turn, endedAt) {
           return;
         }
       },
-      rename: (from, to) => renameSync25(from, to)
+      rename: (from, to) => renameSync27(from, to)
     });
     appendFileSync9(turnsPath, rec);
   } catch {}
@@ -102225,7 +103112,7 @@ function maybePostMissedApprovalDigest(reason) {
     const first = entries[0];
     const chatId = first.chatId;
     const threadId = first.threadId ?? undefined;
-    const digestId = randomBytes12(4).toString("hex");
+    const digestId = randomBytes13(4).toString("hex");
     const text5 = renderMissedApprovalsDigest(entries, {
       agentName: process.env.SWITCHROOM_AGENT_NAME ?? null
     });
@@ -103240,27 +104127,27 @@ var PIN_STATUS_WHILE_WORKING = (() => {
 })();
 var statusPinClaims = new Map;
 var statusPinRightsCache = new PinRightsCache2;
-var STATUS_PIN_STORE_PATH = join67(STATE_DIR, "status-pins.json");
+var STATUS_PIN_STORE_PATH = join68(STATE_DIR, "status-pins.json");
 var statusPinStoreFs = {
-  readFileSync: (p) => readFileSync59(p, "utf8"),
-  writeFileSync: (p, d) => writeFileSync49(p, d),
-  renameSync: (a, b) => renameSync25(a, b),
+  readFileSync: (p) => readFileSync60(p, "utf8"),
+  writeFileSync: (p, d) => writeFileSync50(p, d),
+  renameSync: (a, b) => renameSync27(a, b),
   existsSync: (p) => existsSync57(p)
 };
 var statusPinPersistEnabled = !STATIC && PIN_STATUS_WHILE_WORKING;
-var ACTIVITY_CARD_STORE_PATH = join67(STATE_DIR, "activity-cards-pending.json");
+var ACTIVITY_CARD_STORE_PATH = join68(STATE_DIR, "activity-cards-pending.json");
 var activityCardStoreFs = {
-  readFileSync: (p) => readFileSync59(p, "utf8"),
-  writeFileSync: (p, d) => writeFileSync49(p, d),
-  renameSync: (a, b) => renameSync25(a, b),
+  readFileSync: (p) => readFileSync60(p, "utf8"),
+  writeFileSync: (p, d) => writeFileSync50(p, d),
+  renameSync: (a, b) => renameSync27(a, b),
   existsSync: (p) => existsSync57(p)
 };
 var activityCardPersistEnabled = !STATIC;
-var QUEUED_CARD_STORE_PATH = join67(STATE_DIR, "queued-cards-pending.json");
+var QUEUED_CARD_STORE_PATH = join68(STATE_DIR, "queued-cards-pending.json");
 var queuedCardStoreFs = {
-  readFileSync: (p) => readFileSync59(p, "utf8"),
-  writeFileSync: (p, d) => writeFileSync49(p, d),
-  renameSync: (a, b) => renameSync25(a, b),
+  readFileSync: (p) => readFileSync60(p, "utf8"),
+  writeFileSync: (p, d) => writeFileSync50(p, d),
+  renameSync: (a, b) => renameSync27(a, b),
   existsSync: (p) => existsSync57(p)
 };
 var queuedCardPersistEnabled = !STATIC;
@@ -103499,16 +104386,16 @@ var midSessionCardReaper = isGatewayMain ? setInterval(() => {
   midSessionReaperGuard.tick();
 }, MID_SESSION_CARD_REAPER_INTERVAL_MS) : undefined;
 midSessionCardReaper?.unref();
-async function reconcileStatusPin(pinKey, chatId, desired) {
+async function reconcileStatusPin(pinKey, chatId, desired, threadId) {
   try {
-    await withPinReconcileLock(pinKey, () => reconcileStatusPinInner(pinKey, chatId, desired));
+    await withPinReconcileLock(pinKey, () => reconcileStatusPinInner(pinKey, chatId, desired, threadId));
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     process.stderr.write(`telegram gateway: status-pin reconcile absorbed error (key=${pinKey} chat=${chatId}): ${msg}
 `);
   }
 }
-async function reconcileStatusPinInner(pinKey, chatId, desired) {
+async function reconcileStatusPinInner(pinKey, chatId, desired, threadId) {
   if (!PIN_STATUS_WHILE_WORKING)
     return;
   if (chatId.length === 0)
@@ -103534,6 +104421,7 @@ async function reconcileStatusPinInner(pinKey, chatId, desired) {
   await runStatusPinReconcile({
     pinKey,
     chatId,
+    threadId,
     prev,
     desired,
     persist: statusPinPersistEnabled ? { path: STATUS_PIN_STORE_PATH, fs: statusPinStoreFs } : null,
@@ -103546,37 +104434,26 @@ async function unpinAllStatusPins() {
     await reconcileStatusPin(key, claim.chatId, { pinned: false });
   }
 }
-var dmPinSweepEligible = false;
-var dmPinSweeper = createDmPinSweeper({
-  unpinAll: (chatId) => robustApiCall(() => lockedBot.api.unpinAllChatMessages(chatId), {
-    chat_id: chatId,
-    verb: "dm-pin-sweep.unpin-all"
-  }),
-  pinSilent: (chatId, messageId) => robustApiCall(() => lockedBot.api.pinChatMessage(chatId, messageId, {
-    disable_notification: true
-  }), { chat_id: chatId, verb: "dm-pin-sweep.repin" }),
-  liveTrackedMessageIds: (chatId) => {
-    const ids = [];
-    for (const claim of statusPinClaims.values()) {
-      if (claim.chatId === chatId)
-        ids.push(claim.messageId);
-    }
-    if (statusPinPersistEnabled || bannerPinPersistEnabled || toolPinPersistEnabled) {
-      try {
-        ids.push(...unexpiredStoreRepinIds(loadStatusPins2(STATUS_PIN_STORE_PATH, statusPinStoreFs), chatId, Date.now()));
-      } catch (err) {
-        process.stderr.write(`telegram gateway: dm-pin-sweep: store repin scan failed (chat=${chatId}): ${err.message}
-`);
-      }
+var stalePinSweepEligible = false;
+var STALE_PIN_SWEEP_STORE_PATH = join68(STATE_DIR, "stale-pin-sweep.json");
+var stalePinSweeper = createGatewayStalePinSweeper({
+  telegram: { handle: () => lockedBot, call: robustApiCall },
+  claims: () => statusPinClaims.values(),
+  loadPinRows: () => statusPinPersistEnabled || bannerPinPersistEnabled || toolPinPersistEnabled ? loadStatusPins2(STATUS_PIN_STORE_PATH, statusPinStoreFs) : [],
+  eligible: () => stalePinSweepEligible,
+  store: {
+    path: STALE_PIN_SWEEP_STORE_PATH,
+    fs: {
+      readFileSync: (p) => readFileSync60(p, "utf-8"),
+      writeFileSync: (p, data) => atomicWriteFileSync(p, data, 384),
+      existsSync: (p) => existsSync57(p)
     }
-    return ids;
   },
-  eligible: () => dmPinSweepEligible,
-  log: (line) => process.stderr.write(line)
+  allowUnpinAllForumTopic: process.env.SWITCHROOM_PIN_SWEEP_UNPIN_ALL_TOPIC == null ? undefined : process.env.SWITCHROOM_PIN_SWEEP_UNPIN_ALL_TOPIC === "1"
 });
-function runBootPinCleanupAndDmSweep() {
+function runBootPinCleanupAndStalePinSweep() {
   return runBootPinSweepSteps({
-    scanDmChatIds: () => collectDmChatIdsFromStores({
+    scanSweepTargets: () => collectSweepTargets({
       statusPins: statusPinPersistEnabled || bannerPinPersistEnabled || toolPinPersistEnabled ? loadStatusPins2(STATUS_PIN_STORE_PATH, statusPinStoreFs) : [],
       activityCards: activityCardPersistEnabled ? loadActivityCards2(ACTIVITY_CARD_STORE_PATH, activityCardStoreFs) : [],
       queuedCards: queuedCardPersistEnabled ? loadQueuedCards(QUEUED_CARD_STORE_PATH, queuedCardStoreFs) : []
@@ -103584,14 +104461,14 @@ function runBootPinCleanupAndDmSweep() {
     statusPinCleanup: statusPinBootCleanup,
     activityCardReaper: activityCardBootReaper,
     queuedCardReaper: queuedCardBootReaper,
-    enableDmSweep: () => {
-      dmPinSweepEligible = true;
+    enableSweep: () => {
+      stalePinSweepEligible = true;
     },
-    sweepDm: (id) => dmPinSweeper.sweep(id),
+    sweepTarget: (t) => stalePinSweeper.sweepTarget(t),
     log: (line) => process.stderr.write(line)
   });
 }
-var bootPinSweepGate = createBootSweepGate({ run: runBootPinCleanupAndDmSweep, onError: (err) => process.stderr.write(`telegram gateway: boot pin cleanup / DM sweep failed: ${err.message}
+var bootPinSweepGate = createBootSweepGate({ run: runBootPinCleanupAndStalePinSweep, onError: (err) => process.stderr.write(`telegram gateway: boot pin cleanup / stale-pin sweep failed: ${err.message}
 `) });
 var progressDriver = null;
 var unpinProgressCardForChat = null;
@@ -103599,12 +104476,12 @@ var getPinnedProgressCardMessageId = null;
 var completeProgressCardTurn = null;
 var subagentWatcher = null;
 var workerActivityFeed = null;
-var SOCKET_PATH = process.env.SWITCHROOM_GATEWAY_SOCKET ?? join67(STATE_DIR, "gateway.sock");
+var SOCKET_PATH = process.env.SWITCHROOM_GATEWAY_SOCKET ?? join68(STATE_DIR, "gateway.sock");
 if (isGatewayMain)
-  mkdirSync50(STATE_DIR, { recursive: true, mode: 448 });
-var GATEWAY_PID_PATH = process.env.SWITCHROOM_GATEWAY_PID_FILE ?? join67(STATE_DIR, "gateway.pid.json");
-var GATEWAY_SESSION_MARKER_PATH = process.env.SWITCHROOM_GATEWAY_SESSION_MARKER ?? join67(STATE_DIR, "gateway-session.json");
-var GATEWAY_CLEAN_SHUTDOWN_MARKER_PATH = process.env.SWITCHROOM_GATEWAY_CLEAN_SHUTDOWN_MARKER ?? join67(STATE_DIR, "clean-shutdown.json");
+  mkdirSync51(STATE_DIR, { recursive: true, mode: 448 });
+var GATEWAY_PID_PATH = process.env.SWITCHROOM_GATEWAY_PID_FILE ?? join68(STATE_DIR, "gateway.pid.json");
+var GATEWAY_SESSION_MARKER_PATH = process.env.SWITCHROOM_GATEWAY_SESSION_MARKER ?? join68(STATE_DIR, "gateway-session.json");
+var GATEWAY_CLEAN_SHUTDOWN_MARKER_PATH = process.env.SWITCHROOM_GATEWAY_CLEAN_SHUTDOWN_MARKER ?? join68(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;
@@ -103633,7 +104510,7 @@ function ensureIssuesCard(chatId, threadId) {
     bot: botApi,
     log: (msg) => process.stderr.write(`telegram gateway: ${msg}
 `),
-    persistPath: join67(stateDir, "issues-card.json")
+    persistPath: join68(stateDir, "issues-card.json")
   });
   activeIssuesWatcher = startIssuesWatcher({
     stateDir,
@@ -103833,14 +104710,16 @@ if (isGatewayMain)
 var inboundSpool;
 if (isGatewayMain)
   inboundSpool = STATIC ? undefined : createInboundSpool({
-    path: join67(STATE_DIR, "inbound-spool.jsonl"),
+    path: join68(STATE_DIR, "inbound-spool.jsonl"),
     fs: {
       appendFileSync: (p, d) => appendFileSync9(p, d),
-      readFileSync: (p) => readFileSync59(p, "utf8"),
-      writeFileSync: (p, d) => writeFileSync49(p, d),
-      renameSync: (a, b) => renameSync25(a, b),
+      readFileSync: (p) => readFileSync60(p, "utf8"),
+      writeFileSync: (p, d) => writeFileSync50(p, d),
+      renameSync: (a, b) => renameSync27(a, b),
       existsSync: (p) => existsSync57(p),
-      statSizeSync: (p) => statSync22(p).size
+      statSizeSync: (p) => statSync22(p).size,
+      fsyncFileSync: fsyncPathSync,
+      fsyncDirSync: fsyncPathSync
     },
     onDegraded: (info) => {
       process.stderr.write(`telegram gateway: inbound-spool durability ${info.degraded ? "DEGRADED to in-memory-only" : "RECOVERED"} path=${info.path} consecutiveFailures=${info.consecutiveFailures}${info.error != null ? ` error=${info.error}` : ""}
@@ -103901,13 +104780,13 @@ async function maybeRedeliverUndeliveredAnswer() {
   let transcriptText;
   try {
     const projectsDir = getProjectsDirForCwd();
-    const path3 = join67(projectsDir, `${sessionId}.jsonl`);
+    const path3 = join68(projectsDir, `${sessionId}.jsonl`);
     if (!existsSync57(path3)) {
       process.stderr.write(`telegram gateway: crash-redelivery \u2014 transcript not found for turnKey=${turn.turn_key} session=${sessionId} (${path3}); skipping
 `);
       return;
     }
-    transcriptText = readFileSync59(path3, "utf8");
+    transcriptText = readFileSync60(path3, "utf8");
   } catch (err) {
     process.stderr.write(`telegram gateway: crash-redelivery \u2014 transcript read failed turnKey=${turn.turn_key}: ${err.message}
 `);
@@ -104024,13 +104903,13 @@ function dispatchPermissionVerdict(ev) {
   }
 }
 function rearmPermissionFromStore(msg, persisted) {
-  const { requestId, toolName, description, inputPreview } = msg;
+  const { requestId, toolName, description: description2, inputPreview } = msg;
   const startedAt = persisted.reduce((min, c) => c.startedAt < min ? c.startedAt : min, persisted[0].startedAt);
   const cardText = persisted[0].cardText;
   const cards = persisted.map((c) => ({ chatId: c.chatId, messageId: c.messageId }));
   pendingPermissions.set(requestId, {
     tool_name: toolName,
-    description,
+    description: description2,
     input_preview: inputPreview,
     startedAt,
     card_text: cardText,
@@ -104066,8 +104945,8 @@ var bridgeDeadWatchdog = createBridgeDeadWatchdog({
   isSessionAlive: () => findAgentProcessInContainer2()?.comm === "claude",
   isShuttingDown: () => shuttingDown,
   escalate: (reason) => triggerSelfRestart(process.env.SWITCHROOM_AGENT_NAME ?? "", reason, 1500),
-  crashLogPath: join67(STATE_DIR, "bridge-crash.log"),
-  markerPath: join67(STATE_DIR, "bridge-dead-escalation.json"),
+  crashLogPath: join68(STATE_DIR, "bridge-crash.log"),
+  markerPath: join68(STATE_DIR, "bridge-dead-escalation.json"),
   log: (line) => process.stderr.write(`${line}
 `),
   priorStreak: bridgeDeadPriorStreak,
@@ -104173,8 +105052,8 @@ if (isGatewayMain)
               probeQuotaViaBroker: (t) => probeQuotaForBootCard(agentSlug, t),
               tmuxSupervisor: process.env.SWITCHROOM_TMUX_SUPERVISOR === "1",
               dockerMode: process.env.SWITCHROOM_RUNTIME === "docker",
-              configSnapshotPath: join67(resolvedAgentDirForCard, ".config-snapshot.json"),
-              bootCardStatePath: join67(resolvedAgentDirForCard, ".boot-card-msgid.json"),
+              configSnapshotPath: join68(resolvedAgentDirForCard, ".config-snapshot.json"),
+              bootCardStatePath: join68(resolvedAgentDirForCard, ".boot-card-msgid.json"),
               floodStatePath: FLOOD_STATE_PATH,
               ...updateOutcomeLine ? { updateOutcomeLine } : {}
             }, ackMsgId).then((handle) => {
@@ -104289,7 +105168,7 @@ if (isGatewayMain)
       }
     },
     onPermissionRequest(_client, msg) {
-      const { requestId, toolName, description, inputPreview } = msg;
+      const { requestId, toolName, description: description2, inputPreview } = msg;
       if (isPermissionRearmEnabled()) {
         const persisted = pendingPermissions.has(requestId) ? [] : permCardStore.loadAll().filter((e) => e.requestId === requestId);
         const disposition = classifyPermissionRequest({
@@ -104333,10 +105212,10 @@ if (isGatewayMain)
       const text5 = formatPermissionCardBody({
         toolName,
         inputPreview,
-        description,
+        description: description2,
         agentName: _client.agentName
       });
-      const pendEntry = { tool_name: toolName, description, input_preview: inputPreview, startedAt: Date.now(), card_text: text5, cards: [] };
+      const pendEntry = { tool_name: toolName, description: description2, input_preview: inputPreview, startedAt: Date.now(), card_text: text5, cards: [] };
       pendingPermissions.set(requestId, pendEntry);
       const activeTurn = currentTurn;
       postPermissionCard(requestId, pendEntry);
@@ -104842,7 +105721,7 @@ if (isGatewayMain)
       const receiverUid = receiverUidRaw ? Number(receiverUidRaw) : NaN;
       if (Number.isInteger(receiverUid))
         allowedUids.push(receiverUid);
-      const socketPath = join67(STATE_DIR, "webhook.sock");
+      const socketPath = join68(STATE_DIR, "webhook.sock");
       const webhookInject = (agentName3, inbound) => {
         const msg = inbound;
         const delivered = ipcServer.sendToAgent(agentName3, msg);
@@ -105070,9 +105949,9 @@ function redactOutboundText(text5, site) {
 var VOICE_OUT_DEFAULT_CHUNK_CHARS = 600;
 var VOICE_OUT_HARD_CHUNK_CAP = 4096;
 var voiceOnDemandCache = new VoiceOnDemandCache({
-  persistPath: join67(STATE_DIR, "voice-ondemand.json")
+  persistPath: join68(STATE_DIR, "voice-ondemand.json")
 });
-var VOICE_CACHE_DIR = join67(STATE_DIR, "voice-cache");
+var VOICE_CACHE_DIR = join68(STATE_DIR, "voice-cache");
 var voicePreSynthQueue = new PreSynthQueue({
   runJob: async (job) => {
     const sidecarToken = await materializeSidecarToken2();
@@ -105474,11 +106353,11 @@ async function executeSendGif(rawArgs) {
   };
 }
 async function publishToTelegraph(text5, shortName, authorName) {
-  const accountPath = join67(STATE_DIR, "telegraph-account.json");
+  const accountPath = join68(STATE_DIR, "telegraph-account.json");
   let account = null;
   try {
     if (existsSync57(accountPath)) {
-      const raw = readFileSync59(accountPath, "utf-8");
+      const raw = readFileSync60(accountPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.shortName && parsed.accessToken) {
         account = parsed;
@@ -105497,8 +106376,8 @@ async function publishToTelegraph(text5, shortName, authorName) {
     }
     account = created.value;
     try {
-      mkdirSync50(STATE_DIR, { recursive: true, mode: 448 });
-      writeFileSync49(accountPath, JSON.stringify(account, null, 2), { mode: 384 });
+      mkdirSync51(STATE_DIR, { recursive: true, mode: 448 });
+      writeFileSync50(accountPath, JSON.stringify(account, null, 2), { mode: 384 });
     } catch (err) {
       process.stderr.write(`telegram gateway: telegraph cache write failed: ${err.message}
 `);
@@ -105614,7 +106493,7 @@ _The secret was NOT saved. The agent can re-request with \`request_secret\`._`,
 }
 function readLiveSwitchroomConfigText() {
   const cfgPath = process.env.SWITCHROOM_CONFIG ?? findConfigFile2();
-  return readFileSync59(cfgPath, "utf8");
+  return readFileSync60(cfgPath, "utf8");
 }
 async function executeReact(args) {
   if (!args.chat_id)
@@ -105653,9 +106532,9 @@ async function executeDownloadAttachment(args) {
     fileUniqueId: file.file_unique_id,
     now: Date.now()
   });
-  mkdirSync50(INBOX_DIR, { recursive: true, mode: 448 });
+  mkdirSync51(INBOX_DIR, { recursive: true, mode: 448 });
   assertInsideInbox2(INBOX_DIR, dlPath);
-  writeFileSync49(dlPath, buf, { mode: 384 });
+  writeFileSync50(dlPath, buf, { mode: 384 });
   return { content: [{ type: "text", text: dlPath }] };
 }
 async function executeEditMessage(args) {
@@ -106299,7 +107178,7 @@ function gate(ctx) {
     }
     if (Object.keys(access.pending).length >= 3)
       return { action: "drop", reason: "pairing_capacity" };
-    const code2 = randomBytes12(3).toString("hex");
+    const code2 = randomBytes13(3).toString("hex");
     const now = Date.now();
     access.pending[code2] = {
       senderId,
@@ -106539,8 +107418,13 @@ async function handleInbound(ctx, text5, downloadImage, attachment, extraAttachm
   maybePostMissedApprovalDigest("operator inbound");
   {
     const inboundChatId = ctx.chat?.id;
-    if (inboundChatId != null)
-      dmPinSweeper.sweep(String(inboundChatId));
+    if (inboundChatId != null) {
+      stalePinSweeper.sweepTarget({
+        chatId: String(inboundChatId),
+        threadId: ctx.message?.message_thread_id,
+        isForum: ctx.chat?.is_forum === true
+      });
+    }
   }
   const inboundReceivedAt = Date.now();
   const machineInTurnAtReceipt = isMachineInTurn();
@@ -107023,14 +107907,14 @@ function restartMarkerPath() {
   const agentDir = resolveAgentDirFromEnv();
   if (!agentDir)
     return null;
-  return join67(agentDir, "restart-pending.json");
+  return join68(agentDir, "restart-pending.json");
 }
 function writeRestartMarker(marker) {
   const p = restartMarkerPath();
   if (!p)
     return;
   try {
-    writeFileSync49(p, JSON.stringify(marker));
+    writeFileSync50(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}
 `);
@@ -107049,7 +107933,7 @@ function readRestartMarker() {
   if (!p)
     return null;
   try {
-    return JSON.parse(readFileSync59(p, "utf8"));
+    return JSON.parse(readFileSync60(p, "utf8"));
   } catch {
     return null;
   }
@@ -107059,7 +107943,7 @@ function clearRestartMarker() {
   if (!p)
     return;
   try {
-    rmSync7(p, { force: true });
+    rmSync8(p, { force: true });
     process.stderr.write(`telegram gateway: restart-marker: cleared path=${p}
 `);
   } catch {}
@@ -107215,12 +108099,12 @@ function _resetDockerReachableCache() {
 }
 function spawnSwitchroomDetached(args, onFailure) {
   const fullArgs = SWITCHROOM_CONFIG ? ["--config", SWITCHROOM_CONFIG, ...args] : args;
-  const logPath = join67(STATE_DIR, "detached-spawn.log");
+  const logPath = join68(STATE_DIR, "detached-spawn.log");
   let outFd = null;
   try {
-    mkdirSync50(STATE_DIR, { recursive: true });
-    outFd = openSync13(logPath, "a");
-    writeFileSync49(logPath, `
+    mkdirSync51(STATE_DIR, { recursive: true });
+    outFd = openSync15(logPath, "a");
+    writeFileSync50(logPath, `
 [${new Date().toISOString()}] spawn ${SWITCHROOM_CLI} ${fullArgs.join(" ")}
 `, { flag: "a" });
   } catch {}
@@ -107234,7 +108118,7 @@ function spawnSwitchroomDetached(args, onFailure) {
   });
   if (outFd != null) {
     try {
-      closeSync13(outFd);
+      closeSync15(outFd);
     } catch {}
   }
   if (onFailure) {
@@ -107246,7 +108130,7 @@ function spawnSwitchroomDetached(args, onFailure) {
         return;
       let tail = "";
       try {
-        const full = readFileSync59(logPath, "utf8");
+        const full = readFileSync60(logPath, "utf8");
         tail = full.split(`
 `).slice(-30).join(`
 `).trim();
@@ -107508,10 +108392,10 @@ ${preBlock(formatSwitchroomOutput(detail))}`, { html: true });
 }
 function readRecentDenialsForAgent(agentName3, windowMs, limit) {
   try {
-    const auditPath = join67(homedir19(), ".switchroom", "vault-audit.log");
+    const auditPath = join68(homedir19(), ".switchroom", "vault-audit.log");
     if (!existsSync57(auditPath))
       return [];
-    const raw = readFileSync59(auditPath, "utf8");
+    const raw = readFileSync60(auditPath, "utf8");
     return recentDenialsFromAuditLog(raw, { agentName: agentName3, windowMs, limit });
   } catch {
     return [];
@@ -107562,7 +108446,7 @@ async function buildAgentMetadata(agentName3) {
   try {
     const agentDir = resolveAgentDirFromEnv();
     if (agentDir) {
-      const raw = readFileSync59(join67(agentDir, ".claude", ".claude.json"), "utf8");
+      const raw = readFileSync60(join68(agentDir, ".claude", ".claude.json"), "utf8");
       claudeJson = JSON.parse(raw);
     }
   } catch {}
@@ -107691,7 +108575,7 @@ function buildModelDeps(restartCtx) {
       try {
         const agentDir = resolveAgentDirFromEnv();
         if (agentDir) {
-          const local = await fetchQuota2({ claudeConfigDir: join67(agentDir, ".claude") });
+          const local = await fetchQuota2({ claudeConfigDir: join68(agentDir, ".claude") });
           if (local.ok)
             return formatQuotaLine2(local.data);
         }
@@ -107937,10 +108821,10 @@ function effortMenuReplyMarkup(reply) {
 function flushAgentHandoff(agentDir) {
   let removed = 0;
   for (const fname of [".handoff.md", ".handoff-topic"]) {
-    const p = join67(agentDir, fname);
+    const p = join68(agentDir, fname);
     try {
       if (existsSync57(p)) {
-        unlinkSync29(p);
+        unlinkSync30(p);
         removed++;
       }
     } catch (err) {
@@ -107995,7 +108879,7 @@ async function handleNewCommand(ctx) {
   writeRestartMarker({ chat_id: chatId, thread_id: threadId ?? null, ack_message_id: ackId, ts: Date.now() });
   if (agentDir != null) {
     try {
-      writeFileSync49(join67(agentDir, ".force-fresh-session"), `${kind} at ${new Date().toISOString()}
+      writeFileSync50(join68(agentDir, ".force-fresh-session"), `${kind} at ${new Date().toISOString()}
 `, "utf8");
     } catch (err) {
       process.stderr.write(`telegram gateway: failed to write force-fresh marker: ${err}
@@ -108108,11 +108992,11 @@ function buildFolderPickerDeps() {
   };
 }
 var lockoutOps = {
-  readFileSync: (p, enc) => readFileSync59(p, enc),
-  writeFileSync: (p, data, opts) => writeFileSync49(p, data, opts),
+  readFileSync: (p, enc) => readFileSync60(p, enc),
+  writeFileSync: (p, data, opts) => writeFileSync50(p, data, opts),
   existsSync: (p) => existsSync57(p),
-  mkdirSync: (p, opts) => mkdirSync50(p, opts),
-  joinPath: (...parts) => join67(...parts)
+  mkdirSync: (p, opts) => mkdirSync51(p, opts),
+  joinPath: (...parts) => join68(...parts)
 };
 var FLEET_FALLBACK_DEDUP_MS = 30000;
 function isAuthBrokerSocketReachable() {
@@ -108372,7 +109256,7 @@ async function runCreditWatch() {
   if (!agentDir)
     return;
   const agentName3 = getMyAgentName();
-  const claudeConfigDir = join67(agentDir, ".claude");
+  const claudeConfigDir = join68(agentDir, ".claude");
   const stateDir = STATE_DIR;
   const reason = readClaudeJsonOverage(claudeConfigDir);
   const prev = loadCreditState(stateDir);
@@ -110128,7 +111012,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: join67(agentDir, ".claude") });
+    const result = await fetchQuota2({ claudeConfigDir: join68(agentDir, ".claude") });
     if (!result.ok) {
       await switchroomReply(ctx, `**/usage:** ${escapeHtmlForTg2(result.reason)}`, { html: true });
       return;
@@ -110515,7 +111399,7 @@ ${interimLabel}` : interimLabel
           const unifiedDiff = (() => {
             try {
               const cfgPath = process.env.SWITCHROOM_CONFIG ?? SWITCHROOM_CONFIG ?? findConfigFile2();
-              const raw = readFileSync59(cfgPath, "utf8");
+              const raw = readFileSync60(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}
@@ -111384,7 +112268,7 @@ async function startGateway() {
                         return;
                       }
                     })();
-                    const resolvedAgentDirForBootCard = agentDir ?? join67(homedir19(), ".switchroom", "agents", agentSlug);
+                    const resolvedAgentDirForBootCard = agentDir ?? join68(homedir19(), ".switchroom", "agents", agentSlug);
                     const handle = await startBootCard(chatId, threadId, botApiForCard, {
                       agentName: agentDisplayName,
                       agentSlug,
@@ -111398,8 +112282,8 @@ async function startGateway() {
                       probeQuotaViaBroker: (t) => probeQuotaForBootCard(agentSlug, t),
                       tmuxSupervisor: process.env.SWITCHROOM_TMUX_SUPERVISOR === "1",
                       dockerMode: process.env.SWITCHROOM_RUNTIME === "docker",
-                      configSnapshotPath: join67(resolvedAgentDirForBootCard, ".config-snapshot.json"),
-                      bootCardStatePath: join67(resolvedAgentDirForBootCard, ".boot-card-msgid.json"),
+                      configSnapshotPath: join68(resolvedAgentDirForBootCard, ".config-snapshot.json"),
+                      bootCardStatePath: join68(resolvedAgentDirForBootCard, ".boot-card-msgid.json"),
                       floodStatePath: FLOOD_STATE_PATH,
                       ...updateOutcomeLine ? { updateOutcomeLine } : {}
                     }, ackMsgId);
@@ -111430,10 +112314,10 @@ async function startGateway() {
         try {
           const smAgentDir = resolveAgentDirFromEnv();
           if (smAgentDir) {
-            const activePath = join67(smAgentDir, ".active-session-model");
+            const activePath = join68(smAgentDir, ".active-session-model");
             if (existsSync57(activePath)) {
               try {
-                const launched = readFileSync59(activePath, "utf8").trim();
+                const launched = readFileSync60(activePath, "utf8").trim();
                 const configured = (() => {
                   const d = switchroomExecJson(["agent", "list"]);
                   const raw = d?.agents?.find((a) => a.name === getMyAgentName())?.model ?? null;
@@ -111466,29 +112350,29 @@ async function startGateway() {
                   deliverModelSwitchBootNotice({
                     ...modelBootCardDeps,
                     confirmation,
-                    hasSessionModelAlert: existsSync57(join67(smAgentDir, ".session-model-alert"))
+                    hasSessionModelAlert: existsSync57(join68(smAgentDir, ".session-model-alert"))
                   });
                 }
               } catch {}
             }
-            const activeEffortPath = join67(smAgentDir, ".active-session-effort");
+            const activeEffortPath = join68(smAgentDir, ".active-session-effort");
             if (existsSync57(activeEffortPath)) {
               try {
-                const launchedEffort = readFileSync59(activeEffortPath, "utf8").trim();
+                const launchedEffort = readFileSync60(activeEffortPath, "utf8").trim();
                 const configuredEffort = getConfiguredEffortForPersist();
                 sessionEffortOverride = launchedEffort.length > 0 && launchedEffort !== configuredEffort ? launchedEffort : null;
               } catch {}
             }
-            const alertPath = join67(smAgentDir, ".session-model-alert");
+            const alertPath = join68(smAgentDir, ".session-model-alert");
             if (existsSync57(alertPath)) {
               let alertText = null;
               try {
-                alertText = readFileSync59(alertPath, "utf8").trim();
+                alertText = readFileSync60(alertPath, "utf8").trim();
               } catch {
                 alertText = null;
               }
               try {
-                unlinkSync29(alertPath);
+                unlinkSync30(alertPath);
               } catch {}
               if (alertText && alertText.length > 0) {
                 const operators = loadAccess().allowFrom;
@@ -111609,12 +112493,12 @@ async function startGateway() {
               staleWorkerTtlMs: resolveInflightTerminalCapMs() + WORKER_FEED_STALE_TTL_MARGIN_MS,
               absoluteRowLifetimeCapMs: resolveInflightTerminalCapMs() * WORKER_FEED_ABSOLUTE_ROW_LIFETIME_CAP_MULTIPLE,
               groupMessageLifetimeCapMs: WORKER_FEED_GROUP_MESSAGE_LIFETIME_CAP_MS,
-              reconcilePin: ({ feedKey, chatId, messageId }) => {
+              reconcilePin: ({ feedKey, chatId, threadId, messageId }) => {
                 if (!PIN_STATUS_WHILE_WORKING)
                   return;
                 const key = `wk:group:${feedKey}`;
                 if (messageId != null) {
-                  reconcileStatusPin(key, chatId, { pinned: true, messageId });
+                  reconcileStatusPin(key, chatId, { pinned: true, messageId }, threadId);
                 } else {
                   const unpinChat = chatId || statusPinClaims.get(key)?.chatId;
                   if (unpinChat != null && unpinChat.length > 0) {
@@ -111667,7 +112551,7 @@ async function startGateway() {
 `);
                 }
               },
-              onFinish: ({ agentId, outcome, description, resultText, toolCount, totalTokens, durationMs, background: entryBackground }) => {
+              onFinish: ({ agentId, outcome, description: description2, resultText, toolCount, totalTokens, durationMs, background: entryBackground }) => {
                 workerFeedOriginDeferrals.delete(agentId);
                 deferredDoneReactions.promote();
                 let fleetChatId = "";
@@ -111680,10 +112564,10 @@ async function startGateway() {
                     }
                   }
                 } catch {}
-                let dispatch = resolveWorkerFeedDispatch(null, description, entryBackground);
+                let dispatch = resolveWorkerFeedDispatch(null, description2, entryBackground);
                 if (turnsDb != null) {
                   try {
-                    dispatch = resolveWorkerFeedDispatch(getSubagentByJsonlId(turnsDb, agentId), description, entryBackground);
+                    dispatch = resolveWorkerFeedDispatch(getSubagentByJsonlId(turnsDb, agentId), description2, entryBackground);
                   } catch {}
                 }
                 let isBackground = dispatch.isBackground;
@@ -111773,7 +112657,7 @@ async function startGateway() {
                   fleetChatId: handbackOrigin?.chatId || fleetChatId,
                   ...handbackOrigin?.threadId != null ? { originThreadId: handbackOrigin.threadId } : {},
                   ownerChatId: loadAccess().allowFrom[0] ?? "",
-                  taskDescription: description,
+                  taskDescription: description2,
                   resultText,
                   jsonlAgentId: agentId
                 });
@@ -111799,7 +112683,7 @@ async function startGateway() {
                 process.stderr.write(`telegram gateway: subagent-handback queued agent=${agentId} outcome=${outcome} chat=${decision.chatId} resultChars=${resultText.length}
 `);
               },
-              onProgress: ({ agentId, description, latestSummary, elapsedMs, prevBucketIdx, setBucketIdx, lastTool, toolCount, totalTokens, progressLine, model, skeleton }) => {
+              onProgress: ({ agentId, description: description2, latestSummary, elapsedMs, prevBucketIdx, setBucketIdx, lastTool, toolCount, totalTokens, progressLine, model, skeleton }) => {
                 let fleetChatId = "";
                 try {
                   const fleets = progressDriver?.peekAllFleets() ?? [];
@@ -111810,10 +112694,10 @@ async function startGateway() {
                     }
                   }
                 } catch {}
-                let dispatch = resolveWorkerFeedDispatch(null, description);
+                let dispatch = resolveWorkerFeedDispatch(null, description2);
                 if (turnsDb != null) {
                   try {
-                    dispatch = resolveWorkerFeedDispatch(getSubagentByJsonlId(turnsDb, agentId), description);
+                    dispatch = resolveWorkerFeedDispatch(getSubagentByJsonlId(turnsDb, agentId), description2);
                   } catch {}
                 }
                 const isBackground = dispatch.isBackground || dispatch.isNested;
@@ -111931,7 +112815,7 @@ async function startGateway() {
                   ...progressOrigin?.threadId != null ? { originThreadId: progressOrigin.threadId } : {},
                   ownerChatId: loadAccess().allowFrom[0] ?? "",
                   subagentJsonlId: agentId,
-                  taskDescription: description,
+                  taskDescription: description2,
                   latestSummary,
                   elapsedMs,
                   progressIntervalMs: DEFAULT_PROGRESS_INTERVAL_MS,