@integrity-labs/agt-cli 0.27.125 → 0.27.127

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/dist/{persistent-session-YWGDREIZ.js → persistent-session-PJQZYG2L.js}

@@ -25,8 +25,8 @@ import {
   takeAcpxExecFailureCount,
   takeZombieDetection,
   writePersistentClaudeWrapper
-} from "./chunk-AZEYTJ4L.js";
-import "./chunk-Z6JJRLHH.js";
+} from "./chunk-QON5CU3L.js";
+import "./chunk-MH7HA6QV.js";
 import "./chunk-XWVM4KPK.js";
 export {
   SEND_KEYS_ENTER_DELAY_MS,
@@ -56,4 +56,4 @@ export {
   takeZombieDetection,
   writePersistentClaudeWrapper
 };
-//# sourceMappingURL=persistent-session-YWGDREIZ.js.map
+//# sourceMappingURL=persistent-session-PJQZYG2L.js.map

package/dist/{responsiveness-probe-6YYCQAFI.js → responsiveness-probe-MGMZQSP7.js}

@@ -1,7 +1,7 @@
 import {
   paneLogPath
-} from "./chunk-AZEYTJ4L.js";
-import "./chunk-Z6JJRLHH.js";
+} from "./chunk-QON5CU3L.js";
+import "./chunk-MH7HA6QV.js";
 import "./chunk-XWVM4KPK.js";
 
 // src/lib/responsiveness-probe.ts
@@ -154,4 +154,4 @@ export {
   livePendingInboundOldestAgeSeconds,
   oldestLivePendingInboundMtimeMs
 };
-//# sourceMappingURL=responsiveness-probe-6YYCQAFI.js.map
+//# sourceMappingURL=responsiveness-probe-MGMZQSP7.js.map

package/package.json

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