@integrity-labs/agt-cli 0.28.446 → 0.28.448

package/dist/bin/agt.js

@@ -40,7 +40,7 @@ import {
   success,
   table,
   warn
-} from "../chunk-O25GO4PT.js";
+} from "../chunk-JUUAHLX5.js";
 import {
   AnchorSessionClient,
   CHANNEL_REGISTRY,
@@ -71,7 +71,7 @@ import {
   requiredMcpWildcard,
   resolveChannels,
   serializeManifestForSlackCli
-} from "../chunk-QCEQRMBX.js";
+} from "../chunk-ESZRW7A3.js";
 import "../chunk-XWVM4KPK.js";
 
 // src/bin/agt.ts
@@ -4830,7 +4830,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.446" : "dev";
+var cliVersion = true ? "0.28.448" : "dev";
 async function fetchLatestVersion() {
   const host2 = getHost();
   if (!host2) return null;
@@ -6002,7 +6002,7 @@ function handleError(err) {
 }
 
 // src/bin/agt.ts
-var cliVersion2 = true ? "0.28.446" : "dev";
+var cliVersion2 = true ? "0.28.448" : "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-QCEQRMBX.js → chunk-ESZRW7A3.js}

@@ -3714,19 +3714,22 @@ acknowledge before you start.
 
 - **FAST (< 60s):** handle inline. Reply via the channel tool and end your turn.
 
-- **SLOW (\u2265 60s):** acknowledge first, then handle inline.
+- **SLOW (\u2265 60s):** acknowledge first, then either dispatch or handle inline.
   1. Send a one-line acknowledgement via the channel tool \u2014 short, warm, and tell
      the user you'll come back. Shape (don't copy verbatim, match your voice):
      "On it, this'll take a minute or two, I'll ping when it's done."
-  2. Do the work yourself in this same session, with whatever tools you need \u2014
-     your parent session has the full MCP surface bound.
-  3. Reply with the result via the channel tool, in the same thread / chat /
-     conversation you acknowledged in step 1.
-
-> **Why inline, not sub-agent dispatch:** an upstream Claude Code bug empties the
-> MCP registry for \`tools:\`-allowlisted sub-agents (\`channel-message-handler\` among
-> them), so a dispatched reply silently never lands \u2014 see \xA7 Background dispatch.
-> Handle slow channel work inline until the upstream fix ships.
+  2. Dispatch the work to the \`channel-message-handler\` sub-agent, passing the
+     inbound's identifiers so it replies into the same thread / chat / conversation
+     you acknowledged in step 1. It binds the full MCP surface and posts the reply
+     itself, which keeps this listener turn free for new inbound.
+  3. Handling it inline instead is fine, and often better when you are already deep
+     in the relevant context or dispatch would cost more than the work. Either way,
+     reply with the result via the channel tool in the same conversation.
+
+> **Whoever does the work, the delivery rule still binds:** the reply exists only if
+> a channel reply tool was called. If you dispatch, the sub-agent owns that call \u2014 so
+> confirm it reported success, and if it came back without having replied, reply
+> yourself rather than assuming the user was answered.
 
 Diving into slow work silently leaves operators wondering whether you got the
 message. If a request you started as FAST turns out slow, post a quick "this is
@@ -3753,19 +3756,25 @@ check-in is itself evidence your earlier silence read as non-responsiveness.
 
 For background tool work that **isn't** a channel reply \u2014 multi-step data pulls,
 CRM enrichments, research workflows, cross-MCP orchestration \u2014 use
-\`subagent_type: general-purpose\` (Anthropic's built-in). It inherits the full MCP
-tool surface from this session and reliably binds every \`mcp__*\` server.
-
-**Why not \`augmented-worker\` for now:** an upstream Claude Code bug
-([anthropics/claude-code#64909](https://github.com/anthropics/claude-code/issues/64909))
-gives sub-agents with an explicit \`tools:\` allowlist an empty MCP registry \u2014 every
-\`mcp__*\` call returns "No such tool available". \`general-purpose\` uses \`tools: *\`
-(inherit-all) and escapes it; when the fix ships, \`augmented-worker\` (restricted
-surface) becomes preferred again automatically.
-
-For slow **channel** replies see \xA7 FIRST ACTION \u2014 handled inline for the same
-reason (\`channel-message-handler\` has the same allowlist shape; 0/6 MCP tools
-bound, confirmed 2026-06-03). When the fix lands, both switch back to dispatch.
+\`subagent_type: augmented-worker\`. It carries an explicit allowlist covering every
+MCP server this session has wired, so it gets the tool surface the task needs and
+no more. Reach for \`general-purpose\` (\`tools: *\`, inherit-all) only when you
+genuinely need something outside that allowlist.
+
+**Historical note \u2014 do not reintroduce the old workaround.** An upstream Claude Code
+bug ([anthropics/claude-code#64909](https://github.com/anthropics/claude-code/issues/64909))
+used to hand sub-agents with an explicit \`tools:\` allowlist an empty MCP registry:
+every \`mcp__*\` call returned "No such tool available". That is why this section
+once steered all dispatch to \`general-purpose\` and why slow channel replies were
+handled inline. Anthropic fixed it in **v2.1.163** \u2014 \`mcp__<server>__*\` wildcards in
+sub-agent \`tools:\` frontmatter now expand to the matching MCP tools instead of
+failing an exact-name lookup. Re-verified 2026-07-29 on 2.1.220: a
+\`channel-message-handler\` dispatch reached 469 \`mcp__*\` tools across four servers
+with zero "No such tool available".
+
+For slow **channel** replies see \xA7 FIRST ACTION \u2014 dispatch to
+\`channel-message-handler\`, which binds the same full MCP surface and posts the
+reply itself.
 
 ${activeTasksSection}${personalitySection}${writingStyleSection}## Identity
 
@@ -3789,10 +3798,9 @@ ${resolvedChannels?.includes("slack") ? `
 ## Slack
 
 You have a Slack MCP server connected. **First, see
