@integrity-labs/agt-cli 0.28.829 → 0.28.831

package/dist/mcp/slack-channel.js

@@ -36911,7 +36911,7 @@ var FLAG_REGISTRY = [
   },
   {
     key: "auto-resume-enabled",
-    description: "DO NOT ARM YET (ENG-8395): this flag has no `since` set until a follow-up bisects it from the published agt-cli dist, and an unset `since` makes the flip-reach estimate report FULL reach for a reader that is host-side \u2014 it will tell you a flip reached hosts that have no code to honour it. Arm only once that follow-up has landed. Bounded BLIND auto-resume for circuit-breaker pauses (ENG-6088): at most one unattended resume per trip cycle, fired once the trip driver has been quiet for the configured window and only for provisioning-reload trips (the ENG-7577 class gate \u2014 a crash-class trip still needs an operator). Superseded wherever `resume-reconciler` is on: that path proves the dependency recovered instead of assuming it, and the blind timer is its flag-off fallback. Boolean gate; ships dark. ENG-8395 promoted this from a raw host env var because AGT_AUTO_RESUME_ENABLED lives in the host env file, so its grain is per-HOST \u2014 one flip arms every agent that host runs (agt-aws-1 carries 14), which made the canary-then-fleet rollout its own documentation prescribes impossible. As a registry flag it resolves per org/team/host/AGENT, so one agent can genuinely be cut over first. Read host-side by the manager (agt-cli), not centrally.",
+    description: "Bounded BLIND auto-resume for circuit-breaker pauses (ENG-6088): at most one unattended resume per trip cycle, fired once the trip driver has been quiet for the configured window and only for provisioning-reload trips (the ENG-7577 class gate \u2014 a crash-class trip still needs an operator). Superseded wherever `resume-reconciler` is on: that path proves the dependency recovered instead of assuming it, and the blind timer is its flag-off fallback. Boolean gate; ships dark. ENG-8395 promoted this from a raw host env var because AGT_AUTO_RESUME_ENABLED lives in the host env file, so its grain is per-HOST \u2014 one flip arms every agent that host runs (agt-aws-1 carries 14), which made the canary-then-fleet rollout its own documentation prescribes impossible. As a registry flag it resolves per org/team/host/AGENT, so one agent can genuinely be cut over first. Read host-side by the manager (agt-cli), not centrally.",
     flagType: "boolean",
     // Declared safe value is `false` — identical to today's behaviour on a host
     // that has never set the env var. Fail-safe direction on a flag-DB read
@@ -36928,16 +36928,41 @@ var FLAG_REGISTRY = [
     // An unattended resume is a real availability change — the agent starts
     // spawning sessions again with no human in the loop — so arming it is a
     // deliberate, confirmed write (ADR-0022 sensitive-flag confirm).
-    sensitive: true
-    // ENG-8395 AC5: `since` is deliberately UNSET at merge. It must be bisected
-    // from the PUBLISHED agt-cli dist once the artifact carrying the host-side
-    // reader exists, never guessed — auto-resume.ts is host-side, so an
-    // under-`since` host has no consumer for this flag and a guessed value makes
-    // the flip-reach modal promise reach it does not have (the defect caught on
-    // ENG-8344 / PR #4014). Precedent for the bisect method: slack-hot-thread-guard
-    // = 0.28.339, slack-scheduled-channel-guard = 0.28.421. Setting it later is
-    // safe: `since` is excluded from projectDefinition, so it does not roll
+    sensitive: true,
+    // ENG-10034: bisected from the PUBLISHED agt-cli dists, not from git history —
+    // auto-resume.ts is host-side, so what matters is the first ARTIFACT a host
+    // could be running that contains a consumer for this flag.
+    //
+    // METHOD, so it can be re-run rather than trusted: download each candidate
+    // tarball from the npm registry and grep its contents for the flag-specific
+    // wiring. Binary search over the 22 versions published either side of
+    // ENG-8395's merge gave a clean one-release boundary, eight minutes wide:
+    //
+    //   0.28.506  2026-08-03T22:29:22Z  readAutoResumeEnvOverride ✗  AUTO_RESUME_FLAG_KEY ✗  'auto-resume-enabled' ✗
+    //   0.28.507  2026-08-03T22:37:00Z  readAutoResumeEnvOverride ✓  AUTO_RESUME_FLAG_KEY ✓  'auto-resume-enabled' ✓
+    //
+    // All three symbols are checked rather than one. `getBooleanForAgent` alone
+    // would have been the wrong probe — it is present in BOTH builds, because the
+    // generic resolver long predates this flag. A `since` bisected on a symbol the
+    // flag does not depend on is a number that looks rigorous and is not.
+    //
+    // ENG-8395 AC5 left this unset on purpose and said why: an unset `since` makes
+    // the flip-reach estimate report FULL reach for a host-side reader, promising
+    // reach it does not have (the defect caught on ENG-8344 / PR #4014). The
+    // follow-up it was waiting on was never filed, so the flag sat un-armable for
+    // a month and ENG-6088's bounded auto-resume stayed dark fleet-wide — a
+    // customer agent sat breaker-paused 2h08m on 2026-09-05 with the recovery path
+    // silently disabled. That is what an administrative blocker recorded only in a
+    // code comment costs.
+    //
+    // Same method as its precedents: slack-hot-thread-guard = 0.28.339,
+    // slack-scheduled-channel-guard = 0.28.421 (ENG-8149). Setting it now is safe:
+    // `since` is excluded from projectDefinition, so it does not roll
     // FLAGS_SCHEMA_VERSION.
+    //
+    // This does NOT arm the flag. defaultValue stays false and `sensitive` stays
+    // true; arming is a separate, deliberate decision that belongs to ENG-6066.
+    since: "0.28.507"
   },
   {
     key: "host-poll-rate-alarm",
@@ -38389,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(),
@@ -38427,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? */
@@ -38437,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
@@ -38508,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);
@@ -38681,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;
@@ -43799,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: {
@@ -43809,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

@@ -37043,7 +37043,7 @@ var FLAG_REGISTRY = [
   },
   {
     key: "auto-resume-enabled",
-    description: "DO NOT ARM YET (ENG-8395): this flag has no `since` set until a follow-up bisects it from the published agt-cli dist, and an unset `since` makes the flip-reach estimate report FULL reach for a reader that is host-side \u2014 it will tell you a flip reached hosts that have no code to honour it. Arm only once that follow-up has landed. Bounded BLIND auto-resume for circuit-breaker pauses (ENG-6088): at most one unattended resume per trip cycle, fired once the trip driver has been quiet for the configured window and only for provisioning-reload trips (the ENG-7577 class gate \u2014 a crash-class trip still needs an operator). Superseded wherever `resume-reconciler` is on: that path proves the dependency recovered instead of assuming it, and the blind timer is its flag-off fallback. Boolean gate; ships dark. ENG-8395 promoted this from a raw host env var because AGT_AUTO_RESUME_ENABLED lives in the host env file, so its grain is per-HOST \u2014 one flip arms every agent that host runs (agt-aws-1 carries 14), which made the canary-then-fleet rollout its own documentation prescribes impossible. As a registry flag it resolves per org/team/host/AGENT, so one agent can genuinely be cut over first. Read host-side by the manager (agt-cli), not centrally.",
+    description: "Bounded BLIND auto-resume for circuit-breaker pauses (ENG-6088): at most one unattended resume per trip cycle, fired once the trip driver has been quiet for the configured window and only for provisioning-reload trips (the ENG-7577 class gate \u2014 a crash-class trip still needs an operator). Superseded wherever `resume-reconciler` is on: that path proves the dependency recovered instead of assuming it, and the blind timer is its flag-off fallback. Boolean gate; ships dark. ENG-8395 promoted this from a raw host env var because AGT_AUTO_RESUME_ENABLED lives in the host env file, so its grain is per-HOST \u2014 one flip arms every agent that host runs (agt-aws-1 carries 14), which made the canary-then-fleet rollout its own documentation prescribes impossible. As a registry flag it resolves per org/team/host/AGENT, so one agent can genuinely be cut over first. Read host-side by the manager (agt-cli), not centrally.",
     flagType: "boolean",
     // Declared safe value is `false` — identical to today's behaviour on a host
     // that has never set the env var. Fail-safe direction on a flag-DB read
@@ -37060,16 +37060,41 @@ var FLAG_REGISTRY = [
     // An unattended resume is a real availability change — the agent starts
     // spawning sessions again with no human in the loop — so arming it is a
     // deliberate, confirmed write (ADR-0022 sensitive-flag confirm).
-    sensitive: true
-    // ENG-8395 AC5: `since` is deliberately UNSET at merge. It must be bisected
-    // from the PUBLISHED agt-cli dist once the artifact carrying the host-side
-    // reader exists, never guessed — auto-resume.ts is host-side, so an
-    // under-`since` host has no consumer for this flag and a guessed value makes
-    // the flip-reach modal promise reach it does not have (the defect caught on
-    // ENG-8344 / PR #4014). Precedent for the bisect method: slack-hot-thread-guard
-    // = 0.28.339, slack-scheduled-channel-guard = 0.28.421. Setting it later is
-    // safe: `since` is excluded from projectDefinition, so it does not roll
+    sensitive: true,
+    // ENG-10034: bisected from the PUBLISHED agt-cli dists, not from git history —
+    // auto-resume.ts is host-side, so what matters is the first ARTIFACT a host
+    // could be running that contains a consumer for this flag.
+    //
+    // METHOD, so it can be re-run rather than trusted: download each candidate
+    // tarball from the npm registry and grep its contents for the flag-specific
+    // wiring. Binary search over the 22 versions published either side of
+    // ENG-8395's merge gave a clean one-release boundary, eight minutes wide:
+    //
+    //   0.28.506  2026-08-03T22:29:22Z  readAutoResumeEnvOverride ✗  AUTO_RESUME_FLAG_KEY ✗  'auto-resume-enabled' ✗
+    //   0.28.507  2026-08-03T22:37:00Z  readAutoResumeEnvOverride ✓  AUTO_RESUME_FLAG_KEY ✓  'auto-resume-enabled' ✓
+    //
+    // All three symbols are checked rather than one. `getBooleanForAgent` alone
+    // would have been the wrong probe — it is present in BOTH builds, because the
+    // generic resolver long predates this flag. A `since` bisected on a symbol the
+    // flag does not depend on is a number that looks rigorous and is not.
+    //
+    // ENG-8395 AC5 left this unset on purpose and said why: an unset `since` makes
+    // the flip-reach estimate report FULL reach for a host-side reader, promising
+    // reach it does not have (the defect caught on ENG-8344 / PR #4014). The
+    // follow-up it was waiting on was never filed, so the flag sat un-armable for
+    // a month and ENG-6088's bounded auto-resume stayed dark fleet-wide — a
+    // customer agent sat breaker-paused 2h08m on 2026-09-05 with the recovery path
+    // silently disabled. That is what an administrative blocker recorded only in a
+    // code comment costs.
+    //
+    // Same method as its precedents: slack-hot-thread-guard = 0.28.339,
+    // slack-scheduled-channel-guard = 0.28.421 (ENG-8149). Setting it now is safe:
+    // `since` is excluded from projectDefinition, so it does not roll
     // FLAGS_SCHEMA_VERSION.
+    //
+    // This does NOT arm the flag. defaultValue stays false and `sensitive` stays
+    // true; arming is a separate, deliberate decision that belongs to ENG-6066.
+    since: "0.28.507"
   },
   {
     key: "host-poll-rate-alarm",
@@ -41127,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(),
@@ -41165,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? */
@@ -41175,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
@@ -41246,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);
@@ -41412,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;
@@ -42039,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-6YTEDS3H.js → persistent-session-W23U7GQU.js}

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

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

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

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

@@ -1,6 +1,6 @@
 import {
   sessionTranscriptDir
-} from "./chunk-GJY3KZG6.js";
+} from "./chunk-4ZPOP7EW.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-LFNU6AUU.js.map
+//# sourceMappingURL=session-auth-dead-VDDXVJTX.js.map

package/package.json

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