@integrity-labs/agt-cli 0.28.830 → 0.28.832

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

@@ -30289,10 +30289,19 @@ var UNDELIVERABLE_NOTICE_THROTTLE_MS = 5 * 60 * 1e3;
 function shouldPostUndeliverableNotice(lastNoticeAtMs, nowMs, throttleMs = UNDELIVERABLE_NOTICE_THROTTLE_MS) {
   return lastNoticeAtMs == null || nowMs - lastNoticeAtMs >= throttleMs;
 }
-function undeliverableNoticeText(replay = channelReplayEnabled()) {
-  return noticePromiseIsHonest(replay) ? "\u23F3 I can't get to this right now \u2014 no need to resend; I'll pick it up automatically as soon as I'm free." : "\u23F3 I can't get to this right now. Please resend in a few minutes \u2014 I may not see this one.";
+function undeliverableNoticeText(replay) {
+  const honest = noticePromiseIsHonest(replay);
+  return honest ? "\u23F3 I can't get to this right now \u2014 no need to resend; I'll pick it up automatically as soon as I'm free." : "\u23F3 I can't get to this right now. Please resend in a few minutes \u2014 I may not see this one.";
+}
+function undeliverableNoticeTextForRepeat(i) {
+  if (i.priorNotices <= 0) return undeliverableNoticeText(i.replay);
+  if (i.priorNotices === 1) {
+    return noticePromiseIsHonest(i.replay) ? "\u23F3 Still stuck on this one \u2014 the automatic pickup I mentioned has not happened. Please resend when you can." : "\u23F3 Still stuck on this one, and I still have not picked it up. Resending is the reliable way through.";
+  }
+  return null;
 }
 function noticePromiseIsHonest(replay) {
+  if (replay === void 0) return false;
   if (typeof replay === "boolean") return replay;
   return markerReplayable({
     enabled: replay.enabled ?? channelReplayEnabled(),
@@ -30383,6 +30392,13 @@ function channelReplayEnabled() {
     defaultValue: true
   });
 }
+function combineMarkerReplayFacts(markers) {
+  if (markers.length === 0) return null;
+  return {
+    hasPayload: markers.every((m) => m.hasPayload),
+    discretionary: markers.some((m) => m.discretionary === true)
+  };
+}
 function markerReplayable(i) {
   if (!i.enabled) return false;
   if (!i.hasPayload) return false;
@@ -39696,6 +39712,7 @@ await mcp.connect(new StdioServerTransport());
 var processedIds = /* @__PURE__ */ new Set();
 var lastBusyAckNoticeAt = /* @__PURE__ */ new Map();
 var lastUndeliverableNoticeAt = /* @__PURE__ */ new Map();
+var undeliverableNoticeCount = /* @__PURE__ */ new Map();
 var lastTurnFailedNoticeAt = /* @__PURE__ */ new Map();
 async function postDirectChatNoticeMessage(sessionId, content) {
   try {
@@ -39730,14 +39747,47 @@ function postDirectChatBusyAckNotice(sessionId) {
     }
   })();
 }
+function directChatSessionReplayFacts(sessionId) {
+  if (!DIRECT_CHAT_PENDING_INBOUND_DIR) return null;
+  const found = [];
+  try {
+    clearDirectChatPendingMarkersForSession(
+      DIRECT_CHAT_PENDING_INBOUND_DIR,
+      sessionId,
+      (fullPath) => {
+        try {
+          const marker = JSON.parse(readFileSync11(fullPath, "utf-8"));
+          found.push({ hasPayload: Boolean(marker.payload), discretionary: marker.discretionary });
+        } catch {
+          found.push({ hasPayload: false });
+        }
+      }
+    );
+  } catch {
+    return null;
+  }
+  const facts = combineMarkerReplayFacts(found);
+  return facts ? { enabled: channelReplayEnabled(), ...facts } : null;
+}
 function postDirectChatUndeliverableNotice(sessionId) {
   const now = Date.now();
   if (!shouldPostUndeliverableNotice(lastUndeliverableNoticeAt.get(sessionId), now)) {
     return;
   }
   lastUndeliverableNoticeAt.set(sessionId, now);
+  const text = undeliverableNoticeTextForRepeat({
+    replay: directChatSessionReplayFacts(sessionId) ?? void 0,
+    priorNotices: undeliverableNoticeCount.get(sessionId) ?? 0
+  });
+  if (text === null) {
+    lastUndeliverableNoticeAt.delete(sessionId);
+    return;
+  }
   void (async () => {
-    const ok = await postDirectChatNoticeMessage(sessionId, undeliverableNoticeText());
+    const ok = await postDirectChatNoticeMessage(sessionId, text);
+    if (ok) {
+      undeliverableNoticeCount.set(sessionId, (undeliverableNoticeCount.get(sessionId) ?? 0) + 1);
+    }
     if (!ok) {
       lastUndeliverableNoticeAt.delete(sessionId);
       process.stderr.write(

package/dist/mcp/slack-channel.js

@@ -38414,10 +38414,19 @@ function undeliverableNoticeEligible(shouldEngage) {
 function shouldPostUndeliverableNotice(lastNoticeAtMs, nowMs, throttleMs = UNDELIVERABLE_NOTICE_THROTTLE_MS) {
   return lastNoticeAtMs == null || nowMs - lastNoticeAtMs >= throttleMs;
 }
-function undeliverableNoticeText(replay = channelReplayEnabled()) {
-  return noticePromiseIsHonest(replay) ? "\u23F3 I can't get to this right now \u2014 no need to resend; I'll pick it up automatically as soon as I'm free." : "\u23F3 I can't get to this right now. Please resend in a few minutes \u2014 I may not see this one.";
+function undeliverableNoticeText(replay) {
+  const honest = noticePromiseIsHonest(replay);
+  return honest ? "\u23F3 I can't get to this right now \u2014 no need to resend; I'll pick it up automatically as soon as I'm free." : "\u23F3 I can't get to this right now. Please resend in a few minutes \u2014 I may not see this one.";
+}
+function undeliverableNoticeTextForRepeat(i) {
+  if (i.priorNotices <= 0) return undeliverableNoticeText(i.replay);
+  if (i.priorNotices === 1) {
+    return noticePromiseIsHonest(i.replay) ? "\u23F3 Still stuck on this one \u2014 the automatic pickup I mentioned has not happened. Please resend when you can." : "\u23F3 Still stuck on this one, and I still have not picked it up. Resending is the reliable way through.";
+  }
+  return null;
 }
 function noticePromiseIsHonest(replay) {
+  if (replay === void 0) return false;
   if (typeof replay === "boolean") return replay;
   return markerReplayable({
     enabled: replay.enabled ?? channelReplayEnabled(),
@@ -38452,6 +38461,13 @@ var UndeliverableNoticeScheduler = class {
   }
   /** decision-time stamps, keyed by conversation. Shared with other one-per-window system notices. */
   stamps = /* @__PURE__ */ new Map();
+  /**
+   * ENG-9413 AC4 — how many notices have actually been POSTED for this
+   * conversation. Distinct from `stamps`, which is a decision-time throttle and
+   * is dropped by `cancel()`: a notice that was scheduled and cancelled was
+   * never seen by anyone and must not count toward escalation.
+   */
+  sent = /* @__PURE__ */ new Map();
   /** scheduled-but-unsent notices, keyed by conversation. */
   timers = /* @__PURE__ */ new Map();
   /** is a notice scheduled but not yet sent for this conversation? */
@@ -38462,6 +38478,30 @@ var UndeliverableNoticeScheduler = class {
   stampedAt(key2) {
     return this.stamps.get(key2);
   }
+  /**
+   * ENG-9413 AC4 — notices already POSTED for this conversation. Read by the
+   * channel's send callback to pick escalated copy, or to say nothing at all.
+   * The count is incremented AFTER `send` runs, so inside the callback this is
+   * the number of PRIOR notices.
+   */
+  noticeCount(key2) {
+    return this.sent.get(key2) ?? 0;
+  }
+  /**
+   * ENG-9413 AC4 — record that a notice was CONFIRMED delivered.
+   *
+   * Called by the channel, not by `dispatch`, and that is the correction.
+   * `dispatch`'s `send` is `() => void`: it returns before the Slack or Telegram
+   * request completes, so incrementing there counted posts that never landed. A
+   * failed post would then advance the escalation — the user's SECOND notice
+   * would arrive worded as though they had already seen a first, and their third
+   * would be suppressed entirely, on the strength of notices that were never
+   * delivered. Raised in review on this PR; direct chat already got this right
+   * by incrementing only on `ok`, and the shared scheduler now matches it.
+   */
+  noteDelivered(key2) {
+    this.sent.set(key2, this.noticeCount(key2) + 1);
+  }
   /**
    * ENG-6025: claim this conversation's one-notice-per-window slot for a
    * DIFFERENT system notice (the watchdog give-up line). Returns false when the
@@ -38533,6 +38573,7 @@ var UndeliverableNoticeScheduler = class {
     for (const timer of this.timers.values()) clearTimeout(timer);
     this.timers.clear();
     this.stamps.clear();
+    this.sent.clear();
   }
   clearTimer(key2) {
     const timer = this.timers.get(key2);
@@ -38706,6 +38747,13 @@ function channelReplayEnabled() {
     defaultValue: true
   });
 }
+function combineMarkerReplayFacts(markers) {
+  if (markers.length === 0) return null;
+  return {
+    hasPayload: markers.every((m) => m.hasPayload),
+    discretionary: markers.some((m) => m.discretionary === true)
+  };
+}
 function markerReplayable(i) {
   if (!i.enabled) return false;
   if (!i.hasPayload) return false;
@@ -43824,8 +43872,36 @@ function postUndeliverableNotice(channel, threadTs, isThreadReply, cause = "unkn
     send: () => sendUndeliverableNotice(channel, threadTs, conversationKey)
   });
 }
+function slackConversationReplayFacts(channel, threadTs) {
+  if (!threadTs || !SLACK_PENDING_INBOUND_DIR) return null;
+  const found = [];
+  try {
+    markSeenAllSlackPendingMarkersForThread(
+      SLACK_PENDING_INBOUND_DIR,
+      channel,
+      threadTs,
+      (fullPath) => {
+        try {
+          const marker = JSON.parse(readFileSync18(fullPath, "utf-8"));
+          found.push({ hasPayload: Boolean(marker.payload), discretionary: marker.discretionary });
+        } catch {
+          found.push({ hasPayload: false });
+        }
+      }
+    );
+  } catch {
+    return null;
+  }
+  const facts = combineMarkerReplayFacts(found);
+  return facts ? { enabled: channelReplayEnabled(), ...facts } : null;
+}
 function sendUndeliverableNotice(channel, threadTs, conversationKey) {
   if (!BOT_TOKEN || !channel) return;
+  const text = undeliverableNoticeTextForRepeat({
+    replay: slackConversationReplayFacts(channel, threadTs) ?? void 0,
+    priorNotices: slackUndeliverableNotices.noticeCount(conversationKey)
+  });
+  if (text === null) return;
   fetch("https://slack.com/api/chat.postMessage", {
     method: "POST",
     headers: {
@@ -43834,12 +43910,13 @@ function sendUndeliverableNotice(channel, threadTs, conversationKey) {
     },
     body: JSON.stringify({
       channel,
-      text: undeliverableNoticeText(),
+      text,
       ...threadTs ? { thread_ts: threadTs } : {}
     })
   }).then((res) => res.json()).then((data) => {
     if (data?.ok === true && typeof data.ts === "string" && data.ts) {
       lastSlackUndeliverableNoticeInfo.set(conversationKey, { channel, ts: data.ts });
+      slackUndeliverableNotices.noteDelivered(conversationKey);
     }
   }).catch(() => {
   });

package/dist/mcp/telegram-channel.js

@@ -41152,10 +41152,19 @@ var UNDELIVERABLE_NOTICE_THROTTLE_MS = 5 * 60 * 1e3;
 function shouldPostUndeliverableNotice(lastNoticeAtMs, nowMs, throttleMs = UNDELIVERABLE_NOTICE_THROTTLE_MS) {
   return lastNoticeAtMs == null || nowMs - lastNoticeAtMs >= throttleMs;
 }
-function undeliverableNoticeText(replay = channelReplayEnabled()) {
-  return noticePromiseIsHonest(replay) ? "\u23F3 I can't get to this right now \u2014 no need to resend; I'll pick it up automatically as soon as I'm free." : "\u23F3 I can't get to this right now. Please resend in a few minutes \u2014 I may not see this one.";
+function undeliverableNoticeText(replay) {
+  const honest = noticePromiseIsHonest(replay);
+  return honest ? "\u23F3 I can't get to this right now \u2014 no need to resend; I'll pick it up automatically as soon as I'm free." : "\u23F3 I can't get to this right now. Please resend in a few minutes \u2014 I may not see this one.";
+}
+function undeliverableNoticeTextForRepeat(i) {
+  if (i.priorNotices <= 0) return undeliverableNoticeText(i.replay);
+  if (i.priorNotices === 1) {
+    return noticePromiseIsHonest(i.replay) ? "\u23F3 Still stuck on this one \u2014 the automatic pickup I mentioned has not happened. Please resend when you can." : "\u23F3 Still stuck on this one, and I still have not picked it up. Resending is the reliable way through.";
+  }
+  return null;
 }
 function noticePromiseIsHonest(replay) {
+  if (replay === void 0) return false;
   if (typeof replay === "boolean") return replay;
   return markerReplayable({
     enabled: replay.enabled ?? channelReplayEnabled(),
@@ -41190,6 +41199,13 @@ var UndeliverableNoticeScheduler = class {
   }
   /** decision-time stamps, keyed by conversation. Shared with other one-per-window system notices. */
   stamps = /* @__PURE__ */ new Map();
+  /**
+   * ENG-9413 AC4 — how many notices have actually been POSTED for this
+   * conversation. Distinct from `stamps`, which is a decision-time throttle and
+   * is dropped by `cancel()`: a notice that was scheduled and cancelled was
+   * never seen by anyone and must not count toward escalation.
+   */
+  sent = /* @__PURE__ */ new Map();
   /** scheduled-but-unsent notices, keyed by conversation. */
   timers = /* @__PURE__ */ new Map();
   /** is a notice scheduled but not yet sent for this conversation? */
@@ -41200,6 +41216,30 @@ var UndeliverableNoticeScheduler = class {
   stampedAt(key2) {
     return this.stamps.get(key2);
   }
+  /**
+   * ENG-9413 AC4 — notices already POSTED for this conversation. Read by the
+   * channel's send callback to pick escalated copy, or to say nothing at all.
+   * The count is incremented AFTER `send` runs, so inside the callback this is
+   * the number of PRIOR notices.
+   */
+  noticeCount(key2) {
+    return this.sent.get(key2) ?? 0;
+  }
+  /**
+   * ENG-9413 AC4 — record that a notice was CONFIRMED delivered.
+   *
+   * Called by the channel, not by `dispatch`, and that is the correction.
+   * `dispatch`'s `send` is `() => void`: it returns before the Slack or Telegram
+   * request completes, so incrementing there counted posts that never landed. A
+   * failed post would then advance the escalation — the user's SECOND notice
+   * would arrive worded as though they had already seen a first, and their third
+   * would be suppressed entirely, on the strength of notices that were never
+   * delivered. Raised in review on this PR; direct chat already got this right
+   * by incrementing only on `ok`, and the shared scheduler now matches it.
+   */
+  noteDelivered(key2) {
+    this.sent.set(key2, this.noticeCount(key2) + 1);
+  }
   /**
    * ENG-6025: claim this conversation's one-notice-per-window slot for a
    * DIFFERENT system notice (the watchdog give-up line). Returns false when the
@@ -41271,6 +41311,7 @@ var UndeliverableNoticeScheduler = class {
     for (const timer of this.timers.values()) clearTimeout(timer);
     this.timers.clear();
     this.stamps.clear();
+    this.sent.clear();
   }
   clearTimer(key2) {
     const timer = this.timers.get(key2);
@@ -41437,6 +41478,13 @@ function channelReplayEnabled() {
     defaultValue: true
   });
 }
+function combineMarkerReplayFacts(markers) {
+  if (markers.length === 0) return null;
+  return {
+    hasPayload: markers.every((m) => m.hasPayload),
+    discretionary: markers.some((m) => m.discretionary === true)
+  };
+}
 function markerReplayable(i) {
   if (!i.enabled) return false;
   if (!i.hasPayload) return false;
@@ -42064,19 +42112,40 @@ function notifyUndeliverable(chatId, messageId, cause = "unknown") {
     send: () => void sendUndeliverableNotice(chatId, messageId)
   });
 }
+function telegramMarkerReplayFacts(chatId, messageId) {
+  const path = pendingInboundPath(chatId, messageId);
+  if (!path || !existsSync9(path)) return null;
+  try {
+    const marker = JSON.parse(readFileSync14(path, "utf-8"));
+    const facts = combineMarkerReplayFacts([
+      { hasPayload: Boolean(marker.payload), discretionary: marker.discretionary }
+    ]);
+    return facts ? { enabled: channelReplayEnabled(), ...facts } : null;
+  } catch {
+    return null;
+  }
+}
 async function sendUndeliverableNotice(chatId, messageId) {
+  const text = undeliverableNoticeTextForRepeat({
+    replay: telegramMarkerReplayFacts(String(chatId), String(messageId)) ?? void 0,
+    priorNotices: telegramUndeliverableNotices.noticeCount(String(chatId))
+  });
+  if (text === null) return;
   try {
     const resp = await telegramApiCall(
       "sendMessage",
       {
         chat_id: chatId,
         // ENG-6025: shared copy with the Slack undeliverable notice.
-        text: undeliverableNoticeText(),
+        text,
         reply_to_message_id: Number(messageId),
         allow_sending_without_reply: true
       },
       1e4
     );
+    if (resp.ok) {
+      telegramUndeliverableNotices.noteDelivered(String(chatId));
+    }
     if (!resp.ok) {
       process.stderr.write(
         `telegram-channel(${AGENT_CODE_NAME}): undeliverable notice failed (chat=${redactId(chatId)}): ${resp.description ?? "unknown"}

package/dist/{persistent-session-W23U7GQU.js → persistent-session-N6FIS7UY.js}

@@ -49,8 +49,8 @@ import {
   writeDirectChatSessionState,
   writeEgressAllowlist,
   writePersistentClaudeWrapper
-} from "./chunk-N4QVPPYS.js";
-import "./chunk-4ZPOP7EW.js";
+} from "./chunk-W4KAZQBS.js";
+import "./chunk-DUOFKTAD.js";
 import "./chunk-XWVM4KPK.js";
 export {
   EGRESS_BASELINE_DOMAINS,
@@ -104,4 +104,4 @@ export {
   writeEgressAllowlist,
   writePersistentClaudeWrapper
 };
-//# sourceMappingURL=persistent-session-W23U7GQU.js.map
+//# sourceMappingURL=persistent-session-N6FIS7UY.js.map

package/dist/{responsiveness-probe-IRQKIEBW.js → responsiveness-probe-LWYJM2DK.js}

@@ -1,7 +1,7 @@
 import {
   paneLogPath
-} from "./chunk-N4QVPPYS.js";
-import "./chunk-4ZPOP7EW.js";
+} from "./chunk-W4KAZQBS.js";
+import "./chunk-DUOFKTAD.js";
 import "./chunk-XWVM4KPK.js";
 
 // src/lib/responsiveness-probe.ts
@@ -739,4 +739,4 @@ export {
   readAndResetSlackReplyBindingClassifications,
   readAndResetSlackReplyTargetClassifications
 };
-//# sourceMappingURL=responsiveness-probe-IRQKIEBW.js.map
+//# sourceMappingURL=responsiveness-probe-LWYJM2DK.js.map

package/dist/{session-auth-dead-VDDXVJTX.js → session-auth-dead-LIPEYPBX.js}

@@ -1,6 +1,6 @@
 import {
   sessionTranscriptDir
-} from "./chunk-4ZPOP7EW.js";
+} from "./chunk-DUOFKTAD.js";
 
 // src/lib/session-auth-dead.ts
 import { closeSync, openSync, readSync, readdirSync, statSync } from "fs";
@@ -203,4 +203,4 @@ export {
   decideSessionAuthState,
   probeSessionAuth
 };
-//# sourceMappingURL=session-auth-dead-VDDXVJTX.js.map
+//# sourceMappingURL=session-auth-dead-LIPEYPBX.js.map

package/package.json

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