@integrity-labs/agt-cli 0.28.632 → 0.28.633

package/dist/bin/agt.js

@@ -40,10 +40,10 @@ import {
   success,
   table,
   warn
-} from "../chunk-QDIF33SF.js";
+} from "../chunk-IDERROFJ.js";
 import {
   readDirectChatSessionState
-} from "../chunk-IT2WYXBM.js";
+} from "../chunk-GNTCOXZG.js";
 import {
   AnchorSessionClient,
   CHANNEL_REGISTRY,
@@ -4909,7 +4909,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.632" : "dev";
+var cliVersion = true ? "0.28.633" : "dev";
 async function fetchLatestVersion() {
   const host2 = getHost();
   if (!host2) return null;
@@ -6089,7 +6089,7 @@ function handleError(err) {
 }
 
 // src/bin/agt.ts
-var cliVersion2 = true ? "0.28.632" : "dev";
+var cliVersion2 = true ? "0.28.633" : "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-IT2WYXBM.js → chunk-GNTCOXZG.js}

@@ -2400,8 +2400,22 @@ function isSessionFeedbackDialogVisible(screen) {
   return screen.includes("How is Claude doing this session") && screen.includes("0: Dismiss");
 }
 var USAGE_LIMIT_SAFE_OPTION = "Stop and wait for limit to reset";
+var USAGE_LIMIT_CONTINUE_OPTION = "Wait here, then continue automatically";
+var USAGE_LIMIT_SAFE_OPTIONS = [
+  USAGE_LIMIT_CONTINUE_OPTION,
+  USAGE_LIMIT_SAFE_OPTION
+];
+var USAGE_LIMIT_KNOWN_OPTIONS = [
+  ...USAGE_LIMIT_SAFE_OPTIONS,
+  "Switch to usage credits",
+  "Switch to Team plan",
+  // ENG-9006: the two-option variant Claude Code shipped ~2026-08-17. Filed
+  // with a wedged pane and four unanswered customer Telegram messages queued
+  // behind it.
+  "Upgrade your plan",
+  "Ask your admin for more usage"
+];
 var USAGE_LIMIT_BLOCK_LINES = 6;
-var BILLING_OPTIONS = ["Switch to usage credits", "Switch to Team plan"];
 function optionRowDigit(line2, label) {
   const m = line2.match(
     new RegExp(
@@ -2410,6 +2424,27 @@ function optionRowDigit(line2, label) {
   );
   return m?.[1] ?? null;
 }
+function focusedModalBlock(screen, blockLines) {
+  const lines = screen.split("\n");
+  let footer = -1;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (lines[i].includes("Enter to confirm")) {
+      footer = i;
+      break;
+    }
+  }
+  if (footer < 0) return null;
+  return lines.slice(Math.max(0, footer - blockLines), footer);
+}
+var MCP_DIALOG_OPTIONS = [
+  "Use this and all future MCP servers in this project",
+  "Continue without using these MCP servers"
+];
+function isMcpServersDialogVisible(screen) {
+  const block = focusedModalBlock(screen, USAGE_LIMIT_BLOCK_LINES);
+  if (!block) return false;
+  return block.some((l) => MCP_DIALOG_OPTIONS.some((label) => optionRowDigit(l, label) !== null));
+}
 function usageLimitModalBlock(screen) {
   const lines = screen.split("\n");
   let footer = -1;
@@ -2421,20 +2456,38 @@ function usageLimitModalBlock(screen) {
   }
   if (footer < 0) return null;
   const block = lines.slice(Math.max(0, footer - USAGE_LIMIT_BLOCK_LINES), footer);
-  const hasBillingRow = block.some(
-    (l) => BILLING_OPTIONS.some((label) => optionRowDigit(l, label) !== null)
+  const hasKnownOptionRow = block.some(
+    (l) => USAGE_LIMIT_KNOWN_OPTIONS.some((label) => optionRowDigit(l, label) !== null)
   );
-  return hasBillingRow ? block : null;
+  return hasKnownOptionRow ? block : null;
 }
 function isUsageLimitChoiceDialogVisible(screen) {
   return usageLimitModalBlock(screen) !== null;
 }
+function findUsageLimitSafeOption(screen) {
+  const block = usageLimitModalBlock(screen);
+  if (!block) return null;
+  for (const label of USAGE_LIMIT_SAFE_OPTIONS) {
+    for (const line2 of block) {
+      const digit = optionRowDigit(line2, label);
+      if (digit !== null) return { key: digit, label };
+    }
+  }
+  return null;
+}
 function findUsageLimitSafeOptionKey(screen) {
+  return findUsageLimitSafeOption(screen)?.key ?? null;
+}
+function findUsageLimitResetHint(screen) {
   const block = usageLimitModalBlock(screen);
   if (!block) return null;
   for (const line2 of block) {
-    const digit = optionRowDigit(line2, USAGE_LIMIT_SAFE_OPTION);
-    if (digit !== null) return digit;
+    if (optionRowDigit(line2, USAGE_LIMIT_CONTINUE_OPTION) === null) continue;
+    const idx = line2.indexOf(USAGE_LIMIT_CONTINUE_OPTION);
+    const tail = line2.slice(idx + USAGE_LIMIT_CONTINUE_OPTION.length).trim();
+    const when = tail.replace(/^at\s+/i, "").trim();
+    if (!when) return null;
+    return when.slice(0, 40);
   }
   return null;
 }
@@ -2443,13 +2496,17 @@ function isUnanswerableUsageLimitDialog(screen) {
 }
 function sweepDialogs(screen) {
   if (isUsageLimitChoiceDialogVisible(screen)) {
-    const safeKey = findUsageLimitSafeOptionKey(screen);
-    if (!safeKey) return null;
+    const safe = findUsageLimitSafeOption(screen);
+    if (!safe) return null;
     return {
       kind: "usage-limit-choice",
-      keys: [safeKey, "Enter"],
+      // The log names the option ACTUALLY picked, not a fixed literal. With two
+      // selectable rows now, a constant string would make a fleet sweep unable
+      // to tell an agent that will resume by itself from one parked until a
+      // human touches it.
+      keys: [safe.key, "Enter"],
       interKeyDelayMs: 300,
-      logMessage: `Auto-answered usage-limit choice dialog (picked '${USAGE_LIMIT_SAFE_OPTION}')`
+      logMessage: `Auto-answered usage-limit choice dialog (picked '${safe.label}')`
     };
   }
   if (screen.includes("Choose the text style") || screen.includes("Dark mode") && screen.includes("Light mode")) {
@@ -2484,7 +2541,7 @@ function sweepDialogs(screen) {
       logMessage: "Auto-accepted dev channels"
     };
   }
-  if (screen.includes("Enter to confirm") && screen.includes("MCP")) {
+  if (isMcpServersDialogVisible(screen)) {
     return {
       kind: "mcp-servers",
       keys: ["Enter"],
@@ -2520,6 +2577,24 @@ async function sendDialogKeys(tmuxSession, action) {
     });
   }
 }
+function focusedConfirmDialogBlock(screen) {
+  const lines = screen.split("\n");
+  let footer = -1;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (lines[i].includes("Enter to confirm")) {
+      footer = i;
+      break;
+    }
+  }
+  if (footer < 0) return null;
+  return lines.slice(Math.max(0, footer - USAGE_LIMIT_BLOCK_LINES), footer + 1);
+}
+function isUnclaimedConfirmDialog(screen) {
+  if (focusedConfirmDialogBlock(screen) === null) return false;
+  if (sweepDialogs(screen) !== null) return false;
+  if (isUnanswerableUsageLimitDialog(screen)) return false;
+  return true;
+}
 function simpleTextHash(s) {
   let h = 0;
   for (let i = 0; i < s.length; i++) {
@@ -2529,6 +2604,7 @@ function simpleTextHash(s) {
 }
 
 // src/lib/channel-input-watchdog.ts
+var UNCLAIMED_DIALOG_ALERT_MS = 12e4;
 var STUCK_THRESHOLD_MS = 5e3;
 var MAX_ENTER_FIRES = 3;
 var DISTURB_HEAL_KEYS = ["x", "BSpace", "Enter"];
@@ -2554,30 +2630,39 @@ function decide(pane, prev, now, config = {}) {
       next: prev
     };
   }
+  const unclaimedBlock = isUnclaimedConfirmDialog(pane) ? focusedConfirmDialogBlock(pane) : null;
+  const unclaimedDialogHash = unclaimedBlock ? simpleTextHash(unclaimedBlock.join("\n")) : void 0;
   const inputText = extractInputBoxText(pane);
   if (!inputText) {
-    return { fire: false, next: void 0 };
+    return { fire: false, unclaimedDialogHash, next: void 0 };
   }
   if (inputText === "\u2026") {
-    return { fire: false, next: void 0 };
+    return { fire: false, unclaimedDialogHash, next: void 0 };
   }
   const hash = simpleTextHash(inputText);
   if (!prev || prev.lastInputHash !== hash) {
     return {
       fire: false,
+      unclaimedDialogHash,
       next: { lastInputHash: hash, firstSeenAt: now, fires: 0, lastFireAt: 0, gaveUpLogged: false }
     };
   }
   if (prev.fires >= maxFires) {
     if (!prev.gaveUpLogged) {
-      return { fire: false, gaveUp: true, next: { ...prev, gaveUpLogged: true } };
+      return {
+        fire: false,
+        gaveUp: true,
+        unclaimedDialogHash,
+        next: { ...prev, gaveUpLogged: true }
+      };
     }
-    return { fire: false, next: prev };
+    return { fire: false, unclaimedDialogHash, next: prev };
   }
   const sinceLastAttempt = prev.fires === 0 ? now - prev.firstSeenAt : now - prev.lastFireAt;
-  if (sinceLastAttempt < threshold) return { fire: false, next: prev };
+  if (sinceLastAttempt < threshold) return { fire: false, unclaimedDialogHash, next: prev };
   return {
     fire: true,
+    unclaimedDialogHash,
     next: { ...prev, fires: prev.fires + 1, lastFireAt: now }
   };
 }
@@ -2622,6 +2707,15 @@ function checkChannelInputs(codeNames, io, config = {}, states = sharedStates) {
   for (const key of [...giveUpCounts.keys()]) {
     if (!live.has(key)) giveUpCounts.delete(key);
   }
+  for (const key of [...unclaimedDialogCounts.keys()]) {
+    if (!live.has(key)) unclaimedDialogCounts.delete(key);
+  }
+  for (const key of [...unclaimedDialogSeen.keys()]) {
+    if (!live.has(key)) unclaimedDialogSeen.delete(key);
+  }
+  for (const key of [...usageLimitSignalled.keys()]) {
+    if (!live.has(key)) usageLimitSignalled.delete(key);
+  }
 }
 function checkOne(codeName, io, config, states) {
   const pane = io.capturePane(codeName);
@@ -2635,7 +2729,7 @@ function checkOne(codeName, io, config, states) {
     stuckThresholdMs: config.attachedStuckThresholdMs ?? ATTACHED_STUCK_THRESHOLD_MS
   } : config;
   const prev = states.get(codeName);
-  const { fire, dialog, gaveUp, blockedDialog, next } = decide(
+  const { fire, dialog, gaveUp, blockedDialog, unclaimedDialogHash, next } = decide(
     pane,
     prev,
     io.now(),
@@ -2651,14 +2745,23 @@ function checkOne(codeName, io, config, states) {
   } else {
     states.set(codeName, next);
   }
+  trackUnclaimedDialog(codeName, unclaimedDialogHash, io, effectiveConfig);
+  const onUsageLimitModal = dialog?.kind === "usage-limit-choice" || blockedDialog === "usage-limit-choice-unrecognised-options";
+  if (!onUsageLimitModal) usageLimitSignalled.delete(codeName);
   if (dialog) {
     io.log(
       `[channel-input-watchdog] '${codeName}': ${dialog.logMessage} (dialog was blocking the input box)`
     );
+    if (dialog.kind === "usage-limit-choice") {
+      maybeSignalUsageLimit(codeName, pane, io);
+    }
     io.sendKeys(codeName, dialog.keys, dialog.interKeyDelayMs);
     return;
   }
   if (blockedDialog) {
+    if (blockedDialog === "usage-limit-choice-unrecognised-options") {
+      maybeSignalUsageLimit(codeName, pane, io);
+    }
     io.log(
       `[channel-input-watchdog] '${codeName}': BLOCKED DIALOG (${blockedDialog}) \u2014 refusing to send any key; needs a human to attach to the pane`
     );
@@ -2710,6 +2813,49 @@ function creditWatchdogGiveUpCount(codeName, count) {
   if (count <= 0) return;
   giveUpCounts.set(codeName, (giveUpCounts.get(codeName) ?? 0) + count);
 }
+var usageLimitSignalled = /* @__PURE__ */ new Map();
+function maybeSignalUsageLimit(codeName, pane, io) {
+  if (!io.signalUsageLimit) return;
+  const hint = findUsageLimitResetHint(pane);
+  const key = hint ?? "<no-reset-named>";
+  if (usageLimitSignalled.get(codeName) === key) return;
+  usageLimitSignalled.set(codeName, key);
+  try {
+    io.signalUsageLimit(codeName, hint);
+    io.log(
+      `[channel-input-watchdog] '${codeName}': usage-limit modal \u2014 signalled the channel servers so waiting people are told` + (hint ? ` (resets ${hint})` : " (modal named no reset)")
+    );
+  } catch (err) {
+    io.log(
+      `[channel-input-watchdog] '${codeName}': usage-limit signal write failed: ${err.message}`
+    );
+  }
+}
+function trackUnclaimedDialog(codeName, hash, io, config) {
+  if (!hash) {
+    unclaimedDialogSeen.delete(codeName);
+    return;
+  }
+  const thresholdMs = config.unclaimedDialogAlertMs ?? UNCLAIMED_DIALOG_ALERT_MS;
+  const now = io.now();
+  const prev = unclaimedDialogSeen.get(codeName);
+  if (!prev || prev.hash !== hash) {
+    unclaimedDialogSeen.set(codeName, { hash, firstSeenAt: now, alerted: false });
+    return;
+  }
+  if (prev.alerted) return;
+  const ageMs = now - prev.firstSeenAt;
+  if (ageMs < thresholdMs) return;
+  unclaimedDialogSeen.set(codeName, { ...prev, alerted: true });
+  unclaimedDialogCounts.set(codeName, (unclaimedDialogCounts.get(codeName) ?? 0) + 1);
+  io.log(
+    `[channel-input-watchdog] '${codeName}': UNCLAIMED DIALOG on pane for ${Math.round(
+      ageMs / 1e3
+    )}s \u2014 a modal is focused and no handler in claude-dialogs.ts recognises it (dialog_hash=${hash}); sending nothing. Claude Code has likely reworded a dialog: attach to the pane, then add the new option labels.`
+  );
+}
+var unclaimedDialogCounts = /* @__PURE__ */ new Map();
+var unclaimedDialogSeen = /* @__PURE__ */ new Map();
 
 // src/lib/persistent-session.ts
 var OPENROUTER_ANTHROPIC_BASE_URL = "https://openrouter.ai/api";
@@ -4167,4 +4313,4 @@ export {
   stopAllSessionsAndWait,
   getProjectDir
 };
-//# sourceMappingURL=chunk-IT2WYXBM.js.map
+//# sourceMappingURL=chunk-GNTCOXZG.js.map