@integrity-labs/agt-cli 0.28.57 → 0.28.59

package/dist/mcp/telegram-channel.js

@@ -14221,6 +14221,156 @@ function clearRestartConfirmMarker(filePath) {
   }
 }
 
+// src/dm-restart-notice.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+var RECENT_DM_VERSION = 1;
+var DEFAULT_RECENT_DM_TTL_MS = 30 * 60 * 1e3;
+var DEFAULT_DM_NOTICE_WINDOW_MS = 5 * 60 * 1e3;
+var DEFAULT_MIN_INTERVAL_MS = 1e3;
+function recordDmActivity(map, dmKey, now = /* @__PURE__ */ new Date()) {
+  if (!dmKey) return;
+  map.set(dmKey, { last_activity_at: now.toISOString() });
+}
+function recentlyActiveDmKeys(map, now = /* @__PURE__ */ new Date(), windowMs = DEFAULT_DM_NOTICE_WINDOW_MS) {
+  const cutoff = now.getTime() - windowMs;
+  return [...map.entries()].map(([key2, e]) => ({ key: key2, ts: Date.parse(e.last_activity_at) })).filter(({ ts }) => Number.isFinite(ts) && ts >= cutoff).sort((a, b) => b.ts - a.ts).map(({ key: key2 }) => key2);
+}
+function serializeRecentDms(map) {
+  const out = { version: RECENT_DM_VERSION, dms: {} };
+  for (const [key2, e] of map) out.dms[key2] = e;
+  return JSON.stringify(out, null, 2);
+}
+function loadRecentDms(filePath, opts = {}) {
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const ttlMs = opts.ttlMs ?? DEFAULT_RECENT_DM_TTL_MS;
+  let raw;
+  try {
+    raw = readFileSync2(filePath, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") {
+      opts.onError?.(`dm-restart-notice: failed to read recent-DM file: ${err.message}`);
+    }
+    return /* @__PURE__ */ new Map();
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    opts.onError?.(`dm-restart-notice: malformed recent-DM JSON (${err.message}) \u2014 ignoring`);
+    return /* @__PURE__ */ new Map();
+  }
+  if (typeof parsed !== "object" || parsed === null || // CodeRabbit: reject unknown versions so a future/legacy on-disk format can't
+  // be read with this version's (possibly incompatible) semantics.
+  parsed.version !== RECENT_DM_VERSION || typeof parsed.dms !== "object" || parsed.dms === null) {
+    opts.onError?.("dm-restart-notice: unexpected recent-DM shape/version \u2014 ignoring");
+    return /* @__PURE__ */ new Map();
+  }
+  const map = /* @__PURE__ */ new Map();
+  const cutoff = now.getTime() - ttlMs;
+  for (const [key2, val] of Object.entries(parsed.dms)) {
+    const at = val?.last_activity_at;
+    if (typeof at !== "string") continue;
+    const ts = Date.parse(at);
+    if (!Number.isFinite(ts) || ts < cutoff) continue;
+    map.set(key2, { last_activity_at: at });
+  }
+  return map;
+}
+function createRecentDmPersister(opts) {
+  const interval = opts.minIntervalMs ?? DEFAULT_MIN_INTERVAL_MS;
+  let lastWriteAt = 0;
+  let pendingTimer = null;
+  let pendingSnapshot = null;
+  const writeNow = (snap) => {
+    try {
+      mkdirSync2(dirname2(opts.filePath), { recursive: true });
+      writeFileSync2(opts.filePath, serializeRecentDms(snap), "utf-8");
+      lastWriteAt = Date.now();
+    } catch (err) {
+      opts.onError?.(`dm-restart-notice: failed to persist recent-DMs: ${err.message}`);
+    }
+  };
+  return {
+    schedule(map) {
+      pendingSnapshot = new Map(map);
+      const sinceLast = Date.now() - lastWriteAt;
+      if (sinceLast >= interval) {
+        const snap = pendingSnapshot;
+        pendingSnapshot = null;
+        writeNow(snap);
+        return;
+      }
+      if (pendingTimer) return;
+      pendingTimer = setTimeout(() => {
+        pendingTimer = null;
+        const snap = pendingSnapshot;
+        pendingSnapshot = null;
+        if (snap) writeNow(snap);
+      }, interval - sinceLast);
+      pendingTimer.unref?.();
+    },
+    flush(map) {
+      if (pendingTimer) {
+        clearTimeout(pendingTimer);
+        pendingTimer = null;
+        pendingSnapshot = null;
+      }
+      writeNow(new Map(map));
+    },
+    dispose() {
+      if (pendingTimer) clearTimeout(pendingTimer);
+      pendingTimer = null;
+      pendingSnapshot = null;
+    }
+  };
+}
+var CHANNEL_ADD_RESTART_VERSION = 1;
+var CHANNEL_ADD_RESTART_MAX_AGE_MS = 15 * 60 * 1e3;
+function readChannelAddRestartMarker(filePath) {
+  let raw;
+  try {
+    raw = readFileSync2(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || parsed.version !== CHANNEL_ADD_RESTART_VERSION || typeof parsed.at !== "string") {
+      return null;
+    }
+    const rawAdded = parsed.added;
+    const added = Array.isArray(rawAdded) ? rawAdded.filter((x) => typeof x === "string") : [];
+    return { version: CHANNEL_ADD_RESTART_VERSION, at: parsed.at, added };
+  } catch {
+    return null;
+  }
+}
+function shouldPostChannelAddNotice(marker, bootMs, maxAgeMs = CHANNEL_ADD_RESTART_MAX_AGE_MS) {
+  if (!marker) return false;
+  const at = Date.parse(marker.at);
+  if (!Number.isFinite(at)) return false;
+  const age = bootMs - at;
+  return age <= maxAgeMs && age >= -6e4;
+}
+function clearChannelAddRestartMarker(filePath) {
+  try {
+    unlinkSync2(filePath);
+  } catch {
+  }
+}
+function buildChannelAddNoticeText(added) {
+  const list = added.filter(Boolean);
+  if (list.length === 1) {
+    return `Quick heads-up \u2014 I briefly restarted to bring a new channel (${list[0]}) online. I'm back now; please re-send anything I might have missed.`;
+  }
+  if (list.length > 1) {
+    return `Quick heads-up \u2014 I briefly restarted to bring new channels (${list.join(", ")}) online. I'm back now; please re-send anything I might have missed.`;
+  }
+  return `Quick heads-up \u2014 I briefly restarted to update my configuration. I'm back now; please re-send anything I might have missed.`;
+}
+
 // ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 import process2 from "process";
 