-\xA7 FIRST ACTION on every channel message: triage** \u2014 decide fast vs slow, then
-acknowledge inline before slow work
-(sub-agent dispatch for channel replies is currently disabled by an upstream Claude
-Code bug; see FIRST ACTION for the rationale).
+\xA7 FIRST ACTION on every channel message: triage** \u2014 decide fast vs slow, and
+acknowledge before slow work (which you can then dispatch to
+\`channel-message-handler\` or handle inline; see FIRST ACTION).
 
 For fast requests, reply with \`slack.reply\` (per the delivery rule in FIRST ACTION,
 a plain-text turn does NOT reach Slack \u2014 only a \`slack.reply\` call does). Tools:
@@ -12728,7 +12736,59 @@ function isResumeModeDialogVisible(screen) {
 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_BLOCK_LINES = 6;
+var BILLING_OPTIONS = ["Switch to usage credits", "Switch to Team plan"];
+function optionRowDigit(line2, label) {
+  const m = line2.match(
+    new RegExp(
+      String.raw`^[^\S\n]*(?:❯[^\S\n]*)?(\d)\.[^\S\n]*` + label.replace(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)
+    )
+  );
+  return m?.[1] ?? null;
+}
+function usageLimitModalBlock(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;
+  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)
+  );
+  return hasBillingRow ? block : null;
+}
+function isUsageLimitChoiceDialogVisible(screen) {
+  return usageLimitModalBlock(screen) !== null;
+}
+function findUsageLimitSafeOptionKey(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;
+  }
+  return null;
+}
+function isUnanswerableUsageLimitDialog(screen) {
+  return isUsageLimitChoiceDialogVisible(screen) && findUsageLimitSafeOptionKey(screen) === null;
+}
 function sweepDialogs(screen) {
+  if (isUsageLimitChoiceDialogVisible(screen)) {
+    const safeKey = findUsageLimitSafeOptionKey(screen);
+    if (!safeKey) return null;
+    return {
+      kind: "usage-limit-choice",
+      keys: [safeKey, "Enter"],
+      interKeyDelayMs: 300,
+      logMessage: `Auto-answered usage-limit choice dialog (picked '${USAGE_LIMIT_SAFE_OPTION}')`
+    };
+  }
   if (screen.includes("Choose the text style") || screen.includes("Dark mode") && screen.includes("Light mode")) {
     return {
       kind: "theme-picker",
@@ -12824,6 +12884,13 @@ function decide(pane, prev, now, config = {}) {
   if (dialogAction) {
     return { fire: false, dialog: dialogAction, next: prev };
   }
+  if (isUnanswerableUsageLimitDialog(pane)) {
+    return {
+      fire: false,
+      blockedDialog: "usage-limit-choice-unrecognised-options",
+      next: prev
+    };
+  }
   const inputText = extractInputBoxText(pane);
   if (!inputText) {
     return { fire: false, next: void 0 };
@@ -12905,7 +12972,12 @@ function checkOne(codeName, io, config, states) {
     stuckThresholdMs: config.attachedStuckThresholdMs ?? ATTACHED_STUCK_THRESHOLD_MS
   } : config;
   const prev = states.get(codeName);
-  const { fire, dialog, gaveUp, next } = decide(pane, prev, io.now(), effectiveConfig);
+  const { fire, dialog, gaveUp, blockedDialog, next } = decide(
+    pane,
+    prev,
+    io.now(),
+    effectiveConfig
+  );
   if (next === void 0) {
     states.delete(codeName);
     if (prev && prev.fires > 0) {
@@ -12923,6 +12995,12 @@ function checkOne(codeName, io, config, states) {
     io.sendKeys(codeName, dialog.keys, dialog.interKeyDelayMs);
     return;
   }
+  if (blockedDialog) {
+    io.log(
+      `[channel-input-watchdog] '${codeName}': BLOCKED DIALOG (${blockedDialog}) \u2014 refusing to send any key; needs a human to attach to the pane`
+    );
+    return;
+  }
   const text = extractInputBoxText(pane) ?? "";
   const hash = next?.lastInputHash ?? simpleTextHash(text);
   if (gaveUp) {
@@ -13685,6 +13763,12 @@ async function acceptDialogs(tmuxSession, codeName, log2, primaryModel = null, s
         log2(`[persistent-session] ${dialogAction.logMessage} for '${codeName}'`);
         continue;
       }
+      if (isUnanswerableUsageLimitDialog(screen)) {
+        log2(
+          `[persistent-session] BLOCKED DIALOG (usage-limit-choice-unrecognised-options) for '${codeName}' \u2014 refusing to send any key; needs a human to attach to the pane`
+        );
+        return;
+      }
       if (screen.includes("\u276F") && !screen.includes("Enter to confirm")) {
         if (hasMcpChildren(tmuxSession)) {
           log2(`[persistent-session] Session ready for '${codeName}' \u2014 MCP servers spawned`);
@@ -13799,6 +13883,12 @@ async function preSendPaneHygiene(tmuxSession, codeName, log2) {
       await new Promise((r) => setTimeout(r, 300));
       screen = paneCapture(tmuxSession) ?? "";
     }
+    if (isUnanswerableUsageLimitDialog(screen)) {
+      log2(
+        `[inject] BLOCKED DIALOG (usage-limit-choice-unrecognised-options) for '${codeName}' \u2014 skipping pane hygiene; needs a human to attach to the pane`
+      );
+      return;
+    }
     const orphan = extractInputBoxText(screen);
     if (orphan) {
       log2(
@@ -14313,4 +14403,4 @@ export {
   stopAllSessionsAndWait,
   getProjectDir
 };
-//# sourceMappingURL=chunk-QCEQRMBX.js.map
+//# sourceMappingURL=chunk-ESZRW7A3.js.map