@integrity-labs/agt-cli 0.28.441 → 0.28.443

package/dist/bin/agt.js

@@ -40,7 +40,7 @@ import {
   success,
   table,
   warn
-} from "../chunk-6KTN6GTT.js";
+} from "../chunk-X2LHWP6E.js";
 import {
   AnchorSessionClient,
   CHANNEL_REGISTRY,
@@ -71,7 +71,7 @@ import {
   requiredMcpWildcard,
   resolveChannels,
   serializeManifestForSlackCli
-} from "../chunk-NQP2W2RD.js";
+} from "../chunk-IQX7TMYZ.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.441" : "dev";
+var cliVersion = true ? "0.28.443" : "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.441" : "dev";
+var cliVersion2 = true ? "0.28.443" : "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-NQP2W2RD.js → chunk-IQX7TMYZ.js}

@@ -1325,8 +1325,31 @@ var DEFAULT_SCOPES = [
   // links an inbound Slack sender to their organization_people record (inbound
   // identity reconcile). Existing installs without it degrade gracefully - the
   // reconcile no-ops until the bot is re-authorised with the wider scope set.
-  "users:read.email",
-  "users.profile:write"
+  "users:read.email"
+  // ENG-8203: 'users.profile:write' is deliberately NOT here.
+  //
+  // It is registered with `token_type: 'user'` (ENG-4812 — Slack rejects it
+  // under oauth_config.scopes.bot with `illegal_bot_scopes`). The MANIFEST
+  // generator partitions on that flag; the OAuth install-URL builder does not —
+  // `buildSlackAuthorizeUrl` puts every stored scope into `scope=` — so a
+  // default-scoped OAuth install sent a user-only scope as a bot scope and
+  // Slack rejected the whole authorization with "Invalid permissions
+  // requested". That blocked EVERY new install on the default set.
+  //
+  // Removing it rather than routing it to `user_scope=` is deliberate: the
+  // callback destructures `authed_user?: { id?: string }` and persists only the
+  // BOT token (oauth-callback/route.ts:217,246). `authed_user.access_token` is
+  // never read, so asking for the scope would put an extra consent screen in
+  // front of the installing admin and then discard the token it returned.
+  //
+  // Nothing is lost. `users.profile.set` needs an `xoxp-` user token, which no
+  // OAuth-installed agent has ever had — the bot-status/live-presence indicator
+  // only ever worked where an operator pasted a user token into the wizard by
+  // hand, and that path is untouched. The registry definition stays so existing
+  // configs still render and the `token_type: 'user'` knowledge is preserved.
+  //
+  // Wiring the indicator for OAuth installs means persisting
+  // `authed_user.access_token` first, THEN adding `user_scope=`. Separate work.
 ];
 function getDefaultSlackScopes() {
   return [...DEFAULT_SCOPES];
@@ -5777,10 +5800,10 @@ async function probeComposioMcpToolCall(config, fetchImpl = fetch) {
     }
     const rpcErrMsg = callRpc && "error" in callRpc ? callRpc["error"]?.message ?? "" : "";
     const result = callRpc?.["result"];
-    const contentText = (result?.content ?? []).map((c) => c.text ?? "").join(" ").trim();
-    const failed = Boolean(rpcErrMsg) || Boolean(result?.isError) || isComposioFailureEnvelope(contentText);
+    const contentText2 = (result?.content ?? []).map((c) => c.text ?? "").join(" ").trim();
+    const failed = Boolean(rpcErrMsg) || Boolean(result?.isError) || isComposioFailureEnvelope(contentText2);
     if (failed) {
-      const failureText = [rpcErrMsg, contentText].filter(Boolean).join(" ");
+      const failureText = [rpcErrMsg, contentText2].filter(Boolean).join(" ");
       const snippet = failureText.length > 200 ? `${failureText.slice(0, 200)}\u2026` : failureText;
       const kind = classifyToolCallFailure(failureText);
       if (kind === "account") {
@@ -8487,6 +8510,109 @@ function resolveUsageLimitUntil(marker, now) {
   return until.getTime() > now.getTime() ? until : null;
 }
 
+// ../../packages/core/dist/claude-code-usage/rate-limit-classifier.js
+var UNKNOWN_RATE_LIMIT = Object.freeze({
+  verdict: "unknown",
+  atMs: null,
+  resetsAt: null,
+  text: null
+});
+function contentText(record) {
+  const candidates = [record.content];
+  const message = record.message;
+  if (typeof message === "object" && message !== null) {
+    candidates.push(message.content);
+  }
+  const parts = [];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string") {
+      if (candidate)
+        parts.push(candidate);
+      continue;
+    }
+    if (!Array.isArray(candidate))
+      continue;
+    for (const block of candidate) {
+      if (typeof block === "string") {
+        if (block)
+          parts.push(block);
+        continue;
+      }
+      if (typeof block !== "object" || block === null)
+        continue;
+      const text = block.text;
+      if (typeof text === "string" && text)
+        parts.push(text);
+    }
+  }
+  const joined = parts.join("\n").trim();
+  return joined ? joined : null;
+}
+function classifyTranscriptLine(line2, startMs, endMs, now) {
+  const trimmed = line2.trim();
+  if (!trimmed)
+    return null;
+  let obj;
+  try {
+    obj = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+  if (typeof obj !== "object" || obj === null)
+    return null;
+  const record = obj;
+  if (record.type !== "assistant")
+    return null;
+  const ts = record.timestamp;
+  if (typeof ts !== "string" || !ts)
+    return null;
+  const tsMs = new Date(ts).getTime();
+  if (!Number.isFinite(tsMs) || tsMs < startMs || tsMs > endMs)
+    return null;
+  if (record.error === "rate_limit" || record.apiErrorStatus === 429) {
+    const text = contentText(record);
+    const observation = text ? parseUsageBanner(text, now ?? new Date(endMs)) : null;
+    return { verdict: "capped", atMs: tsMs, resetsAt: observation?.weekResetsAt ?? null, text };
+  }
+  if (record.isApiErrorMessage === true)
+    return null;
+  const message = record.message;
+  if (typeof message !== "object" || message === null)
+    return null;
+  const msg = message;
+  if (msg.model === "<synthetic>")
+    return null;
+  const usage = msg.usage;
+  if (typeof usage !== "object" || usage === null)
+    return null;
+  const u = usage;
+  const spent = Number(u.input_tokens ?? 0) + Number(u.output_tokens ?? 0) + Number(u.cache_creation_input_tokens ?? 0) + Number(u.cache_read_input_tokens ?? 0);
+  if (!Number.isFinite(spent) || spent <= 0)
+    return null;
+  return { verdict: "serving", atMs: tsMs, resetsAt: null, text: null };
+}
+function pickNewerClassification(current, next) {
+  if (next.verdict === "unknown")
+    return current;
+  if (current.verdict === "unknown")
+    return next;
+  return next.atMs >= current.atMs ? next : current;
+}
+function classifyTranscriptRateLimit(jsonl, startMs, endMs, now) {
+  let newest = UNKNOWN_RATE_LIMIT;
+  for (const line2 of jsonl.split("\n")) {
+    const classified = classifyTranscriptLine(line2, startMs, endMs, now);
+    if (classified)
+      newest = pickNewerClassification(newest, classified);
+  }
+  return newest;
+}
+
+// ../../packages/core/dist/claude-code-usage/transcript-location.js
+function encodeClaudeProjectPath(projectDir) {
+  return "-" + projectDir.replace(/^\//, "").replace(/[/.]/g, "-");
+}
+
 // ../../packages/core/dist/account-enforcement/marker.js
 var ACCOUNT_ENFORCEMENT_MARKER_FILENAME = "account-enforcement.json";
 var ACCOUNT_ENFORCEMENT_MARKER_VERSION = 1;
@@ -9193,6 +9319,33 @@ var FLAG_REGISTRY = [
     // projectDefinition, so setting it does not roll FLAGS_SCHEMA_VERSION.
     since: "0.28.421"
   },
+  {
+    key: "usage-limit-reactive-notice",
+    description: "Report a Claude Code usage cap REACTIVELY instead of predicting it (ENG-8201). Today the manager guesses from the agent transcript that the next turn will be refused, writes a marker, and every channel MCP refuses to dispatch on the strength of that guess - so a wrong guess is a swallowed message, and because the notice is throttled per (channel, sender) while the DROP is not, the usual symptom is total silence rather than a wrong reply. A refused turn actually costs nothing (rejected in under a second, zero tokens) and Claude Code records it with the reset time in it, so there is no need to guess: dispatch, and report the refusal if one comes back. off = today behaviour (pre-dispatch marker gate, no watcher). shadow = still gate on the marker, but ALSO watch dispatched messages and log the refusal that would have been reported - measures the true-positive rate with no user-visible change. enforce = stop reading the marker before dispatch; every admitted human message reaches the agent and a refusal is answered in-thread with the reset time from the error itself. Read live from the heartbeat flags-cache (or the env override).",
+    flagType: "enum",
+    allowedValues: ["off", "shadow", "enforce"],
+    // Ships dark: off preserves today's gate byte-for-byte. shadow is a free
+    // local log line (the watch is a transcript read, no model spend), so it is a
+    // cheap soak; enforce changes what reaches the agent, so it is the audited
+    // per-org flip.
+    defaultValue: "off",
+    // Enum override AGT_USAGE_LIMIT_REACTIVE_MODE (off|shadow|enforce), resolved
+    // by resolveUsageLimitReactiveMode in the channel-server bundle.
+    envVar: "AGT_USAGE_LIMIT_REACTIVE_MODE",
+    // enforce sends a message to an agent the host currently believes is capped -
+    // a deliberate availability trade (the refusal is free, but it is still a
+    // dispatch the operator previously suppressed), so flipping toward it is an
+    // audited change (ADR-0022 sensitive-flag confirm).
+    sensitive: true
+    // ENG-8149: `since` is the agt-cli version that first carries
+    // resolveUsageLimitReactiveMode + the MCP watcher. It cannot be known before
+    // this lands (the auto-publish patch-bumps on merge), and an undefined
+    // `since` makes the flip-reach modal claim FULL reach - true for flags that
+    // predate the reach work, wrong for a NEW host-read flag whose reader older
+    // hosts simply do not have. Backfilled by a follow-up commit once the
+    // publishing run reports the version. Excluded from projectDefinition, so
+    // setting it does not roll FLAGS_SCHEMA_VERSION.
+  },
   {
     key: "slack-hot-thread-guard",
     description: "Server-side hot-thread guard on the slack.reply surface (ENG-7462). Prevents an agent posting a NEW top-level Slack message when it meant to reply inside the thread it is already working in - a prompt/memory rule proved insufficient (the agent had the rule and still slipped). When a reply would otherwise post to channel ROOT (no thread_ts / message_ts / inbound_id, no active kanban card) and the agent has a recent active thread in that channel (its last bot-posted thread, from the persisted trackedThreads cache, within a freshness window), the reply is redirected into that thread. proactive:true no longer implies channel root; posting at root becomes a deliberate action (the to_channel_root flag, or the thread_ts:null sentinel). off = guard never runs, replies with no coords root exactly as today (ships dark). shadow = compute + log the would-redirect but STILL post to root (measure the fire rate before acting). enforce = apply the redirect (a soft-block: redirect + inform, never a hard rejection). Read live from the heartbeat flags-cache (or the env override); enforce is a deliberate per-org flip after a shadow soak.",
@@ -12439,9 +12592,7 @@ function rotateDailySession(codeName, now = /* @__PURE__ */ new Date(), timezone
   writeFile(codeName, { current: next, history });
   return next.sessionId;
 }
-function encodeProjectPath(projectDir) {
-  return "-" + projectDir.replace(/^\//, "").replace(/[/.]/g, "-");
-}
+var encodeProjectPath = encodeClaudeProjectPath;
 function sessionFileExists(projectDir, sessionId) {
   const path = join4(
     homedir4(),
@@ -12943,7 +13094,7 @@ function restartEgressSidecar(codeName) {
   }
 }
 function buildDockerRunCommand(args) {
-  const { codeName, agentId, wrapperPath, projectDir, homeDir, runId, passApiKey, passOpenRouter, egress, forwardSlackReplyBinding, forwardBlockTurnEndAllMarkers, forwardKanbanWaiting, forwardNotifyDispatch } = args;
+  const { codeName, agentId, wrapperPath, projectDir, homeDir, runId, passApiKey, passOpenRouter, egress, forwardSlackReplyBinding, forwardBlockTurnEndAllMarkers, forwardKanbanWaiting, forwardNotifyDispatch, forwardUsageLimitReactive } = args;
   const q = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
   const agentDir2 = join5(homeDir, ".augmented", codeName);
   const agentIdDir = join5(homeDir, ".augmented", agentId);
@@ -12980,6 +13131,7 @@ function buildDockerRunCommand(args) {
   if (forwardBlockTurnEndAllMarkers) envArgs.push("-e AGT_BLOCK_TURN_END_ALL_MARKERS_ENABLED");
   if (forwardKanbanWaiting) envArgs.push("-e AGT_KANBAN_WAITING_ENABLED");
   if (forwardNotifyDispatch) envArgs.push("-e AGT_NOTIFY_DISPATCH");
+  if (forwardUsageLimitReactive) envArgs.push("-e AGT_USAGE_LIMIT_REACTIVE_MODE");
   const egressImage = process.env.AGT_EGRESS_IMAGE || "agt-squid:latest";
   const internalNet = `agt-net-${codeName}`;
   const squidName = `agt-squid-${codeName}`;
@@ -13333,6 +13485,12 @@ function spawnSession(config, session) {
     if (config.notifyDispatchMode && config.notifyDispatchMode !== "off" && !process.env["AGT_NOTIFY_DISPATCH"]) {
       tmuxSessionEnvArgs.push("-e", `AGT_NOTIFY_DISPATCH=${config.notifyDispatchMode}`);
     }
+    if (config.usageLimitReactiveMode && config.usageLimitReactiveMode !== "off" && !process.env["AGT_USAGE_LIMIT_REACTIVE_MODE"]) {
+      tmuxSessionEnvArgs.push(
+        "-e",
+        `AGT_USAGE_LIMIT_REACTIVE_MODE=${config.usageLimitReactiveMode}`
+      );
+    }
     const sessionHomeDir = process.env.HOME?.trim() || homedir5();
     let egress;
     if (egressMode(codeName) === "allowlist") {
@@ -13365,7 +13523,13 @@ function spawnSession(config, session) {
       // ENG-7682 (notify Slice 1): forward AGT_NOTIFY_DISPATCH if it will be in
       // the session env (operator-set OR materialized from the flag above).
       forwardNotifyDispatch: !!process.env["AGT_NOTIFY_DISPATCH"] || // feature-gate-allow: registry-flag envVar operator-override precedence, not a new gate
-      !!config.notifyDispatchMode && config.notifyDispatchMode !== "off"
+      !!config.notifyDispatchMode && config.notifyDispatchMode !== "off",
+      // ENG-8201: forward AGT_USAGE_LIMIT_REACTIVE_MODE if it will be in the
+      // session env (operator-set OR materialized from the flag above). This
+      // is the ONLY way the flag reaches an isolated agent — the flags-cache
+      // is not in the container's mount set.
+      forwardUsageLimitReactive: !!process.env["AGT_USAGE_LIMIT_REACTIVE_MODE"] || // feature-gate-allow: registry-flag envVar operator-override precedence, not a new gate
+      !!config.usageLimitReactiveMode && config.usageLimitReactiveMode !== "off"
     }) : JSON.stringify(wrapperPath);
     const tmuxEnv = {
       ...process.env,
@@ -14045,6 +14209,9 @@ export {
   serializeUsageLimitMarker,
   parseUsageLimitMarker,
   resolveUsageLimitUntil,
+  UNKNOWN_RATE_LIMIT,
+  pickNewerClassification,
+  classifyTranscriptRateLimit,
   ACCOUNT_ENFORCEMENT_MARKER_FILENAME,
   serializeAccountEnforcementMarker,
   KANBAN_CHECK_COMMAND,
@@ -14125,4 +14292,4 @@ export {
   stopAllSessionsAndWait,
   getProjectDir
 };
-//# sourceMappingURL=chunk-NQP2W2RD.js.map
+//# sourceMappingURL=chunk-IQX7TMYZ.js.map