@@ -14321,15 +14471,15 @@ import {
   createWriteStream,
   existsSync as existsSync5,
   ftruncateSync,
-  mkdirSync as mkdirSync4,
+  mkdirSync as mkdirSync5,
   openSync,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   readdirSync as readdirSync3,
   renameSync as renameSync4,
   statSync as statSync2,
-  unlinkSync as unlinkSync4,
+  unlinkSync as unlinkSync5,
   watch,
-  writeFileSync as writeFileSync5,
+  writeFileSync as writeFileSync6,
   writeSync
 } from "fs";
 import { homedir as homedir3 } from "os";
@@ -14457,7 +14607,7 @@ function redactAugmentedPaths(msg) {
 }
 
 // src/telegram-attachments.ts
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, chmodSync, renameSync as renameSync2, unlinkSync as unlinkSync2 } from "fs";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3, chmodSync, renameSync as renameSync2, unlinkSync as unlinkSync3 } from "fs";
 function resolveTelegramInboundDir(codeName) {
   return resolveChannelInboundDir(codeName, "telegram-inbound");
 }
@@ -14546,10 +14696,10 @@ async function downloadTelegramFile(fileId, opts) {
   if (!isPathInside(savedPath, dir)) {
     throw new Error(`refusing to write ${savedPath} outside ${dir}`);
   }
-  mkdirSync2(dir, { recursive: true });
+  mkdirSync3(dir, { recursive: true });
   const tempPath = `${savedPath}.${process.pid}.${Date.now()}.tmp`;
   try {
-    writeFileSync2(tempPath, bytes, { mode: 384, flag: "wx" });
+    writeFileSync3(tempPath, bytes, { mode: 384, flag: "wx" });
     try {
       chmodSync(tempPath, 384);
     } catch {
@@ -14557,7 +14707,7 @@ async function downloadTelegramFile(fileId, opts) {
     renameSync2(tempPath, savedPath);
   } catch (err) {
     try {
-      unlinkSync2(tempPath);
+      unlinkSync3(tempPath);
     } catch {
     }
     throw err;
@@ -15483,7 +15633,7 @@ function buildCommandRegistrations() {
 }
 
 // src/agent-config-state.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
 import { join as join2 } from "path";
 var SESSION_STATE_FILENAME = "session-state.json";
 function readAgentSessionState(stateDir) {
@@ -15491,7 +15641,7 @@ function readAgentSessionState(stateDir) {
   const path = join2(stateDir, SESSION_STATE_FILENAME);
   if (!existsSync2(path)) return null;
   try {
-    const parsed = JSON.parse(readFileSync2(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync3(path, "utf-8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
     return parsed;
   } catch {
@@ -16005,11 +16155,11 @@ var TELEGRAM_EGRESS_TOOLS = /* @__PURE__ */ new Set([
 ]);
 
 // src/telegram-pending-inbound-cleanup.ts
-import { readdirSync, readFileSync as readFileSync3, statSync } from "fs";
+import { readdirSync, readFileSync as readFileSync4, statSync } from "fs";
 import { join as join3 } from "path";
 function markerArrivalMs(fullPath) {
   try {
-    const received = JSON.parse(readFileSync3(fullPath, "utf-8")).received_at;
+    const received = JSON.parse(readFileSync4(fullPath, "utf-8")).received_at;
     const parsed = received ? Date.parse(received) : Number.NaN;
     if (Number.isFinite(parsed)) return parsed;
   } catch {
@@ -16044,11 +16194,11 @@ function clearAllTelegramPendingMarkersForChat(pendingDir, chatId, clearMarkerFi
 // src/mcp-spawn-lock.ts
 import {
   existsSync as existsSync3,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync4,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync5,
   renameSync as renameSync3,
-  unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync3
+  unlinkSync as unlinkSync4,
+  writeFileSync as writeFileSync4
 } from "fs";
 import { join as join4 } from "path";
 function defaultIsPidAlive(pid) {
@@ -16078,10 +16228,10 @@ function acquireMcpSpawnLock(args) {
       return { kind: "blocked", path, holder: existing };
     }
   }
-  mkdirSync3(agentDir, { recursive: true, mode: 448 });
+  mkdirSync4(agentDir, { recursive: true, mode: 448 });
   const tmpPath = `${path}.${selfPid}.tmp`;
   const payload = { pid: selfPid, started_at: now() };
-  writeFileSync3(tmpPath, JSON.stringify(payload), { mode: 384 });
+  writeFileSync4(tmpPath, JSON.stringify(payload), { mode: 384 });
   renameSync3(tmpPath, path);
   return { kind: "acquired", path };
 }
@@ -16092,14 +16242,14 @@ function releaseMcpSpawnLock(lockPath, opts = {}) {
   if (!existing) return;
   if (existing.pid !== selfPid) return;
   try {
-    unlinkSync3(lockPath);
+    unlinkSync4(lockPath);
   } catch {
   }
 }
 function readLockHolder(path) {
   if (!existsSync3(path)) return null;
   try {
-    const raw = readFileSync4(path, "utf8");
+    const raw = readFileSync5(path, "utf8");
     const parsed = JSON.parse(raw);
     const pid = typeof parsed.pid === "number" ? parsed.pid : Number(parsed.pid);
     if (!Number.isFinite(pid) || pid <= 0) return null;
@@ -16111,11 +16261,11 @@ function readLockHolder(path) {
 }
 
 // src/ack-reaction.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
 import { join as join6 } from "path";
 
 // src/flags-cache-read.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync6 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join5 } from "path";
 function defaultFlagsCachePath() {
@@ -16132,7 +16282,7 @@ function envBoolean(raw) {
 function cachedBoolean(key2, path) {
   try {
     if (!existsSync4(path)) return void 0;
-    const parsed = JSON.parse(readFileSync5(path, "utf8"));
+    const parsed = JSON.parse(readFileSync6(path, "utf8"));
     if (!parsed || typeof parsed !== "object") return void 0;
     const flags = parsed.flags;
     if (!flags || typeof flags !== "object") return void 0;
@@ -16224,7 +16374,7 @@ var GIVE_UP_SIGNAL_MAX_AGE_MS = 30 * 60 * 1e3;
 function readGiveUpSignalAtMs(path, now = Date.now()) {
   if (!path) return null;
   try {
-    const raw = JSON.parse(readFileSync6(path, "utf8"));
+    const raw = JSON.parse(readFileSync7(path, "utf8"));
     if (typeof raw.gave_up_at !== "string") return null;
     const t = Date.parse(raw.gave_up_at);
     if (!Number.isFinite(t) || t > now) return null;
@@ -16256,7 +16406,7 @@ function oldestPendingMarkerAgeMs(dir, now = Date.now()) {
     if (!name.endsWith(".json")) continue;
     let receivedAt;
     try {
-      const raw = JSON.parse(readFileSync6(join6(dir, name), "utf-8"));
+      const raw = JSON.parse(readFileSync7(join6(dir, name), "utf-8"));
       if (raw.discretionary === true) continue;
       receivedAt = raw.received_at;
     } catch {
@@ -16288,8 +16438,11 @@ function orphanSweepIntervalMs() {
 }
 var MAX_MARKER_REPLAYS = 3;
 function channelReplayEnabled() {
-  const v = process.env.AGT_CHANNEL_REPLAY_ENABLED;
-  return v === "1" || v === "true";
+  return resolveHostBooleanFlag({
+    key: "channel-replay",
+    envVar: "AGT_CHANNEL_REPLAY_ENABLED",
+    defaultValue: false
+  });
 }
 function shouldReplayMarker(i) {
   if (!i.enabled) return false;
@@ -16314,13 +16467,13 @@ function recordChannelDeflection(agentDir, channel, cause) {
   const path = deflectionCounterPath(agentDir, channel);
   let counts = {};
   try {
-    const parsed = JSON.parse(readFileSync6(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync7(path, "utf-8"));
     if (parsed && typeof parsed === "object") counts = parsed;
   } catch {
   }
   counts[cause] = (counts[cause] ?? 0) + 1;
   try {
-    writeFileSync4(path, JSON.stringify(counts), { mode: 384 });
+    writeFileSync5(path, JSON.stringify(counts), { mode: 384 });
   } catch {
   }
 }
@@ -16457,7 +16610,7 @@ var stderrLogStream = null;
 if (AGENT_CODE_NAME && AGENT_CODE_NAME !== "unknown") {
   try {
     const logDir = join7(homedir3(), ".augmented", AGENT_CODE_NAME);
-    mkdirSync4(logDir, { recursive: true });
+    mkdirSync5(logDir, { recursive: true });
     stderrLogStream = createWriteStream(join7(logDir, "telegram-channel-stderr.log"), {
       flags: "a",
       mode: 384
@@ -16871,7 +17024,7 @@ async function handleStatusCommand(opts) {
 async function handleRestartCommand(opts) {
   try {
     if (!existsSync5(RESTART_FLAGS_DIR)) {
-      mkdirSync4(RESTART_FLAGS_DIR, { recursive: true });
+      mkdirSync5(RESTART_FLAGS_DIR, { recursive: true });
     }
     const flagPath = join7(RESTART_FLAGS_DIR, `${AGENT_CODE_NAME}.flag`);
     writeTelegramRestartConfirm(
@@ -16885,7 +17038,7 @@ async function handleRestartCommand(opts) {
       reply: { chat_id: opts.chatId, message_id: opts.messageId }
     };
     const tmpPath = `${flagPath}.${process.pid}.${randomUUID2()}.tmp`;
-    writeFileSync5(tmpPath, JSON.stringify(flag) + "\n", "utf8");
+    writeFileSync6(tmpPath, JSON.stringify(flag) + "\n", "utf8");
     renameSync4(tmpPath, flagPath);
     process.stderr.write(
       `telegram-channel(${AGENT_CODE_NAME}): /restart queued from chat ${redactId(opts.chatId)}
@@ -17261,6 +17414,56 @@ var PENDING_INBOUND_DIR = AGENT_DIR ? join7(AGENT_DIR, "telegram-pending-inbound
 var RECOVERY_OUTBOX_DIR = AGENT_DIR ? join7(AGENT_DIR, "telegram-recovery-outbox") : null;
 var RESTART_CONFIRM_FILE = AGENT_DIR ? join7(AGENT_DIR, "telegram-restart-confirm.json") : null;
 var TELEGRAM_PROCESS_BOOT_MS = Date.now();
+var TELEGRAM_RECENT_DMS_FILE = AGENT_DIR ? join7(AGENT_DIR, "telegram-recent-dms.json") : null;
+var TELEGRAM_CHANNEL_ADD_RESTART_FILE = AGENT_DIR ? join7(AGENT_DIR, "telegram-channel-add-restart.json") : null;
+var recentDms = /* @__PURE__ */ new Map();
+var recentDmPersister = TELEGRAM_RECENT_DMS_FILE ? createRecentDmPersister({
+  filePath: TELEGRAM_RECENT_DMS_FILE,
+  onError: (m) => process.stderr.write(`telegram-channel(${AGENT_CODE_NAME}): ${redactAugmentedPaths(m)}
+`)
+}) : null;
+if (TELEGRAM_RECENT_DMS_FILE) {
+  const loadedRecentDms = loadRecentDms(TELEGRAM_RECENT_DMS_FILE, {
+    onError: (m) => process.stderr.write(`telegram-channel(${AGENT_CODE_NAME}): ${redactAugmentedPaths(m)}
+`)
+  });
+  for (const [k, v] of loadedRecentDms) recentDms.set(k, v);
+}
+async function notifyDmUsersOnChannelAddRestart() {
+  if (!TELEGRAM_CHANNEL_ADD_RESTART_FILE) return;
+  const marker = readChannelAddRestartMarker(TELEGRAM_CHANNEL_ADD_RESTART_FILE);
+  if (!shouldPostChannelAddNotice(marker, TELEGRAM_PROCESS_BOOT_MS)) {
+    if (marker) clearChannelAddRestartMarker(TELEGRAM_CHANNEL_ADD_RESTART_FILE);
+    return;
+  }
+  const chats = recentlyActiveDmKeys(recentDms);
+  const text = buildChannelAddNoticeText(marker.added);
+  let notified = 0;
+  for (const chatId of chats) {
+    try {
+      const resp = await telegramApiCall("sendMessage", { chat_id: chatId, text }, 1e4);
+      if (resp.ok) notified += 1;
+      else {
+        process.stderr.write(
+          `telegram-channel(${AGENT_CODE_NAME}): channel-add DM notice rejected chat=${redactId(chatId)}: ${resp.description ?? "unknown"}
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): channel-add DM notice send failed: ${redactAugmentedPaths(err.message)}
+`
+      );
+    }
+  }
+  clearChannelAddRestartMarker(TELEGRAM_CHANNEL_ADD_RESTART_FILE);
+  if (notified > 0) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): notified ${notified} recently-active chat(s) after channel-add restart
+`
+    );
+  }
+}
 function safeMarkerName(chatId, messageId) {
   const safe = (s) => s.replace(/[^A-Za-z0-9_-]/g, "_");
   return `${safe(chatId)}__${safe(messageId)}.json`;
@@ -17284,8 +17487,8 @@ function writePendingInboundMarker(chatId, messageId, chatType, undeliverable =
     ...payload ? { payload } : {}
   };
   try {
-    mkdirSync4(PENDING_INBOUND_DIR, { recursive: true, mode: 448 });
-    writeFileSync5(path, JSON.stringify(marker), { mode: 384 });
+    mkdirSync5(PENDING_INBOUND_DIR, { recursive: true, mode: 448 });
+    writeFileSync6(path, JSON.stringify(marker), { mode: 384 });
   } catch (err) {
     process.stderr.write(
       `telegram-channel(${AGENT_CODE_NAME}): pending-inbound marker write failed: ${err.message}
@@ -17313,7 +17516,7 @@ function rewriteTelegramMarkerInPlace(path, marker) {
 function clearTelegramMarkerFileWithHeal(fullPath) {
   let marker = null;
   try {
-    marker = JSON.parse(readFileSync7(fullPath, "utf-8"));
+    marker = JSON.parse(readFileSync8(fullPath, "utf-8"));
   } catch {
   }
   if (marker && decideRecoveryHeal({
@@ -17323,7 +17526,7 @@ function clearTelegramMarkerFileWithHeal(fullPath) {
     notifyBackOnline(marker.chat_id);
   }
   try {
-    if (existsSync5(fullPath)) unlinkSync4(fullPath);
+    if (existsSync5(fullPath)) unlinkSync5(fullPath);
   } catch {
   }
 }
@@ -17331,7 +17534,7 @@ function readPendingInboundMarker(chatId, messageId) {
   const path = pendingInboundPath(chatId, messageId);
   if (!path || !existsSync5(path)) return null;
   try {
-    return JSON.parse(readFileSync7(path, "utf-8"));
+    return JSON.parse(readFileSync8(path, "utf-8"));
   } catch {
     return null;
   }
@@ -17354,7 +17557,7 @@ async function processRecoveryOutboxFile(filename) {
   const fullPath = join7(RECOVERY_OUTBOX_DIR, filename);
   let payload;
   try {
-    const raw = readFileSync7(fullPath, "utf-8");
+    const raw = readFileSync8(fullPath, "utf-8");
     payload = JSON.parse(raw);
   } catch (err) {
     process.stderr.write(
@@ -17412,7 +17615,7 @@ ${payload.text}`;
   }
   if (sendSucceeded) {
     try {
-      unlinkSync4(fullPath);
+      unlinkSync5(fullPath);
     } catch {
     }
     return;
@@ -17472,7 +17675,7 @@ function scanRecoveryRetries() {
 function startRecoveryOutboxWatcher() {
   if (!RECOVERY_OUTBOX_DIR) return;
   try {
-    mkdirSync4(RECOVERY_OUTBOX_DIR, { recursive: true, mode: 448 });
+    mkdirSync5(RECOVERY_OUTBOX_DIR, { recursive: true, mode: 448 });
   } catch (err) {
     process.stderr.write(
       `telegram-channel(${AGENT_CODE_NAME}): recovery outbox mkdir failed: ${err.message}
@@ -17530,14 +17733,14 @@ function sweepTelegramStaleMarkers(thresholdMs) {
     const fullPath = join7(PENDING_INBOUND_DIR, filename);
     let marker;
     try {
-      marker = JSON.parse(readFileSync7(fullPath, "utf-8"));
+      marker = JSON.parse(readFileSync8(fullPath, "utf-8"));
     } catch (err) {
       process.stderr.write(
         `telegram-channel(${AGENT_CODE_NAME}): stale-marker parse failed for ${redactId(filename)}: ${err.message}
 `
       );
       try {
-        unlinkSync4(fullPath);
+        unlinkSync5(fullPath);
       } catch {
       }
       cleared++;
@@ -17551,7 +17754,7 @@ function sweepTelegramStaleMarkers(thresholdMs) {
         recordChannelDeflection(AGENT_DIR, "telegram", "replay_orphaned");
       }
       try {
-        unlinkSync4(fullPath);
+        unlinkSync5(fullPath);
       } catch {
       }
       cleared++;
@@ -17581,7 +17784,7 @@ function listPendingInboundChatIds() {
       if (!name.endsWith(".json")) continue;
       try {
         const marker = JSON.parse(
-          readFileSync7(join7(PENDING_INBOUND_DIR, name), "utf8")
+          readFileSync8(join7(PENDING_INBOUND_DIR, name), "utf8")
         );
         if (typeof marker.chat_id === "string" && marker.chat_id) chats.add(marker.chat_id);
       } catch {
@@ -18329,7 +18532,7 @@ async function replayPendingTelegramMarkers() {
     const fullPath = join7(PENDING_INBOUND_DIR, name);
     let marker;
     try {
-      marker = JSON.parse(readFileSync7(fullPath, "utf-8"));
+      marker = JSON.parse(readFileSync8(fullPath, "utf-8"));
     } catch {
       continue;
     }
@@ -18572,6 +18775,11 @@ async function pollLoop() {
           );
           continue;
         }
+        if (msg.chat.type === "private" && !isFromBot && chatId) {
+          recordDmActivity(recentDms, String(chatId));
+          if (isShuttingDown) recentDmPersister?.flush(recentDms);
+          else recentDmPersister?.schedule(recentDms);
+        }
         observedChatClient?.observe({
           chat_id: chatId,
           chat_title: msg.chat.title ?? msg.chat.username ?? msg.chat.first_name ?? null,
@@ -18877,6 +19085,14 @@ function shutdown(reason) {
     `telegram-channel(${AGENT_CODE_NAME}): ${reason} \u2014 exiting
 `
   );
+  try {
+    recentDmPersister?.flush(recentDms);
+  } catch {
+  }
+  try {
+    recentDmPersister?.dispose();
+  } catch {
+  }
   try {
     releaseMcpSpawnLock(acquiredLockPath);
   } catch {
@@ -18926,6 +19142,7 @@ void (async () => {
   }
 })();
 void notifyRestartCompleteOnBoot();
+void notifyDmUsersOnChannelAddRestart();
 pollLoop().catch((err) => {
   process.stderr.write(
     `telegram-channel(${AGENT_CODE_NAME}): poll loop died: ${err.message}

package/dist/{persistent-session-INTCKEG6.js → persistent-session-42V6NGMR.js}

@@ -25,8 +25,8 @@ import {
   takeZombieDetection,
   writeDirectChatSessionState,
   writePersistentClaudeWrapper
-} from "./chunk-MKKTPM6J.js";
-import "./chunk-SJRG5VUF.js";
+} from "./chunk-UA3LEZL4.js";
+import "./chunk-OEZEWEEG.js";
 import "./chunk-XWVM4KPK.js";
 export {
   SEND_KEYS_ENTER_DELAY_MS,
@@ -56,4 +56,4 @@ export {
   writeDirectChatSessionState,
   writePersistentClaudeWrapper
 };
-//# sourceMappingURL=persistent-session-INTCKEG6.js.map
+//# sourceMappingURL=persistent-session-42V6NGMR.js.map

package/dist/{responsiveness-probe-XAYQAVLV.js → responsiveness-probe-YSSYWWTG.js}

@@ -1,7 +1,7 @@
 import {
   paneLogPath
-} from "./chunk-MKKTPM6J.js";
-import "./chunk-SJRG5VUF.js";
+} from "./chunk-UA3LEZL4.js";
+import "./chunk-OEZEWEEG.js";
 import "./chunk-XWVM4KPK.js";
 
 // src/lib/responsiveness-probe.ts
@@ -250,4 +250,4 @@ export {
   parkPendingInbound,
   readAndResetChannelDeflections
 };
-//# sourceMappingURL=responsiveness-probe-XAYQAVLV.js.map
+//# sourceMappingURL=responsiveness-probe-YSSYWWTG.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@integrity-labs/agt-cli",
-  "version": "0.28.57",
+  "version": "0.28.59",
   "description": "Augmented Team CLI — agent provisioning and management",
   "type": "module",
   "engines": {