@integrity-labs/agt-cli 0.20.1 → 0.20.5

package/mcp/slack-channel.js

@@ -14323,27 +14323,6 @@ 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";
 
@@ -14439,16 +14418,21 @@ var StdioServerTransport = class {
 // src/slack-channel.ts
 import {
   chmodSync,
+  closeSync,
   createWriteStream,
   existsSync,
+  fsyncSync,
+  ftruncateSync,
   mkdirSync as mkdirSync2,
+  openSync,
   readFileSync as readFileSync2,
   readdirSync,
   renameSync,
   statSync,
   unlinkSync,
   watch,
-  writeFileSync as writeFileSync2
+  writeFileSync as writeFileSync2,
+  writeSync
 } from "fs";
 import { basename, join as join2, resolve as resolve2 } from "path";
 import { homedir as homedir2 } from "os";
@@ -15047,6 +15031,30 @@ function createSlackBotUserIdClient(args) {
   };
 }
 
+// src/pending-reminder-schedule.ts
+var REMINDER_SCHEDULE_MS = [5, 10, 20].map((m) => m * 6e4);
+var MAX_REMINDERS = REMINDER_SCHEDULE_MS.length;
+var RESPONSE_TIMEOUT_MS = REMINDER_SCHEDULE_MS[0];
+function nextReminderFireAtMs(receivedAtMs, currentReminderCount) {
+  const safeCount = Number.isFinite(currentReminderCount) ? Math.max(0, Math.trunc(currentReminderCount)) : 0;
+  let elapsed = 0;
+  for (let i = 0; i <= safeCount && i < MAX_REMINDERS; i++) {
+    elapsed += REMINDER_SCHEDULE_MS[i];
+  }
+  return receivedAtMs + elapsed;
+}
+function reminderText(reminderIndex, cancelCommandAvailable) {
+  switch (reminderIndex) {
+    case 0:
+      return "Heads-up \u2014 I'm still on it. This one's taking more than the usual minute.";
+    case 1:
+      return "Still working. Going deeper than expected; back when I have something useful.";
+    case 2:
+    default:
+      return cancelCommandAvailable ? "I'm 30+ min in on this. Type `/cancel` to abort, or ping me if it's urgent and I'll re-scope." : "I'm 30+ min in on this. If the answer's urgent, ping me and I'll pause to triage. Otherwise I'll keep going.";
+  }
+}
+
 // src/slack-channel.ts
 var BOT_TOKEN = process.env.SLACK_BOT_TOKEN;
 var APP_TOKEN = process.env.SLACK_APP_TOKEN;
@@ -15091,8 +15099,8 @@ var SLACK_PEER_CLASSIFIER_CONFIG = {
   peers: parsePeersEnv(process.env.SLACK_PEERS, process.env.SLACK_PEERS_GATE),
   peer_disabled_mode: SLACK_PEER_DISABLED_MODE
 };
-var RESPONSE_TIMEOUT_MS = 3e5;
 var pendingMessages = /* @__PURE__ */ new Map();
+var CANCEL_COMMAND_AVAILABLE = false;
 var SLACK_AGENT_DIR = AGENT_CODE_NAME ? join2(homedir2(), ".augmented", AGENT_CODE_NAME) : null;
 var SLACK_PENDING_INBOUND_DIR = SLACK_AGENT_DIR ? join2(SLACK_AGENT_DIR, "slack-pending-inbound") : null;
 var SLACK_RECOVERY_OUTBOX_DIR = SLACK_AGENT_DIR ? join2(SLACK_AGENT_DIR, "slack-recovery-outbox") : null;
@@ -15128,6 +15136,49 @@ function writeSlackPendingInboundMarker(channel, threadTs, messageTs) {
     );
   }
 }
