@integrity-labs/agt-cli 0.19.25 → 0.20.0

package/dist/{persistent-session-J2K3JFJQ.js → persistent-session-BVR3HES5.js}

@@ -14,7 +14,7 @@ import {
   stopAllSessionsAndWait,
   stopPersistentSession,
   writePersistentClaudeWrapper
-} from "./chunk-ZQNOWGHB.js";
+} from "./chunk-55SJYI7V.js";
 export {
   _internals,
   collectDiagnostics,
@@ -32,4 +32,4 @@ export {
   stopPersistentSession,
   writePersistentClaudeWrapper
 };
-//# sourceMappingURL=persistent-session-J2K3JFJQ.js.map
+//# sourceMappingURL=persistent-session-BVR3HES5.js.map

package/mcp/index.js

@@ -21076,7 +21076,7 @@ var AGT_HOST = process.env.AGT_HOST;
 var AGT_API_KEY = process.env.AGT_API_KEY;
 var AGT_AGENT_ID = process.env.AGT_AGENT_ID;
 var AGT_AGENT_CODE_NAME = process.env.AGT_AGENT_CODE_NAME;
-var AGT_APP_URL = (process.env.AGT_APP_URL ?? "").replace(/\/+$/, "");
+var AGT_APP_URL = (process.env.AGT_APP_URL?.trim() || "https://app.augmented.team").replace(/\/+$/, "");
 function readRunId() {
   const raw = process.env.AGT_RUN_ID ?? "";
   if (!raw || raw === "${AGT_RUN_ID}") return null;

package/mcp/slack-channel.js

@@ -14323,6 +14323,27 @@ async function isThreadKilled(opts) {
   }
 }
 
+// src/pending-timeout-rearm.ts
+var DEFAULT_STALE_MARKER_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_RESPONSE_TIMEOUT_MS = 5 * 60 * 1e3;
+function decideRearmAction(opts) {
+  const { receivedAtMs, nowMs } = opts;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_RESPONSE_TIMEOUT_MS;
+  const staleMs = opts.staleMs ?? DEFAULT_STALE_MARKER_MS;
+  if (!Number.isFinite(receivedAtMs)) {
+    return { kind: "stale" };
+  }
+  const elapsedMs = Math.max(0, nowMs - receivedAtMs);
+  if (elapsedMs > staleMs) {
+    return { kind: "stale" };
+  }
+  const remainingMs = timeoutMs - elapsedMs;
+  if (remainingMs <= 0) {
+    return { kind: "fire" };
+  }
+  return { kind: "arm", remainingMs };
+}
+
 // ../../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";
 
@@ -15195,7 +15216,7 @@ async function processSlackRecoveryOutboxFile(filename) {
 `
       );
       if (payload.thread_ts) {
-        clearAllSlackPendingMarkersForThread(payload.channel, payload.thread_ts);
+        clearPendingMessage(payload.channel, payload.thread_ts);
       }
     } else {
       process.stderr.write(
@@ -15306,37 +15327,126 @@ function startSlackRecoveryOutboxWatcher() {
   retryTimer.unref?.();
 }
 startSlackRecoveryOutboxWatcher();
-function trackPendingMessage(channel, threadTs, messageTs) {
+async function fireSlackResponseTimeout(channel, threadTs, messageTs) {
+  try {
+    await fetch("https://slack.com/api/chat.postMessage", {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${BOT_TOKEN}` },
+      body: JSON.stringify({
+        channel,
+        thread_ts: threadTs,
+        text: "Sorry \u2014 I didn't get a response back to you within 5 minutes, so this one fell on the floor. Please re-send if it's still relevant."
+      })
+    });
+  } catch {
+  }
+  try {
+    await fetch("https://slack.com/api/reactions.remove", {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${BOT_TOKEN}` },
+      body: JSON.stringify({ channel, timestamp: messageTs, name: "eyes" })
+    });
+  } catch {
+  }
+  process.stderr.write(
+    `slack-channel: Response timeout for message ${redactSlackId(messageTs)} in ${redactSlackId(channel)}
+`
+  );
+  clearSlackPendingInboundMarker(channel, threadTs, messageTs);
+}
+function armSlackPendingTimer(channel, threadTs, messageTs, durationMs) {
   const key2 = `${channel}:${threadTs}:${messageTs}`;
-  const timer = setTimeout(async () => {
+  const existing = pendingMessages.get(key2);
+  if (existing) clearTimeout(existing);
+  const timer = setTimeout(() => {
     pendingMessages.delete(key2);
+    void fireSlackResponseTimeout(channel, threadTs, messageTs);
+  }, Math.max(0, durationMs));
+  timer.unref?.();
+  pendingMessages.set(key2, timer);
+}
+function trackPendingMessage(channel, threadTs, messageTs) {
+  writeSlackPendingInboundMarker(channel, threadTs, messageTs);
+  armSlackPendingTimer(channel, threadTs, messageTs, RESPONSE_TIMEOUT_MS);
+}
+var STALE_MARKER_MS = 24 * 60 * 60 * 1e3;
+function rearmSlackPendingTimersFromDisk() {
+  if (!SLACK_PENDING_INBOUND_DIR) return;
+  if (!existsSync(SLACK_PENDING_INBOUND_DIR)) return;
+  let filenames;
+  try {
+    filenames = readdirSync(SLACK_PENDING_INBOUND_DIR);
+  } catch (err) {
+    process.stderr.write(
+      `slack-channel(${AGENT_CODE_NAME}): rearm readdir failed: ${err.message}
+`
+    );
+    return;
+  }
+  const now = Date.now();
+  let armed = 0;
+  let firedNow = 0;
+  let cleared = 0;
+  for (const filename of filenames) {
+    if (!filename.endsWith(".json")) continue;
+    const fullPath = join2(SLACK_PENDING_INBOUND_DIR, filename);
+    let marker;
     try {
-      await fetch("https://slack.com/api/chat.postMessage", {
-        method: "POST",
-        headers: { "Content-Type": "application/json", Authorization: `Bearer ${BOT_TOKEN}` },
-        body: JSON.stringify({
-          channel,
-          thread_ts: threadTs,
-          text: "Sorry \u2014 I didn't get a response back to you within 5 minutes, so this one fell on the floor. Please re-send if it's still relevant."
-        })
-      });
-    } catch {
+      marker = JSON.parse(readFileSync2(fullPath, "utf-8"));
+    } catch (err) {
+      process.stderr.write(
+        `slack-channel(${AGENT_CODE_NAME}): rearm parse failed for ${filename}: ${err.message}
+`
+      );
+      try {
+        unlinkSync(fullPath);
+      } catch {
+      }
+      continue;
     }
-    try {
-      await fetch("https://slack.com/api/reactions.remove", {
-        method: "POST",
-        headers: { "Content-Type": "application/json", Authorization: `Bearer ${BOT_TOKEN}` },
-        body: JSON.stringify({ channel, timestamp: messageTs, name: "eyes" })
-      });
-    } catch {
+    const { channel, thread_ts, message_ts, received_at } = marker;
+    if (!channel || !thread_ts || !message_ts || !received_at) {
+      try {
+        unlinkSync(fullPath);
+      } catch {
+      }
+      continue;
     }
-    process.stderr.write(`slack-channel: Response timeout for message ${redactSlackId(messageTs)} in ${redactSlackId(channel)}
-`);
-    clearSlackPendingInboundMarker(channel, threadTs, messageTs);
-  }, RESPONSE_TIMEOUT_MS);
-  pendingMessages.set(key2, timer);
-  writeSlackPendingInboundMarker(channel, threadTs, messageTs);
+    const action = decideRearmAction({
+      receivedAtMs: Date.parse(received_at),
+      nowMs: now,
+      timeoutMs: RESPONSE_TIMEOUT_MS,
+      staleMs: STALE_MARKER_MS
+    });
+    if (action.kind === "stale") {
+      process.stderr.write(
+        `slack-channel(${AGENT_CODE_NAME}): rearm skipping stale/invalid marker channel=${redactSlackId(channel)} message=${redactSlackId(message_ts)}
+`
+      );
+      try {
+        unlinkSync(fullPath);
+      } catch {
+      }
+      cleared++;
+      continue;
+    }
+    if (action.kind === "fire") {
+      pendingMessages.delete(`${channel}:${thread_ts}:${message_ts}`);
+      void fireSlackResponseTimeout(channel, thread_ts, message_ts);
+      firedNow++;
+    } else {
+      armSlackPendingTimer(channel, thread_ts, message_ts, action.remainingMs);
+      armed++;
+    }
+  }
+  if (armed > 0 || firedNow > 0 || cleared > 0) {
+    process.stderr.write(
+      `slack-channel(${AGENT_CODE_NAME}): rearm summary armed=${armed} fired_now=${firedNow} stale_cleared=${cleared}
+`
+    );
+  }
 }
+rearmSlackPendingTimersFromDisk();
 function clearPendingMessage(channel, threadTs) {
   for (const [key2, timer] of pendingMessages) {
     if (key2.startsWith(`${channel}:${threadTs}:`)) {

package/mcp/telegram-channel.js

@@ -14000,6 +14000,27 @@ function redactAugmentedPaths(msg) {
   );
 }
 
+// src/pending-timeout-rearm.ts
+var DEFAULT_STALE_MARKER_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_RESPONSE_TIMEOUT_MS = 5 * 60 * 1e3;
+function decideRearmAction(opts) {
+  const { receivedAtMs, nowMs } = opts;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_RESPONSE_TIMEOUT_MS;
+  const staleMs = opts.staleMs ?? DEFAULT_STALE_MARKER_MS;
+  if (!Number.isFinite(receivedAtMs)) {
+    return { kind: "stale" };
+  }
+  const elapsedMs = Math.max(0, nowMs - receivedAtMs);
+  if (elapsedMs > staleMs) {
+    return { kind: "stale" };
+  }
+  const remainingMs = timeoutMs - elapsedMs;
+  if (remainingMs <= 0) {
+    return { kind: "fire" };
+  }
+  return { kind: "arm", remainingMs };
+}
+
 // src/telegram-attachments.ts
 import { mkdirSync, writeFileSync, chmodSync, renameSync, unlinkSync } from "fs";
 function resolveTelegramInboundDir(codeName) {
@@ -15226,7 +15247,7 @@ async function processRecoveryOutboxFile(filename) {
         `telegram-channel(${AGENT_CODE_NAME}): ghost-reply recovery sent (chat=${redactId(payload.chat_id)} msg=${redactId(payload.message_id ?? "")})
 `
       );
-      if (payload.message_id) clearPendingInboundMarker(payload.chat_id, payload.message_id);
+      if (payload.message_id) clearPendingMessage(payload.chat_id, payload.message_id);
     } else {
       process.stderr.write(
         `telegram-channel(${AGENT_CODE_NAME}): ghost-reply recovery failed (chat=${redactId(payload.chat_id)}): ${resp.description ?? "unknown"}
@@ -15334,45 +15355,129 @@ function startRecoveryOutboxWatcher() {
   retryTimer.unref?.();
 }
 startRecoveryOutboxWatcher();
-function trackPendingMessage(chatId, messageId, chatType) {
+function fireTelegramResponseTimeout(chatId, messageId) {
+  clearPendingInboundMarker(chatId, messageId);
+  void setMessageReaction(chatId, messageId, null);
+  void telegramApiCall(
+    "sendMessage",
+    {
+      chat_id: chatId,
+      text: "Sorry \u2014 I didn't get a response back to you within 5 minutes, so this one fell on the floor. Please re-send if it's still relevant.",
+      reply_to_message_id: Number(messageId),
+      allow_sending_without_reply: true
+    },
+    1e4
+  ).then((resp) => {
+    if (!resp.ok) {
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): timeout sendMessage failed for chat ${redactId(chatId)} message ${redactId(messageId)}: ${resp.description ?? "unknown"}
+`
+      );
+    }
+  }).catch((err) => {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): timeout sendMessage error for chat ${redactId(chatId)} message ${redactId(messageId)}: ${err.message}
+`
+    );
+  });
+  process.stderr.write(
+    `telegram-channel(${AGENT_CODE_NAME}): response timeout for message ${redactId(messageId)} in chat ${redactId(chatId)}
+`
+  );
+}
+function armTelegramPendingTimer(chatId, messageId, chatType, durationMs) {
   const key2 = `${chatId}:${messageId}`;
   const existing = pendingMessages.get(key2);
   if (existing) clearTimeout(existing.timer);
   const timer = setTimeout(() => {
     pendingMessages.delete(key2);
-    clearPendingInboundMarker(chatId, messageId);
-    void setMessageReaction(chatId, messageId, null);
-    void telegramApiCall(
-      "sendMessage",
-      {
-        chat_id: chatId,
-        text: "Sorry \u2014 I didn't get a response back to you within 5 minutes, so this one fell on the floor. Please re-send if it's still relevant.",
-        reply_to_message_id: Number(messageId),
-        allow_sending_without_reply: true
-      },
-      1e4
-    ).then((resp) => {
-      if (!resp.ok) {
-        process.stderr.write(
-          `telegram-channel(${AGENT_CODE_NAME}): timeout sendMessage failed for chat ${redactId(chatId)} message ${redactId(messageId)}: ${resp.description ?? "unknown"}
+    fireTelegramResponseTimeout(chatId, messageId);
+  }, Math.max(0, durationMs));
+  timer.unref?.();
+  pendingMessages.set(key2, { timer, chatType });
+}
+function trackPendingMessage(chatId, messageId, chatType) {
+  writePendingInboundMarker(chatId, messageId, chatType);
+  armTelegramPendingTimer(chatId, messageId, chatType, RESPONSE_TIMEOUT_MS);
+}
+var STALE_MARKER_MS = 24 * 60 * 60 * 1e3;
+function rearmPendingTimersFromDisk() {
+  if (!PENDING_INBOUND_DIR) return;
+  if (!existsSync(PENDING_INBOUND_DIR)) return;
+  let filenames;
+  try {
+    filenames = readdirSync(PENDING_INBOUND_DIR);
+  } catch (err) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): rearm readdir failed: ${err.message}
 `
-        );
-      }
-    }).catch((err) => {
+    );
+    return;
+  }
+  const now = Date.now();
+  let armed = 0;
+  let firedNow = 0;
+  let cleared = 0;
+  for (const filename of filenames) {
+    if (!filename.endsWith(".json")) continue;
+    const fullPath = join2(PENDING_INBOUND_DIR, filename);
+    let marker;
+    try {
+      marker = JSON.parse(readFileSync(fullPath, "utf-8"));
+    } catch (err) {
       process.stderr.write(
-        `telegram-channel(${AGENT_CODE_NAME}): timeout sendMessage error for chat ${redactId(chatId)} message ${redactId(messageId)}: ${err.message}
+        `telegram-channel(${AGENT_CODE_NAME}): rearm parse failed for ${filename}: ${err.message}
 `
       );
+      try {
+        unlinkSync2(fullPath);
+      } catch {
+      }
+      continue;
+    }
+    const { chat_id, message_id, chat_type, received_at } = marker;
+    if (!chat_id || !message_id || !received_at) {
+      try {
+        unlinkSync2(fullPath);
+      } catch {
+      }
+      continue;
+    }
+    const action = decideRearmAction({
+      receivedAtMs: Date.parse(received_at),
+      nowMs: now,
+      timeoutMs: RESPONSE_TIMEOUT_MS,
+      staleMs: STALE_MARKER_MS
     });
+    if (action.kind === "stale") {
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): rearm skipping stale/invalid marker chat=${redactId(chat_id)} message=${redactId(message_id)}
+`
+      );
+      try {
+        unlinkSync2(fullPath);
+      } catch {
+      }
+      cleared++;
+      continue;
+    }
+    if (action.kind === "fire") {
+      pendingMessages.delete(`${chat_id}:${message_id}`);
+      fireTelegramResponseTimeout(chat_id, message_id);
+      firedNow++;
+    } else {
+      armTelegramPendingTimer(chat_id, message_id, chat_type ?? "private", action.remainingMs);
+      armed++;
+    }
+  }
+  if (armed > 0 || firedNow > 0 || cleared > 0) {
     process.stderr.write(
-      `telegram-channel(${AGENT_CODE_NAME}): response timeout for message ${redactId(messageId)} in chat ${redactId(chatId)}
+      `telegram-channel(${AGENT_CODE_NAME}): rearm summary armed=${armed} fired_now=${firedNow} stale_cleared=${cleared}
 `
     );
-  }, RESPONSE_TIMEOUT_MS);
-  timer.unref?.();
-  pendingMessages.set(key2, { timer, chatType });
-  writePendingInboundMarker(chatId, messageId, chatType);
+  }
 }
+rearmPendingTimersFromDisk();
 function clearPendingMessage(chatId, messageId) {
   if (messageId) {
     const key2 = `${chatId}:${messageId}`;

package/package.json

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