omniagent 0.1.14 → 0.1.16

package/README.md

@@ -94,9 +94,11 @@ is not supported for usage extraction yet. Usage extraction may launch agent TUI
 cost if an agent reads repo context or instructions on startup; omniagent uses cheap/minimal
 launch settings where possible. Usage extraction times out after 30 seconds unless the target
 config defines a target-specific timeout; built-in TUI probes may use longer defaults. Some CLIs
-gate usage inspection behind onboarding state — Antigravity requires the project to be trusted
-(run `agy` once and accept the trust prompt); omniagent does not complete auth or onboarding
-prompts for you. Pass `--timeout=<seconds>` to override the per-agent timeout for the current
+gate usage inspection behind auth or onboarding state. When Antigravity requests directory trust,
+interactive usage shows the exact directory and forwards approval only after you confirm;
+omniagent never accepts trust automatically or completes authentication prompts. If Antigravity
+requests directory trust, JSON, debug, and non-interactive runs return a `trust_required` error
+instead of prompting. Pass `--timeout=<seconds>` to override the per-agent timeout for the current
 run.
 
 ## Local Overrides (`.local`)

package/dist/agy-DlbWeyP_.js

@@ -0,0 +1,379 @@
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { c as cleanControlOutput, m as makeUsageLimit, U as UsageExtractionError, a as compactLines, p as parsePercentRemaining } from "./cli.js";
+import { r as runPtyScenario, e as enterKey, a as escapeKey } from "./pty-D8BFQQQg.js";
+const TRUST_DIALOG_PATTERN = /Do you trust the contents of this project\?/i;
+const READY_PATTERN = /\?\s+for shortcuts/i;
+const LOGIN_SELECTION_PATTERN = /Select login method:/i;
+const USAGE_GROUP_HEADING_PATTERN = /^[A-Z][A-Z0-9 &/-]+$/;
+const LIMIT_LABEL_PATTERN = /limit$/i;
+const MODELS_LINE_PATTERN = /^Models within this group:\s*(.+)$/i;
+const REFRESH_PATTERN = /Refreshes\s+in\s+(?:(\d+)h)?\s*(?:(\d+)m)?/i;
+const NOT_SIGNED_IN_PATTERN = /\bnot signed in\b/i;
+const SIGNING_IN_PATTERN = /\bsigning in\b/i;
+const DISABLED_PATTERN = /^Disabled$/i;
+const AGY_USAGE_FALLBACK_PATH = [".omniagent", "state", "usage", "antigravity-cli"];
+const STARTUP_READY_TIMEOUT_MS = 25e3;
+const USAGE_PANEL_STABLE_MS = 1e3;
+const USAGE_PANEL_MIN_OBSERVE_MS = 2e3;
+function isCurrentTrustDialog(snapshot) {
+  return TRUST_DIALOG_PATTERN.test(snapshot.screen);
+}
+function isNotCurrentTrustDialog(snapshot) {
+  return !isCurrentTrustDialog(snapshot);
+}
+function isReady(snapshot) {
+  return READY_PATTERN.test(snapshot.screen);
+}
+function isLoginSelection(snapshot) {
+  return LOGIN_SELECTION_PATTERN.test(snapshot.screen);
+}
+function isStartupTerminalState(snapshot) {
+  return isReady(snapshot) || isCurrentTrustDialog(snapshot) || isLoginSelection(snapshot);
+}
+function isPostTrustTerminalState(snapshot) {
+  return isReady(snapshot) || isLoginSelection(snapshot);
+}
+function isCurrentSignInFailure(snapshot) {
+  return NOT_SIGNED_IN_PATTERN.test(snapshot.screen) || isLoginSelection(snapshot);
+}
+function isInteractionBlocked(snapshot) {
+  return isCurrentTrustDialog(snapshot) || isCurrentSignInFailure(snapshot);
+}
+function isAuthenticationTransition(snapshot) {
+  return SIGNING_IN_PATTERN.test(snapshot.screen);
+}
+function isUsageWriteBlocked(snapshot) {
+  return isInteractionBlocked(snapshot) || isAuthenticationTransition(snapshot);
+}
+function createStableUsagePanelWait(stableMs = USAGE_PANEL_STABLE_MS, minObserveMs = USAGE_PANEL_MIN_OBSERVE_MS) {
+  let previousSignature = "";
+  let firstSeenAt = null;
+  let stableSince = 0;
+  return (snapshot) => {
+    if (isInteractionBlocked(snapshot)) {
+      return true;
+    }
+    const groups = parseAgyUsage(snapshot.screen, cleanControlOutput(snapshot.raw));
+    if (groups.length === 0) {
+      previousSignature = "";
+      firstSeenAt = null;
+      stableSince = 0;
+      return false;
+    }
+    const signature = usageGroupSignature(groups);
+    const now = Date.now();
+    if (firstSeenAt == null) {
+      firstSeenAt = now;
+    }
+    if (signature !== previousSignature) {
+      previousSignature = signature;
+      stableSince = now;
+      return false;
+    }
+    return now - firstSeenAt >= minObserveMs && now - stableSince >= stableMs;
+  };
+}
+function guardedUsageWrite(value, scenarioState, waitMs) {
+  return {
+    waitMs,
+    write: (snapshot) => {
+      if (isUsageWriteBlocked(snapshot)) {
+        scenarioState.canEnterUsage = false;
+        return void 0;
+      }
+      return scenarioState.canEnterUsage ? value : void 0;
+    }
+  };
+}
+async function extractAgyUsage(context) {
+  const command = context.command ?? context.launch?.command ?? "agy";
+  const launchCwd = await ensureAgyUsageCwd(context.homeDir, context.repoRoot);
+  const scenarioState = {
+    trustOutcome: "not-requested",
+    canEnterUsage: false,
+    reachedReadyAfterTrust: false
+  };
+  const ptyResult = await runPtyScenario({
+    command,
+    args: context.launch?.args ?? [],
+    cwd: launchCwd.path,
+    cols: 120,
+    rows: 40,
+    timeoutMs: context.launch?.timeoutMs ?? 7e4,
+    signal: context.signal,
+    debug: context.debug,
+    steps: [
+      {
+        waitFor: isStartupTerminalState,
+        waitForTimeoutMs: STARTUP_READY_TIMEOUT_MS,
+        optional: true,
+        capture: "startup",
+        captureWaitMs: 0
+      },
+      {
+        skipIf: isNotCurrentTrustDialog,
+        skipIfSource: "screen",
+        write: async () => {
+          if (context.confirm == null) {
+            scenarioState.trustOutcome = "required";
+            return void 0;
+          }
+          const approved = await context.confirm({
+            type: "trust-directory",
+            targetId: context.targetId,
+            displayName: context.displayName,
+            path: launchCwd.path,
+            managed: launchCwd.managed
+          });
+          scenarioState.trustOutcome = approved ? "approved" : "denied";
+          return void 0;
+        }
+      },
+      {
+        write: (snapshot2) => {
+          if (!isCurrentTrustDialog(snapshot2)) {
+            return void 0;
+          }
+          if (scenarioState.trustOutcome === "approved") {
+            return enterKey();
+          }
+          if (scenarioState.trustOutcome === "denied") {
+            return escapeKey();
+          }
+          return void 0;
+        }
+      },
+      {
+        skipIf: () => scenarioState.trustOutcome !== "approved",
+        waitFor: isPostTrustTerminalState,
+        waitForTimeoutMs: STARTUP_READY_TIMEOUT_MS,
+        optional: true
+      },
+      {
+        write: (snapshot2) => {
+          const readyForUsage = isReady(snapshot2) && !isInteractionBlocked(snapshot2);
+          if (scenarioState.trustOutcome === "approved" && readyForUsage) {
+            scenarioState.reachedReadyAfterTrust = true;
+          }
+          scenarioState.canEnterUsage = scenarioState.trustOutcome !== "denied" && scenarioState.trustOutcome !== "required" && readyForUsage;
+          return void 0;
+        }
+      },
+      ...[..."/usage"].map((character) => guardedUsageWrite(character, scenarioState, 25)),
+      guardedUsageWrite(enterKey(), scenarioState, 250),
+      {
+        skipIf: () => !scenarioState.canEnterUsage,
+        waitFor: createStableUsagePanelWait(),
+        waitForTimeoutMs: 15e3,
+        optional: true,
+        capture: "usage",
+        captureWaitMs: 0
+      },
+      guardedUsageWrite(escapeKey(), scenarioState, 250)
+    ]
+  });
+  const buildError = (message, code) => {
+    const error = code == null ? new Error(message) : new UsageExtractionError(code, message);
+    if (ptyResult.debug.length > 0) {
+      Object.assign(error, { debug: ptyResult.debug });
+    }
+    return error;
+  };
+  const trustSubject = launchCwd.managed ? "managed usage directory" : "project directory";
+  if (scenarioState.trustOutcome === "required") {
+    throw buildError(
+      `Antigravity needs permission to trust the ${trustSubject} at ${launchCwd.path}. Re-run usage in an interactive terminal to review this request.`,
+      "trust_required"
+    );
+  }
+  if (scenarioState.trustOutcome === "denied") {
+    throw buildError(
+      `Antigravity trust was declined for the ${trustSubject} at ${launchCwd.path}.`,
+      "trust_denied"
+    );
+  }
+  if (isCurrentSignInFailure(ptyResult)) {
+    throw buildError(`Antigravity is not signed in. Run \`${command}\` and complete the login.`);
+  }
+  if (scenarioState.trustOutcome === "approved" && !scenarioState.reachedReadyAfterTrust) {
+    throw buildError(
+      `Antigravity did not accept trust for the ${trustSubject} at ${launchCwd.path}. Run \`${command}\` there once, accept the trust prompt, then re-run usage.`,
+      "trust_acceptance_failed"
+    );
+  }
+  if (isCurrentTrustDialog(ptyResult)) {
+    throw buildError(
+      `Antigravity still requires trust for the ${trustSubject} at ${launchCwd.path}.`,
+      "trust_required"
+    );
+  }
+  const snapshot = ptyResult.snapshots.usage ?? ptyResult;
+  const cleanedOutput = cleanControlOutput(snapshot.raw);
+  if (isCurrentSignInFailure(snapshot)) {
+    throw buildError(`Antigravity is not signed in. Run \`${command}\` and complete the login.`);
+  }
+  const groups = parseAgyUsage(snapshot.screen, cleanedOutput);
+  if (groups.length === 0) {
+    throw buildError("Antigravity /usage output did not include Models & Quota limit groups.");
+  }
+  return {
+    targetId: context.targetId,
+    displayName: context.displayName,
+    command,
+    limits: groups.map((group) => {
+      const percentRemaining = group.disabled || group.percentRemaining == null ? null : clampPercent(group.percentRemaining);
+      const limit = makeUsageLimit({
+        targetId: context.targetId,
+        scope: usageScope(group.heading),
+        window: "weekly",
+        label: titleCase(group.heading),
+        percentUsed: percentRemaining == null ? null : 100 - percentRemaining,
+        percentRemaining,
+        remainingText: group.disabled ? "Disabled" : null,
+        resetText: group.resetText,
+        raw: group.raw,
+        now: context.now
+      });
+      return {
+        ...limit,
+        resetAt: parseAgyRefreshResetAt(group.resetText, context.now) ?? limit.resetAt
+      };
+    }),
+    debug: ptyResult.debug.length > 0 ? ptyResult.debug : void 0
+  };
+}
+async function ensureAgyUsageCwd(homeDir, repoRoot) {
+  const fallbackDir = path.join(homeDir, ...AGY_USAGE_FALLBACK_PATH);
+  try {
+    await mkdir(fallbackDir, { recursive: true });
+    return { path: fallbackDir, managed: true };
+  } catch {
+    return { path: repoRoot, managed: false };
+  }
+}
+function parseAgyUsage(screen, cleanedOutput = "") {
+  const fromRaw = parseAgyUsageLines(compactLines(cleanedOutput));
+  const fromScreen = parseAgyUsageLines(compactLines(screen));
+  const merged = /* @__PURE__ */ new Map();
+  for (const group of [...fromRaw, ...fromScreen]) {
+    merged.set(usageGroupKey(group), group);
+  }
+  return [...merged.values()];
+}
+function usageGroupKey(group) {
+  return `${group.heading.trim().toLowerCase()}\0${group.limitLabel.trim().toLowerCase()}`;
+}
+function usageGroupSignature(groups) {
+  return JSON.stringify(
+    groups.map((group) => ({
+      heading: group.heading,
+      models: group.models,
+      limitLabel: group.limitLabel,
+      percentRemaining: group.percentRemaining,
+      resetText: group.resetText,
+      disabled: group.disabled
+    }))
+  );
+}
+function parseAgyUsageLines(lines) {
+  const groups = [];
+  let index = 0;
+  while (index < lines.length) {
+    const heading = lines[index] ?? "";
+    if (!isUsageGroupHeading(heading)) {
+      index += 1;
+      continue;
+    }
+    const rawLines = [heading];
+    let models = null;
+    let limitLabel = "";
+    let percentRemaining = null;
+    let resetText = null;
+    let disabled = false;
+    index += 1;
+    while (index < lines.length && !isUsageGroupHeading(lines[index] ?? "")) {
+      const line = lines[index] ?? "";
+      rawLines.push(line);
+      const modelsMatch = MODELS_LINE_PATTERN.exec(line);
+      if (modelsMatch?.[1]) {
+        models = modelsMatch[1].trim();
+      }
+      if (LIMIT_LABEL_PATTERN.test(line)) {
+        limitLabel = line.trim();
+      }
+      const linePercentRemaining = parseAgyRemainingPercent(line);
+      if (linePercentRemaining != null && percentRemaining == null) {
+        percentRemaining = linePercentRemaining;
+      }
+      const lineResetText = parseAgyRefreshText(line);
+      if (lineResetText != null) {
+        resetText = lineResetText;
+      }
+      if (DISABLED_PATTERN.test(line)) {
+        disabled = true;
+      }
+      index += 1;
+    }
+    if (limitLabel && (percentRemaining != null || resetText != null || disabled)) {
+      groups.push({
+        heading,
+        models,
+        limitLabel,
+        percentRemaining,
+        resetText,
+        disabled,
+        raw: rawLines.join("\n")
+      });
+    }
+  }
+  return groups;
+}
+function isUsageGroupHeading(line) {
+  if (!USAGE_GROUP_HEADING_PATTERN.test(line)) {
+    return false;
+  }
+  return !/^(MODELS|WEEKLY|MONTHLY|DAILY|ACCOUNT)$/i.test(line);
+}
+function parseAgyRemainingPercent(line) {
+  return parsePercentRemaining(line) ?? parseStandalonePercent(line);
+}
+function parseStandalonePercent(line) {
+  const match = /(?:^|\])\s*(\d+(?:\.\d+)?)\s*%\s*$/i.exec(line);
+  if (!match?.[1]) {
+    return null;
+  }
+  return Number(match[1]);
+}
+function parseAgyRefreshText(line) {
+  const match = /(Refreshes\s+in\s+(?:(?:\d+)h)?\s*(?:(?:\d+)m)?)/i.exec(line);
+  return match?.[1]?.trim() ?? null;
+}
+function parseAgyRefreshResetAt(resetText, now) {
+  if (resetText == null) {
+    return null;
+  }
+  const match = REFRESH_PATTERN.exec(resetText);
+  if (match == null) {
+    return null;
+  }
+  const hours = Number(match[1] ?? 0);
+  const minutes = Number(match[2] ?? 0);
+  if (!Number.isFinite(hours) || !Number.isFinite(minutes) || hours + minutes <= 0) {
+    return null;
+  }
+  return new Date(now.getTime() + hours * 36e5 + minutes * 6e4).toISOString();
+}
+function clampPercent(value) {
+  return Math.max(0, Math.min(100, value));
+}
+function usageScope(heading) {
+  return heading.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+function titleCase(value) {
+  return value.trim().toLowerCase().split(/\s+/).map((word) => word === "gpt" ? "GPT" : `${word.charAt(0).toUpperCase()}${word.slice(1)}`).join(" ");
+}
+export {
+  extractAgyUsage,
+  parseAgyUsage
+};

package/dist/{claude-BuXp9FHS.js → claude-CcxRb8OW.js}

@@ -3,8 +3,8 @@ import { readFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { promisify } from "node:util";
-import { c as cleanControlOutput, a as compactLines, p as parsePercentUsed, m as makeUsageLimit } from "./cli.js";
-import { r as runPtyScenario, a as enterKey, e as escapeKey } from "./pty-CMd3Wxfe.js";
+import { c as cleanControlOutput, a as compactLines, b as parsePercentUsed, m as makeUsageLimit } from "./cli.js";
+import { r as runPtyScenario, e as enterKey, a as escapeKey } from "./pty-D8BFQQQg.js";
 const execFileAsync = promisify(execFile);
 const CLAUDE_CODE_KEYCHAIN_SERVICE = "Claude Code-credentials";
 const CLAUDE_CODE_CREDENTIALS_PATH = [".claude", ".credentials.json"];

package/dist/cli.js

@@ -1332,13 +1332,13 @@ const agyTarget = {
     }
   },
   usage: {
-    windows: ["credits"],
+    windows: ["weekly"],
     launch: {
       command: "agy",
       timeoutMs: 7e4
     },
     extract: async (context) => {
-      const { extractAgyUsage } = await import("./agy-Clt40QYQ.js");
+      const { extractAgyUsage } = await import("./agy-DlbWeyP_.js");
       return extractAgyUsage(context);
     }
   }
@@ -1399,7 +1399,7 @@ const claudeTarget = {
       timeoutMs: 6e4
     },
     extract: async (context) => {
-      const { extractClaudeUsage } = await import("./claude-BuXp9FHS.js");
+      const { extractClaudeUsage } = await import("./claude-CcxRb8OW.js");
       return extractClaudeUsage(context);
     }
   }
