@integrity-labs/agt-cli 0.28.57 → 0.28.58

package/dist/mcp/slack-channel.js

@@ -15448,15 +15448,15 @@ import {
   createWriteStream,
   existsSync as existsSync7,
   ftruncateSync,
-  mkdirSync as mkdirSync5,
+  mkdirSync as mkdirSync6,
   openSync,
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync9,
   readdirSync as readdirSync3,
   renameSync as renameSync3,
   statSync as statSync2,
-  unlinkSync as unlinkSync4,
+  unlinkSync as unlinkSync5,
   watch,
-  writeFileSync as writeFileSync6,
+  writeFileSync as writeFileSync7,
   writeSync
 } from "fs";
 import { basename, join as join7, resolve as resolve2 } from "path";
@@ -15575,6 +15575,156 @@ function isThreadEntry(value) {
   return (v.involvement === "started" || v.involvement === "mentioned") && typeof v.last_seen_at === "string";
 }
 
+// src/dm-restart-notice.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync6, unlinkSync as unlinkSync3, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname3 } 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_MS2 = 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 = readFileSync6(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_MS2;
+  let lastWriteAt = 0;
+  let pendingTimer = null;
+  let pendingSnapshot = null;
+  const writeNow = (snap) => {
+    try {
+      mkdirSync3(dirname3(opts.filePath), { recursive: true });
+      writeFileSync4(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 = readFileSync6(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 {
+    unlinkSync3(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.`;
+}
+
 // src/safe-async.ts
 async function runOrRetry(fn, opts) {
   try {
@@ -15593,8 +15743,8 @@ async function runOrRetry(fn, opts) {
 }
 
 // src/slack-bot-photo.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname3 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname4 } from "path";
 async function applyBotPhoto(opts) {
   const fetchImpl = opts.fetchImpl ?? fetch;
   const log = opts.log ?? ((m) => {
@@ -15603,7 +15753,7 @@ async function applyBotPhoto(opts) {
   const { token, avatarUrl, markerPath } = opts;
   if (markerPath && existsSync5(markerPath)) {
     try {
-      if (readFileSync6(markerPath, "utf-8").trim() === avatarUrl) {
+      if (readFileSync7(markerPath, "utf-8").trim() === avatarUrl) {
         return { status: "skipped-unchanged" };
       }
     } catch {
@@ -15644,8 +15794,8 @@ async function applyBotPhoto(opts) {
     }
     if (markerPath) {
       try {
-        mkdirSync3(dirname3(markerPath), { recursive: true, mode: 448 });
-        writeFileSync4(markerPath, avatarUrl, { mode: 384 });
+        mkdirSync4(dirname4(markerPath), { recursive: true, mode: 448 });
+        writeFileSync5(markerPath, avatarUrl, { mode: 384 });
       } catch {
       }
     }
@@ -16428,11 +16578,11 @@ function createSlackBotUserIdClient(args) {
 // src/mcp-spawn-lock.ts
 import {
   existsSync as existsSync6,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync7,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync8,
   renameSync as renameSync2,
-  unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync5
+  unlinkSync as unlinkSync4,
+  writeFileSync as writeFileSync6
 } from "fs";
 import { join as join6 } from "path";
 function defaultIsPidAlive(pid) {
@@ -16462,10 +16612,10 @@ function acquireMcpSpawnLock(args) {
       return { kind: "blocked", path, holder: existing };
     }
   }
-  mkdirSync4(agentDir, { recursive: true, mode: 448 });
+  mkdirSync5(agentDir, { recursive: true, mode: 448 });
   const tmpPath = `${path}.${selfPid}.tmp`;
   const payload = { pid: selfPid, started_at: now() };
-  writeFileSync5(tmpPath, JSON.stringify(payload), { mode: 384 });
+  writeFileSync6(tmpPath, JSON.stringify(payload), { mode: 384 });
   renameSync2(tmpPath, path);
   return { kind: "acquired", path };
 }
@@ -16476,14 +16626,14 @@ function releaseMcpSpawnLock(lockPath, opts = {}) {
   if (!existing) return;
   if (existing.pid !== selfPid) return;
   try {
-    unlinkSync3(lockPath);
+    unlinkSync4(lockPath);
   } catch {
   }
 }
 function readLockHolder(path) {
   if (!existsSync6(path)) return null;
   try {
-    const raw = readFileSync7(path, "utf8");
+    const raw = readFileSync8(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;
@@ -16672,7 +16822,7 @@ function readLiveAllowedUsers() {
       return liveAllowedUsersCache.value;
     }
     const value = extractAllowedUsersFromMcpJson(
-      readFileSync8(SLACK_MCP_CONFIG_PATH, "utf-8")
+      readFileSync9(SLACK_MCP_CONFIG_PATH, "utf-8")
     );
     if (value === null) return null;
     liveAllowedUsersCache = { mtimeMs, value };
@@ -16687,6 +16837,8 @@ function getEffectiveAllowedUsers() {
 var SLACK_PENDING_INBOUND_DIR = SLACK_AGENT_DIR ? join7(SLACK_AGENT_DIR, "slack-pending-inbound") : null;
 var SLACK_RECOVERY_OUTBOX_DIR = SLACK_AGENT_DIR ? join7(SLACK_AGENT_DIR, "slack-recovery-outbox") : null;
 var SLACK_RESTART_CONFIRM_FILE = SLACK_AGENT_DIR ? join7(SLACK_AGENT_DIR, "slack-restart-confirm.json") : null;
+var SLACK_RECENT_DMS_FILE = SLACK_AGENT_DIR ? join7(SLACK_AGENT_DIR, "slack-recent-dms.json") : null;
+var SLACK_CHANNEL_ADD_RESTART_FILE = SLACK_AGENT_DIR ? join7(SLACK_AGENT_DIR, "slack-channel-add-restart.json") : null;
 var SLACK_MAX_RECOVERY_ATTEMPTS = 3;
 var SLACK_AVATAR_MARKER_PATH = SLACK_AGENT_DIR ? join7(SLACK_AGENT_DIR, "slack-avatar-applied") : null;
 function redactSlackId(id) {
@@ -16717,8 +16869,8 @@ function writeSlackPendingInboundMarker(channel, threadTs, messageTs, undelivera
     ...payload ? { payload } : {}
   };
   try {
-    mkdirSync5(SLACK_PENDING_INBOUND_DIR, { recursive: true, mode: 448 });
-    writeFileSync6(path, JSON.stringify(marker), { mode: 384 });
+    mkdirSync6(SLACK_PENDING_INBOUND_DIR, { recursive: true, mode: 448 });
+    writeFileSync7(path, JSON.stringify(marker), { mode: 384 });
   } catch (err) {
     process.stderr.write(
       `slack-channel(${AGENT_CODE_NAME}): pending-inbound marker write failed: ${err.message}
@@ -16748,7 +16900,7 @@ function attachSlackReplayPayload(channel, threadTs, messageTs, payload) {
   if (!path) return;
   let marker;
   try {
-    marker = JSON.parse(readFileSync8(path, "utf-8"));
+    marker = JSON.parse(readFileSync9(path, "utf-8"));
   } catch {
     return;
   }
@@ -16759,7 +16911,7 @@ function readSlackPendingInboundMarker(channel, threadTs, messageTs) {
   const path = slackPendingInboundPath(channel, threadTs, messageTs);
   if (!path || !existsSync7(path)) return null;
   try {
-    return JSON.parse(readFileSync8(path, "utf-8"));
+    return JSON.parse(readFileSync9(path, "utf-8"));
   } catch {
     return null;
   }
@@ -16887,7 +17039,7 @@ function __resetSlackBusyAckNoticeThrottle() {
 function clearSlackMarkerFileWithHeal(fullPath) {
   let marker = null;
   try {
-    marker = JSON.parse(readFileSync8(fullPath, "utf-8"));
+    marker = JSON.parse(readFileSync9(fullPath, "utf-8"));
   } catch {
   }
   if (marker && decideRecoveryHeal({
@@ -16897,7 +17049,7 @@ function clearSlackMarkerFileWithHeal(fullPath) {
     healSlackUndeliverable(marker.channel, marker.message_ts);
   }
   try {
-    if (existsSync7(fullPath)) unlinkSync4(fullPath);
+    if (existsSync7(fullPath)) unlinkSync5(fullPath);
   } catch {
   }
 }
@@ -16941,7 +17093,7 @@ async function processSlackRecoveryOutboxFile(filename) {
   const fullPath = join7(SLACK_RECOVERY_OUTBOX_DIR, filename);
   let payload;
   try {
-    payload = JSON.parse(readFileSync8(fullPath, "utf-8"));
+    payload = JSON.parse(readFileSync9(fullPath, "utf-8"));
   } catch (err) {
     process.stderr.write(
       `slack-channel(${AGENT_CODE_NAME}): recovery outbox parse failed (${filename}): ${err.message}
@@ -17009,7 +17161,7 @@ ${payload.text}`;
   }
   if (sendSucceeded) {
     try {
-      unlinkSync4(fullPath);
+      unlinkSync5(fullPath);
     } catch {
     }
     return;
@@ -17068,7 +17220,7 @@ function scanSlackRecoveryRetries() {
 function startSlackRecoveryOutboxWatcher() {
   if (!SLACK_RECOVERY_OUTBOX_DIR) return;
   try {
-    mkdirSync5(SLACK_RECOVERY_OUTBOX_DIR, { recursive: true, mode: 448 });
+    mkdirSync6(SLACK_RECOVERY_OUTBOX_DIR, { recursive: true, mode: 448 });
   } catch (err) {
     process.stderr.write(
       `slack-channel(${AGENT_CODE_NAME}): recovery outbox mkdir failed: ${err.message}
@@ -17127,14 +17279,14 @@ function sweepSlackStaleMarkers(thresholdMs) {
     const fullPath = join7(SLACK_PENDING_INBOUND_DIR, filename);
     let marker;
     try {
-      marker = JSON.parse(readFileSync8(fullPath, "utf-8"));
+      marker = JSON.parse(readFileSync9(fullPath, "utf-8"));
     } catch (err) {
       process.stderr.write(
         `slack-channel(${AGENT_CODE_NAME}): stale-marker parse failed for ${redactSlackId(filename)}: ${err.message}
 `
       );
       try {
-        unlinkSync4(fullPath);
+        unlinkSync5(fullPath);
       } catch {
       }
       cleared++;
@@ -17149,7 +17301,7 @@ function sweepSlackStaleMarkers(thresholdMs) {
         recordChannelDeflection(SLACK_AGENT_DIR, "slack", "replay_orphaned");
       }
       try {
-        unlinkSync4(fullPath);
+        unlinkSync5(fullPath);
       } catch {
       }
       cleared++;
@@ -17179,7 +17331,7 @@ function listPendingSlackConversations() {
       if (!name.endsWith(".json")) continue;
       try {
         const marker = JSON.parse(
-          readFileSync8(join7(SLACK_PENDING_INBOUND_DIR, name), "utf8")
+          readFileSync9(join7(SLACK_PENDING_INBOUND_DIR, name), "utf8")
         );
         if (typeof marker.channel !== "string" || !marker.channel) continue;
         if (typeof marker.thread_ts !== "string" || !marker.thread_ts) continue;
@@ -17273,7 +17425,7 @@ async function notifyStrandedInboundsOnFirstConnect() {
       const fullPath = join7(SLACK_PENDING_INBOUND_DIR, filename);
       let marker;
       try {
-        marker = JSON.parse(readFileSync8(fullPath, "utf-8"));
+        marker = JSON.parse(readFileSync9(fullPath, "utf-8"));
       } catch {
         continue;
       }
@@ -17286,7 +17438,7 @@ async function notifyStrandedInboundsOnFirstConnect() {
       const key2 = `${channel}__${thread_ts}`;
       if (seen.has(key2)) {
         try {
-          unlinkSync4(fullPath);
+          unlinkSync5(fullPath);
         } catch {
         }
         continue;
@@ -17300,7 +17452,7 @@ async function notifyStrandedInboundsOnFirstConnect() {
       if (res.ok) {
         notified += 1;
         try {
-          unlinkSync4(fullPath);
+          unlinkSync5(fullPath);
         } catch {
         }
       } else {
@@ -17372,6 +17524,49 @@ async function notifyRestartCompleteOnFirstConnect() {
     restartConfirmNoticeInFlight = false;
   }
 }
+var dmChannelAddNoticeFired = false;
+var dmChannelAddNoticeInFlight = false;
+async function notifyDmUsersOnChannelAddRestart() {
+  if (dmChannelAddNoticeFired || dmChannelAddNoticeInFlight) return;
+  if (!SLACK_CHANNEL_ADD_RESTART_FILE) return;
+  dmChannelAddNoticeInFlight = true;
+  try {
+    const marker = readChannelAddRestartMarker(SLACK_CHANNEL_ADD_RESTART_FILE);
+    if (!shouldPostChannelAddNotice(marker, SLACK_PROCESS_BOOT_MS)) {
+      if (marker) clearChannelAddRestartMarker(SLACK_CHANNEL_ADD_RESTART_FILE);
+      return;
+    }
+    const dmChannels = recentlyActiveDmKeys(recentDms);
+    const text = buildChannelAddNoticeText(marker.added);
+    let notified = 0;
+    for (const channel of dmChannels) {
+      const res = await postSlackMessage({ channel, text });
+      if (res.ok) {
+        notified += 1;
+      } else {
+        process.stderr.write(
+          `slack-channel(${AGENT_CODE_NAME}): channel-add DM notice failed channel=${redactSlackId(channel)} error=${res.error}
+`
+        );
+      }
+    }
+    clearChannelAddRestartMarker(SLACK_CHANNEL_ADD_RESTART_FILE);
+    if (notified > 0) {
+      process.stderr.write(
+        `slack-channel(${AGENT_CODE_NAME}): notified ${notified} recently-active DM(s) after channel-add restart
+`
+      );
+    }
+  } catch (err) {
+    process.stderr.write(
+      `slack-channel(${AGENT_CODE_NAME}): channel-add DM notice threw: ${redactAugmentedPaths2(err.message)}
+`
+    );
+  } finally {
+    dmChannelAddNoticeFired = true;
+    dmChannelAddNoticeInFlight = false;
+  }
+}
 function writeSlackRestartConfirm(reply, requesterName) {
   if (!SLACK_RESTART_CONFIRM_FILE) return;
   const marker = {
@@ -17806,7 +18001,7 @@ async function handleSlashCommandEnvelope(payload) {
     }
     try {
       if (!existsSync7(RESTART_FLAGS_DIR)) {
-        mkdirSync5(RESTART_FLAGS_DIR, { recursive: true });
+        mkdirSync6(RESTART_FLAGS_DIR, { recursive: true });
       }
       const flagPath = join7(RESTART_FLAGS_DIR, `${codeName}.flag`);
       writeSlackRestartConfirm(
@@ -17826,7 +18021,7 @@ async function handleSlashCommandEnvelope(payload) {
         }
       };
       const tmpPath = `${flagPath}.${process.pid}.${randomUUID2()}.tmp`;
-      writeFileSync6(tmpPath, JSON.stringify(flag) + "\n", "utf8");
+      writeFileSync7(tmpPath, JSON.stringify(flag) + "\n", "utf8");
       renameSync3(tmpPath, flagPath);
       process.stderr.write(
         `slack-channel(${codeName}): /restart slash-command queued from channel ${hashChannelId(payload.channel_id)}
@@ -17968,7 +18163,7 @@ async function handleRestartCommand(opts) {
   const codeName = AGENT_CODE_NAME ?? "unknown";
   try {
     if (!existsSync7(RESTART_FLAGS_DIR)) {
-      mkdirSync5(RESTART_FLAGS_DIR, { recursive: true });
+      mkdirSync6(RESTART_FLAGS_DIR, { recursive: true });
     }
     const flagPath = join7(RESTART_FLAGS_DIR, `${codeName}.flag`);
     writeSlackRestartConfirm(
@@ -17989,7 +18184,7 @@ async function handleRestartCommand(opts) {
       }
     };
     const tmpPath = `${flagPath}.${process.pid}.${randomUUID2()}.tmp`;
-    writeFileSync6(tmpPath, JSON.stringify(flag) + "\n", "utf8");
+    writeFileSync7(tmpPath, JSON.stringify(flag) + "\n", "utf8");
     renameSync3(tmpPath, flagPath);
     process.stderr.write(
       `slack-channel(${codeName}): /restart queued from channel ${hashChannelId(opts.channel)}
@@ -18085,6 +18280,8 @@ async function denyUnauthorizedWatch(opts) {
     ...opts.threadTs ? { thread_ts: opts.threadTs } : {}
   });
 }
+var recentDms = /* @__PURE__ */ new Map();
+var recentDmPersister = null;
 var trackedThreads = /* @__PURE__ */ new Map();
 var THREAD_STORE_PATH = resolveThreadStorePath();
 var THREAD_STORE_TTL_DAYS = parseTtlDays(process.env.SLACK_THREAD_FOLLOW_TTL_DAYS);
@@ -18131,7 +18328,7 @@ var slackStderrLogStream = null;
 if (AGENT_CODE_NAME) {
   try {
     const logDir = join7(homedir3(), ".augmented", AGENT_CODE_NAME);
-    mkdirSync5(logDir, { recursive: true });
+    mkdirSync6(logDir, { recursive: true });
     slackStderrLogStream = createWriteStream(join7(logDir, "slack-channel-stderr.log"), {
       flags: "a",
       mode: 384
@@ -18712,7 +18909,7 @@ ${result.formatted}` : "Thread is empty or not found."
         };
       }
       size = stat2.size;
-      bytes = readFileSync8(resolvedPath);
+      bytes = readFileSync9(resolvedPath);
     } catch (err) {
       return {
         content: [{ type: "text", text: `Failed to read file: ${err.message}` }],
@@ -19350,8 +19547,8 @@ async function downloadSlackFile(fileId, codeName) {
   if (!isPathInside(savedPath, dir)) {
     throw new Error(`refusing to write ${savedPath} outside ${dir}`);
   }
-  mkdirSync5(dir, { recursive: true });
-  writeFileSync6(savedPath, bytes, { mode: 384 });
+  mkdirSync6(dir, { recursive: true });
+  writeFileSync7(savedPath, bytes, { mode: 384 });
   try {
     chmodSync(savedPath, 384);
   } catch {
@@ -19430,7 +19627,7 @@ async function replayPendingSlackMarkers() {
     const fullPath = join7(SLACK_PENDING_INBOUND_DIR, name);
     let marker;
     try {
-      marker = JSON.parse(readFileSync8(fullPath, "utf-8"));
+      marker = JSON.parse(readFileSync9(fullPath, "utf-8"));
     } catch {
       continue;
     }
@@ -19557,6 +19754,7 @@ async function connectSocketMode() {
       void notifyStrandedInboundsOnFirstConnect();
     }
     void notifyRestartCompleteOnFirstConnect();
+    void notifyDmUsersOnChannelAddRestart();
     void applyBotPhotoOnFirstConnect();
   };
   ws.onmessage = async (event) => {
@@ -19754,6 +19952,14 @@ async function connectSocketMode() {
       const isThreadReply = !!evt.thread_ts && evt.thread_ts !== evt.ts;
       const trackTs = evt.thread_ts ?? evt.ts ?? "";
       const threadKey = buildThreadKey(evt.channel, trackTs);
+      if (isDirectMessage && !isBot && evt.channel && evt.user && evt.user !== botUserId) {
+        recordDmActivity(recentDms, evt.channel);
+        if (isShuttingDown) {
+          recentDmPersister?.flush(recentDms);
+        } else {
+          recentDmPersister?.schedule(recentDms);
+        }
+      }
       if (isBot && peerClassification?.kind === "peer-ingress") {
         const peerGate = peerClassification.peer.gate_path;
         if (peerGate === "intra_org_unrestricted") {
@@ -19989,6 +20195,14 @@ function shutdown(reason, exitCode = 0) {
     threadPersister?.dispose();
   } catch {
   }
+  try {
+    recentDmPersister?.flush(recentDms);
+  } catch {
+  }
+  try {
+    recentDmPersister?.dispose();
+  } catch {
+  }
   process.stderr.write(`slack-channel: ${reason} \u2014 closing Socket Mode and exiting
 `);
   try {
@@ -20032,7 +20246,12 @@ process.on("unhandledRejection", (reason) => {
 }
 if (THREAD_STORE_PATH) {
   const threadStoreLabel = "slack-tracked-threads.json";
-  const redact = (msg) => msg.replaceAll(THREAD_STORE_PATH, threadStoreLabel);
+  const recentDmsLabel = "slack-recent-dms.json";
+  const redact = (msg) => {
+    let out = msg.replaceAll(THREAD_STORE_PATH, threadStoreLabel);
+    if (SLACK_RECENT_DMS_FILE) out = out.replaceAll(SLACK_RECENT_DMS_FILE, recentDmsLabel);
+    return out;
+  };
   const { threads, pruned } = loadThreadStore(THREAD_STORE_PATH, {
     ttlDays: THREAD_STORE_TTL_DAYS,
     onError: (msg) => process.stderr.write(`${redact(msg)}
@@ -20048,6 +20267,18 @@ if (THREAD_STORE_PATH) {
     `slack-channel: hydrated ${trackedThreads.size} tracked thread(s)${pruned > 0 ? ` (pruned ${pruned} stale)` : ""} from ${threadStoreLabel}
 `
   );
+  if (SLACK_RECENT_DMS_FILE) {
+    const loadedDms = loadRecentDms(SLACK_RECENT_DMS_FILE, {
+      onError: (msg) => process.stderr.write(`${redact(msg)}
+`)
+    });
+    for (const [key2, entry] of loadedDms) recentDms.set(key2, entry);
+    recentDmPersister = createRecentDmPersister({
+      filePath: SLACK_RECENT_DMS_FILE,
+      onError: (msg) => process.stderr.write(`${redact(msg)}
+`)
+    });
+  }
 } else {
   process.stderr.write(
     "slack-channel: AGT_AGENT_CODE_NAME not set \u2014 running without thread-follow persistence\n"