@garuda-agent/garuda 0.17.0 → 0.18.1

package/CHANGELOG.md

@@ -1,5 +1,248 @@
 # Changelog
 
+## 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
+folders (Documents, Downloads, Pictures and the Photos library, Mail and the like), and on macOS it
+could reach denied paths through `/System/Volumes/Data`. Update to 0.18.1. It also has the UX work
+of docs/lld/ux.md (receipts, a network question, `/rewind`, word-level diffs, the morning brief,
+`/export --html`, `garuda advise` and more) and eval failure kinds.
+
+- Security: sandboxed commands can no longer read your personal folders: Desktop, Documents,
+  Downloads, Movies, Music, Pictures (with the Photos library), Public, and Mail, Messages, Safari,
+  Calendars, Contacts, iCloud Drive and other cloud folders in `~/Library`. A project inside one of
+  them stays readable, the rest of that folder does not. On macOS each read and write rule also
+  covers the same path under `/System/Volumes/Data`, where a command could reach it before. Found
+  in a live run: a model's `find /` in an eval made macOS ask the user to let iTerm into Downloads
+  and Photos.
+- Evals: a repo task now runs in a copy of the project with no history, not a git worktree, and
+  its commands cannot read the project's checkout (except `node_modules` and venvs) or the rest of
+  the home folder except hidden entries. In a live run, a model read the user's checkout, which
+  holds the commit that the task asks for. Repo results from before this change may have read the
+  answer; run them again.
+- UX, patch 7 (docs/lld/ux.md U11, U8): `/export --html [file]` writes the session as one page:
+  your requests, the answers, each tool call that opens to its output (an edit opens to its
+  change), and the receipts. Every text is escaped; the page has no script and no link, and its
+  own policy forbids them. `garuda advise` runs the repo suite (`garuda eval --from-git`) on two
+  models (default Haiku 5.5 and Sonnet 5.5, 2 runs a task, at most $2), compares them as
+  `eval compare` does, and advises: the model that passes clearly more, or on a tie the cheaper
+  one. It asks first with a cost guess, and writes `advice.txt` and `report.html`.
+- UX, patch 6 (docs/lld/ux.md U7, U9): the morning brief. The first chat after jobs ran shows them
+  once: each job's verdict, its tests ("tests 120 → 126" when the runner's summary gives counts)
+  and its branch, and the total cost. `.garuda/jobs/brief.seen` keeps the time of the last brief.
+  The first-run tour: the first chat in a project with code names its stack ("TypeScript with
+  vitest (pnpm)") and offers three first tasks; typing 1, 2 or 3 runs one. It shows once per
+  project (`~/.garuda/ui.json` keeps a hash of the folder, not its path).
+- UX, patch 5 (docs/lld/ux.md U5): diffs mark the changed words of a changed line (inverse video),
+  in approvals, in hunk review and in `/diff`. From 140 columns a diff is side by side, with the
+  line numbers of both files. An approval that can review hunks says so in its first line:
+  "3 hunks · h reviews them one by one". Syntax colours are not in this patch (decision D10).
+  Only a real diff (with a hunk header) gets the marks and the two columns; other previews, such
+  as the project-settings question, keep their simple colours (the first live run showed that
+  question twice, side by side).
+- UX, patch 4 (docs/lld/ux.md U6): `/rewind` lists the turns that undo can reach (files, cost, age).
+  `/rewind <n>` goes back to the start of turn n in one step, with one question; `/redo` brings the
+  turns back one at a time. `/rewind fork <n>` starts a new session with the conversation up to
+  turn n and the files as they were then; the old session does not change. A new `fork` record
+  starts such a session.
+- UX, patch 3 (docs/lld/ux.md U4): in the chat, calls of one read-only tool in a row become one
+  line, for example `● Read 5 files  docs/architecture.md, SECURITY.md, +3`; a lone call keeps its
+  line and its result. Edits, commands and failed calls always keep a line of their own. Ctrl-O
+  still shows the last call's output. The model's plan (`todo_write`) is drawn live above the
+  input during the turn and printed once at the end, instead of after every update.
+- The chat's wordmark has a drop shadow (a 3D look), drawn twice as large from 130 columns, with
+  the card as wide as the wordmark; a tall screen gets some space above it. A screen reader gets no
+  wordmark (the card says the name).
+- The chat starts on a clear screen, with the banner centred, and you type in a visible chat box
+  with a hint ("Type a task · / for commands · @ for files"). The old screen goes into the
+  scrollback, not away; `"ui": { "clearOnStart": false }` in settings keeps it on screen. Garuda
+  stays in the terminal's normal screen, so its scrollback, search and copy still work. The box's
+  border dims while a turn runs. With `GARUDA_SCREEN_READER=1`, or under 40 columns, there is no box
+  and the banner is not centred.
+- UX, patch 2 (docs/lld/ux.md U2): a chat with no network allowlist starts Garuda's proxy with no
+  host on it ("watch mode"). A command in the sandbox that needs a host now asks for it (once, this
+  session, or no) instead of failing with a DNS error; an empty list needs no consent. After "this
+  session", Garuda says which line in `network.allow` keeps it for the project (a preset such as
+  `npm` when the host belongs to one). The receipt names a blocked host. `-p`, jobs and evals keep
+  no network, as before.
+- The chat shows your requests with a bar (`▌`) on every line, and Garuda's answer starts with `✦`,
+  so requests and answers differ at a glance. With `GARUDA_SCREEN_READER=1` they read "You:" and
+  "Garuda:".
+- The chat warns at start when `dist/` is older than its checkout ("run pnpm build first"), as the
+  evals do. `garudaCommit` and `staleBuildNote` moved to `src/buildCheck.ts`.
+- Docs: `architecture.md`, `hld.md` and the docs index describe Garuda as it is now. The release
+  history in their prose (version lists, "since 0.x", test counts per release) is gone; the
+  CHANGELOG keeps it.
+- UX, patch 1 (docs/lld/ux.md): a receipt after each turn that changed files, ran tests, ran a command outside the sandbox, or had a host blocked: the
+  files with their lines (from the undo snapshots), the last test run with its count for vitest,
+  jest, node:test, pytest, Maven and `go test -v`, the commands in and outside the sandbox, blocked
+  hosts, what `/undo` puts back, and the session's cost per kept change. A turn that only answered
+  keeps the usage line, also when it ran read-only commands in the sandbox (the first live run: a
+  `find` gave a receipt with no news). The session records the receipt (`receipt`), `/export` shows it, and
+  `-p --json` has it as `receipt`. Under 60 columns, in a pipe and with `GARUDA_SCREEN_READER=1` it
+  is plain lines.
+- The chat asks how to go on after the step limit: go on for as many steps again, summarise what is
+  left, or stop. After the same tool call 3 times it says to type a hint, and no longer names
+  `--resume`.
+- The chat's footer shows the context as a bar and a number (yellow from 70%, red from 80%). The key
+  hints show in the first 5 chats; then the footer says `? keys`, and `?` on an empty line lists them.
+- Design: the UX note (docs/lld/ux.md), with mock-ups and no code yet. A receipt after each
+  turn (files, tests, sandbox, undo, cost per kept change), a blocked host as a one-key fix,
+  next steps after a stop, a live plan, better diffs, rewind and fork, a morning brief from the
+  night shift, `garuda advise` (which model for this repo), a first-run tour, a quieter footer,
+  HTML export, and reduced motion and screen-reader modes. Ten decisions for the user.
+- Blog: "Garuda against Claude Code, with intervals": the eval method, the Claude Code
+  baseline, the faults the live runs found in the tasks, the Graphify A/B, the tuned prompt, and
+  the limits.
+- The Homebrew formula in the repository names 0.18.0 and its tarball hash.
+- Failure kinds: the eval report gives one line, "Failures by kind", that counts the failed runs
+  as `check` (the check failed), `protected-files`, `step-limit`, `token-limit`,
+  `repeated-calls`, `refusal`, `timeout`, `error` or `setup` (the key, the connection or the MCP
+  server), and names up to three runs of each kind. A limit or a timeout wins over the check that
+  failed after it. `report.json` has the same in `evidence.failures`, with each failed run's
+  steps, tokens and time.
+- The reports of the runs in the blog post are in `docs/quality-baseline/evals/0.18/`, with a
+  README that maps each run to the post and gives the `eval compare` commands. Local paths are
+  removed. A test checks that the files hold no local path and that `compare` gives the post's
+  numbers. The post links to them. Biome and the docs site leave the folder out.
+
+## 0.18.0 (2026-11-04)
+
+- Biome 2.6.2 (with @inquirer/prompts 8.7.4, react 19.3.1 and smol-toml 1.9.1, from Dependabot's
+  group update). Biome 2.6 formats Markdown and YAML by default: Markdown formatting is off (the
+  docs keep their own layout), and pnpm's lockfiles are left out.
+- Dependabot: `@types/node` stays on the oldest supported Node line (no major updates); each other
+  major update comes as its own pull request.
+- The Homebrew formula in the repository names 0.17.0 and its tarball hash.
+- Eval evidence, part 1 (T11a): the report gives the pass rate over all attempts with a 95%
+  interval (a cluster bootstrap over tasks, so repeats of one task count together), the tasks that
+  passed every run or none, the median and p95 of steps, tokens and time, the cost per accepted
+  change (all attempts divided by the passes), and unexpected changes (files that a run changed
+  but the task did not need; a new `allowChanges` field widens a task's scope). `--shuffle` and
+  `--seed` set the run order. `report.json` is version 2, with Garuda's version and commit, the
+  model, the OS, the seed, the run order and a hash of each task. A run whose every attempt failed
+  with an error gives no interval ("No scored run"), a task with only error runs is not counted as
+  "passed none", and an authentication error (401 or 403, for example a refused API key) stops the
+  eval at the first run instead of failing every run the same way.
+- `garuda eval compare <a> <b>` (T11a part 2): two reports of the same tasks side by side, the
+  difference of the pass rates (B − A) with a paired 95% interval, and each arm's cost per accepted
+  change, unexpected changes and median time. It refuses reports whose tasks differ, and a
+  difference whose interval contains 0 is "no clear difference". The run report now says when its
+  interval is only a rough guide (fewer than 10 tasks, or every draw gave the same rate).
+- The Claude Code baseline (T11b): `garuda eval --agent claude-code` runs `claude -p` on the same
+  tasks with the same scratch folders, time limit and grading, so `garuda eval compare` can set
+  Garuda against Claude Code. Claude Code runs with every tool allowed, so only in the OS sandbox,
+  with network only to `api.anthropic.com`, a new config folder per run, and the API key in its
+  environment only. Its turns, tokens and cost come from its JSON result. `eval compare` prints a
+  zero difference as "0 pts" and says when every draw gave the same difference. The user's first
+  live baseline run found that the proxy for `api.anthropic.com` started only in a Garuda turn, so
+  Claude Code had no network: the runner now starts it first (`Runtime.prepareCommands`). An eval
+  now also stops at the first run that cannot reach the API (a refused connection, an unknown
+  host, a certificate error), as it does for a refused key.
+- `garuda eval compare` also compares the cost per accepted change: the ratio B/A with a paired
+  95% interval, and a verdict ("B costs more", "B costs less" or "no clear difference"). An unknown
+  cost gives no ratio. The hard-coupon task allows changes in the coupon module and the API routes
+  (`allowChanges`): both agents made them in the first baseline runs. Its task hash changes, so
+  compare new hard-suite runs only with new ones.
+- A held-out set (T11c): 10 new, harder tasks in TypeScript, Python and Java, apart from every
+  suite. `--split heldout` runs them, `--split all` runs them with the dev tasks, and a plain
+  `garuda eval` never does (a held-out id with `-t` is refused with the fix). They cover a defect
+  whose cause is in another file (3), a refactor across modules (2), tests that a mutation check
+  must find good enough (2), conventions from the repository's `AGENTS.md` that a hidden test
+  checks (2), and a vague request (1). Each task's hash is recorded in the tests: a changed task
+  must change its hash on purpose, and a tuning result seen before the change is invalid.
+  `report.json` records the split. `--list` shows the held-out set. The compare note now says
+  "the same pass-rate difference".
+- The first held-out run (Haiku 5.5, 3 runs a task: 27/30) found a fault in one task:
+  the export-dates task (now `med-export-dates`) failed 0/3 only because the agent, with the right fix each time, added a CSV
+  test to the protected test file. Its hidden test decides, so the visible tests are no longer
+  protected, and a new test is in scope there and in the two conventions tasks. The hashes of these
+  three tasks change: compare held-out runs only with runs made after this change.
+- A harder held-out set (T11c, second version). The first set was at its ceiling for Haiku 5.5,
+  so it is now a dev suite, `-s medium` (ids `med-…`), and 10 new tasks took its place. Each has a
+  trap: a quick fix that passes the visible tests fails the hidden test or the mutation check (a
+  cache key without the currency, a new idempotency key per retry, invoice shares and yen, a
+  command registry with unchanged output, settings by the README's rules, 6 subtle mutants in two
+  test-writing tasks, a migration and a reset endpoint by `AGENTS.md`, and a slow search that must
+  keep every result). Their ids start with `held-out-`. The tests prove each trap. Compare
+  held-out runs only with runs made after this change. The run report's id column now fits the
+  longest id, so the columns after it line up.
+- The second held-out run (Haiku 5.5, 3 runs a task: 28/30) found two faults, both in the checks.
+  `held-out-conventions-migration` failed 2/3 with correct work: the agent named the field
+  `dueAt` (as `created_at` suggests), and the hidden test read `dueDate`, which the prompt never
+  named. The prompt now names it. The report gave "The check failed:" with nothing after it: a
+  guard stopped the check with no output. Each guard now prints what is missing, and a check with
+  no output reports its exit code. Four held-out hashes change.
+- Tests: `test/evals.test.ts` self-tests the basic and hard suites only (the medium tasks ran twice
+  there), with 60 s for each task. The user's `pnpm check` timed out on `hard-rounding` at 5 s,
+  then on the LSP reference sample. `vitest.config.ts` now gives every test 30 s, the limit that
+  the release checks used, so `pnpm check` agrees with them.
+- The third held-out run, with the Claude Code baseline, ran an old build: `dist/` was older than
+  the checkout, so the old tasks ran, and `report.json` named the checkout's commit, not the
+  build's. A build now records the commit it came from (tsup sets it), `report.json` gives it as
+  `garuda.commit` and adds `garuda.checkout` when the checkout differs, and `garuda eval` warns
+  at the start: "This build is from commit …, but the checkout is at …: run pnpm build first."
+- Held-out prompts with visible tests now say "You may add tests in new files, but do not change
+  the existing test files": in the same run the agent appended a correct test to a protected test
+  file after "do not change the existing ones". Five held-out hashes change.
+- Same run, same (old) tasks, Haiku 5.5: Garuda 26/30, Claude Code 27/30, no clear difference in
+  the pass rate; Claude Code cost ×1.50 per accepted change (paired interval ×1.35 to ×1.71).
+- Design (T11; T11a and T11b built, T11c–d not yet): eval evidence — intervals and consistency over repeated runs, cost per
+  accepted change, unexpected changes, a Claude Code baseline runner, a held-out task split, and a
+  proposer loop that edits only a prompt addendum (`docs/lld/eval-evidence.md`).
+
+- An eval A/B of one MCP server: `garuda eval --mcp <server>` allows that one server from your
+  own `~/.garuda/mcp.json` (no other server, and none from a project file), and
+  `--mcp-prepare <command>` runs a command in each scratch folder, in the sandbox, before the agent
+  starts; what it writes is not counted as the agent's change. For Graphify:
+  `--mcp graphify --mcp-prepare "graphify update ."`. Each run records its MCP tool calls; the
+  report and `eval compare` show them ("the agent never used the server" when none), compare notes
+  when the arms' servers differ, and `report.json` records the server and the command. A server
+  that does not start, or a failed prepare command, stops the eval at the first run. The Claude
+  Code baseline refuses both options.
+- The prepare command now runs before the agent's runtime starts, so a note that it writes into
+  `GARUDA.md` reaches the agent (the user's first Graphify run: the agent never called the server,
+  and a note written later would not have been read). A `~/.garuda/mcp.json` whose `"servers"` is a
+  list now gets a message that shows the right form, not "expected record, received array".
+- Docs: Graphify as an example MCP server in the tools guide (install, `mcp.json`, the note in
+  `GARUDA.md`, and what we measured: ×1.28 cost per accepted change on the hard suite, no change in
+  passes). Garuda does not include it. The T11d design gets the user's keep rule: an edit with the
+  same passes stays when its cost per accepted change is clearly lower.
+- Tests: `waitUntil` waits up to 20 s by default (it was 5 s), under the 30 s test limit. The
+  user's `pnpm check` failed the M5 Ctrl-C test on a busy machine. Two test files had their own
+  copy with 4 or 5 s (a second M5 Ctrl-C test then failed the same way); they use `waitUntil`
+  now, and a test refuses a new copy.
+
+- The proposer loop (T11d): `garuda eval tune --addendum <file>` improves a prompt addendum. A
+  proposer model (default `claude-opus-5-5`) reads the dev runs that failed, or each task's cost
+  when all passed, and writes a new version; it stays when no task goes from all runs to none and
+  it passes 2 more runs (`--margin`) or as many at a clearly lower cost per accepted change (the
+  user's rule). Texts that ask to skip or edit tests or checks, or to leave the sandbox, are
+  refused before a run; the proposer never sees the held-out tasks; `--max-cost` (default $20)
+  stops before a round that would pass it. At the end the held-out set compares no addendum with
+  the final one. Garuda never edits the file: the versions, inputs, reports and history go to
+  `.garuda/evals/tune-<id>/`. `garuda eval --addendum <file>` runs any suite with an addendum.
+- `eval tune` after the user's first run (Haiku 5.5 agent, Opus 5.5 proposer, $0.65): the kept
+  version cut the held-out cost per accepted change to ×0.81 (×0.75 to ×0.88), all runs passing.
+  The run also found four faults, now fixed: two of three proposals were refused for phrases in
+  rules against cheating ("never modify tests to make them pass") or about reading ("skip tests
+  you won't run"), so a negation now clears a phrase and a refused text gets one more try in the
+  round; the held-out comparison said the reports had no task hashes; runs went one at a time
+  (about 16 minutes a score), so `--parallel` (default 4) runs them together; and nothing printed
+  during a score, so each run prints a line. Two runs of one task at the same time can no longer
+  take the same session file name (also for `garuda eval --parallel`).
+
+- The system prompt tells the agent how to work in few steps: batch tool calls that do not depend
+  on each other, find before reading, no exploration with bash, all edits in one step, one narrow
+  test run, fix the code not the tests, stop when done. The rules come from the first
+  `garuda eval tune` run: on the held-out set, with every run passing, they cut the cost per
+  accepted change to ×0.81 (95% interval ×0.75 to ×0.88) with Haiku 5.5 and ×0.87 (×0.79 to
+  ×0.95) with Sonnet 5.5. The tuned text's rules against `remember` and for one-sentence answers
+  are left out: they served the evals, not users. The prompt's own wording, measured against
+  0.17.0's prompt on the held-out set (3 runs a task, seed 7): with Sonnet 5.5, 30/30 both and
+  ×0.90 (×0.84 to ×0.96); with Haiku 5.5, 30/30 and 29/30 (one miss of the invoice refund trap)
+  and ×0.88 (×0.79 to ×1.02), so the Haiku saving is likely but not shown with confidence.
+
 ## 0.17.0 (2026-10-27)
 
 - macOS: no command process outlives the command (IPI-04). Seatbelt has no process namespace, so a

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.17.0. Release notes: [CHANGELOG.md](CHANGELOG.md).
+0.18.1. Release notes: [CHANGELOG.md](CHANGELOG.md).
 
 ## What Garuda does on your machine
 
@@ -15,7 +15,8 @@ decisions. It works with Claude and with OpenAI-compatible models, local ones to
 - `write_file` and `edit_file` show a diff first. You allow once, allow for this session, or deny.
 - Commands (`bash`) run in an OS sandbox when your machine has one: Seatbelt on macOS, bubblewrap
   on Linux. There they run with no question, but they can write only in the project, temp folders
-  and package caches, cannot read secrets in your home folder (such as `~/.ssh`), and have no
+  and package caches, cannot read secrets in your home folder (such as `~/.ssh`) or your personal folders (Documents,
+  Downloads, Pictures and the like, outside the project), and have no
   network unless you open an allowlist. So a command can change project files without a question;
   `/undo` restores the files in its snapshot (ignored files, such as build output, are not in it).
 - A command outside the sandbox asks first, unless one of your allow rules covers it. The strict

package/SECURITY.md

@@ -6,7 +6,7 @@ Garuda runs commands and edits files for a model, so we take security reports se
 
 | Version | Supported |
 | --- | --- |
-| 0.17.x | Yes |
+| 0.18.x | Yes |
 | Older | No |
 
 ## Node and dependencies

package/dist/{acpCommand-7EY3NHPG.js → acpCommand-JAYNMIMP.js}

@@ -2,34 +2,37 @@
 import {
   Runtime,
   auditDirFor
-} from "./chunk-2DYMJMRQ.js";
+} from "./chunk-5UDYQ5MK.js";
 import "./chunk-G2AX7MGS.js";
-import "./chunk-A2QAIRQL.js";
-import {
-  FileSessionStore
-} from "./chunk-735BKABA.js";
+import "./chunk-ULAJPMY7.js";
+import "./chunk-JMH5W5DG.js";
 import {
   chooseModel,
   keepProviderKeys,
   loadModelsConfig,
   providerKeySource,
   resolveModel
-} from "./chunk-JRVWH27M.js";
-import "./chunk-U65DQZDB.js";
-import "./chunk-J4346IDH.js";
+} from "./chunk-QLBCM2YQ.js";
+import "./chunk-NH72AELP.js";
+import "./chunk-4QRTTRVK.js";
+import "./chunk-A2QAIRQL.js";
+import {
+  FileSessionStore
+} from "./chunk-NLS7GMF7.js";
+import "./chunk-7KBOIPUT.js";
 import {
   loadSearchConfig
 } from "./chunk-B25VL4RU.js";
-import "./chunk-23FXBNBB.js";
+import "./chunk-MNE7HHX2.js";
 import {
   VERSION
-} from "./chunk-BSK5T2ZG.js";
+} from "./chunk-IYGJWX65.js";
 import "./chunk-5DEWP3YX.js";
