@integrity-labs/agt-cli 0.27.126 → 0.27.127

package/dist/bin/agt.js

@@ -28,7 +28,7 @@ import {
   success,
   table,
   warn
-} from "../chunk-LTZS7SHV.js";
+} from "../chunk-RKM5IRRT.js";
 import {
   CHANNEL_REGISTRY,
   DEPLOYMENT_TEMPLATES,
@@ -4934,7 +4934,7 @@ import { execFileSync, execSync } from "child_process";
 import { existsSync as existsSync10, realpathSync as realpathSync2 } from "fs";
 import chalk18 from "chalk";
 import ora16 from "ora";
-var cliVersion = true ? "0.27.126" : "dev";
+var cliVersion = true ? "0.27.127" : "dev";
 async function fetchLatestVersion() {
   const host2 = getHost();
   if (!host2) return null;
@@ -5857,7 +5857,7 @@ function handleError(err) {
 }
 
 // src/bin/agt.ts
-var cliVersion2 = true ? "0.27.126" : "dev";
+var cliVersion2 = true ? "0.27.127" : "dev";
 var program = new Command();
 program.name("agt").description("Augmented CLI \u2014 agent provisioning and management").version(cliVersion2).option("--json", "Emit machine-readable JSON output (suppress spinners and colors)").option("--skip-update-check", "Skip the automatic update check on startup");
 program.hook("preAction", async (thisCommand, actionCommand) => {

package/dist/{chunk-LTZS7SHV.js → chunk-RKM5IRRT.js}

@@ -7646,4 +7646,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-LTZS7SHV.js.map
+//# sourceMappingURL=chunk-RKM5IRRT.js.map

package/dist/lib/manager-worker.js

@@ -17,7 +17,7 @@ import {
   provisionStopHook,
   requireHost,
   safeWriteJsonAtomic
-} from "../chunk-LTZS7SHV.js";
+} from "../chunk-RKM5IRRT.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -4494,7 +4494,7 @@ var cachedMaintenanceWindow = null;
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.27.126" : "dev";
+var agtCliVersion = true ? "0.27.127" : "dev";
 function resolveBrewPath(execFileSync4) {
   try {
     const out = execFileSync4("which", ["brew"], { timeout: 5e3 }).toString().trim();

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;
       }

package/dist/mcp/telegram-channel.js

@@ -14180,6 +14180,47 @@ var Server = class extends Protocol {
   }
 };
 
+// src/restart-confirm.ts
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, 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 (!existsSync(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 (!existsSync(filePath)) return null;
+    const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+    if (!parsed || typeof parsed !== "object") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function clearRestartConfirmMarker(filePath) {
+  try {
+    if (existsSync(filePath)) unlinkSync(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";
 
@@ -14274,18 +14315,18 @@ var StdioServerTransport = class {
 
 // src/telegram-channel.ts
 import https from "https";
-import { createHash, randomUUID } from "crypto";
+import { createHash, randomUUID as randomUUID2 } from "crypto";
 import {
   createWriteStream,
-  existsSync as existsSync2,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync3,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync4,
   readdirSync as readdirSync2,
-  renameSync as renameSync3,
+  renameSync as renameSync4,
   statSync,
-  unlinkSync as unlinkSync3,
+  unlinkSync as unlinkSync4,
   watch,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join4 } from "path";
@@ -14412,7 +14453,7 @@ function redactAugmentedPaths(msg) {
 }
 
 // src/telegram-attachments.ts
-import { mkdirSync, writeFileSync, chmodSync, renameSync, unlinkSync } from "fs";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, chmodSync, renameSync as renameSync2, unlinkSync as unlinkSync2 } from "fs";
 function resolveTelegramInboundDir(codeName) {
   return resolveChannelInboundDir(codeName, "telegram-inbound");
 }
@@ -14501,18 +14542,18 @@ async function downloadTelegramFile(fileId, opts) {
   if (!isPathInside(savedPath, dir)) {
     throw new Error(`refusing to write ${savedPath} outside ${dir}`);
   }
-  mkdirSync(dir, { recursive: true });
+  mkdirSync2(dir, { recursive: true });
   const tempPath = `${savedPath}.${process.pid}.${Date.now()}.tmp`;
   try {
-    writeFileSync(tempPath, bytes, { mode: 384, flag: "wx" });
+    writeFileSync2(tempPath, bytes, { mode: 384, flag: "wx" });
     try {
       chmodSync(tempPath, 384);
     } catch {
     }
-    renameSync(tempPath, savedPath);
+    renameSync2(tempPath, savedPath);
   } catch (err) {
     try {
-      unlinkSync(tempPath);
+      unlinkSync2(tempPath);
     } catch {
     }
     throw err;
@@ -15733,12 +15774,12 @@ var TELEGRAM_EGRESS_TOOLS = /* @__PURE__ */ new Set([
 
 // src/mcp-spawn-lock.ts
 import {
-  existsSync,
-  mkdirSync as mkdirSync2,
-  readFileSync,
-  renameSync as renameSync2,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync2
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync2,
+  renameSync as renameSync3,
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync3
 } from "fs";
 import { join as join2 } from "path";
 function defaultIsPidAlive(pid) {
@@ -15768,11 +15809,11 @@ function acquireMcpSpawnLock(args) {
       return { kind: "blocked", path, holder: existing };
     }
   }
-  mkdirSync2(agentDir, { recursive: true, mode: 448 });
+  mkdirSync3(agentDir, { recursive: true, mode: 448 });
   const tmpPath = `${path}.${selfPid}.tmp`;
   const payload = { pid: selfPid, started_at: now() };
-  writeFileSync2(tmpPath, JSON.stringify(payload), { mode: 384 });
-  renameSync2(tmpPath, path);
+  writeFileSync3(tmpPath, JSON.stringify(payload), { mode: 384 });
+  renameSync3(tmpPath, path);
   return { kind: "acquired", path };
 }
 function releaseMcpSpawnLock(lockPath, opts = {}) {
@@ -15782,14 +15823,14 @@ function releaseMcpSpawnLock(lockPath, opts = {}) {
   if (!existing) return;
   if (existing.pid !== selfPid) return;
   try {
-    unlinkSync2(lockPath);
+    unlinkSync3(lockPath);
   } catch {
   }
 }
 function readLockHolder(path) {
-  if (!existsSync(path)) return null;
+  if (!existsSync2(path)) return null;
   try {
-    const raw = readFileSync(path, "utf8");
+    const raw = readFileSync2(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;
@@ -15801,7 +15842,7 @@ function readLockHolder(path) {
 }
 
 // src/ack-reaction.ts
-import { readdirSync, readFileSync as readFileSync2 } from "fs";
+import { readdirSync, readFileSync as readFileSync3 } from "fs";
 import { join as join3 } from "path";
 var REPLY_WEDGED_THRESHOLD_MS = 5 * 60 * 1e3;
 var ACK_STARTUP_GRACE_MS = 6e4;
@@ -15860,7 +15901,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(readFileSync2(path, "utf8"));
+    const raw = JSON.parse(readFileSync3(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;
@@ -15892,7 +15933,7 @@ function oldestPendingMarkerAgeMs(dir, now = Date.now()) {
     if (!name.endsWith(".json")) continue;
     let receivedAt;
     try {
-      const raw = JSON.parse(readFileSync2(join3(dir, name), "utf-8"));
+      const raw = JSON.parse(readFileSync3(join3(dir, name), "utf-8"));
       receivedAt = raw.received_at;
     } catch {
       continue;
@@ -16035,7 +16076,7 @@ var stderrLogStream = null;
 if (AGENT_CODE_NAME && AGENT_CODE_NAME !== "unknown") {
   try {
     const logDir = join4(homedir2(), ".augmented", AGENT_CODE_NAME);
-    mkdirSync3(logDir, { recursive: true });
+    mkdirSync4(logDir, { recursive: true });
     stderrLogStream = createWriteStream(join4(logDir, "telegram-channel-stderr.log"), {
       flags: "a",
       mode: 384
@@ -16249,6 +16290,66 @@ function __resetBusyAckNoticeThrottle() {
   lastBusyAckNoticeAt.clear();
 }
 var RESTART_FLAGS_DIR = join4(homedir2(), ".augmented", "restart-flags");
+function writeTelegramRestartConfirm(reply, requesterName) {
+  if (!RESTART_CONFIRM_FILE) return;
+  const marker = {
+    source: "telegram",
+    requested_at: Date.now(),
+    ...requesterName ? { requester_name: requesterName } : {},
+    reply
+  };
+  try {
+    writeRestartConfirmMarker(RESTART_CONFIRM_FILE, marker);
+  } catch (err) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): restart-confirm marker write failed: ${redactAugmentedPaths(err.message)}
+`
+    );
+  }
+}
+async function notifyRestartCompleteOnBoot() {
+  if (!RESTART_CONFIRM_FILE) return;
+  const marker = readRestartConfirmMarker(RESTART_CONFIRM_FILE);
+  if (!shouldPostRestartConfirm(marker, TELEGRAM_PROCESS_BOOT_MS, Date.now())) {
+    if (marker) clearRestartConfirmMarker(RESTART_CONFIRM_FILE);
+    return;
+  }
+  const chatId = marker.reply["chat_id"];
+  if (chatId == null) {
+    clearRestartConfirmMarker(RESTART_CONFIRM_FILE);
+    return;
+  }
+  const messageId = marker.reply["message_id"];
+  try {
+    const resp = await telegramApiCall(
+      "sendMessage",
+      {
+        chat_id: chatId,
+        text: buildBackOnlineText(marker.requester_name),
+        // Thread under the original /restart command when we have its id.
+        ...messageId != null ? { reply_to_message_id: Number(messageId), allow_sending_without_reply: true } : {}
+      },
+      1e4
+    );
+    if (resp.ok) {
+      clearRestartConfirmMarker(RESTART_CONFIRM_FILE);
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): posted back-online confirmation after restart
+`
+      );
+    } else {
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): back-online confirmation rejected (chat=${redactId(chatId)}): ${resp.description ?? "unknown"}
+`
+      );
+    }
+  } catch (err) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): back-online confirmation send failed: ${redactAugmentedPaths(err.message)}
+`
+    );
+  }
+}
 function buildTelegramHelpMessage(codeName) {
   return [
     `\u{1F916} *Available commands for \`${codeName}\`*`,
@@ -16286,19 +16387,23 @@ async function handleHelpCommand(opts) {
 }
 async function handleRestartCommand(opts) {
   try {
-    if (!existsSync2(RESTART_FLAGS_DIR)) {
-      mkdirSync3(RESTART_FLAGS_DIR, { recursive: true });
+    if (!existsSync3(RESTART_FLAGS_DIR)) {
+      mkdirSync4(RESTART_FLAGS_DIR, { recursive: true });
     }
     const flagPath = join4(RESTART_FLAGS_DIR, `${AGENT_CODE_NAME}.flag`);
+    writeTelegramRestartConfirm(
+      { chat_id: opts.chatId, message_id: opts.messageId },
+      opts.requesterName
+    );
     const flag = {
       codeName: AGENT_CODE_NAME,
       source: "telegram",
       ts: Date.now(),
       reply: { chat_id: opts.chatId, message_id: opts.messageId }
     };
-    const tmpPath = `${flagPath}.${process.pid}.${randomUUID()}.tmp`;
-    writeFileSync3(tmpPath, JSON.stringify(flag) + "\n", "utf8");
-    renameSync3(tmpPath, flagPath);
+    const tmpPath = `${flagPath}.${process.pid}.${randomUUID2()}.tmp`;
+    writeFileSync4(tmpPath, JSON.stringify(flag) + "\n", "utf8");
+    renameSync4(tmpPath, flagPath);
     process.stderr.write(
       `telegram-channel(${AGENT_CODE_NAME}): /restart queued from chat ${redactId(opts.chatId)}
 `
@@ -16663,6 +16768,8 @@ async function classifyRestartCommand(text) {
 var AGENT_DIR = AGENT_CODE_NAME && AGENT_CODE_NAME !== "unknown" ? join4(homedir2(), ".augmented", AGENT_CODE_NAME) : null;
 var PENDING_INBOUND_DIR = AGENT_DIR ? join4(AGENT_DIR, "telegram-pending-inbound") : null;
 var RECOVERY_OUTBOX_DIR = AGENT_DIR ? join4(AGENT_DIR, "telegram-recovery-outbox") : null;
+var RESTART_CONFIRM_FILE = AGENT_DIR ? join4(AGENT_DIR, "telegram-restart-confirm.json") : null;
+var TELEGRAM_PROCESS_BOOT_MS = Date.now();
 function safeMarkerName(chatId, messageId) {
   const safe = (s) => s.replace(/[^A-Za-z0-9_-]/g, "_");
   return `${safe(chatId)}__${safe(messageId)}.json`;
@@ -16686,8 +16793,8 @@ function writePendingInboundMarker(chatId, messageId, chatType, undeliverable =
     ...payload ? { payload } : {}
   };
   try {
-    mkdirSync3(PENDING_INBOUND_DIR, { recursive: true, mode: 448 });
-    writeFileSync3(path, JSON.stringify(marker), { mode: 384 });
+    mkdirSync4(PENDING_INBOUND_DIR, { recursive: true, mode: 448 });
+    writeFileSync4(path, JSON.stringify(marker), { mode: 384 });
   } catch (err) {
     process.stderr.write(
       `telegram-channel(${AGENT_CODE_NAME}): pending-inbound marker write failed: ${err.message}
@@ -16698,7 +16805,7 @@ function writePendingInboundMarker(chatId, messageId, chatType, undeliverable =
 function clearTelegramMarkerFileWithHeal(fullPath) {
   let marker = null;
   try {
-    marker = JSON.parse(readFileSync3(fullPath, "utf-8"));
+    marker = JSON.parse(readFileSync4(fullPath, "utf-8"));
   } catch {
   }
   if (marker && decideRecoveryHeal({
@@ -16708,7 +16815,7 @@ function clearTelegramMarkerFileWithHeal(fullPath) {
     notifyBackOnline(marker.chat_id);
   }
   try {
-    if (existsSync2(fullPath)) unlinkSync3(fullPath);
+    if (existsSync3(fullPath)) unlinkSync4(fullPath);
   } catch {
   }
 }
@@ -16719,9 +16826,9 @@ function clearPendingInboundMarker(chatId, messageId) {
 }
 function readPendingInboundMarker(chatId, messageId) {
   const path = pendingInboundPath(chatId, messageId);
-  if (!path || !existsSync2(path)) return null;
+  if (!path || !existsSync3(path)) return null;
   try {
-    return JSON.parse(readFileSync3(path, "utf-8"));
+    return JSON.parse(readFileSync4(path, "utf-8"));
   } catch {
     return null;
   }
@@ -16744,7 +16851,7 @@ async function processRecoveryOutboxFile(filename) {
   const fullPath = join4(RECOVERY_OUTBOX_DIR, filename);
   let payload;
   try {
-    const raw = readFileSync3(fullPath, "utf-8");
+    const raw = readFileSync4(fullPath, "utf-8");
     payload = JSON.parse(raw);
   } catch (err) {
     process.stderr.write(
@@ -16752,7 +16859,7 @@ async function processRecoveryOutboxFile(filename) {
 `
     );
     try {
-      renameSync3(fullPath, `${fullPath}.parse-error.poison`);
+      renameSync4(fullPath, `${fullPath}.parse-error.poison`);
     } catch {
     }
     return;
@@ -16763,7 +16870,7 @@ async function processRecoveryOutboxFile(filename) {
 `
     );
     try {
-      renameSync3(fullPath, `${fullPath}.malformed.poison`);
+      renameSync4(fullPath, `${fullPath}.malformed.poison`);
     } catch {
     }
     return;
@@ -16799,7 +16906,7 @@ async function processRecoveryOutboxFile(filename) {
   }
   if (sendSucceeded) {
     try {
-      unlinkSync3(fullPath);
+      unlinkSync4(fullPath);
     } catch {
     }
     return;
@@ -16807,7 +16914,7 @@ async function processRecoveryOutboxFile(filename) {
   const next = nextRetryName(filename);
   if (next) {
     try {
-      renameSync3(fullPath, join4(RECOVERY_OUTBOX_DIR, next.next));
+      renameSync4(fullPath, join4(RECOVERY_OUTBOX_DIR, next.next));
       if (next.attempt >= MAX_RECOVERY_ATTEMPTS) {
         process.stderr.write(
           `telegram-channel(${AGENT_CODE_NAME}): ghost-reply recovery exhausted retries \u2014 moved to ${next.next}
@@ -16859,7 +16966,7 @@ function scanRecoveryRetries() {
 function startRecoveryOutboxWatcher() {
   if (!RECOVERY_OUTBOX_DIR) return;
   try {
-    mkdirSync3(RECOVERY_OUTBOX_DIR, { recursive: true, mode: 448 });
+    mkdirSync4(RECOVERY_OUTBOX_DIR, { recursive: true, mode: 448 });
   } catch (err) {
     process.stderr.write(
       `telegram-channel(${AGENT_CODE_NAME}): recovery outbox mkdir failed: ${err.message}
@@ -16877,7 +16984,7 @@ function startRecoveryOutboxWatcher() {
     const watcher = watch(RECOVERY_OUTBOX_DIR, (event, filename) => {
       if (event !== "rename" || !filename) return;
       if (!isFirstAttemptOutboxFile(filename)) return;
-      if (existsSync2(join4(RECOVERY_OUTBOX_DIR, filename))) {
+      if (existsSync3(join4(RECOVERY_OUTBOX_DIR, filename))) {
         void processRecoveryOutboxFile(filename);
       }
     });
@@ -16898,7 +17005,7 @@ function trackPendingMessage(chatId, messageId, chatType, undeliverable = false,
 }
 function sweepTelegramStaleMarkers(thresholdMs) {
   if (!PENDING_INBOUND_DIR) return;
-  if (!existsSync2(PENDING_INBOUND_DIR)) return;
+  if (!existsSync3(PENDING_INBOUND_DIR)) return;
   let filenames;
   try {
     filenames = readdirSync2(PENDING_INBOUND_DIR);
@@ -16917,14 +17024,14 @@ function sweepTelegramStaleMarkers(thresholdMs) {
     const fullPath = join4(PENDING_INBOUND_DIR, filename);
     let marker;
     try {
-      marker = JSON.parse(readFileSync3(fullPath, "utf-8"));
+      marker = JSON.parse(readFileSync4(fullPath, "utf-8"));
     } catch (err) {
       process.stderr.write(
         `telegram-channel(${AGENT_CODE_NAME}): stale-marker parse failed for ${redactId(filename)}: ${err.message}
 `
       );
       try {
-        unlinkSync3(fullPath);
+        unlinkSync4(fullPath);
       } catch {
       }
       cleared++;
@@ -16933,7 +17040,7 @@ function sweepTelegramStaleMarkers(thresholdMs) {
     const { chat_id, message_id, received_at } = marker;
     if (!chat_id || !message_id || isPendingMarkerStale(received_at, now, thresholdMs)) {
       try {
-        unlinkSync3(fullPath);
+        unlinkSync4(fullPath);
       } catch {
       }
       cleared++;
@@ -16956,14 +17063,14 @@ var orphanSweepTimer = setInterval(() => {
 orphanSweepTimer.unref?.();
 var lastGiveUpHandledAtMs = null;
 function listPendingInboundChatIds() {
-  if (!PENDING_INBOUND_DIR || !existsSync2(PENDING_INBOUND_DIR)) return [];
+  if (!PENDING_INBOUND_DIR || !existsSync3(PENDING_INBOUND_DIR)) return [];
   const chats = /* @__PURE__ */ new Set();
   try {
     for (const name of readdirSync2(PENDING_INBOUND_DIR)) {
       if (!name.endsWith(".json")) continue;
       try {
         const marker = JSON.parse(
-          readFileSync3(join4(PENDING_INBOUND_DIR, name), "utf8")
+          readFileSync4(join4(PENDING_INBOUND_DIR, name), "utf8")
         );
         if (typeof marker.chat_id === "string" && marker.chat_id) chats.add(marker.chat_id);
       } catch {
@@ -17082,7 +17189,7 @@ function clearPendingMessage(chatId, messageId) {
     clearPendingInboundMarker(chatId, messageId);
     return;
   }
-  if (!PENDING_INBOUND_DIR || !existsSync2(PENDING_INBOUND_DIR)) return;
+  if (!PENDING_INBOUND_DIR || !existsSync3(PENDING_INBOUND_DIR)) return;
   const safeChatId = chatId.replace(/[^A-Za-z0-9_-]/g, "_");
   const prefix = `${safeChatId}__`;
   let filenames;
@@ -17693,7 +17800,7 @@ await mcp.connect(new StdioServerTransport());
 var REPLAY_SCAN_INTERVAL_MS = 6e4;
 async function replayPendingTelegramMarkers() {
   if (!channelReplayEnabled()) return;
-  if (!PENDING_INBOUND_DIR || !existsSync2(PENDING_INBOUND_DIR)) return;
+  if (!PENDING_INBOUND_DIR || !existsSync3(PENDING_INBOUND_DIR)) return;
   const probe = process.env.TMUX && AGENT_CODE_NAME && AGENT_CODE_NAME !== "unknown" ? probeAgentSessionCached(AGENT_CODE_NAME) : { tmux: "unknown", claude: "unknown" };
   const sessionAlive = probe.tmux === "alive" && probe.claude === "alive";
   if (!sessionAlive) return;
@@ -17710,7 +17817,7 @@ async function replayPendingTelegramMarkers() {
     const fullPath = join4(PENDING_INBOUND_DIR, name);
     let marker;
     try {
-      marker = JSON.parse(readFileSync3(fullPath, "utf-8"));
+      marker = JSON.parse(readFileSync4(fullPath, "utf-8"));
     } catch {
       continue;
     }
@@ -17742,12 +17849,12 @@ async function replayPendingTelegramMarkers() {
       continue;
     }
     try {
-      if (existsSync2(path)) {
+      if (existsSync3(path)) {
         const updated = {
           ...marker,
           replay_count: (marker.replay_count ?? 0) + 1
         };
-        writeFileSync3(path, JSON.stringify(updated), { mode: 384 });
+        writeFileSync4(path, JSON.stringify(updated), { mode: 384 });
       }
     } catch {
     }
@@ -17906,7 +18013,9 @@ async function pollLoop() {
           if (disposition === "act") {
             await handleRestartCommand({
               chatId,
-              messageId: String(msg.message_id)
+              messageId: String(msg.message_id),
+              // ENG-6194: first_name personalises the back-online confirmation.
+              requesterName: msg.from?.first_name?.trim() || void 0
             });
           } else if (disposition === "verification_failed") {
             try {
@@ -18229,6 +18338,7 @@ void (async () => {
     }
   }
 })();
+void notifyRestartCompleteOnBoot();
 pollLoop().catch((err) => {
   process.stderr.write(
     `telegram-channel(${AGENT_CODE_NAME}): poll loop died: ${err.message}

package/package.json

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