@garuda-agent/garuda 0.18.1 → 0.19.0

package/CHANGELOG.md

@@ -1,5 +1,78 @@
 # Changelog
 
+## 0.19.0 (2026-11-06)
+
+A security fix and the dependency majors. Sandboxed commands can no longer read the keys that the
+`ant` CLI stores. The Anthropic SDK 1.x moves Garuda's requests to API version `2026-10-21` and
+sends the key as `Authorization: Bearer` instead of `X-Api-Key`. Most setups notice nothing. If
+your requests go through a gateway or proxy (for example with `ANTHROPIC_BASE_URL`) that reads
+`X-Api-Key`, change it to read `Authorization`: the API takes either. This change is why the
+version is 0.19.0, not 0.18.3.
+
+- Security: sandboxed commands can no longer read `~/.config/anthropic/credentials`, where the `ant`
+  CLI stores keys. The SDK 1.x reads them too when it has no key.
+- The Homebrew formula in the repository names 0.18.2 and its tarball hash.
+- The Anthropic SDK is 1.6 (was 0.128). It uses API version `2026-10-21` and sends the key as
+  `Authorization: Bearer`. Garuda's requests needed no change: they send no `temperature`,
+  `top_p` or `top_k`, which that version refuses. A proxy in front of the API that reads
+  `X-Api-Key` must read `Authorization` now.
+- undici is 8.12 (was 7.30). Its HTTP/2 default stays off for model requests: Garuda's
+  20-minute wait for quiet streams was checked on HTTP/1.1. undici 8 needs Node.js 22.19 or newer;
+  Garuda already needs 22.23.4.
+- The ACP SDK is 2.4 (was 1.7). Garuda speaks the same protocol, ACP version 1, and uses only its
+  stable parts. The SDK now refuses `session/new` before `initialize`, as the protocol says;
+  editors always send `initialize` first.
+
+## 0.18.2 (2026-11-06)
+
+A fix release for repo evals (`garuda eval -s repo`, `garuda advise`). On macOS, 0.18.1 failed
+every check of a project whose tools live in `~/Library` (pnpm does), and Vite projects failed
+before a test ran. It also makes `garuda advise` faster and cheaper to repeat: runs in parallel,
+reuse of earlier runs, a cost estimate from real requests, and the command to go on after a stop
+at the cap. A provider outage no longer counts against a model.
+
+- Fix: repo-task evals (`-s repo`, `garuda advise`) on macOS failed every check in 0.18.1 when the
+  project's tools live in `~/Library`. pnpm runs the version that a project asks for from
+  `~/Library/pnpm`, and the 0.18.1 rules denied all of the home folder except hidden entries. The
+  check stopped with "EPERM: process.cwd failed", so both models passed 0 of 30 in the user's run.
+  `~/Library` is readable again in these runs; Mail, Messages, Safari, iCloud Drive, the other
+  personal parts and the keychains stay denied for every sandboxed command. Run 0.18.1 repo evals
+  again.
+- `advise` gives no advice when neither model passes a task: the check itself may fail.
+- Evals: a timeout while the model's API is silent is a new failure kind, `provider`. It applies
+  when a request was open at the limit, and the stream had broken and been retried or the API had
+  sent nothing for 2 minutes. Such a run is not scored, and it runs once more by itself; its
+  spending is kept. In the user's Sonnet run, 4 of 5 timeouts were such stalls, and they counted
+  against the model. A timeout also shows its steps now, not 0.
+- Fix: in repo-task evals, Vite could not write its compiled `vitest.config.ts` to
+  `node_modules/.vite-temp`, because the task's `node_modules` links to the project's and was
+  read-only. In the user's suite 10 of 30 tasks failed for both models before a test ran.
+  Commands may now write `.vite-temp`, `.vite` and `.cache` there, and nothing else.
+- `garuda eval --from-git` checks each kept commit a third time, as an eval runs it (a copy, in the
+  sandbox), and leaves out a commit whose tests fail there. Before, it checked only on the host,
+  and a task could pass the build but never an eval (2 of 30 in the user's suite: tests that start
+  their own sandbox). Build your suite again.
+- The Homebrew formula in the repository names 0.18.1 and its tarball hash.
+- `garuda advise` runs 4 tasks at a time (`--parallel <n>`); each result line starts with the
+  model and a count, as in `[haiku-5-5 12/30] ✓ fix-parser: pass`. The first real run, one at a
+  time, took 64 minutes for 30 tasks.
+- `advise` reuses an earlier run of a model when the model, the task hashes, `--repeat`, `--seed`
+  and the Garuda version and build commit are the same and every run is there. Runs of 0.18.0 and
+  before are not reused: they could read your checkout (the 0.18.1 fix).
+- The cost estimate comes from the mean cost of earlier runs of the model on the same tasks. With
+  none, it prices each request of the other model's runs (from their session files) at this
+  model's prices; else the token guess. Each line says which. (A first version scaled by the ratio
+  of list prices: 20 for Sonnet 5.5 over Haiku 5.5, but Haiku costs 5 times as much for a prompt
+  over 100 000 tokens. On a real run it estimated $19.16 where the requests give $12.62.)
+- The repriced estimate is scaled by what both models really cost on shared repo tasks before:
+  Sonnet 5.5 needs fewer steps and tokens than Haiku 5.5, and cost $6.30 where Haiku's requests at
+  its prices gave $12.62 (× 0.52). Without the factor, the user's 90-run estimate was $33.62; with
+  it, $17.37. Runs where no task passed, and built-in suites, are left out.
+- When the estimate or the first model's real cost passes `--max-cost`, `advise` prints the
+  command that goes on (`garuda advise --models a,b --repeat R --seed S --max-cost N`). The first
+  model's run is kept and reused.
+- `advise` stops when a run fails to start (for example a refused key), not at a missing report.
+
 ## 0.18.1 (2026-11-06)
 
 A security release. In 0.18.0 and earlier, a command in the OS sandbox could read your personal