-import "./chunk-ZAE25JM2.js";
-import "./chunk-ATW7BNIG.js";
 import "./chunk-PZS3V6P3.js";
+import "./chunk-QANRZW7W.js";
+import "./chunk-ATW7BNIG.js";
 import "./chunk-AOGFYUKG.js";
-import "./chunk-B4SJY7KT.js";
+import "./chunk-LMKGSYJC.js";
 import "./chunk-BHZ6G65V.js";
 import "./chunk-P6XWWIEK.js";
 import "./chunk-UIRJOQQS.js";
@@ -47,12 +50,12 @@ async function acpCommand(options) {
 `);
       return 1;
     }
-    const { setupCommand, terminalIO } = await import("./setupCommand-GBQIVYJC.js");
+    const { setupCommand, terminalIO } = await import("./setupCommand-OSOMFHDQ.js");
     return setupCommand({}, { io: await terminalIO() });
   }
   const output = protocolOutput(process.stdout, process.stderr);
   const input = Readable.toWeb(process.stdin);
-  const { acpServer, setupNeeded } = await import("./server-VEYIJHEU.js");
+  const { acpServer, setupNeeded } = await import("./server-ASM73QVY.js");
   const server = acpServer({
     version: VERSION,
     // Not on native Windows: the setup there could not keep a key private (no 0600).
@@ -190,4 +193,4 @@ export {
   prepare,
   protocolOutput
 };
-//# sourceMappingURL=acpCommand-7EY3NHPG.js.map
+//# sourceMappingURL=acpCommand-JAYNMIMP.js.map

package/dist/advise-HDKJGNBL.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+import {
+  compareReports,
+  costPerPass,
+  formatComparison,
+  loadReport,
+  repoEvalTasks
+} from "./chunk-CWVXOSAA.js";
+import {
+  escapeHtml
+} from "./chunk-TLA2PDGM.js";
+import {
+  loadModelsConfig,
+  resolveModel
+} from "./chunk-QLBCM2YQ.js";
+import "./chunk-NH72AELP.js";
+import "./chunk-DQSCCE77.js";
+import "./chunk-4QRTTRVK.js";
+import "./chunk-A2QAIRQL.js";
+import "./chunk-2OYTNNUJ.js";
+import {
+  newSessionId
+} from "./chunk-NLS7GMF7.js";
+import "./chunk-7KBOIPUT.js";
+import "./chunk-ATW7BNIG.js";
+import "./chunk-WK5NE6RY.js";
+import "./chunk-AOGFYUKG.js";
+import "./chunk-QXTHEFKP.js";
+import "./chunk-LMKGSYJC.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, writeFileSync } from "fs";
+import { 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}`;
+  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");
+}
+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;
+  if (!Number.isInteger(repeat) || repeat < 1 || !(maxCost > 0)) {
+    process.stderr.write("--repeat must be a whole number of 1 or more, and --max-cost above 0.\n");
+    return 1;
+  }
+  const { repoSuite, runEvalCommand } = await import("./evalCommand-BLJJ4G76.js");
+  const suite = await repoSuite();
+  if (typeof suite === "string") {
+    process.stderr.write(`${suite}
+`);
+    return 1;
+  }
+  const tasks = repoEvalTasks(suite).length;
+  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 runs = tasks * repeat;
+  const estimates = prices.map((p) => estimateUsd(p, runs));
+  const total = estimates[0] === void 0 || estimates[1] === void 0 ? void 0 : estimates[0] + estimates[1];
+  process.stderr.write(
+    [
+      `Your repo: ${tasks} task${tasks === 1 ? "" : "s"} from its history (tests that fail before the commit and pass after it).`,
+      `Models: ${a}, ${b} \xB7 ${repeat} run${repeat === 1 ? "" : "s"} a task \xB7 ${2 * runs} runs, ${total === void 0 ? "cost unknown" : `about $${total.toFixed(2)} (a guess)`}.`,
+      `Cap: --max-cost $${maxCost}; it stops before a model that would pass it.`,
+      ""
+    ].join("\n")
+  );
+  if (total !== void 0 && total > maxCost) {
+    process.stderr.write(`The guess passes the cap: raise --max-cost, or lower --repeat.
+`);
+    return 1;
+  }
+  if (options.yes !== true) {
+    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(process.cwd(), ".garuda", "evals", `advise-${newSessionId()}`);
+  mkdirSync(dir, { recursive: true });
+  const run = (model, label) => runEvalCommand({ model, suite: "repo", repeat, shuffle: true, seed, outDir: join(dir, label) });
+  await run(a, "a");
+  const first = await loadReport(join(dir, "a"));
+  const spent = costPerPass(first.results);
+  const spentA = spent.kind === "unknown" ? void 0 : spent.totalUsd;
+  const ratio = prices[0] === void 0 || prices[1] === void 0 ? void 0 : prices[1].input / prices[0].input;
+  if (spentA !== void 0 && ratio !== void 0 && spentA * (1 + ratio) > maxCost) {
+    process.stderr.write(
+      `Stopped before ${b}: ${a} cost $${spentA.toFixed(2)}, so ${b} would take the total past $${maxCost}.
+`
+    );
+    return 1;
+  }
+  await run(b, "b");
+  const second = await loadReport(join(dir, "b"));
+  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_REPEAT,
+  GUESS_INPUT_TOKENS,
+  GUESS_OUTPUT_TOKENS,
+  adviceHtml,
+  adviceText,
+  estimateUsd,
+  runAdvise
+};
+//# sourceMappingURL=advise-HDKJGNBL.js.map

