@integrity-labs/agt-cli 0.28.582 → 0.28.583

package/dist/bin/agt.js

@@ -40,7 +40,7 @@ import {
   success,
   table,
   warn
-} from "../chunk-XYWEC7PX.js";
+} from "../chunk-I4ZI4W7S.js";
 import {
   AnchorSessionClient,
   CHANNEL_REGISTRY,
@@ -4908,7 +4908,7 @@ import { execFileSync, execSync } from "child_process";
 import { existsSync as existsSync10, realpathSync as realpathSync2 } from "fs";
 import chalk18 from "chalk";
 import ora16 from "ora";
-var cliVersion = true ? "0.28.582" : "dev";
+var cliVersion = true ? "0.28.583" : "dev";
 async function fetchLatestVersion() {
   const host2 = getHost();
   if (!host2) return null;
@@ -6086,7 +6086,7 @@ function handleError(err) {
 }
 
 // src/bin/agt.ts
-var cliVersion2 = true ? "0.28.582" : "dev";
+var cliVersion2 = true ? "0.28.583" : "dev";
 var program = new Command();
 program.name("agt").description("Augmented CLI \u2014 agent provisioning and management").version(cliVersion2).option("--json", "Emit machine-readable JSON output (suppress spinners and colors)").option("--skip-update-check", "Skip the automatic update check on startup");
 program.hook("preAction", async (thisCommand, actionCommand) => {

package/dist/{chunk-XYWEC7PX.js → chunk-I4ZI4W7S.js}

@@ -5971,7 +5971,7 @@ function exchangeFailureKind(err) {
 }
 
 // src/lib/api-client.ts
-var agtCliVersion = true ? "0.28.582" : "dev";
+var agtCliVersion = true ? "0.28.583" : "dev";
 var lastConfigHash = null;
 function setConfigHash(hash) {
   lastConfigHash = hash && hash.length > 0 ? hash : null;
@@ -9347,4 +9347,4 @@ export {
   managerInstallSystemUnitCommand,
   managerUninstallSystemUnitCommand
 };
-//# sourceMappingURL=chunk-XYWEC7PX.js.map
+//# sourceMappingURL=chunk-I4ZI4W7S.js.map

package/dist/lib/manager-worker.js

@@ -53,7 +53,7 @@ import {
   safeWriteJsonAtomic,
   setConfigHash,
   tripClass
-} from "../chunk-XYWEC7PX.js";
+} from "../chunk-I4ZI4W7S.js";
 import {
   getProjectDir as getProjectDir2,
   getReadyTasks,
@@ -11624,7 +11624,7 @@ var agentRestartTimezoneInputs = /* @__PURE__ */ new Map();
 var lastVersionCheckAt = 0;
 var VERSION_CHECK_INTERVAL_MS = 5 * 60 * 1e3;
 var lastResponsivenessProbeAt = 0;
-var agtCliVersion = true ? "0.28.582" : "dev";
+var agtCliVersion = true ? "0.28.583" : "dev";
 function resolveBrewPath(execFileSync2) {
   try {
     const out = execFileSync2("which", ["brew"], { timeout: 5e3 }).toString().trim();

package/dist/mcp/slack-channel.js

@@ -36636,6 +36636,145 @@ function shouldPostUndeliverableNotice(lastNoticeAtMs, nowMs, throttleMs = UNDEL
 function undeliverableNoticeText(replayEnabled = channelReplayEnabled()) {
   return replayEnabled ? "\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.";
 }
+var UNDELIVERABLE_NOTICE_DEBOUNCE_MS = 3e4;
+function undeliverableNoticeDebounceMs() {
+  const raw = (process.env.AGT_CHANNEL_UNDELIVERABLE_NOTICE_DEBOUNCE_MS ?? "").trim();
+  if (!/^\d+$/.test(raw)) return UNDELIVERABLE_NOTICE_DEBOUNCE_MS;
+  const parsed = Number(raw);
+  return Number.isSafeInteger(parsed) ? parsed : UNDELIVERABLE_NOTICE_DEBOUNCE_MS;
+}
+function undeliverableNoticeDelayMs(cause, debounceMs = undeliverableNoticeDebounceMs()) {
+  if (isConfirmedUndeliverableCause(cause)) return 0;
+  return debounceMs;
+}
+function isConfirmedUndeliverableCause(cause) {
+  return cause === "integration_down" || cause === "session_dead";
+}
+function decideUndeliverableNoticeDispatch(i) {
+  if (i.confirmed && i.hasPendingNotice) return "send-now";
+  if (!shouldPostUndeliverableNotice(i.lastNoticeAtMs, i.nowMs, i.throttleMs)) return "suppress";
+  if (i.confirmed) return "send-now";
+  if (i.hasPendingNotice) return "suppress";
+  return i.delayMs > 0 ? "schedule" : "send-now";
+}
+var UndeliverableNoticeScheduler = class {
+  constructor(throttleMs = UNDELIVERABLE_NOTICE_THROTTLE_MS) {
+    this.throttleMs = throttleMs;
+  }
+  /** decision-time stamps, keyed by conversation. Shared with other one-per-window system notices. */
+  stamps = /* @__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? */
+  hasPending(key2) {
+    return this.timers.has(key2);
+  }
+  /** when this conversation was last stamped, or undefined if never. */
+  stampedAt(key2) {
+    return this.stamps.get(key2);
+  }
+  /**
+   * 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
+   * window is still closed. Sharing the stamp is the point: the user gets one
+   * system message per conversation per window, whichever fires first.
+   */
+  claimThrottleSlot(key2, nowMs = Date.now()) {
+    if (!shouldPostUndeliverableNotice(this.stamps.get(key2), nowMs, this.throttleMs)) return false;
+    this.stamps.set(key2, nowMs);
+    return true;
+  }
+  /**
+   * Run the dispatch decision and carry it out. `send` is invoked synchronously
+   * for 'send-now' and after `delayMs` for 'schedule'; it is never invoked for
+   * 'suppress'. Returns the decision so callers can log it.
+   */
+  dispatch(key2, i) {
+    const nowMs = i.nowMs ?? Date.now();
+    const decision = decideUndeliverableNoticeDispatch({
+      confirmed: i.confirmed,
+      delayMs: i.delayMs,
+      hasPendingNotice: this.timers.has(key2),
+      lastNoticeAtMs: this.stamps.get(key2),
+      nowMs,
+      throttleMs: this.throttleMs
+    });
+    if (decision === "suppress") return "suppress";
+    if (decision === "send-now") {
+      this.clearTimer(key2);
+      this.stamps.set(key2, nowMs);
+      this.safeSend(i.send);
+      return "send-now";
+    }
+    this.stamps.set(key2, nowMs);
+    const timer = setTimeout(() => {
+      this.timers.delete(key2);
+      this.safeSend(i.send);
+    }, i.delayMs);
+    timer.unref?.();
+    this.timers.set(key2, timer);
+    return "schedule";
+  }
+  /**
+   * The agent engaged: drop a scheduled-but-unsent notice, and its stamp with
+   * it. Returns whether anything was actually cancelled.
+   *
+   * Cancelling something that was never sent cannot be wrong, so this needs no
+   * "was it undeliverable?" gate - which is what Slack's version had, and why
+   * it missed the case where the marker had never been flagged.
+   */
+  cancel(key2) {
+    if (!this.timers.has(key2)) return false;
+    this.clearTimer(key2);
+    this.stamps.delete(key2);
+    return true;
+  }
+  /**
+   * Forget this conversation entirely - pending timer AND stamp - after a
+   * POSTED notice has been retracted (ENG-7705). Distinct from cancel(): that
+   * one is a no-op when nothing is pending, this one always clears the stamp so
+   * a later busy period earns a fresh notice instead of staying muted.
+   */
+  forget(key2) {
+    this.clearTimer(key2);
+    this.stamps.delete(key2);
+  }
+  /** Test seam / shutdown: drop all timers and stamps. */
+  reset() {
+    for (const timer of this.timers.values()) clearTimeout(timer);
+    this.timers.clear();
+    this.stamps.clear();
+  }
+  clearTimer(key2) {
+    const timer = this.timers.get(key2);
+    if (timer) clearTimeout(timer);
+    this.timers.delete(key2);
+  }
+  /**
+   * ENG-6247 round 3 (CodeRabbit #4446): the notice is fire-and-forget by design
+   * everywhere else - "a failed notice never blocks inbound processing" - and
+   * that has to hold here too.
+   *
+   * The delayed case is the dangerous one: a setTimeout callback runs outside
+   * every request context, so a synchronous throw from `send` is an unhandled
+   * exception and takes the channel server down. Both call sites close over
+   * network-calling code. A notice the user was never promised must not be able
+   * to cost them their agent.
+   *
+   * The immediate case is wrapped for the same reason one step earlier: it runs
+   * inside the inbound handler, so an escaping throw would abort processing of
+   * the very message the notice was about.
+   *
+   * Swallowed rather than logged: this module is pure and has no channel logger,
+   * and both send closures already report their own failures.
+   */
+  safeSend(send) {
+    try {
+      send();
+    } catch {
+    }
+  }
+};
 function undeliverableNoticeConversationKey(channel, threadTs, isThreadReply) {
   return isThreadReply && threadTs ? `${channel}:${threadTs}` : channel;
 }
@@ -41481,16 +41620,19 @@ function healSlackUndeliverable(channel, messageTs) {
     });
   });
 }
-var lastSlackUndeliverableNoticeAt = /* @__PURE__ */ new Map();
+var slackUndeliverableNotices = new UndeliverableNoticeScheduler();
 var lastSlackUndeliverableNoticeInfo = /* @__PURE__ */ new Map();
-function postUndeliverableNotice(channel, threadTs, isThreadReply) {
+function postUndeliverableNotice(channel, threadTs, isThreadReply, cause = "unknown") {
   if (!BOT_TOKEN || !channel) return;
-  const now = Date.now();
   const conversationKey = undeliverableNoticeConversationKey(channel, threadTs, isThreadReply);
-  if (!shouldPostUndeliverableNotice(lastSlackUndeliverableNoticeAt.get(conversationKey), now)) {
-    return;
-  }
-  lastSlackUndeliverableNoticeAt.set(conversationKey, now);
+  slackUndeliverableNotices.dispatch(conversationKey, {
+    confirmed: isConfirmedUndeliverableCause(cause),
+    delayMs: undeliverableNoticeDelayMs(cause),
+    send: () => sendUndeliverableNotice(channel, threadTs, conversationKey)
+  });
+}
+function sendUndeliverableNotice(channel, threadTs, conversationKey) {
+  if (!BOT_TOKEN || !channel) return;
   fetch("https://slack.com/api/chat.postMessage", {
     method: "POST",
     headers: {
@@ -41510,13 +41652,19 @@ function postUndeliverableNotice(channel, threadTs, isThreadReply) {
   });
 }
 function __resetSlackUndeliverableNoticeThrottle() {
-  lastSlackUndeliverableNoticeAt.clear();
+  slackUndeliverableNotices.reset();
   lastSlackUndeliverableNoticeInfo.clear();
 }
+function __slackUndeliverableNoticeScheduled(conversationKey) {
+  return slackUndeliverableNotices.hasPending(conversationKey);
+}
+function cancelScheduledSlackUndeliverableNotice(conversationKey) {
+  slackUndeliverableNotices.cancel(conversationKey);
+}
 function deleteSlackUndeliverableNotice(conversationKey) {
+  slackUndeliverableNotices.forget(conversationKey);
   const info = lastSlackUndeliverableNoticeInfo.get(conversationKey);
   lastSlackUndeliverableNoticeInfo.delete(conversationKey);
-  lastSlackUndeliverableNoticeAt.delete(conversationKey);
   if (!BOT_TOKEN || !info) return;
   fetch("https://slack.com/api/chat.delete", {
     method: "POST",
@@ -41604,6 +41752,11 @@ function clearSlackMarkerFileWithHeal(fullPath) {
     marker = JSON.parse(readFileSync18(fullPath, "utf-8"));
   } catch {
   }
+  if (marker?.channel) {
+    cancelScheduledSlackUndeliverableNotice(
+      undeliverableNoticeConversationKeyFromMarker(marker)
+    );
+  }
   if (marker && decideRecoveryHeal({
     wasUndeliverable: marker.undeliverable === true,
     hasTarget: Boolean(marker.channel && marker.message_ts)
@@ -41632,6 +41785,11 @@ function healThenEngageSlackMarker(fullPath, opts) {
   } catch {
     return false;
   }
+  if (marker.channel) {
+    cancelScheduledSlackUndeliverableNotice(
+      undeliverableNoticeConversationKeyFromMarker(marker)
+    );
+  }
   if (decideRecoveryHeal({
     wasUndeliverable: marker.undeliverable === true,
     hasTarget: Boolean(marker.channel && marker.message_ts)
@@ -42415,10 +42573,7 @@ function postSlackWatchdogGiveUpNotice(channel, threadTs, isThreadReply, reason)
   if (!BOT_TOKEN || !channel) return;
   const now = Date.now();
   const conversationKey = isThreadReply ? `${channel}:${threadTs}` : channel;
-  if (!shouldPostUndeliverableNotice(lastSlackUndeliverableNoticeAt.get(conversationKey), now)) {
-    return;
-  }
-  lastSlackUndeliverableNoticeAt.set(conversationKey, now);
+  if (!slackUndeliverableNotices.claimThrottleSlot(conversationKey, now)) return;
   process.stderr.write(
     `slack-channel(${AGENT_CODE_NAME}): give-up notice posted channel=${redactSlackId(channel)}
 `
@@ -45988,8 +46143,8 @@ async function connectSocketMode() {
       };
       const ackDecision = decideAckReaction(ackInputs);
       const arrivedWhileBusy = hasInFlightInbound(SLACK_PENDING_INBOUND_DIR);
+      const cause = classifyUndeliverableCause(ackInputs) ?? "unknown";
       if (ackDecision === "undeliverable") {
-        const cause = classifyUndeliverableCause(ackInputs) ?? "unknown";
         recordChannelDeflection(SLACK_AGENT_DIR, "slack", cause);
         process.stderr.write(
           `slack-channel(${AGENT_CODE_NAME}): [channel-deflection] cause=${cause} channel=slack ts=${redactSlackId(ts)}
@@ -46008,7 +46163,7 @@ async function connectSocketMode() {
         }).catch(() => {
         });
         if (ackDecision === "undeliverable" && channel && undeliverableNoticeEligible(shouldEngage)) {
-          postUndeliverableNotice(channel, threadTs, isThreadReply);
+          postUndeliverableNotice(channel, threadTs, isThreadReply, cause);
         }
       }
       if (channel && ts && armMarker) {
@@ -46300,7 +46455,8 @@ connectSocketModeSafely();
 export {
   __resetSlackBusyAckNoticeThrottle,
   __resetSlackGiveUpNoticeStateForTests,
-  __resetSlackUndeliverableNoticeThrottle
+  __resetSlackUndeliverableNoticeThrottle,
+  __slackUndeliverableNoticeScheduled
 };
 /*! Bundled license information:
 

package/dist/mcp/telegram-channel.js

@@ -39247,6 +39247,145 @@ function shouldPostUndeliverableNotice(lastNoticeAtMs, nowMs, throttleMs = UNDEL
 function undeliverableNoticeText(replayEnabled = channelReplayEnabled()) {
   return replayEnabled ? "\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.";
 }
+var UNDELIVERABLE_NOTICE_DEBOUNCE_MS = 3e4;
+function undeliverableNoticeDebounceMs() {
+  const raw = (process.env.AGT_CHANNEL_UNDELIVERABLE_NOTICE_DEBOUNCE_MS ?? "").trim();
+  if (!/^\d+$/.test(raw)) return UNDELIVERABLE_NOTICE_DEBOUNCE_MS;
+  const parsed = Number(raw);
+  return Number.isSafeInteger(parsed) ? parsed : UNDELIVERABLE_NOTICE_DEBOUNCE_MS;
+}
+function undeliverableNoticeDelayMs(cause, debounceMs = undeliverableNoticeDebounceMs()) {
+  if (isConfirmedUndeliverableCause(cause)) return 0;
+  return debounceMs;
+}
+function isConfirmedUndeliverableCause(cause) {
+  return cause === "integration_down" || cause === "session_dead";
+}
+function decideUndeliverableNoticeDispatch(i) {
+  if (i.confirmed && i.hasPendingNotice) return "send-now";
+  if (!shouldPostUndeliverableNotice(i.lastNoticeAtMs, i.nowMs, i.throttleMs)) return "suppress";
+  if (i.confirmed) return "send-now";
+  if (i.hasPendingNotice) return "suppress";
+  return i.delayMs > 0 ? "schedule" : "send-now";
+}
+var UndeliverableNoticeScheduler = class {
+  constructor(throttleMs = UNDELIVERABLE_NOTICE_THROTTLE_MS) {
+    this.throttleMs = throttleMs;
+  }
+  /** decision-time stamps, keyed by conversation. Shared with other one-per-window system notices. */
+  stamps = /* @__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? */
+  hasPending(key2) {
+    return this.timers.has(key2);
+  }
+  /** when this conversation was last stamped, or undefined if never. */
+  stampedAt(key2) {
+    return this.stamps.get(key2);
+  }
+  /**
+   * 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
+   * window is still closed. Sharing the stamp is the point: the user gets one
+   * system message per conversation per window, whichever fires first.
+   */
+  claimThrottleSlot(key2, nowMs = Date.now()) {
+    if (!shouldPostUndeliverableNotice(this.stamps.get(key2), nowMs, this.throttleMs)) return false;
+    this.stamps.set(key2, nowMs);
+    return true;
+  }
+  /**
+   * Run the dispatch decision and carry it out. `send` is invoked synchronously
+   * for 'send-now' and after `delayMs` for 'schedule'; it is never invoked for
+   * 'suppress'. Returns the decision so callers can log it.
+   */
+  dispatch(key2, i) {
+    const nowMs = i.nowMs ?? Date.now();
+    const decision = decideUndeliverableNoticeDispatch({
+      confirmed: i.confirmed,
+      delayMs: i.delayMs,
+      hasPendingNotice: this.timers.has(key2),
+      lastNoticeAtMs: this.stamps.get(key2),
+      nowMs,
+      throttleMs: this.throttleMs
+    });
+    if (decision === "suppress") return "suppress";
+    if (decision === "send-now") {
+      this.clearTimer(key2);
+      this.stamps.set(key2, nowMs);
+      this.safeSend(i.send);
+      return "send-now";
+    }
+    this.stamps.set(key2, nowMs);
+    const timer = setTimeout(() => {
+      this.timers.delete(key2);
+      this.safeSend(i.send);
+    }, i.delayMs);
+    timer.unref?.();
+    this.timers.set(key2, timer);
+    return "schedule";
+  }
+  /**
+   * The agent engaged: drop a scheduled-but-unsent notice, and its stamp with
+   * it. Returns whether anything was actually cancelled.
+   *
+   * Cancelling something that was never sent cannot be wrong, so this needs no
+   * "was it undeliverable?" gate - which is what Slack's version had, and why
+   * it missed the case where the marker had never been flagged.
+   */
+  cancel(key2) {
+    if (!this.timers.has(key2)) return false;
+    this.clearTimer(key2);
+    this.stamps.delete(key2);
+    return true;
+  }
+  /**
+   * Forget this conversation entirely - pending timer AND stamp - after a
+   * POSTED notice has been retracted (ENG-7705). Distinct from cancel(): that
+   * one is a no-op when nothing is pending, this one always clears the stamp so
+   * a later busy period earns a fresh notice instead of staying muted.
+   */
+  forget(key2) {
+    this.clearTimer(key2);
+    this.stamps.delete(key2);
+  }
+  /** Test seam / shutdown: drop all timers and stamps. */
+  reset() {
+    for (const timer of this.timers.values()) clearTimeout(timer);
+    this.timers.clear();
+    this.stamps.clear();
+  }
+  clearTimer(key2) {
+    const timer = this.timers.get(key2);
+    if (timer) clearTimeout(timer);
+    this.timers.delete(key2);
+  }
+  /**
+   * ENG-6247 round 3 (CodeRabbit #4446): the notice is fire-and-forget by design
+   * everywhere else - "a failed notice never blocks inbound processing" - and
+   * that has to hold here too.
+   *
+   * The delayed case is the dangerous one: a setTimeout callback runs outside
+   * every request context, so a synchronous throw from `send` is an unhandled
+   * exception and takes the channel server down. Both call sites close over
+   * network-calling code. A notice the user was never promised must not be able
+   * to cost them their agent.
+   *
+   * The immediate case is wrapped for the same reason one step earlier: it runs
+   * inside the inbound handler, so an escaping throw would abort processing of
+   * the very message the notice was about.
+   *
+   * Swallowed rather than logged: this module is pure and has no channel logger,
+   * and both send closures already report their own failures.
+   */
+  safeSend(send) {
+    try {
+      send();
+    } catch {
+    }
+  }
+};
 var BUSY_ACK_THRESHOLD_MS = 12e4;
 var BUSY_ACK_NOTICE_THROTTLE_MS = 20 * 60 * 1e3;
 function channelBusyAckEnabled() {
@@ -39959,12 +40098,18 @@ async function setMessageReaction(chatId, messageId, emoji2) {
     );
   }
 }
-var lastUndeliverableNoticeAt = /* @__PURE__ */ new Map();
-async function notifyUndeliverable(chatId, messageId) {
-  const key2 = String(chatId);
-  const now = Date.now();
-  if (!shouldPostUndeliverableNotice(lastUndeliverableNoticeAt.get(key2), now)) return;
-  lastUndeliverableNoticeAt.set(key2, now);
+var telegramUndeliverableNotices = new UndeliverableNoticeScheduler();
+function cancelScheduledUndeliverableNotice(chatId) {
+  telegramUndeliverableNotices.cancel(String(chatId));
+}
+function notifyUndeliverable(chatId, messageId, cause = "unknown") {
+  telegramUndeliverableNotices.dispatch(String(chatId), {
+    confirmed: isConfirmedUndeliverableCause(cause),
+    delayMs: undeliverableNoticeDelayMs(cause),
+    send: () => void sendUndeliverableNotice(chatId, messageId)
+  });
+}
+async function sendUndeliverableNotice(chatId, messageId) {
   try {
     const resp = await telegramApiCall(
       "sendMessage",
@@ -39991,7 +40136,10 @@ async function notifyUndeliverable(chatId, messageId) {
   }
 }
 function __resetUndeliverableNoticeThrottle() {
-  lastUndeliverableNoticeAt.clear();
+  telegramUndeliverableNotices.reset();
+}
+function __telegramUndeliverableNoticeScheduled(chatId) {
+  return telegramUndeliverableNotices.hasPending(String(chatId));
 }
 var lastBackOnlineNoticeAt = /* @__PURE__ */ new Map();
 function notifyBackOnline(chatId) {
@@ -41005,6 +41153,9 @@ function clearTelegramMarkerFileWithHeal(fullPath) {
     marker = JSON.parse(readFileSync14(fullPath, "utf-8"));
   } catch {
   }
+  if (marker?.chat_id) {
+    cancelScheduledUndeliverableNotice(marker.chat_id);
+  }
   if (marker && decideRecoveryHeal({
     wasUndeliverable: marker.undeliverable === true,
     hasTarget: Boolean(marker.chat_id)
@@ -41035,6 +41186,7 @@ function markTelegramMarkerEngagedInPlace(fullPath, opts) {
     (/* @__PURE__ */ new Date()).toISOString()
   );
   if (!decision.stamp) return opts.promise ? decision.promised : false;
+  if (marker.chat_id) cancelScheduledUndeliverableNotice(marker.chat_id);
   Object.assign(marker, decision.stamp);
   if (marker.undeliverable) delete marker.undeliverable;
   rewriteTelegramMarkerInPlace(fullPath, marker);
@@ -41053,6 +41205,7 @@ function markTelegramMarkerSeenWithHeal(fullPath) {
   } catch {
     return;
   }
+  if (marker.chat_id) cancelScheduledUndeliverableNotice(marker.chat_id);
   if (decideRecoveryHeal({
     wasUndeliverable: marker.undeliverable === true,
     hasTarget: Boolean(marker.chat_id)
@@ -41733,8 +41886,7 @@ function armTelegramTurnFailureWatch(args) {
 }
 async function notifyWatchdogGiveUp(chatId, reason) {
   const now = Date.now();
-  if (!shouldPostUndeliverableNotice(lastUndeliverableNoticeAt.get(chatId), now)) return;
-  lastUndeliverableNoticeAt.set(chatId, now);
+  if (!telegramUndeliverableNotices.claimThrottleSlot(chatId, now)) return;
   try {
     const resp = await telegramApiCall(
       "sendMessage",
@@ -43277,7 +43429,7 @@ async function pollLoop() {
         if (ackDecision === "ack") {
           void setMessageReaction(chatId, messageId, ACK_EMOJI);
         } else if (ackDecision === "undeliverable") {
-          void notifyUndeliverable(chatId, messageId);
+          notifyUndeliverable(chatId, messageId, classifyUndeliverableCause(ackInputs) ?? "unknown");
         }
         const fileMeta = [];
         for (const attachment of classifiedAttachments) {
@@ -43508,6 +43660,7 @@ export {
   __resetBusyAckNoticeThrottle,
   __resetGiveUpNoticeStateForTests,
   __resetUndeliverableNoticeThrottle,
+  __telegramUndeliverableNoticeScheduled,
   _resetQueuedReplyCountsForTests
 };
 /*! Bundled license information:

package/package.json

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