+function updateSlackPendingInboundMarker(marker) {
+  const path = slackPendingInboundPath(marker.channel, marker.thread_ts, marker.message_ts);
+  if (!path) return false;
+  let fd;
+  try {
+    fd = openSync(path, "r+");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return false;
+    process.stderr.write(
+      `slack-channel(${AGENT_CODE_NAME}): pending-inbound marker open-for-update failed: ${err.message}
+`
+    );
+    return false;
+  }
+  try {
+    const payload = Buffer.from(JSON.stringify(marker));
+    ftruncateSync(fd, 0);
+    writeSync(fd, payload, 0, payload.length, 0);
+    fsyncSync(fd);
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `slack-channel(${AGENT_CODE_NAME}): pending-inbound marker write failed: ${err.message}
+`
+    );
+    return false;
+  } finally {
+    try {
+      closeSync(fd);
+    } catch {
+    }
+  }
+}
+function readSlackPendingInboundMarker(channel, threadTs, messageTs) {
+  const path = slackPendingInboundPath(channel, threadTs, messageTs);
+  if (!path || !existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync2(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
 function clearSlackPendingInboundMarker(channel, threadTs, messageTs) {
   const path = slackPendingInboundPath(channel, threadTs, messageTs);
   if (!path) return;
@@ -15327,32 +15378,72 @@ function startSlackRecoveryOutboxWatcher() {
   retryTimer.unref?.();
 }
 startSlackRecoveryOutboxWatcher();
-async function fireSlackResponseTimeout(channel, threadTs, messageTs) {
+var SLACK_REMINDER_FETCH_TIMEOUT_MS = 1e4;
+async function slackFetchWithTimeout(url, body) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), SLACK_REMINDER_FETCH_TIMEOUT_MS);
   try {
-    await fetch("https://slack.com/api/chat.postMessage", {
+    await fetch(url, {
       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."
-      })
+      body: JSON.stringify(body),
+      signal: controller.signal
     });
-  } catch {
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function fireSlackResponseTimeout(channel, threadTs, messageTs) {
+  const marker = readSlackPendingInboundMarker(channel, threadTs, messageTs);
+  if (!marker) {
+    return;
+  }
+  const reminderIndex = marker.reminder_count ?? 0;
+  if (reminderIndex >= MAX_REMINDERS) {
+    return;
   }
   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" })
+    await slackFetchWithTimeout("https://slack.com/api/chat.postMessage", {
+      channel,
+      thread_ts: threadTs,
+      text: reminderText(reminderIndex, CANCEL_COMMAND_AVAILABLE)
     });
   } catch {
   }
+  if (reminderIndex === 1) {
+    try {
+      await slackFetchWithTimeout("https://slack.com/api/reactions.remove", {
+        channel,
+        timestamp: messageTs,
+        name: "eyes"
+      });
+    } catch {
+    }
+    try {
+      await slackFetchWithTimeout("https://slack.com/api/reactions.add", {
+        channel,
+        timestamp: messageTs,
+        name: "hourglass_flowing_sand"
+      });
+    } catch {
+    }
+  }
+  const nextCount = reminderIndex + 1;
+  const persisted = updateSlackPendingInboundMarker({ ...marker, reminder_count: nextCount });
+  if (!persisted) {
+    process.stderr.write(
+      `slack-channel(${AGENT_CODE_NAME}): reminder ${nextCount}/${MAX_REMINDERS} posted but marker cleared mid-fire (agent replied) \u2014 not arming next timer
+`
+    );
+    return;
+  }
   process.stderr.write(
-    `slack-channel: Response timeout for message ${redactSlackId(messageTs)} in ${redactSlackId(channel)}
+    `slack-channel(${AGENT_CODE_NAME}): reminder ${nextCount}/${MAX_REMINDERS} posted for message ${redactSlackId(messageTs)} in ${redactSlackId(channel)} (marker left pending)
 `
   );
-  clearSlackPendingInboundMarker(channel, threadTs, messageTs);
+  if (nextCount < MAX_REMINDERS) {
+    armSlackPendingTimer(channel, threadTs, messageTs, REMINDER_SCHEDULE_MS[nextCount]);
+  }
 }
 function armSlackPendingTimer(channel, threadTs, messageTs, durationMs) {
   const key2 = `${channel}:${threadTs}:${messageTs}`;
@@ -15387,8 +15478,10 @@ function rearmSlackPendingTimersFromDisk() {
   let armed = 0;
   let firedNow = 0;
   let cleared = 0;
+  let exhausted = 0;
   for (const filename of filenames) {
     if (!filename.endsWith(".json")) continue;
+    if (filename.endsWith(".tmp")) continue;
     const fullPath = join2(SLACK_PENDING_INBOUND_DIR, filename);
     let marker;
     try {
@@ -15412,15 +15505,18 @@ function rearmSlackPendingTimersFromDisk() {
       }
       continue;
     }
-    const action = decideRearmAction({
-      receivedAtMs: Date.parse(received_at),
-      nowMs: now,
-      timeoutMs: RESPONSE_TIMEOUT_MS,
-      staleMs: STALE_MARKER_MS
-    });
-    if (action.kind === "stale") {
+    const receivedAtMs = Date.parse(received_at);
+    if (!Number.isFinite(receivedAtMs)) {
+      try {
+        unlinkSync(fullPath);
+      } catch {
+      }
+      cleared++;
+      continue;
+    }
+    if (now - receivedAtMs > STALE_MARKER_MS) {
       process.stderr.write(
-        `slack-channel(${AGENT_CODE_NAME}): rearm skipping stale/invalid marker channel=${redactSlackId(channel)} message=${redactSlackId(message_ts)}
+        `slack-channel(${AGENT_CODE_NAME}): rearm skipping stale marker channel=${redactSlackId(channel)} message=${redactSlackId(message_ts)}
 `
       );
       try {
@@ -15430,18 +15526,25 @@ function rearmSlackPendingTimersFromDisk() {
       cleared++;
       continue;
     }
-    if (action.kind === "fire") {
+    const reminderCount = marker.reminder_count ?? 0;
+    if (reminderCount >= MAX_REMINDERS) {
+      exhausted++;
+      continue;
+    }
+    const nextFireAt = nextReminderFireAtMs(receivedAtMs, reminderCount);
+    const remainingMs = nextFireAt - now;
+    if (remainingMs <= 0) {
       pendingMessages.delete(`${channel}:${thread_ts}:${message_ts}`);
       void fireSlackResponseTimeout(channel, thread_ts, message_ts);
       firedNow++;
     } else {
-      armSlackPendingTimer(channel, thread_ts, message_ts, action.remainingMs);
+      armSlackPendingTimer(channel, thread_ts, message_ts, remainingMs);
       armed++;
     }
   }
-  if (armed > 0 || firedNow > 0 || cleared > 0) {
+  if (armed > 0 || firedNow > 0 || cleared > 0 || exhausted > 0) {
     process.stderr.write(
-      `slack-channel(${AGENT_CODE_NAME}): rearm summary armed=${armed} fired_now=${firedNow} stale_cleared=${cleared}
+      `slack-channel(${AGENT_CODE_NAME}): rearm summary armed=${armed} fired_now=${firedNow} stale_cleared=${cleared} reminders_exhausted=${exhausted}
 `
     );
   }
@@ -15456,6 +15559,26 @@ function clearPendingMessage(channel, threadTs) {
   }
   clearAllSlackPendingMarkersForThread(channel, threadTs);
 }
+function noteThreadActivity(channel, threadTs) {
+  if (!channel || !threadTs) return;
+  clearPendingMessage(channel, threadTs);
+}
+function noteThreadActivityByMessageTs(channel, messageTs) {
+  if (!channel || !messageTs) return;
+  clearPendingMessage(channel, messageTs);
+  const suffix = `:${messageTs}`;
+  for (const [key2, timer] of pendingMessages) {
+    if (!key2.startsWith(`${channel}:`)) continue;
+    if (!key2.endsWith(suffix)) continue;
+    clearTimeout(timer);
+    pendingMessages.delete(key2);
+    const parts = key2.split(":");
+    if (parts.length >= 3) {
+      const threadTs = parts[1];
+      clearSlackPendingInboundMarker(channel, threadTs, messageTs);
+    }
+  }
+}
 var RESTART_FLAGS_DIR = join2(homedir2(), ".augmented", "restart-flags");
 function hashChannelId(id) {
   return createHash("sha256").update(id).digest("hex").slice(0, 8);
@@ -16221,6 +16344,7 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
   }
   if (name === "slack.react") {
     const { channel, timestamp, emoji: emoji2 } = args;
+    noteThreadActivityByMessageTs(channel, timestamp);
     try {
       const res = await fetch("https://slack.com/api/reactions.add", {
         method: "POST",
@@ -16248,6 +16372,7 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
   if (name === "slack.read_thread") {
     const { channel, thread_ts, limit: rawLimit } = args;
     const limit = Math.min(Math.max(rawLimit ?? 50, 1), 200);
+    noteThreadActivity(channel, thread_ts);
     try {
       const allMessages = [];
       let cursor;
@@ -16637,6 +16762,7 @@ async function handleSendStructured(args) {
   if (typeof text !== "string" || !text) {
     return errResult("text is required (used as fallback for push notifications and unfurls)");
   }
+  noteThreadActivity(channel, thread_ts);
   const validation = validateSlackBlocks2(blocks);
   if (!validation.ok) {
     return errResult(`Invalid blocks: ${validation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);

package/mcp/telegram-channel.js

@@ -13865,16 +13865,21 @@ var StdioServerTransport = class {
 import https from "https";
 import { createHash, randomUUID } from "crypto";
 import {
+  closeSync,
   createWriteStream,
   existsSync,
+  fsyncSync,
+  ftruncateSync,
   mkdirSync as mkdirSync2,
+  openSync,
   readFileSync,
   readdirSync,
   renameSync as renameSync2,
   statSync,
   unlinkSync as unlinkSync2,
   watch,
-  writeFileSync as writeFileSync2
+  writeFileSync as writeFileSync2,
+  writeSync
 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
@@ -14000,27 +14005,6 @@ 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) {
@@ -14836,6 +14820,30 @@ function createObservedChatClient(args) {
   };
 }
 
+// src/pending-reminder-schedule.ts
+var REMINDER_SCHEDULE_MS = [5, 10, 20].map((m) => m * 6e4);
+var MAX_REMINDERS = REMINDER_SCHEDULE_MS.length;
+var RESPONSE_TIMEOUT_MS = REMINDER_SCHEDULE_MS[0];
+function nextReminderFireAtMs(receivedAtMs, currentReminderCount) {
+  const safeCount = Number.isFinite(currentReminderCount) ? Math.max(0, Math.trunc(currentReminderCount)) : 0;
+  let elapsed = 0;
+  for (let i = 0; i <= safeCount && i < MAX_REMINDERS; i++) {
+    elapsed += REMINDER_SCHEDULE_MS[i];
+  }
+  return receivedAtMs + elapsed;
+}
+function reminderText(reminderIndex, cancelCommandAvailable) {
+  switch (reminderIndex) {
+    case 0:
+      return "Heads-up \u2014 I'm still on it. This one's taking more than the usual minute.";
+    case 1:
+      return "Still working. Going deeper than expected; back when I have something useful.";
+    case 2:
+    default:
+      return cancelCommandAvailable ? "I'm 30+ min in on this. Type `/cancel` to abort, or ping me if it's urgent and I'll re-scope." : "I'm 30+ min in on this. If the answer's urgent, ping me and I'll pause to triage. Otherwise I'll keep going.";
+  }
+}
+
 // src/telegram-channel.ts
 function redactId(id) {
   return createHash("sha256").update(String(id)).digest("hex").slice(0, 8);
@@ -14969,7 +14977,8 @@ function telegramApiCall(method, body, timeoutMs) {
   });
 }
 var ACK_EMOJI = "\u{1F440}";
-var RESPONSE_TIMEOUT_MS = 3e5;
+var CANCEL_COMMAND_AVAILABLE = false;
+var REMINDER_REACTION_EMOJI = "\u23F3";
 async function setMessageReaction(chatId, messageId, emoji2) {
   try {
     const resp = await telegramApiCall(
@@ -15189,6 +15198,49 @@ function clearPendingInboundMarker(chatId, messageId) {
   } catch {
   }
 }
+function updatePendingInboundMarker(marker) {
+  const path = pendingInboundPath(marker.chat_id, marker.message_id);
+  if (!path) return false;
+  let fd;
+  try {
+    fd = openSync(path, "r+");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return false;
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): pending-inbound marker open-for-update failed: ${err.message}
+`
+    );
+    return false;
+  }
+  try {
+    const payload = Buffer.from(JSON.stringify(marker));
+    ftruncateSync(fd, 0);
+    writeSync(fd, payload, 0, payload.length, 0);
+    fsyncSync(fd);
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): pending-inbound marker write failed: ${err.message}
+`
+    );
+    return false;
+  } finally {
+    try {
+      closeSync(fd);
+    } catch {
+    }
+  }
+}
+function readPendingInboundMarker(chatId, messageId) {
+  const path = pendingInboundPath(chatId, messageId);
+  if (!path || !existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
 var MAX_RECOVERY_ATTEMPTS = 3;
 function nextRetryName(filename) {
   const match = filename.match(/^(.*?)(?:\.retry-(\d+))?\.json$/);
@@ -15356,13 +15408,16 @@ function startRecoveryOutboxWatcher() {
 }
 startRecoveryOutboxWatcher();
 function fireTelegramResponseTimeout(chatId, messageId) {
-  clearPendingInboundMarker(chatId, messageId);
-  void setMessageReaction(chatId, messageId, null);
+  const marker = readPendingInboundMarker(chatId, messageId);
+  if (!marker) return;
+  const reminderIndex = marker.reminder_count ?? 0;
+  if (reminderIndex >= MAX_REMINDERS) return;
+  const chatType = marker.chat_type ?? "private";
   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.",
+      text: reminderText(reminderIndex, CANCEL_COMMAND_AVAILABLE),
       reply_to_message_id: Number(messageId),
       allow_sending_without_reply: true
     },
@@ -15370,20 +15425,35 @@ function fireTelegramResponseTimeout(chatId, messageId) {
   ).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"}
+        `telegram-channel(${AGENT_CODE_NAME}): reminder 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}
+      `telegram-channel(${AGENT_CODE_NAME}): reminder sendMessage error for chat ${redactId(chatId)} message ${redactId(messageId)}: ${err.message}
 `
     );
   });
+  if (reminderIndex === 1) {
+    void setMessageReaction(chatId, messageId, REMINDER_REACTION_EMOJI);
+  }
+  const nextCount = reminderIndex + 1;
+  const persisted = updatePendingInboundMarker({ ...marker, reminder_count: nextCount, chat_type: chatType });
+  if (!persisted) {
+    process.stderr.write(
+      `telegram-channel(${AGENT_CODE_NAME}): reminder ${nextCount}/${MAX_REMINDERS} posted but marker cleared mid-fire (agent replied) \u2014 not arming next timer
+`
+    );
+    return;
+  }
   process.stderr.write(
-    `telegram-channel(${AGENT_CODE_NAME}): response timeout for message ${redactId(messageId)} in chat ${redactId(chatId)}
+    `telegram-channel(${AGENT_CODE_NAME}): reminder ${nextCount}/${MAX_REMINDERS} posted for message ${redactId(messageId)} in chat ${redactId(chatId)} (marker left pending)
 `
   );
+  if (nextCount < MAX_REMINDERS) {
+    armTelegramPendingTimer(chatId, messageId, chatType, REMINDER_SCHEDULE_MS[nextCount]);
+  }
 }
 function armTelegramPendingTimer(chatId, messageId, chatType, durationMs) {
   const key2 = `${chatId}:${messageId}`;
@@ -15418,8 +15488,10 @@ function rearmPendingTimersFromDisk() {
   let armed = 0;
   let firedNow = 0;
   let cleared = 0;
+  let exhausted = 0;
   for (const filename of filenames) {
     if (!filename.endsWith(".json")) continue;
+    if (filename.endsWith(".tmp")) continue;
     const fullPath = join2(PENDING_INBOUND_DIR, filename);
     let marker;
     try {
@@ -15443,15 +15515,18 @@ function rearmPendingTimersFromDisk() {
       }
       continue;
     }
-    const action = decideRearmAction({
-      receivedAtMs: Date.parse(received_at),
-      nowMs: now,
-      timeoutMs: RESPONSE_TIMEOUT_MS,
-      staleMs: STALE_MARKER_MS
-    });
-    if (action.kind === "stale") {
+    const receivedAtMs = Date.parse(received_at);
+    if (!Number.isFinite(receivedAtMs)) {
+      try {
+        unlinkSync2(fullPath);
+      } catch {
+      }
+      cleared++;
+      continue;
+    }
+    if (now - receivedAtMs > STALE_MARKER_MS) {
       process.stderr.write(
-        `telegram-channel(${AGENT_CODE_NAME}): rearm skipping stale/invalid marker chat=${redactId(chat_id)} message=${redactId(message_id)}
+        `telegram-channel(${AGENT_CODE_NAME}): rearm skipping stale marker chat=${redactId(chat_id)} message=${redactId(message_id)}
 `
       );
       try {
@@ -15461,18 +15536,25 @@ function rearmPendingTimersFromDisk() {
       cleared++;
       continue;
     }
-    if (action.kind === "fire") {
+    const reminderCount = marker.reminder_count ?? 0;
+    if (reminderCount >= MAX_REMINDERS) {
+      exhausted++;
+      continue;
+    }
+    const nextFireAt = nextReminderFireAtMs(receivedAtMs, reminderCount);
+    const remainingMs = nextFireAt - now;
+    if (remainingMs <= 0) {
       pendingMessages.delete(`${chat_id}:${message_id}`);
       fireTelegramResponseTimeout(chat_id, message_id);
       firedNow++;
     } else {
-      armTelegramPendingTimer(chat_id, message_id, chat_type ?? "private", action.remainingMs);
+      armTelegramPendingTimer(chat_id, message_id, chat_type ?? "private", remainingMs);
       armed++;
     }
   }
-  if (armed > 0 || firedNow > 0 || cleared > 0) {
+  if (armed > 0 || firedNow > 0 || cleared > 0 || exhausted > 0) {
     process.stderr.write(
-      `telegram-channel(${AGENT_CODE_NAME}): rearm summary armed=${armed} fired_now=${firedNow} stale_cleared=${cleared}
+      `telegram-channel(${AGENT_CODE_NAME}): rearm summary armed=${armed} fired_now=${firedNow} stale_cleared=${cleared} reminders_exhausted=${exhausted}
 `
     );
   }
@@ -15511,6 +15593,10 @@ function clearPendingMessage(chatId, messageId) {
     return;
   }
 }
+function noteThreadActivity(chatId, messageId) {
+  if (!chatId) return;
+  clearPendingMessage(chatId, messageId);
+}
 var mcp = new Server(
   { name: "telegram", version: "0.1.0" },
   {
@@ -15729,6 +15815,7 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
         isError: true
       };
     }
+    noteThreadActivity(chat_id, message_id);
     try {
       const data = await telegramApiCall(
         "setMessageReaction",

package/package.json

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