package/dist/brief-RWKESOPT.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import {
+  parseTestCount
+} from "./chunk-4QRTTRVK.js";
+import {
+  formatCost,
+  jobCost,
+  sumCosts
+} from "./chunk-3MRQJKUO.js";
+import "./chunk-AOGFYUKG.js";
+import {
+  JOBS_DIR,
+  listJobs
+} from "./chunk-VTMD5IHD.js";
+import "./chunk-UIRJOQQS.js";
+import "./chunk-4LFJFDCF.js";
+import "./chunk-3NJNVZTK.js";
+
+// src/jobs/brief.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+var BRIEF_FILE = "brief.seen";
+var FIRST_BRIEF_MS = 24 * 36e5;
+function testsText(job) {
+  const proof = job.result?.proof;
+  const after = proof?.after;
+  if (after === void 0) return "no tests";
+  const count = (tail) => tail === void 0 ? void 0 : parseTestCount(tail)?.total;
+  const before = count(proof?.before?.tail);
+  const now = count(after.tail);
+  const passed = after.exitCode === 0 && !after.timedOut;
+  if (before !== void 0 && now !== void 0 && passed) return `tests ${before} \u2192 ${now}`;
+  return passed ? "tests pass" : "tests fail after the change";
+}
+function jobLine(job, paint) {
+  const verdict = job.result?.proof?.verdict;
+  const ok = job.status === "done" && verdict === "ready";
+  const mark = ok ? paint("green", "\u2713") : paint("red", "\u2717");
+  const what = verdict === "ready" ? "ready to merge" : verdict === "needs-look" ? "needs a look" : job.status === "done" ? "done, no verdict" : job.status;
+  const title = job.title.length > 32 ? `${job.title.slice(0, 31)}\u2026` : job.title;
+  return `  ${mark} ${title.padEnd(32)}  ${what.padEnd(16)}  ${testsText(job).padEnd(26)}  ${paint("dim", job.branch)}`;
+}
+function briefText(jobs, paint) {
+  if (jobs.length === 0) return void 0;
+  const cost = sumCosts(jobs.flatMap((j) => j.result === void 0 ? [] : [jobCost(j.result)]));
+  return [
+    paint(
+      "bold",
+      `While you were away: ${jobs.length} job${jobs.length === 1 ? "" : "s"} ran (${formatCost(cost)})`
+    ),
+    ...jobs.map((j) => jobLine(j, paint)),
+    paint(
+      "dim",
+      "  /jobs <id> shows a job's report and review \xB7 git diff <base>...<branch> shows its change"
+    )
+  ].join("\n");
+}
+function endedSince(jobs, since) {
+  return jobs.filter((j) => j.endedAt !== void 0 && Date.parse(j.endedAt) > since).filter((j) => j.status === "done" || j.status === "stopped" || j.status === "failed").sort((a, b) => Date.parse(a.endedAt ?? "") - Date.parse(b.endedAt ?? ""));
+}
+async function morningBrief(root, paint, now = Date.now()) {
+  const dir = join(root, JOBS_DIR);
+  const file = join(dir, BRIEF_FILE);
+  let since = now - FIRST_BRIEF_MS;
+  try {
+    const data = JSON.parse(await readFile(file, "utf8"));
+    if (typeof data.seenAt === "string" && !Number.isNaN(Date.parse(data.seenAt))) {
+      since = Date.parse(data.seenAt);
+    }
+  } catch {
+  }
+  const jobs = endedSince(await listJobs(root), since);
+  if (jobs.length === 0) return void 0;
+  try {
+    await mkdir(dir, { recursive: true });
+    await writeFile(file, `${JSON.stringify({ seenAt: new Date(now).toISOString() })}
+`);
+  } catch {
+  }
+  return briefText(jobs, paint);
+}
+export {
+  BRIEF_FILE,
+  FIRST_BRIEF_MS,
+  briefText,
+  endedSince,
+  jobLine,
+  morningBrief,
+  testsText
+};
+//# sourceMappingURL=brief-RWKESOPT.js.map

package/dist/buildCheck-HB46NWLX.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import {
+  CHAT_STALE,
+  garudaCommit,
+  staleBuildNote
+} from "./chunk-YAQ6QLKB.js";
+import "./chunk-QXTHEFKP.js";
+import "./chunk-LMKGSYJC.js";
+import "./chunk-BHZ6G65V.js";
+import "./chunk-P6XWWIEK.js";
+import "./chunk-UIRJOQQS.js";
+import "./chunk-4LFJFDCF.js";
+import "./chunk-3NJNVZTK.js";
+export {
+  CHAT_STALE,
+  garudaCommit,
+  staleBuildNote
+};
+//# sourceMappingURL=buildCheck-HB46NWLX.js.map