@integrity-labs/agt-cli 0.27.17 → 0.27.19

package/dist/lib/manager-worker.js

@@ -15,7 +15,7 @@ import {
   provisionOrientHook,
   provisionStopHook,
   requireHost
-} from "../chunk-QQVNHJ76.js";
+} from "../chunk-OUPCUHJZ.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -3166,7 +3166,7 @@ var cachedFrameworkVersion = null;
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.27.17" : "dev";
+var agtCliVersion = true ? "0.27.19" : "dev";
 function resolveBrewPath(execFileSync4) {
   try {
     const out = execFileSync4("which", ["brew"], { timeout: 5e3 }).toString().trim();

package/dist/mcp/direct-chat-channel.js

@@ -14114,6 +14114,14 @@ var mcp = new Server(
       tools: {}
     },
     instructions: [
+      // ENG-5845: highest-priority guard first. Without this framing,
+      // Opus 4.8 reads the softer "Reply using…" line as a suggestion and
+      // emits plain text — the reply lives in the local Claude session
+      // but never reaches the operator's session_id through the channel
+      // API. Mirrors the slack-channel CRITICAL line shipped in
+      // ENG-5830. Total instructions string is ~850 / 2048 chars so we
+      // have room to be explicit.
+      "CRITICAL: every response to a direct-chat <channel> tag MUST go through direct_chat.reply (passing the session_id verbatim). Text in your session WITHOUT a direct_chat.reply call never reaches the operator \u2014 the reply dies inside the agent process.",
       'Messages from the webapp Direct Chat arrive as <channel source="direct-chat" session_id="..." user="...">.',
       "Reply using the direct_chat.reply tool, passing the session_id from the tag.",
       "Always reply to every direct chat message \u2014 the user is waiting in the webapp.",

package/dist/mcp/slack-channel.js

@@ -14265,6 +14265,9 @@ function decideAckReaction(i) {
   }
   return "ack";
 }
+function decideRecoveryHeal(i) {
+  return i.wasUndeliverable && i.hasTarget ? "heal" : "none";
+}
 function oldestPendingMarkerAgeMs(dir, now = Date.now()) {
   if (!dir) return null;
   let names;
@@ -15589,14 +15592,16 @@ function slackPendingInboundPath(channel, threadTs, messageTs) {
   if (!SLACK_PENDING_INBOUND_DIR) return null;
   return join4(SLACK_PENDING_INBOUND_DIR, safeSlackMarkerName(channel, threadTs, messageTs));
 }
-function writeSlackPendingInboundMarker(channel, threadTs, messageTs) {
+function writeSlackPendingInboundMarker(channel, threadTs, messageTs, undeliverable = false) {
   const path = slackPendingInboundPath(channel, threadTs, messageTs);
   if (!path || !SLACK_PENDING_INBOUND_DIR) return;
   const marker = {
     channel,
     thread_ts: threadTs,
     message_ts: messageTs,
-    received_at: (/* @__PURE__ */ new Date()).toISOString()
+    received_at: (/* @__PURE__ */ new Date()).toISOString(),
+    // Only persist the flag when set — keeps healthy-path markers byte-identical.
+    ...undeliverable ? { undeliverable: true } : {}
   };
   try {
     mkdirSync3(SLACK_PENDING_INBOUND_DIR, { recursive: true, mode: 448 });
@@ -15608,6 +15613,43 @@ function writeSlackPendingInboundMarker(channel, threadTs, messageTs) {
     );
   }
 }
+function healSlackUndeliverable(channel, messageTs) {
+  if (!BOT_TOKEN || !channel || !messageTs) return;
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${BOT_TOKEN}`
+  };
+  fetch("https://slack.com/api/reactions.remove", {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ channel, timestamp: messageTs, name: "x" })
+  }).catch(() => {
+  }).finally(() => {
+    fetch("https://slack.com/api/reactions.add", {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ channel, timestamp: messageTs, name: "eyes" })
+    }).catch(() => {
+    });
+  });
+}
+function clearSlackMarkerFileWithHeal(fullPath) {
+  let marker = null;
+  try {
+    marker = JSON.parse(readFileSync4(fullPath, "utf-8"));
+  } catch {
+  }
+  if (marker && decideRecoveryHeal({
+    wasUndeliverable: marker.undeliverable === true,
+    hasTarget: Boolean(marker.channel && marker.message_ts)
+  }) === "heal") {
+    healSlackUndeliverable(marker.channel, marker.message_ts);
+  }
+  try {
+    if (existsSync2(fullPath)) unlinkSync2(fullPath);
+  } catch {
+  }
+}
 function clearAllSlackPendingMarkersForThread(channel, threadTs) {
   if (!SLACK_PENDING_INBOUND_DIR) return;
   const safeChan = channel.replace(/[^A-Za-z0-9_-]/g, "_");
@@ -15616,10 +15658,7 @@ function clearAllSlackPendingMarkersForThread(channel, threadTs) {
   try {
     for (const f of readdirSync2(SLACK_PENDING_INBOUND_DIR)) {
       if (!f.startsWith(prefix) || !f.endsWith(".json")) continue;
-      try {
-        unlinkSync2(join4(SLACK_PENDING_INBOUND_DIR, f));
-      } catch {
-      }
+      clearSlackMarkerFileWithHeal(join4(SLACK_PENDING_INBOUND_DIR, f));
     }
   } catch {
   }
@@ -15800,8 +15839,8 @@ function startSlackRecoveryOutboxWatcher() {
 }
 startSlackRecoveryOutboxWatcher();
 var STALE_MARKER_MS = 24 * 60 * 60 * 1e3;
-function trackPendingMessage(channel, threadTs, messageTs) {
-  writeSlackPendingInboundMarker(channel, threadTs, messageTs);
+function trackPendingMessage(channel, threadTs, messageTs, undeliverable = false) {
+  writeSlackPendingInboundMarker(channel, threadTs, messageTs, undeliverable);
 }
 function sweepSlackStaleMarkersOnBoot() {
   if (!SLACK_PENDING_INBOUND_DIR) return;
@@ -15888,10 +15927,7 @@ function noteThreadActivityByMessageTs(channel, messageTs) {
   for (const filename of filenames) {
     if (!filename.startsWith(channelPrefix)) continue;
     if (!filename.endsWith(messageSuffix)) continue;
-    try {
-      unlinkSync2(join4(SLACK_PENDING_INBOUND_DIR, filename));
-    } catch {
-    }
+    clearSlackMarkerFileWithHeal(join4(SLACK_PENDING_INBOUND_DIR, filename));
   }
 }
 var RESTART_FLAGS_DIR = join4(homedir2(), ".augmented", "restart-flags");
@@ -17888,7 +17924,7 @@ async function connectSocketMode() {
         });
       }
       if (channel && ts && shouldEngage) {
-        trackPendingMessage(channel, threadTs, ts);
+        trackPendingMessage(channel, threadTs, ts, ackDecision === "undeliverable");
       }
       const userName = await resolveUserName(user);
       const fileMeta = await buildInboundFileMeta(evt.files, AGENT_CODE_NAME, channel);

package/dist/mcp/telegram-channel.js

@@ -15517,6 +15517,9 @@ function decideAckReaction(i) {
   }
   return "ack";
 }
+function decideRecoveryHeal(i) {
+  return i.wasUndeliverable && i.hasTarget ? "heal" : "none";
+}
 function oldestPendingMarkerAgeMs(dir, now = Date.now()) {
   if (!dir) return null;
   let names;
@@ -15805,6 +15808,40 @@ async function notifyUndeliverable(chatId, messageId) {
 function __resetUndeliverableNoticeThrottle() {
   lastUndeliverableNoticeAt.clear();
 }
+var lastBackOnlineNoticeAt = /* @__PURE__ */ new Map();
+function notifyBackOnline(chatId) {
+  const key2 = String(chatId);
+  const now = Date.now();
+  const last = lastBackOnlineNoticeAt.get(key2);
+  if (last != null && now - last < UNDELIVERABLE_NOTICE_THROTTLE_MS) return;
+  lastBackOnlineNoticeAt.set(key2, now);
+  void (async () => {
+    try {
+      const resp = await telegramApiCall(
+        "sendMessage",
+        {
+          chat_id: chatId,
+          text: "\u2705 Back online \u2014 catching up on what I missed."
+        },
+        1e4
+      );
+      if (!resp.ok) {
+        process.stderr.write(
+          `telegram-channel(${AGENT_CODE_NAME}): back-online notice failed (chat=${redactId(chatId)}): ${resp.description ?? "unknown"}
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(
+        `telegram-channel(${AGENT_CODE_NAME}): back-online notice error: ${err.message}
+`
+      );
+    }
+  })();
+}
+function __resetBackOnlineNoticeThrottle() {
+  lastBackOnlineNoticeAt.clear();
+}
 var RESTART_FLAGS_DIR = join4(homedir2(), ".augmented", "restart-flags");
 function buildTelegramHelpMessage(codeName) {
   return [
@@ -15972,14 +16009,16 @@ function pendingInboundPath(chatId, messageId) {
   if (!PENDING_INBOUND_DIR) return null;
   return join4(PENDING_INBOUND_DIR, safeMarkerName(chatId, messageId));
 }
-function writePendingInboundMarker(chatId, messageId, chatType) {
+function writePendingInboundMarker(chatId, messageId, chatType, undeliverable = false) {
   const path = pendingInboundPath(chatId, messageId);
   if (!path || !PENDING_INBOUND_DIR) return;
   const marker = {
     chat_id: chatId,
     message_id: messageId,
     chat_type: chatType,
-    received_at: (/* @__PURE__ */ new Date()).toISOString()
+    received_at: (/* @__PURE__ */ new Date()).toISOString(),
+    // Only persist the flag when set — keeps healthy-path markers byte-identical.
+    ...undeliverable ? { undeliverable: true } : {}
   };
   try {
     mkdirSync3(PENDING_INBOUND_DIR, { recursive: true, mode: 448 });
@@ -15991,14 +16030,28 @@ function writePendingInboundMarker(chatId, messageId, chatType) {
     );
   }
 }
-function clearPendingInboundMarker(chatId, messageId) {
-  const path = pendingInboundPath(chatId, messageId);
-  if (!path) return;
+function clearTelegramMarkerFileWithHeal(fullPath) {
+  let marker = null;
   try {
-    if (existsSync2(path)) unlinkSync3(path);
+    marker = JSON.parse(readFileSync3(fullPath, "utf-8"));
+  } catch {
+  }
+  if (marker && decideRecoveryHeal({
+    wasUndeliverable: marker.undeliverable === true,
+    hasTarget: Boolean(marker.chat_id)
+  }) === "heal") {
+    notifyBackOnline(marker.chat_id);
+  }
+  try {
+    if (existsSync2(fullPath)) unlinkSync3(fullPath);
   } catch {
   }
 }
+function clearPendingInboundMarker(chatId, messageId) {
+  const path = pendingInboundPath(chatId, messageId);
+  if (!path) return;
+  clearTelegramMarkerFileWithHeal(path);
+}
 var MAX_RECOVERY_ATTEMPTS = 3;
 function nextRetryName(filename) {
   const match = filename.match(/^(.*?)(?:\.retry-(\d+))?\.json$/);
@@ -16166,8 +16219,8 @@ function startRecoveryOutboxWatcher() {
 }
 startRecoveryOutboxWatcher();
 var STALE_MARKER_MS = 24 * 60 * 60 * 1e3;
-function trackPendingMessage(chatId, messageId, chatType) {
-  writePendingInboundMarker(chatId, messageId, chatType);
+function trackPendingMessage(chatId, messageId, chatType, undeliverable = false) {
+  writePendingInboundMarker(chatId, messageId, chatType, undeliverable);
 }
 function sweepTelegramStaleMarkersOnBoot() {
   if (!PENDING_INBOUND_DIR) return;
@@ -16246,10 +16299,7 @@ function clearPendingMessage(chatId, messageId) {
   for (const filename of filenames) {
     if (!filename.startsWith(prefix)) continue;
     if (!filename.endsWith(".json")) continue;
-    try {
-      unlinkSync3(join4(PENDING_INBOUND_DIR, filename));
-    } catch {
-    }
+    clearTelegramMarkerFileWithHeal(join4(PENDING_INBOUND_DIR, filename));
   }
 }
 function noteThreadActivity(chatId, messageId) {
@@ -17104,7 +17154,7 @@ async function pollLoop() {
         } else if (ackDecision === "undeliverable") {
           void notifyUndeliverable(chatId, messageId);
         }
-        trackPendingMessage(chatId, messageId, msg.chat.type);
+        trackPendingMessage(chatId, messageId, msg.chat.type, ackDecision === "undeliverable");
         const fileMeta = [];
         for (const attachment of classifiedAttachments) {
           if (attachment.kind === "image") {
@@ -17231,5 +17281,6 @@ pollLoop().catch((err) => {
   process.exit(1);
 });
 export {
+  __resetBackOnlineNoticeThrottle,
   __resetUndeliverableNoticeThrottle
 };

package/package.json

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