@integrity-labs/agt-cli 0.28.441 → 0.28.443

package/dist/mcp/direct-chat-channel.js

@@ -18867,7 +18867,7 @@ var require_filters = __commonJS({
       return r.copySafeness(str, res);
     }
     _exports.indent = indent;
-    function join13(arr, del, attr) {
+    function join14(arr, del, attr) {
       del = del || "";
       if (attr) {
         arr = lib.map(arr, function(v) {
@@ -18876,7 +18876,7 @@ var require_filters = __commonJS({
       }
       return arr.join(del);
     }
-    _exports.join = join13;
+    _exports.join = join14;
     function last(arr) {
       return arr[arr.length - 1];
     }
@@ -30087,6 +30087,40 @@ function resolveHostBooleanFlag(opts) {
   if (cached2 !== void 0) return cached2;
   return opts.defaultValue;
 }
+var USAGE_LIMIT_REACTIVE_FLAG_KEY = "usage-limit-reactive-notice";
+function parseUsageLimitReactiveMode(raw) {
+  if (raw === void 0) return void 0;
+  const v = raw.trim().toLowerCase();
+  if (v === "") return void 0;
+  if (v === "off" || v === "shadow" || v === "enforce") return v;
+  const b = envBoolean(raw);
+  if (b === true) return "enforce";
+  if (b === false) return "off";
+  return void 0;
+}
+function cachedUsageLimitReactiveMode(path) {
+  try {
+    if (!existsSync4(path)) return void 0;
+    const parsed = JSON.parse(readFileSync6(path, "utf8"));
+    if (!parsed || typeof parsed !== "object") return void 0;
+    const flags = parsed.flags;
+    if (!flags || typeof flags !== "object") return void 0;
+    const value = flags[USAGE_LIMIT_REACTIVE_FLAG_KEY];
+    if (typeof value === "string") return parseUsageLimitReactiveMode(value);
+    if (typeof value === "boolean") return value ? "enforce" : "off";
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolveUsageLimitReactiveMode(opts) {
+  const env2 = opts?.env ?? process.env;
+  const modeOverride = parseUsageLimitReactiveMode(env2["AGT_USAGE_LIMIT_REACTIVE_MODE"]);
+  if (modeOverride !== void 0) return modeOverride;
+  const cached2 = cachedUsageLimitReactiveMode(opts?.cachePath ?? defaultFlagsCachePath());
+  if (cached2 !== void 0) return cached2;
+  return "off";
+}
 
 // src/ack-reaction.ts
 var REPLY_WEDGED_THRESHOLD_MS = 5 * 60 * 1e3;
@@ -30399,19 +30433,19 @@ function readLockHolder(path) {
 }
 
 // src/direct-chat-channel.ts
-import { homedir as homedir4 } from "os";
-import { join as join12 } from "path";
+import { homedir as homedir5 } from "os";
+import { join as join13 } from "path";
 import { randomUUID } from "crypto";
 import {
   watch,
   mkdirSync as mkdirSync5,
   writeFileSync as writeFileSync6,
-  readFileSync as readFileSync11,
-  readdirSync as readdirSync4,
+  readFileSync as readFileSync12,
+  readdirSync as readdirSync5,
   existsSync as existsSync6,
   renameSync as renameSync5,
   unlinkSync as unlinkSync4,
-  statSync as statSync2,
+  statSync as statSync3,
   createWriteStream
 } from "fs";
 
@@ -31989,8 +32023,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.
 ];
 var SLACK_SCOPE_PRESETS = {
   minimal: [
@@ -34142,7 +34199,113 @@ var BANNER_PATTERNS = [
   // pct=100.
   new RegExp(`${SUBJECT}hit\\s+your\\s+(?:[a-z0-9-]+\\s+)?limit${SEP}resets\\s+(${RESET_DATE})`, "i")
 ];
+function parseUsageBanner(text, now = /* @__PURE__ */ new Date()) {
+  let bestIndex = -1;
+  let best = null;
+  for (let i = 0; i < BANNER_PATTERNS.length; i++) {
+    const pattern = new RegExp(BANNER_PATTERNS[i].source, "gi");
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      if (match.index === pattern.lastIndex)
+        pattern.lastIndex++;
+      let pct;
+      let resetStr;
+      if (i === 0) {
+        pct = Number.parseInt(match[1], 10);
+        resetStr = match[2];
+      } else {
+        pct = 100;
+        resetStr = match[1];
+      }
+      if (!Number.isFinite(pct) || pct < 0 || pct > 100)
+        continue;
+      const nextChar = text[match.index + match[0].length];
+      if (nextChar !== void 0 && /[A-Za-z0-9]/.test(nextChar))
+        continue;
+      const weekResetsAt = parseResetDateTime(resetStr, now);
+      if (!weekResetsAt)
+        continue;
+      if (match.index >= bestIndex) {
+        bestIndex = match.index;
+        best = { pct, weekResetsAt };
+      }
+    }
+  }
+  return best;
+}
+var MONTHS = [
+  "jan",
+  "feb",
+  "mar",
+  "apr",
+  "may",
+  "jun",
+  "jul",
+  "aug",
+  "sep",
+  "oct",
+  "nov",
+  "dec"
+];
+var TIME_TAIL = /,\s*(\d{1,2})(?::(\d{2}))?\s*(am|pm)(?:\s*\(?UTC\)?)?\s*$/i;
+var TIME_ONLY = /^(\d{1,2})(?::(\d{2}))?\s*(am|pm)(?:\s*\(?UTC\)?)?$/i;
 var MS_PER_DAY = 24 * 60 * 60 * 1e3;
+function parseAmPm(hourStr, minStr, ampm) {
+  const rawHour = Number.parseInt(hourStr, 10);
+  if (!Number.isFinite(rawHour) || rawHour < 1 || rawHour > 12)
+    return null;
+  let minute = 0;
+  if (minStr) {
+    minute = Number.parseInt(minStr, 10);
+    if (!Number.isFinite(minute) || minute < 0 || minute > 59)
+      return null;
+  }
+  const isPm = ampm.toLowerCase() === "pm";
+  return { hour: rawHour % 12 + (isPm ? 12 : 0), minute };
+}
+function parseResetDateTime(humanDate, now) {
+  const trimmed = humanDate.trim();
+  const timeOnly = trimmed.match(TIME_ONLY);
+  if (timeOnly) {
+    const hm = parseAmPm(timeOnly[1], timeOnly[2], timeOnly[3]);
+    if (!hm)
+      return null;
+    const todayAt = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), hm.hour, hm.minute);
+    return new Date(todayAt <= now.getTime() ? todayAt + MS_PER_DAY : todayAt);
+  }
+  const timeMatch = trimmed.match(TIME_TAIL);
+  const dateOnly = timeMatch ? trimmed.slice(0, timeMatch.index).trim() : trimmed;
+  const parts = dateOnly.split(/\s+/);
+  if (parts.length !== 2)
+    return null;
+  const month = MONTHS.indexOf(parts[0].slice(0, 3).toLowerCase());
+  if (month < 0)
+    return null;
+  const day = Number.parseInt(parts[1], 10);
+  if (!Number.isFinite(day) || day < 1 || day > 31)
+    return null;
+  let hour = 0;
+  let minute = 0;
+  if (timeMatch) {
+    const hm = parseAmPm(timeMatch[1], timeMatch[2], timeMatch[3]);
+    if (!hm)
+      return null;
+    hour = hm.hour;
+    minute = hm.minute;
+  }
+  const baseYear = now.getUTCFullYear();
+  let resolved = null;
+  let bestDelta = Number.POSITIVE_INFINITY;
+  for (const y of [baseYear - 1, baseYear, baseYear + 1]) {
+    const candidate = new Date(Date.UTC(y, month, day, hour, minute));
+    const delta = Math.abs(candidate.getTime() - now.getTime());
+    if (delta < bestDelta) {
+      bestDelta = delta;
+      resolved = candidate;
+    }
+  }
+  return resolved;
+}
 
 // ../core/dist/claude-code-usage/usage-limit-marker.js
 var USAGE_LIMIT_MARKER_FILENAME = "claude-usage-limit.json";
@@ -34180,6 +34343,109 @@ function buildUsageLimitReplyText(limitedUntil) {
   return `Your agent has hit its Claude Code usage limit until ${formatUtcClock(limitedUntil)}. It'll pick back up once the limit resets \u2014 please try again after then.`;
 }
 
+// ../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(record2) {
+  const candidates = [record2.content];
+  const message = record2.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(line, startMs, endMs, now) {
+  const trimmed = line.trim();
+  if (!trimmed)
+    return null;
+  let obj;
+  try {
+    obj = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+  if (typeof obj !== "object" || obj === null)
+    return null;
+  const record2 = obj;
+  if (record2.type !== "assistant")
+    return null;
+  const ts = record2.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 (record2.error === "rate_limit" || record2.apiErrorStatus === 429) {
+    const text = contentText(record2);
+    const observation = text ? parseUsageBanner(text, now ?? new Date(endMs)) : null;
+    return { verdict: "capped", atMs: tsMs, resetsAt: observation?.weekResetsAt ?? null, text };
+  }
+  if (record2.isApiErrorMessage === true)
+    return null;
+  const message = record2.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 line of jsonl.split("\n")) {
+    const classified = classifyTranscriptLine(line, startMs, endMs, now);
+    if (classified)
+      newest = pickNewerClassification(newest, classified);
+  }
+  return newest;
+}
+
+// ../core/dist/claude-code-usage/transcript-location.js
+function encodeClaudeProjectPath(projectDir) {
+  return "-" + projectDir.replace(/^\//, "").replace(/[/.]/g, "-");
+}
+
 // ../core/dist/account-enforcement/marker.js
 var ACCOUNT_ENFORCEMENT_MARKER_FILENAME = "account-enforcement.json";
 var ACCOUNT_ENFORCEMENT_MARKER_VERSION = 1;
@@ -34824,6 +35090,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.",
@@ -35547,6 +35840,75 @@ function shouldSendAccountWarn(opts) {
   }).reply;
 }
 
+// src/rate-limit-watch.ts
+import { readFileSync as readFileSync11, readdirSync as readdirSync4, statSync as statSync2 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join12 } from "path";
+var DEFAULT_WATCH_MS = 5e3;
+var DEFAULT_POLL_MS = 400;
+function agentTranscriptDir(opts) {
+  const cwd = opts?.cwd ?? process.cwd();
+  const home = opts?.home ?? homedir4();
+  return join12(home, ".claude", "projects", encodeClaudeProjectPath(cwd));
+}
+function classifyTranscriptSince(opts) {
+  const dir = opts.transcriptDir ?? agentTranscriptDir({ cwd: opts.cwd, home: opts.home });
+  let entries;
+  try {
+    entries = readdirSync4(dir);
+  } catch {
+    return UNKNOWN_RATE_LIMIT;
+  }
+  let newest = UNKNOWN_RATE_LIMIT;
+  for (const name of entries) {
+    if (!name.endsWith(".jsonl")) continue;
+    const path = join12(dir, name);
+    try {
+      const st = statSync2(path);
+      if (!st.isFile() || st.mtimeMs < opts.sinceMs) continue;
+    } catch {
+      continue;
+    }
+    let content;
+    try {
+      content = readFileSync11(path, "utf-8");
+    } catch {
+      continue;
+    }
+    newest = pickNewerClassification(
+      newest,
+      classifyTranscriptRateLimit(content, opts.sinceMs, opts.nowMs, new Date(opts.nowMs))
+    );
+  }
+  return newest;
+}
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function watchForRateLimitRefusal(opts) {
+  const now = opts.now ?? (() => Date.now());
+  const wait = opts.wait ?? sleep;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_WATCH_MS;
+  const pollMs = opts.pollMs ?? DEFAULT_POLL_MS;
+  const deadline = now() + timeoutMs;
+  for (; ; ) {
+    let result;
+    try {
+      result = classifyTranscriptSince({
+        sinceMs: opts.sinceMs,
+        nowMs: now(),
+        transcriptDir: opts.transcriptDir,
+        cwd: opts.cwd,
+        home: opts.home
+      });
+    } catch {
+      return null;
+    }
+    if (result.verdict === "capped") return result;
+    if (result.verdict === "serving") return null;
+    if (now() >= deadline) return null;
+    await wait(pollMs);
+  }
+}
+
 // src/direct-chat-channel.ts
 var DIRECT_CHAT_MAINTENANCE_CACHE = /* @__PURE__ */ new Map();
 var DIRECT_CHAT_MAINTENANCE_COOLDOWN_MS = (() => {
@@ -35565,21 +35927,21 @@ var DIRECT_CHAT_ACCOUNT_WARN_COOLDOWN_MS = (() => {
 var AGT_HOST = process.env.AGT_HOST;
 var AGT_API_KEY = process.env.AGT_API_KEY;
 var AGT_AGENT_ID = process.env.AGT_AGENT_ID;
-var DIRECT_CHAT_AGENT_DIR = AGT_AGENT_ID ? join12(homedir4(), ".augmented", AGT_AGENT_ID) : null;
+var DIRECT_CHAT_AGENT_DIR = AGT_AGENT_ID ? join13(homedir5(), ".augmented", AGT_AGENT_ID) : null;
 var INBOUND_ATTACHMENTS_DIR = resolveInboundAttachmentsDir({
   codeName: process.env.AGT_AGENT_CODE_NAME,
   turnInitiatorFile: process.env.AGT_TURN_INITIATOR_FILE,
   agentId: AGT_AGENT_ID,
-  homeDir: homedir4()
+  homeDir: homedir5()
 });
 var AGT_AGENT_CODE_NAME = process.env.AGT_AGENT_CODE_NAME;
 var directChatStderrLogStream = null;
 if (AGT_AGENT_CODE_NAME) {
   try {
-    const logDir = join12(homedir4(), ".augmented", AGT_AGENT_CODE_NAME);
+    const logDir = join13(homedir5(), ".augmented", AGT_AGENT_CODE_NAME);
     mkdirSync5(logDir, { recursive: true });
     directChatStderrLogStream = createWriteStream(
-      join12(logDir, "direct-chat-channel-stderr.log"),
+      join13(logDir, "direct-chat-channel-stderr.log"),
       { flags: "a", mode: 384 }
     );
     directChatStderrLogStream.on("error", () => {
@@ -35598,10 +35960,10 @@ if (AGT_AGENT_CODE_NAME) {
   } catch {
   }
 }
-var PROGRESS_HEARTBEAT_PATH = AGT_AGENT_CODE_NAME ? join12(homedir4(), ".augmented", AGT_AGENT_CODE_NAME, "channel-progress-heartbeat.json") : null;
-var DIRECT_CHAT_PENDING_INBOUND_DIR = AGT_AGENT_CODE_NAME ? join12(homedir4(), ".augmented", AGT_AGENT_CODE_NAME, "direct-chat-pending-inbound") : null;
-var DIRECT_CHAT_DELIVERY_LEDGER_DIR = AGT_AGENT_CODE_NAME ? join12(homedir4(), ".augmented", AGT_AGENT_CODE_NAME, ".agt-inbound-delivery-ledger") : null;
-var DIRECT_CHAT_CODE_NAME_AGENT_DIR = AGT_AGENT_CODE_NAME ? join12(homedir4(), ".augmented", AGT_AGENT_CODE_NAME) : null;
+var PROGRESS_HEARTBEAT_PATH = AGT_AGENT_CODE_NAME ? join13(homedir5(), ".augmented", AGT_AGENT_CODE_NAME, "channel-progress-heartbeat.json") : null;
+var DIRECT_CHAT_PENDING_INBOUND_DIR = AGT_AGENT_CODE_NAME ? join13(homedir5(), ".augmented", AGT_AGENT_CODE_NAME, "direct-chat-pending-inbound") : null;
+var DIRECT_CHAT_DELIVERY_LEDGER_DIR = AGT_AGENT_CODE_NAME ? join13(homedir5(), ".augmented", AGT_AGENT_CODE_NAME, ".agt-inbound-delivery-ledger") : null;
+var DIRECT_CHAT_CODE_NAME_AGENT_DIR = AGT_AGENT_CODE_NAME ? join13(homedir5(), ".augmented", AGT_AGENT_CODE_NAME) : null;
 var DIRECT_CHAT_STALE_MARKER_MS = 24 * 60 * 60 * 1e3;
 function recordDirectChatDelivery(sessionId, messageIds) {
   if (!sessionId) return;
@@ -35612,8 +35974,8 @@ function recordDirectChatDelivery(sessionId, messageIds) {
     delivered_at: (/* @__PURE__ */ new Date()).toISOString()
   });
 }
-var DIRECT_CHAT_RECOVERY_OUTBOX_DIR = AGT_AGENT_CODE_NAME ? join12(homedir4(), ".augmented", AGT_AGENT_CODE_NAME, "direct-chat-recovery-outbox") : null;
-var DIRECT_CHAT_RECOVERY_LEDGER_DIR = AGT_AGENT_CODE_NAME ? join12(homedir4(), ".augmented", AGT_AGENT_CODE_NAME, ".agt-direct-chat-recovery-ledger") : null;
+var DIRECT_CHAT_RECOVERY_OUTBOX_DIR = AGT_AGENT_CODE_NAME ? join13(homedir5(), ".augmented", AGT_AGENT_CODE_NAME, "direct-chat-recovery-outbox") : null;
+var DIRECT_CHAT_RECOVERY_LEDGER_DIR = AGT_AGENT_CODE_NAME ? join13(homedir5(), ".augmented", AGT_AGENT_CODE_NAME, ".agt-direct-chat-recovery-ledger") : null;
 var progressReceivedAt = /* @__PURE__ */ new Map();
 var directChatProgressState = { tracked: null };
 var directChatProgressTickRunning = false;
@@ -35632,7 +35994,7 @@ var directChatKanbanCardClient = createKanbanCardActiveClient({
 function readProgressHeartbeat() {
   if (!PROGRESS_HEARTBEAT_PATH || !existsSync6(PROGRESS_HEARTBEAT_PATH)) return null;
   try {
-    return parseProgressHeartbeat(readFileSync11(PROGRESS_HEARTBEAT_PATH, "utf-8"));
+    return parseProgressHeartbeat(readFileSync12(PROGRESS_HEARTBEAT_PATH, "utf-8"));
   } catch {
     return null;
   }
@@ -35641,7 +36003,7 @@ function seedProgressHeartbeat() {
   if (!PROGRESS_HEARTBEAT_PATH) return;
   const tmp = `${PROGRESS_HEARTBEAT_PATH}.${process.pid}.tmp`;
   try {
-    mkdirSync5(join12(homedir4(), ".augmented", AGT_AGENT_CODE_NAME), { recursive: true });
+    mkdirSync5(join13(homedir5(), ".augmented", AGT_AGENT_CODE_NAME), { recursive: true });
     writeFileSync6(tmp, serializeProgressHeartbeat(SEED_PROGRESS_STEP, Date.now()), { mode: 384 });
     renameSync5(tmp, PROGRESS_HEARTBEAT_PATH);
   } catch {
@@ -35762,7 +36124,7 @@ var STREAM_REPLY_FLUSH_MS = (() => {
   const n = raw ? Number(raw) : NaN;
   return Number.isFinite(n) && n >= 0 ? n : 60;
 })();
-var sleep = (ms) => ms > 0 ? new Promise((resolve) => setTimeout(resolve, ms)) : Promise.resolve();
+var sleep2 = (ms) => ms > 0 ? new Promise((resolve) => setTimeout(resolve, ms)) : Promise.resolve();
 async function apiPost(path, body) {
   const token = await getAuthToken();
   const res = await fetchWithTimeout(`${AGT_HOST}${path}`, {
@@ -35833,7 +36195,7 @@ var inboundAttachmentDeps = {
   },
   ensureDir: (dir) => mkdirSync5(dir, { recursive: true }),
   writeFile: (path, bytes) => writeFileSync6(path, bytes, { mode: 384 }),
-  joinPath: (...parts) => join12(...parts),
+  joinPath: (...parts) => join13(...parts),
   warn: (msg) => process.stderr.write(`${msg}
 `)
 };
@@ -36012,11 +36374,11 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
         recordDirectChatDelivery(session_id, message_ids);
         const messageId = data.message_id;
         for (let i = 1; i < slices.length; i++) {
-          await sleep(STREAM_REPLY_FLUSH_MS);
+          await sleep2(STREAM_REPLY_FLUSH_MS);
           const isFinal = i === slices.length - 1;
           let ok = await postDirectChatUpdate(messageId, session_id, slices[i]);
           if (!ok && isFinal) {
-            await sleep(STREAM_REPLY_FLUSH_MS);
+            await sleep2(STREAM_REPLY_FLUSH_MS);
             ok = await postDirectChatUpdate(messageId, session_id, slices[i]);
             if (!ok) {
               return {
@@ -36165,7 +36527,7 @@ function scheduleDirectChatBusyAck(sessionId, messageId, arrivedWhileBusy) {
     let paneLogFreshAgeMs = null;
     if (DIRECT_CHAT_CODE_NAME_AGENT_DIR) {
       try {
-        const paneMtimeMs = statSync2(join12(DIRECT_CHAT_CODE_NAME_AGENT_DIR, "pane.log")).mtimeMs;
+        const paneMtimeMs = statSync3(join13(DIRECT_CHAT_CODE_NAME_AGENT_DIR, "pane.log")).mtimeMs;
         paneLogFreshAgeMs = Math.max(0, Date.now() - paneMtimeMs);
       } catch {
       }
@@ -36213,6 +36575,63 @@ function scheduleDirectChatBusyAck(sessionId, messageId, arrivedWhileBusy) {
   }, thresholdMs);
   timer.unref();
 }
+function armUsageLimitWatch(args) {
+  void (async () => {
+    try {
+      const refusal = await watchForRateLimitRefusal({ sinceMs: args.sinceMs });
+      if (!refusal) return;
+      if (!refusal.resetsAt) {
+        process.stderr.write(
+          `direct-chat-channel: [usage-limit-reactive] mode=${args.mode} refusal detected for session=${args.sessionId} but no reset time in it (${refusal.text ?? "no text"}) - no notice
+`
+        );
+        return;
+      }
+      if (args.mode === "shadow") {
+        process.stderr.write(
+          `direct-chat-channel: [usage-limit-reactive] mode=shadow WOULD notify session=${args.sessionId} message=${args.messageId} resets=${refusal.resetsAt.toISOString()}
+`
+        );
+        return;
+      }
+      const throttleKey = `${args.sessionId}|usage_limit`;
+      const throttle = decideDeclineReply({
+        cache: DIRECT_CHAT_USAGE_LIMIT_CACHE,
+        key: throttleKey,
+        cooldownMs: DIRECT_CHAT_MAINTENANCE_COOLDOWN_MS,
+        now: Date.now()
+      });
+      const route = throttle.reply ? "/host/direct-chat/reply" : "/host/direct-chat/consume";
+      const body = throttle.reply ? {
+        agent_id: AGT_AGENT_ID,
+        session_id: args.sessionId,
+        content: buildUsageLimitReplyText(refusal.resetsAt),
+        message_ids: [args.messageId]
+      } : { agent_id: AGT_AGENT_ID, session_id: args.sessionId, message_ids: [args.messageId] };
+      const res = await apiPost(route, body);
+      const data = await res.json().catch(() => ({}));
+      if (res.ok && data.error == null) {
+        claimTracker.clear(args.sessionId, [args.messageId]);
+        clearDirectChatPendingMarkersForSession(DIRECT_CHAT_PENDING_INBOUND_DIR, args.sessionId);
+        process.stderr.write(
+          `direct-chat-channel: [usage-limit-reactive] ${throttle.reply ? "reported" : "consumed (notice throttled)"} refusal for session=${args.sessionId} message=${args.messageId} resets=${refusal.resetsAt.toISOString()}
+`
+        );
+      } else {
+        if (throttle.reply) DIRECT_CHAT_USAGE_LIMIT_CACHE.delete(throttleKey);
+        process.stderr.write(
+          `direct-chat-channel: [usage-limit-reactive] ${throttle.reply ? "notice" : "consume"} failed for session=${args.sessionId}: ${data.error ?? `HTTP ${res.status}`}
+`
+        );
+      }
+    } catch (err) {
+      process.stderr.write(
+        `direct-chat-channel: [usage-limit-reactive] watch failed for session=${args.sessionId}: ${err.message}
+`
+      );
+    }
+  })();
+}
 async function pollForMessages(sinceMs) {
   try {
     const res = await apiPost("/host/direct-chat/poll", {
@@ -36239,7 +36658,8 @@ async function pollForMessages(sinceMs) {
       const isNotice = msg.kind === "notice";
       const maintenanceActive = !isNotice && isMaintenanceModeActive();
       const accountMuted = !isNotice && !maintenanceActive ? readAccountEnforcementLevel({ codeName: AGT_AGENT_CODE_NAME ?? null }) === "mute" : false;
-      const usageLimitUntil = !isNotice && !maintenanceActive && !accountMuted ? readUsageLimitUntil({ codeName: AGT_AGENT_CODE_NAME ?? null }) : null;
+      const reactiveMode = resolveUsageLimitReactiveMode();
+      const usageLimitUntil = !isNotice && !maintenanceActive && !accountMuted && reactiveMode !== "enforce" ? readUsageLimitUntil({ codeName: AGT_AGENT_CODE_NAME ?? null }) : null;
       if (!isNotice && !maintenanceActive && !accountMuted && !usageLimitUntil) {
         markProcessed(msg.id);
         claimTracker.track(msg.session_id, msg.id);
@@ -36357,6 +36777,7 @@ async function pollForMessages(sinceMs) {
       if (!isNotice && msg.sender_id) {
         clearScheduledTurnMarker(DIRECT_CHAT_CODE_NAME_AGENT_DIR);
       }
+      const dispatchedAtMs = Date.now();
       await mcp.notification({
         method: "notifications/claude/channel",
         params: {
@@ -36417,6 +36838,14 @@ async function pollForMessages(sinceMs) {
         `direct-chat-channel: Injected message ${msg.id} (session=${msg.session_id})
 `
       );
+      if (!isNotice && reactiveMode !== "off") {
+        armUsageLimitWatch({
+          mode: reactiveMode,
+          sessionId: msg.session_id,
+          messageId: msg.id,
+          sinceMs: dispatchedAtMs
+        });
+      }
     }
   } catch (err) {
     process.stderr.write(
@@ -36522,8 +36951,8 @@ function sweepAgedDirectChatMarkersNow(thresholdMs) {
   if (!DIRECT_CHAT_PENDING_INBOUND_DIR) return;
   const now = Date.now();
   const res = sweepAgedDirectChatMarkers(DIRECT_CHAT_PENDING_INBOUND_DIR, {
-    readdir: (dir) => readdirSync4(dir),
-    readFile: (p2) => readFileSync11(p2, "utf8"),
+    readdir: (dir) => readdirSync5(dir),
+    readFile: (p2) => readFileSync12(p2, "utf8"),
     unlink: (p2) => {
       if (existsSync6(p2)) unlinkSync4(p2);
     },
@@ -36559,7 +36988,7 @@ function sanitizeRecoveryText(text) {
 }
 function directChatRecoveryDeps() {
   return {
-    readFile: (p2) => readFileSync11(p2, "utf-8"),
+    readFile: (p2) => readFileSync12(p2, "utf-8"),
     renameFile: (from, to) => renameSync5(from, to),
     unlinkFile: (p2) => {
       if (existsSync6(p2)) unlinkSync4(p2);
@@ -36572,7 +37001,7 @@ function directChatRecoveryDeps() {
       if (!DIRECT_CHAT_RECOVERY_LEDGER_DIR) return;
       if (markerName.includes("/") || markerName.includes("\\") || markerName.includes("..")) return;
       try {
-        const p2 = join12(DIRECT_CHAT_RECOVERY_LEDGER_DIR, markerName);
+        const p2 = join13(DIRECT_CHAT_RECOVERY_LEDGER_DIR, markerName);
         if (existsSync6(p2)) unlinkSync4(p2);
       } catch {
       }
@@ -36608,7 +37037,7 @@ async function processDirectChatRecoveryOutboxFile(filename) {
   if (!enabled) return;
   directChatRecoveryInFlight.add(filename);
   try {
-    const fullPath = join12(DIRECT_CHAT_RECOVERY_OUTBOX_DIR, filename);
+    const fullPath = join13(DIRECT_CHAT_RECOVERY_OUTBOX_DIR, filename);
     await consumeDirectChatRecoveryFile(fullPath, filename, directChatRecoveryDeps());
   } catch (err) {
     process.stderr.write(
@@ -36626,7 +37055,7 @@ if (DIRECT_CHAT_RECOVERY_OUTBOX_DIR) {
   } catch {
   }
   try {
-    for (const f of readdirSync4(DIRECT_CHAT_RECOVERY_OUTBOX_DIR)) {
+    for (const f of readdirSync5(DIRECT_CHAT_RECOVERY_OUTBOX_DIR)) {
       if (f.endsWith(".json")) void processDirectChatRecoveryOutboxFile(f);
     }
   } catch {
@@ -36636,7 +37065,7 @@ if (DIRECT_CHAT_RECOVERY_OUTBOX_DIR) {
       if (!filename) return;
       const name = filename.toString();
       if (!name.endsWith(".json")) return;
-      if (existsSync6(join12(DIRECT_CHAT_RECOVERY_OUTBOX_DIR, name))) {
+      if (existsSync6(join13(DIRECT_CHAT_RECOVERY_OUTBOX_DIR, name))) {
         void processDirectChatRecoveryOutboxFile(name);
       }
     });