package/README.md

@@ -7,7 +7,7 @@ Website and docs: https://madhu-sv.github.io/garuda/
 Garuda is a coding agent for the terminal, and for editors over the Agent Client Protocol. It reads
 and edits your code, runs commands in an OS sandbox, and keeps an audit log of its permission
 decisions. It works with Claude and with OpenAI-compatible models, local ones too. This is version
-0.18.1. Release notes: [CHANGELOG.md](CHANGELOG.md).
+0.19.0. Release notes: [CHANGELOG.md](CHANGELOG.md).
 
 ## What Garuda does on your machine
 

package/dist/{acpCommand-JAYNMIMP.js → acpCommand-SIFV5XBS.js}

@@ -1,19 +1,18 @@
 #!/usr/bin/env node
-import {
-  Runtime,
-  auditDirFor
-} from "./chunk-5UDYQ5MK.js";
-import "./chunk-G2AX7MGS.js";
-import "./chunk-ULAJPMY7.js";
-import "./chunk-JMH5W5DG.js";
 import {
   chooseModel,
   keepProviderKeys,
   loadModelsConfig,
   providerKeySource,
   resolveModel
-} from "./chunk-QLBCM2YQ.js";
-import "./chunk-NH72AELP.js";
+} from "./chunk-QE7E77IR.js";
+import {
+  Runtime,
+  auditDirFor
+} from "./chunk-BFK432BK.js";
+import "./chunk-G2AX7MGS.js";
+import "./chunk-ULAJPMY7.js";
+import "./chunk-65NUEOI7.js";
 import "./chunk-4QRTTRVK.js";
 import "./chunk-A2QAIRQL.js";
 import {
@@ -26,13 +25,13 @@ import {
 import "./chunk-MNE7HHX2.js";
 import {
   VERSION
-} from "./chunk-IYGJWX65.js";
+} from "./chunk-U6Z4WH3B.js";
 import "./chunk-5DEWP3YX.js";
 import "./chunk-PZS3V6P3.js";
 import "./chunk-QANRZW7W.js";
 import "./chunk-ATW7BNIG.js";
 import "./chunk-AOGFYUKG.js";
-import "./chunk-LMKGSYJC.js";
+import "./chunk-L5TZTKUV.js";
 import "./chunk-BHZ6G65V.js";
 import "./chunk-P6XWWIEK.js";
 import "./chunk-UIRJOQQS.js";
@@ -50,7 +49,7 @@ async function acpCommand(options) {
 `);
       return 1;
     }
-    const { setupCommand, terminalIO } = await import("./setupCommand-OSOMFHDQ.js");
+    const { setupCommand, terminalIO } = await import("./setupCommand-YHDRJTPZ.js");
     return setupCommand({}, { io: await terminalIO() });
   }
   const output = protocolOutput(process.stdout, process.stderr);
@@ -193,4 +192,4 @@ export {
   prepare,
   protocolOutput
 };
-//# sourceMappingURL=acpCommand-JAYNMIMP.js.map
+//# sourceMappingURL=acpCommand-SIFV5XBS.js.map

package/dist/advise-EA7OIYSV.js

@@ -0,0 +1,433 @@
+#!/usr/bin/env node
+import {
+  taskHash
+} from "./chunk-2TX3KY4M.js";
+import {
+  garudaCommit
+} from "./chunk-YIU5QGMV.js";
+import {
+  escapeHtml
+} from "./chunk-4BELTWP4.js";
+import {
+  BUILD_COMMIT
+} from "./chunk-FBCVU2P2.js";
+import {
+  compareReports,
+  costPerPass,
+  formatComparison,
+  loadReport,
+  repoEvalTasks
+} from "./chunk-CKVF67VJ.js";
+import {
+  loadModelsConfig,
+  resolveModel
+} from "./chunk-QE7E77IR.js";
+import "./chunk-AX3A5KPH.js";
+import "./chunk-2OYTNNUJ.js";
+import "./chunk-NXJ4XLB5.js";
+import "./chunk-BFK432BK.js";
+import "./chunk-G2AX7MGS.js";
+import "./chunk-ULAJPMY7.js";
+import "./chunk-65NUEOI7.js";
+import "./chunk-4QRTTRVK.js";
+import "./chunk-A2QAIRQL.js";
+import {
+  newSessionId
+} from "./chunk-NLS7GMF7.js";
+import {
+  costOf,
+  responseCost
+} from "./chunk-7KBOIPUT.js";
+import "./chunk-B25VL4RU.js";
+import "./chunk-MNE7HHX2.js";
+import {
+  VERSION
+} from "./chunk-U6Z4WH3B.js";
+import "./chunk-5DEWP3YX.js";
+import "./chunk-PZS3V6P3.js";
+import "./chunk-QANRZW7W.js";
+import "./chunk-ATW7BNIG.js";
+import "./chunk-A4SSBJ2P.js";
+import "./chunk-AOGFYUKG.js";
+import "./chunk-5GF2VINR.js";
+import "./chunk-L5TZTKUV.js";
+import "./chunk-BHZ6G65V.js";
+import "./chunk-P6XWWIEK.js";
+import "./chunk-UIRJOQQS.js";
+import "./chunk-4LFJFDCF.js";
+import "./chunk-3NJNVZTK.js";
+
+// src/cli/advise.ts
+import { mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { basename, join } from "path";
+import { createInterface } from "readline/promises";
+var ADVISE_MODELS = ["claude-haiku-5-5", "claude-sonnet-5-5"];
+var ADVISE_REPEAT = 2;
+var ADVISE_MAX_COST = 2;
+var GUESS_INPUT_TOKENS = 6e4;
+var GUESS_OUTPUT_TOKENS = 1500;
+function estimateUsd(price, runs) {
+  if (price === void 0) return void 0;
+  return runs * (GUESS_INPUT_TOKENS * price.input + GUESS_OUTPUT_TOKENS * price.output) / 1e6;
+}
+function adviceText(a, b, c, tasks) {
+  const rough = tasks < 10 ? ` With ${tasks} task${tasks === 1 ? "" : "s"}, this is a rough guide.` : "";
+  if (c.verdict === "B passes more")
+    return `Advice: ${b} for this repo. It passes more often.${rough}`;
+  if (c.verdict === "B passes less")
+    return `Advice: ${a} for this repo. It passes more often.${rough}`;
+  if (c.rateA === 0 && c.rateB === 0) {
+    return `Advice: none. Neither model passed a task, so the check itself may fail: read a run's "reason" in report.json before you trust this.`;
+  }
+  const ratio = c.costRatio;
+  if (ratio === void 0) {
+    return `Advice: no clear difference in passes, and the cost could not be compared.${rough}`;
+  }
+  const times = (x) => `${x.toFixed(1)} times`;
+  if (ratio.verdict === "B costs less per accepted change") {
+    return `Advice: ${b} for this repo. It passes as often, and ${a} costs ${times(1 / ratio.value)} as much per accepted change.${rough}`;
+  }
+  if (ratio.verdict === "B costs more per accepted change") {
+    return `Advice: ${a} for this repo. It passes as often, and ${b} costs ${times(ratio.value)} as much per accepted change.${rough}`;
+  }
+  const cheaper = ratio.value <= 1 ? b : a;
+  return `Advice: either. No clear difference in passes or in cost; ${cheaper} was cheaper in these runs.${rough}`;
+}
+function adviceHtml(comparison, advice) {
+  return [
+    "<!doctype html>",
+    '<html lang="en"><head><meta charset="utf-8">',
+    `<meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'">`,
+    "<title>Garuda advise</title>",
+    "<style>body{font:15px/1.5 system-ui,sans-serif;max-width:900px;margin:32px auto;padding:0 16px}",
+    "pre{font:13px/1.45 ui-monospace,monospace;white-space:pre-wrap}.advice{font-weight:600}</style>",
+    "</head><body><h1>Which model for this repository</h1>",
+    `<p class="advice">${escapeHtml(advice)}</p>`,
+    `<pre>${escapeHtml(comparison)}</pre>`,
+    "</body></html>",
+    ""
+  ].join("\n");
+}
+var ADVISE_PARALLEL = 4;
+function pastRuns(evalsDir) {
+  const folders = [];
+  try {
+    for (const name of readdirSync(evalsDir)) {
+      const path = join(evalsDir, name);
+      folders.push(path, join(path, "a"), join(path, "b"));
+    }
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const folder of folders) {
+    const file = join(folder, "report.json");
+    try {
+      const data = JSON.parse(readFileSync(file, "utf8"));
+      const garuda = data.garuda;
+      out.push({
+        path: folder,
+        model: typeof data.spec === "string" ? data.spec : typeof data.model === "string" ? data.model : void 0,
+        version: typeof garuda?.version === "string" ? garuda.version : void 0,
+        commit: typeof garuda?.commit === "string" ? garuda.commit : void 0,
+        suite: typeof data.suite === "string" ? data.suite : void 0,
+        repeat: typeof data.repeat === "number" ? data.repeat : void 0,
+        seed: typeof data.seed === "number" ? data.seed : void 0,
+        tasks: typeof data.tasks === "object" && data.tasks !== null ? data.tasks : void 0,
+        results: Array.isArray(data.results) ? data.results : [],
+        mtimeMs: statSync(file).mtimeMs
+      });
+    } catch {
+    }
+  }
+  return out.sort((x, y) => y.mtimeMs - x.mtimeMs);
+}
+var sameTasks = (a, b) => a !== void 0 && Object.keys(a).length === Object.keys(b).length && Object.entries(b).every(([id, hash]) => a[id] === hash);
+function reusableRun(runs, want) {
+  const count = Object.keys(want.tasks).length * want.repeat;
+  return runs.find(
+    (r) => r.model === want.model && r.version === want.version && r.commit === want.commit && r.suite === "repo" && r.repeat === want.repeat && r.seed === want.seed && sameTasks(r.tasks, want.tasks) && r.results.length === count
+  );
+}
+function pastCostPerRun(runs, model, tasks) {
+  const results = runs.filter((r) => r.model === model && sameTasks(r.tasks, tasks)).flatMap((r) => r.results);
+  if (results.length === 0 || results.some((r) => r.costUsd === void 0)) return void 0;
+  return results.reduce((sum, r) => sum + (r.costUsd ?? 0), 0) / results.length;
+}
+function repricedSessionCost(file, price) {
+  let text;
+  try {
+    text = readFileSync(file, "utf8");
+  } catch {
+    return void 0;
+  }
+  let usd = 0;
+  for (const line of text.split("\n")) {
+    if (line.trim() === "") continue;
+    let record;
+    try {
+      record = JSON.parse(line);
+    } catch {
+      return void 0;
+    }
+    if (record.type === "unreported" || record.type === "child_debit") return void 0;
+    if (line.includes('"subagent":{')) return void 0;
+    if (record.type === "assistant") {
+      const cost = responseCost(record.response, price);
+      if (cost === void 0) return void 0;
+      usd += cost;
+    }
+    if (record.type === "side_usage") usd += costOf(record.usage, price);
+  }
+  return usd;
+}
+function repricedCostPerRun(runs, model, tasks, price) {
+  if (price === void 0) return void 0;
+  const costs = [];
+  for (const run of runs.filter((r) => r.model === model && sameTasks(r.tasks, tasks))) {
+    for (const result of run.results) {
+      const file = result.sessionFile;
+      if (file === void 0) {
+        costs.push(void 0);
+        continue;
+      }
+      const near = join(run.path, basename(file));
+      costs.push(repricedSessionCost(near, price) ?? repricedSessionCost(file, price));
+    }
+  }
+  const known = costs.filter((c) => c !== void 0);
+  if (known.length === 0 || known.length * 2 < costs.length) return void 0;
+  return known.reduce((sum, c) => sum + c, 0) / known.length;
+}
+function repriceFactor(runs, source, target, price) {
+  const useful = runs.filter((r) => r.suite === "repo" && r.results.some((x) => x.passed));
+  const sets = [];
+  for (const run of useful.filter((r) => r.model === source && r.tasks !== void 0)) {
+    const tasks = run.tasks;
+    if (sets.some((t) => sameTasks(t, tasks))) continue;
+    if (useful.some((r) => r.model === target && sameTasks(r.tasks, tasks))) sets.push(tasks);
+  }
+  const ratios = [];
+  for (const tasks of sets) {
+    const real = pastCostPerRun(useful, target, tasks);
+    const repriced = repricedCostPerRun(useful, source, tasks, price);
+    if (real !== void 0 && repriced !== void 0 && repriced > 0) ratios.push(real / repriced);
+  }
+  if (ratios.length === 0) return void 0;
+  return { value: ratios.reduce((sum, r) => sum + r, 0) / ratios.length, sets: ratios.length };
+}
+function costEstimate(runs, own, repriced, price) {
+  if (own !== void 0) return { usd: own * runs, how: "from earlier runs" };
+  if (repriced.perRun !== void 0) {
+    const f = repriced.factor;
+    return {
+      usd: repriced.perRun * (f?.value ?? 1) * runs,
+      how: f === void 0 ? `from ${repriced.from}'s requests at this model's prices` : `from ${repriced.from}'s requests at this model's prices, \xD7 ${f.value.toFixed(2)} as in ${f.sets} earlier comparison${f.sets === 1 ? "" : "s"}`
+    };
+  }
+  return { usd: estimateUsd(price, runs), how: "a guess" };
+}
+var sumKnown = (values) => values.some((v) => v === void 0) ? void 0 : values.reduce((sum, v) => sum + (v ?? 0), 0);
+function continueCommand(a, b, repeat, seed, maxCost) {
+  return `garuda advise --models ${a},${b} --repeat ${repeat} --seed ${seed} --max-cost ${Math.ceil(maxCost)}`;
+}
+async function runAdvise(options) {
+  const [a, b] = options.models ?? ADVISE_MODELS;
+  if (a === void 0 || b === void 0 || options.models?.length === 1 || (options.models?.length ?? 2) > 2) {
+    process.stderr.write("Give two models: --models <a>,<b>.\n");
+    return 1;
+  }
+  const repeat = options.repeat ?? ADVISE_REPEAT;
+  const maxCost = options.maxCost ?? ADVISE_MAX_COST;
+  const seed = options.seed ?? 1;
+  const parallel = options.parallel ?? ADVISE_PARALLEL;
+  if (!Number.isInteger(repeat) || repeat < 1 || !(maxCost > 0) || !Number.isInteger(parallel) || parallel < 1) {
+    process.stderr.write(
+      "--repeat and --parallel must be whole numbers of 1 or more, and --max-cost above 0.\n"
+    );
+    return 1;
+  }
+  const { repoSuite, runEvalCommand } = await import("./evalCommand-GQWNI2YJ.js");
+  const suite = await repoSuite();
+  if (typeof suite === "string") {
+    process.stderr.write(`${suite}
+`);
+    return 1;
+  }
+  const repoTasks = repoEvalTasks(suite);
+  const tasks = repoTasks.length;
+  const hashes = Object.fromEntries(repoTasks.map((t) => [t.id, taskHash(t)]));
+  const models = await loadModelsConfig();
+  if (models.problem !== void 0) {
+    process.stderr.write(`${models.problem}
+`);
+    return 1;
+  }
+  let prices;
+  try {
+    prices = [resolveModel(a, models.config).info.price, resolveModel(b, models.config).info.price];
+  } catch (error) {
+    process.stderr.write(`${error.message}
+`);
+    return 1;
+  }
+  const evalsDir = join(process.cwd(), ".garuda", "evals");
+  const past = pastRuns(evalsDir);
+  const commit = BUILD_COMMIT ?? await garudaCommit();
+  const want = { repeat, seed, tasks: hashes, version: VERSION, commit };
+  const reuse = [
+    reusableRun(past, { ...want, model: a }),
+    reusableRun(past, { ...want, model: b })
+  ];
+  const runs = tasks * repeat;
+  const perRun = [pastCostPerRun(past, a, hashes), pastCostPerRun(past, b, hashes)];
+  const repriced = (i, from) => perRun[i] === void 0 ? repricedCostPerRun(past, from, hashes, prices[i]) : void 0;
+  const factors = [
+    perRun[0] === void 0 ? repriceFactor(past, b, a, prices[0]) : void 0,
+    perRun[1] === void 0 ? repriceFactor(past, a, b, prices[1]) : void 0
+  ];
+  const estimates = [
+    costEstimate(
+      runs,
+      perRun[0],
+      { perRun: repriced(0, b), from: b, factor: factors[0] },
+      prices[0]
+    ),
+    costEstimate(
+      runs,
+      perRun[1],
+      { perRun: repriced(1, a), from: a, factor: factors[1] },
+      prices[1]
+    )
+  ];
+  const line = (model, i) => {
+    const r = reuse[i];
+    const e = estimates[i];
+    return r !== void 0 ? `  ${model}: reuses ${r.path} (Garuda ${r.version}, ${r.results.length} runs)` : `  ${model}: ${runs} runs, ${e?.usd === void 0 ? "cost unknown" : `about $${e.usd.toFixed(2)} (${e.how})`}`;
+  };
+  const toSpend = sumKnown(
+    [0, 1].filter((i) => reuse[i] === void 0).map((i) => estimates[i]?.usd)
+  );
+  process.stderr.write(
+    [
+      `Your repo: ${tasks} task${tasks === 1 ? "" : "s"} from its history (tests that fail before the commit and pass after it).`,
+      `${repeat} run${repeat === 1 ? "" : "s"} a task, ${parallel} at a time, seed ${seed}:`,
+      line(a, 0),
+      line(b, 1),
+      `Cap: --max-cost $${maxCost}; it stops before a model that would pass it.`,
+      ""
+    ].join("\n")
+  );
+  if (toSpend !== void 0 && toSpend > maxCost) {
+    process.stderr.write(
+      `The estimate passes the cap. To go on: ${continueCommand(a, b, repeat, seed, toSpend * 1.25)}
+`
+    );
+    return 1;
+  }
+  if (options.yes !== true && (reuse[0] === void 0 || reuse[1] === void 0)) {
+    if (!process.stdin.isTTY) {
+      process.stderr.write("Add --yes to start without a question.\n");
+      return 1;
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    const answer = await rl.question("Start? (y/N) ");
+    rl.close();
+    if (!/^y(es)?$/i.test(answer.trim())) return 1;
+  }
+  const dir = join(evalsDir, `advise-${newSessionId()}`);
+  mkdirSync(dir, { recursive: true });
+  const runModel = async (model, label, i) => {
+    const earlier = reuse[i];
+    if (earlier !== void 0) {
+      process.stderr.write(`Reusing ${earlier.path} for ${model}.
+`);
+      return earlier.path;
+    }
+    const outDir = join(dir, label);
+    const code = await runEvalCommand({
+      model,
+      suite: "repo",
+      repeat,
+      shuffle: true,
+      seed,
+      parallel,
+      outDir,
+      progress: model.replace(/^claude-/, "")
+    });
+    return code === 1 ? void 0 : outDir;
+  };
+  const pathA = await runModel(a, "a", 0);
+  if (pathA === void 0) return 1;
+  const first = await loadReport(pathA);
+  if (reuse[0] === void 0 && reuse[1] === void 0) {
+    const spent = costPerPass(first.results);
+    const spentA = spent.kind === "unknown" ? void 0 : spent.totalUsd;
+    const nextB = costEstimate(
+      runs,
+      perRun[1],
+      {
+        perRun: repricedCostPerRun(pastRuns(evalsDir), a, hashes, prices[1]),
+        from: a,
+        factor: factors[1]
+      },
+      prices[1]
+    ).usd;
+    if (spentA !== void 0 && nextB !== void 0 && spentA + nextB > maxCost) {
+      process.stderr.write(
+        [
+          `Stopped before ${b}: ${a} cost $${spentA.toFixed(2)}, and ${b} would cost about $${nextB.toFixed(2)}, past $${maxCost}.`,
+          `${a}'s run is kept and will be reused. To go on: ${continueCommand(a, b, repeat, seed, nextB * 1.25)}`,
+          ""
+        ].join("\n")
+      );
+      return 1;
+    }
+  }
+  const pathB = await runModel(b, "b", 1);
+  if (pathB === void 0) return 1;
+  const second = await loadReport(pathB);
+  const result = compareReports(first, second, { seed });
+  if ("problems" in result) {
+    process.stderr.write(`The two runs cannot be compared:
+${result.problems.join("\n")}
+`);
+    return 1;
+  }
+  const comparison = formatComparison(first, second, result.comparison);
+  const advice = adviceText(a, b, result.comparison, tasks);
+  writeFileSync(join(dir, "advice.txt"), `${advice}
+
+${comparison}
+`);
+  writeFileSync(join(dir, "report.html"), adviceHtml(comparison, advice));
+  process.stdout.write(`
+${comparison}
+
+${advice}
+Report: ${join(dir, "report.html")}
+`);
+  return 0;
+}
+export {
+  ADVISE_MAX_COST,
+  ADVISE_MODELS,
+  ADVISE_PARALLEL,
+  ADVISE_REPEAT,
+  GUESS_INPUT_TOKENS,
+  GUESS_OUTPUT_TOKENS,
+  adviceHtml,
+  adviceText,
+  continueCommand,
+  costEstimate,
+  estimateUsd,
+  pastCostPerRun,
+  pastRuns,
+  repriceFactor,
+  repricedCostPerRun,
+  repricedSessionCost,
+  reusableRun,
+  runAdvise,
+  sumKnown
+};
+//# sourceMappingURL=advise-EA7OIYSV.js.map

package/dist/{anthropic-NQIZLD64.js → anthropic-6DKONNQG.js}

@@ -42,11 +42,12 @@ function withHiddenThinking(response) {
   };
 }
 var STREAM_IDLE_MS = 20 * 6e4;