@@ -1484,7 +1484,7 @@ const codexTarget = {
       timeoutMs: 6e4
     },
     extract: async (context) => {
-      const { extractCodexUsage } = await import("./codex-OCvtxDjw.js");
+      const { extractCodexUsage } = await import("./codex-DhlBosXm.js");
       return extractCodexUsage(context);
     }
   }
@@ -10701,6 +10701,13 @@ function emptyToNull(value) {
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+class UsageExtractionError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "UsageExtractionError";
+  }
+}
 const USAGE_BAR_WIDTH = 12;
 const ANSI = {
   reset: "\x1B[0m",
@@ -10735,6 +10742,12 @@ class UsageExtractionTimeoutError extends Error {
     this.timeoutMs = timeoutMs;
   }
 }
+class UsageCommandInterruptedError extends Error {
+  constructor() {
+    super("Usage cancelled.");
+    this.name = "UsageCommandInterruptedError";
+  }
+}
 function normalizeOptionalWindow(value) {
   if (value == null) {
     return null;
@@ -10805,6 +10818,68 @@ function uniqueNormalizedWindows(values) {
   }
   return result;
 }
+class UsageConfirmationPrompter {
+  rl = null;
+  queue = Promise.resolve();
+  closed = false;
+  interrupt;
+  constructor(interrupt) {
+    this.interrupt = interrupt;
+  }
+  confirm = (request, signal) => {
+    const confirmation = this.queue.then(() => this.ask(request, signal));
+    this.queue = confirmation.then(
+      () => void 0,
+      () => void 0
+    );
+    return confirmation;
+  };
+  close() {
+    this.closed = true;
+    this.rl?.close();
+    this.rl = null;
+  }
+  async ask(request, signal) {
+    if (this.closed) {
+      throw new Error("Usage confirmation is no longer available.");
+    }
+    if (signal.aborted) {
+      throw signal.reason instanceof Error ? signal.reason : new Error("Usage confirmation was cancelled.");
+    }
+    const scope = request.managed ? "managed usage directory" : "project directory";
+    const question = `${request.displayName} needs to trust this ${scope}:
+${request.path}
+
+Allow this? [y/N] `;
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    this.rl = rl;
+    const handleInterrupt = () => this.interrupt();
+    rl.once("SIGINT", handleInterrupt);
+    try {
+      while (true) {
+        const answer = (await rl.question(question, { signal })).trim().toLowerCase();
+        if (!answer || answer === "n" || answer === "no") {
+          return false;
+        }
+        if (answer === "y" || answer === "yes") {
+          return true;
+        }
+        console.error("Please enter yes or no.");
+      }
+    } catch (error) {
+      if (signal.aborted && signal.reason instanceof Error) {
+        throw signal.reason;
+      }
+      throw error;
+    } finally {
+      rl.removeListener("SIGINT", handleInterrupt);
+      rl.close();
+      if (this.rl === rl) {
+        this.rl = null;
+      }
+    }
+  }
+}
 function formatUsageTargetLabel(targets) {
   return buildSupportedTargetLabel(targets);
 }
@@ -10815,6 +10890,13 @@ function formatSupportedUsageTargetsMessage(targets) {
 function getUsageCommand(target) {
   return target.usage?.launch?.command;
 }
+function supportsUsageConfirmation(target) {
+  if (target.id.trim().toLowerCase() === "agy") {
+    return true;
+  }
+  const builtInAgyExtractor = BUILTIN_TARGETS.find((candidate) => candidate.id === "agy")?.usage?.extract;
+  return builtInAgyExtractor != null && target.usage?.extract === builtInAgyExtractor;
+}
 async function checkUsageCommandAvailability(target) {
   const command = getUsageCommand(target)?.trim();
   if (!command) {
@@ -10872,6 +10954,7 @@ function validateCodexCommand(candidate) {
 }
 function buildContext(options) {
   const windows = uniqueNormalizedWindows(options.target.usage?.windows ?? []);
+  const confirm = options.confirm;
   const launch = {
     ...options.target.usage?.launch ?? {},
     timeoutMs: options.timeoutMs
@@ -10888,6 +10971,7 @@ function buildContext(options) {
     homeDir: options.homeDir,
     launch,
     signal: options.signal,
+    confirm: confirm == null ? void 0 : (request) => confirm(request, options.signal),
     debug: {
       enabled: options.debug,
       includeRawOutput: options.debug,
@@ -10901,7 +10985,11 @@ function filterTargetResult(target, result, selectedWindow) {
     window: normalizeUsageWindow(limit.window)
   }));
   const filteredLimits = selectedWindow == null ? normalizedLimits : normalizedLimits.filter((limit) => limit.window === selectedWindow);
-  const notes = selectedWindow != null && filteredLimits.length === 0 ? [`${target.displayName} reported no usage rows for window "${selectedWindow}".`] : [];
+  const resultNotes = result.notes ?? [];
+  const notes = selectedWindow != null && filteredLimits.length === 0 ? [
+    ...resultNotes,
+    `${target.displayName} reported no usage rows for window "${selectedWindow}".`
+  ] : resultNotes;
   return {
     result: {
       targetId: result.targetId,
@@ -10936,10 +11024,14 @@ async function extractUsageForTarget(options) {
         debug: []
       };
     }
-    const result = await withUsageTimeout((signal) => {
-      const context = buildContext({ ...options, signal });
-      return extractor(context);
-    }, options.timeoutMs);
+    const result = await withUsageTimeout(
+      (signal) => {
+        const context = buildContext({ ...options, signal });
+        return extractor(context);
+      },
+      options.timeoutMs,
+      options.commandSignal
+    );
     const filtered = filterTargetResult(options.target, result, options.selectedWindow);
     return {
       status: "success",
@@ -10951,7 +11043,7 @@ async function extractUsageForTarget(options) {
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    const code = isUsageTimeoutError(error) ? "usage_extraction_timeout" : "usage_extraction_failed";
+    const code = isUsageTimeoutError(error) ? "usage_extraction_timeout" : getUsageExtractionErrorCode(error);
     return {
       status: "error",
       target: options.target,
@@ -10960,6 +11052,21 @@ async function extractUsageForTarget(options) {
     };
   }
 }
+function getUsageExtractionErrorCode(error) {
+  if (error instanceof UsageExtractionError) {
+    return error.code;
+  }
+  if (error && typeof error === "object") {
+    const code = error.code;
+    if (typeof code === "string") {
+      const normalized = code.trim();
+      if (/^[a-z][a-z0-9_]*$/.test(normalized)) {
+        return normalized;
+      }
+    }
+  }
+  return "usage_extraction_failed";
+}
 function isUsageTimeoutError(error) {
   if (error instanceof UsageExtractionTimeoutError) {
     return true;
@@ -10983,18 +11090,25 @@ function isDebugArtifact(value) {
   const artifact = value;
   return (artifact.type === "raw-output" || artifact.type === "screen-snapshot") && typeof artifact.label === "string";
 }
-function withUsageTimeout(run, timeoutMs) {
+function withUsageTimeout(run, timeoutMs, commandSignal) {
   return new Promise((resolve, reject) => {
     const controller = new AbortController();
     let settled = false;
     let timeoutFired = false;
-    let timeout;
+    let timeout = null;
+    let removeCommandAbortListener = null;
+    const cleanup = () => {
+      if (timeout != null) {
+        clearTimeout(timeout);
+      }
+      removeCommandAbortListener?.();
+    };
     const settleResolve = (value) => {
       if (settled) {
         return;
       }
       settled = true;
-      clearTimeout(timeout);
+      cleanup();
       resolve(value);
     };
     const settleReject = (error) => {
@@ -11002,7 +11116,7 @@ function withUsageTimeout(run, timeoutMs) {
         return;
       }
       settled = true;
-      clearTimeout(timeout);
+      cleanup();
       reject(error);
     };
     timeout = setTimeout(() => {
@@ -11013,6 +11127,19 @@ function withUsageTimeout(run, timeoutMs) {
         settleReject(error);
       });
     }, timeoutMs);
+    if (commandSignal) {
+      const abortFromCommand = () => {
+        const reason = commandSignal.reason instanceof Error ? commandSignal.reason : new UsageCommandInterruptedError();
+        controller.abort(reason);
+        settleReject(reason);
+      };
+      if (commandSignal.aborted) {
+        abortFromCommand();
+        return;
+      }
+      commandSignal.addEventListener("abort", abortFromCommand, { once: true });
+      removeCommandAbortListener = () => commandSignal.removeEventListener("abort", abortFromCommand);
+    }
     let promise;
     try {
       promise = run(controller.signal);
@@ -11631,9 +11758,17 @@ async function runUsageCommand(argv) {
     }
   }
   const now = /* @__PURE__ */ new Date();
-  const outcomes = await Promise.all(
-    selectedTargets.map(
-      (target) => extractUsageForTarget({
+  const commandController = new AbortController();
+  const confirmationPrompter = !jsonOutput && Boolean(process.stdin.isTTY) && Boolean(process.stderr.isTTY) ? new UsageConfirmationPrompter(() => {
+    if (!commandController.signal.aborted) {
+      commandController.abort(new UsageCommandInterruptedError());
+    }
+  }) : null;
+  let outcomes;
+  try {
+    let confirmationTargetChain = Promise.resolve();
+    const outcomePromises = selectedTargets.map((target) => {
+      const extract = () => extractUsageForTarget({
         target,
         repoRoot,
         agentsDir,
@@ -11642,10 +11777,29 @@ async function runUsageCommand(argv) {
         timeoutMs: resolveTargetTimeoutMs(target, cliTimeoutMs),
         debug: debugOutput,
         now,
-        command: resolvedUsageCommands.get(target.id)
-      })
-    )
-  );
+        command: resolvedUsageCommands.get(target.id),
+        confirm: supportsUsageConfirmation(target) ? confirmationPrompter?.confirm : void 0,
+        commandSignal: commandController.signal
+      });
+      if (confirmationPrompter == null || !supportsUsageConfirmation(target)) {
+        return extract();
+      }
+      const outcome = confirmationTargetChain.then(extract);
+      confirmationTargetChain = outcome.then(
+        () => void 0,
+        () => void 0
+      );
+      return outcome;
+    });
+    outcomes = await Promise.all(outcomePromises);
+  } finally {
+    confirmationPrompter?.close();
+  }
+  if (commandController.signal.reason instanceof UsageCommandInterruptedError) {
+    console.error(commandController.signal.reason.message);
+    process.exit(130);
+    return null;
+  }
   const targets = [];
   const errors = [];
   const notes = [];
@@ -11731,7 +11885,7 @@ const usageCommand = {
     type: "boolean",
     describe: "Print JSON and include extractor debug artifacts when available."
   }).epilog(
-    "Usage extraction may launch agent TUIs and may incur cost if an agent reads repo context on startup. omniagent uses cheap/minimal launch settings where possible."
+    "Usage extraction may launch agent TUIs and may incur cost if an agent reads repo context on startup. Interactive runs may ask before forwarding directory trust; JSON, debug, and non-interactive runs never prompt."
   ),
   handler: async (argv) => {
     await runUsageCommand(argv);
@@ -13102,11 +13256,12 @@ if (!entry) {
   }
 }
 export {
+  UsageExtractionError as U,
   compactLines as a,
-  parsePercentRemaining as b,
+  parsePercentUsed as b,
   cleanControlOutput as c,
   parseResetText as d,
   makeUsageLimit as m,
-  parsePercentUsed as p,
+  parsePercentRemaining as p,
   runCli
 };

package/dist/{codex-OCvtxDjw.js → codex-DhlBosXm.js}

@@ -1,7 +1,7 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { c as cleanControlOutput, b as parsePercentRemaining, m as makeUsageLimit, d as parseResetText } from "./cli.js";
-import { r as runPtyScenario, a as enterKey, t as typeTextSteps } from "./pty-CMd3Wxfe.js";
+import { c as cleanControlOutput, p as parsePercentRemaining, m as makeUsageLimit, d as parseResetText } from "./cli.js";
+import { r as runPtyScenario, e as enterKey, t as typeTextSteps } from "./pty-D8BFQQQg.js";
 const CODEX_WINDOWS = [
   ["main", "5h", "main5hLimit"],
   ["main", "weekly", "mainWeeklyLimit"],

package/dist/{pty-CMd3Wxfe.js → pty-D8BFQQQg.js}

@@ -78,17 +78,18 @@ async function runPtyScenario(options) {
   });
   const cancellationPromise = new Promise((_, reject) => {
     cancelScenario = (message) => {
-      if (!exited) {
-        timedOut = true;
-        if (child) {
-          safeKillPty(child);
-        }
+      timedOut = true;
+      if (!exited && child) {
+        safeKillPty(child);
       }
       reject(buildScenarioError(message));
     };
   });
   cancellationPromise.catch(() => {
   });
+  timeout = setTimeout(() => {
+    cancelScenario?.(`PTY scenario timed out after ${formatDuration(timeoutMs)}.`);
+  }, timeoutMs);
   if (options.signal) {
     const abortHandler = () => {
       cancelScenario?.(formatAbortReason(options.signal, timeoutMs));
@@ -99,10 +100,6 @@ async function runPtyScenario(options) {
       options.signal.addEventListener("abort", abortHandler, { once: true });
       removeAbortListener = () => options.signal?.removeEventListener("abort", abortHandler);
     }
-  } else {
-    timeout = setTimeout(() => {
-      cancelScenario?.(`PTY scenario timed out after ${formatDuration(timeoutMs)}.`);
-    }, timeoutMs);
   }
   const withScenarioTimeout = async (promise) => Promise.race([promise, cancellationPromise]);
   const throwIfTimedOut = () => {
@@ -160,7 +157,13 @@ async function runPtyScenario(options) {
       }
       if (step.write != null) {
         throwIfTimedOut();
-        child.write(step.write);
+        const write = typeof step.write === "function" ? await withScenarioTimeout(
+          Promise.resolve(step.write({ raw, screen: readScreen(terminal) }))
+        ) : step.write;
+        throwIfTimedOut();
+        if (write != null && !exited) {
+          child.write(write);
+        }
       }
       if (step.waitFor != null) {
         const matched = await withScenarioTimeout(
@@ -355,8 +358,8 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 export {
-  enterKey as a,
-  escapeKey as e,
+  escapeKey as a,
+  enterKey as e,
   runPtyScenario as r,
   typeTextSteps as t
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omniagent",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Unified agent configuration CLI that compiles canonical agent configs to multiple runtimes.",
   "type": "module",
   "bin": {

package/dist/agy-Clt40QYQ.js

@@ -1,138 +0,0 @@
-import { c as cleanControlOutput, m as makeUsageLimit, a as compactLines } from "./cli.js";
-import { r as runPtyScenario, t as typeTextSteps, e as escapeKey, a as enterKey } from "./pty-CMd3Wxfe.js";
-const TRUST_DIALOG_PATTERN = /Do you trust the contents of this project\?/i;
-const READY_PATTERN = /\?\s+for shortcuts/i;
-const REMAINING_CREDITS_PATTERN = /Remaining AI Credits:\s*(.+?)\s*$/i;
-const CREDITS_NOT_ENABLED_PATTERN = /AI Credits not enabled/i;
-const ACCOUNT_PLAN_PATTERN = /^\S+@\S+\.\S+\s+\((.+?)\)\s*$/;
-const STANDALONE_PLAN_PATTERN = /^\((.*(?:quota|plan|tier).*)\)$/i;
-const SIGN_IN_PATTERN = /\b(?:not signed in|Signing in)\b/i;
-function isTrustDialog(snapshot) {
-  return TRUST_DIALOG_PATTERN.test(snapshot.raw) || TRUST_DIALOG_PATTERN.test(snapshot.screen);
-}
-function isReadyOrTrustDialog(snapshot) {
-  return READY_PATTERN.test(snapshot.screen) || isTrustDialog(snapshot);
-}
-function hasCreditsPanel(snapshot) {
-  return REMAINING_CREDITS_PATTERN.test(snapshot.screen) || REMAINING_CREDITS_PATTERN.test(cleanControlOutput(snapshot.raw));
-}
-function withTrustSkip(step) {
-  return { ...step, skipIf: isTrustDialog, skipIfSource: "raw" };
-}
-async function extractAgyUsage(context) {
-  const command = context.command ?? context.launch?.command ?? "agy";
-  const ptyResult = await runPtyScenario({
-    command,
-    args: context.launch?.args ?? [],
-    cwd: context.repoRoot,
-    cols: 120,
-    rows: 40,
-    timeoutMs: context.launch?.timeoutMs ?? 7e4,
-    signal: context.signal,
-    debug: context.debug,
-    steps: [
-      { waitFor: isReadyOrTrustDialog, waitForTimeoutMs: 25e3 },
-      ...typeTextSteps("/credits", 25).map(withTrustSkip),
-      withTrustSkip({ waitMs: 250, write: enterKey() }),
-      withTrustSkip({
-        waitFor: hasCreditsPanel,
-        waitForTimeoutMs: 15e3,
-        optional: true,
-        capture: "credits",
-        captureWaitMs: 500
-      }),
-      { write: escapeKey(), waitMs: 250 }
-    ]
-  });
-  const buildError = (message) => {
-    const error = new Error(message);
-    if (ptyResult.debug.length > 0) {
-      Object.assign(error, { debug: ptyResult.debug });
-    }
-    return error;
-  };
-  if (isTrustDialog(ptyResult)) {
-    throw buildError(
-      `Antigravity has not trusted this project yet. Run \`${command}\` in ${context.repoRoot} once, accept the trust prompt, then re-run usage.`
-    );
-  }
-  const snapshot = ptyResult.snapshots.credits ?? ptyResult;
-  const cleanedOutput = cleanControlOutput(snapshot.raw);
-  const parsed = parseAgyCredits(snapshot.screen, cleanedOutput);
-  if (parsed.notEnabled) {
-    throw buildError(
-      "Antigravity AI Credits are not enabled for this account. Enable them via /settings in agy."
-    );
-  }
-  if (parsed.remaining == null) {
-    if (SIGN_IN_PATTERN.test(snapshot.screen) || SIGN_IN_PATTERN.test(cleanedOutput)) {
-      throw buildError(`Antigravity is not signed in. Run \`${command}\` and complete the login.`);
-    }
-    throw buildError("Antigravity /credits output did not include a Remaining AI Credits value.");
-  }
-  return {
-    targetId: context.targetId,
-    displayName: context.displayName,
-    command,
-    limits: [
-      // Credits are an absolute balance rather than a percentage window.
-      makeUsageLimit({
-        targetId: context.targetId,
-        scope: "ai_credits",
-        window: "credits",
-        label: parsed.plan ? `AI Credits (${parsed.plan})` : "AI Credits",
-        percentUsed: null,
-        percentRemaining: null,
-        remainingText: parsed.remaining,
-        resetText: null,
-        raw: parsed.rawLine,
-        now: context.now
-      })
-    ],
-    debug: ptyResult.debug.length > 0 ? ptyResult.debug : void 0
-  };
-}
-function parseAgyCredits(screen, cleanedOutput = "") {
-  const fromScreen = parseAgyCreditsLines(compactLines(screen));
-  if (fromScreen.remaining != null || fromScreen.notEnabled) {
-    return fromScreen;
-  }
-  const fromRaw = parseAgyCreditsLines(compactLines(cleanedOutput));
-  if (fromRaw.remaining != null || fromRaw.notEnabled) {
-    return fromRaw;
-  }
-  return fromScreen.plan != null ? fromScreen : fromRaw;
-}
-function parseAgyCreditsLines(lines) {
-  const parsed = {
-    remaining: null,
-    notEnabled: false,
-    plan: null,
-    rawLine: ""
-  };
-  for (const line of lines) {
-    const remainingMatch = REMAINING_CREDITS_PATTERN.exec(line);
-    if (remainingMatch?.[1]) {
-      const value = remainingMatch[1].trim();
-      if (CREDITS_NOT_ENABLED_PATTERN.test(value)) {
-        parsed.notEnabled = true;
-        parsed.rawLine = line.trim();
-        continue;
-      }
-      parsed.remaining = value;
-      parsed.rawLine = line.trim();
-      continue;
-    }
-    if (parsed.plan == null) {
-      const planMatch = ACCOUNT_PLAN_PATTERN.exec(line) ?? STANDALONE_PLAN_PATTERN.exec(line);
-      if (planMatch?.[1]) {
-        parsed.plan = planMatch[1].trim();
-      }
-    }
-  }
-  return parsed;
-}
-export {
-  extractAgyUsage,
-  parseAgyCredits
-};