@yul-labs/agent-relay 0.1.1 → 0.1.3

package/dist/cli.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import fs6, { promises, constants, statSync, chmodSync } from 'fs';
-import path5 from 'path';
+import fs7, { promises, constants, statSync, chmodSync } from 'fs';
+import path6 from 'path';
 import { z } from 'zod';
-import { execa } from 'execa';
 import os from 'os';
+import { execa } from 'execa';
 import * as nodePty from 'node-pty';
 import { createRequire } from 'module';
 import { randomUUID } from 'crypto';
@@ -90,7 +90,7 @@ function resolveApprovalMode(defaults, adapter) {
   return adapter?.approvalPolicy ?? defaults.approvalPolicy ?? (defaults.requireApprovalOnRiskyActions ? "gated" : "auto");
 }
 function resolveSandbox(defaults, adapter) {
-  return adapter?.sandbox ?? defaults.sandbox ?? "workspace-write";
+  return adapter?.sandbox ?? defaults.sandbox ?? "danger-full-access";
 }
 var hooksSchema = z.object({
   /** Shell command run just before the agent starts. */
@@ -117,6 +117,14 @@ var deciderSchema = z.object({
   apiKey: z.string().optional(),
   maxTokens: z.number().int().positive().optional()
 }).strict();
+var pricingRuleSchema = z.object({
+  /** Regex (case-insensitive) matched against the model id; first match wins. */
+  match: z.string().min(1),
+  input: z.number().nonnegative(),
+  output: z.number().nonnegative(),
+  cacheWrite: z.number().nonnegative().optional(),
+  cacheRead: z.number().nonnegative().optional()
+}).strict();
 var configSchema = z.object({
   defaultAdapter: z.string().min(1),
   sessionsDir: z.string().min(1).default(".agent-relay/sessions"),
@@ -125,6 +133,8 @@ var configSchema = z.object({
   adapters: z.record(adapterConfigSchema),
   /** Which decider answers interactive prompts. */
   decider: deciderSchema.optional(),
+  /** Override the built-in per-model token pricing (USD per 1M tokens). */
+  pricing: z.array(pricingRuleSchema).optional(),
   /** Optional shell-command lifecycle hooks. */
   hooks: hooksSchema.optional()
 }).strict().superRefine((cfg, ctx) => {
@@ -145,9 +155,10 @@ function createDefaultConfig() {
       maxTurns: 20,
       timeoutMs: 18e5,
       idleTimeoutMs: 3e5,
-      // Autonomous by default: agents run unattended without asking.
+      // Autonomous by default: agents run unattended without asking, with full
+      // bypass so they can act freely (tighten `sandbox` for guarded runs).
       approvalPolicy: "auto",
-      sandbox: "workspace-write",
+      sandbox: "danger-full-access",
       requireApprovalOnRiskyActions: false
     },
     // Interactive (PTY) is the default mode: the agent runs in its real TUI and
@@ -185,7 +196,7 @@ ${detail}`,
   return result.data;
 }
 function configPath(rootDir) {
-  return path5.resolve(rootDir, CONFIG_FILENAME);
+  return path6.resolve(rootDir, CONFIG_FILENAME);
 }
 async function loadConfig(rootDir) {
   const file = configPath(rootDir);
@@ -225,7 +236,7 @@ function stringifyConfig(config) {
 }
 async function saveConfig(rootDir, config) {
   const file = configPath(rootDir);
-  await promises.mkdir(path5.dirname(file), { recursive: true });
+  await promises.mkdir(path6.dirname(file), { recursive: true });
   await promises.writeFile(file, stringifyConfig(config), "utf8");
   return file;
 }
@@ -240,7 +251,7 @@ async function dirExists(p) {
   }
 }
 async function runInit(options) {
-  const rootDir = path5.resolve(options.rootDir);
+  const rootDir = path6.resolve(options.rootDir);
   const cfgPath = configPath(rootDir);
   let configCreated = false;
   let configExists = false;
@@ -255,8 +266,8 @@ async function runInit(options) {
     configCreated = true;
   }
   const config = await loadConfig(rootDir);
-  const sessionsDir = path5.resolve(rootDir, config.sessionsDir);
-  const logsDir = path5.resolve(rootDir, config.logsDir);
+  const sessionsDir = path6.resolve(rootDir, config.sessionsDir);
+  const logsDir = path6.resolve(rootDir, config.logsDir);
   const createdDirs = [];
   for (const dir of [sessionsDir, logsDir]) {
     if (!await dirExists(dir)) {
@@ -272,6 +283,100 @@ async function runInit(options) {
     createdDirs
   };
 }
+async function realish(p) {
+  try {
+    return await promises.realpath(p);
+  } catch {
+    return p;
+  }
+}
+function projectDirCandidates(absCwd) {
+  return [absCwd.replace(/[/.]/g, "-"), absCwd.replace(/\//g, "-")];
+}
+async function resolveProjectDir(root, cwd) {
+  const abs = await realish(cwd);
+  for (const name of projectDirCandidates(abs)) {
+    const dir = path6.join(root, name);
+    try {
+      const st = await promises.stat(dir);
+      if (st.isDirectory()) return dir;
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function findLatestClaudeTranscript(opts) {
+  const root = opts.projectsDir ?? path6.join(os.homedir(), ".claude", "projects");
+  const since = opts.sinceMs ?? 0;
+  const dir = await resolveProjectDir(root, opts.cwd);
+  if (!dir) return void 0;
+  let files;
+  try {
+    files = await promises.readdir(dir);
+  } catch {
+    return void 0;
+  }
+  const candidates = [];
+  for (const f of files) {
+    if (!f.endsWith(".jsonl")) continue;
+    const file = path6.join(dir, f);
+    try {
+      const st = await promises.stat(file);
+      if (st.mtimeMs + 2e3 < since) continue;
+      candidates.push({ file, mtimeMs: st.mtimeMs });
+    } catch {
+    }
+  }
+  candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return candidates[0]?.file;
+}
+async function sumClaudeUsage(file) {
+  let text;
+  try {
+    text = await promises.readFile(file, "utf8");
+  } catch {
+    return void 0;
+  }
+  let input = 0;
+  let output = 0;
+  let cacheCreate = 0;
+  let cacheRead = 0;
+  let model;
+  let any = false;
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    let rec;
+    try {
+      rec = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const u = rec.message?.usage;
+    if (!u || typeof u !== "object") continue;
+    any = true;
+    input += u.input_tokens ?? 0;
+    output += u.output_tokens ?? 0;
+    cacheCreate += u.cache_creation_input_tokens ?? 0;
+    cacheRead += u.cache_read_input_tokens ?? 0;
+    if (!model && typeof rec.message?.model === "string")
+      model = rec.message.model;
+  }
+  if (!any) return void 0;
+  return {
+    source: "transcript",
+    model,
+    inputTokens: input,
+    outputTokens: output,
+    cacheCreationTokens: cacheCreate,
+    cachedInputTokens: cacheRead,
+    totalTokens: input + output + cacheCreate + cacheRead
+  };
+}
+async function findLatestClaudeUsage(opts) {
+  const file = await findLatestClaudeTranscript(opts);
+  if (!file) return void 0;
+  return sumClaudeUsage(file);
+}
 
 // src/core/util/json.ts
 function safeJsonParse(text) {
@@ -493,6 +598,7 @@ var CommandDecider = class {
     }
   }
 };
+var MIN_API_MAX_TOKENS = 512;
 var ApiDecider = class {
   constructor(opts) {
     this.opts = opts;
@@ -522,7 +628,7 @@ var ApiDecider = class {
         body: JSON.stringify({
           model: this.opts.model ?? "default",
           messages: [{ role: "user", content: render(req) }],
-          max_tokens: this.opts.maxTokens ?? 2048,
+          max_tokens: Math.max(this.opts.maxTokens ?? 2048, MIN_API_MAX_TOKENS),
           temperature: this.opts.temperature ?? 0,
           stream: false
         }),
@@ -594,8 +700,8 @@ async function isExecutableFile(file) {
 async function which(command) {
   if (!command) return null;
   const exts = pathExtensions();
-  if (command.includes(path5.sep) || command.includes("/")) {
-    const base = path5.resolve(command);
+  if (command.includes(path6.sep) || command.includes("/")) {
+    const base = path6.resolve(command);
     for (const ext of exts) {
       const candidate = base + ext;
       if (await isExecutableFile(candidate)) return candidate;
@@ -603,11 +709,11 @@ async function which(command) {
     return null;
   }
   const pathEnv = process.env.PATH ?? process.env.Path ?? "";
-  const dirs = pathEnv.split(path5.delimiter).filter(Boolean);
-  const fallbacks = process.platform === "win32" ? [] : ["/usr/local/bin", "/opt/homebrew/bin", path5.join(os.homedir(), ".local/bin")];
+  const dirs = pathEnv.split(path6.delimiter).filter(Boolean);
+  const fallbacks = process.platform === "win32" ? [] : ["/usr/local/bin", "/opt/homebrew/bin", path6.join(os.homedir(), ".local/bin")];
   for (const dir of [...dirs, ...fallbacks]) {
     for (const ext of exts) {
-      const candidate = path5.join(dir, command + ext);
+      const candidate = path6.join(dir, command + ext);
       if (await isExecutableFile(candidate)) return candidate;
     }
   }
@@ -733,11 +839,11 @@ function ensurePtyHelperExecutable() {
   if (process.platform === "win32") return;
   try {
     const require2 = createRequire(import.meta.url);
-    const root = path5.dirname(require2.resolve("node-pty/package.json"));
+    const root = path6.dirname(require2.resolve("node-pty/package.json"));
     const candidates = [
-      path5.join(root, "build", "Release", "spawn-helper"),
-      path5.join(root, "build", "Debug", "spawn-helper"),
-      path5.join(
+      path6.join(root, "build", "Release", "spawn-helper"),
+      path6.join(root, "build", "Debug", "spawn-helper"),
+      path6.join(
         root,
         "prebuilds",
         `${process.platform}-${process.arch}`,
@@ -899,6 +1005,7 @@ function runPtySession(opts, ctx) {
     let handling = false;
     let quitting = false;
     let settled = false;
+    let usage;
     let finished = false;
     let disposeData;
     let disposeExit;
@@ -915,6 +1022,7 @@ function runPtySession(opts, ctx) {
     const triggerQuit = (reason) => {
       if (finished || quitting) return;
       quitting = true;
+      settled = true;
       if (completionTimer) clearTimeout(completionTimer);
       completionTimer = void 0;
       emit("status", `task appears complete (${reason})`);
@@ -994,6 +1102,10 @@ function runPtySession(opts, ctx) {
     };
     const onSettle = async () => {
       if (finished || handling || quitting) return;
+      if (opts.scrapeUsage) {
+        const u = opts.scrapeUsage(cleanTerminalText(buffer));
+        if (u) usage = { ...usage, ...u };
+      }
       if (pendingComment !== void 0) {
         const comment = pendingComment;
         pendingComment = void 0;
@@ -1130,7 +1242,14 @@ function runPtySession(opts, ctx) {
         exitCode,
         error,
         sessionRef: void 0,
-        meta: { interactions, settled }
+        // `completedCleanly` is an unambiguous success flag (exit 0, not aborted/
+        // error) — use it instead of `settled` for "did the run finish well?".
+        meta: {
+          interactions,
+          settled,
+          completedCleanly: success,
+          ...usage ? { usage } : {}
+        }
       });
     });
     if (ctx.signal.aborted) onAbort();
@@ -1230,8 +1349,17 @@ var InteractivePtyAdapter = class {
     else args.push(input.prompt);
     return this.spawn(args, initialInput, input, ctx);
   }
-  spawn(args, initialInput, input, ctx, extra) {
+  async spawn(args, initialInput, input, ctx, extra) {
     const decider = ctx.decider ?? new RuleDecider();
+    try {
+      const resolved = await which(this.cfg.command);
+      ctx.onEvent({
+        type: "status",
+        timestamp: (this.cfg.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+        text: resolved ? `resolved ${this.cfg.command} \u2192 ${resolved}` : `${this.cfg.command} not found on PATH; relying on spawn-time resolution`
+      });
+    } catch {
+    }
     return runPtySession(
       {
         command: this.cfg.command,
@@ -1244,6 +1372,7 @@ var InteractivePtyAdapter = class {
         completionPattern: this.cfg.completionPattern,
         completionIdleMs: input.completionIdleMs ?? this.cfg.completionIdleMs,
         workingPattern: this.cfg.workingPattern,
+        scrapeUsage: this.cfg.scrapeUsage,
         quitKeys: this.cfg.quitKeys,
         setup: extra?.setup,
         promptAfterSetup: extra?.promptAfterSetup,
@@ -1261,6 +1390,17 @@ var InteractivePtyAdapter = class {
 };
 
 // src/adapters/interactive/claude-interactive.ts
+function scrapeClaudeStatusLine(text) {
+  const u = { source: "status-line" };
+  const ctx = text.match(/context[^\n]*?(\d{1,3})\s*%/i);
+  if (ctx) {
+    u.contextPercent = Number(ctx[1]);
+    u.raw = ctx[0].trim().replace(/\s+/g, " ");
+  }
+  const cost = text.match(/session\s*\$\s*([\d.]+)/i);
+  if (cost) u.subscriptionSessionCostUsd = Number(cost[1]);
+  return u.contextPercent !== void 0 || u.subscriptionSessionCostUsd !== void 0 ? u : void 0;
+}
 var DEFINITION = {
   name: "claude",
   type: "claude",
@@ -1269,6 +1409,9 @@ var DEFINITION = {
   supportsResume: true
 };
 var ClaudeInteractiveAdapter = class _ClaudeInteractiveAdapter extends InteractivePtyAdapter {
+  clock;
+  /** Override the projects root (~/.claude/projects) for tests. */
+  projectsDir;
   constructor(opts = {}) {
     super({
       definition: DEFINITION,
@@ -1285,14 +1428,14 @@ var ClaudeInteractiveAdapter = class _ClaudeInteractiveAdapter extends Interacti
         if (input.approvalMode === "readonly")
           return [...head, "--permission-mode", "plan"];
         if (input.approvalMode === "gated")
-          return [...head, "--permission-mode", "acceptEdits"];
+          return [...head, "--permission-mode", "default"];
         return [...head, "--dangerously-skip-permissions"];
       },
       // Resume the most recent conversation in the cwd and send the follow-up
       // prompt. (`--continue` picks the latest session; the native id is not
       // captured in PTY mode, so a specific `--resume <id>` is not used.)
       resumeArgs: (input) => {
-        const mode = input.approvalMode === "readonly" ? ["--permission-mode", "plan"] : input.approvalMode === "gated" ? ["--permission-mode", "acceptEdits"] : ["--dangerously-skip-permissions"];
+        const mode = input.approvalMode === "readonly" ? ["--permission-mode", "plan"] : input.approvalMode === "gated" ? ["--permission-mode", "default"] : ["--dangerously-skip-permissions"];
         return ["--continue", "--effort", "xhigh", ...mode];
       },
       // Unattended ultracode: once Claude is idle (past the trust dialog), type
@@ -1306,6 +1449,10 @@ var ClaudeInteractiveAdapter = class _ClaudeInteractiveAdapter extends Interacti
         approvalPattern: /(allow|grant|permission|approve|trust|proceed|do you want)[^\n]{0,60}\?|\[y\/n\]|\(y\/n\)/i
       },
       keymap: new ArrowKeymap(),
+      // SUPPLEMENT only: grab context% / session $ from the status line when it
+      // is enabled. The authoritative token counts come from the transcript in
+      // run() below and overwrite these on the same meta.usage object.
+      scrapeUsage: scrapeClaudeStatusLine,
       // Claude's TUI stays open after a task; quit once it's been idle a while.
       completionIdleMs: 8e3,
       // While Claude is ACTIVELY working it shows "(esc to interrupt)" — that is
@@ -1319,6 +1466,32 @@ var ClaudeInteractiveAdapter = class _ClaudeInteractiveAdapter extends Interacti
       workingPattern: /interrupt/i,
       quitKeys: ""
     });
+    this.clock = opts.now ?? (() => /* @__PURE__ */ new Date());
+    this.projectsDir = opts.projectsDir;
+  }
+  /**
+   * Run Claude, then read AUTHORITATIVE token usage from its session transcript
+   * (~/.claude/projects/<cwd>/<id>.jsonl) and surface it as `meta.usage`. This is
+   * device-independent — it works regardless of whether the user has a usage
+   * status line — and overwrites the best-effort status-line scrape's token
+   * figures while keeping its context%/cost extras. Best-effort: if no transcript
+   * is found, the status-line usage (if any) is left as-is.
+   */
+  async run(input, ctx) {
+    const startedAt = this.clock().getTime();
+    const result = await super.run(input, ctx);
+    if (result.error) return result;
+    const transcript = await findLatestClaudeUsage({
+      cwd: input.cwd,
+      sinceMs: startedAt,
+      projectsDir: this.projectsDir
+    });
+    if (!transcript) return result;
+    const prior = result.meta?.usage ?? {};
+    return {
+      ...result,
+      meta: { ...result.meta, usage: { ...prior, ...transcript } }
+    };
   }
   static fromConfig(config) {
     return new _ClaudeInteractiveAdapter({
@@ -1328,7 +1501,7 @@ var ClaudeInteractiveAdapter = class _ClaudeInteractiveAdapter extends Interacti
   }
 };
 var ROLLOUT_UUID_RE = /-([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})\.jsonl$/;
-async function realish(p) {
+async function realish2(p) {
   try {
     return await promises.realpath(p);
   } catch {
@@ -1344,7 +1517,7 @@ async function listRollouts(root) {
     return out;
   }
   for (const y of years) {
-    const yDir = path5.join(root, y);
+    const yDir = path6.join(root, y);
     let months;
     try {
       months = await promises.readdir(yDir);
@@ -1352,7 +1525,7 @@ async function listRollouts(root) {
       continue;
     }
     for (const m of months) {
-      const mDir = path5.join(yDir, m);
+      const mDir = path6.join(yDir, m);
       let days;
       try {
         days = await promises.readdir(mDir);
@@ -1360,7 +1533,7 @@ async function listRollouts(root) {
         continue;
       }
       for (const d of days) {
-        const dDir = path5.join(mDir, d);
+        const dDir = path6.join(mDir, d);
         let files;
         try {
           files = await promises.readdir(dDir);
@@ -1369,7 +1542,7 @@ async function listRollouts(root) {
         }
         for (const f of files) {
           if (!f.startsWith("rollout-") || !f.endsWith(".jsonl")) continue;
-          const file = path5.join(dDir, f);
+          const file = path6.join(dDir, f);
           try {
             const st = await promises.stat(file);
             out.push({ file, mtimeMs: st.mtimeMs });
@@ -1402,25 +1575,55 @@ async function readSessionMeta(file) {
   }
 }
 function uuidFromRolloutFilename(file) {
-  const m = ROLLOUT_UUID_RE.exec(path5.basename(file));
+  const m = ROLLOUT_UUID_RE.exec(path6.basename(file));
   return m?.[1];
 }
-async function findLatestCodexSessionId(opts) {
-  const root = opts.sessionsDir ?? path5.join(os.homedir(), ".codex", "sessions");
+async function findLatestCodexRollout(opts) {
+  const root = opts.sessionsDir ?? path6.join(os.homedir(), ".codex", "sessions");
   const since = opts.sinceMs ?? 0;
-  const targetCwd = await realish(opts.cwd);
+  const targetCwd = await realish2(opts.cwd);
   const rollouts = await listRollouts(root);
   for (const { file, mtimeMs } of rollouts) {
     if (mtimeMs + 2e3 < since) continue;
     const meta = await readSessionMeta(file);
     if (!meta?.cwd) continue;
-    const metaCwd = await realish(meta.cwd);
+    const metaCwd = await realish2(meta.cwd);
     if (metaCwd !== targetCwd) continue;
     const id = meta.id ?? uuidFromRolloutFilename(file);
-    if (id) return id;
+    return { file, id };
   }
   return void 0;
 }
+async function sumCodexUsage(file) {
+  let text;
+  try {
+    text = await promises.readFile(file, "utf8");
+  } catch {
+    return void 0;
+  }
+  let total;
+  for (const line of text.split("\n")) {
+    if (!line.includes("token_count")) continue;
+    let rec;
+    try {
+      rec = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (rec.payload?.type !== "token_count") continue;
+    const t = rec.payload.info?.total_token_usage;
+    if (t && typeof t === "object") total = t;
+  }
+  if (!total) return void 0;
+  return {
+    source: "transcript",
+    inputTokens: total.input_tokens,
+    cachedInputTokens: total.cached_input_tokens,
+    outputTokens: total.output_tokens,
+    reasoningTokens: total.reasoning_output_tokens,
+    totalTokens: total.total_tokens
+  };
+}
 
 // src/adapters/interactive/codex-interactive.ts
 var DEFINITION2 = {
@@ -1442,7 +1645,7 @@ var CodexInteractiveAdapter = class _CodexInteractiveAdapter extends Interactive
       now: opts.now,
       installHint: "Install the Codex CLI (`npm i -g @openai/codex`), run `codex login`, and ensure `codex` is on your PATH.",
       preArgs: (input) => {
-        const sandbox = input.approvalMode === "readonly" ? "read-only" : input.sandbox ?? "workspace-write";
+        const sandbox = input.approvalMode === "readonly" ? "read-only" : input.sandbox ?? "danger-full-access";
         const approval = input.approvalMode === "gated" ? "on-request" : "never";
         return ["-s", sandbox, "-a", approval];
       },
@@ -1478,29 +1681,28 @@ var CodexInteractiveAdapter = class _CodexInteractiveAdapter extends Interactive
     this.sessionsDir = opts.sessionsDir;
   }
   /**
-   * Run Codex, then capture its NATIVE session id (the rollout UUID) for this
-   * cwd and attach it to the result's `sessionRef` so the runner persists it and
-   * a later resume can use `codex resume <id> "<prompt>"`. Capture is best-effort:
-   * if no rollout matches (or any I/O fails) the result is returned unchanged, so
-   * the run still resumes via the `--last` fallback.
+   * Run Codex, then read its rollout for this cwd to capture (a) the NATIVE
+   * session id (the rollout UUID) for `sessionRef` so a later resume can use
+   * `codex resume <id> "<prompt>"`, and (b) authoritative token usage for
+   * `meta.usage` (device-independent — from Codex's own log, not the TUI). Both
+   * are best-effort: if no rollout matches (or any I/O fails) the result is
+   * returned unchanged, so the run still resumes via the `--last` fallback.
    */
   async run(input, ctx) {
     const startedAt = this.clock().getTime();
     const result = await super.run(input, ctx);
     if (result.error) return result;
-    const nativeSessionId = await findLatestCodexSessionId({
+    const rollout = await findLatestCodexRollout({
       cwd: input.cwd,
       sinceMs: startedAt,
       sessionsDir: this.sessionsDir
     });
-    if (!nativeSessionId) return result;
+    if (!rollout) return result;
+    const usage = await sumCodexUsage(rollout.file);
     return {
       ...result,
-      sessionRef: {
-        adapter: this.definition.name,
-        nativeSessionId,
-        resumable: true
-      }
+      sessionRef: rollout.id ? { adapter: this.definition.name, nativeSessionId: rollout.id, resumable: true } : result.sessionRef,
+      meta: usage ? { ...result.meta, usage } : result.meta
     };
   }
   static fromConfig(config) {
@@ -1780,11 +1982,11 @@ async function commandCheck(name, command, installHint) {
   };
 }
 async function runDoctor(options) {
-  const rootDir = path5.resolve(options.rootDir);
+  const rootDir = path6.resolve(options.rootDir);
   const checks = [];
   checks.push(checkNode());
-  let sessionsDir = path5.resolve(rootDir, ".agent-relay/sessions");
-  let logsDir = path5.resolve(rootDir, ".agent-relay/logs");
+  let sessionsDir = path6.resolve(rootDir, ".agent-relay/sessions");
+  let logsDir = path6.resolve(rootDir, ".agent-relay/logs");
   try {
     const config = await loadConfig(rootDir);
     checks.push({
@@ -1792,8 +1994,8 @@ async function runDoctor(options) {
       level: "ok",
       detail: `Valid config (defaultAdapter: ${config.defaultAdapter})`
     });
-    sessionsDir = path5.resolve(rootDir, config.sessionsDir);
-    logsDir = path5.resolve(rootDir, config.logsDir);
+    sessionsDir = path6.resolve(rootDir, config.sessionsDir);
+    logsDir = path6.resolve(rootDir, config.logsDir);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     const missing = message.includes("not found");
@@ -1909,7 +2111,7 @@ var RunLogger = class {
     if (this.opts.maxBytes && this.bytes >= this.opts.maxBytes) {
       if (!this.truncated) {
         this.truncated = true;
-        fs6.appendFileSync(
+        fs7.appendFileSync(
           this.logFile,
           `... [log truncated at ${this.opts.maxBytes} bytes \u2014 raise --max-log-bytes for more]
 `
@@ -1917,12 +2119,12 @@ var RunLogger = class {
       }
       return;
     }
-    fs6.appendFileSync(this.logFile, text);
+    fs7.appendFileSync(this.logFile, text);
     this.bytes += Buffer.byteLength(text);
   }
   /** Ensure the log directory exists and write the run header. */
   start(header) {
-    fs6.mkdirSync(path5.dirname(this.logFile), { recursive: true });
+    fs7.mkdirSync(path6.dirname(this.logFile), { recursive: true });
     const lines = [
       "================ agent-relay run ================",
       `sessionId : ${header.sessionId}`,
@@ -1976,6 +2178,27 @@ var RunLogger = class {
     this.append(lines.join("\n"));
   }
 };
+
+// src/core/pricing.ts
+var DEFAULT_PRICING = [
+  { match: /opus/i, pricing: { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.5 } },
+  { match: /sonnet/i, pricing: { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.3 } },
+  { match: /haiku/i, pricing: { input: 1, output: 5, cacheWrite: 1.25, cacheRead: 0.1 } }
+];
+function pricingForModel(model, overrides = []) {
+  if (!model) return void 0;
+  for (const rule of [...overrides, ...DEFAULT_PRICING]) {
+    if (rule.match.test(model)) return rule.pricing;
+  }
+  return void 0;
+}
+function computeCostUsd(usage, overrides = []) {
+  const p = pricingForModel(usage.model, overrides);
+  if (!p) return null;
+  const M = 1e6;
+  const cost = ((usage.inputTokens ?? 0) * p.input + (usage.outputTokens ?? 0) * p.output + (usage.cacheCreationTokens ?? 0) * (p.cacheWrite ?? p.input) + (usage.cachedInputTokens ?? 0) * (p.cacheRead ?? 0)) / M;
+  return Math.round(cost * 1e6) / 1e6;
+}
 var SessionManager = class {
   constructor(sessionsDir) {
     this.sessionsDir = sessionsDir;
@@ -1983,7 +2206,7 @@ var SessionManager = class {
   sessionsDir;
   /** Absolute path to a session's JSON metadata file. */
   filePath(sessionId) {
-    return path5.join(this.sessionsDir, `${sessionId}.json`);
+    return path6.join(this.sessionsDir, `${sessionId}.json`);
   }
   /** Build a fresh session record in the `created` state (not yet persisted). */
   create(input) {
@@ -2050,7 +2273,7 @@ var SessionManager = class {
       if (!entry.endsWith(".json")) continue;
       try {
         const raw = await promises.readFile(
-          path5.join(this.sessionsDir, entry),
+          path6.join(this.sessionsDir, entry),
           "utf8"
         );
         metas.push(JSON.parse(raw));
@@ -2074,12 +2297,12 @@ async function runAgent(options) {
   }
   const adapter = options.resolveAdapter(adapterName, config);
   const detector = options.detector ?? new CompositeCompletionDetector();
-  const rootDir = path5.resolve(options.rootDir);
-  const cwd = path5.resolve(options.cwd ?? rootDir);
-  const sessionsDir = path5.resolve(rootDir, config.sessionsDir);
-  const logsDir = path5.resolve(rootDir, config.logsDir);
+  const rootDir = path6.resolve(options.rootDir);
+  const cwd = path6.resolve(options.cwd ?? rootDir);
+  const sessionsDir = path6.resolve(rootDir, config.sessionsDir);
+  const logsDir = path6.resolve(rootDir, config.logsDir);
   const sessionId = options.sessionId ?? randomUUID();
-  const logFile = path5.join(logsDir, `${sessionId}.log`);
+  const logFile = path6.join(logsDir, `${sessionId}.log`);
   const sessions = new SessionManager(sessionsDir);
   const startedAt = iso();
   const session = sessions.create({
@@ -2297,6 +2520,28 @@ async function runAgent(options) {
     }
     externalSignal?.removeEventListener("abort", onExternalAbort);
   }
+  if (result?.meta && typeof result.meta === "object") {
+    const usage = result.meta.usage;
+    if (usage && (usage.inputTokens != null || usage.outputTokens != null)) {
+      const overrides = (config.pricing ?? []).map((r) => ({
+        match: new RegExp(r.match, "i"),
+        pricing: {
+          input: r.input,
+          output: r.output,
+          cacheWrite: r.cacheWrite,
+          cacheRead: r.cacheRead
+        }
+      }));
+      usage.costUsd = computeCostUsd(usage, overrides);
+      if (usage.costUsd === null) {
+        onEvent({
+          type: "status",
+          timestamp: iso(),
+          text: `usage: no price for model ${usage.model ? `"${usage.model}"` : "(unknown)"} \u2192 costUsd=null (set config.pricing to override)`
+        });
+      }
+    }
+  }
   const status = detector.detect({ result, events, abortReason, error: runError }) ?? "failed";
   const endedAt = iso();
   const error = runError && !result?.error ? { message: runError.message, code: "ADAPTER_THREW" } : result?.error ?? (abortReason === "timeout" || abortReason === "idle" ? {
@@ -2375,7 +2620,7 @@ async function resolvePrompt(options) {
     );
   }
   if (options.promptFile) {
-    const file = path5.resolve(options.rootDir, options.promptFile);
+    const file = path6.resolve(options.rootDir, options.promptFile);
     try {
       const text = await promises.readFile(file, "utf8");
       if (!text.trim()) {
@@ -2402,7 +2647,7 @@ async function resolvePrompt(options) {
   );
 }
 async function runCommand(options) {
-  const rootDir = path5.resolve(options.rootDir);
+  const rootDir = path6.resolve(options.rootDir);
   const config = options.config ?? await loadConfigOrDefault(rootDir, options.onDefaultConfig);
   const prompt = await resolvePrompt({
     prompt: options.prompt,
@@ -2434,9 +2679,9 @@ async function runCommand(options) {
   });
 }
 async function resumeCommand(options) {
-  const rootDir = path5.resolve(options.rootDir);
+  const rootDir = path6.resolve(options.rootDir);
   const config = options.config ?? await loadConfigOrDefault(rootDir, options.onDefaultConfig);
-  const sessionsDir = path5.resolve(rootDir, config.sessionsDir);
+  const sessionsDir = path6.resolve(rootDir, config.sessionsDir);
   const sessions = new SessionManager(sessionsDir);
   const session = await sessions.load(options.sessionId);
   const resolveAdapter = options.resolveAdapter ?? createAdapterFactory();
@@ -2487,9 +2732,9 @@ async function resumeCommand(options) {
   return { session, resumable, resumed: true, outcome };
 }
 async function resolveManager(opts) {
-  const rootDir = path5.resolve(opts.rootDir);
+  const rootDir = path6.resolve(opts.rootDir);
   const config = await loadConfigOrDefault(rootDir, opts.onDefaultConfig);
-  const sessionsDir = path5.resolve(rootDir, config.sessionsDir);
+  const sessionsDir = path6.resolve(rootDir, config.sessionsDir);
   const sessions = new SessionManager(sessionsDir);
   return { sessions, metas: await sessions.list() };
 }
@@ -2810,7 +3055,7 @@ program.command("run").description("Run a prompt through an agent adapter").opti
   "api decider: OpenAI-compatible chat-completions URL"
 ).option("--decider-model <model>", "api decider: model name").option("--decider-key <key>", "api decider: bearer API key").option(
   "--decider-max-tokens <n>",
-  "api decider: max tokens",
+  "api decider: max tokens (default 2048; floor 512 \u2014 reasoning models need headroom)",
   positiveIntArg("--decider-max-tokens")
 ).option(
   "--decider-timeout-ms <n>",
@@ -2882,7 +3127,7 @@ program.command("resume").description("Inspect a prior session and optionally se
   "Decider override: rule | always-approve | command | api"
 ).option("--decider-command <cmdline>", "command decider: full command line").option("--decider-url <url>", "api decider: chat-completions URL").option("--decider-model <model>", "api decider: model name").option("--decider-key <key>", "api decider: bearer API key").option(
   "--decider-max-tokens <n>",
-  "api decider: max tokens",
+  "api decider: max tokens (default 2048; floor 512 \u2014 reasoning models need headroom)",
   positiveIntArg("--decider-max-tokens")
 ).option(
   "--decider-timeout-ms <n>",