+var STREAM_ALLOW_H2 = false;
 var dispatchers = /* @__PURE__ */ new Map();
 function streamFetch(idleMs = STREAM_IDLE_MS) {
   let agent = dispatchers.get(idleMs);
   if (agent === void 0) {
-    agent = new Agent({ bodyTimeout: idleMs });
+    agent = new Agent({ bodyTimeout: idleMs, allowH2: STREAM_ALLOW_H2 });
     dispatchers.set(idleMs, agent);
   }
   const dispatcher = agent;
@@ -320,6 +321,7 @@ export {
   AnthropicClient,
   BATCH_CHECK_TIMEOUT_MS,
   BATCH_POLL_MS,
+  STREAM_ALLOW_H2,
   STREAM_IDLE_MS,
   WEB_SEARCH_TOOL,
   clientOptions,
@@ -330,4 +332,4 @@ export {
   toWireTools,
   withHiddenThinking
 };
-//# sourceMappingURL=anthropic-NQIZLD64.js.map
+//# sourceMappingURL=anthropic-6DKONNQG.js.map

package/dist/{buildCheck-HB46NWLX.js → buildCheck-JNWGER5R.js}

@@ -3,9 +3,9 @@ import {
   CHAT_STALE,
   garudaCommit,
   staleBuildNote
-} from "./chunk-YAQ6QLKB.js";
-import "./chunk-QXTHEFKP.js";
-import "./chunk-LMKGSYJC.js";
+} from "./chunk-YIU5QGMV.js";
+import "./chunk-5GF2VINR.js";
+import "./chunk-L5TZTKUV.js";
 import "./chunk-BHZ6G65V.js";
 import "./chunk-P6XWWIEK.js";
 import "./chunk-UIRJOQQS.js";
@@ -16,4 +16,4 @@ export {
   garudaCommit,
   staleBuildNote
 };
-//# sourceMappingURL=buildCheck-HB46NWLX.js.map
+//# sourceMappingURL=buildCheck-JNWGER5R.js.map

package/dist/buildInfo-APQVLWI7.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import {
+  BUILD_COMMIT
+} from "./chunk-FBCVU2P2.js";
+export {
+  BUILD_COMMIT
+};
+//# sourceMappingURL=buildInfo-APQVLWI7.js.map

package/dist/{chunk-TWQ7V2L6.js → chunk-2THG7PEC.js}

@@ -2,7 +2,7 @@
 import {
   hostCommand,
   shellWord
-} from "./chunk-QXTHEFKP.js";
+} from "./chunk-5GF2VINR.js";
 import {
   JOBS_DIR
 } from "./chunk-VTMD5IHD.js";
@@ -154,4 +154,4 @@ export {
   nightAgentTime,
   removeAgent
 };
-//# sourceMappingURL=chunk-TWQ7V2L6.js.map
+//# sourceMappingURL=chunk-2THG7PEC.js.map