@integrity-labs/agt-cli 0.27.125 → 0.27.127

package/dist/mcp/slack-channel.js

@@ -14974,6 +14974,47 @@ function clearOldestSlackPendingMarkerInChannel(dir, channel, clear = defaultCle
   }
 }
 
+// src/restart-confirm.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, renameSync, unlinkSync as unlinkSync2, writeFileSync } from "fs";
+import { dirname } from "path";
+import { randomUUID } from "crypto";
+var RESTART_CONFIRM_MAX_AGE_MS = 10 * 60 * 1e3;
+function shouldPostRestartConfirm(marker, processBootMs, nowMs) {
+  if (!marker) return false;
+  const requestedAt = marker.requested_at;
+  if (typeof requestedAt !== "number" || !Number.isFinite(requestedAt)) return false;
+  if (requestedAt >= processBootMs) return false;
+  if (nowMs - requestedAt > RESTART_CONFIRM_MAX_AGE_MS) return false;
+  return true;
+}
+function buildBackOnlineText(name) {
+  const trimmed = typeof name === "string" ? name.trim() : "";
+  return trimmed ? `Hey ${trimmed}, I'm back online after my restart. \u{1F7E2}` : `I'm back online after my restart. \u{1F7E2}`;
+}
+function writeRestartConfirmMarker(filePath, marker) {
+  const dir = dirname(filePath);
+  if (!existsSync2(dir)) mkdirSync(dir, { recursive: true, mode: 448 });
+  const tmpPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  writeFileSync(tmpPath, JSON.stringify(marker) + "\n", { encoding: "utf8", mode: 384 });
+  renameSync(tmpPath, filePath);
+}
+function readRestartConfirmMarker(filePath) {
+  try {
+    if (!existsSync2(filePath)) return null;
+    const parsed = JSON.parse(readFileSync2(filePath, "utf8"));
+    if (!parsed || typeof parsed !== "object") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function clearRestartConfirmMarker(filePath) {
+  try {
+    if (existsSync2(filePath)) unlinkSync2(filePath);
+  } catch {
+  }
+}
+
 // ../../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";
 
@@ -15070,23 +15111,23 @@ var StdioServerTransport = class {
 import {
   chmodSync,
   createWriteStream,
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync5,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync6,
   readdirSync as readdirSync3,
-  renameSync as renameSync2,
+  renameSync as renameSync3,
   statSync as statSync2,
-  unlinkSync as unlinkSync3,
+  unlinkSync as unlinkSync4,
   watch,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync5
 } from "fs";
 import { basename, join as join5, resolve as resolve2 } from "path";
 import { homedir as homedir2 } from "os";
-import { createHash, randomUUID } from "crypto";
+import { createHash, randomUUID as randomUUID2 } from "crypto";
 
 // src/slack-thread-store.ts
-import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { dirname } from "path";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2 } from "path";
 var FILE_VERSION = 1;
 var DEFAULT_TTL_DAYS = 30;
 var DEFAULT_MIN_INTERVAL_MS = 1e3;
@@ -15096,7 +15137,7 @@ function loadThreadStore(filePath, opts = {}) {
   const ttlMs = ttlDays * 24 * 60 * 60 * 1e3;
   let raw;
   try {
-    raw = readFileSync2(filePath, "utf-8");
+    raw = readFileSync3(filePath, "utf-8");
   } catch {
     return { threads: /* @__PURE__ */ new Map(), pruned: 0 };
   }
@@ -15140,8 +15181,8 @@ function createThreadPersister(opts) {
   let pendingSnapshot = null;
   const writeNow = (snap) => {
     try {
-      mkdirSync(dirname(opts.filePath), { recursive: true });
-      writeFileSync(opts.filePath, serializeThreadStore(snap), "utf-8");
+      mkdirSync2(dirname2(opts.filePath), { recursive: true });
+      writeFileSync2(opts.filePath, serializeThreadStore(snap), "utf-8");
       lastWriteAt = Date.now();
     } catch (err) {
       opts.onError?.(
@@ -15210,17 +15251,17 @@ async function runOrRetry(fn, opts) {
 }
 
 // src/slack-bot-photo.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3 } from "path";
 async function applyBotPhoto(opts) {
   const fetchImpl = opts.fetchImpl ?? fetch;
   const log = opts.log ?? ((m) => {
     process.stderr.write(m);
   });
   const { token, avatarUrl, markerPath } = opts;
-  if (markerPath && existsSync2(markerPath)) {
+  if (markerPath && existsSync3(markerPath)) {
     try {
-      if (readFileSync3(markerPath, "utf-8").trim() === avatarUrl) {
+      if (readFileSync4(markerPath, "utf-8").trim() === avatarUrl) {
         return { status: "skipped-unchanged" };
       }
     } catch {
@@ -15261,8 +15302,8 @@ async function applyBotPhoto(opts) {
     }
     if (markerPath) {
       try {
-        mkdirSync2(dirname2(markerPath), { recursive: true, mode: 448 });
-        writeFileSync2(markerPath, avatarUrl, { mode: 384 });
+        mkdirSync3(dirname3(markerPath), { recursive: true, mode: 448 });
+        writeFileSync3(markerPath, avatarUrl, { mode: 384 });
       } catch {
       }
     }
@@ -16000,12 +16041,12 @@ function createSlackBotUserIdClient(args) {
 
 // src/mcp-spawn-lock.ts
 import {
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync4,
-  renameSync,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync3
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync5,
+  renameSync as renameSync2,
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync4
 } from "fs";
 import { join as join4 } from "path";
 function defaultIsPidAlive(pid) {
@@ -16035,11 +16076,11 @@ 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 });
-  renameSync(tmpPath, path);
+  writeFileSync4(tmpPath, JSON.stringify(payload), { mode: 384 });
+  renameSync2(tmpPath, path);
   return { kind: "acquired", path };
 }
 function releaseMcpSpawnLock(lockPath, opts = {}) {
@@ -16049,14 +16090,14 @@ function releaseMcpSpawnLock(lockPath, opts = {}) {
   if (!existing) return;
   if (existing.pid !== selfPid) return;
   try {
-    unlinkSync2(lockPath);
+    unlinkSync3(lockPath);
   } catch {
   }
 }
 function readLockHolder(path) {
-  if (!existsSync3(path)) return null;
+  if (!existsSync4(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;
@@ -16237,6 +16278,7 @@ var SLACK_PEER_CLASSIFIER_CONFIG = {
 var SLACK_AGENT_DIR = AGENT_CODE_NAME ? join5(homedir2(), ".augmented", AGENT_CODE_NAME) : null;
 var SLACK_PENDING_INBOUND_DIR = SLACK_AGENT_DIR ? join5(SLACK_AGENT_DIR, "slack-pending-inbound") : null;
 var SLACK_RECOVERY_OUTBOX_DIR = SLACK_AGENT_DIR ? join5(SLACK_AGENT_DIR, "slack-recovery-outbox") : null;
+var SLACK_RESTART_CONFIRM_FILE = SLACK_AGENT_DIR ? join5(SLACK_AGENT_DIR, "slack-restart-confirm.json") : null;
 var SLACK_MAX_RECOVERY_ATTEMPTS = 3;
 var SLACK_AVATAR_MARKER_PATH = SLACK_AGENT_DIR ? join5(SLACK_AGENT_DIR, "slack-avatar-applied") : null;
 function redactSlackId(id) {
@@ -16263,8 +16305,8 @@ function writeSlackPendingInboundMarker(channel, threadTs, messageTs, undelivera
     ...undeliverable ? { undeliverable: true } : {}
   };
   try {
-    mkdirSync4(SLACK_PENDING_INBOUND_DIR, { recursive: true, mode: 448 });
-    writeFileSync4(path, JSON.stringify(marker), { mode: 384 });
+    mkdirSync5(SLACK_PENDING_INBOUND_DIR, { recursive: true, mode: 448 });
+    writeFileSync5(path, JSON.stringify(marker), { mode: 384 });
   } catch (err) {
     process.stderr.write(
       `slack-channel(${AGENT_CODE_NAME}): pending-inbound marker write failed: ${err.message}
@@ -16274,9 +16316,9 @@ function writeSlackPendingInboundMarker(channel, threadTs, messageTs, undelivera
 }
 function readSlackPendingInboundMarker(channel, threadTs, messageTs) {
   const path = slackPendingInboundPath(channel, threadTs, messageTs);
-  if (!path || !existsSync4(path)) return null;
+  if (!path || !existsSync5(path)) return null;
   try {
-    return JSON.parse(readFileSync5(path, "utf-8"));
+    return JSON.parse(readFileSync6(path, "utf-8"));
   } catch {
     return null;
   }
@@ -16395,7 +16437,7 @@ function __resetSlackBusyAckNoticeThrottle() {
 function clearSlackMarkerFileWithHeal(fullPath) {
   let marker = null;
   try {
-    marker = JSON.parse(readFileSync5(fullPath, "utf-8"));
+    marker = JSON.parse(readFileSync6(fullPath, "utf-8"));
   } catch {
   }
   if (marker && decideRecoveryHeal({
@@ -16405,7 +16447,7 @@ function clearSlackMarkerFileWithHeal(fullPath) {
     healSlackUndeliverable(marker.channel, marker.message_ts);
   }
   try {
-    if (existsSync4(fullPath)) unlinkSync3(fullPath);
+    if (existsSync5(fullPath)) unlinkSync4(fullPath);
   } catch {
   }
 }
@@ -16449,14 +16491,14 @@ async function processSlackRecoveryOutboxFile(filename) {
   const fullPath = join5(SLACK_RECOVERY_OUTBOX_DIR, filename);
   let payload;
   try {
-    payload = JSON.parse(readFileSync5(fullPath, "utf-8"));
+    payload = JSON.parse(readFileSync6(fullPath, "utf-8"));
   } catch (err) {
     process.stderr.write(
       `slack-channel(${AGENT_CODE_NAME}): recovery outbox parse failed (${filename}): ${err.message}
 `
     );
     try {
-      renameSync2(fullPath, `${fullPath}.parse-error.poison`);
+      renameSync3(fullPath, `${fullPath}.parse-error.poison`);
     } catch {
     }
     return;
@@ -16467,7 +16509,7 @@ async function processSlackRecoveryOutboxFile(filename) {
 `
     );
     try {
-      renameSync2(fullPath, `${fullPath}.malformed.poison`);
+      renameSync3(fullPath, `${fullPath}.malformed.poison`);
     } catch {
     }
     return;
@@ -16515,7 +16557,7 @@ async function processSlackRecoveryOutboxFile(filename) {
   }
   if (sendSucceeded) {
     try {
-      unlinkSync3(fullPath);
+      unlinkSync4(fullPath);
     } catch {
     }
     return;
@@ -16523,7 +16565,7 @@ async function processSlackRecoveryOutboxFile(filename) {
   const next = slackNextRetryName(filename);
   if (next) {
     try {
-      renameSync2(fullPath, join5(SLACK_RECOVERY_OUTBOX_DIR, next.next));
+      renameSync3(fullPath, join5(SLACK_RECOVERY_OUTBOX_DIR, next.next));
       if (next.attempt >= SLACK_MAX_RECOVERY_ATTEMPTS) {
         process.stderr.write(
           `slack-channel(${AGENT_CODE_NAME}): ghost-reply recovery exhausted retries \u2014 moved to ${next.next}
@@ -16574,7 +16616,7 @@ function scanSlackRecoveryRetries() {
 function startSlackRecoveryOutboxWatcher() {
   if (!SLACK_RECOVERY_OUTBOX_DIR) return;
   try {
-    mkdirSync4(SLACK_RECOVERY_OUTBOX_DIR, { recursive: true, mode: 448 });
+    mkdirSync5(SLACK_RECOVERY_OUTBOX_DIR, { recursive: true, mode: 448 });
   } catch (err) {
     process.stderr.write(
       `slack-channel(${AGENT_CODE_NAME}): recovery outbox mkdir failed: ${err.message}
@@ -16592,7 +16634,7 @@ function startSlackRecoveryOutboxWatcher() {
     const watcher = watch(SLACK_RECOVERY_OUTBOX_DIR, (event, filename) => {
       if (event !== "rename" || !filename) return;
       if (!isFirstAttemptSlackOutboxFile(filename)) return;
-      if (existsSync4(join5(SLACK_RECOVERY_OUTBOX_DIR, filename))) {
+      if (existsSync5(join5(SLACK_RECOVERY_OUTBOX_DIR, filename))) {
         void processSlackRecoveryOutboxFile(filename);
       }
     });
@@ -16613,7 +16655,7 @@ function trackPendingMessage(channel, threadTs, messageTs, undeliverable = false
 }
 function sweepSlackStaleMarkers(thresholdMs) {
   if (!SLACK_PENDING_INBOUND_DIR) return;
-  if (!existsSync4(SLACK_PENDING_INBOUND_DIR)) return;
+  if (!existsSync5(SLACK_PENDING_INBOUND_DIR)) return;
   let filenames;
   try {
     filenames = readdirSync3(SLACK_PENDING_INBOUND_DIR);
@@ -16632,14 +16674,14 @@ function sweepSlackStaleMarkers(thresholdMs) {
     const fullPath = join5(SLACK_PENDING_INBOUND_DIR, filename);
     let marker;
     try {
-      marker = JSON.parse(readFileSync5(fullPath, "utf-8"));
+      marker = JSON.parse(readFileSync6(fullPath, "utf-8"));
     } catch (err) {
       process.stderr.write(
         `slack-channel(${AGENT_CODE_NAME}): stale-marker parse failed for ${redactSlackId(filename)}: ${err.message}
 `
       );
       try {
-        unlinkSync3(fullPath);
+        unlinkSync4(fullPath);
       } catch {
       }
       cleared++;
@@ -16648,7 +16690,7 @@ function sweepSlackStaleMarkers(thresholdMs) {
     const { channel, thread_ts, message_ts, received_at } = marker;
     if (!channel || !thread_ts || !message_ts || isPendingMarkerStale(received_at, now, thresholdMs)) {
       try {
-        unlinkSync3(fullPath);
+        unlinkSync4(fullPath);
       } catch {
       }
       cleared++;
@@ -16671,14 +16713,14 @@ var slackOrphanSweepTimer = setInterval(() => {
 slackOrphanSweepTimer.unref?.();
 var lastSlackGiveUpHandledAtMs = null;
 function listPendingSlackConversations() {
-  if (!SLACK_PENDING_INBOUND_DIR || !existsSync4(SLACK_PENDING_INBOUND_DIR)) return [];
+  if (!SLACK_PENDING_INBOUND_DIR || !existsSync5(SLACK_PENDING_INBOUND_DIR)) return [];
   const byKey = /* @__PURE__ */ new Map();
   try {
     for (const name of readdirSync3(SLACK_PENDING_INBOUND_DIR)) {
       if (!name.endsWith(".json")) continue;
       try {
         const marker = JSON.parse(
-          readFileSync5(join5(SLACK_PENDING_INBOUND_DIR, name), "utf8")
+          readFileSync6(join5(SLACK_PENDING_INBOUND_DIR, name), "utf8")
         );
         if (typeof marker.channel !== "string" || !marker.channel) continue;
         if (typeof marker.thread_ts !== "string" || !marker.thread_ts) continue;
@@ -16755,7 +16797,7 @@ async function notifyStrandedInboundsOnFirstConnect() {
   strandedInboundNoticeInFlight = true;
   let hadFailure = false;
   try {
-    if (!SLACK_PENDING_INBOUND_DIR || !existsSync4(SLACK_PENDING_INBOUND_DIR)) return;
+    if (!SLACK_PENDING_INBOUND_DIR || !existsSync5(SLACK_PENDING_INBOUND_DIR)) return;
     let filenames;
     try {
       filenames = readdirSync3(SLACK_PENDING_INBOUND_DIR);
@@ -16771,7 +16813,7 @@ async function notifyStrandedInboundsOnFirstConnect() {
       const fullPath = join5(SLACK_PENDING_INBOUND_DIR, filename);
       let marker;
       try {
-        marker = JSON.parse(readFileSync5(fullPath, "utf-8"));
+        marker = JSON.parse(readFileSync6(fullPath, "utf-8"));
       } catch {
         continue;
       }
@@ -16784,7 +16826,7 @@ async function notifyStrandedInboundsOnFirstConnect() {
       const key2 = `${channel}__${thread_ts}`;
       if (seen.has(key2)) {
         try {
-          unlinkSync3(fullPath);
+          unlinkSync4(fullPath);
         } catch {
         }
         continue;
@@ -16798,7 +16840,7 @@ async function notifyStrandedInboundsOnFirstConnect() {
       if (res.ok) {
         notified += 1;
         try {
-          unlinkSync3(fullPath);
+          unlinkSync4(fullPath);
         } catch {
         }
       } else {
@@ -16820,6 +16862,73 @@ async function notifyStrandedInboundsOnFirstConnect() {
     strandedInboundNoticeInFlight = false;
   }
 }
+var restartConfirmNoticeFired = false;
+var restartConfirmNoticeInFlight = false;
+var firstConnectNoticesGated = false;
+var suppressStrandedForBoot = false;
+async function notifyRestartCompleteOnFirstConnect() {
+  if (restartConfirmNoticeFired || restartConfirmNoticeInFlight) return;
+  if (!SLACK_RESTART_CONFIRM_FILE) return;
+  restartConfirmNoticeInFlight = true;
+  let hadFailure = false;
+  try {
+    const marker = readRestartConfirmMarker(SLACK_RESTART_CONFIRM_FILE);
+    if (!shouldPostRestartConfirm(marker, SLACK_PROCESS_BOOT_MS, Date.now())) {
+      if (marker) clearRestartConfirmMarker(SLACK_RESTART_CONFIRM_FILE);
+      return;
+    }
+    const channel = marker.reply["channel"];
+    if (channel == null) {
+      clearRestartConfirmMarker(SLACK_RESTART_CONFIRM_FILE);
+      return;
+    }
+    const threadTs = marker.reply["thread_ts"];
+    const res = await postSlackMessage({
+      channel: String(channel),
+      ...threadTs != null ? { thread_ts: String(threadTs) } : {},
+      text: buildBackOnlineText(marker.requester_name)
+    });
+    if (res.ok) {
+      clearRestartConfirmMarker(SLACK_RESTART_CONFIRM_FILE);
+      process.stderr.write(
+        `slack-channel(${AGENT_CODE_NAME}): posted back-online confirmation after restart
+`
+      );
+    } else {
+      hadFailure = true;
+      process.stderr.write(
+        `slack-channel(${AGENT_CODE_NAME}): back-online confirmation failed: ${res.error}
+`
+      );
+    }
+  } catch (err) {
+    hadFailure = true;
+    process.stderr.write(
+      `slack-channel(${AGENT_CODE_NAME}): back-online confirmation threw: ${redactAugmentedPaths2(err.message)}
+`
+    );
+  } finally {
+    if (!hadFailure) restartConfirmNoticeFired = true;
+    restartConfirmNoticeInFlight = false;
+  }
+}
+function writeSlackRestartConfirm(reply, requesterName) {
+  if (!SLACK_RESTART_CONFIRM_FILE) return;
+  const marker = {
+    source: "slack",
+    requested_at: Date.now(),
+    ...requesterName ? { requester_name: requesterName } : {},
+    reply
+  };
+  try {
+    writeRestartConfirmMarker(SLACK_RESTART_CONFIRM_FILE, marker);
+  } catch (err) {
+    process.stderr.write(
+      `slack-channel(${AGENT_CODE_NAME}): restart-confirm marker write failed: ${redactAugmentedPaths2(err.message)}
+`
+    );
+  }
+}
 function clearPendingMessage(channel, threadTs) {
   clearAllSlackPendingMarkersForThread2(channel, threadTs);
 }
@@ -16831,7 +16940,7 @@ function noteThreadActivityByMessageTs(channel, messageTs) {
   if (!channel || !messageTs) return;
   clearPendingMessage(channel, messageTs);
   if (!SLACK_PENDING_INBOUND_DIR) return;
-  if (!existsSync4(SLACK_PENDING_INBOUND_DIR)) return;
+  if (!existsSync5(SLACK_PENDING_INBOUND_DIR)) return;
   let filenames;
   try {
     filenames = readdirSync3(SLACK_PENDING_INBOUND_DIR);
@@ -17231,10 +17340,17 @@ async function handleSlashCommandEnvelope(payload) {
       return;
     }
     try {
-      if (!existsSync4(RESTART_FLAGS_DIR)) {
-        mkdirSync4(RESTART_FLAGS_DIR, { recursive: true });
+      if (!existsSync5(RESTART_FLAGS_DIR)) {
+        mkdirSync5(RESTART_FLAGS_DIR, { recursive: true });
       }
       const flagPath = join5(RESTART_FLAGS_DIR, `${codeName}.flag`);
+      writeSlackRestartConfirm(
+        {
+          channel: payload.channel_id,
+          ...payload.thread_ts ? { thread_ts: payload.thread_ts } : {}
+        },
+        payload.user_name
+      );
       const flag = {
         codeName,
         source: "slack",
@@ -17244,9 +17360,9 @@ async function handleSlashCommandEnvelope(payload) {
           ...payload.thread_ts ? { thread_ts: payload.thread_ts } : {}
         }
       };
-      const tmpPath = `${flagPath}.${process.pid}.${randomUUID()}.tmp`;
-      writeFileSync4(tmpPath, JSON.stringify(flag) + "\n", "utf8");
-      renameSync2(tmpPath, flagPath);
+      const tmpPath = `${flagPath}.${process.pid}.${randomUUID2()}.tmp`;
+      writeFileSync5(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)}
 `
@@ -17342,10 +17458,17 @@ async function handleHelpCommand(opts) {
 async function handleRestartCommand(opts) {
   const codeName = AGENT_CODE_NAME ?? "unknown";
   try {
-    if (!existsSync4(RESTART_FLAGS_DIR)) {
-      mkdirSync4(RESTART_FLAGS_DIR, { recursive: true });
+    if (!existsSync5(RESTART_FLAGS_DIR)) {
+      mkdirSync5(RESTART_FLAGS_DIR, { recursive: true });
     }
     const flagPath = join5(RESTART_FLAGS_DIR, `${codeName}.flag`);
+    writeSlackRestartConfirm(
+      {
+        channel: opts.channel,
+        ...opts.threadTs ? { thread_ts: opts.threadTs } : {}
+      },
+      opts.requesterName
+    );
     const flag = {
       codeName,
       source: "slack",
@@ -17356,9 +17479,9 @@ async function handleRestartCommand(opts) {
         message_ts: opts.ts
       }
     };
-    const tmpPath = `${flagPath}.${process.pid}.${randomUUID()}.tmp`;
-    writeFileSync4(tmpPath, JSON.stringify(flag) + "\n", "utf8");
-    renameSync2(tmpPath, flagPath);
+    const tmpPath = `${flagPath}.${process.pid}.${randomUUID2()}.tmp`;
+    writeFileSync5(tmpPath, JSON.stringify(flag) + "\n", "utf8");
+    renameSync3(tmpPath, flagPath);
     process.stderr.write(
       `slack-channel(${codeName}): /restart queued from channel ${hashChannelId(opts.channel)}
 `
@@ -17440,7 +17563,7 @@ var slackStderrLogStream = null;
 if (AGENT_CODE_NAME) {
   try {
     const logDir = join5(homedir2(), ".augmented", AGENT_CODE_NAME);
-    mkdirSync4(logDir, { recursive: true });
+    mkdirSync5(logDir, { recursive: true });
     slackStderrLogStream = createWriteStream(join5(logDir, "slack-channel-stderr.log"), {
       flags: "a",
       mode: 384
@@ -18015,7 +18138,7 @@ ${result.formatted}` : "Thread is empty or not found."
         };
       }
       size = stat2.size;
-      bytes = readFileSync5(resolvedPath);
+      bytes = readFileSync6(resolvedPath);
     } catch (err) {
       return {
         content: [{ type: "text", text: `Failed to read file: ${err.message}` }],
@@ -18653,8 +18776,8 @@ async function downloadSlackFile(fileId, codeName) {
   if (!isPathInside(savedPath, dir)) {
     throw new Error(`refusing to write ${savedPath} outside ${dir}`);
   }
-  mkdirSync4(dir, { recursive: true });
-  writeFileSync4(savedPath, bytes, { mode: 384 });
+  mkdirSync5(dir, { recursive: true });
+  writeFileSync5(savedPath, bytes, { mode: 384 });
   try {
     chmodSync(savedPath, 384);
   } catch {
@@ -18765,7 +18888,18 @@ async function connectSocketMode() {
     process.stderr.write("slack-channel: Socket Mode connected\n");
     recordActivity("connect");
     void setBotStatus(":large_green_circle:", "Active");
-    void notifyStrandedInboundsOnFirstConnect();
+    if (!firstConnectNoticesGated) {
+      firstConnectNoticesGated = true;
+      suppressStrandedForBoot = SLACK_RESTART_CONFIRM_FILE != null && shouldPostRestartConfirm(
+        readRestartConfirmMarker(SLACK_RESTART_CONFIRM_FILE),
+        SLACK_PROCESS_BOOT_MS,
+        Date.now()
+      );
+    }
+    if (!suppressStrandedForBoot) {
+      void notifyStrandedInboundsOnFirstConnect();
+    }
+    void notifyRestartCompleteOnFirstConnect();
     void applyBotPhotoOnFirstConnect();
   };
   ws.onmessage = async (event) => {
@@ -18878,13 +19012,16 @@ async function connectSocketMode() {
           });
           return;
         }
+        const resolvedName = await resolveUserName(evt.user);
+        const requesterName = resolvedName && resolvedName !== evt.user ? resolvedName : void 0;
         await handleRestartCommand({
           channel: evt.channel ?? "",
           // Only carry thread_ts when the originating message was already
           // threaded; a top-level command acks in-channel rather than
           // synthesising a brand-new thread (CodeRabbit feedback).
           threadTs: evt.thread_ts,
-          ts: evt.ts ?? ""
+          ts: evt.ts ?? "",
+          requesterName
         });
         return;
       }