pitroom 0.20.0 → 0.22.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "pitroom",
   "description": "A free pit crew for your expensive coding agent: the superpowers development workflow, run by cheap workers. Delegate research, fixes, tests, reviews and whole plans from Claude Code, Codex or any agent to OpenCode, Codex or Claude Code workers, with receipts that prove the savings.",
-  "version": "0.20.0",
+  "version": "0.22.0",
   "author": {
     "name": "TahaAtas"
   },

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "pitroom",
-  "version": "0.20.0",
+  "version": "0.22.0",
   "description": "A free pit crew for your expensive coding agent: delegate research, fixes, tests, reviews and parallel investigations to cheap worker agents running your own models, with verified answers, exact diffs and cost receipts.",
   "author": {
     "name": "TahaAtas"

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.22.0
+
+### Workers
+- **`--continue` works with Gemini.** It was refused ("cannot continue sessions") because Gemini CLI's `--resume` was known to take an index or `latest`, which is not safe with parallel workers. It takes the session id as well (checked live on 0.62: a follow-up remembered what the first run read), and the id is in the stream's first event, so Pitroom resumes by it like with the other workers: `pitroom run --continue last "…"`, or `continue` in `pitroom_run`.
+
+### Dashboard
+- **A crew is one card.** On the Live tab, runs that share a group (two or more: `pitroom run -g name`, a `pitroom_run` with `tasks`) now show as one card: the group name, the workers that are in it (`opencode ×3`), how many runs, how many are running, done or need attention, a progress bar, the tokens and the estimated saving of the crew, and when it started. It opens onto its runs, which are the usual cards; a crew that is still working is open by itself. A group of one run, and runs without a group, stay plain cards; the group picker still lists one crew's runs flat. A crew with a run among the newest is returned whole, so "Show older runs" never leaves it with fewer runs than it has.
+
+## 0.21.0
+
+### Windows
+- **A real git guard on Windows.** Until now the guard (a worker may not commit, reset, push, `git add`, `clean` and so on) was a `sh` script and Windows had none. Now the ref and push guard (git's own env config with a `reference-transaction` hook) is on there too, and the `git` shim runs on the `sh.exe` that Git for Windows brings (`git.cmd` for cmd.exe and PowerShell, `git` for Git Bash). A worker that starts git without a shell skips the shim and is left with the config layer. The guard tests, which were skipped on Windows, run there now; `pitroom doctor` reports the shim as ready or says what is missing.
+
+### Costs
+- **A price catalog that keeps itself up to date (opt-in).** `"priceFeed": true` (or `PITROOM_PRICE_FEED=1`): at most once a day, in a background process after a run (a run never waits for it), Pitroom fetches the public models.dev price list (the one OpenCode reads; USD per 1M tokens of about 8,000 models) and keeps a trimmed copy (about 400 KB) in its state directory; a failed or implausible answer keeps the old copy and is not retried for an hour. It is a fallback behind your own `workerPrices`, and the receipt says which was used (`estimated from models.dev prices`). `"primary"` can then be any model id of the catalog for the savings comparison, so it no longer goes stale (before: four fixed presets). New command `pitroom prices [--refresh] [--json]`, a doctor line, and settings `priceFeedUrl` and `priceFeedHours`. **Off by default**, because until now Pitroom's own code made no network request at all: PRIVACY.md says what the request carries (nothing about you; a plain GET) and what it shows (your IP address to models.dev).
+- **Prices for the CLIs that report no cost.** Codex and Gemini give tokens but no cost, so a run's `worker cost` was `n/a` and counted as free in the savings, which overstated them. The new config `"workerPrices": {"codex:gpt-6.1-sol": "1.25,10,0.125"}` (USD per 1M tokens, "in,out[,cachedIn]", keyed `backend:model` or `backend`) lets you say what they cost: the cost is then estimated from the tokens, shown as `~$0.016 (estimated from your workerPrices)` in the receipt and marked estimated in the dashboard, kept in the ledger and history, and taken off the savings. A cost the CLI reported always wins. `pitroom doctor` warns about a worker in your chain that reports no cost and has no price. Pitroom still knows no vendor prices and fetches none: the numbers are yours.
+
 ## 0.20.0
 
 ### Notifications

package/PRIVACY.md

@@ -6,7 +6,9 @@ Pitroom is a command-line tool and a set of agent skills that run on your own co
 
 ## What the Pitroom authors collect
 
-Nothing. Pitroom has no accounts, no analytics and no telemetry, and its own code makes no network requests. No data is sent to the authors.
+Nothing. Pitroom has no accounts, no analytics and no telemetry, and by default its own code makes no network requests. No data is sent to the authors.
+
+**One request you can turn on.** With `"priceFeed": true` in the config (or `PITROOM_PRICE_FEED=1`; off by default) Pitroom keeps a price list of AI models up to date: at most once a day, in a background process after a run, it sends a plain `GET` for one public file (`https://models.dev/api.json` unless you set `priceFeedUrl`) and keeps a trimmed copy in its state directory. The request carries no data about you, your code, your tasks or your runs, and no cookie or account; like any web request it shows your IP address to the server that answers it. Nothing is fetched while the feed is off, and `pitroom prices` shows what it holds.
 
 ## Data categories and purposes
 

package/README.md

@@ -276,7 +276,7 @@ To repeat it on your own repository: `pitroom crew -d <repo> -g bench "<question
 
 macOS and Linux are the main platforms. **Windows** runs the same test suite in CI (Windows Server, Node 22 and 24, with the fake workers; the worker CLIs themselves are not run there), with these differences:
 
-- **No git guard.** Pitroom's shim that blocks a worker's history changes and pushes is a `sh` script and is not available on Windows; `pitroom doctor` says so. Read-only runs are still limited by each worker CLI's own rules and `--isolate` keeps edits in a copy, so prefer `--isolate` and check the patch before `apply`.
+- **The git guard** is the same two layers as elsewhere, built on the `sh.exe` that Git for Windows ships: git's own config (a `reference-transaction` hook that refuses every ref update, and push URLs that go nowhere) is always on; the `git` shim (`git.cmd` for cmd.exe and PowerShell, `git` for Git Bash) adds friendly refusals and also blocks `add`, `restore`, `clean` and the rest. A worker that starts git without a shell (a plain `CreateProcess`) skips the shim, and is left with the config layer. `pitroom doctor` says which is in effect. It is verified in CI with Git for Windows, not yet with the worker CLIs on a real Windows machine.
 - **The launcher is `pitroom.cmd`** (`%USERPROFILE%\.local\bin`), started with the Node that ran `pitroom install` or the one in `PITROOM_NODE`; it does not search for another Node.
 - **Line endings.** Pitroom compares and applies patches byte for byte. Keep `core.autocrlf` off (or an `eol=lf` in `.gitattributes`, as this repository has); a checkout converted to CRLF has not been tested with `apply`.
 - A read snapshot's files are not made read-only (Windows has no POSIX modes), and a `--verify` command runs in `cmd.exe`, which reports a missing command as `is not recognized`.
@@ -662,7 +662,7 @@ pitroom run -m nvidia/z-ai/glm-5.3 "…"                   # another model on th
 | OpenCode (v2+) | ✅ | per-run permission rules | reported | private `--standalone` server per run |
 | Codex CLI | ✅ | OS sandbox (`read-only` / `workspace-write`) | tokens only | `codex login`; your `~/.codex/config.toml` is ignored for workers (its MCP servers run outside the sandbox); models take `#effort` |
 | Claude Code | ✅ | tool allowlist (`--restricted --safe-mode`, `dontAsk`) | reported | `claude auth login`; its default is often Opus, so prefer `-W claude:haiku` |
-| Gemini CLI | beta | `--approval-mode plan` plus Pitroom's policy rules | tokens only | an API key from Google AI Studio (sign in with `gemini` or set `GEMINI_API_KEY`; Google account sign-in is refused by Google); workers run in a private Gemini home without your hooks, MCP servers and skills; secret-file rules are not enforced by Gemini 0.62, but a read run with secret-looking files reads a [clean snapshot](#modes) without them; pin a model, e.g. `-W gemini:gemini-3.8-flash`; no `--continue` (see [the notes](docs/backends.md#gemini-cli-notes)) |
+| Gemini CLI | beta | `--approval-mode plan` plus Pitroom's policy rules | tokens only | an API key from Google AI Studio (sign in with `gemini` or set `GEMINI_API_KEY`; Google account sign-in is refused by Google); workers run in a private Gemini home without your hooks, MCP servers and skills; secret-file rules are not enforced by Gemini 0.62, but a read run with secret-looking files reads a [clean snapshot](#modes) without them; pin a model, e.g. `-W gemini:gemini-3.8-flash`; `--continue` works (by session id; see [the notes](docs/backends.md#gemini-cli-notes)) |
 
 ### Models, costs and effort
 
@@ -678,7 +678,7 @@ codex   gpt-6-sol    low/medium*/high/xhigh/max/ultra   1     1     24k
 claude  haiku        low/medium/high/xhigh/max          ?     -     -           -       -
 ```
 
-Pitroom cannot know vendor prices and does not fetch them, so a cost is what you enter: `"costs": {"codex:gpt-6-sol": 1, "codex:gpt-6.1-sol": 2}` in the config, in any unit (they are only compared). `pitroom doctor` then prints the cost of the models in use and says when you priced a cheaper one of the same worker. A target that names only an effort (`codex:#low`) uses the model from `models`; a Codex or Claude Code worker with no pinned model gets a warning, because it would run the vendor's own default, which can change and cost more. `--effort LEVEL` sets the level for one run; your agent picks model and level from `pitroom models` (cheapest that fits: `low` for lookups, `medium` for ordinary changes, `high` for reviews).
+Pitroom knows no vendor prices of its own and, unless you turn on `priceFeed` (see the config notes), fetches none, so a cost is what you enter: `"costs": {"codex:gpt-6-sol": 1, "codex:gpt-6.1-sol": 2}` in the config, in any unit (they are only compared; dollar prices for the receipts of Codex and Gemini go in `workerPrices`, see the config notes). `pitroom doctor` then prints the cost of the models in use and says when you priced a cheaper one of the same worker. A target that names only an effort (`codex:#low`) uses the model from `models`; a Codex or Claude Code worker with no pinned model gets a warning, because it would run the vendor's own default, which can change and cost more. `--effort LEVEL` sets the level for one run; your agent picks model and level from `pitroom models` (cheapest that fits: `low` for lookups, `medium` for ordinary changes, `high` for reviews).
 
 Fallbacks cross backends (e.g. `"fallback": ["codex:#low", "opencode"]`): a worker that is rate-limited, logged out or missing its model hands the task to the next. Follow-ups (`--continue`) always stay on the worker that owns the session. Writing an adapter: [docs/backends.md](docs/backends.md). A model that says "rate limited" (a daily quota used up, an overloaded provider) is remembered for the time its message gives, or a guess: the next runs skip it while a fallback is left, so they do not each wait for it to fail. `pitroom cooldown` lists what is skipped and until when, `--clear` tries it again, and `doctor` shows it too.
 
@@ -730,6 +730,8 @@ Or put defaults in `~/.config/pitroom/config.json` (flags and env still win); `p
 - `tiers`: `cheap`, `standard` and `capable` name the workers for plan tasks and `--tier`; an optional `review` tier names who reviews a run (by default another worker than the implementer's, `standard` first).
 - `audit`: the chance (0 to 1, default 0 = off) that a finished read run is re-checked in the background, see [Audits](#audits). The `audit` tier (else `cheap`) names who does it.
 - `costs`: your relative cost per `worker:model`, only compared with each other; `maxParallel`: workers at once (default 20, at most 30).
+- `workerPrices`: USD per 1M tokens of a worker model, for the CLIs that report no cost (Codex, Gemini): `"workerPrices": {"codex:gpt-6.1-sol": "1.25,10,0.125"}` is "in,out[,cachedIn]", keyed `backend:model` (the model that ran, else the one you asked for) or `backend` alone. Without one the receipt says `worker cost n/a` and the run counts as free in the savings, which overstates them (`pitroom doctor` warns); with one the cost is estimated from the tokens, shown as `~$0.016 (estimated from your workerPrices)`, kept in the ledger, history and dashboard, and taken off the savings. Pitroom knows no vendor prices and does not fetch them, so this is your number.
+- `priceFeed`: keep a price catalog up to date (default `false`; `PITROOM_PRICE_FEED=1`). The catalog is the public [models.dev](https://models.dev) list OpenCode also reads (USD per 1M tokens of about 8,000 models): at most once a day (`priceFeedHours`, default 24), in a background process after a run, never while a run waits, Pitroom sends a plain `GET` for that one file (`priceFeedUrl` / `PITROOM_PRICE_FEED_URL` to use a mirror, `priceFeedHours` / `PITROOM_PRICE_FEED_HOURS` for the interval) and keeps a trimmed copy (about 400 KB) in its state directory; a failed refresh keeps the old copy and is not retried for an hour. It is only a fallback: your `workerPrices` come first, and the receipt says which was used (`estimated from models.dev prices`). With it, `"primary": "<model id>"` can name any model of the catalog for the savings comparison (`"primary": "claude-opus-5-5"`), where without it only the four presets exist. `pitroom prices` shows the feed, the catalog and the price each worker in use gets; `pitroom prices --refresh` fetches now. What it sends: [PRIVACY.md](PRIVACY.md). The listed prices are API list prices: a worker on a subscription (Codex with a ChatGPT account) does not pay them, so for such a worker the estimate is what the same tokens would cost on the API.
 - `notify`: a desktop notification when a run that went to the background (`--bg`, a crew, an MCP call) has ended, so a long job does not have to be watched (default `false`; `PITROOM_NOTIFY=1`). Runs that went well but took less than `notifyAfter` seconds (default 15; `PITROOM_NOTIFY_AFTER`) and audits are not announced (a failure always is), and a crew says so once, when its last run ends, judged as a whole. A worker process that is killed outright never gets to say so. The built-in notifier uses `osascript` on macOS and `notify-send` on Linux (none for Windows yet); `notifyCommand` runs a command of your own instead, in a shell, with the text in `PITROOM_NOTIFY_TITLE` and `PITROOM_NOTIFY_BODY` (and `PITROOM_NOTIFY_RUN`, `PITROOM_NOTIFY_STATE`): for example `"notifyCommand": "curl -s -d \"$PITROOM_NOTIFY_BODY\" ntfy.sh/my-topic"`.
 - `mcpDash`: whether a run that an MCP client starts, and that is still going after a few seconds, also starts the dashboard and returns its address (default `true`; `PITROOM_MCP_DASH=0` or `"mcpDash": false` turns it off), see [the MCP server](#1-install-pick-your-agent).
 - `countRateLimits`: whether runs that failed on a rate limit or quota count in `pitroom history stats` and the dashboard's Stats (default `false`: they are left out of the run counts, success rates, times and tokens and shown apart as rate-limited, since they say nothing about the worker's work; `true` counts them as not ok).

package/dist/lib.mjs

@@ -380,10 +380,10 @@ function parseEvents2(jsonl) {
       }
       case "turn.completed": {
         const u = e.usage ?? {};
-        const cached2 = num2(u.cached_input_tokens);
+        const cached3 = num2(u.cached_input_tokens);
         const reasoning = num2(u.reasoning_output_tokens);
-        usage.input += Math.max(0, num2(u.input_tokens) - cached2);
-        usage.cacheRead += cached2;
+        usage.input += Math.max(0, num2(u.input_tokens) - cached3);
+        usage.cacheRead += cached3;
         usage.cacheWrite += num2(u.cache_write_input_tokens);
         usage.output += Math.max(0, num2(u.output_tokens) - reasoning);
         usage.reasoning += reasoning;
@@ -752,9 +752,9 @@ function parseEvents3(jsonl) {
       if (e.severity === "error") error ??= String(e.message ?? "Gemini CLI error");
     } else if (e.type === "result") {
       const s = e.stats ?? {};
-      const cached2 = num3(s.cached);
-      usage.cacheRead += cached2;
-      usage.input += s.input !== void 0 ? num3(s.input) : Math.max(0, num3(s.input_tokens) - cached2);
+      const cached3 = num3(s.cached);
+      usage.cacheRead += cached3;
+      usage.input += s.input !== void 0 ? num3(s.input) : Math.max(0, num3(s.input_tokens) - cached3);
       usage.output += num3(s.output_tokens);
       usage.total += num3(s.total_tokens) || num3(s.input_tokens) + num3(s.output_tokens);
       usage.toolCalls = Math.max(usage.toolCalls, num3(s.tool_calls));
@@ -827,6 +827,7 @@ function invocation3(req) {
     "none"
   ];
   for (const p of policies) args.push("--policy", path5.join(dir, p));
+  if (req.sessionId) args.push("--resume", req.sessionId);
   if (process.env.PITROOM_GEMINI_TRUST === "1") args.push("--skip-trust");
   const [model] = (req.model ?? "").split("#");
   if (model) args.push("--model", model);
@@ -913,7 +914,7 @@ function catalog3() {
 var gemini = {
   id: "gemini",
   name: "Gemini CLI",
-  capabilities: { readOnly: "approval-mode", resume: "none", reportsCost: false, attachFiles: false },
+  capabilities: { readOnly: "approval-mode", resume: "by-id", reportsCost: false, attachFiles: false },
   binary: binary3,
   catalog: catalog3,
   invocation: invocation3,
@@ -1725,7 +1726,9 @@ var planName = (file) => path10.basename(file).replace(/\.md$/i, "");
 // src/vcs/guard.ts
 import fs11 from "node:fs";
 import path11 from "node:path";
-var VERSION = 1;
+var VERSION = 2;
+var WINDOWS = process.platform === "win32";
+var fwd = (p) => WINDOWS ? p.replace(/\\/g, "/") : p;
 var SHIM = `#!/bin/sh
 # pitroom git guard v${VERSION}. Blocks git commands that change history, refs, the
 # index or discard work. The primary agent reviews and commits, not the worker.
@@ -1802,9 +1805,10 @@ function shimDir() {
   return path11.join(home(), "shim", `v${VERSION}`);
 }
 function findRealGit(skip) {
+  const same = (a, b) => WINDOWS ? a.toLowerCase() === b.toLowerCase() : a === b;
   for (const dir of (process.env.PATH ?? "").split(path11.delimiter).filter(Boolean)) {
-    if (path11.resolve(dir) === skip) continue;
-    const p = path11.join(dir, "git");
+    if (same(path11.resolve(dir), skip)) continue;
+    const p = path11.join(dir, WINDOWS ? "git.exe" : "git");
     try {
       fs11.accessSync(p, fs11.constants.X_OK);
       if (fs11.statSync(p).isFile()) return p;
@@ -1813,6 +1817,24 @@ function findRealGit(skip) {
   }
   return void 0;
 }
+function findGitSh(realGit) {
+  let dir = path11.dirname(realGit);
+  for (let i = 0; i < 4; i++) {
+    for (const rel of ["bin/sh.exe", "usr/bin/sh.exe"]) {
+      const p = path11.join(dir, rel);
+      if (fs11.existsSync(p)) return p;
+    }
+    const up = path11.dirname(dir);
+    if (up === dir) break;
+    dir = up;
+  }
+  return void 0;
+}
+var cmdShim = (sh) => `@echo off\r
+set "MSYS2_ARG_CONV_EXCL=*"\r
+"${sh}" "%~dp0git" %*\r
+exit /b %errorlevel%\r
+`;
 var HOOK_VERSION = 1;
 var REF_HOOK = `#!/bin/sh
 # pitroom git guard (layer 2, v${HOOK_VERSION}): refuse ref updates made by workers.
@@ -1826,7 +1848,17 @@ function writeIfChanged(file, content) {
   fs11.mkdirSync(path11.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.tmp`;
   fs11.writeFileSync(tmp, content, { mode: 493 });
-  fs11.renameSync(tmp, file);
+  renameOver(tmp, file);
+}
+function pathKey(env) {
+  const keys = Object.keys(env).filter((k) => k.toLowerCase() === "path");
+  return keys.includes("PATH") ? "PATH" : keys[0] ?? "PATH";
+}
+function onePath(env) {
+  const key = pathKey(env);
+  const out = { ...env };
+  for (const k of Object.keys(out)) if (k !== key && k.toLowerCase() === "path") delete out[k];
+  return out;
 }
 function withGitConfig(env, entries) {
   const out = { ...env };
@@ -1847,17 +1879,27 @@ function guardEnv(env) {
     GIT_PAGER: "cat",
     PAGER: "cat"
   };
-  if (process.platform === "win32") return { ...env, ...quiet };
   writeIfChanged(path11.join(hooksDir(), "reference-transaction"), REF_HOOK);
-  env = withGitConfig(env, [
-    ["core.hooksPath", hooksDir()],
+  env = withGitConfig(onePath(env), [
+    ["core.hooksPath", fwd(hooksDir())],
     ["url.pitroom-push-blocked://.pushInsteadOf", ""]
   ]);
   const dir = shimDir();
   const real = findRealGit(dir);
   if (!real) return { ...env, ...quiet };
+  let sh;
+  if (WINDOWS) {
+    sh = findGitSh(real);
+    if (!sh) return { ...env, ...quiet };
+    writeIfChanged(path11.join(dir, "git.cmd"), cmdShim(sh));
+  }
   writeIfChanged(path11.join(dir, "git"), SHIM);
-  return { ...env, ...quiet, PITROOM_REAL_GIT: real, PATH: `${dir}${path11.delimiter}${env.PATH ?? ""}` };
+  const key = pathKey(env);
+  return { ...env, ...quiet, PITROOM_REAL_GIT: fwd(real), [key]: `${dir}${path11.delimiter}${env[key] ?? ""}` };
+}
+function shimReady() {
+  const env = guardEnv({ ...process.env });
+  return Boolean(env[pathKey(env)]?.startsWith(shimDir()));
 }
 
 // src/core/slots.ts
@@ -1994,7 +2036,7 @@ function secretWarning(files, mode) {
 var slash = (p) => p.split(path13.sep).join("/");
 
 // src/core/receipt.ts
-import fs15 from "node:fs";
+import fs16 from "node:fs";
 
 // src/core/config.ts
 import fs14 from "node:fs";
@@ -2019,7 +2061,11 @@ var SCHEMA = {
   mcpDash: "boolean",
   notify: "boolean",
   notifyCommand: "string",
-  notifyAfter: "number"
+  notifyAfter: "number",
+  workerPrices: "record",
+  priceFeed: "boolean",
+  priceFeedUrl: "string",
+  priceFeedHours: "number"
 };
 function configPath() {
   if (process.env.PITROOM_CONFIG) return path14.resolve(process.env.PITROOM_CONFIG);
@@ -2117,10 +2163,64 @@ function effective(flags = {}) {
     mcpDash: setting(void 0, flag01(e.PITROOM_MCP_DASH), c.mcpDash, true),
     notify: setting(void 0, flag01(e.PITROOM_NOTIFY), c.notify, false),
     notifyCommand: setting(void 0, e.PITROOM_NOTIFY_COMMAND?.trim() || void 0, c.notifyCommand?.trim() || void 0, void 0),
-    notifyAfter: setting(void 0, days(e.PITROOM_NOTIFY_AFTER), days(c.notifyAfter), 15)
+    notifyAfter: setting(void 0, days(e.PITROOM_NOTIFY_AFTER), days(c.notifyAfter), 15),
+    workerPrices: setting(void 0, void 0, c.workerPrices, {}),
+    priceFeed: setting(void 0, flag01(e.PITROOM_PRICE_FEED), c.priceFeed, false),
+    priceFeedUrl: setting(void 0, e.PITROOM_PRICE_FEED_URL?.trim() || void 0, c.priceFeedUrl?.trim() || void 0, "https://models.dev/api.json"),
+    priceFeedHours: setting(void 0, positiveInt(e.PITROOM_PRICE_FEED_HOURS), positiveInt(c.priceFeedHours), 24)
   };
 }
 
+// src/core/prices.ts
+import fs15 from "node:fs";
+import path15 from "node:path";
+var RETRY_AFTER_FAILURE_MS = 60 * 6e4;
+var catalogFile = () => path15.join(home(), "prices.json");
+function trim(raw) {
+  const out = {};
+  if (!raw || typeof raw !== "object") return out;
+  for (const [provider, p] of Object.entries(raw)) {
+    for (const [id, m] of Object.entries(p?.models ?? {})) {
+      const c = m?.cost;
+      const ok = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0;
+      if (!c || !ok(c.input) || !ok(c.output)) continue;
+      out[`${provider}/${id}`] = [c.input, c.output, ok(c.cache_read) ? c.cache_read : c.input / 10];
+    }
+  }
+  return out;
+}
+var cached2;
+function readCatalog() {
+  const file = catalogFile();
+  try {
+    const { mtimeMs } = fs15.statSync(file);
+    if (cached2?.file === file && cached2.mtimeMs === mtimeMs) return cached2.catalog;
+    const parsed = JSON.parse(fs15.readFileSync(file, "utf8"));
+    const catalog5 = parsed && typeof parsed.models === "object" && parsed.models && Number.isFinite(Date.parse(parsed.fetchedAt)) ? parsed : void 0;
+    cached2 = { file, mtimeMs, catalog: catalog5 };
+    return catalog5;
+  } catch {
+    return void 0;
+  }
+}
+var OWN = { codex: ["openai"], claude: ["anthropic"], gemini: ["google"] };
+function catalogPrice(backend, ...models) {
+  const catalog5 = readCatalog();
+  if (!catalog5) return void 0;
+  for (const raw of models) {
+    const id = raw?.split("#")[0];
+    if (!id) continue;
+    const keys = [id, ...[...OWN[backend] ?? [], "anthropic", "openai", "google"].map((p) => `${p}/${id}`)];
+    const any = keys.find((k) => catalog5.models[k]) ?? Object.keys(catalog5.models).filter((k) => k.endsWith(`/${id}`)).sort()[0];
+    const triple = any ? catalog5.models[any] : void 0;
+    if (any && triple && triple.length === 3 && triple.every((n) => Number.isFinite(n) && n >= 0)) {
+      const [input, output, cachedInput] = triple;
+      return { input, output, cachedInput, key: any };
+    }
+  }
+  return void 0;
+}
+
 // src/core/receipt.ts
 var PRESETS = {
   sonnet: { name: "Claude Sonnet", input: 3, output: 15, cachedInput: 0.3 },
@@ -2134,17 +2234,27 @@ function primaryPrice() {
   if (custom && custom.length >= 2 && custom.every((n) => Number.isFinite(n) && n >= 0)) {
     return { name: "custom", input: custom[0], output: custom[1], cachedInput: custom[2] ?? custom[0] / 10 };
   }
-  return PRESETS[eff.primary.value.toLowerCase()] ?? PRESETS.sonnet;
+  const named = eff.primary.value;
+  const preset = PRESETS[named.toLowerCase()];
+  if (preset) return preset;
+  const c = eff.priceFeed.value ? catalogPrice("", named) : void 0;
+  return c ? { name: named, source: "catalog", input: c.input, output: c.output, cachedInput: c.cachedInput } : PRESETS.sonnet;
 }
 var estimateTokens = (text) => Math.ceil(text.length / 4);
+function parsePriceSpec(spec, name = "worker") {
+  const parts = typeof spec === "string" ? spec.split(",").map((x) => Number(x.trim())) : [];
+  if (parts.length < 2 || parts.length > 3 || !parts.every((n) => Number.isFinite(n) && n >= 0)) return void 0;
+  return { name, source: "config", input: parts[0], output: parts[1], cachedInput: parts[2] ?? parts[0] / 10 };
+}
+var costAt = (usage, price) => (usage.input * price.input + usage.cacheRead * price.cachedInput + (usage.output + usage.reasoning) * price.output) / 1e6;
+var workerCostOf = (usage) => usage?.cost ?? usage?.costEstimate;
 function savedUsd(usage, returnedTokens, price = primaryPrice()) {
-  const wouldCost = (usage.input * price.input + usage.cacheRead * price.cachedInput + (usage.output + usage.reasoning) * price.output) / 1e6;
   const readingTheReport = returnedTokens * price.input / 1e6;
-  return Math.max(0, wouldCost - (usage.cost ?? 0) - readingTheReport);
+  return Math.max(0, costAt(usage, price) - (workerCostOf(usage) ?? 0) - readingTheReport);
 }
 function readLedger(sinceMs) {
-  if (!fs15.existsSync(ledgerFile())) return [];
-  return fs15.readFileSync(ledgerFile(), "utf8").split("\n").filter(Boolean).flatMap((l) => {
+  if (!fs16.existsSync(ledgerFile())) return [];
+  return fs16.readFileSync(ledgerFile(), "utf8").split("\n").filter(Boolean).flatMap((l) => {
     try {
       return [JSON.parse(l)];
     } catch {
@@ -2220,10 +2330,10 @@ ${tile(0, compact(t.tokens), "Tokens offloaded")}${tile(1, t.ratio ? `${Math.rou
 
 // src/core/process.ts
 import { spawn } from "node:child_process";
-import fs16 from "node:fs";
+import fs17 from "node:fs";
 async function spawnWorker(inv, opts) {
-  const out = fs16.openSync(opts.stdoutFile, "w");
-  const err = fs16.openSync(opts.stderrFile, "w");
+  const out = fs17.openSync(opts.stdoutFile, "w");
+  const err = fs17.openSync(opts.stderrFile, "w");
   const res = { code: null, timedOut: false, stopped: false };
   const child = spawn(inv.command, inv.args, {
     cwd: opts.cwd,
@@ -2246,7 +2356,7 @@ async function spawnWorker(inv, opts) {
   }, opts.timeoutSec * 1e3);
   res.code = await new Promise((resolve2) => {
     child.on("error", (e) => {
-      res.spawnError = e.code === "ENOENT" ? fs16.existsSync(opts.cwd) ? `${inv.command} not found` : `the working directory ${opts.cwd} does not exist` : e.message;
+      res.spawnError = e.code === "ENOENT" ? fs17.existsSync(opts.cwd) ? `${inv.command} not found` : `the working directory ${opts.cwd} does not exist` : e.message;
       resolve2(127);
     });
     child.on("close", (c) => resolve2(c));
@@ -2255,8 +2365,8 @@ async function spawnWorker(inv, opts) {
   if (killer) clearTimeout(killer);
   process.off("SIGINT", stop);
   process.off("SIGTERM", stop);
-  fs16.closeSync(out);
-  fs16.closeSync(err);
+  fs17.closeSync(out);
+  fs17.closeSync(err);
   return res;
 }
 export {
@@ -2269,8 +2379,10 @@ export {
   badgeUrl,
   brief,
   card,
+  catalogPrice,
   compact,
   cooldownMs,
+  costAt,
   describeTarget,
   estimateTokens,
   extractRefs,
@@ -2291,12 +2403,14 @@ export {
   newRunId,
   parseAudit,
   parsePlan,
+  parsePriceSpec,
   parseStatus,
   parseTarget,
   parseVerdict,
   planName,
   planTask,
   primaryPrice,
+  readCatalog,
   readLedger,
   readMeta,
   releaseSlot,
@@ -2310,11 +2424,14 @@ export {
   savedUsd,
   secretWarning,
   shimDir,
+  shimReady,
   slotHolders,
   spawnWorker,
   totals,
+  trim,
   tryAcquireSlot,
   usd,
   verifyRefs,
+  workerCostOf,
   writeMeta
 };