pitroom 0.22.0 → 0.23.0

package/dist/pitroom.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import fs38 from "node:fs";
+import fs41 from "node:fs";
 
 // src/core/errors.ts
 var UserError = class extends Error {
@@ -220,7 +220,10 @@ var DENY_BASH = [
   "opencode",
   "claude",
   "codex",
-  "gemini"
+  "gemini",
+  "qwen",
+  "kilo",
+  "kilocode"
 ].map((c) => `Bash(${c}:*)`);
 var SECRETS = ["**/.env", "**/.env.*", "**/*.pem", "**/id_rsa*", "**/id_ed25519*"].map((p) => `Read(${p})`);
 function toolsFor(mode, web2) {
@@ -940,6 +943,10 @@ var gemini = {
   doctor: doctor3
 };
 
+// src/backends/kilo/index.ts
+import { spawnSync as spawnSync5 } from "node:child_process";
+import path7 from "node:path";
+
 // src/backends/opencode/index.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
 
@@ -1149,17 +1156,19 @@ var FORBIDDEN_BASH = [
   "twine upload*",
   // no recursive delegation
   "opencode*",
+  "kilo *",
+  "kilocode*",
   "pitroom *",
   "*pitroom*"
 ];
-function scratchDirs() {
+function scratchDirs(app) {
   const data = process.env.XDG_DATA_HOME ?? path6.join(os6.homedir(), ".local", "share");
   const rules = {
     "*": "deny",
-    [path6.join(data, "opencode", "tool-output", "*")]: "allow",
-    [path6.join(data, "opencode", "shell", "*", "*")]: "allow"
+    [path6.join(data, app, "tool-output", "*")]: "allow",
+    [path6.join(data, app, "shell", "*", "*")]: "allow"
   };
-  for (const tmp of /* @__PURE__ */ new Set([os6.tmpdir(), realpath(os6.tmpdir())])) rules[path6.join(tmp, "opencode", "*")] = "allow";
+  for (const tmp of /* @__PURE__ */ new Set([os6.tmpdir(), realpath(os6.tmpdir())])) rules[path6.join(tmp, app, "*")] = "allow";
   return rules;
 }
 function realpath(p) {
@@ -1180,7 +1189,7 @@ var COMMON = {
   doom_loop: "deny"
 };
 var web = (on) => ({ webfetch: on ? "allow" : "deny", websearch: on ? "allow" : "deny" });
-function readProfile(allowWeb = false) {
+function readProfile(allowWeb = false, app = "opencode") {
   return {
     "*": "deny",
     read: READ_FILES,
@@ -1196,11 +1205,11 @@ function readProfile(allowWeb = false) {
     bash: READ_ONLY_BASH,
     shell: READ_ONLY_BASH,
     edit: "deny",
-    external_directory: scratchDirs(),
+    external_directory: scratchDirs(app),
     ...COMMON
   };
 }
-function writeProfile(allowWeb = false) {
+function writeProfile(allowWeb = false, app = "opencode") {
   const bash = { "*": "allow" };
   for (const pattern of FORBIDDEN_BASH) bash[pattern] = "deny";
   return {
@@ -1209,25 +1218,26 @@ function writeProfile(allowWeb = false) {
     ...web(allowWeb),
     bash,
     shell: bash,
-    external_directory: scratchDirs(),
+    external_directory: scratchDirs(app),
     ...COMMON
   };
 }
 function agentFor(mode) {
   return mode === "read" ? AGENT.read : AGENT.write;
 }
-function configContent(existing, allowWeb = false) {
+function configContent(existing, allowWeb = false, app = "opencode", extra = {}) {
   const ours = {
+    ...extra,
     agent: {
       [AGENT.read]: {
         mode: "primary",
         description: "pitroom: read-only worker (research, search, review)",
-        permission: readProfile(allowWeb)
+        permission: readProfile(allowWeb, app)
       },
       [AGENT.write]: {
         mode: "primary",
         description: "pitroom: editing worker (no git history changes, no bulk deletes)",
-        permission: writeProfile(allowWeb)
+        permission: writeProfile(allowWeb, app)
       }
     }
   };
@@ -1404,10 +1414,348 @@ var opencode = {
   doctor: doctor4
 };
 
+// src/backends/kilo/index.ts
+var binary5 = () => findBinary("kilo", "PITROOM_KILO_BIN", ["~/.kilo/bin/kilo"]);
+function kilo(args, timeout = 6e4) {
+  const { command, prefix } = resolveCommand(binary5());
+  const r = spawnSync5(command, [...prefix, ...args], { encoding: "utf8", timeout, stdio: ["ignore", "pipe", "pipe"], maxBuffer: 64 * 1024 * 1024 });
+  return { ok: r.status === 0, out: r.stdout ?? "", err: r.stderr ?? "", missing: !!r.error };
+}
+function invocation5(req) {
+  const args = [
+    "run",
+    "--agent",
+    agentFor(req.mode),
+    "--format",
+    "json",
+    "--title",
+    req.title,
+    // Some failure causes only appear in the server logs (Kilo takes the level in capitals only).
+    "--print-logs",
+    "--log-level",
+    "ERROR"
+  ];
+  if (req.model) args.push("--model", req.model);
+  if (req.sessionId) args.push("--session", req.sessionId);
+  for (const f of req.files) args.push("--file", f);
+  args.push(req.prompt);
+  const { command, prefix } = resolveCommand(binary5());
+  return {
+    command,
+    args: [...prefix, ...args],
+    env: {
+      // A worker run must not upgrade Kilo underneath the user.
+      KILO_CONFIG_CONTENT: configContent(process.env.KILO_CONFIG_CONTENT, req.web, "kilo", { autoupdate: false }),
+      // No daemon to attach to: a private server per run (see above).
+      XDG_STATE_HOME: path7.join(home(), "kilo-state")
+    }
+  };
+}
+function failure5(run2, stderr, exitCode) {
+  if (exitCode === 0 && !run2.error) return void 0;
+  const detail = stderr.match(/error="([^"]+)"/g)?.pop()?.slice(7, -1);
+  const raw = run2.error ?? `kilo exited with code ${exitCode}`;
+  const message = detail && !raw.includes(detail) ? `${raw}: ${detail}` : raw;
+  return { kind: classify4(message), message };
+}
+function listModels2() {
+  return kilo(["models"]).out.split("\n").map((s) => s.trim()).filter((s) => /^[\w.-]+\/\S+$/.test(s));
+}
+function defaultModel4() {
+  try {
+    const out = kilo(["debug", "config"], 3e4).out;
+    const model = JSON.parse(out.slice(out.indexOf("{"))).model;
+    return typeof model === "string" ? model : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function catalog5() {
+  return { models: listModels2().map((id) => ({ id })), source: "`kilo models` (reasoning variants are provider-specific: provider/model#variant)" };
+}
+function doctor5({ models, hasFallback }) {
+  const version = kilo(["--version"]);
+  if (version.missing || !version.ok) {
+    return [{ level: "fail", message: `kilo not runnable (${binary5()}). Install Kilo Code's CLI (npm i -g @kilocode/cli), or set PITROOM_KILO_BIN` }];
+  }
+  const checks = [{ level: "ok", message: `Kilo Code ${version.out.trim().split("\n").pop()} at ${binary5()} (beta worker: checked against 7.8)` }];
+  const def = defaultModel4();
+  for (const m of models) {
+    const model = m ?? def;
+    checks.push(model ? { level: "ok", message: `Kilo Code ${m ? "model" : "default model"}: ${model}` } : { level: "warn", message: 'Kilo Code has no default model: pass -W kilo:<provider/model> or set "model" in its config' });
+  }
+  if (!hasFallback) checks.push({ level: "warn", message: "no fallback workers configured for Kilo Code runs" });
+  checks.push({ level: "ok", message: `permission profiles ${AGENT.read}/${AGENT.write} injected per run through KILO_CONFIG_CONTENT` });
+  return checks;
+}
+var kiloBackend = {
+  id: "kilo",
+  name: "Kilo Code",
+  capabilities: { readOnly: "permission-rules", resume: "by-id", reportsCost: true, attachFiles: true },
+  binary: binary5,
+  invocation: invocation5,
+  parse: parseEvents4,
+  failure: failure5,
+  defaultModel: defaultModel4,
+  listModels: listModels2,
+  catalog: catalog5,
+  doctor: doctor5
+};
+
+// src/backends/qwen/index.ts
+import { spawnSync as spawnSync6 } from "node:child_process";
+import fs8 from "node:fs";
+import os7 from "node:os";
+import path8 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// src/backends/qwen/events.ts
+var EDIT_TOOLS4 = /* @__PURE__ */ new Set(["write_file", "edit", "notebook_edit"]);
+var SHELL = "run_shell_command";
+var DENIED4 = /permission was declined|denied by permission rules|requires permission|not allowed/i;
+var API_ERROR = /^\[API Error: /;
+function parseEvents5(jsonl) {
+  const usage2 = { input: 0, output: 0, reasoning: 0, cacheRead: 0, cacheWrite: 0, total: 0, steps: 0, toolCalls: 0, denied: 0 };
+  const tools = {};
+  const edits = [];
+  const pendingEdits = /* @__PURE__ */ new Map();
+  const timeline = [];
+  const stepOf = /* @__PURE__ */ new Map();
+  let sessionId;
+  let model;
+  let lastText = "";
+  let finalText;
+  let lastActivity;
+  let error;
+  for (const line of jsonl.split("\n")) {
+    if (!line.trim()) continue;
+    let e;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    sessionId ??= e.session_id;
+    if (e.type === "system" && e.subtype === "init") {
+      model = e.model;
+    } else if (e.type === "system" && e.subtype === "retry") {
+      lastActivity = `waiting to retry (attempt ${e.data?.attempt ?? "?"} of ${e.data?.maxRetries ?? "?"})`;
+    } else if (e.type === "assistant") {
+      const content = e.message?.content ?? [];
+      const text = content.filter((c) => c.type === "text").map((c) => String(c.text ?? "")).join(" ").trim();
+      if (API_ERROR.test(text)) {
+        error = apiError(text);
+        continue;
+      }
+      usage2.steps++;
+      for (const c of content) {
+        if (c.type === "text" && String(c.text ?? "").trim()) {
+          lastText = String(c.text).trim();
+          lastActivity = `says: ${oneLine5(lastText)}`;
+          if (timeline.length < MAX_STEPS) timeline.push({ kind: "say", text: clip5(lastText, 600) });
+        } else if (c.type === "tool_use") {
+          usage2.toolCalls++;
+          tools[c.name] = (tools[c.name] ?? 0) + 1;
+          const target = c.input?.file_path ?? c.input?.path ?? c.input?.pattern ?? c.input?.command ?? c.input?.url;
+          lastActivity = `${c.name} ${target ? oneLine5(String(target), 60) : ""}`.trim();
+          if (EDIT_TOOLS4.has(c.name) && c.input?.file_path) pendingEdits.set(String(c.id), String(c.input.file_path));
+          if (timeline.length < MAX_STEPS) {
+            const step = { kind: EDIT_TOOLS4.has(c.name) ? "edit" : c.name === SHELL ? "shell" : "tool", name: c.name, text: clip5(String(target ?? ""), 240) };
+            timeline.push(step);
+            stepOf.set(String(c.id), step);
+          }
+        }
+      }
+    } else if (e.type === "user") {
+      for (const c of e.message?.content ?? []) {
+        if (c?.type !== "tool_result") continue;
+        const text = typeof c.content === "string" ? c.content : JSON.stringify(c.content ?? "");
+        const step = stepOf.get(String(c.tool_use_id));
+        if (step) step.ok = !c.is_error;
+        if (c.is_error) {
+          if (DENIED4.test(text)) usage2.denied++;
+        } else if (pendingEdits.has(String(c.tool_use_id))) {
+          edits.push(pendingEdits.get(String(c.tool_use_id)));
+        }
+      }
+    } else if (e.type === "result") {
+      const u = e.usage ?? {};
+      usage2.input += Math.max(0, num5(u.input_tokens) - num5(u.cache_read_input_tokens));
+      usage2.cacheRead += num5(u.cache_read_input_tokens);
+      usage2.output += num5(u.output_tokens);
+      usage2.total += num5(u.total_tokens) || num5(u.input_tokens) + num5(u.output_tokens);
+      usage2.denied = Math.max(usage2.denied, Array.isArray(e.permission_denials) ? e.permission_denials.length : 0);
+      if (e.is_error) {
+        error ??= apiError(String(e.error?.message ?? e.result ?? e.subtype ?? "Qwen Code error"));
+      } else if (typeof e.result === "string") {
+        finalText = e.result.trim();
+      }
+    }
+  }
+  return { sessionId, model, finalText: finalText ?? (error ? "" : lastText), usage: usage2, tools, edits, lastActivity, timeline, error };
+}
+var apiError = (text) => text.replace(API_ERROR, "").replace(/\](?=\s*(\n|$))/, "").replace(/\s+/g, " ").trim() || text;
+var clip5 = (s, n) => s.length > n ? `${s.slice(0, n - 1)}\u2026` : s;
+var num5 = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+var oneLine5 = (s, max = 80) => {
+  const t = s.replace(/\s+/g, " ").trim();
+  return t.length > max ? `${t.slice(0, max - 1)}\u2026` : t;
+};
+
+// src/backends/qwen/index.ts
+var binary6 = () => findBinary("qwen", "PITROOM_QWEN_BIN", ["~/.local/bin/qwen", "~/.npm-global/bin/qwen"]);
+var policyDir2 = () => path8.resolve(path8.dirname(fileURLToPath2(import.meta.url)), "..", "policies", "qwen");
+var EXCLUDED = [
+  "agent",
+  "send_message",
+  "skill",
+  "manage_memory",
+  "search_memory",
+  "enter_worktree",
+  "exit_worktree",
+  "record_artifact",
+  "cron_create",
+  "cron_list",
+  "cron_delete",
+  "loop_wakeup",
+  "task_stop",
+  "update_goal",
+  "get_goal",
+  "list_agents",
+  "report_findings",
+  "tool_call",
+  "tool_search",
+  "read_mcp_resource"
+];
+var WEB = ["web_fetch", "web_search"];
+var EDITS_HERE = ["Edit(./**)", "write_file(./**)", "notebook_edit(./**)"];
+var DENY_SHELL = [
+  "git commit",
+  "git push",
+  "git pull",
+  "git reset",
+  "git checkout",
+  "git restore",
+  "git clean",
+  "git stash",
+  "git rebase",
+  "git merge",
+  "git switch",
+  "git branch",
+  "git tag",
+  "git rm",
+  "git worktree",
+  "git update-ref",
+  "git config",
+  "git remote",
+  "git cherry-pick",
+  "git revert",
+  "git am",
+  "git add",
+  "rm -rf",
+  "rm -fr",
+  "sudo",
+  "chown",
+  "kill",
+  "pkill",
+  "killall",
+  "gh",
+  "npm publish",
+  "pitroom",
+  "opencode",
+  "claude",
+  "codex",
+  "gemini",
+  "qwen",
+  "kilo",
+  "kilocode"
+].map((c) => `run_shell_command(${c})`);
+function invocation6(req) {
+  const read3 = req.mode === "read";
+  const exclude = [...EXCLUDED, ...req.web ? [] : WEB, ...read3 ? [] : DENY_SHELL];
+  const args = [
+    // The prompt is the first word: the list options below take every word that follows them, and Qwen Code reads
+    // no prompt after "--". One that starts with "-" would be read as an option: a leading space keeps it the prompt.
+    req.prompt.startsWith("-") ? ` ${req.prompt}` : req.prompt,
+    "--safe-mode",
+    "--output-format",
+    "stream-json",
+    "--approval-mode",
+    read3 ? "plan" : "default",
+    "--exclude-tools",
+    ...exclude
+  ];
+  if (!read3) args.push("--allowed-tools", ...EDITS_HERE, "run_shell_command");
+  const model = (req.model ?? "").split("#")[0];
+  if (model) args.push("--model", model);
+  if (req.sessionId) args.push("--resume", req.sessionId);
+  const { command, prefix } = resolveCommand(binary6());
+  return {
+    command,
+    args: [...prefix, ...args],
+    env: {
+      QWEN_CODE_SYSTEM_DEFAULTS_PATH: path8.join(policyDir2(), "worker-defaults.json"),
+      QWEN_CODE_DISABLE_CRON: "1",
+      QWEN_DISABLE_AUTO_TITLE: "1"
+    }
+  };
+}
+function classify5(message) {
+  if (/\b40[13]\b|incorrect api key|invalid api key|unauthori[sz]ed|authenticat|not logged in|no auth/i.test(message)) return "auth";
+  if (/\b429\b|rate.?limit|too many requests|quota|capacity|overloaded|\b529\b/i.test(message)) return "rate-limited";
+  if (/model[^.]*(not found|does not exist|not available|not supported)|invalid model|model_not_found|\b404\b/i.test(message)) return "model-unavailable";
+  return "other";
+}
+function failure6(run2, stderr, exitCode) {
+  if (exitCode === 0 && !run2.error) return void 0;
+  const detail = stderr.trim().split("\n").filter((l) => l.trim() && !/SAFE MODE/.test(l)).pop();
+  const message = run2.error ?? detail ?? `qwen exited with code ${exitCode}`;
+  return { kind: classify5(message), message };
+}
+function userSettings() {
+  try {
+    return JSON.parse(fs8.readFileSync(path8.join(process.env.QWEN_HOME ?? path8.join(os7.homedir(), ".qwen"), "settings.json"), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function defaultModel5() {
+  const name = userSettings().model?.name;
+  return typeof name === "string" && name ? name : void 0;
+}
+function doctor6({ models, hasFallback }) {
+  const { command, prefix } = resolveCommand(binary6());
+  const r = spawnSync6(command, [...prefix, "--version"], { encoding: "utf8", timeout: 6e4, stdio: ["ignore", "pipe", "pipe"] });
+  if (r.error || r.status !== 0) return [{ level: "fail", message: `qwen not runnable (${binary6()}). Install Qwen Code (npm i -g @qwen-code/qwen-code), or set PITROOM_QWEN_BIN` }];
+  const checks = [{ level: "ok", message: `Qwen Code ${r.stdout.trim()} at ${binary6()} (beta worker: checked against Qwen Code 0.25)` }];
+  const auth = userSettings().security?.auth?.selectedType;
+  const key = process.env.OPENAI_API_KEY || process.env.DASHSCOPE_API_KEY || process.env.ANTHROPIC_API_KEY || process.env.GEMINI_API_KEY;
+  checks.push(
+    auth || key ? { level: "ok", message: `Qwen Code: sign-in ${auth ?? "from an API key in the environment"}` } : { level: "warn", message: "Qwen Code has no sign-in method set: run `qwen` once to choose one, or set OPENAI_API_KEY (and OPENAI_BASE_URL) for an OpenAI-compatible provider" }
+  );
+  for (const m of models) {
+    const model = m ?? defaultModel5();
+    checks.push({ level: model ? "ok" : "warn", message: model ? `Qwen Code model: ${model}` : "Qwen Code model: none pinned (pass -W qwen:<model> or set model.name in ~/.qwen/settings.json)" });
+  }
+  if (!hasFallback) checks.push({ level: "warn", message: "no fallback workers configured for Qwen Code runs" });
+  return checks;
+}
+var qwen = {
+  id: "qwen",
+  name: "Qwen Code",
+  capabilities: { readOnly: "approval-mode", resume: "by-id", reportsCost: false, attachFiles: false },
+  binary: binary6,
+  invocation: invocation6,
+  parse: parseEvents5,
+  failure: failure6,
+  defaultModel: defaultModel5,
+  doctor: doctor6
+};
+
 // src/backends/index.ts
-var REGISTRY = new Map([opencode, codex, claude, gemini].map((b) => [b.id, b]));
+var REGISTRY = new Map([opencode, codex, claude, gemini, qwen, kiloBackend].map((b) => [b.id, b]));
 var DEFAULT_BACKEND = opencode.id;
-var PLANNED = [];
+var PLANNED = ["hermes"];
 var backendIds = () => [...REGISTRY.keys()];
 var allBackends = () => [...REGISTRY.values()];
 var isBackendId = (id) => REGISTRY.has(id) || PLANNED.includes(id);
@@ -1422,12 +1770,12 @@ function getBackend(id) {
 }
 
 // src/cli/args.ts
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 
 // src/core/config.ts
-import fs8 from "node:fs";
-import os7 from "node:os";
-import path7 from "node:path";
+import fs9 from "node:fs";
+import os8 from "node:os";
+import path9 from "node:path";
 var SCHEMA = {
   worker: "string",
   fallback: "string[]",
@@ -1441,6 +1789,8 @@ var SCHEMA = {
   tiers: "record",
   costs: "numbers",
   audit: "number",
+  auditFix: "boolean",
+  auditFocus: "boolean",
   readIn: "string",
   cacheDays: "number",
   countRateLimits: "boolean",
@@ -1451,12 +1801,14 @@ var SCHEMA = {
   workerPrices: "record",
   priceFeed: "boolean",
   priceFeedUrl: "string",
-  priceFeedHours: "number"
+  priceFeedHours: "number",
+  budgetDaily: "number",
+  rankWorkers: "boolean"
 };
 function configPath() {
-  if (process.env.PITROOM_CONFIG) return path7.resolve(process.env.PITROOM_CONFIG);
-  const base2 = process.platform === "win32" ? process.env.APPDATA ?? path7.join(os7.homedir(), "AppData", "Roaming") : process.env.XDG_CONFIG_HOME ?? path7.join(os7.homedir(), ".config");
-  return path7.join(base2, "pitroom", "config.json");
+  if (process.env.PITROOM_CONFIG) return path9.resolve(process.env.PITROOM_CONFIG);
+  const base2 = process.platform === "win32" ? process.env.APPDATA ?? path9.join(os8.homedir(), "AppData", "Roaming") : process.env.XDG_CONFIG_HOME ?? path9.join(os8.homedir(), ".config");
+  return path9.join(base2, "pitroom", "config.json");
 }
 var cached;
 function loadConfig() {
@@ -1464,10 +1816,10 @@ function loadConfig() {
   const file2 = configPath();
   const config = {};
   const warnings = [];
-  if (fs8.existsSync(file2)) {
+  if (fs9.existsSync(file2)) {
     let raw;
     try {
-      raw = JSON.parse(fs8.readFileSync(file2, "utf8"));
+      raw = JSON.parse(fs9.readFileSync(file2, "utf8"));
     } catch (e) {
       warnings.push(`${file2}: invalid JSON (${e.message}); ignored`);
     }
@@ -1509,6 +1861,10 @@ var rate = (v) => {
   const n = typeof v === "string" && v.trim() !== "" ? Number(v) : v;
   return typeof n === "number" && Number.isFinite(n) && n >= 0 ? Math.min(n, 1) : void 0;
 };
+var amount = (v) => {
+  const n = typeof v === "string" && v.trim() !== "" ? Number(v) : v;
+  return typeof n === "number" && Number.isFinite(n) && n >= 0 ? n : void 0;
+};
 var days = (v) => {
   const n = typeof v === "string" && v.trim() !== "" ? Number(v) : v;
   return typeof n === "number" && Number.isInteger(n) && n >= 0 ? n : void 0;
@@ -1543,6 +1899,8 @@ function effective(flags = {}) {
     tiers: setting(void 0, void 0, c.tiers, {}),
     costs: setting(void 0, void 0, c.costs, {}),
     audit: setting(void 0, rate(e.PITROOM_AUDIT), rate(c.audit), 0),
+    auditFix: setting(void 0, flag01(e.PITROOM_AUDIT_FIX), c.auditFix, false),
+    auditFocus: setting(void 0, flag01(e.PITROOM_AUDIT_FOCUS), c.auditFocus, false),
     readIn: setting(void 0, readIn(e.PITROOM_READ_IN), readIn(c.readIn), "auto"),
     cacheDays: setting(void 0, days(e.PITROOM_CACHE_DAYS), days(c.cacheDays), 7),
     countRateLimits: setting(void 0, void 0, c.countRateLimits, false),
@@ -1553,7 +1911,9 @@ function effective(flags = {}) {
     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)
+    priceFeedHours: setting(void 0, positiveInt(e.PITROOM_PRICE_FEED_HOURS), positiveInt(c.priceFeedHours), 24),
+    rankWorkers: setting(void 0, flag01(e.PITROOM_RANK_WORKERS), c.rankWorkers, false),
+    budgetDaily: setting(void 0, amount(e.PITROOM_BUDGET_DAILY), amount(c.budgetDaily), void 0)
   };
 }
 
@@ -1689,9 +2049,9 @@ function exitCodeFor(meta) {
 }
 function readTask(p) {
   const file2 = flag(p, "task-file");
-  if (file2) return fs9.readFileSync(file2, "utf8");
+  if (file2) return fs10.readFileSync(file2, "utf8");
   const words = p.positional;
-  if (words.length === 1 && words[0] === "-") return fs9.readFileSync(0, "utf8");
+  if (words.length === 1 && words[0] === "-") return fs10.readFileSync(0, "utf8");
   return words.join(" ");
 }
 function runOptions(p, task) {
@@ -1739,16 +2099,16 @@ function effortFlag(p) {
 import readline from "node:readline";
 
 // src/core/run.ts
-import { spawn as spawn4, spawnSync as spawnSync6 } from "node:child_process";
-import fs27 from "node:fs";
-import path23 from "node:path";
+import { spawn as spawn4, spawnSync as spawnSync8 } from "node:child_process";
+import fs29 from "node:fs";
+import path25 from "node:path";
 
 // src/vcs/git.ts
-import { spawnSync as spawnSync5 } from "node:child_process";
+import { spawnSync as spawnSync7 } from "node:child_process";
 import crypto2 from "node:crypto";
-import fs10 from "node:fs";
-import os8 from "node:os";
-import path8 from "node:path";
+import fs11 from "node:fs";
+import os9 from "node:os";
+import path10 from "node:path";
 var SAFE = [
   "-c",
   "color.ui=false",
@@ -1760,7 +2120,7 @@ var SAFE = [
   "diff.mnemonicPrefix=false"
 ];
 function git(cwd, args, env) {
-  const r = spawnSync5("git", [...SAFE, ...args], {
+  const r = spawnSync7("git", [...SAFE, ...args], {
     cwd,
     env: env ?? process.env,
     encoding: "utf8",
@@ -1780,31 +2140,31 @@ function gitAvailable() {
 }
 function canonical(dir) {
   try {
-    return fs10.realpathSync.native(dir);
+    return fs11.realpathSync.native(dir);
   } catch {
     return dir;
   }
 }
 function repoRoot(dir) {
   const r = git(dir, ["rev-parse", "--show-toplevel"]);
-  return r.code === 0 ? canonical(path8.resolve(r.stdout.trim())) : void 0;
+  return r.code === 0 ? canonical(path10.resolve(r.stdout.trim())) : void 0;
 }
 function snapshotTree(root, exclude = [], drop2 = []) {
-  const tmp = path8.join(os8.tmpdir(), `pitroom-index-${process.pid}-${crypto2.randomBytes(4).toString("hex")}`);
-  const real = path8.resolve(root, must(root, ["rev-parse", "--git-path", "index"]).trim());
+  const tmp = path10.join(os9.tmpdir(), `pitroom-index-${process.pid}-${crypto2.randomBytes(4).toString("hex")}`);
+  const real = path10.resolve(root, must(root, ["rev-parse", "--git-path", "index"]).trim());
   const env = { ...process.env, GIT_INDEX_FILE: tmp };
   try {
-    if (fs10.existsSync(real)) fs10.copyFileSync(real, tmp);
+    if (fs11.existsSync(real)) fs11.copyFileSync(real, tmp);
     else must(root, ["read-tree", "--empty"], env);
     must(root, ["add", "-A", "--", ":/", ...exclude.map((p) => `:(top,exclude)${p}`), ...drop2.map((p) => `:(top,literal,exclude)${p}`)], env);
     if (drop2.length) {
-      const r = spawnSync5("git", ["update-index", "--force-remove", "-z", "--stdin"], { cwd: root, env, input: `${drop2.join("\0")}\0`, encoding: "utf8" });
+      const r = spawnSync7("git", ["update-index", "--force-remove", "-z", "--stdin"], { cwd: root, env, input: `${drop2.join("\0")}\0`, encoding: "utf8" });
       if (r.status !== 0) throw new Error(`git update-index failed: ${r.stderr.trim()}`);
     }
     return must(root, ["write-tree"], env).trim();
   } finally {
-    fs10.rmSync(tmp, { force: true });
-    fs10.rmSync(`${tmp}.lock`, { force: true });
+    fs11.rmSync(tmp, { force: true });
+    fs11.rmSync(`${tmp}.lock`, { force: true });
   }
 }
 var DIFF = ["diff", "--no-ext-diff", "--no-textconv", "--no-renames"];
@@ -1824,27 +2184,27 @@ function diffTrees(root, a, b) {
   return { changes, stats: { files: changes.length, insertions, deletions }, patch };
 }
 function createIsolatedCopy(root, tree, dest) {
-  const objects = path8.join(path8.resolve(root, must(root, ["rev-parse", "--git-common-dir"]).trim()), "objects");
-  fs10.mkdirSync(path8.dirname(dest), { recursive: true });
-  must(path8.dirname(dest), ["init", "--quiet", dest]);
-  fs10.writeFileSync(path8.join(dest, ".git", "objects", "info", "alternates"), `${objects}
+  const objects = path10.join(path10.resolve(root, must(root, ["rev-parse", "--git-common-dir"]).trim()), "objects");
+  fs11.mkdirSync(path10.dirname(dest), { recursive: true });
+  must(path10.dirname(dest), ["init", "--quiet", dest]);
+  fs11.writeFileSync(path10.join(dest, ".git", "objects", "info", "alternates"), `${objects}
 `);
   must(dest, ["read-tree", tree]);
   must(dest, ["checkout-index", "--all", "--force"]);
 }
 function removeIsolatedCopy(dest, ownedBy) {
-  const rel = path8.relative(ownedBy, dest);
-  if (!rel || rel.startsWith("..") || path8.isAbsolute(rel)) throw new Error(`refusing to remove ${dest}`);
-  fs10.rmSync(dest, { recursive: true, force: true });
+  const rel = path10.relative(ownedBy, dest);
+  if (!rel || rel.startsWith("..") || path10.isAbsolute(rel)) throw new Error(`refusing to remove ${dest}`);
+  fs11.rmSync(dest, { recursive: true, force: true });
 }
 function linkIntoWorktree(root, worktree, rels) {
   const linked = [];
   for (const rel of rels) {
-    const src = path8.join(root, rel);
-    const dst = path8.join(worktree, rel);
-    if (!fs10.existsSync(src) || fs10.existsSync(dst)) continue;
-    fs10.mkdirSync(path8.dirname(dst), { recursive: true });
-    fs10.symlinkSync(src, dst, process.platform === "win32" ? "junction" : void 0);
+    const src = path10.join(root, rel);
+    const dst = path10.join(worktree, rel);
+    if (!fs11.existsSync(src) || fs11.existsSync(dst)) continue;
+    fs11.mkdirSync(path10.dirname(dst), { recursive: true });
+    fs11.symlinkSync(src, dst, process.platform === "win32" ? "junction" : void 0);
     linked.push(rel);
   }
   return linked;
@@ -1950,11 +2310,11 @@ function resolveChain(flags = {}) {
 
 // src/core/process.ts
 import { spawn } from "node:child_process";
-import fs12 from "node:fs";
+import fs13 from "node:fs";
 
 // src/vcs/guard.ts
-import fs11 from "node:fs";
-import path9 from "node:path";
+import fs12 from "node:fs";
+import path11 from "node:path";
 var VERSION = 2;
 var WINDOWS = process.platform === "win32";
 var fwd = (p) => WINDOWS ? p.replace(/\\/g, "/") : p;
@@ -2031,29 +2391,29 @@ esac
 exec "$real" "$@"
 `;
 function shimDir() {
-  return path9.join(home(), "shim", `v${VERSION}`);
+  return path11.join(home(), "shim", `v${VERSION}`);
 }
 function findRealGit(skip) {
   const same2 = (a, b) => WINDOWS ? a.toLowerCase() === b.toLowerCase() : a === b;
-  for (const dir of (process.env.PATH ?? "").split(path9.delimiter).filter(Boolean)) {
-    if (same2(path9.resolve(dir), skip)) continue;
-    const p = path9.join(dir, WINDOWS ? "git.exe" : "git");
+  for (const dir of (process.env.PATH ?? "").split(path11.delimiter).filter(Boolean)) {
+    if (same2(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;
+      fs12.accessSync(p, fs12.constants.X_OK);
+      if (fs12.statSync(p).isFile()) return p;
     } catch {
     }
   }
   return void 0;
 }
 function findGitSh(realGit) {
-  let dir = path9.dirname(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 = path9.join(dir, rel);
-      if (fs11.existsSync(p)) return p;
+      const p = path11.join(dir, rel);
+      if (fs12.existsSync(p)) return p;
     }
-    const up = path9.dirname(dir);
+    const up = path11.dirname(dir);
     if (up === dir) break;
     dir = up;
   }
@@ -2071,12 +2431,12 @@ var REF_HOOK = `#!/bin/sh
 echo "pitroom: git ref updates (commit, reset, branch, tag, stash, rebase, merge) are blocked for workers" >&2
 exit 1
 `;
-var hooksDir = () => path9.join(home(), "git-hooks", `v${HOOK_VERSION}`);
+var hooksDir = () => path11.join(home(), "git-hooks", `v${HOOK_VERSION}`);
 function writeIfChanged(file2, content) {
-  if (fs11.existsSync(file2) && fs11.readFileSync(file2, "utf8") === content) return;
-  fs11.mkdirSync(path9.dirname(file2), { recursive: true });
+  if (fs12.existsSync(file2) && fs12.readFileSync(file2, "utf8") === content) return;
+  fs12.mkdirSync(path11.dirname(file2), { recursive: true });
   const tmp = `${file2}.${process.pid}.tmp`;
-  fs11.writeFileSync(tmp, content, { mode: 493 });
+  fs12.writeFileSync(tmp, content, { mode: 493 });
   renameOver(tmp, file2);
 }
 function pathKey(env) {
@@ -2108,7 +2468,7 @@ function guardEnv(env) {
     GIT_PAGER: "cat",
     PAGER: "cat"
   };
-  writeIfChanged(path9.join(hooksDir(), "reference-transaction"), REF_HOOK);
+  writeIfChanged(path11.join(hooksDir(), "reference-transaction"), REF_HOOK);
   env = withGitConfig(onePath(env), [
     ["core.hooksPath", fwd(hooksDir())],
     ["url.pitroom-push-blocked://.pushInsteadOf", ""]
@@ -2120,11 +2480,11 @@ function guardEnv(env) {
   if (WINDOWS) {
     sh = findGitSh(real);
     if (!sh) return { ...env, ...quiet };
-    writeIfChanged(path9.join(dir, "git.cmd"), cmdShim(sh));
+    writeIfChanged(path11.join(dir, "git.cmd"), cmdShim(sh));
   }
-  writeIfChanged(path9.join(dir, "git"), SHIM);
+  writeIfChanged(path11.join(dir, "git"), SHIM);
   const key = pathKey(env);
-  return { ...env, ...quiet, PITROOM_REAL_GIT: fwd(real), [key]: `${dir}${path9.delimiter}${env[key] ?? ""}` };
+  return { ...env, ...quiet, PITROOM_REAL_GIT: fwd(real), [key]: `${dir}${path11.delimiter}${env[key] ?? ""}` };
 }
 function shimReady() {
   const env = guardEnv({ ...process.env });
@@ -2133,8 +2493,8 @@ function shimReady() {
 
 // src/core/process.ts
 async function spawnWorker(inv, opts) {
-  const out = fs12.openSync(opts.stdoutFile, "w");
-  const err = fs12.openSync(opts.stderrFile, "w");
+  const out = fs13.openSync(opts.stdoutFile, "w");
+  const err = fs13.openSync(opts.stderrFile, "w");
   const res = { code: null, timedOut: false, stopped: false };
   const child = spawn(inv.command, inv.args, {
     cwd: opts.cwd,
@@ -2157,7 +2517,7 @@ async function spawnWorker(inv, opts) {
   }, opts.timeoutSec * 1e3);
   res.code = await new Promise((resolve2) => {
     child.on("error", (e) => {
-      res.spawnError = e.code === "ENOENT" ? fs12.existsSync(opts.cwd) ? `${inv.command} not found` : `the working directory ${opts.cwd} does not exist` : e.message;
+      res.spawnError = e.code === "ENOENT" ? fs13.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));
@@ -2166,8 +2526,8 @@ async function spawnWorker(inv, opts) {
   if (killer) clearTimeout(killer);
   process.off("SIGINT", stop);
   process.off("SIGTERM", stop);
-  fs12.closeSync(out);
-  fs12.closeSync(err);
+  fs13.closeSync(out);
+  fs13.closeSync(err);
   return res;
 }
 
@@ -2199,12 +2559,12 @@ function parseAudit(text) {
 }
 
 // src/core/cooldown.ts
-import fs13 from "node:fs";
-import path10 from "node:path";
+import fs14 from "node:fs";
+import path12 from "node:path";
 var MAX_MS = 24 * 36e5;
 var OVERLOAD_MS = 20 * 6e4;
 var DAILY_MS = 4 * 36e5;
-var file = () => path10.join(home(), "cooldowns.json");
+var file = () => path12.join(home(), "cooldowns.json");
 function cooldownKey(target, backend) {
   const model = (target.model ?? backend.defaultModel?.() ?? "").split("#")[0];
   return `${target.backend}:${model}`;
@@ -2227,16 +2587,16 @@ function cooldownMs(message) {
 }
 function read() {
   try {
-    const raw = JSON.parse(fs13.readFileSync(file(), "utf8"));
+    const raw = JSON.parse(fs14.readFileSync(file(), "utf8"));
     return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
   } catch {
     return {};
   }
 }
 function write(all) {
-  fs13.mkdirSync(path10.dirname(file()), { recursive: true });
+  fs14.mkdirSync(path12.dirname(file()), { recursive: true });
   const tmp = `${file()}.${process.pid}.tmp`;
-  fs13.writeFileSync(tmp, `${JSON.stringify(all, null, 2)}
+  fs14.writeFileSync(tmp, `${JSON.stringify(all, null, 2)}
 `);
   renameOver(tmp, file());
 }
@@ -2266,14 +2626,14 @@ function untilText(c, now = Date.now()) {
 }
 
 // src/core/snapshot.ts
-import fs15 from "node:fs";
-import path12 from "node:path";
+import fs16 from "node:fs";
+import path14 from "node:path";
 import crypto3 from "node:crypto";
 
 // src/core/secrets.ts
 import { execFileSync } from "node:child_process";
-import fs14 from "node:fs";
-import path11 from "node:path";
+import fs15 from "node:fs";
+import path13 from "node:path";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "out", ".next", "target", "vendor", ".venv", "venv", "__pycache__", "coverage", ".turbo", ".cache"]);
 var MAX_VISITED = 2e4;
 var MAX_DEPTH = 4;
@@ -2291,16 +2651,16 @@ function findSecretFiles(dir) {
     if (depth > MAX_DEPTH || visited > MAX_VISITED) return;
     let entries;
     try {
-      entries = fs14.readdirSync(d, { withFileTypes: true });
+      entries = fs15.readdirSync(d, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       visited++;
       if (e.isDirectory()) {
-        if (!SKIP_DIRS.has(e.name)) walk(path11.join(d, e.name), depth + 1);
+        if (!SKIP_DIRS.has(e.name)) walk(path13.join(d, e.name), depth + 1);
       } else if (e.isFile() && looksSecret(e.name)) {
-        found.push(slash(path11.relative(dir, path11.join(d, e.name))));
+        found.push(slash(path13.relative(dir, path13.join(d, e.name))));
       }
     }
   };
@@ -2310,7 +2670,7 @@ function findSecretFiles(dir) {
 function findSecretFilesInTree(root, dir) {
   try {
     const out = execFileSync("git", ["-C", root, "ls-files", "-z", "--cached", "--others", "--exclude-standard"], { encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
-    return out.split("\0").filter((f) => f && looksSecret(path11.basename(f)) && !path11.relative(dir, path11.join(root, f)).startsWith("..")).map((f) => slash(path11.relative(dir, path11.join(root, f)))).sort();
+    return out.split("\0").filter((f) => f && looksSecret(path13.basename(f)) && !path13.relative(dir, path13.join(root, f)).startsWith("..")).map((f) => slash(path13.relative(dir, path13.join(root, f)))).sort();
   } catch {
     return [];
   }
@@ -2322,7 +2682,7 @@ function secretWarning(files, mode) {
   const fix = mode === "isolate" ? "add them to .gitignore, or" : "use an isolated copy (-i, git-ignored files are left out) or a clean checkout, or";
   return `secret-looking files ${where} (${shown}): the worker is told not to read them, but nothing stops it, and its model may be hosted by a third party; ${fix} set PITROOM_NO_SECRET_WARNING=1 to silence this`;
 }
-var slash = (p) => p.split(path11.sep).join("/");
+var slash = (p) => p.split(path13.sep).join("/");
 
 // src/core/snapshot.ts
 var READ_IN = ["auto", "snapshot", "project"];
@@ -2330,7 +2690,7 @@ var KEEP_MS = 24 * 36e5;
 var PRUNE_AGE_MS = 3 * 24 * 36e5;
 var KEEP_NEWEST = 6;
 var JUST_USED_MS = 10 * 6e4;
-var snapshotsDir = () => path12.join(home(), "snapshots");
+var snapshotsDir = () => path14.join(home(), "snapshots");
 function wantSnapshot(readIn2, root, dir) {
   if (!root || readIn2 === "project") return void 0;
   const secrets = findSecretFiles(dir);
@@ -2339,19 +2699,19 @@ function wantSnapshot(readIn2, root, dir) {
 function readSnapshot(root) {
   const drop2 = findSecretFilesInTree(root, root);
   const tree = snapshotTree(root, [], drop2);
-  const dest = path12.join(snapshotsDir(), tree);
-  if (fs15.existsSync(path12.join(dest, ".git"))) {
+  const dest = path14.join(snapshotsDir(), tree);
+  if (fs16.existsSync(path14.join(dest, ".git"))) {
     touch(dest);
     return { dir: dest, tree, created: false };
   }
-  const tmp = path12.join(snapshotsDir(), `.tmp-${process.pid}-${crypto3.randomBytes(3).toString("hex")}`);
+  const tmp = path14.join(snapshotsDir(), `.tmp-${process.pid}-${crypto3.randomBytes(3).toString("hex")}`);
   try {
     createIsolatedCopy(root, tree, tmp);
     readOnly(tmp);
     try {
-      fs15.renameSync(tmp, dest);
+      fs16.renameSync(tmp, dest);
     } catch (e) {
-      if (!fs15.existsSync(path12.join(dest, ".git"))) throw e;
+      if (!fs16.existsSync(path14.join(dest, ".git"))) throw e;
       removeIsolatedCopy(tmp, snapshotsDir());
     }
   } catch (e) {
@@ -2367,17 +2727,17 @@ function readSnapshot(root) {
 function touch(dir) {
   try {
     const now = /* @__PURE__ */ new Date();
-    fs15.utimesSync(dir, now, now);
+    fs16.utimesSync(dir, now, now);
   } catch {
   }
 }
 function readOnly(dir) {
   const walk = (d) => {
-    for (const e of fs15.readdirSync(d, { withFileTypes: true })) {
+    for (const e of fs16.readdirSync(d, { withFileTypes: true })) {
       if (e.name === ".git") continue;
-      const p = path12.join(d, e.name);
+      const p = path14.join(d, e.name);
       if (e.isDirectory()) walk(p);
-      else if (e.isFile()) fs15.chmodSync(p, fs15.statSync(p).mode & ~146);
+      else if (e.isFile()) fs16.chmodSync(p, fs16.statSync(p).mode & ~146);
     }
   };
   try {
@@ -2388,7 +2748,7 @@ function readOnly(dir) {
 function prune(now = Date.now(), maxAgeMs = PRUNE_AGE_MS, keepNewest = KEEP_NEWEST) {
   let names;
   try {
-    names = fs15.readdirSync(snapshotsDir());
+    names = fs16.readdirSync(snapshotsDir());
   } catch {
     return 0;
   }
@@ -2396,14 +2756,14 @@ function prune(now = Date.now(), maxAgeMs = PRUNE_AGE_MS, keepNewest = KEEP_NEWE
   for (const id of listRunIds()) {
     try {
       const m = readMeta(id);
-      if (m.snapshot?.dir && isActive(m.state)) inUse.add(path12.resolve(m.snapshot.dir));
+      if (m.snapshot?.dir && isActive(m.state)) inUse.add(path14.resolve(m.snapshot.dir));
     } catch {
     }
   }
   const entries = names.map((n) => {
-    const dir = path12.join(snapshotsDir(), n);
+    const dir = path14.join(snapshotsDir(), n);
     try {
-      return { n, dir, age: now - fs15.statSync(dir).mtimeMs };
+      return { n, dir, age: now - fs16.statSync(dir).mtimeMs };
     } catch {
       return void 0;
     }
@@ -2411,7 +2771,7 @@ function prune(now = Date.now(), maxAgeMs = PRUNE_AGE_MS, keepNewest = KEEP_NEWE
   let removed = 0;
   let rank = 0;
   for (const e of entries) {
-    if (inUse.has(path12.resolve(e.dir))) continue;
+    if (inUse.has(path14.resolve(e.dir))) continue;
     const half = e.n.startsWith(".tmp-");
     const old = e.age >= (half ? KEEP_MS : maxAgeMs);
     const surplus = !half && ++rank > keepNewest && e.age >= JUST_USED_MS;
@@ -2427,10 +2787,10 @@ function prune(now = Date.now(), maxAgeMs = PRUNE_AGE_MS, keepNewest = KEEP_NEWE
 }
 function makeWritable(dir) {
   const walk = (d) => {
-    for (const e of fs15.readdirSync(d, { withFileTypes: true })) {
-      const p = path12.join(d, e.name);
+    for (const e of fs16.readdirSync(d, { withFileTypes: true })) {
+      const p = path14.join(d, e.name);
       if (e.isDirectory()) walk(p);
-      else if (e.isFile()) fs15.chmodSync(p, fs15.statSync(p).mode | 128);
+      else if (e.isFile()) fs16.chmodSync(p, fs16.statSync(p).mode | 128);
     }
   };
   try {
@@ -2441,17 +2801,17 @@ function makeWritable(dir) {
 function backToProject(text, snapshotDir, root) {
   let real = snapshotDir;
   try {
-    real = fs15.realpathSync(snapshotDir);
+    real = fs16.realpathSync(snapshotDir);
   } catch {
   }
   let out = text;
-  for (const dir of /* @__PURE__ */ new Set([real, snapshotDir])) out = out.split(`${dir}${path12.sep}`).join(`${root}${path12.sep}`).split(dir).join(root);
+  for (const dir of /* @__PURE__ */ new Set([real, snapshotDir])) out = out.split(`${dir}${path14.sep}`).join(`${root}${path14.sep}`).split(dir).join(root);
   return out;
 }
 
 // src/core/audit.ts
 import crypto4 from "node:crypto";
-import path13 from "node:path";
+import path15 from "node:path";
 var ANSWER_MAX = 8e3;
 function auditRate(meta) {
   return meta.auditRate ?? effective().audit.value;
@@ -2462,10 +2822,27 @@ function draw(id) {
 function auditable(meta, answer) {
   return meta.mode === "read" && meta.state === "done" && !meta.reviewOf && !meta.auditOf && !meta.audit && !!answer.trim();
 }
-function sampled(meta) {
-  const rate2 = auditRate(meta);
+function sampled(meta, rate2 = auditRate(meta)) {
   return rate2 > 0 && (rate2 >= 1 || draw(meta.id) < rate2);
 }
+var ASKS_FOR_LIST = /\b(all|every|each|list|lists|enumerate|how many|count|which)\b/i;
+function focusedRate(base2, task, record2) {
+  if (base2 <= 0 || base2 >= 1) return { rate: base2, why: [] };
+  let rate2 = base2;
+  const why = [];
+  if (ASKS_FOR_LIST.test(task)) {
+    rate2 *= 2;
+    why.push("asks for a list or a count");
+  }
+  if (record2 && record2.audited >= 3 && record2.agreed / record2.audited < 0.5) {
+    rate2 *= 2;
+    why.push(`the worker's audited answers were confirmed ${record2.agreed} of ${record2.audited} times`);
+  } else if (record2 && record2.audited >= 5 && record2.agreed === record2.audited) {
+    rate2 /= 2;
+    why.push(`the worker's ${record2.audited} audited answers were all confirmed`);
+  }
+  return { rate: Math.min(rate2, 1), why };
+}
 function pickAuditor(meta) {
   const eff = effective();
   const tiers = eff.tiers.value;
@@ -2478,9 +2855,9 @@ function relativeToAuditor(answer, meta) {
   let out = answer;
   const roots = [...new Set([meta.dir, meta.repoRoot].filter((r) => !!r))].sort((a, b) => b.length - a.length);
   for (const root of roots) {
-    const rel = path13.relative(meta.dir, root);
-    const prefix = rel ? `${rel.split(path13.sep).join("/")}/` : "";
-    out = out.split(`${root}${path13.sep}`).join(prefix).replace(new RegExp(`${root.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\w.-])`, "g"), rel || ".");
+    const rel = path15.relative(meta.dir, root);
+    const prefix = rel ? `${rel.split(path15.sep).join("/")}/` : "";
+    out = out.split(`${root}${path15.sep}`).join(prefix).replace(new RegExp(`${root.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\w.-])`, "g"), rel || ".");
   }
   return out;
 }
@@ -2513,18 +2890,34 @@ function auditTask(meta, answer) {
     'Under DISPUTED list only claims you checked and found wrong or unsupported; write "- (none)" when there are none.'
   ].join("\n");
 }
+function wantsFix(target, resumable) {
+  const a = target.audit;
+  return effective().auditFix.value && resumable && !!target.sessionId && !target.fixOf && !a?.fix && a?.state === "done" && (a.verdict === "partial" || a.verdict === "disagree") && !!a.disputed?.length;
+}
+function fixTask(disputed) {
+  return [
+    "Another worker audited your answer above and disputed these claims:",
+    ...disputed.map((d) => `- ${d}`),
+    "",
+    "Check each one yourself against the files (the auditor can be wrong too). Then give your whole answer again,",
+    "corrected, in the same answer format: keep what holds, fix what does not, and add what was missing.",
+    "Under OPEN ISSUES, say which disputed claims you accepted and which you kept, and why."
+  ].join("\n");
+}
 function auditLines(meta) {
+  const fixing = meta.fixOf ? [`\u2500\u2500 correction: the answer of ${meta.fixOf}, checked again against what its audit disputed`] : [];
   if (meta.auditOf) {
     return meta.state === "done" ? [`\u2500\u2500 audit of ${meta.auditOf}: ${(meta.auditVerdict ?? "unclear").toUpperCase()}${meta.auditDisputed?.length ? ` \xB7 ${meta.auditDisputed.length} disputed` : ""}`] : [];
   }
   const a = meta.audit;
-  if (!a) return [];
+  if (!a) return fixing;
   if (a.state === "done") {
     const head = `\u2500\u2500 audit (run ${a.id}): ${(a.verdict ?? "unclear").toUpperCase()}${a.verdict === "agree" ? "" : a.verdict === "unclear" ? " (the auditor did not answer in the expected form)" : ""}`;
-    return [head, ...(a.disputed ?? []).map((d) => `   disputed: ${d}`)];
+    const fix = a.fix ? [`\u2500\u2500 fix: the worker is correcting its answer as a follow-up (pitroom show ${a.fix})`] : [];
+    return [...fixing, head, ...(a.disputed ?? []).map((d) => `   disputed: ${d}`), ...fix];
   }
-  if (a.state === "running" || a.state === "queued") return [`\u2500\u2500 audit: another worker is re-checking this answer in the background (pitroom show ${a.id})`];
-  return [`\u2500\u2500 audit (run ${a.id}) ${a.state}: no verdict`];
+  if (a.state === "running" || a.state === "queued") return [...fixing, `\u2500\u2500 audit: another worker is re-checking this answer in the background (pitroom show ${a.id})`];
+  return [...fixing, `\u2500\u2500 audit (run ${a.id}) ${a.state}: no verdict`];
 }
 function auditBadge(meta) {
   const a = meta.audit;
@@ -2533,26 +2926,20 @@ function auditBadge(meta) {
   return a.state === "running" || a.state === "queued" ? "PENDING" : "FAILED";
 }
 
-// src/core/notify.ts
-import { spawn as spawn3 } from "node:child_process";
-import crypto5 from "node:crypto";
-import fs22 from "node:fs";
-import path18 from "node:path";
-
 // src/core/history.ts
-import fs19 from "node:fs";
+import fs20 from "node:fs";
 import { createRequire } from "node:module";
-import path16 from "node:path";
+import path18 from "node:path";
 import zlib from "node:zlib";
 
 // src/core/receipt.ts
-import fs17 from "node:fs";
-import path15 from "node:path";
+import fs18 from "node:fs";
+import path17 from "node:path";
 
 // src/core/prices.ts
 import { spawn as spawn2 } from "node:child_process";
-import fs16 from "node:fs";
-import path14 from "node:path";
+import fs17 from "node:fs";
+import path16 from "node:path";
 var DEFAULT_URL = "https://models.dev/api.json";
 var RETRY_AFTER_FAILURE_MS = 60 * 6e4;
 var MIN_MODELS = 100;
@@ -2565,8 +2952,8 @@ function catalogLabel() {
     return url;
   }
 }
-var catalogFile = () => path14.join(home(), "prices.json");
-var attemptFile = () => path14.join(home(), "prices.attempt");
+var catalogFile = () => path16.join(home(), "prices.json");
+var attemptFile = () => path16.join(home(), "prices.attempt");
 function trim(raw) {
   const out = {};
   if (!raw || typeof raw !== "object") return out;
@@ -2584,19 +2971,19 @@ var cached2;
 function readCatalog() {
   const file2 = catalogFile();
   try {
-    const { mtimeMs } = fs16.statSync(file2);
+    const { mtimeMs } = fs17.statSync(file2);
     if (cached2?.file === file2 && cached2.mtimeMs === mtimeMs) return cached2.catalog;
-    const parsed = JSON.parse(fs16.readFileSync(file2, "utf8"));
-    const catalog5 = parsed && typeof parsed.models === "object" && parsed.models && Number.isFinite(Date.parse(parsed.fetchedAt)) ? parsed : void 0;
-    cached2 = { file: file2, mtimeMs, catalog: catalog5 };
-    return catalog5;
+    const parsed = JSON.parse(fs17.readFileSync(file2, "utf8"));
+    const catalog6 = parsed && typeof parsed.models === "object" && parsed.models && Number.isFinite(Date.parse(parsed.fetchedAt)) ? parsed : void 0;
+    cached2 = { file: file2, mtimeMs, catalog: catalog6 };
+    return catalog6;
   } catch {
     return void 0;
   }
 }
 var ageMs = (file2) => {
   try {
-    return Date.now() - fs16.statSync(file2).mtimeMs;
+    return Date.now() - fs17.statSync(file2).mtimeMs;
   } catch {
     return Infinity;
   }
@@ -2615,17 +3002,17 @@ async function refreshCatalog() {
     const models = trim(await r.json());
     const n = Object.keys(models).length;
     if (n < MIN_MODELS) throw new Error(`only ${n} priced models in it (a catalog has thousands): not used`);
-    fs16.mkdirSync(home(), { recursive: true });
+    fs17.mkdirSync(home(), { recursive: true });
     const tmp = `${catalogFile()}.${process.pid}.tmp`;
-    const catalog5 = { fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), source: url, models };
-    fs16.writeFileSync(tmp, JSON.stringify(catalog5));
+    const catalog6 = { fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), source: url, models };
+    fs17.writeFileSync(tmp, JSON.stringify(catalog6));
     renameOver(tmp, catalogFile());
-    fs16.rmSync(attemptFile(), { force: true });
+    fs17.rmSync(attemptFile(), { force: true });
     return { state: "updated", models: n };
   } catch (e) {
     try {
-      fs16.mkdirSync(home(), { recursive: true });
-      fs16.writeFileSync(attemptFile(), `${(/* @__PURE__ */ new Date()).toISOString()} ${e.message}
+      fs17.mkdirSync(home(), { recursive: true });
+      fs17.writeFileSync(attemptFile(), `${(/* @__PURE__ */ new Date()).toISOString()} ${e.message}
 `);
     } catch {
     }
@@ -2637,8 +3024,8 @@ function refreshInBackground() {
     if (!refreshDue()) return;
     const script = process.argv[1];
     if (!script) return;
-    fs16.mkdirSync(home(), { recursive: true });
-    fs16.writeFileSync(attemptFile(), `${(/* @__PURE__ */ new Date()).toISOString()} refresh started
+    fs17.mkdirSync(home(), { recursive: true });
+    fs17.writeFileSync(attemptFile(), `${(/* @__PURE__ */ new Date()).toISOString()} refresh started
 `);
     const child = spawn2(process.execPath, [script, "prices", "--refresh", "--quiet"], { detached: true, stdio: "ignore", env: process.env });
     child.on("error", () => void 0);
@@ -2648,14 +3035,14 @@ function refreshInBackground() {
 }
 var OWN = { codex: ["openai"], claude: ["anthropic"], gemini: ["google"] };
 function catalogPrice(backend, ...models) {
-  const catalog5 = readCatalog();
-  if (!catalog5) return void 0;
+  const catalog6 = readCatalog();
+  if (!catalog6) 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;
+    const any = keys.find((k) => catalog6.models[k]) ?? Object.keys(catalog6.models).filter((k) => k.endsWith(`/${id}`)).sort()[0];
+    const triple = any ? catalog6.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 };
@@ -2668,7 +3055,7 @@ function catalogStatus() {
   const c = readCatalog();
   let lastFailure;
   try {
-    const t = fs16.readFileSync(attemptFile(), "utf8").trim();
+    const t = fs17.readFileSync(attemptFile(), "utf8").trim();
     if (t && !t.endsWith("refresh started")) lastFailure = t;
   } catch {
   }
@@ -2739,13 +3126,13 @@ function record(meta) {
     saved: meta.savedUsd ?? 0,
     price: primaryPrice().name
   };
-  fs17.mkdirSync(path15.dirname(ledgerFile()), { recursive: true });
-  fs17.appendFileSync(ledgerFile(), `${JSON.stringify(entry)}
+  fs18.mkdirSync(path17.dirname(ledgerFile()), { recursive: true });
+  fs18.appendFileSync(ledgerFile(), `${JSON.stringify(entry)}
 `);
 }
 function readLedger(sinceMs2) {
-  if (!fs17.existsSync(ledgerFile())) return [];
-  return fs17.readFileSync(ledgerFile(), "utf8").split("\n").filter(Boolean).flatMap((l) => {
+  if (!fs18.existsSync(ledgerFile())) return [];
+  return fs18.readFileSync(ledgerFile(), "utf8").split("\n").filter(Boolean).flatMap((l) => {
     try {
       return [JSON.parse(l)];
     } catch {
@@ -2820,7 +3207,7 @@ ${tile(0, compact(t.tokens), "Tokens offloaded")}${tile(1, t.ratio ? `${Math.rou
 }
 
 // src/core/ui.ts
-import fs18 from "node:fs";
+import fs19 from "node:fs";
 var WEEK_MS = 7 * 24 * 3600 * 1e3;
 var RECENT = 40;
 var RECENT_HOURS = 1;
@@ -2911,9 +3298,9 @@ function cardsFor(m) {
   const out = [];
   for (const [phase, text] of phases) {
     const marker = runFile(m.id, `card-${phase}`);
-    if (fs18.existsSync(marker)) continue;
+    if (fs19.existsSync(marker)) continue;
     if (!(phase === "started" && !isActive(m.state))) out.push(text());
-    fs18.writeFileSync(marker, "");
+    fs19.writeFileSync(marker, "");
   }
   return out;
 }
@@ -2924,10 +3311,10 @@ function hookCards(input) {
   const response = event.tool_response;
   const output = typeof response === "string" ? response : [response?.stdout, response?.stderr].filter(Boolean).join("\n");
   const ids = [...new Set(`${command}
-${output}`.match(RUN_ID) ?? [])].filter((id) => fs18.existsSync(`${runsDir()}/${id}`));
+${output}`.match(RUN_ID) ?? [])].filter((id) => fs19.existsSync(`${runsDir()}/${id}`));
   const since2 = Date.now() - RECENT_HOURS * 36e5;
   for (const id of listRunIds().slice(-RECENT)) {
-    if (ids.includes(id) || fs18.existsSync(runFile(id, "card-ended"))) continue;
+    if (ids.includes(id) || fs19.existsSync(runFile(id, "card-ended"))) continue;
     try {
       const m = readMeta(id);
       if (!isActive(m.state) && Date.parse(m.endedAt ?? m.startedAt) > since2) ids.push(id);
@@ -2949,7 +3336,7 @@ var SCHEMA_VERSION = 1;
 var PATCH_MAX = 1e6;
 var ANSWER_MAX2 = 2e5;
 var cached3;
-var historyFile = () => path16.join(home(), "history.db");
+var historyFile = () => path18.join(home(), "history.db");
 function openDb() {
   const file2 = historyFile();
   if (cached3?.file === file2) return cached3.db;
@@ -2963,7 +3350,7 @@ function openDb() {
     } finally {
       process.emitWarning = emit;
     }
-    fs19.mkdirSync(path16.dirname(file2), { recursive: true });
+    fs20.mkdirSync(path18.dirname(file2), { recursive: true });
     db = new DatabaseSync(file2);
     db.exec("PRAGMA journal_mode=WAL; PRAGMA busy_timeout=5000; PRAGMA synchronous=NORMAL;");
     migrate(db);
@@ -2998,35 +3385,35 @@ function migrate(db) {
 function readRunFile(id, name) {
   const f = runFile(id, name);
   try {
-    if (fs19.existsSync(f)) return fs19.readFileSync(f, "utf8");
-    if (fs19.existsSync(`${f}.gz`)) return zlib.gunzipSync(fs19.readFileSync(`${f}.gz`)).toString("utf8");
+    if (fs20.existsSync(f)) return fs20.readFileSync(f, "utf8");
+    if (fs20.existsSync(`${f}.gz`)) return zlib.gunzipSync(fs20.readFileSync(`${f}.gz`)).toString("utf8");
   } catch {
   }
   return void 0;
 }
 function gzipFile(f) {
-  if (!fs19.existsSync(f)) return;
-  fs19.writeFileSync(`${f}.gz`, zlib.gzipSync(fs19.readFileSync(f)));
-  fs19.rmSync(f);
+  if (!fs20.existsSync(f)) return;
+  fs20.writeFileSync(`${f}.gz`, zlib.gzipSync(fs20.readFileSync(f)));
+  fs20.rmSync(f);
 }
 function compactRun(meta) {
   if (!TERMINAL.includes(meta.state)) return;
-  const dir = path16.dirname(runFile(meta.id, "meta.json"));
+  const dir = path18.dirname(runFile(meta.id, "meta.json"));
   let names;
   try {
-    names = fs19.readdirSync(dir);
+    names = fs20.readdirSync(dir);
   } catch {
     return;
   }
   for (const n of names) {
-    if (/^events(\.attempt-\d+)?\.jsonl$/.test(n)) gzipFile(path16.join(dir, n));
+    if (/^events(\.attempt-\d+)?\.jsonl$/.test(n)) gzipFile(path18.join(dir, n));
     else if (/^stderr(\.attempt-\d+)?\.log$/.test(n)) {
-      if (meta.state === "done" && !/attempt/.test(n)) fs19.rmSync(path16.join(dir, n), { force: true });
-      else gzipFile(path16.join(dir, n));
+      if (meta.state === "done" && !/attempt/.test(n)) fs20.rmSync(path18.join(dir, n), { force: true });
+      else gzipFile(path18.join(dir, n));
     }
   }
 }
-var clip5 = (s, n) => s && s.length > n ? s.slice(0, n) : s;
+var clip6 = (s, n) => s && s.length > n ? s.slice(0, n) : s;
 function timelineOf(meta) {
   const raw = readRunFile(meta.id, "events.jsonl");
   if (!raw) return [];
@@ -3043,8 +3430,8 @@ function recordRun(meta) {
   try {
     const u = meta.usage;
     const known = db.prepare("SELECT answer IS NOT NULL AS has FROM runs WHERE id = ?").get(meta.id);
-    const answer = known?.has ? void 0 : clip5(readRunFile(meta.id, "summary.md")?.trim(), ANSWER_MAX2);
-    const patch = known?.has ? void 0 : clip5(readRunFile(meta.id, "changes.patch"), PATCH_MAX);
+    const answer = known?.has ? void 0 : clip6(readRunFile(meta.id, "summary.md")?.trim(), ANSWER_MAX2);
+    const patch = known?.has ? void 0 : clip6(readRunFile(meta.id, "changes.patch"), PATCH_MAX);
     const seconds = meta.endedAt ? Math.max(0, Math.round((Date.parse(meta.endedAt) - Date.parse(meta.startedAt)) / 1e3)) : null;
     const t = meta.ran ?? meta.worker;
     const fields = {
@@ -3056,7 +3443,7 @@ function recordRun(meta) {
       kind: kind(meta),
       backend: t.backend,
       model: meta.resolvedModel ?? t.model ?? null,
-      task: clip5(meta.task, 2e4) ?? "",
+      task: clip6(meta.task, 2e4) ?? "",
       grp: meta.group ?? null,
       dir: meta.dir,
       review_of: meta.reviewOf ?? meta.auditOf ?? null,
@@ -3070,7 +3457,7 @@ function recordRun(meta) {
       saved: meta.savedUsd ?? null,
       files_changed: meta.changes?.length ?? 0,
       applied: meta.applied ? 1 : 0,
-      error: clip5(meta.error, 2e3) ?? null,
+      error: clip6(meta.error, 2e3) ?? null,
       meta_json: JSON.stringify(meta)
     };
     db.exec("BEGIN IMMEDIATE");
@@ -3230,6 +3617,51 @@ function auditStats(db, since2) {
   }
   return { total, byWorker };
 }
+function workerRecord(backend, model, sinceMs2) {
+  const db = openDb();
+  if (!db) return void 0;
+  const since2 = new Date(sinceMs2).toISOString();
+  const fits = (m) => !model || m === model || !!m?.endsWith(`/${model}`) || model.endsWith(`/${m}`);
+  const rec = { runs: 0, ok: 0, audited: 0, agreed: 0 };
+  try {
+    for (const r of db.prepare(`SELECT model, SUM(NOT ${LIMITED}) runs, SUM(state='done') ok FROM runs WHERE backend = ? AND started_at >= ? AND ${NOT_AUDIT} GROUP BY model`).all(backend, since2)) {
+      if (!fits(r.model)) continue;
+      rec.runs += r.runs ?? 0;
+      rec.ok += r.ok ?? 0;
+    }
+    const audits = db.prepare(`SELECT r.model, json_extract(a.meta_json, '$.auditVerdict') v, COUNT(*) n
+      FROM runs a JOIN runs r ON r.id = json_extract(a.meta_json, '$.auditOf')
+      WHERE r.backend = ? AND a.started_at >= ? AND a.state = 'done' AND json_extract(a.meta_json, '$.auditOf') IS NOT NULL
+      GROUP BY r.model, v`).all(backend, since2);
+    for (const r of audits) {
+      if (!fits(r.model)) continue;
+      rec.audited += r.n;
+      if (r.v === "agree") rec.agreed += r.n;
+    }
+  } catch {
+    return void 0;
+  }
+  return rec;
+}
+function spentSince(sinceMs2) {
+  const db = openDb();
+  if (!db) return void 0;
+  try {
+    return db.prepare("SELECT COALESCE(SUM(cost),0) spent FROM runs WHERE started_at >= ?").get(new Date(sinceMs2).toISOString()).spent;
+  } catch {
+    return void 0;
+  }
+}
+function recentCosts(backend, model, n = 5) {
+  const db = openDb();
+  if (!db) return [];
+  try {
+    const rows = db.prepare("SELECT model, cost FROM runs WHERE backend = ? AND cost IS NOT NULL AND steps > 0 ORDER BY started_at DESC LIMIT 200").all(backend);
+    return rows.filter((r) => !model || r.model === model || r.model?.endsWith(`/${model}`) || model.endsWith(`/${r.model}`)).slice(0, n).map((r) => r.cost);
+  } catch {
+    return [];
+  }
+}
 function workerRows(rows, ledger, audited) {
   const out = rows.map((r) => ({ backend: r.backend, model: r.model ?? void 0, runs: r.runs, ok: r.ok ?? 0, limited: r.limited ?? 0, avgSeconds: r.avg_s, avgTokens: r.avg_t, saved: 0, audited: 0, agreed: 0 }));
   const key = (backend, model) => `${backend ?? ""}\0${model ?? ""}`;
@@ -3278,12 +3710,96 @@ function historyStats(sinceMs2) {
   }
 }
 
-// src/core/report.ts
+// src/core/budget.ts
 import fs21 from "node:fs";
+var startOfDay = (now = /* @__PURE__ */ new Date()) => new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+function activeSpend(sinceMs2) {
+  let total = 0;
+  for (const id of listRunIds()) {
+    try {
+      const m = freshMeta(id);
+      if (!isActive(m.state) || Date.parse(m.startedAt) < sinceMs2) continue;
+      const target = m.ran ?? m.worker;
+      const events = runFile(id, "events.jsonl");
+      if (!fs21.existsSync(events)) continue;
+      const run2 = getBackend(target.backend).parse(fs21.readFileSync(events, "utf8"));
+      if (run2.usage.cost !== void 0) total += run2.usage.cost;
+      else {
+        const price = workerPrice(target.backend, run2.model, target.model);
+        if (price) total += costAt(run2.usage, price);
+      }
+    } catch {
+    }
+  }
+  return total;
+}
+function isFree(t) {
+  let model = t.model;
+  try {
+    model ??= getBackend(t.backend).defaultModel?.();
+  } catch {
+  }
+  const price = workerPrice(t.backend, model);
+  if (price) return price.input === 0 && price.output === 0 && price.cachedInput === 0;
+  const costs = recentCosts(t.backend, model);
+  return costs.length > 0 && costs.every((c) => c === 0);
+}
+function withinBudget(chain, now = /* @__PURE__ */ new Date()) {
+  const budget = effective().budgetDaily.value;
+  if (budget === void 0) return { chain };
+  const finished = spentSince(startOfDay(now));
+  if (finished === void 0) return { chain };
+  const spent = finished + activeSpend(startOfDay(now));
+  if (spent < budget) {
+    return { chain, warning: spent >= 0.8 * budget ? `the workers cost ${usd(spent)} today, of your ${usd(budget)} daily budget ("budgetDaily")` : void 0 };
+  }
+  const free = chain.filter(isFree);
+  if (!free.length) {
+    throw new UserError(
+      `the workers cost ${usd(spent)} today, which reaches your daily budget of ${usd(budget)} ("budgetDaily"): only workers that cost nothing run now, and ${chain.map(describeTarget).join(", ")} ${chain.length === 1 ? "is" : "are"} not known to be free. Raise the budget, name a free worker (-W), or wait until tomorrow.`,
+      3
+    );
+  }
+  const left = chain.length - free.length;
+  return { chain: free, warning: `the daily budget (${usd(budget)}) is spent (${usd(spent)} today): only the free workers run${left ? `, ${left} paid one${left === 1 ? "" : "s"} left out` : ""}` };
+}
+
+// src/core/rank.ts
+var MIN_RUNS = 5;
+var MIN_AUDITS = 3;
+function scoreOf(r) {
+  if (!r || r.runs < MIN_RUNS) return void 0;
+  const ok = Math.min(r.ok, r.runs) / r.runs;
+  return r.audited >= MIN_AUDITS ? ok * (r.agreed / r.audited) : ok;
+}
+var pct = (x) => `${Math.round(x * 100)}%`;
+function rankChain(chain, recordOf) {
+  const scored = chain.map((t, i) => ({ t, i, score: scoreOf(recordOf(t)) }));
+  const slots = scored.filter((s) => s.score !== void 0);
+  if (slots.length < 2) return { chain };
+  const ranked = [...slots].sort((a, b) => Math.round(b.score * 10) - Math.round(a.score * 10) || a.i - b.i);
+  const out = [...chain];
+  slots.forEach((slot, k) => out[slot.i] = ranked[k].t);
+  if (out[0] === chain[0]) return { chain: out };
+  const by = (t) => scored.find((s) => s.t === t).score;
+  return {
+    chain: out,
+    note: `ranked by record ("rankWorkers"): ${describeTarget(out[0])} (${pct(by(out[0]))}) goes before ${describeTarget(chain[0])} (${pct(by(chain[0]))})`
+  };
+}
+
+// src/core/notify.ts
+import { spawn as spawn3 } from "node:child_process";
+import crypto5 from "node:crypto";
+import fs24 from "node:fs";
+import path20 from "node:path";
+
+// src/core/report.ts
+import fs23 from "node:fs";
 
 // src/core/plan.ts
-import fs20 from "node:fs";
-import path17 from "node:path";
+import fs22 from "node:fs";
+import path19 from "node:path";
 var FENCE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
 var RULE = /^ {0,3}([-*_])(\s*\1){2,}\s*$/;
 function structure(lines) {
@@ -3330,9 +3846,9 @@ function parsePlan(text, file2 = "") {
   return { file: file2, title: titleHeading?.text ?? "", header, constraints, tasks };
 }
 function loadPlan(file2) {
-  const abs = path17.resolve(file2);
-  if (!fs20.existsSync(abs) || !fs20.statSync(abs).isFile()) throw new UserError(`plan not found: ${file2}`);
-  const plan = parsePlan(fs20.readFileSync(abs, "utf8"), fs20.realpathSync(abs));
+  const abs = path19.resolve(file2);
+  if (!fs22.existsSync(abs) || !fs22.statSync(abs).isFile()) throw new UserError(`plan not found: ${file2}`);
+  const plan = parsePlan(fs22.readFileSync(abs, "utf8"), fs22.realpathSync(abs));
   if (!plan.tasks.length) throw new UserError(`${file2} has no "Task N" headings (see pitroom-writing-plans)`);
   return plan;
 }
@@ -3351,7 +3867,7 @@ function brief(plan, task) {
   ].filter(Boolean).join("\n\n")}
 `;
 }
-var planName = (file2) => path17.basename(file2).replace(/\.md$/i, "");
+var planName = (file2) => path19.basename(file2).replace(/\.md$/i, "");
 
 // src/core/style.ts
 var enabled = () => {
@@ -3411,7 +3927,7 @@ function duration(meta) {
 }
 function readSummary(meta) {
   const f = runFile(meta.id, "summary.md");
-  return fs21.existsSync(f) ? fs21.readFileSync(f, "utf8").trim() : archivedRun(meta.id)?.answer ?? "";
+  return fs23.existsSync(f) ? fs23.readFileSync(f, "utf8").trim() : archivedRun(meta.id)?.answer ?? "";
 }
 function formatReport(meta, finalText = readSummary(meta), maxLines = 400) {
   const out = [];
@@ -3497,8 +4013,8 @@ function formatReport(meta, finalText = readSummary(meta), maxLines = 400) {
 }
 function live(meta) {
   const f = runFile(meta.id, "events.jsonl");
-  if (!fs21.existsSync(f)) return { steps: 0, toolCalls: 0 };
-  const p = getBackend((meta.ran ?? meta.worker).backend).parse(fs21.readFileSync(f, "utf8"));
+  if (!fs23.existsSync(f)) return { steps: 0, toolCalls: 0 };
+  const p = getBackend((meta.ran ?? meta.worker).backend).parse(fs23.readFileSync(f, "utf8"));
   return { steps: p.usage.steps, toolCalls: p.usage.toolCalls, last: p.lastActivity };
 }
 function progress(meta) {
@@ -3518,21 +4034,33 @@ function groupIds(group) {
     }
   });
 }
-var oneLine5 = (s, max) => {
+var retryShell = (platform = process.platform) => platform === "win32" ? "powershell" : "sh";
+var quoteFor = (shell) => (s) => /^[\w./:@=\\-]+$/.test(s) && !(shell === "sh" && s.includes("\\")) ? s : shell === "sh" ? `'${s.replace(/'/g, `'\\''`)}'` : `'${s.replace(/'/g, "''")}'`;
+function retryCommands(metas, shell = retryShell()) {
+  const quote = quoteFor(shell);
+  return metas.filter((m) => ["failed", "timeout", "stopped"].includes(m.state) && !m.auditOf && !m.reviewOf && !m.parent && !m.fixOf).map((m) => {
+    const where = ["-d", quote(m.dir), ...m.group ? ["-g", quote(m.group)] : []];
+    if (m.plan) return ["pitroom run", m.mode === "write" ? "-w" : "-i", "--plan", quote(m.plan.file), "--step", String(m.plan.step), ...where, "--bg"].join(" ");
+    const mode = m.mode === "isolate" ? ["-i"] : m.mode === "write" ? ["-w"] : [];
+    const end = shell === "sh" || m.task.startsWith("-") ? ["--"] : [];
+    return ["pitroom run", ...mode, ...where, "--bg", ...end, quote(m.task)].join(" ");
+  });
+}
+var oneLine6 = (s, max) => {
   const t = s.replace(/\s+/g, " ").trim();
   return t.length > max ? `${t.slice(0, max - 1)}\u2026` : t;
 };
 function headline(meta, max = 160) {
   const text = readSummary(meta);
   const line = text.split("\n").find((l) => /^SUMMARY:/i.test(l.trim())) ?? text.split("\n").find((l) => l.trim()) ?? "";
-  return oneLine5(line.replace(/^SUMMARY:\s*/i, ""), max);
+  return oneLine6(line.replace(/^SUMMARY:\s*/i, ""), max);
 }
 function table(metas) {
   if (!metas.length) return "no runs";
   const rows = metas.map((m) => {
     const l = m.state === "running" ? live(m) : void 0;
     const steps = l ? String(l.steps) : m.usage ? String(m.usage.steps) : "-";
-    const note = l?.last ? oneLine5(l.last, 48) : isActive(m.state) ? oneLine5(m.task, 48) : headline(m, 48) || oneLine5(m.error ?? m.task, 48);
+    const note = l?.last ? oneLine6(l.last, 48) : isActive(m.state) ? oneLine6(m.task, 48) : headline(m, 48) || oneLine6(m.error ?? m.task, 48);
     return [m.id, m.state, m.mode, duration(m), steps, describeTarget(m.ran ?? m.worker), note];
   });
   const head = ["RUN", "STATE", "MODE", "TIME", "STEPS", "WORKER", "NOW / RESULT"];
@@ -3574,15 +4102,15 @@ async function watch(select, opts) {
         const prev = seen.get(m.id);
         const l = m.state === "running" ? live(m) : { steps: m.usage?.steps ?? 0, toolCalls: m.usage?.toolCalls ?? 0 };
         const attempts = m.attempts?.length ?? 0;
-        const base2 = { run: m.id, mode: m.mode, task: oneLine5(m.task, 60) };
+        const base2 = { run: m.id, mode: m.mode, task: oneLine6(m.task, 60) };
         if (!prev) emit({ event: m.state === "queued" ? "queued" : "started", ...base2 }, m);
         else if (prev.state === "queued" && m.state === "running") emit({ event: "started", ...base2 }, m);
         if (attempts > (prev?.attempts ?? 0)) {
           const a = m.attempts[attempts - 1];
-          emit({ event: "fallback", run: m.id, failed: a.target, reason: oneLine5(a.error, 120) }, m);
+          emit({ event: "fallback", run: m.id, failed: a.target, reason: oneLine6(a.error, 120) }, m);
         }
         if (m.state === "running" && l.steps > (prev?.steps ?? 0)) {
-          emit({ event: "progress", run: m.id, steps: l.steps, tools: l.toolCalls, last: "last" in l && l.last ? oneLine5(String(l.last), 80) : void 0 });
+          emit({ event: "progress", run: m.id, steps: l.steps, tools: l.toolCalls, last: "last" in l && l.last ? oneLine6(String(l.last), 80) : void 0 });
         }
         if (TERMINAL.includes(m.state) && prev?.state !== m.state) {
           emit({
@@ -3591,7 +4119,7 @@ async function watch(select, opts) {
             time: duration(m),
             worker: describeTarget(m.ran ?? m.worker),
             summary: headline(m) || void 0,
-            error: m.error ? oneLine5(m.error, 160) : void 0,
+            error: m.error ? oneLine6(m.error, 160) : void 0,
             refs: m.refs ? `${m.refs.valid}/${m.refs.total}` : void 0,
             changes: m.changes?.length || void 0
           }, m);
@@ -3658,12 +4186,12 @@ function claimGroup(group) {
   try {
     const ids = groupIds(group).sort();
     if (ids.length < 2) return true;
-    const dir = path18.join(home(), "notified");
-    fs22.mkdirSync(dir, { recursive: true });
-    for (const f of fs22.readdirSync(dir)) {
-      if (Date.now() - fs22.statSync(path18.join(dir, f)).mtimeMs > 30 * 864e5) fs22.rmSync(path18.join(dir, f), { force: true });
+    const dir = path20.join(home(), "notified");
+    fs24.mkdirSync(dir, { recursive: true });
+    for (const f of fs24.readdirSync(dir)) {
+      if (Date.now() - fs24.statSync(path20.join(dir, f)).mtimeMs > 30 * 864e5) fs24.rmSync(path20.join(dir, f), { force: true });
     }
-    fs22.writeFileSync(path18.join(dir, crypto5.createHash("sha1").update(ids.join(",")).digest("hex").slice(0, 16)), "", { flag: "wx" });
+    fs24.writeFileSync(path20.join(dir, crypto5.createHash("sha1").update(ids.join(",")).digest("hex").slice(0, 16)), "", { flag: "wx" });
     return true;
   } catch {
     return false;
@@ -3697,30 +4225,30 @@ function notifyEnded(meta) {
 }
 
 // src/core/templates.ts
-import fs24 from "node:fs";
-import path20 from "node:path";
+import fs26 from "node:fs";
+import path22 from "node:path";
 
 // src/core/install.ts
-import fs23 from "node:fs";
-import os9 from "node:os";
-import path19 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import fs25 from "node:fs";
+import os10 from "node:os";
+import path21 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 var LEGACY = ["pitroom", "opencode-worker"];
 function packageRoot() {
-  return path19.resolve(path19.dirname(fileURLToPath2(import.meta.url)), "..");
+  return path21.resolve(path21.dirname(fileURLToPath3(import.meta.url)), "..");
 }
 function skillNames(root = packageRoot()) {
-  const dir = path19.join(root, "skills");
-  if (!fs23.existsSync(dir)) return [];
-  return fs23.readdirSync(dir).filter((d) => fs23.existsSync(path19.join(dir, d, "SKILL.md"))).sort();
+  const dir = path21.join(root, "skills");
+  if (!fs25.existsSync(dir)) return [];
+  return fs25.readdirSync(dir).filter((d) => fs25.existsSync(path21.join(dir, d, "SKILL.md"))).sort();
 }
 function skillTargets() {
-  const home3 = os9.homedir();
-  const targets = [path19.join(home3, ".agents", "skills")];
-  if (fs23.existsSync(path19.join(home3, ".claude"))) targets.push(path19.join(home3, ".claude", "skills"));
+  const home3 = os10.homedir();
+  const targets = [path21.join(home3, ".agents", "skills")];
+  if (fs25.existsSync(path21.join(home3, ".claude"))) targets.push(path21.join(home3, ".claude", "skills"));
   return targets;
 }
-var launcherPath = () => path19.join(os9.homedir(), ".local", "bin", process.platform === "win32" ? "pitroom.cmd" : "pitroom");
+var launcherPath = () => path21.join(os10.homedir(), ".local", "bin", process.platform === "win32" ? "pitroom.cmd" : "pitroom");
 var LAUNCHER_MARK = "# pitroom launcher";
 function launcherScript(bundle) {
   if (process.platform === "win32") {
@@ -3750,7 +4278,7 @@ exit 127
 function isOurLauncher(file2, root) {
   if (linksInto(file2, root)) return true;
   try {
-    const s = fs23.readFileSync(file2, "utf8");
+    const s = fs25.readFileSync(file2, "utf8");
     return s.includes(LAUNCHER_MARK) && s.includes(root);
   } catch {
     return false;
@@ -3758,64 +4286,64 @@ function isOurLauncher(file2, root) {
 }
 function isPitroomLauncher(file2) {
   try {
-    return fs23.readFileSync(file2, "utf8").includes(LAUNCHER_MARK);
+    return fs25.readFileSync(file2, "utf8").includes(LAUNCHER_MARK);
   } catch {
     return false;
   }
 }
 function placeLauncher(bundle, root, force) {
   const dest = launcherPath();
-  fs23.mkdirSync(path19.dirname(dest), { recursive: true });
-  const exists = fs23.lstatSync(dest, { throwIfNoEntry: false });
+  fs25.mkdirSync(path21.dirname(dest), { recursive: true });
+  const exists = fs25.lstatSync(dest, { throwIfNoEntry: false });
   if (exists && !isOurLauncher(dest, root)) {
     if (!force) return `! ${dest} exists and is not Pitroom's launcher; kept (use --force to back it up and replace)`;
-    fs23.renameSync(dest, `${dest}.bak-${Date.now()}`);
+    fs25.renameSync(dest, `${dest}.bak-${Date.now()}`);
   } else if (exists) {
-    fs23.rmSync(dest, { force: true });
+    fs25.rmSync(dest, { force: true });
   }
-  fs23.writeFileSync(dest, launcherScript(bundle), { mode: 493 });
+  fs25.writeFileSync(dest, launcherScript(bundle), { mode: 493 });
   return `\u2714 ${dest} \u2192 launcher for ${bundle} (Node 22.13+)`;
 }
 function linksInto(link, dir) {
-  const st = fs23.lstatSync(link, { throwIfNoEntry: false });
+  const st = fs25.lstatSync(link, { throwIfNoEntry: false });
   if (!st?.isSymbolicLink()) return false;
-  const target = path19.resolve(path19.dirname(link), fs23.readlinkSync(link));
-  const rel = path19.relative(dir, target);
-  return !rel.startsWith("..") && !path19.isAbsolute(rel);
+  const target = path21.resolve(path21.dirname(link), fs25.readlinkSync(link));
+  const rel = path21.relative(dir, target);
+  return !rel.startsWith("..") && !path21.isAbsolute(rel);
 }
 function place(src, dest, opts) {
-  fs23.mkdirSync(path19.dirname(dest), { recursive: true });
-  const st = fs23.lstatSync(dest, { throwIfNoEntry: false });
+  fs25.mkdirSync(path21.dirname(dest), { recursive: true });
+  const st = fs25.lstatSync(dest, { throwIfNoEntry: false });
   if (st && !st.isSymbolicLink()) {
     if (!opts.force) return `! ${dest} exists and is not a link; kept (use --force to back it up and replace)`;
-    fs23.renameSync(dest, `${dest}.bak-${Date.now()}`);
+    fs25.renameSync(dest, `${dest}.bak-${Date.now()}`);
   } else if (st) {
-    fs23.unlinkSync(dest);
+    fs25.unlinkSync(dest);
   }
-  if (opts.copy) fs23.cpSync(src, dest, { recursive: true });
-  else fs23.symlinkSync(src, dest, process.platform === "win32" ? "junction" : fs23.statSync(src).isDirectory() ? "dir" : "file");
+  if (opts.copy) fs25.cpSync(src, dest, { recursive: true });
+  else fs25.symlinkSync(src, dest, process.platform === "win32" ? "junction" : fs25.statSync(src).isDirectory() ? "dir" : "file");
   return `\u2714 ${dest} \u2192 ${opts.copy ? "copied" : src}`;
 }
 function install(opts) {
   const root = packageRoot();
   const skills2 = opts.skills === false ? [] : skillNames(root);
-  if (opts.skills !== false && !skills2.length) throw new Error(`no skills found under ${path19.join(root, "skills")}`);
+  if (opts.skills !== false && !skills2.length) throw new Error(`no skills found under ${path21.join(root, "skills")}`);
   const out = [];
   for (const base2 of opts.skills === false ? [] : skillTargets()) {
     for (const legacy of LEGACY) {
-      const l = path19.join(base2, legacy);
+      const l = path21.join(base2, legacy);
       if (!skills2.includes(legacy) && linksInto(l, root)) {
-        fs23.unlinkSync(l);
+        fs25.unlinkSync(l);
         out.push(`\u2714 removed old link ${l}`);
       }
     }
-    for (const name of skills2) out.push(place(path19.join(root, "skills", name), path19.join(base2, name), opts));
+    for (const name of skills2) out.push(place(path21.join(root, "skills", name), path21.join(base2, name), opts));
   }
-  const bundle = path19.join(root, "dist", "pitroom.mjs");
-  if (fs23.existsSync(bundle)) {
+  const bundle = path21.join(root, "dist", "pitroom.mjs");
+  if (fs25.existsSync(bundle)) {
     out.push(placeLauncher(bundle, root, opts.force));
-    const onPath = (process.env.PATH ?? "").split(path19.delimiter).some((d) => path19.resolve(d) === path19.dirname(launcherPath()));
-    if (!onPath) out.push(`! ${path19.dirname(launcherPath())} is not on PATH; add it, or run ${launcherPath()} directly`);
+    const onPath = (process.env.PATH ?? "").split(path21.delimiter).some((d) => path21.resolve(d) === path21.dirname(launcherPath()));
+    if (!onPath) out.push(`! ${path21.dirname(launcherPath())} is not on PATH; add it, or run ${launcherPath()} directly`);
   }
   return out;
 }
@@ -3823,24 +4351,24 @@ function uninstall() {
   const root = packageRoot();
   const out = [];
   for (const base2 of skillTargets()) {
-    if (!fs23.existsSync(base2)) continue;
-    for (const name of fs23.readdirSync(base2)) {
-      const l = path19.join(base2, name);
+    if (!fs25.existsSync(base2)) continue;
+    for (const name of fs25.readdirSync(base2)) {
+      const l = path21.join(base2, name);
       if (linksInto(l, root)) {
-        fs23.unlinkSync(l);
+        fs25.unlinkSync(l);
         out.push(`\u2714 removed ${l}`);
       }
     }
   }
   if (isOurLauncher(launcherPath(), root)) {
-    fs23.rmSync(launcherPath(), { force: true });
+    fs25.rmSync(launcherPath(), { force: true });
     out.push(`\u2714 removed ${launcherPath()}`);
   }
   return out.length ? out : ["nothing to remove"];
 }
 function installedSkills() {
   const names = skillNames();
-  return skillTargets().map((base2) => ({ base: base2, names: names.filter((n) => fs23.existsSync(path19.join(base2, n, "SKILL.md"))) }));
+  return skillTargets().map((base2) => ({ base: base2, names: names.filter((n) => fs25.existsSync(path21.join(base2, n, "SKILL.md"))) }));
 }
 
 // src/core/templates.ts
@@ -3851,9 +4379,9 @@ var FILES = {
   "code-reviewer": "pitroom-review/code-reviewer.md"
 };
 function loadTemplate(name, root = packageRoot()) {
-  const file2 = path20.join(root, "skills", FILES[name]);
-  if (!fs24.existsSync(file2)) throw new UserError(`template missing: ${file2} (broken install? run pitroom doctor)`, 3);
-  return fs24.readFileSync(file2, "utf8").replace(/^\s*<!--[\s\S]*?-->\s*/, "");
+  const file2 = path22.join(root, "skills", FILES[name]);
+  if (!fs26.existsSync(file2)) throw new UserError(`template missing: ${file2} (broken install? run pitroom doctor)`, 3);
+  return fs26.readFileSync(file2, "utf8").replace(/^\s*<!--[\s\S]*?-->\s*/, "");
 }
 function fill(template, values) {
   const missing = [...template.matchAll(/\{\{([A-Z_]+)\}\}/g)].map((m) => m[1]).filter((k) => !(k in values));
@@ -3863,10 +4391,10 @@ function fill(template, values) {
 
 // src/core/slots.ts
 import crypto6 from "node:crypto";
-import fs25 from "node:fs";
-import path21 from "node:path";
-var slotsDir = () => path21.join(home(), "slots");
-var locksDir = () => path21.join(home(), "locks");
+import fs27 from "node:fs";
+import path23 from "node:path";
+var slotsDir = () => path23.join(home(), "slots");
+var locksDir = () => path23.join(home(), "locks");
 var STARTUP_GRACE_MS = 3e4;
 function holderActive(runId, self) {
   if (!runId || runId === self) return false;
@@ -3880,23 +4408,23 @@ function holderActive(runId, self) {
   }
 }
 function tryClaim(file2, runId) {
-  fs25.mkdirSync(path21.dirname(file2), { recursive: true });
+  fs27.mkdirSync(path23.dirname(file2), { recursive: true });
   try {
-    fs25.writeFileSync(file2, runId, { flag: "wx" });
+    fs27.writeFileSync(file2, runId, { flag: "wx" });
     return true;
   } catch (e) {
     if (e.code !== "EEXIST") throw e;
   }
   let owner = "";
   try {
-    owner = fs25.readFileSync(file2, "utf8").trim();
+    owner = fs27.readFileSync(file2, "utf8").trim();
   } catch {
   }
   if (owner === runId) return true;
   if (holderActive(owner, runId)) return false;
-  fs25.rmSync(file2, { force: true });
+  fs27.rmSync(file2, { force: true });
   try {
-    fs25.writeFileSync(file2, runId, { flag: "wx" });
+    fs27.writeFileSync(file2, runId, { flag: "wx" });
     return true;
   } catch {
     return false;
@@ -3905,25 +4433,25 @@ function tryClaim(file2, runId) {
 function releaseIfOwner(file2, runId) {
   if (!file2) return;
   try {
-    if (fs25.readFileSync(file2, "utf8").trim() === runId) fs25.rmSync(file2, { force: true });
+    if (fs27.readFileSync(file2, "utf8").trim() === runId) fs27.rmSync(file2, { force: true });
   } catch {
   }
 }
 function tryAcquireSlot(runId, maxParallel) {
   for (let n = 0; n < Math.max(1, maxParallel); n++) {
-    const file2 = path21.join(slotsDir(), `slot-${n}`);
+    const file2 = path23.join(slotsDir(), `slot-${n}`);
     if (tryClaim(file2, runId)) return file2;
   }
   return void 0;
 }
 var releaseSlot = (file2, runId) => releaseIfOwner(file2, runId);
-var lockFile = (repoRoot2) => path21.join(locksDir(), `write-${crypto6.createHash("sha1").update(path21.resolve(repoRoot2)).digest("hex").slice(0, 16)}`);
+var lockFile = (repoRoot2) => path23.join(locksDir(), `write-${crypto6.createHash("sha1").update(path23.resolve(repoRoot2)).digest("hex").slice(0, 16)}`);
 function acquireWriteLock(repoRoot2, runId) {
   const file2 = lockFile(repoRoot2);
   if (tryClaim(file2, runId)) return;
   let owner = "";
   try {
-    owner = fs25.readFileSync(file2, "utf8").trim();
+    owner = fs27.readFileSync(file2, "utf8").trim();
   } catch {
   }
   throw new UserError(`another --write run (${owner}) is active in this repo; use --isolate for parallel changes`, 3);
@@ -3943,35 +4471,38 @@ var RULES = {
     "Run the relevant tests, type checks or linters if they are cheap and available, and report the result."
   ]
 };
-function buildPrompt(mode, task, followUp) {
+var COMPLETE = "When the task asks for all of something, a list or a count: search the whole scope (e.g. a project-wide grep) instead of stopping at the first hits, give the complete list or the exact count, and say how you found it. If you could not cover everything, say what is left out under OPEN ISSUES.";
+function buildPrompt(mode, task, followUp, audit = false) {
   if (followUp) return `Follow-up from the primary agent. Same rules and answer format as before.
 
 ${task}`;
+  const rules = mode === "read" && !audit ? [...RULES[mode], COMPLETE] : RULES[mode];
+  const economy = audit ? "" : "\n- Be economical: open only what you need, but do not cut a search short when the task asks for a complete list or a count.";
+  const format = audit ? "End with the reply form the task gives, and nothing else." : `End with this answer format (plain text, no preamble):
+SUMMARY: 1-5 lines that directly answer the task.
+DETAILS: key findings with file:line references; only what the primary agent needs, but a list or count the task asks for goes here in full.
+FILES CHANGED: paths, or "none".
+VERIFICATION: commands you ran (searches included) and their results, or "not run".
+OPEN ISSUES: risks, uncertainties, follow-ups, or "none".`;
   return `You are a worker agent. A primary coding agent delegated this bounded task to you. Your answer is draft work that the primary agent will verify, and it is the only thing the primary sees, so make it self-contained.
 
 Rules:
-- ${RULES[mode].join("\n- ")}
+- ${rules.join("\n- ")}
 - Stay inside the task scope and the project directory.
 - Never commit, push, reset, checkout, restore, stash, clean, rebase or merge, and never discard or overwrite uncommitted work you did not create.
 - Never read or reveal secrets (.env files, keys, tokens).
 - Delete a file only when the task explicitly asks for it, and name every file you delete under FILES CHANGED. Whether anything else should be deleted or overwritten is the primary agent's decision: propose it under OPEN ISSUES and leave the file alone.
-- Do not ask questions. If something is ambiguous, choose the safest reasonable interpretation and state the assumption.
-- Be economical: open only what you need.
+- Do not ask questions. If something is ambiguous, choose the safest reasonable interpretation and state the assumption.${economy}
 
-End with this answer format (plain text, no preamble):
-SUMMARY: 1-5 lines that directly answer the task.
-DETAILS: key findings with file:line references; only what the primary agent needs.
-FILES CHANGED: paths, or "none".
-VERIFICATION: commands you ran and their results, or "not run".
-OPEN ISSUES: risks, uncertainties, follow-ups, or "none".
+${format}
 
 Task:
 ${task}`;
 }
 
 // src/core/refs.ts
-import fs26 from "node:fs";
-import path22 from "node:path";
+import fs28 from "node:fs";
+import path24 from "node:path";
 var FILE_EXTENSIONS = new Set(
   "ts tsx mts cts js jsx mjs cjs json jsonc json5 md mdx txt rst py pyi rb go rs java kt kts swift c h cc cpp cxx hpp hh cs fs php lua r jl sh bash zsh fish ps1 bat yml yaml toml ini cfg conf env html htm css scss sass less vue svelte astro sql graphql gql proto lock xml svg csv tsv gradle tf hcl dart ex exs erl hs ml scala clj vim el mk cmake dockerfile gitignore gitattributes editorconfig npmrc nvmrc".split(" ")
 );
@@ -4022,13 +4553,13 @@ function extractRefs(answer) {
   return [...seen.values()];
 }
 function verifyRefs(refs, dirs) {
-  const roots = [...new Set(dirs.filter(Boolean).map((d) => path22.resolve(d)))];
+  const roots = [...new Set(dirs.filter(Boolean).map((d) => path24.resolve(d)))];
   const invalid = [];
   const lineCache = /* @__PURE__ */ new Map();
   const load = (file2) => {
     if (!lineCache.has(file2)) {
-      const size = fs26.statSync(file2).size;
-      const lines = size > MAX_BYTES ? null : fs26.readFileSync(file2, "utf8").split("\n");
+      const size = fs28.statSync(file2).size;
+      const lines = size > MAX_BYTES ? null : fs28.readFileSync(file2, "utf8").split("\n");
       if (lines && lines[lines.length - 1] === "") lines.pop();
       lineCache.set(file2, lines);
     }
@@ -4039,9 +4570,9 @@ function verifyRefs(refs, dirs) {
   const candidates = (ref) => {
     const direct = resolve(ref.file, roots);
     if (direct) return [direct];
-    if (path22.isAbsolute(ref.file)) return [];
+    if (path24.isAbsolute(ref.file)) return [];
     const wanted = ref.file.replace(/^(\.{1,2}\/)+/, "");
-    return (byName().get(path22.basename(wanted)) ?? []).filter((f) => f.split(path22.sep).join("/").endsWith(`/${wanted}`) || path22.basename(f) === wanted).slice(0, 20);
+    return (byName().get(path24.basename(wanted)) ?? []).filter((f) => f.split(path24.sep).join("/").endsWith(`/${wanted}`) || path24.basename(f) === wanted).slice(0, 20);
   };
   const check = (file2, ref) => {
     const lines = load(file2);
@@ -4056,7 +4587,7 @@ function verifyRefs(refs, dirs) {
     if (!files.length) {
       if (!ref.file.includes("/") && !isFileName(ref.file)) continue;
       total++;
-      invalid.push({ ref: ref.text, reason: path22.isAbsolute(ref.file) && !inside(ref.file, roots) ? "outside the project" : "file not found" });
+      invalid.push({ ref: ref.text, reason: path24.isAbsolute(ref.file) && !inside(ref.file, roots) ? "outside the project" : "file not found" });
       continue;
     }
     total++;
@@ -4077,7 +4608,7 @@ function enclosedBy(lines, ref) {
   return lines.slice(Math.max(0, ref.start - 1 - DEFINITION_LOOKBACK), ref.start).some((l) => def.test(l));
 }
 var isFileName = (name) => {
-  const base2 = path22.basename(name);
+  const base2 = path24.basename(name);
   return !base2.includes(".") || new RegExp(`^(${EXTENSIONLESS})$`).test(base2) || FILE_EXTENSIONS.has(base2.split(".").pop().toLowerCase());
 };
 function indexFiles(roots) {
@@ -4086,19 +4617,19 @@ function indexFiles(roots) {
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs26.readdirSync(dir, { withFileTypes: true });
+      entries = fs28.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (count >= MAX_INDEXED) return;
       if (e.isDirectory()) {
-        if (!SKIP_DIRS2.has(e.name)) walk(path22.join(dir, e.name));
+        if (!SKIP_DIRS2.has(e.name)) walk(path24.join(dir, e.name));
       } else if (e.isFile()) {
         count++;
         const list2 = index.get(e.name);
-        if (list2) list2.push(path22.join(dir, e.name));
-        else index.set(e.name, [path22.join(dir, e.name)]);
+        if (list2) list2.push(path24.join(dir, e.name));
+        else index.set(e.name, [path24.join(dir, e.name)]);
       }
     }
   };
@@ -4106,10 +4637,10 @@ function indexFiles(roots) {
   return index;
 }
 function resolve(ref, roots) {
-  const candidates = path22.isAbsolute(ref) ? inside(ref, roots) ? [ref] : [] : roots.map((r) => path22.join(r, ref));
+  const candidates = path24.isAbsolute(ref) ? inside(ref, roots) ? [ref] : [] : roots.map((r) => path24.join(r, ref));
   return candidates.find((c) => {
     try {
-      return fs26.statSync(c).isFile() && inside(c, roots);
+      return fs28.statSync(c).isFile() && inside(c, roots);
     } catch {
       return false;
     }
@@ -4117,14 +4648,14 @@ function resolve(ref, roots) {
 }
 function inside(file2, roots) {
   return roots.some((r) => {
-    const rel = path22.relative(r, path22.resolve(file2));
-    return rel !== "" && !rel.startsWith("..") && !path22.isAbsolute(rel);
+    const rel = path24.relative(r, path24.resolve(file2));
+    return rel !== "" && !rel.startsWith("..") && !path24.isAbsolute(rel);
   });
 }
 var escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 
 // src/core/run.ts
-var VERSION2 = true ? "0.22.0" : "0.0.0-dev";
+var VERSION2 = true ? "0.23.0" : "0.0.0-dev";
 function planWork(o) {
   if (!o.plan) return { task: o.task.trim(), tier: o.tier };
   if (o.continueFrom) throw new UserError("a follow-up continues its parent's task; drop --plan/--step");
@@ -4156,7 +4687,7 @@ function prepareRun(o) {
     parent = readMeta(o.continueFrom);
     if (o.worker || o.tier || o.effort) throw new UserError("a follow-up runs on the same worker as its parent; drop --worker/--tier/--effort");
     if (!parent.sessionId) throw new UserError(`run ${parent.id} has no worker session to continue`, 3);
-    if (parent.mode === "isolate" && (!parent.worktree || !fs27.existsSync(parent.worktree))) {
+    if (parent.mode === "isolate" && (!parent.worktree || !fs29.existsSync(parent.worktree))) {
       throw new UserError(`the isolated copy of run ${parent.id} is gone (applied or discarded)`, 3);
     }
     const ran = parent.ran ?? parent.worker;
@@ -4166,7 +4697,16 @@ function prepareRun(o) {
     const chain = resolveChain({ worker: o.worker, model: o.model, tier: work.tier, effort: o.effort, noFallback: o.noFallback });
     ({ worker, fallback } = chain);
     warnings.push(...chain.warnings);
+    if (effective().rankWorkers.value && !o.worker && !o.model && !work.tier && fallback.length) {
+      const since2 = Date.now() - 30 * 864e5;
+      const ranked = rankChain([worker, ...fallback], (t) => workerRecord(t.backend, t.model, since2));
+      [worker, ...fallback] = ranked.chain;
+      if (ranked.note) warnings.push(ranked.note);
+    }
   }
+  const budget = withinBudget([worker, ...fallback]);
+  [worker, ...fallback] = budget.chain;
+  if (budget.warning) warnings.push(budget.warning);
   const backend = getBackend(worker.backend);
   if (parent && backend.capabilities.resume === "none") {
     throw new UserError(`the ${backend.name} worker cannot continue sessions`, 3);
@@ -4175,18 +4715,18 @@ function prepareRun(o) {
     throw new UserError(`the ${backend.name} worker cannot attach files; put the content in the task`);
   }
   const mode = parent?.mode ?? o.mode;
-  const dir = canonical(path23.resolve(parent?.dir ?? o.dir));
-  if (!fs27.existsSync(dir) || !fs27.statSync(dir).isDirectory()) throw new UserError(`not a directory: ${dir}`);
+  const dir = canonical(path25.resolve(parent?.dir ?? o.dir));
+  if (!fs29.existsSync(dir) || !fs29.statSync(dir).isDirectory()) throw new UserError(`not a directory: ${dir}`);
   const root = repoRoot(dir);
   if (mode === "isolate" && !root) throw new UserError("--isolate needs a git repository", 3);
   if (mode === "write" && !root && !o.allowNonGit) {
     throw new UserError("--write outside a git repo cannot be tracked or reverted; pass --allow-non-git to accept that", 3);
   }
-  const files = o.files.map((f) => path23.resolve(f));
-  for (const f of files) if (!fs27.existsSync(f)) throw new UserError(`file not found: ${f}`);
+  const files = o.files.map((f) => path25.resolve(f));
+  for (const f of files) if (!fs29.existsSync(f)) throw new UserError(`file not found: ${f}`);
   const readIn2 = READ_IN.includes(effective().readIn.value) ? effective().readIn.value : "auto";
   const snap = mode === "read" && !o.review && !o.inPlace && !parent ? wantSnapshot(readIn2, root, dir) : void 0;
-  if (parent?.snapshot?.dir && !fs27.existsSync(parent.snapshot.dir)) {
+  if (parent?.snapshot?.dir && !fs29.existsSync(parent.snapshot.dir)) {
     throw new UserError(`the read snapshot of run ${parent.id} is gone (cleaned up); ask the question again as a new run`, 3);
   }
   if (!parent && !snap && !process.env.PITROOM_NO_SECRET_WARNING) {
@@ -4220,6 +4760,7 @@ function prepareRun(o) {
     worktree: parent?.mode === "isolate" ? parent.worktree : void 0,
     reviewOf: o.review?.of,
     auditOf: o.audit?.of,
+    fixOf: o.fix?.of,
     auditRate: o.auditRate,
     inPlace: o.inPlace || void 0,
     cache: o.cache,
@@ -4233,13 +4774,13 @@ function prepareRun(o) {
     try {
       acquireWriteLock(root, meta.id);
     } catch (e) {
-      fs27.rmSync(runDir(meta.id), { recursive: true, force: true });
+      fs29.rmSync(runDir(meta.id), { recursive: true, force: true });
       throw e;
     }
   }
-  fs27.writeFileSync(runFile(meta.id, "task.md"), `${meta.task}
+  fs29.writeFileSync(runFile(meta.id, "task.md"), `${meta.task}
 `);
-  if (work.brief) fs27.writeFileSync(runFile(meta.id, "brief.md"), work.brief);
+  if (work.brief) fs29.writeFileSync(runFile(meta.id, "brief.md"), work.brief);
   return meta;
 }
 var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -4321,7 +4862,7 @@ async function execute(meta) {
       (meta.attempts ??= []).push({ target: describeTarget(target), error: why.message });
       for (const f of ["events.jsonl", "stderr.log"]) {
         const from = runFile(meta.id, f);
-        if (fs27.existsSync(from)) fs27.renameSync(from, runFile(meta.id, f.replace(".", `.attempt-${i + 1}.`)));
+        if (fs29.existsSync(from)) fs29.renameSync(from, runFile(meta.id, f.replace(".", `.attempt-${i + 1}.`)));
       }
       writeMeta(meta);
     }
@@ -4340,7 +4881,18 @@ async function execute(meta) {
 }
 function autoAudit(meta) {
   try {
-    if (!auditable(meta, read2(runFile(meta.id, "summary.md"))) || !sampled(meta)) return;
+    if (!auditable(meta, read2(runFile(meta.id, "summary.md")))) return;
+    let rate2 = auditRate(meta);
+    if (meta.auditRate === void 0 && effective().auditFocus.value) {
+      const ran = meta.ran ?? meta.worker;
+      const focus = focusedRate(rate2, meta.task, workerRecord(ran.backend, meta.resolvedModel ?? ran.model, Date.now() - 30 * 864e5));
+      rate2 = focus.rate;
+      if (focus.why.length) {
+        meta.auditFocus = { rate: rate2, why: focus.why };
+        writeMeta(meta);
+      }
+    }
+    if (!sampled(meta, rate2)) return;
     startAudit(meta);
   } catch {
   }
@@ -4374,6 +4926,30 @@ function settleAudit(a) {
     const target = readMeta(a.auditOf);
     target.audit = { id: a.id, state: a.state, verdict: a.state === "done" ? a.auditVerdict : void 0, disputed: a.state === "done" ? a.auditDisputed : void 0 };
     writeMeta(target);
+    startFix(target);
+  } catch {
+  }
+}
+function startFix(target) {
+  try {
+    const ran = target.ran ?? target.worker;
+    if (!wantsFix(target, getBackend(ran.backend).capabilities.resume !== "none")) return;
+    const f = prepareRun({
+      mode: target.mode,
+      task: fixTask(target.audit.disputed),
+      dir: target.dir,
+      files: [],
+      link: [],
+      timeoutSec: target.timeoutSec,
+      continueFrom: target.id,
+      allowNonGit: true,
+      web: false,
+      noFallback: false,
+      fix: { of: target.id }
+    });
+    target.audit = { ...target.audit, fix: f.id };
+    writeMeta(target);
+    startInBackground(f);
   } catch {
   }
 }
@@ -4385,8 +4961,8 @@ function prepareTree(meta) {
       const s = readSnapshot(root);
       meta.snapshot.dir = s.dir;
       meta.snapshot.tree = s.tree;
-      meta.cwd = path23.join(s.dir, path23.relative(root, meta.dir));
-      if (!fs27.existsSync(meta.cwd)) meta.cwd = s.dir;
+      meta.cwd = path25.join(s.dir, path25.relative(root, meta.dir));
+      if (!fs29.existsSync(meta.cwd)) meta.cwd = s.dir;
       if (shown) meta.warnings.push(`read in a clean snapshot of your project: the secret-looking files (${shown}) and git-ignored files are not in it; --in-place reads the directory itself`);
     } catch (e) {
       meta.snapshot = void 0;
@@ -4396,9 +4972,9 @@ function prepareTree(meta) {
   if (root && meta.mode === "write") meta.baseTree = snapshotTree(root);
   if (root && meta.mode === "isolate" && !meta.worktree) {
     meta.baseTree = snapshotTree(root);
-    meta.worktree = path23.join(worktreesDir(), meta.id);
+    meta.worktree = path25.join(worktreesDir(), meta.id);
     createIsolatedCopy(root, meta.baseTree, meta.worktree);
-    meta.cwd = path23.join(meta.worktree, path23.relative(root, meta.dir));
+    meta.cwd = path25.join(meta.worktree, path25.relative(root, meta.dir));
     const linked = linkIntoWorktree(root, meta.worktree, meta.link);
     if (linked.length) meta.warnings.push(`linked into the isolated copy (shared with your tree): ${linked.join(", ")}`);
   }
@@ -4406,7 +4982,7 @@ function prepareTree(meta) {
 function attempt(meta, backend, target) {
   const inv = backend.invocation({
     mode: meta.mode,
-    prompt: buildPrompt(meta.mode, meta.task, !!meta.parent),
+    prompt: buildPrompt(meta.mode, meta.task, !!meta.parent, !!meta.auditOf),
     cwd: meta.cwd,
     model: target.model,
     sessionId: meta.sessionId,
@@ -4421,7 +4997,7 @@ function attempt(meta, backend, target) {
     timeoutSec: meta.timeoutSec
   });
 }
-var read2 = (f) => fs27.existsSync(f) ? fs27.readFileSync(f, "utf8") : "";
+var read2 = (f) => fs29.existsSync(f) ? fs29.readFileSync(f, "utf8") : "";
 function retryableFailure(meta, backend, res) {
   const run2 = backend.parse(read2(runFile(meta.id, "events.jsonl")));
   if (run2.usage.steps > 0) return void 0;
@@ -4441,12 +5017,12 @@ function finalize(meta, res) {
   if (meta.snapshot?.dir && meta.repoRoot) run2.finalText = backToProject(run2.finalText, meta.snapshot.dir, meta.repoRoot);
   meta.sessionId = run2.sessionId ?? meta.sessionId;
   meta.usage = run2.usage;
-  fs27.writeFileSync(runFile(meta.id, "summary.md"), `${run2.finalText}
+  fs29.writeFileSync(runFile(meta.id, "summary.md"), `${run2.finalText}
 `);
   if (meta.plan && !meta.reviewOf) meta.taskStatus = parseStatus(run2.finalText);
   if (meta.reviewOf) {
     meta.verdict = parseVerdict(run2.finalText);
-    if (meta.packageFile) fs27.rmSync(meta.packageFile, { force: true });
+    if (meta.packageFile) fs29.rmSync(meta.packageFile, { force: true });
   }
   if (!res.timedOut && !res.stopped && !meta.error) {
     const f = backend.failure(run2, read2(runFile(meta.id, "stderr.log")), res.code);
@@ -4506,16 +5082,16 @@ function captureChanges(meta) {
   const d = diffTrees(target, meta.baseTree, meta.afterTree);
   meta.changes = d.changes;
   meta.stats = d.stats;
-  fs27.writeFileSync(runFile(meta.id, "changes.patch"), d.patch);
+  fs29.writeFileSync(runFile(meta.id, "changes.patch"), d.patch);
 }
 function verifyPath() {
-  const extra = [path23.dirname(process.execPath), "/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"];
-  const parts = (process.env.PATH ?? "").split(path23.delimiter).filter(Boolean);
-  for (const d of process.platform === "win32" ? [path23.dirname(process.execPath)] : extra) if (!parts.includes(d)) parts.push(d);
-  return parts.join(path23.delimiter);
+  const extra = [path25.dirname(process.execPath), "/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"];
+  const parts = (process.env.PATH ?? "").split(path25.delimiter).filter(Boolean);
+  for (const d of process.platform === "win32" ? [path25.dirname(process.execPath)] : extra) if (!parts.includes(d)) parts.push(d);
+  return parts.join(path25.delimiter);
 }
 function runVerify(meta) {
-  const r = spawnSync6(meta.verify, {
+  const r = spawnSync8(meta.verify, {
     cwd: meta.cwd,
     shell: true,
     encoding: "utf8",
@@ -4525,7 +5101,7 @@ function runVerify(meta) {
     env: { ...process.env, PATH: verifyPath(), PWD: meta.cwd, PITROOM_ACTIVE: "1" }
   });
   const output = `${r.stdout ?? ""}${r.stderr ?? ""}`;
-  fs27.writeFileSync(runFile(meta.id, "verify.log"), output);
+  fs29.writeFileSync(runFile(meta.id, "verify.log"), output);
   const notFound = process.platform === "win32" && r.status === 1 && /is not recognized as an internal or external command/.test(output);
   return { ok: r.status === 0, code: notFound ? 127 : r.status, tail: output.trimEnd().split("\n").slice(-25).join("\n") };
 }
@@ -4580,12 +5156,12 @@ function discardRun(meta) {
   return `discarded the isolated copy of ${meta.id}; the patch stays in ${runFile(meta.id, "changes.patch")}`;
 }
 function cleanupWorktree(meta) {
-  if (meta.worktree && fs27.existsSync(meta.worktree)) removeIsolatedCopy(meta.worktree, worktreesDir());
+  if (meta.worktree && fs29.existsSync(meta.worktree)) removeIsolatedCopy(meta.worktree, worktreesDir());
 }
 
 // src/cli/mcp-extras.ts
-import fs28 from "node:fs";
-import path24 from "node:path";
+import fs30 from "node:fs";
+import path26 from "node:path";
 
 // src/cli/mcp-support.ts
 import { spawn as spawn5 } from "node:child_process";
@@ -4650,7 +5226,7 @@ function workerFlags(a, only) {
   return out;
 }
 var strip = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
-var clip6 = (s) => s.length > MAX_OUTPUT ? `${s.slice(0, MAX_OUTPUT)}
+var clip7 = (s) => s.length > MAX_OUTPUT ? `${s.slice(0, MAX_OUTPUT)}
 \u2026 (${s.length - MAX_OUTPUT} more characters)` : s;
 function pit(args, timeoutMs = 60 * 6e4, signal) {
   return new Promise((resolve2) => {
@@ -4675,10 +5251,10 @@ function pit(args, timeoutMs = 60 * 6e4, signal) {
 }
 function asResult(r, still) {
   const text = [r.out, r.err && r.code !== 0 ? r.err : ""].filter(Boolean).join("\n\n") || "(no output)";
-  if (r.code === 75 && still) return { text: clip6(`${text}
+  if (r.code === 75 && still) return { text: clip7(`${text}
 
 ${still}`) };
-  return { text: clip6(text), isError: r.code === 2 || r.code === 3 || r.code === 5 || r.code === 6 || r.code === 1 && !r.out };
+  return { text: clip7(text), isError: r.code === 2 || r.code === 3 || r.code === 5 || r.code === 6 || r.code === 1 && !r.out };
 }
 var plain = async (args, ctx, timeoutMs = 6e4) => asResult(await pit(args, timeoutMs, ctx.signal));
 function trackProgress(ctx, ids) {
@@ -4793,7 +5369,7 @@ var RpcError = class extends Error {
 var RUN = /^pitroom:\/\/run\/(\d{8}-\d{6}-[0-9a-f]{4})(\/patch)?$/;
 var LISTED = 30;
 var runOfUri = (uri) => RUN.exec(uri)?.[1];
-var oneLine6 = (text, n) => {
+var oneLine7 = (text, n) => {
   const flat = text.replace(/\s+/g, " ").trim();
   return flat.length > n ? `${flat.slice(0, n - 1)}\u2026` : flat;
 };
@@ -4803,8 +5379,8 @@ function listResources() {
     try {
       const m = freshMeta(id);
       const what2 = `${m.state} \xB7 ${m.mode} \xB7 ${m.worker.backend}${m.worker.model ? `:${m.worker.model.split("/").pop()}` : ""}`;
-      resources.push({ uri: `pitroom://run/${id}`, name: `run ${id}`, title: oneLine6(m.task, 70), description: `${what2}: the report`, mimeType: "text/plain" });
-      if (m.changes?.length) resources.push({ uri: `pitroom://run/${id}/patch`, name: `patch ${id}`, title: `Patch of ${oneLine6(m.task, 60)}`, description: `${what2}: the exact diff, ${m.changes.length} file(s)`, mimeType: "text/x-diff" });
+      resources.push({ uri: `pitroom://run/${id}`, name: `run ${id}`, title: oneLine7(m.task, 70), description: `${what2}: the report`, mimeType: "text/plain" });
+      if (m.changes?.length) resources.push({ uri: `pitroom://run/${id}/patch`, name: `patch ${id}`, title: `Patch of ${oneLine7(m.task, 60)}`, description: `${what2}: the exact diff, ${m.changes.length} file(s)`, mimeType: "text/x-diff" });
     } catch {
     }
   }
@@ -4822,7 +5398,7 @@ async function readResource(uri, ctx) {
   const patch = m[2] !== void 0;
   const r = await pit(["show", m[1], patch ? "--patch" : "--full"], 6e4, ctx.signal);
   if (r.code !== 0) throw new RpcError(r.code === 3 || r.code === 2 ? -32002 : -32603, r.err || r.out || `run ${m[1]} cannot be read`);
-  return { contents: [{ uri, mimeType: patch ? "text/x-diff" : "text/plain", text: clip6(r.out) }] };
+  return { contents: [{ uri, mimeType: patch ? "text/x-diff" : "text/plain", text: clip7(r.out) }] };
 }
 var PROMPTS = [
   {
@@ -4870,7 +5446,7 @@ function skillPrompts() {
   const root = packageRoot();
   for (const name of skillNames(root)) {
     try {
-      const text = fs28.readFileSync(path24.join(root, "skills", name, "SKILL.md"), "utf8");
+      const text = fs30.readFileSync(path26.join(root, "skills", name, "SKILL.md"), "utf8");
       const front = /^---\n([\s\S]*?)\n---\n/.exec(text);
       const body = (front ? text.slice(front[0].length) : text).trim();
       const description = /^description:\s*(.+)$/m.exec(front?.[1] ?? "")?.[1]?.trim() ?? `The ${name} skill.`;
@@ -5388,22 +5964,22 @@ async function serveMcp() {
 
 // src/cli/mcp-http.ts
 import crypto8 from "node:crypto";
-import fs30 from "node:fs";
+import fs32 from "node:fs";
 import http2 from "node:http";
-import path26 from "node:path";
+import path28 from "node:path";
 
 // src/core/dash.ts
 import { spawn as spawn6 } from "node:child_process";
 import crypto7 from "node:crypto";
-import fs29 from "node:fs";
+import fs31 from "node:fs";
 import http from "node:http";
-import path25 from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import path27 from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // src/core/file-diff.ts
 var PREVIEW_LINES = 300;
 function gitPath(value, prefix = true) {
-  let path34 = value;
+  let path36 = value;
   if (value.startsWith('"') && value.endsWith('"')) {
     const bytes = [];
     const escapes = { t: "	", n: "\n", r: "\r", b: "\b", f: "\f", v: "\v" };
@@ -5411,9 +5987,9 @@ function gitPath(value, prefix = true) {
       if (match[1] && /^[0-7]+$/.test(match[1])) bytes.push(parseInt(match[1], 8));
       else bytes.push(...new TextEncoder().encode(match[2] ?? escapes[match[1]] ?? match[1]));
     }
-    path34 = new TextDecoder().decode(new Uint8Array(bytes));
+    path36 = new TextDecoder().decode(new Uint8Array(bytes));
   }
-  return prefix ? path34.replace(/^[ab]\//, "") : path34;
+  return prefix ? path36.replace(/^[ab]\//, "") : path36;
 }
 function headerPath(header) {
   const quoted = header.match(/^diff --git ("(?:[^"\\]|\\.)*"|\S+) ("(?:[^"\\]|\\.)*"|\S+)$/);
@@ -5528,7 +6104,7 @@ var WEEK_MS2 = 7 * 24 * 3600 * 1e3;
 var SCAN = 400;
 var RUN_ID3 = /^\d{8}-\d{6}-[0-9a-f]{4}$/;
 var LOCAL_HOST = /^(127\.0\.0\.1|localhost|\[::1\]):\d+$/i;
-var oneLine7 = (s, max) => {
+var oneLine8 = (s, max) => {
   const t = s.replace(/\s+/g, " ").trim();
   return t.length > max ? `${t.slice(0, max - 1)}\u2026` : t;
 };
@@ -5539,6 +6115,22 @@ function findings(m) {
   return parts.length ? parts.join(" \xB7 ") : "no findings";
 }
 var canDiscard = (m) => m.mode === "isolate" && !isActive(m.state) && !m.applied && !m.discarded;
+function groupAction(group, verb) {
+  const metas = groupIds(group).map((id) => freshMeta(id));
+  let done = 0;
+  for (const m of metas) {
+    try {
+      if (verb === "stop" && isActive(m.state) && stopRun(m.id)) done++;
+      if (verb === "discard" && canDiscard(m)) {
+        discardRun(m);
+        done++;
+      }
+    } catch {
+    }
+  }
+  const what2 = verb === "stop" ? "stopping" : "discarded the isolated copies of";
+  return { done, message: done ? `${what2} ${done} run${done === 1 ? "" : "s"} of ${group}` : `nothing to ${verb} in ${group}` };
+}
 function toRun(m) {
   const l = m.state === "running" ? live(m) : void 0;
   return {
@@ -5560,7 +6152,7 @@ function toRun(m) {
     changes: m.changes?.length || void 0,
     applied: m.applied || void 0,
     discardable: canDiscard(m) || void 0,
-    note: l?.last ? oneLine7(String(l.last), 140) : isActive(m.state) ? "" : m.verifyResult && !m.verifyResult.ok ? `verify failed: ${m.verify ?? ""}` : m.verdict ? findings(m) : m.auditOf && m.state === "done" ? m.auditDisputed?.length ? `${m.auditDisputed.length} disputed` : "nothing disputed" : headline(m, 200) || oneLine7(m.error ?? "", 200)
+    note: l?.last ? oneLine8(String(l.last), 140) : isActive(m.state) ? "" : m.verifyResult && !m.verifyResult.ok ? `verify failed: ${m.verify ?? ""}` : m.verdict ? findings(m) : m.auditOf && m.state === "done" ? m.auditDisputed?.length ? `${m.auditDisputed.length} disputed` : "nothing disputed" : headline(m, 200) || oneLine8(m.error ?? "", 200)
   };
 }
 function dashState(opts = {}) {
@@ -5663,15 +6255,15 @@ var HEADERS = {
   "content-security-policy": `default-src 'none'; script-src 'self' 'sha256-${crypto7.createHash("sha256").update(THEME_SCRIPT).digest("base64")}'; style-src 'self' 'unsafe-inline'; img-src data:; connect-src 'self'; base-uri 'none'; form-action 'none'`
 };
 var ASSETS = { "/assets/app.js": "text/javascript; charset=utf-8", "/assets/app.css": "text/css; charset=utf-8" };
-var assetsDir = () => fileURLToPath3(new URL("./ui/", import.meta.url));
+var assetsDir = () => fileURLToPath4(new URL("./ui/", import.meta.url));
 var assetCache = /* @__PURE__ */ new Map();
 function readAsset(route) {
   try {
-    const file2 = path25.join(assetsDir(), path25.basename(route));
-    const { mtimeMs } = fs29.statSync(file2);
+    const file2 = path27.join(assetsDir(), path27.basename(route));
+    const { mtimeMs } = fs31.statSync(file2);
     const hit = assetCache.get(route);
     if (hit && hit.mtimeMs === mtimeMs) return hit.data;
-    const data = fs29.readFileSync(file2);
+    const data = fs31.readFileSync(file2);
     assetCache.set(route, { mtimeMs, data });
     return data;
   } catch {
@@ -5690,6 +6282,18 @@ function handler(touch2, token) {
     const given = Buffer.from(String(req.headers["x-pitroom-token"] ?? ""));
     if (given.length !== tokenBuf.length || !crypto7.timingSafeEqual(given, tokenBuf)) return json(res, 403, { error: "forbidden" });
     if (req.headers.origin !== `http://${req.headers.host}`) return json(res, 403, { error: "forbidden origin" });
+    const g = /^\/api\/group\/([^/]+)\/(stop|discard)$/.exec(pathname);
+    if (g) {
+      let group;
+      try {
+        group = decodeURIComponent(g[1]);
+      } catch {
+        return json(res, 404, { error: "no such group" });
+      }
+      if (!group || group.length > 100 || !groupIds(group).length) return json(res, 404, { error: "no such group" });
+      const r = groupAction(group, g[2]);
+      return r.done ? json(res, 200, { ok: true, message: r.message }) : json(res, 409, { error: r.message });
+    }
     const m = /^\/api\/run\/([^/]+)\/(stop|discard)$/.exec(pathname);
     if (!m) return json(res, 404, { error: "not found" });
     let meta;
@@ -5746,6 +6350,17 @@ function handler(touch2, token) {
       const days2 = Number(url.searchParams.get("days") ?? 30);
       return json(res, 200, { ...historyStats(days2 > 0 ? Date.now() - days2 * 864e5 : void 0), price: primaryPrice().name });
     }
+    const retry = /^\/api\/group\/([^/]+)\/retry$/.exec(url.pathname);
+    if (retry) {
+      let group = "";
+      try {
+        group = decodeURIComponent(retry[1]);
+      } catch {
+      }
+      const ids = group && group.length <= 100 ? groupIds(group) : [];
+      if (!ids.length) return json(res, 404, { error: "no such group" });
+      return json(res, 200, { commands: retryCommands(ids.map((id) => freshMeta(id))), shell: retryShell() });
+    }
     const m = /^\/api\/run\/([^/]+)$/.exec(url.pathname);
     if (m) {
       const d = runDetail(m[1]);
@@ -5777,7 +6392,7 @@ function startDash(opts) {
     });
   });
 }
-var registryFile = () => path25.join(home(), "dash.json");
+var registryFile = () => path27.join(home(), "dash.json");
 async function ping(port) {
   try {
     const r = await fetch(`http://127.0.0.1:${port}/api/state?limit=1`, { signal: AbortSignal.timeout(1500) });
@@ -5789,12 +6404,12 @@ async function ping(port) {
 async function runningDash() {
   let r;
   try {
-    r = JSON.parse(fs29.readFileSync(registryFile(), "utf8"));
+    r = JSON.parse(fs31.readFileSync(registryFile(), "utf8"));
   } catch {
     return void 0;
   }
   if (!isAlive(r.pid)) {
-    fs29.rmSync(registryFile(), { force: true });
+    fs31.rmSync(registryFile(), { force: true });
     return void 0;
   }
   return await ping(r.port) ? { ...r, url: `http://127.0.0.1:${r.port}/` } : void 0;
@@ -5811,7 +6426,7 @@ async function dashCommand(o) {
   if (o.stop) {
     if (!existing) throw new UserError("pitroom dash is not running");
     process.kill(existing.pid, "SIGTERM");
-    fs29.rmSync(registryFile(), { force: true });
+    fs31.rmSync(registryFile(), { force: true });
     o.log(`stopped pitroom dash (${existing.url})`);
     return 0;
   }
@@ -5848,9 +6463,9 @@ async function dashCommand(o) {
     if (explicit || e.code !== "EADDRINUSE") throw new UserError(`pitroom dash: ${e.message}`);
     dash = await startDash({ port: 0, idleMs: o.idleMs });
   }
-  fs29.mkdirSync(home(), { recursive: true });
+  fs31.mkdirSync(home(), { recursive: true });
   const tmp = `${registryFile()}.${process.pid}.tmp`;
-  fs29.writeFileSync(tmp, JSON.stringify({ pid: process.pid, port: dash.port }));
+  fs31.writeFileSync(tmp, JSON.stringify({ pid: process.pid, port: dash.port }));
   renameOver(tmp, registryFile());
   const stop = () => void dash.close();
   process.once("SIGINT", stop);
@@ -5860,7 +6475,7 @@ async function dashCommand(o) {
   if (o.open) openBrowser(dash.url);
   await dash.closed;
   try {
-    if (JSON.parse(fs29.readFileSync(registryFile(), "utf8")).pid === process.pid) fs29.rmSync(registryFile(), { force: true });
+    if (JSON.parse(fs31.readFileSync(registryFile(), "utf8")).pid === process.pid) fs31.rmSync(registryFile(), { force: true });
   } catch {
   }
   return 0;
@@ -5872,10 +6487,10 @@ var MAX_BODY = 4e6;
 var MAX_SESSIONS = 64;
 var IDLE_MS = 60 * 6e4;
 var PATH = "/mcp";
-var tokenFile = () => path26.join(home(), "mcp-token");
+var tokenFile = () => path28.join(home(), "mcp-token");
 var readToken = (file2) => {
   try {
-    const kept = fs30.readFileSync(file2, "utf8").trim();
+    const kept = fs32.readFileSync(file2, "utf8").trim();
     return kept.length >= 16 ? kept : void 0;
   } catch {
     return void 0;
@@ -5890,10 +6505,10 @@ function mcpToken() {
   const file2 = tokenFile();
   let token = readToken(file2);
   if (!token) {
-    fs30.mkdirSync(path26.dirname(file2), { recursive: true });
+    fs32.mkdirSync(path28.dirname(file2), { recursive: true });
     token = crypto8.randomBytes(32).toString("hex");
     try {
-      fs30.writeFileSync(file2, `${token}
+      fs32.writeFileSync(file2, `${token}
 `, { mode: 384, flag: "wx" });
     } catch (e) {
       if (e.code !== "EEXIST") throw e;
@@ -5902,7 +6517,7 @@ function mcpToken() {
     }
   }
   try {
-    fs30.chmodSync(file2, 384);
+    fs32.chmodSync(file2, 384);
   } catch {
   }
   return { token, from: file2 };
@@ -5928,7 +6543,7 @@ function reply(res, status, body, headers = {}) {
   res.writeHead(status, { ...text ? { "Content-Type": "application/json" } : {}, "Content-Length": Buffer.byteLength(text), ...headers });
   res.end(text);
 }
-var failure5 = (code, message) => ({ jsonrpc: "2.0", id: null, error: { code, message } });
+var failure7 = (code, message) => ({ jsonrpc: "2.0", id: null, error: { code, message } });
 function readBody(req) {
   return new Promise((resolve2, reject) => {
     const chunks = [];
@@ -5955,23 +6570,23 @@ function evictIdle(sessions) {
 function makeHandler(token, sessions) {
   return async (req, res) => {
     const url = new URL(req.url ?? "/", "http://127.0.0.1");
-    if (url.pathname !== PATH) return reply(res, 404, failure5(-32600, `not found: the endpoint is ${PATH}`));
-    if (!LOCAL_HOST.test(req.headers.host ?? "")) return reply(res, 403, failure5(-32600, "forbidden host"));
+    if (url.pathname !== PATH) return reply(res, 404, failure7(-32600, `not found: the endpoint is ${PATH}`));
+    if (!LOCAL_HOST.test(req.headers.host ?? "")) return reply(res, 403, failure7(-32600, "forbidden host"));
     const origin = req.headers.origin;
-    if (origin !== void 0 && !LOCAL_ORIGIN.test(origin)) return reply(res, 403, failure5(-32600, "forbidden origin"));
+    if (origin !== void 0 && !LOCAL_ORIGIN.test(origin)) return reply(res, 403, failure7(-32600, "forbidden origin"));
     const auth = /^Bearer\s+(.+)$/i.exec(req.headers.authorization ?? "")?.[1]?.trim();
-    if (!auth || !sameSecret(auth, token)) return reply(res, 401, failure5(-32001, "a bearer token is needed"), { "WWW-Authenticate": "Bearer" });
+    if (!auth || !sameSecret(auth, token)) return reply(res, 401, failure7(-32001, "a bearer token is needed"), { "WWW-Authenticate": "Bearer" });
     const sid = typeof req.headers["mcp-session-id"] === "string" ? req.headers["mcp-session-id"] : void 0;
     if (req.method === "DELETE") {
-      if (!sid || !sessions.has(sid)) return reply(res, 404, failure5(-32600, "no such session"));
+      if (!sid || !sessions.has(sid)) return reply(res, 404, failure7(-32600, "no such session"));
       drop(sessions, sid);
       return reply(res, 204);
     }
     if (req.method === "GET") {
-      if (!/text\/event-stream|\*\/\*/.test(req.headers.accept ?? "")) return reply(res, 406, failure5(-32600, "a GET opens the event stream: send Accept: text/event-stream"));
-      if (!sid) return reply(res, 400, failure5(-32600, "Mcp-Session-Id is missing: initialize first"));
+      if (!/text\/event-stream|\*\/\*/.test(req.headers.accept ?? "")) return reply(res, 406, failure7(-32600, "a GET opens the event stream: send Accept: text/event-stream"));
+      if (!sid) return reply(res, 400, failure7(-32600, "Mcp-Session-Id is missing: initialize first"));
       const kept2 = sessions.get(sid);
-      if (!kept2) return reply(res, 404, failure5(-32600, "no such session: initialize again"));
+      if (!kept2) return reply(res, 404, failure7(-32600, "no such session: initialize again"));
       kept2.closeStream?.();
       res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache" });
       res.write(": open\n\n");
@@ -6000,9 +6615,9 @@ data: ${JSON.stringify(msg)}
       res.on("close", close);
       return;
     }
-    if (req.method !== "POST") return reply(res, 405, failure5(-32600, "GET, POST or DELETE"), { Allow: "GET, POST, DELETE" });
+    if (req.method !== "POST") return reply(res, 405, failure7(-32600, "GET, POST or DELETE"), { Allow: "GET, POST, DELETE" });
     const body = await readBody(req);
-    if (body === "too-big") return reply(res, 413, failure5(-32600, `a request body is at most ${MAX_BODY} bytes`));
+    if (body === "too-big") return reply(res, 413, failure7(-32600, `a request body is at most ${MAX_BODY} bytes`));
     let parsed;
     try {
       parsed = JSON.parse(body);
@@ -6014,15 +6629,15 @@ data: ${JSON.stringify(msg)}
     const single = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
     if (single?.method === "initialize") {
       if (sid) drop(sessions, sid);
-      if (sessions.size >= MAX_SESSIONS && !evictIdle(sessions)) return reply(res, 503, failure5(-32e3, `${MAX_SESSIONS} sessions are busy with requests: try again when one ends`));
+      if (sessions.size >= MAX_SESSIONS && !evictIdle(sessions)) return reply(res, 503, failure7(-32e3, `${MAX_SESSIONS} sessions are busy with requests: try again when one ends`));
       const id = crypto8.randomUUID();
       kept = { session: newSession(), lastSeen: Date.now() };
       sessions.set(id, kept);
       headers["Mcp-Session-Id"] = id;
     } else {
-      if (!sid) return reply(res, 400, failure5(-32600, "Mcp-Session-Id is missing: initialize first"));
+      if (!sid) return reply(res, 400, failure7(-32600, "Mcp-Session-Id is missing: initialize first"));
       kept = sessions.get(sid);
-      if (!kept) return reply(res, 404, failure5(-32600, "no such session: initialize again"));
+      if (!kept) return reply(res, 404, failure7(-32600, "no such session: initialize again"));
     }
     kept.lastSeen = Date.now();
     if (!wantsStream(parsed)) {
@@ -6052,7 +6667,7 @@ async function serveMcpHttp(opts) {
     handler2(req, res).catch((e) => {
       process.stderr.write(`pitroom mcp: ${String(e.stack ?? e)}
 `);
-      reply(res, 500, failure5(-32603, "internal error"));
+      reply(res, 500, failure7(-32603, "internal error"));
     });
   });
   const sweep = setInterval(() => {
@@ -6083,23 +6698,23 @@ async function serveMcpHttp(opts) {
 }
 
 // src/cli/commands.ts
-import { spawnSync as spawnSync8 } from "node:child_process";
-import fs36 from "node:fs";
-import path32 from "node:path";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { spawnSync as spawnSync11 } from "node:child_process";
+import fs39 from "node:fs";
+import path34 from "node:path";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // src/core/init.ts
-import fs31 from "node:fs";
-import path27 from "node:path";
+import fs33 from "node:fs";
+import path29 from "node:path";
 var FREE = /-free$/;
 var TIER_ORDER = [["cheap", "opencode"], ["standard", "codex"], ["capable", "claude"]];
-var isFound = (binary5) => path27.isAbsolute(binary5) && fs31.existsSync(binary5);
+var isFound = (binary7) => path29.isAbsolute(binary7) && fs33.existsSync(binary7);
 function planInit(opts = {}) {
   const file2 = configPath();
   const workers = backendIds().map((id) => {
     const b = getBackend(id);
-    const binary5 = b.binary();
-    return { id, name: b.name, found: isFound(binary5), binary: binary5 };
+    const binary7 = b.binary();
+    return { id, name: b.name, found: isFound(binary7), binary: binary7 };
   });
   const notes = [];
   const config = {};
@@ -6113,15 +6728,15 @@ function planInit(opts = {}) {
     } catch {
       notes.push("could not list OpenCode models (is it logged in?)");
     }
-    const defaultModel4 = b.defaultModel?.();
-    const chosen = opts.model ?? defaultModel4;
+    const defaultModel6 = b.defaultModel?.();
+    const chosen = opts.model ?? defaultModel6;
     const free = models.filter((m) => FREE.test(m) && m !== chosen);
-    opencode2 = { defaultModel: defaultModel4, models: models.length, free: free.slice(0, 6) };
+    opencode2 = { defaultModel: defaultModel6, models: models.length, free: free.slice(0, 6) };
     if (opts.model) {
       if (models.length && !models.includes(opts.model)) throw new UserError(`"${opts.model}" is not in \`opencode models\``);
       if (!models.length) notes.push(`could not check "${opts.model}": \`opencode models\` listed nothing`);
       config.models = { opencode: opts.model };
-    } else if (!defaultModel4) {
+    } else if (!defaultModel6) {
       blocked = `OpenCode has no default model: choose one with --model <id>${free.length ? ` (free models you have: ${free.slice(0, 4).join(", ")})` : ""}`;
     }
     const fallback = opts.fallback ?? free.slice(0, 2);
@@ -6139,15 +6754,15 @@ function planInit(opts = {}) {
   if (Object.keys(tiers).length > 1) config.tiers = tiers;
   if (!workers.some((w) => w.found)) blocked = "no worker CLI found: install OpenCode (https://opencode.ai), Codex CLI, Claude Code or Gemini CLI first";
   else if (!blocked && !Object.keys(config).length) notes.push("nothing to propose: the default model and the single worker need no config");
-  return { path: file2, exists: fs31.existsSync(file2), workers, opencode: opencode2, config, blocked, notes };
+  return { path: file2, exists: fs33.existsSync(file2), workers, opencode: opencode2, config, blocked, notes };
 }
 function writeInit(plan, force) {
   if (plan.blocked) throw new UserError(plan.blocked);
   if (!Object.keys(plan.config).length) throw new UserError("nothing to write: the proposal is empty");
-  if (plan.exists && !force) throw new UserError(`${plan.path} already exists: pass --force to replace it (the old file is kept as ${path27.basename(plan.path)}.bak)`);
-  fs31.mkdirSync(path27.dirname(plan.path), { recursive: true });
-  if (plan.exists) fs31.copyFileSync(plan.path, `${plan.path}.bak`);
-  fs31.writeFileSync(plan.path, `${JSON.stringify(plan.config, null, 2)}
+  if (plan.exists && !force) throw new UserError(`${plan.path} already exists: pass --force to replace it (the old file is kept as ${path29.basename(plan.path)}.bak)`);
+  fs33.mkdirSync(path29.dirname(plan.path), { recursive: true });
+  if (plan.exists) fs33.copyFileSync(plan.path, `${plan.path}.bak`);
+  fs33.writeFileSync(plan.path, `${JSON.stringify(plan.config, null, 2)}
 `);
   return plan.path;
 }
@@ -6167,18 +6782,18 @@ function formatInit(plan, written) {
 }
 
 // src/core/mcp-install.ts
-import { spawnSync as spawnSync7 } from "node:child_process";
-import fs32 from "node:fs";
-import os10 from "node:os";
-import path28 from "node:path";
+import { spawnSync as spawnSync9 } from "node:child_process";
+import fs34 from "node:fs";
+import os11 from "node:os";
+import path30 from "node:path";
 var CLIENT_IDS = ["claude-code", "codex", "gemini", "cursor", "claude-desktop"];
 var NAME = "pitroom";
 function mcpCommand() {
   const launcher = launcherPath();
   if (isPitroomLauncher(launcher)) return { command: launcher, args: ["mcp"] };
-  for (const dir of (process.env.PATH ?? "").split(path28.delimiter).filter(Boolean)) {
-    const p = path28.join(dir, process.platform === "win32" ? "pitroom.cmd" : "pitroom");
-    if (fs32.existsSync(p)) return { command: path28.resolve(p), args: ["mcp"] };
+  for (const dir of (process.env.PATH ?? "").split(path30.delimiter).filter(Boolean)) {
+    const p = path30.join(dir, process.platform === "win32" ? "pitroom.cmd" : "pitroom");
+    if (fs34.existsSync(p)) return { command: path30.resolve(p), args: ["mcp"] };
   }
   return { command: process.execPath, args: [process.argv[1] ?? "pitroom", "mcp"] };
 }
@@ -6188,13 +6803,13 @@ var same = (a, b) => {
 };
 function run(backendId, args) {
   const { command, prefix } = resolveCommand(getBackend(backendId).binary());
-  const r = spawnSync7(command, [...prefix, ...args], { encoding: "utf8", timeout: 6e4, stdio: ["ignore", "pipe", "pipe"] });
+  const r = spawnSync9(command, [...prefix, ...args], { encoding: "utf8", timeout: 6e4, stdio: ["ignore", "pipe", "pipe"] });
   return { ok: r.status === 0 && !r.error, out: `${r.stdout ?? ""}${r.stderr ?? ""}`.trim() };
 }
 var runnable = (backendId) => run(backendId, ["--version"]).ok;
 var readJson = (file2) => {
   try {
-    return JSON.parse(fs32.readFileSync(file2, "utf8"));
+    return JSON.parse(fs34.readFileSync(file2, "utf8"));
   } catch {
     return void 0;
   }
@@ -6203,8 +6818,8 @@ var jsonState = (file2, c) => {
   const entry = readJson(file2)?.mcpServers?.[NAME];
   return entry === void 0 ? "absent" : same(c, entry) ? "same" : "different";
 };
-var home2 = () => os10.homedir();
-var geminiDir = () => path28.join(process.env.GEMINI_CLI_HOME ?? home2(), ".gemini");
+var home2 = () => os11.homedir();
+var geminiDir = () => path30.join(process.env.GEMINI_CLI_HOME ?? home2(), ".gemini");
 function cliClient(id, backend, name, where, o) {
   return {
     id,
@@ -6227,43 +6842,43 @@ function jsonClient(id, name, file2, dir) {
   return {
     id,
     name,
-    found: () => fs32.existsSync(dir()),
+    found: () => fs34.existsSync(dir()),
     state: (c) => jsonState(file2(), c),
     add: (c) => {
       let config = {};
-      if (fs32.existsSync(file2())) {
+      if (fs34.existsSync(file2())) {
         config = readJson(file2());
         if (!config || typeof config !== "object" || Array.isArray(config)) return { ok: false, message: `${rel()} is not valid JSON: left alone` };
         const backup = `${file2()}.bak-pitroom`;
-        if (!fs32.existsSync(backup)) fs32.copyFileSync(file2(), backup);
+        if (!fs34.existsSync(backup)) fs34.copyFileSync(file2(), backup);
       }
       config.mcpServers = { ...config.mcpServers ?? {}, [NAME]: { command: c.command, args: c.args } };
-      fs32.mkdirSync(path28.dirname(file2()), { recursive: true });
+      fs34.mkdirSync(path30.dirname(file2()), { recursive: true });
       const tmp = `${file2()}.${process.pid}.tmp`;
-      fs32.writeFileSync(tmp, `${JSON.stringify(config, null, 2)}
+      fs34.writeFileSync(tmp, `${JSON.stringify(config, null, 2)}
 `);
-      fs32.renameSync(tmp, file2());
+      fs34.renameSync(tmp, file2());
       return { ok: true, message: rel() };
     },
     remove: () => {
       const config = readJson(file2());
       if (!config?.mcpServers?.[NAME]) return { ok: true, message: rel() };
       delete config.mcpServers[NAME];
-      fs32.writeFileSync(file2(), `${JSON.stringify(config, null, 2)}
+      fs34.writeFileSync(file2(), `${JSON.stringify(config, null, 2)}
 `);
       return { ok: true, message: rel() };
     }
   };
 }
 function desktopFile() {
-  if (process.platform === "darwin") return path28.join(home2(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
-  if (process.platform === "win32") return path28.join(process.env.APPDATA ?? path28.join(home2(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
-  return path28.join(process.env.XDG_CONFIG_HOME ?? path28.join(home2(), ".config"), "Claude", "claude_desktop_config.json");
+  if (process.platform === "darwin") return path30.join(home2(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  if (process.platform === "win32") return path30.join(process.env.APPDATA ?? path30.join(home2(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+  return path30.join(process.env.XDG_CONFIG_HOME ?? path30.join(home2(), ".config"), "Claude", "claude_desktop_config.json");
 }
 function codexState(c) {
   let text;
   try {
-    text = fs32.readFileSync(path28.join(process.env.CODEX_HOME ?? path28.join(home2(), ".codex"), "config.toml"), "utf8");
+    text = fs34.readFileSync(path30.join(process.env.CODEX_HOME ?? path30.join(home2(), ".codex"), "config.toml"), "utf8");
   } catch {
     return "absent";
   }
@@ -6281,7 +6896,7 @@ function codexState(c) {
 function clients() {
   return [
     cliClient("claude-code", "claude", "Claude Code", "user settings (~/.claude.json)", {
-      state: (c) => jsonState(path28.join(home2(), ".claude.json"), c),
+      state: (c) => jsonState(path30.join(home2(), ".claude.json"), c),
       add: (c) => ["mcp", "add", "--scope", "user", NAME, "--", c.command, ...c.args],
       remove: () => ["mcp", "remove", NAME, "--scope", "user"]
     }),
@@ -6291,12 +6906,12 @@ function clients() {
       remove: () => ["mcp", "remove", NAME]
     }),
     cliClient("gemini", "gemini", "Gemini CLI", "user settings (~/.gemini/settings.json)", {
-      state: (c) => jsonState(path28.join(geminiDir(), "settings.json"), c),
+      state: (c) => jsonState(path30.join(geminiDir(), "settings.json"), c),
       add: (c) => ["mcp", "add", "--scope", "user", NAME, c.command, ...c.args],
       remove: () => ["mcp", "remove", "--scope", "user", NAME]
     }),
-    jsonClient("cursor", "Cursor", () => path28.join(home2(), ".cursor", "mcp.json"), () => path28.join(home2(), ".cursor")),
-    jsonClient("claude-desktop", "Claude Desktop", desktopFile, () => path28.dirname(desktopFile()))
+    jsonClient("cursor", "Cursor", () => path30.join(home2(), ".cursor", "mcp.json"), () => path30.join(home2(), ".cursor")),
+    jsonClient("claude-desktop", "Claude Desktop", desktopFile, () => path30.dirname(desktopFile()))
   ];
 }
 function attempt2(f) {
@@ -6367,16 +6982,16 @@ var parseClients = (value) => {
 
 // src/core/plan-status.ts
 import crypto9 from "node:crypto";
-import fs33 from "node:fs";
-import path29 from "node:path";
+import fs35 from "node:fs";
+import path31 from "node:path";
 function notesFile(plan) {
   const id = crypto9.createHash("sha1").update(plan.file).digest("hex").slice(0, 12);
-  return path29.join(home(), "plans", id, "notes.md");
+  return path31.join(home(), "plans", id, "notes.md");
 }
 function readNotes(plan) {
   const f = notesFile(plan);
-  if (!fs33.existsSync(f)) return [];
-  return fs33.readFileSync(f, "utf8").split("\n").slice(1).filter(Boolean).map((l) => {
+  if (!fs35.existsSync(f)) return [];
+  return fs35.readFileSync(f, "utf8").split("\n").slice(1).filter(Boolean).map((l) => {
     const m = /^(\d{4}-\d\d-\d\d \d\d:\d\d) (.*)$/.exec(l);
     return m ? { at: m[1], text: m[2] } : { at: "", text: l };
   });
@@ -6384,11 +6999,11 @@ function readNotes(plan) {
 function addNote(planFile, text) {
   const plan = loadPlan(planFile);
   const f = notesFile(plan);
-  fs33.mkdirSync(path29.dirname(f), { recursive: true });
-  if (!fs33.existsSync(f)) fs33.writeFileSync(f, `# plan: ${plan.file}
+  fs35.mkdirSync(path31.dirname(f), { recursive: true });
+  if (!fs35.existsSync(f)) fs35.writeFileSync(f, `# plan: ${plan.file}
 `);
   const at = (/* @__PURE__ */ new Date()).toISOString().slice(0, 16).replace("T", " ");
-  fs33.appendFileSync(f, `${at} ${text.replace(/\s+/g, " ").trim()}
+  fs35.appendFileSync(f, `${at} ${text.replace(/\s+/g, " ").trim()}
 `);
   return f;
 }
@@ -6456,26 +7071,26 @@ ${rulings}`,
 
 // src/core/cache.ts
 import crypto10 from "node:crypto";
-import fs34 from "node:fs";
-import path30 from "node:path";
+import fs36 from "node:fs";
+import path32 from "node:path";
 var SCAN2 = 500;
 function cacheKey(o) {
   if (o.verify || o.mode !== "read" || o.continueFrom || o.web || o.plan || o.review || o.audit || o.auditRate === 1) return void 0;
   if (!(effective().cacheDays.value > 0)) return void 0;
-  const dir = canonical(path30.resolve(o.dir));
+  const dir = canonical(path32.resolve(o.dir));
   const root = repoRoot(dir);
   if (!root) return void 0;
   try {
     const tree = snapshotTree(root);
     const head = commitOf(root, "HEAD") ?? "";
     const files = o.files.map((f) => {
-      const abs = path30.resolve(f);
-      return [abs, crypto10.createHash("sha256").update(fs34.readFileSync(abs)).digest("hex")];
+      const abs = path32.resolve(f);
+      return [abs, crypto10.createHash("sha256").update(fs36.readFileSync(abs)).digest("hex")];
     });
     const question = o.task.replace(/\s+/g, " ").trim();
     const readIn2 = READ_IN.includes(effective().readIn.value) ? effective().readIn.value : "auto";
     const where = !o.inPlace && wantSnapshot(readIn2, root, dir) ? "snapshot" : "project";
-    const key = crypto10.createHash("sha256").update(JSON.stringify([question, path30.relative(root, dir), files, where])).digest("hex");
+    const key = crypto10.createHash("sha256").update(JSON.stringify([question, path32.relative(root, dir), files, where])).digest("hex");
     return { key, state: `${head}:${tree}` };
   } catch {
     return void 0;
@@ -6517,10 +7132,138 @@ function ago(iso, now = Date.now()) {
 }
 var cachedNote = (m) => `pitroom \u27F2 cached answer \xB7 the same question on the same code as run ${m.id} (${ago(m.endedAt ?? m.startedAt)}) \xB7 no worker ran \xB7 --fresh asks one again`;
 
+// src/core/eval.ts
+import { spawnSync as spawnSync10 } from "node:child_process";
+import fs37 from "node:fs";
+var KINDS = ["definition", "count", "set"];
+function loadEval(file2) {
+  let raw;
+  try {
+    raw = JSON.parse(fs37.readFileSync(file2, "utf8"));
+  } catch (e) {
+    throw new UserError(`cannot read ${file2}: ${e.message}`);
+  }
+  const list2 = raw?.questions;
+  if (!Array.isArray(list2) || !list2.length) throw new UserError(`${file2}: expected {"questions": [{"id", "task", "kind", "truth"}, \u2026]}`);
+  const ids = /* @__PURE__ */ new Set();
+  return list2.map((q, i) => {
+    const where = `${file2}: question ${i + 1}`;
+    if (!q || typeof q !== "object") throw new UserError(`${where} is not an object`);
+    const id = typeof q.id === "string" && q.id.trim() ? q.id.trim() : `q${i + 1}`;
+    if (ids.has(id)) throw new UserError(`${where}: the id "${id}" is used twice`);
+    ids.add(id);
+    if (typeof q.task !== "string" || !q.task.trim()) throw new UserError(`${where} (${id}) has no task`);
+    if (!KINDS.includes(q.kind)) throw new UserError(`${where} (${id}): kind must be one of ${KINDS.join(", ")}`);
+    const t = q.truth;
+    const grep = t && typeof t === "object" && !Array.isArray(t) && typeof t.grep === "string" && t.grep;
+    const literal = q.kind === "definition" && typeof t === "string" && /:\d+$/.test(t) || q.kind === "count" && typeof t === "number" && Number.isInteger(t) && t >= 0 || q.kind === "set" && Array.isArray(t) && t.every((s) => typeof s === "string");
+    if (!grep && !literal) {
+      const want = { definition: '"path:line"', count: "a whole number", set: "a list of paths" }[q.kind];
+      throw new UserError(`${where} (${id}): truth must be ${want} or {"grep": "pattern", \u2026}`);
+    }
+    return { id, task: q.task.trim(), kind: q.kind, truth: t };
+  });
+}
+var clean = (p) => p.replace(/\\/g, "/").replace(/^\.?\//, "");
+function gitGrep(root, flags, t) {
+  const r = spawnSync10("git", ["-C", root, "grep", ...flags, t.regex ? "-E" : "-F", ...t.word ? ["-w"] : [], "-e", t.grep, "--", t.dir ?? "."], {
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024
+  });
+  if (r.status === 1) return [];
+  if (r.status !== 0) throw new UserError(`git grep "${t.grep}" failed: ${(r.stderr || r.error?.message || "").trim()}`);
+  const exclude = t.exclude ? new RegExp(t.exclude) : void 0;
+  return r.stdout.split("\n").filter(Boolean).filter((l) => !exclude?.test(l.split(":")[0]));
+}
+function truthOf(q, root) {
+  const t = q.truth;
+  if (t && typeof t === "object" && !Array.isArray(t)) {
+    if (!root) throw new UserError(`question ${q.id}: a "grep" truth needs a git repository`);
+    if (q.kind === "definition") {
+      const hit = gitGrep(root, ["-n"], t).map((l) => /^(.*?):(\d+):/.exec(l)).find(Boolean);
+      if (!hit) throw new UserError(`question ${q.id}: git grep found no definition for "${t.grep}"`);
+      return { path: clean(hit[1]), line: Number(hit[2]) };
+    }
+    const files = [...new Set(gitGrep(root, ["-l"], t).map(clean))];
+    return q.kind === "count" ? { count: files.length } : { files };
+  }
+  if (q.kind === "definition") {
+    const m = /^(.*):(\d+)$/.exec(t);
+    return { path: clean(m[1]), line: Number(m[2]) };
+  }
+  if (q.kind === "count") return { count: t };
+  return { files: [...new Set(t.map(clean))] };
+}
+function answerParts(answer) {
+  const text = answer.replace(/`/g, "");
+  const s = /SUMMARY:\s*([\s\S]*?)(?=^\s*(?:DETAILS|FILES CHANGED|VERIFICATION|OPEN ISSUES):|$(?![\s\S]))/m.exec(text);
+  const d = /^\s*DETAILS:\s*([\s\S]*?)(?=^\s*(?:FILES CHANGED|VERIFICATION|OPEN ISSUES):|$(?![\s\S]))/m.exec(text);
+  const summary = s ? s[1] : text.split(/^\s*(?:DETAILS|FILES CHANGED|VERIFICATION|OPEN ISSUES):/m)[0];
+  return { summary: summary.trim(), details: (d?.[1] ?? "").trim() };
+}
+function pathsIn(text) {
+  const found = text.replace(/\\/g, "/").match(/[A-Za-z0-9_.@\-/]+\.[A-Za-z0-9]{1,8}(?::\d+)?/g) ?? [];
+  return [...new Set(found.map((p) => clean(p.replace(/:\d+$/, ""))))];
+}
+function scoreAnswer(q, truth, answer, root) {
+  const prefix = root ? `${clean(root).replace(/\/$/, "")}/` : "";
+  const text = prefix ? answer.replace(/\\/g, "/").split(prefix).join("") : answer;
+  const { summary, details } = answerParts(text);
+  if (!summary && !details) return { score: 0, got: "(no answer)" };
+  if ("line" in truth) {
+    const flat = summary.replace(/\s+/g, " ");
+    if (new RegExp(`(^|[^\\w./-])\\.?/?${escape2(truth.path)}:${truth.line}(?!\\d)`).test(flat)) return { score: 1, got: `${truth.path}:${truth.line}` };
+    const named = pathsIn(flat).includes(truth.path);
+    return { score: named ? 0.5 : 0, got: flat.slice(0, 120) };
+  }
+  if ("count" in truth) {
+    const n = /\d[\d,]*/.exec(summary);
+    const got2 = n ? Number(n[0].replace(/,/g, "")) : void 0;
+    return { score: got2 === truth.count ? 1 : 0, got: got2 === void 0 ? "(no number)" : String(got2) };
+  }
+  let got = pathsIn(summary);
+  if (!got.length) got = pathsIn(details);
+  const hit = got.filter((p) => truth.files.includes(p)).length;
+  const precision = got.length ? hit / got.length : 0;
+  const recall = truth.files.length ? hit / truth.files.length : got.length ? 0 : 1;
+  const f1 = precision + recall ? 2 * precision * recall / (precision + recall) : 0;
+  return { score: !truth.files.length && !got.length ? 1 : f1, got: `${hit}/${truth.files.length} found, ${got.length - hit} extra` };
+}
+var escape2 = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var mean = (a) => a.length ? a.reduce((x, y) => x + y, 0) / a.length : 0;
+var median = (a) => {
+  const s = a.filter((x) => x !== void 0).sort((x, y) => x - y);
+  return s.length ? s[Math.floor(s.length / 2)] : void 0;
+};
+function summarize(rows) {
+  const by = /* @__PURE__ */ new Map();
+  for (const r of rows) by.set(r.worker, [...by.get(r.worker) ?? [], r]);
+  return [...by.entries()].map(([worker, rs]) => ({
+    worker,
+    questions: rs.length,
+    failed: rs.filter((r) => r.state !== "done").length,
+    score: mean(rs.map((r) => r.score)),
+    byKind: Object.fromEntries(KINDS.filter((k) => rs.some((r) => r.kind === k)).map((k) => [k, mean(rs.filter((r) => r.kind === k).map((r) => r.score))])),
+    medianSeconds: median(rs.map((r) => r.seconds)),
+    medianTokens: median(rs.map((r) => r.tokens))
+  })).sort((a, b) => b.score - a.score || (a.medianSeconds ?? 1e9) - (b.medianSeconds ?? 1e9));
+}
+var pct2 = (x) => x === void 0 ? "-" : `${Math.round(x * 100)}%`;
+function formatEval(rows, group) {
+  const out = [`pitroom eval "${group}": ${new Set(rows.map((r) => r.question)).size} questions \xD7 ${new Set(rows.map((r) => r.worker)).size} workers`, ""];
+  for (const r of rows) out.push(`  ${pct2(r.score).padStart(4)}  ${r.question.padEnd(16)} ${r.worker.padEnd(28)} ${r.state === "done" ? r.got : `(${r.state})`}`);
+  out.push("", "| Worker | Score | Definition | Count | List | Failed | Median time | Median tokens |", "|---|---|---|---|---|---|---|---|");
+  for (const s of summarize(rows)) {
+    out.push(`| ${s.worker} | **${pct2(s.score)}** | ${pct2(s.byKind.definition)} | ${pct2(s.byKind.count)} | ${pct2(s.byKind.set)} | ${s.failed}/${s.questions} | ${s.medianSeconds ?? "-"} s | ${s.medianTokens === void 0 ? "-" : `${Math.round(s.medianTokens / 1e3)}k`} |`);
+  }
+  out.push("", `Every run is in the history: pitroom wait -g ${group}, or the dashboard's group picker.`);
+  return out.join("\n");
+}
+
 // src/core/review.ts
 import crypto11 from "node:crypto";
-import fs35 from "node:fs";
-import path31 from "node:path";
+import fs38 from "node:fs";
+import path33 from "node:path";
 var TEMPLATE2 = { task: "task-reviewer", fix: "re-review", range: "code-reviewer" };
 var section = (title, body) => `## ${title}
 
@@ -6538,7 +7281,7 @@ function ancestors(m) {
 function briefOf(m) {
   const root = [m, ...ancestors(m)].at(-1);
   const f = runFile(root.id, "brief.md");
-  return fs35.existsSync(f) ? fs35.readFileSync(f, "utf8") : root.task;
+  return fs38.existsSync(f) ? fs38.readFileSync(f, "utf8") : root.task;
 }
 function latestReview(ids) {
   for (const id of listRunIds().reverse()) {
@@ -6552,7 +7295,7 @@ function latestReview(ids) {
 }
 function diffOf(m, from = m.baseTree) {
   const where = m.mode === "isolate" ? m.worktree : m.repoRoot;
-  if (where && fs35.existsSync(where) && from && m.afterTree) return reviewDiff(where, from, m.afterTree);
+  if (where && fs38.existsSync(where) && from && m.afterTree) return reviewDiff(where, from, m.afterTree);
   if (from !== m.baseTree) {
     throw new UserError(`the isolated copy of ${m.id} is gone, so its fix round cannot be shown on its own; review a run that is not applied yet`, 3);
   }
@@ -6566,7 +7309,7 @@ function runReview(id) {
   if (!m.changes?.length) throw new UserError(`run ${m.id} made no changes; nothing to review`);
   const chain = ancestors(m);
   const previous = latestReview(chain.map((a) => a.id));
-  const dir = m.mode === "isolate" && m.worktree && fs35.existsSync(m.worktree) ? m.cwd : m.dir;
+  const dir = m.mode === "isolate" && m.worktree && fs38.existsSync(m.worktree) ? m.cwd : m.dir;
   const job = { of: m.id, dir, implementer: m.ran ?? m.worker, group: m.group, plan: m.plan };
   const title = m.plan ? `Task ${m.plan.step}: ${m.plan.title}` : `run ${m.id}`;
   if (!previous) {
@@ -6642,19 +7385,19 @@ function writePackage(job) {
   const root = repoRoot(job.dir);
   if (!g || !root) throw new UserError(`not a git repository: ${job.dir}`);
   const name = `review-${crypto11.randomBytes(4).toString("hex")}.md`;
-  const inside2 = !path31.relative(fs35.realpathSync(root), fs35.realpathSync(g)).startsWith("..");
-  const file2 = inside2 ? path31.join(g, "pitroom", name) : path31.join(root, ".pitroom", name);
+  const inside2 = !path33.relative(fs38.realpathSync(root), fs38.realpathSync(g)).startsWith("..");
+  const file2 = inside2 ? path33.join(g, "pitroom", name) : path33.join(root, ".pitroom", name);
   if (!inside2) ignoreInGit(root, "/.pitroom/");
-  fs35.mkdirSync(path31.dirname(file2), { recursive: true });
-  fs35.writeFileSync(file2, job.package);
+  fs38.mkdirSync(path33.dirname(file2), { recursive: true });
+  fs38.writeFileSync(file2, job.package);
   return file2;
 }
 function ignoreInGit(root, pattern) {
-  const exclude = path31.resolve(root, git(root, ["rev-parse", "--git-path", "info/exclude"]).stdout.trim());
-  const text = fs35.existsSync(exclude) ? fs35.readFileSync(exclude, "utf8") : "";
+  const exclude = path33.resolve(root, git(root, ["rev-parse", "--git-path", "info/exclude"]).stdout.trim());
+  const text = fs38.existsSync(exclude) ? fs38.readFileSync(exclude, "utf8") : "";
   if (text.split(/\r?\n/).includes(pattern)) return;
-  fs35.mkdirSync(path31.dirname(exclude), { recursive: true });
-  fs35.appendFileSync(exclude, `${text && !text.endsWith("\n") ? "\n" : ""}# Pitroom review packages in worktrees (removed after each review)
+  fs38.mkdirSync(path33.dirname(exclude), { recursive: true });
+  fs38.appendFileSync(exclude, `${text && !text.endsWith("\n") ? "\n" : ""}# Pitroom review packages in worktrees (removed after each review)
 ${pattern}
 `);
 }
@@ -6698,9 +7441,9 @@ function modelTable(opts = {}) {
   const known = /* @__PURE__ */ new Set();
   for (const b of allBackends()) {
     if (opts.backend && b.id !== opts.backend) continue;
-    const catalog5 = b.catalog?.() ?? { models: [], source: "no model list for this worker" };
-    sources.push(`${b.id}: ${catalog5.source}`);
-    for (const m of catalog5.models) {
+    const catalog6 = b.catalog?.() ?? { models: [], source: "no model list for this worker" };
+    sources.push(`${b.id}: ${catalog6.source}`);
+    for (const m of catalog6.models) {
       const key = `${b.id}:${m.id}`;
       known.add(key);
       const s = seen.get(key);
@@ -6810,10 +7553,10 @@ async function cmdReview(p) {
       writeMeta(meta);
     }
   } catch (e) {
-    fs36.rmSync(packageFile, { force: true });
+    fs39.rmSync(packageFile, { force: true });
     throw e;
   }
-  fs36.writeFileSync(runFile(meta.id, "package.md"), job.package);
+  fs39.writeFileSync(runFile(meta.id, "package.md"), job.package);
   return launch(p, meta);
 }
 async function cmdAudit(p) {
@@ -6922,7 +7665,7 @@ function cmdPlan(p) {
 }
 function cmdCrew(p) {
   const file2 = flag(p, "task-file");
-  const tasks = (file2 ? fs36.readFileSync(file2, "utf8").split(/^\s*---\s*$/m) : p.positional).map((t) => t.trim()).filter(Boolean);
+  const tasks = (file2 ? fs39.readFileSync(file2, "utf8").split(/^\s*---\s*$/m) : p.positional).map((t) => t.trim()).filter(Boolean);
   if (!tasks.length) throw new UserError('crew needs tasks: pitroom crew -g NAME "task 1" "task 2" (or --task-file with --- separators)');
   if (has(p, "write") && tasks.length > 1) {
     throw new UserError("parallel --write runs would edit the same tree; use --isolate (each worker gets its own isolated copy)");
@@ -6943,6 +7686,32 @@ function cmdCrew(p) {
    results: pitroom wait -g ${group}`);
   return 0;
 }
+async function cmdEval(p) {
+  const file2 = p.positional[0];
+  if (!file2 || p.positional.length > 1) throw new UserError("eval takes one questions file: pitroom eval QUESTIONS.json [-W worker]\u2026 (see pitroom --help)");
+  if (has(p, "write") || has(p, "isolate") || has(p, "continue") || has(p, "plan")) throw new UserError("eval asks read questions: drop -w/-i/--continue/--plan");
+  const questions = loadEval(file2);
+  const base2 = runOptions(p, "eval");
+  const root = repoRoot(path34.resolve(base2.dir));
+  const truths = new Map(questions.map((q) => [q.id, truthOf(q, root)]));
+  const workers = [...new Set(p.flags.get("worker") ?? [effective().worker.value])];
+  const group = flag(p, "group") ?? `eval-${(/* @__PURE__ */ new Date()).toISOString().slice(11, 19).replace(/:/g, "")}`;
+  const started = workers.flatMap(
+    (worker) => questions.map((q) => ({ q, worker, meta: startInBackground(prepareRun({ ...runOptions(p, q.task), worker, auditRate: 0, noFallback: true, group })) }))
+  );
+  if (!has(p, "json")) console.error(`pitroom eval "${group}": ${questions.length} questions \xD7 ${workers.length} worker${workers.length === 1 ? "" : "s"} started (pitroom watch -g ${group})`);
+  const rounds = Math.ceil(started.length / effective().maxParallel.value);
+  const { metas } = await waitMany(started.map((s) => s.meta.id), { any: false, timeoutMs: (base2.timeoutSec * rounds + 120) * 1e3 });
+  const rows = started.map((s, i) => {
+    const m = metas[i];
+    const answer = readRunFile(m.id, "summary.md") ?? "";
+    const res = m.state === "done" ? scoreAnswer(s.q, truths.get(s.q.id), answer, root) : { score: 0, got: `(${m.state})` };
+    const seconds = m.endedAt ? Math.round((Date.parse(m.endedAt) - Date.parse(m.startedAt)) / 1e3) : void 0;
+    return { question: s.q.id, kind: s.q.kind, worker: s.worker, run: m.id, state: m.state, score: res.score, got: res.got, seconds, tokens: m.usage?.total };
+  });
+  console.log(has(p, "json") ? JSON.stringify({ group, truths: Object.fromEntries(truths), summary: summarize(rows), rows }, null, 2) : formatEval(rows, group));
+  return 0;
+}
 function selectIds(p, fallback) {
   const group = flag(p, "group");
   if (group) {
@@ -7123,13 +7892,13 @@ function sinceMs(s) {
   if (!m) throw new UserError("--since takes 7d, 30d, \u2026 or all");
   return Date.now() - Number(m[1]) * 864e5;
 }
-var readStdin = () => process.stdin.isTTY ? "" : fs36.readFileSync(0, "utf8");
+var readStdin = () => process.stdin.isTTY ? "" : fs39.readFileSync(0, "utf8");
 function cmdStatusline(p) {
   const input = readStdin();
   const lines = [];
   const then = flag(p, "then");
   if (then) {
-    const r = process.platform === "win32" ? spawnSync8(then, { shell: true, input, encoding: "utf8", timeout: 5e3 }) : spawnSync8("/bin/sh", ["-c", then], { input, encoding: "utf8", timeout: 5e3 });
+    const r = process.platform === "win32" ? spawnSync11(then, { shell: true, input, encoding: "utf8", timeout: 5e3 }) : spawnSync11("/bin/sh", ["-c", then], { input, encoding: "utf8", timeout: 5e3 });
     if (r.stdout?.trimEnd()) lines.push(r.stdout.trimEnd());
   }
   try {
@@ -7163,8 +7932,8 @@ function cmdModels(p) {
   return 0;
 }
 function cmdHookStart() {
-  const script = path32.join(path32.dirname(path32.dirname(fileURLToPath4(import.meta.url))), "hooks", "session-start.mjs");
-  if (fs36.existsSync(script)) spawnSync8(process.execPath, [script], { stdio: ["ignore", "inherit", "ignore"], env: process.env });
+  const script = path34.join(path34.dirname(path34.dirname(fileURLToPath5(import.meta.url))), "hooks", "session-start.mjs");
+  if (fs39.existsSync(script)) spawnSync11(process.execPath, [script], { stdio: ["ignore", "inherit", "ignore"], env: process.env });
   return 0;
 }
 function cmdInit(p) {
@@ -7204,8 +7973,8 @@ function cmdSavings(p) {
   est. saved          ${usd(t.saved)}  (vs ${primaryPrice().name} list prices)`);
   const out = flag(p, "card");
   if (out) {
-    fs36.writeFileSync(out, card(t, period));
-    console.log(`card written to ${path32.resolve(out)}`);
+    fs39.writeFileSync(out, card(t, period));
+    console.log(`card written to ${path34.resolve(out)}`);
   }
   if (has(p, "badge")) console.log(`![pitroom](${badgeUrl(t)})`);
   return 0;
@@ -7247,7 +8016,7 @@ function cmdConfig(p) {
     console.log(JSON.stringify({ path: configPath(), settings: eff, warnings }, null, 2));
     return 0;
   }
-  console.log(`config file: ${configPath()}${fs36.existsSync(configPath()) ? "" : " (not present)"}`);
+  console.log(`config file: ${configPath()}${fs39.existsSync(configPath()) ? "" : " (not present)"}`);
   for (const [key, s] of Object.entries(eff)) {
     const v = Array.isArray(s.value) ? s.value.join(", ") || "\u2014" : s.value && typeof s.value === "object" ? Object.entries(s.value).map(([k, m]) => `${k}=${m}`).join(", ") || "\u2014" : s.value === void 0 ? key === "model" ? "the worker's default" : "\u2014" : String(s.value);
     console.log(`  ${key.padEnd(15)} ${v}  (${s.source})`);
@@ -7271,7 +8040,7 @@ function cmdClean(p) {
     const m = readMeta(id);
     if (m.mode === "isolate" && !m.discarded && !m.applied) discardRun(m);
     recordRun(m);
-    fs36.rmSync(runDir(id), { recursive: true, force: true });
+    fs39.rmSync(runDir(id), { recursive: true, force: true });
   }
   const snapshots = prune(Date.now(), 0);
   console.log(`removed ${old.length} run(s)${snapshots ? ` and ${snapshots} read snapshot${snapshots === 1 ? "" : "s"}` : ""}; the history and the savings ledger are kept`);
@@ -7281,10 +8050,10 @@ var cmdRevert = (p) => (console.log(revertRun(freshMeta(resolveRun(p.positional[
 var cmdDiscard = (p) => (console.log(discardRun(freshMeta(resolveRun(p.positional[0])))), 0);
 
 // src/core/doctor.ts
-import { spawnSync as spawnSync9 } from "node:child_process";
-import fs37 from "node:fs";
-import os11 from "node:os";
-import path33 from "node:path";
+import { spawnSync as spawnSync12 } from "node:child_process";
+import fs40 from "node:fs";
+import os12 from "node:os";
+import path35 from "node:path";
 var MARK2 = { ok: () => green("\u2714"), warn: () => yellow("!"), fail: () => red("\u2718") };
 var NEXT = [
   { when: /no default model|no fallback workers/, command: "pitroom init", why: "propose a starter config (fallback models from your catalogue)" },
@@ -7307,14 +8076,14 @@ function usageLine() {
   return `${ids.length} run${ids.length === 1 ? "" : "s"} so far${when2} (pitroom savings shows what they saved)`;
 }
 function firstNodeOnPath() {
-  for (const dir of (process.env.PATH ?? "").split(path33.delimiter).filter(Boolean)) {
-    const file2 = path33.join(dir, process.platform === "win32" ? "node.exe" : "node");
+  for (const dir of (process.env.PATH ?? "").split(path35.delimiter).filter(Boolean)) {
+    const file2 = path35.join(dir, process.platform === "win32" ? "node.exe" : "node");
     try {
-      if (!fs37.statSync(file2).isFile()) continue;
+      if (!fs40.statSync(file2).isFile()) continue;
     } catch {
       continue;
     }
-    const r = spawnSync9(file2, ["-p", "process.versions.node"], { encoding: "utf8", timeout: 5e3 });
+    const r = spawnSync12(file2, ["-p", "process.versions.node"], { encoding: "utf8", timeout: 5e3 });
     return r.status === 0 ? { path: file2, version: r.stdout.trim() } : { path: file2, version: "" };
   }
   return void 0;
@@ -7329,7 +8098,7 @@ var READ_ONLY_HOW = {
   "tool-allowlist": "a tool allowlist",
   "approval-mode": "the CLI's read-only approval mode"
 };
-function doctor5(probe) {
+function doctor7(probe) {
   const checks = [];
   let current = "Setup";
   const section2 = (name) => void (current = name);
@@ -7337,12 +8106,12 @@ function doctor5(probe) {
   const addAll = (list2) => list2.forEach((c) => add(c.level, c.message));
   add("ok", `pitroom ${VERSION2} \xB7 node ${process.versions.node} \xB7 state in ${home()}`);
   const onPath = firstNodeOnPath();
-  if (onPath && onPath.version && tooOld(onPath.version) && path33.resolve(onPath.path) !== path33.resolve(process.execPath)) {
+  if (onPath && onPath.version && tooOld(onPath.version) && path35.resolve(onPath.path) !== path35.resolve(process.execPath)) {
     add("warn", `the first \`node\` on PATH is v${onPath.version} (${onPath.path}), older than the 22.13 Pitroom needs: shells that agent apps start may use it (the pitroom command finds a newer Node itself; other tools may not)`);
   }
   add(gitAvailable() ? "ok" : "warn", gitAvailable() ? "git available" : "git not found: --write/--isolate tracking disabled");
   const cfg = loadConfig();
-  add(cfg.warnings.length ? "warn" : "ok", `config: ${configPath()}${fs37.existsSync(configPath()) ? "" : " (not present, defaults in use)"}`);
+  add(cfg.warnings.length ? "warn" : "ok", `config: ${configPath()}${fs40.existsSync(configPath()) ? "" : " (not present, defaults in use)"}`);
   for (const w of cfg.warnings) add("warn", w);
   if (shimReady()) add("ok", "git guard shim ready");
   else if (process.platform === "win32") add("warn", "git guard: the ref and push guard is on, but the git shim needs the sh.exe of Git for Windows next to git (not found), so a worker's `git add`, `restore` or `clean` is not blocked; prefer --isolate and check the patch before apply");
@@ -7485,7 +8254,7 @@ function liveProbe(target) {
     title: "pitroom doctor probe"
   });
   const t0 = Date.now();
-  const r = spawnSync9(inv.command, inv.args, {
+  const r = spawnSync12(inv.command, inv.args, {
     encoding: "utf8",
     timeout: 3e5,
     stdio: ["ignore", "pipe", "pipe"],
@@ -7515,20 +8284,20 @@ function skillChecks() {
     else if (!viaPlugin) checks.push({ level: "warn", message: `no Pitroom skills in ${base2}; run \`pitroom install\`` });
   }
   if (geminiExtensionInstalled()) {
-    const linked = installedSkills().some((i) => i.base.includes(`${path33.sep}.agents${path33.sep}`) && i.names.length);
+    const linked = installedSkills().some((i) => i.base.includes(`${path35.sep}.agents${path35.sep}`) && i.names.length);
     checks.push(
       linked ? { level: "warn", message: "Pitroom is installed as a Gemini CLI extension and linked into ~/.agents/skills: Gemini loads the skills twice; run `pitroom uninstall` or `gemini extensions uninstall pitroom`" } : { level: "ok", message: "Gemini CLI extension installed (skills + context)" }
     );
   }
   if (viaPlugin) {
-    const linked = installedSkills().some((i) => i.base.includes(`${path33.sep}.claude${path33.sep}`) && i.names.length);
+    const linked = installedSkills().some((i) => i.base.includes(`${path35.sep}.claude${path35.sep}`) && i.names.length);
     checks.push(
       linked ? { level: "warn", message: "Pitroom is installed as a Claude Code plugin and linked into ~/.claude/skills: skills load twice; run `pitroom uninstall` or remove the plugin" } : { level: "ok", message: "Claude Code plugin installed (skills + session-start hook)" }
     );
   }
   const launcher = launcherPath();
-  if (fs37.existsSync(launcher)) {
-    const r = spawnSync9(launcher, ["--version"], { encoding: "utf8", timeout: 3e4, stdio: ["ignore", "pipe", "pipe"], shell: process.platform === "win32" });
+  if (fs40.existsSync(launcher)) {
+    const r = spawnSync12(launcher, ["--version"], { encoding: "utf8", timeout: 3e4, stdio: ["ignore", "pipe", "pipe"], shell: process.platform === "win32" });
     checks.push(
       r.status === 0 ? { level: "ok", message: `launcher ${launcher} \u2192 pitroom ${r.stdout.trim()}` } : { level: "fail", message: `launcher ${launcher} does not start: ${(r.stderr || r.stdout).trim().slice(0, 200)}` }
     );
@@ -7538,13 +8307,13 @@ function skillChecks() {
   return checks;
 }
 function geminiExtensionInstalled() {
-  const home3 = process.env.GEMINI_CLI_HOME ?? os11.homedir();
-  return fs37.existsSync(path33.join(home3, ".gemini", "extensions", "pitroom"));
+  const home3 = process.env.GEMINI_CLI_HOME ?? os12.homedir();
+  return fs40.existsSync(path35.join(home3, ".gemini", "extensions", "pitroom"));
 }
 function pluginInstalled() {
   try {
-    const f = path33.join(os11.homedir(), ".claude", "plugins", "installed_plugins.json");
-    const plugins = JSON.parse(fs37.readFileSync(f, "utf8")).plugins ?? {};
+    const f = path35.join(os12.homedir(), ".claude", "plugins", "installed_plugins.json");
+    const plugins = JSON.parse(fs40.readFileSync(f, "utf8")).plugins ?? {};
     return Object.keys(plugins).some((k) => k.startsWith("pitroom@"));
   } catch {
     return false;
@@ -7561,24 +8330,24 @@ function superpowersActive() {
   for (const p of openCodePlugins()) {
     if (/superpowers/i.test(p)) found.push(`OpenCode plugin ${p}`);
   }
-  for (const base2 of [path33.join(os11.homedir(), ".agents", "skills"), path33.join(os11.homedir(), ".claude", "skills")]) {
-    const dir = path33.join(base2, "using-superpowers");
-    if (fs37.existsSync(path33.join(dir, "SKILL.md"))) found.push(dir);
+  for (const base2 of [path35.join(os12.homedir(), ".agents", "skills"), path35.join(os12.homedir(), ".claude", "skills")]) {
+    const dir = path35.join(base2, "using-superpowers");
+    if (fs40.existsSync(path35.join(dir, "SKILL.md"))) found.push(dir);
   }
   return found;
 }
 function claudePlugins() {
   try {
-    const f = path33.join(os11.homedir(), ".claude", "plugins", "installed_plugins.json");
-    return Object.keys(JSON.parse(fs37.readFileSync(f, "utf8")).plugins ?? {});
+    const f = path35.join(os12.homedir(), ".claude", "plugins", "installed_plugins.json");
+    return Object.keys(JSON.parse(fs40.readFileSync(f, "utf8")).plugins ?? {});
   } catch {
     return [];
   }
 }
 function claudePluginEnabled(key) {
   try {
-    const f = path33.join(os11.homedir(), ".claude", "settings.json");
-    return JSON.parse(fs37.readFileSync(f, "utf8")).enabledPlugins?.[key] !== false;
+    const f = path35.join(os12.homedir(), ".claude", "settings.json");
+    return JSON.parse(fs40.readFileSync(f, "utf8")).enabledPlugins?.[key] !== false;
   } catch {
     return true;
   }
@@ -7587,7 +8356,7 @@ function codexPlugins() {
   const plugins = /* @__PURE__ */ new Map();
   let text;
   try {
-    text = fs37.readFileSync(path33.join(process.env.CODEX_HOME ?? path33.join(os11.homedir(), ".codex"), "config.toml"), "utf8");
+    text = fs40.readFileSync(path35.join(process.env.CODEX_HOME ?? path35.join(os12.homedir(), ".codex"), "config.toml"), "utf8");
   } catch {
     return plugins;
   }
@@ -7605,11 +8374,11 @@ function codexPlugins() {
   return plugins;
 }
 function openCodePlugins() {
-  const dir = path33.join(process.env.XDG_CONFIG_HOME ?? path33.join(os11.homedir(), ".config"), "opencode");
+  const dir = path35.join(process.env.XDG_CONFIG_HOME ?? path35.join(os12.homedir(), ".config"), "opencode");
   const plugins = [];
   for (const name of ["opencode.json", "opencode.jsonc"]) {
     try {
-      const text = fs37.readFileSync(path33.join(dir, name), "utf8").replace(/\/\*[\s\S]*?\*\/|^\s*\/\/.*$/gm, "");
+      const text = fs40.readFileSync(path35.join(dir, name), "utf8").replace(/\/\*[\s\S]*?\*\/|^\s*\/\/.*$/gm, "");
       const list2 = JSON.parse(text).plugin;
       if (Array.isArray(list2)) plugins.push(...list2.filter((p) => typeof p === "string"));
     } catch {
@@ -7617,7 +8386,7 @@ function openCodePlugins() {
   }
   for (const folder of ["plugin", "plugins"]) {
     try {
-      for (const f of fs37.readdirSync(path33.join(dir, folder))) plugins.push(path33.join(dir, folder, f));
+      for (const f of fs40.readdirSync(path35.join(dir, folder))) plugins.push(path35.join(dir, folder, f));
     } catch {
     }
   }
@@ -7639,6 +8408,9 @@ Usage
                                         fix round) or of a commit range; by default on another worker
   pitroom audit RUN [-W worker]         another worker re-checks a read run's answer (AGREE / PARTIAL / DISAGREE);
                                         "audit" in the config (0 to 1) does it for a share of read runs
+  pitroom eval QUESTIONS.json [-W worker]\u2026 [--json]
+                                        your questions with known answers, put to each worker and scored
+                                        (definition: path:line, count: the number, set: F1 of the paths)
   pitroom plan status PLAN [--json]     a plan's progress: runs, STATUS, review, fix rounds, applied
   pitroom plan note PLAN "Task N: \u2026"    record a completion, deferred finding or ruling (outside the repo)
   pitroom status [run | -g NAME]        state / live progress (default: latest run)
@@ -7722,14 +8494,17 @@ Workers: ${backendIds().join(", ")} (targets: "opencode", "opencode:provider/mod
 Env: PITROOM_WORKER, PITROOM_MODEL, PITROOM_FALLBACK="t1,t2", PITROOM_TIMEOUT, PITROOM_MAX_PARALLEL,
      PITROOM_PRIMARY=sonnet|opus|haiku|gpt-5, PITROOM_PRICE="in,out", PITROOM_HOME, PITROOM_CONFIG, PITROOM_CACHE_DAYS,
      PITROOM_NOTIFY, PITROOM_NOTIFY_COMMAND, PITROOM_NOTIFY_AFTER, PITROOM_MCP_DASH, PITROOM_PRICE_FEED, PITROOM_PRICE_FEED_URL,
-     PITROOM_PRICE_FEED_HOURS, PITROOM_<WORKER>_BIN
+     PITROOM_PRICE_FEED_HOURS, PITROOM_AUDIT, PITROOM_AUDIT_FIX, PITROOM_AUDIT_FOCUS, PITROOM_BUDGET_DAILY, PITROOM_RANK_WORKERS,
+     PITROOM_<WORKER>_BIN
 Config: ~/.config/pitroom/config.json (worker, fallback, models, tiers, timeout, primary, price, link, web, maxParallel, audit, readIn, cacheDays,
-        countRateLimits, mcpDash, notify, notifyCommand, notifyAfter, workerPrices, priceFeed, priceFeedUrl, priceFeedHours)`;
+        countRateLimits, mcpDash, notify, notifyCommand, notifyAfter, workerPrices, priceFeed, priceFeedUrl, priceFeedHours,
+        auditFix, auditFocus, budgetDaily, rankWorkers)`;
 var COMMANDS = {
   run: cmdRun,
   crew: cmdCrew,
   review: cmdReview,
   audit: cmdAudit,
+  eval: cmdEval,
   cooldown: cmdCooldown,
   prices: cmdPrices,
   mcp: (p) => {
@@ -7738,7 +8513,7 @@ var COMMANDS = {
     if (port !== void 0 && !(/^\d+$/.test(port) && Number(port) <= 65535)) throw new UserError("--port takes a number from 0 to 65535 (0 picks a free one)");
     const dir = flag(p, "dir");
     if (dir !== void 0) {
-      if (!fs38.statSync(dir, { throwIfNoEntry: false })?.isDirectory()) throw new UserError(`-d ${dir}: no such directory`);
+      if (!fs41.statSync(dir, { throwIfNoEntry: false })?.isDirectory()) throw new UserError(`-d ${dir}: no such directory`);
       process.chdir(dir);
       process.env.PWD = process.cwd();
     }
@@ -7762,7 +8537,7 @@ var COMMANDS = {
   statusline: cmdStatusline,
   "hook-card": cmdHookCard,
   "hook-start": cmdHookStart,
-  doctor: (p) => doctor5(has(p, "probe")),
+  doctor: (p) => doctor7(has(p, "probe")),
   config: cmdConfig,
   init: cmdInit,
   install: cmdInstall,