pitroom 0.15.0 → 0.17.0

package/dist/pitroom.mjs

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
 
+// src/cli.ts
+import fs35 from "node:fs";
+
 // src/core/errors.ts
 var UserError = class extends Error {
   constructor(message, code = 2) {
@@ -1417,7 +1420,8 @@ var SCHEMA = {
   tiers: "record",
   costs: "numbers",
   audit: "number",
-  readIn: "string"
+  readIn: "string",
+  cacheDays: "number"
 };
 function configPath() {
   if (process.env.PITROOM_CONFIG) return path7.resolve(process.env.PITROOM_CONFIG);
@@ -1475,6 +1479,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 days = (v) => {
+  const n = typeof v === "string" && v.trim() !== "" ? Number(v) : v;
+  return typeof n === "number" && Number.isInteger(n) && n >= 0 ? n : void 0;
+};
 var readIn = (v) => v === "auto" || v === "snapshot" || v === "project" ? v : void 0;
 var list = (s) => s?.split(",").map((x) => x.trim()).filter(Boolean);
 function setting(flag2, env, conf, fallback) {
@@ -1501,7 +1509,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),
-    readIn: setting(void 0, readIn(e.PITROOM_READ_IN), readIn(c.readIn), "auto")
+    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)
   };
 }
 
@@ -1578,6 +1587,8 @@ var BOOL_FLAGS = {
   "--stop": "stop",
   "--open": "open",
   "--serve": "serve",
+  "--fresh": "fresh",
+  "--http": "http",
   "-h": "help",
   "--help": "help",
   "-v": "version",
@@ -1680,7 +1691,6 @@ function effortFlag(p) {
 }
 
 // src/cli/mcp.ts
-import { spawn as spawn3 } from "node:child_process";
 import readline from "node:readline";
 
 // src/core/run.ts
@@ -1727,16 +1737,16 @@ function repoRoot(dir) {
   const r = git(dir, ["rev-parse", "--show-toplevel"]);
   return r.code === 0 ? path8.resolve(r.stdout.trim()) : void 0;
 }
-function snapshotTree(root, exclude = [], drop = []) {
+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 env = { ...process.env, GIT_INDEX_FILE: tmp };
   try {
     if (fs9.existsSync(real)) fs9.copyFileSync(real, tmp);
     else must(root, ["read-tree", "--empty"], env);
-    must(root, ["add", "-A", "--", ":/", ...exclude.map((p) => `:(top,exclude)${p}`), ...drop.map((p) => `:(top,literal,exclude)${p}`)], env);
-    if (drop.length) {
-      const r = spawnSync5("git", ["update-index", "--force-remove", "-z", "--stdin"], { cwd: root, env, input: `${drop.join("\0")}\0`, encoding: "utf8" });
+    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" });
       if (r.status !== 0) throw new Error(`git update-index failed: ${r.stderr.trim()}`);
     }
     return must(root, ["write-tree"], env).trim();
@@ -1801,6 +1811,7 @@ ${must(root, [...DIFF, "-U10", a, b])}`;
 }
 function rangeDiff(root, a, b) {
   const range = `${a}..${b}`;
+  const since2 = git(root, ["merge-base", a, b]).code === 0 ? `${a}...${b}` : range;
   const log2 = must(root, ["log", "--oneline", "--no-decorate", range]).trim();
   return [
     `## COMMITS
@@ -1808,10 +1819,10 @@ function rangeDiff(root, a, b) {
 ${log2 || "(none)"}`,
     `## FILES CHANGED
 
-${must(root, [...DIFF, "--stat", range]).trim() || "(none)"}`,
+${must(root, [...DIFF, "--stat", since2]).trim() || "(none)"}`,
     `## DIFF
 
-${must(root, [...DIFF, "-U10", range])}`
+${must(root, [...DIFF, "-U10", since2])}`
   ].join("\n\n");
 }
 function commitOf(root, ref) {
@@ -2046,7 +2057,7 @@ async function spawnWorker(inv, opts) {
   process.once("SIGINT", stop);
   process.once("SIGTERM", stop);
   let killer;
-  const timer = setTimeout(() => {
+  const timer2 = setTimeout(() => {
     res.timedOut = true;
     child.kill("SIGTERM");
     killer = setTimeout(() => child.kill("SIGKILL"), 1e4);
@@ -2058,7 +2069,7 @@ async function spawnWorker(inv, opts) {
     });
     child.on("close", (c) => resolve2(c));
   });
-  clearTimeout(timer);
+  clearTimeout(timer2);
   if (killer) clearTimeout(killer);
   process.off("SIGINT", stop);
   process.off("SIGTERM", stop);
@@ -2231,8 +2242,8 @@ function wantSnapshot(readIn2, root, dir) {
   return readIn2 === "snapshot" || secrets.length ? { secrets } : void 0;
 }
 function readSnapshot(root) {
-  const drop = findSecretFilesInTree(root, root);
-  const tree = snapshotTree(root, [], drop);
+  const drop2 = findSecretFilesInTree(root, root);
+  const tree = snapshotTree(root, [], drop2);
   const dest = path12.join(snapshotsDir(), tree);
   if (fs14.existsSync(path12.join(dest, ".git"))) {
     touch(dest);
@@ -2374,6 +2385,9 @@ function auditTask(meta, answer) {
   return [
     "You are auditing another worker's answer to a read-only question about this project. Do not take the answer on trust:",
     "check its key claims yourself against the files here (open the cited files and lines, search for what it says exists or is missing).",
+    "Check the answer against the QUESTION, not only its own claims: every condition the question sets (a directory or scope,",
+    'what to leave out, "all", "only", "exactly", a count) must hold. Valid references do not make an answer right:',
+    "for a list, look for items that are missing and items that do not belong; for a count, count again yourself.",
     "Do not edit anything and do not run anything that changes files.",
     "",
     "QUESTION:",
@@ -2388,7 +2402,7 @@ function auditTask(meta, answer) {
     "DISPUTED:",
     "- <the claim> \u2014 <what is actually true, with path:line>",
     "",
-    "AGREE: every key claim you checked holds. PARTIAL: some are wrong or could not be verified. DISAGREE: the main conclusion is wrong.",
+    "AGREE: every key claim you checked holds and the answer meets every condition of the question (no extra or missing items, the right count). PARTIAL: some are wrong, unverified, or the answer goes beyond or falls short of the question's scope. DISAGREE: the main conclusion is wrong.",
     'Under DISPUTED list only claims you checked and found wrong or unsupported; write "- (none)" when there are none.'
   ].join("\n");
 }
@@ -2574,18 +2588,18 @@ function place(src, dest, opts) {
 }
 function install(opts) {
   const root = packageRoot();
-  const skills = opts.skills === false ? [] : skillNames(root);
-  if (opts.skills !== false && !skills.length) throw new Error(`no skills found under ${path14.join(root, "skills")}`);
+  const skills2 = opts.skills === false ? [] : skillNames(root);
+  if (opts.skills !== false && !skills2.length) throw new Error(`no skills found under ${path14.join(root, "skills")}`);
   const out = [];
   for (const base2 of opts.skills === false ? [] : skillTargets()) {
     for (const legacy of LEGACY) {
       const l = path14.join(base2, legacy);
-      if (!skills.includes(legacy) && linksInto(l, root)) {
+      if (!skills2.includes(legacy) && linksInto(l, root)) {
         fs16.unlinkSync(l);
         out.push(`\u2714 removed old link ${l}`);
       }
     }
-    for (const name of skills) out.push(place(path14.join(root, "skills", name), path14.join(base2, name), opts));
+    for (const name of skills2) out.push(place(path14.join(root, "skills", name), path14.join(base2, name), opts));
   }
   const bundle = path14.join(root, "dist", "pitroom.mjs");
   if (fs16.existsSync(bundle)) {
@@ -3129,12 +3143,12 @@ function hookCards(input) {
   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) => fs21.existsSync(`${runsDir()}/${id}`));
-  const since = Date.now() - RECENT_HOURS * 36e5;
+  const since2 = Date.now() - RECENT_HOURS * 36e5;
   for (const id of listRunIds().slice(-RECENT)) {
     if (ids.includes(id) || fs21.existsSync(runFile(id, "card-ended"))) continue;
     try {
       const m = readMeta(id);
-      if (!isActive(m.state) && Date.parse(m.endedAt ?? m.startedAt) > since) ids.push(id);
+      if (!isActive(m.state) && Date.parse(m.endedAt ?? m.startedAt) > since2) ids.push(id);
     } catch {
     }
   }
@@ -3347,6 +3361,7 @@ function archivedId(ref) {
     return void 0;
   }
 }
+var VERIFY_FAILED = "(r.state = 'done' AND json_extract(r.meta_json, '$.verifyResult.ok') = 0)";
 var ftsQuery = (text) => text.split(/\s+/).filter(Boolean).map((w) => `"${w.replace(/"/g, '""')}"*`).join(" ");
 function listHistory(q = {}) {
   const db = openDb();
@@ -3366,7 +3381,7 @@ function listHistory(q = {}) {
     args.push(q.backend);
   }
   if (q.state) {
-    where.push(q.state === "problem" ? "r.state IN ('failed','timeout','stopped')" : "r.state = ?");
+    where.push(q.state === "problem" ? `(r.state IN ('failed','timeout','stopped') OR ${VERIFY_FAILED})` : "r.state = ?");
     if (q.state !== "problem") args.push(q.state);
   }
   if (q.group) {
@@ -3381,7 +3396,7 @@ function listHistory(q = {}) {
   try {
     const total = db.prepare(`SELECT COUNT(*) AS n FROM runs r ${base2}`).get(...args).n;
     const page = q.beforeId ? `${base2 ? `${base2} AND` : "WHERE"} r.id < ?` : base2;
-    const rows = db.prepare(`SELECT r.*, json_extract(r.meta_json, '$.audit.state') AS audit_state, json_extract(r.meta_json, '$.audit.verdict') AS audit_verdict FROM runs r ${page} ORDER BY r.id DESC LIMIT ?`).all(...args, ...q.beforeId ? [q.beforeId] : [], Math.min(Math.max(q.limit ?? 30, 1), 200));
+    const rows = db.prepare(`SELECT r.*, json_extract(r.meta_json, '$.audit.state') AS audit_state, json_extract(r.meta_json, '$.audit.verdict') AS audit_verdict, ${VERIFY_FAILED} AS verify_failed FROM runs r ${page} ORDER BY r.id DESC LIMIT ?`).all(...args, ...q.beforeId ? [q.beforeId] : [], Math.min(Math.max(q.limit ?? 30, 1), 200));
     return {
       total,
       rows: rows.map((r) => ({
@@ -3395,6 +3410,7 @@ function listHistory(q = {}) {
         group: r.grp ?? void 0,
         verdict: r.verdict ?? void 0,
         audit: auditBadge({ audit: r.audit_state ? { id: "", state: r.audit_state, verdict: r.audit_verdict ?? void 0 } : void 0 }),
+        verifyFailed: r.verify_failed ? true : void 0,
         seconds: r.seconds ?? void 0,
         steps: r.steps ?? void 0,
         tokens: r.tokens ?? void 0,
@@ -3408,17 +3424,17 @@ function listHistory(q = {}) {
   }
 }
 var NOT_AUDIT = "json_extract(meta_json, '$.auditOf') IS NULL";
-function auditStats(db, since) {
+function auditStats(db, since2) {
   const total = { runs: 0, agree: 0, partial: 0, disagree: 0, unclear: 0, tokens: 0 };
   const byWorker = /* @__PURE__ */ new Map();
   try {
-    const t = db.prepare("SELECT COUNT(*) runs, COALESCE(SUM(tokens),0) tokens FROM runs WHERE started_at >= ? AND json_extract(meta_json, '$.auditOf') IS NOT NULL").get(since);
+    const t = db.prepare("SELECT COUNT(*) runs, COALESCE(SUM(tokens),0) tokens FROM runs WHERE started_at >= ? AND json_extract(meta_json, '$.auditOf') IS NOT NULL").get(since2);
     total.runs = t.runs;
     total.tokens = t.tokens;
     const rows = db.prepare(`SELECT r.backend, 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 a.started_at >= ? AND a.state = 'done' AND json_extract(a.meta_json, '$.auditOf') IS NOT NULL
-      GROUP BY r.backend, r.model, v`).all(since);
+      GROUP BY r.backend, r.model, v`).all(since2);
     for (const r of rows) {
       const v = r.v ?? "unclear";
       if (v in total && v !== "runs" && v !== "tokens") total[v] += r.n;
@@ -3456,12 +3472,12 @@ function historyStats(sinceMs2) {
   const empty = { totals: { runs: 0, ok: 0, failed: 0, seconds: 0, tokens: 0, saved: 0 }, audits: { runs: 0, agree: 0, partial: 0, disagree: 0, unclear: 0, tokens: 0 }, byWorker: [], byDay: [] };
   const db = openDb();
   if (!db) return empty;
-  const since = sinceMs2 ? new Date(sinceMs2).toISOString() : "";
+  const since2 = sinceMs2 ? new Date(sinceMs2).toISOString() : "";
   try {
-    const t = db.prepare(`SELECT COUNT(*) runs, COALESCE(SUM(state='done'),0) ok, COALESCE(SUM(seconds),0) seconds, COALESCE(SUM(tokens),0) tokens, COALESCE(SUM(saved),0) saved FROM runs WHERE started_at >= ? AND ${NOT_AUDIT}`).get(since);
-    const w = db.prepare(`SELECT backend, model, COUNT(*) runs, SUM(state='done') ok, AVG(seconds) avg_s, AVG(tokens) avg_t, COALESCE(SUM(saved),0) saved FROM runs WHERE started_at >= ? AND ${NOT_AUDIT} GROUP BY backend, model ORDER BY runs DESC LIMIT 40`).all(since);
-    const d = db.prepare(`SELECT substr(started_at,1,10) day, COUNT(*) runs, SUM(state='done') ok, COALESCE(SUM(saved),0) saved FROM runs WHERE started_at >= ? AND ${NOT_AUDIT} GROUP BY day ORDER BY day DESC LIMIT 60`).all(since);
-    const audits = auditStats(db, since);
+    const t = db.prepare(`SELECT COUNT(*) runs, COALESCE(SUM(state='done'),0) ok, COALESCE(SUM(seconds),0) seconds, COALESCE(SUM(tokens),0) tokens, COALESCE(SUM(saved),0) saved FROM runs WHERE started_at >= ? AND ${NOT_AUDIT}`).get(since2);
+    const w = db.prepare(`SELECT backend, model, COUNT(*) runs, SUM(state='done') ok, AVG(seconds) avg_s, AVG(tokens) avg_t, COALESCE(SUM(saved),0) saved FROM runs WHERE started_at >= ? AND ${NOT_AUDIT} GROUP BY backend, model ORDER BY runs DESC LIMIT 40`).all(since2);
+    const d = db.prepare(`SELECT substr(started_at,1,10) day, COUNT(*) runs, SUM(state='done') ok, COALESCE(SUM(saved),0) saved FROM runs WHERE started_at >= ? AND ${NOT_AUDIT} GROUP BY day ORDER BY day DESC LIMIT 60`).all(since2);
+    const audits = auditStats(db, since2);
     const ledger = readLedger(sinceMs2);
     const byDay = /* @__PURE__ */ new Map();
     for (const e of ledger) byDay.set(e.at.slice(0, 10), (byDay.get(e.at.slice(0, 10)) ?? 0) + e.saved);
@@ -3541,7 +3557,9 @@ function readSummary(meta) {
 }
 function formatReport(meta, finalText = readSummary(meta), maxLines = 400) {
   const out = [];
-  out.push(`${bold("pitroom")} ${stateColour(meta.state, `${ICON2[meta.state]} ${meta.state}`)} \xB7 ${meta.mode} \xB7 ${duration(meta)} \xB7 run ${dim(meta.id)}`);
+  const verifyFailed = meta.state === "done" && meta.verifyResult && !meta.verifyResult.ok;
+  const head = verifyFailed ? stateColour("failed", "\u26A0 done \xB7 verify failed") : stateColour(meta.state, `${ICON2[meta.state]} ${meta.state}`);
+  out.push(`${bold("pitroom")} ${head} \xB7 ${meta.mode} \xB7 ${duration(meta)} \xB7 run ${dim(meta.id)}`);
   const ran = meta.ran ?? meta.worker;
   const ids = [`worker ${ran.backend}`, meta.resolvedModel && `model ${meta.resolvedModel}`, meta.sessionId && `session ${meta.sessionId}`];
   out.push(ids.filter(Boolean).join(" \xB7 "));
@@ -3607,7 +3625,9 @@ function formatReport(meta, finalText = readSummary(meta), maxLines = 400) {
   }
   if (meta.verifyResult) {
     const v = meta.verifyResult;
-    out.push(`\u2500\u2500 verify: \`${meta.verify}\` ${v.ok ? "\u2714 passed" : `\u2718 failed (exit ${v.code})`}`);
+    const notFound = !v.ok && v.code === 127 && /not found|no such file/i.test(v.tail);
+    out.push(`\u2500\u2500 verify: \`${meta.verify}\` ${v.ok ? "\u2714 passed" : notFound ? "\u2718 could not run (exit 127: command not found)" : `\u2718 failed (exit ${v.code})`}`);
+    if (notFound) out.push("   the command is not on the PATH Pitroom runs with (an app such as an MCP client may start it without your shell's PATH): give its full path, or set PATH in the command");
     if (!v.ok && v.tail) out.push(...v.tail.split("\n").map((l) => `   ${l}`));
   }
   if (isActive(meta.state)) {
@@ -3631,7 +3651,7 @@ function progress(meta) {
 }
 
 // src/core/run.ts
-var VERSION2 = true ? "0.15.0" : "0.0.0-dev";
+var VERSION2 = true ? "0.17.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");
@@ -3729,6 +3749,7 @@ function prepareRun(o) {
     auditOf: o.audit?.of,
     auditRate: o.auditRate,
     inPlace: o.inPlace || void 0,
+    cache: o.cache,
     snapshot: parent?.snapshot ?? (snap ? { dir: "", tree: "", left: snap.secrets } : void 0),
     plan: work.plan ?? o.review?.plan ?? parent?.plan,
     reviewKind: o.review?.kind,
@@ -4000,6 +4021,12 @@ function captureChanges(meta) {
   meta.stats = d.stats;
   fs24.writeFileSync(runFile(meta.id, "changes.patch"), d.patch);
 }
+function verifyPath() {
+  const extra = [path20.dirname(process.execPath), "/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"];
+  const parts = (process.env.PATH ?? "").split(path20.delimiter).filter(Boolean);
+  for (const d of process.platform === "win32" ? [path20.dirname(process.execPath)] : extra) if (!parts.includes(d)) parts.push(d);
+  return parts.join(path20.delimiter);
+}
 function runVerify(meta) {
   const r = spawnSync6(meta.verify, {
     cwd: meta.cwd,
@@ -4008,7 +4035,7 @@ function runVerify(meta) {
     timeout: 15 * 6e4,
     stdio: ["ignore", "pipe", "pipe"],
     maxBuffer: 64 * 1024 * 1024,
-    env: { ...process.env, PWD: meta.cwd, PITROOM_ACTIVE: "1" }
+    env: { ...process.env, PATH: verifyPath(), PWD: meta.cwd, PITROOM_ACTIVE: "1" }
   });
   const output = `${r.stdout ?? ""}${r.stderr ?? ""}`;
   fs24.writeFileSync(runFile(meta.id, "verify.log"), output);
@@ -4059,17 +4086,128 @@ function cleanupWorktree(meta) {
   if (meta.worktree && fs24.existsSync(meta.worktree)) removeIsolatedCopy(meta.worktree, worktreesDir());
 }
 
-// src/cli/mcp.ts
-var PROTOCOLS = ["2025-06-18", "2025-03-26", "2024-11-05"];
+// src/cli/mcp-extras.ts
+import fs25 from "node:fs";
+import path21 from "node:path";
+
+// src/cli/mcp-support.ts
+import { spawn as spawn3 } from "node:child_process";
+
+// src/core/group.ts
+function groupIds(group) {
+  return listRunIds().filter((id) => {
+    try {
+      return readMeta(id).group === group;
+    } catch {
+      return false;
+    }
+  });
+}
+var oneLine5 = (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);
+}
+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);
+    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"];
+  const widths = head.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
+  const fmt = (r, header = false) => r.map((c, i) => {
+    const cell2 = i === r.length - 1 ? c : c.padEnd(widths[i]);
+    return header ? dim(cell2) : i === 1 ? stateColour(r[1], cell2) : cell2;
+  }).join("  ");
+  return [fmt(head, true), ...rows.map((r) => fmt(r))].join("\n");
+}
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+async function waitMany(ids, opts) {
+  const deadline = Date.now() + opts.timeoutMs;
+  for (; ; ) {
+    const metas = ids.map((id) => freshMeta(id));
+    const done = metas.filter((m) => TERMINAL.includes(m.state)).length;
+    if (opts.any ? done > 0 : done === metas.length) return { metas, timedOut: false };
+    if (Date.now() >= deadline) return { metas, timedOut: true };
+    await sleep2(1500);
+  }
+}
+async function watch(select, opts) {
+  const seen = /* @__PURE__ */ new Map();
+  const line = (s) => opts.write(`${s}
+`);
+  const emit = (e, m) => {
+    if (!opts.brief) return opts.write(`${JSON.stringify(e)}
+`);
+    if (e.event === "started" && m) line(startedCard(m));
+    else if (e.event === "fallback" && m) line(`\u{1F3C1} Pitroom \u21BB ${m.id} fell back from ${String(e.failed)}: ${String(e.reason)}`);
+    else if (m && TERMINAL.includes(m.state)) line(endedCard(m));
+    else if (e.event === "all-done") line(`\u{1F3C1} Pitroom: ${String(e.runs)} run${e.runs === 1 ? "" : "s"} finished (${String(e.ok)} ok${e.failed ? `, ${String(e.failed)} not ok` : ""})`);
+  };
+  const deadline = opts.timeoutMs > 0 ? Date.now() + opts.timeoutMs : Infinity;
+  for (; ; ) {
+    const metas = select().map((id) => freshMeta(id));
+    if (opts.json || opts.brief) {
+      for (const m of metas) {
+        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) };
+        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);
+        }
+        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 });
+        }
+        if (TERMINAL.includes(m.state) && prev?.state !== m.state) {
+          emit({
+            event: m.state,
+            run: m.id,
+            time: duration(m),
+            worker: describeTarget(m.ran ?? m.worker),
+            summary: headline(m) || void 0,
+            error: m.error ? oneLine5(m.error, 160) : void 0,
+            refs: m.refs ? `${m.refs.valid}/${m.refs.total}` : void 0,
+            changes: m.changes?.length || void 0
+          }, m);
+        }
+        seen.set(m.id, { state: m.state, steps: l.steps, attempts });
+      }
+    } else {
+      opts.write(`\x1B[H\x1B[2J${table(metas)}
+
+${(/* @__PURE__ */ new Date()).toLocaleTimeString()} \xB7 Ctrl-C to stop watching (workers keep running)
+`);
+    }
+    const allDone = metas.length > 0 && metas.every((m) => TERMINAL.includes(m.state));
+    if (allDone || metas.length === 0 && seen.size === 0) {
+      if (opts.json || opts.brief) {
+        const ok = metas.filter((m) => m.state === "done").length;
+        emit({ event: "all-done", runs: metas.length, ok, failed: metas.length - ok });
+      }
+      return { metas, timedOut: false };
+    }
+    if (Date.now() >= deadline) return { metas, timedOut: true };
+    await sleep2(opts.intervalMs);
+  }
+}
+
+// src/cli/mcp-support.ts
 var MAX_OUTPUT = 12e4;
 var DEFAULT_WAIT = 50;
 var MAX_WAIT = 540;
-var INSTRUCTIONS = [
-  "Pitroom hands bounded work to cheaper worker agents and returns a verified answer, the exact diff and a cost receipt. You decide, verify and answer.",
-  'Use pitroom_run with mode "read" for research and locating code, mode "isolate" for code changes (the worker edits a copy; check it with pitroom_review, then pitroom_apply or pitroom_discard).',
-  'A run can take minutes: pitroom_run waits up to waitSeconds, then returns the run id as "still running"; call pitroom_wait with it.',
-  "It is optional: for a small task you can do yourself, skip it."
-].join(" ");
+var MAX_TASKS = 20;
+var PROGRESS_EVERY_MS = 5e3;
 var ToolError = class extends Error {
 };
 var str = (a, key, required = false) => {
@@ -4105,6 +4243,12 @@ var oneOf = (a, key, allowed, fallback) => {
   if (!allowed.includes(v)) throw new ToolError(`"${key}" must be one of: ${allowed.join(", ")}`);
   return v;
 };
+var since = (a) => {
+  const v = str(a, "since");
+  if (v === void 0) return [];
+  if (v !== "all" && !/^\d+d$/.test(v)) throw new ToolError('"since" takes 7d, 30d, \u2026 or all');
+  return ["--since", v];
+};
 function workerFlags(a, only) {
   const out = [];
   const on = (key) => !only || only.includes(key);
@@ -4122,7 +4266,7 @@ function workerFlags(a, only) {
 var strip = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
 var clip6 = (s) => s.length > MAX_OUTPUT ? `${s.slice(0, MAX_OUTPUT)}
 \u2026 (${s.length - MAX_OUTPUT} more characters)` : s;
-function pit(args, timeoutMs = 60 * 6e4) {
+function pit(args, timeoutMs = 60 * 6e4, signal) {
   return new Promise((resolve2) => {
     const script = process.argv[1];
     if (!script) return resolve2({ code: 1, out: "", err: "cannot locate the pitroom executable" });
@@ -4131,10 +4275,14 @@ function pit(args, timeoutMs = 60 * 6e4) {
     let err = "";
     child.stdout.on("data", (d) => out += d);
     child.stderr.on("data", (d) => err += d);
-    const timer = setTimeout(() => child.kill("SIGTERM"), timeoutMs);
+    const stop = () => child.kill("SIGTERM");
+    const timer2 = setTimeout(stop, timeoutMs);
+    signal?.addEventListener("abort", stop, { once: true });
+    if (signal?.aborted) stop();
     child.on("error", (e) => resolve2({ code: 1, out, err: err || String(e.message) }));
     child.on("close", (code) => {
-      clearTimeout(timer);
+      clearTimeout(timer2);
+      signal?.removeEventListener("abort", stop);
       resolve2({ code, out: strip(out).trim(), err: strip(err).trim() });
     });
   });
@@ -4144,117 +4292,365 @@ function asResult(r, still) {
   if (r.code === 75 && still) return { text: clip6(`${text}
 
 ${still}`) };
-  return { text: clip6(text), isError: r.code === 2 || r.code === 3 || r.code === 1 && !r.out };
+  return { text: clip6(text), isError: r.code === 2 || r.code === 3 || r.code === 5 || r.code === 6 || r.code === 1 && !r.out };
 }
-async function startAndWait(start, seconds, task) {
+var plain = async (args, ctx, timeoutMs = 6e4) => asResult(await pit(args, timeoutMs, ctx.signal));
+function trackProgress(ctx, ids) {
+  const tick2 = () => {
+    try {
+      const lines = ids().map((id) => freshMeta(id)).filter((m) => isActive(m.state)).map((m) => progress(m).replace(/^pitroom\s+/, ""));
+      if (lines.length) ctx.progress(lines.slice(0, 3).join("\n") + (lines.length > 3 ? `
+\u2026 and ${lines.length - 3} more` : ""));
+    } catch {
+    }
+  };
+  const first = setTimeout(tick2, 800);
+  const timer2 = setInterval(tick2, PROGRESS_EVERY_MS);
+  return () => {
+    clearTimeout(first);
+    clearInterval(timer2);
+  };
+}
+async function waitFor(ids, seconds, ctx, group) {
+  const args = group ? ["wait", "-g", group, "--timeout", String(seconds)] : ["wait", ...ids, "--timeout", String(seconds)];
+  const done = trackProgress(ctx, () => group ? groupIds(group) : ids);
+  let r;
+  try {
+    r = await pit(args, (seconds + 60) * 1e3, ctx.signal);
+  } finally {
+    done();
+  }
+  const again = group ? `{"group": "${group}"}` : `{"runs": ${JSON.stringify(ids)}}`;
+  return asResult(r, `Not finished yet: call pitroom_wait with ${again} (waitSeconds up to ${MAX_WAIT}); pitroom_stop ends it.`);
+}
+var cancelled = (ctx) => ctx.signal.aborted && ctx.signal.reason === "cancelled";
+async function stopQuietly(args) {
+  const r = await pit(args, 3e4);
+  if (r.code !== 0) process.stderr.write(`pitroom mcp: ${args.join(" ")} failed: ${r.err || r.out}
+`);
+}
+async function startAndWait(start, seconds, ctx, task) {
   const started = await pit([...start, "--bg", "--json", ...task === void 0 ? [] : ["--", task]]);
   if (started.code !== 0) return asResult(started);
   let id;
+  let cached3 = false;
   try {
-    id = JSON.parse(started.out).id;
+    ({ id, cached: cached3 = false } = JSON.parse(started.out));
   } catch {
     return { text: `could not read the run id from: ${started.out.slice(0, 200)}`, isError: true };
   }
-  return waitFor([id], seconds);
+  const result = await waitFor([id], seconds, ctx);
+  if (cancelled(ctx) && !cached3) await stopQuietly(["stop", id]);
+  if (cached3) result.text = `Cached answer: the same question on the same code as run ${id}; no worker ran (fresh: true asks one).
+
+${result.text}`;
+  return result;
+}
+async function startCrew(flags, tasks, seconds, ctx) {
+  const started = await pit(["crew", ...flags, "--json", "--", ...tasks]);
+  if (started.code !== 0) return asResult(started);
+  let group;
+  try {
+    group = JSON.parse(started.out).group;
+  } catch {
+    return { text: `could not read the group from: ${started.out.slice(0, 200)}`, isError: true };
+  }
+  const result = await waitFor([], seconds, ctx, group);
+  if (cancelled(ctx)) await stopQuietly(["stop", "-g", group]);
+  return result;
 }
-async function waitFor(ids, seconds, group) {
-  const args = group ? ["wait", "-g", group, "--timeout", String(seconds)] : ["wait", ...ids, "--timeout", String(seconds)];
-  const r = await pit(args, (seconds + 60) * 1e3);
-  const again = group ? `{"group": "${group}"}` : `{"runs": ${JSON.stringify(ids)}}`;
-  return asResult(r, `Not finished yet: call pitroom_wait with ${again} (waitSeconds up to ${MAX_WAIT}); pitroom_stop ends it.`);
+
+// src/cli/mcp-extras.ts
+var RpcError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+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) => {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > n ? `${flat.slice(0, n - 1)}\u2026` : flat;
+};
+function listResources() {
+  const resources = [];
+  for (const id of listRunIds().slice(-LISTED).reverse()) {
+    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" });
+    } catch {
+    }
+  }
+  return { resources };
+}
+var resourceTemplates = () => ({
+  resourceTemplates: [
+    { uriTemplate: "pitroom://run/{id}", name: "run-report", title: "A run's report", description: "The report of a run: answer, receipt, verified references.", mimeType: "text/plain" },
+    { uriTemplate: "pitroom://run/{id}/patch", name: "run-patch", title: "A run's patch", description: "The exact diff an isolated or in-place run made.", mimeType: "text/x-diff" }
+  ]
+});
+async function readResource(uri, ctx) {
+  const m = RUN.exec(uri);
+  if (!m) throw new RpcError(-32002, `unknown resource: ${uri}`);
+  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) }] };
+}
+var PROMPTS = [
+  {
+    name: "research",
+    title: "Research with a worker",
+    description: "Find, map or explain code through a read-only worker, and verify what comes back.",
+    arguments: [{ name: "question", description: "What to find out about the project.", required: true }],
+    text: (a) => `Use the pitroom_run tool (mode "read") to find out: ${a.question}
+
+Give the worker the full question and any file it should start from. When it answers, check one or two of the cited file:line references yourself before relying on the answer, and say plainly what is verified and what is not. If it comes back "still running", call pitroom_wait with the run id.`
+  },
+  {
+    name: "implement",
+    title: "Get a change made",
+    description: "A worker makes a change in an isolated copy; you review the exact diff and apply it only when it is right.",
+    arguments: [{ name: "task", description: "The change to make, with the context a worker needs.", required: true }],
+    text: (a) => `Get this change made by a worker: ${a.task}
+
+Call pitroom_run with mode "isolate" (add "verify" with the project's test command if there is one). Read the diff with pitroom_show (patch: true), then have it judged with pitroom_review. If the diff does what was asked and the review has no critical findings, call pitroom_apply; otherwise pitroom_run with "continue" to ask for the fix, or pitroom_discard. Do not apply a change you have not read.`
+  },
+  {
+    name: "review",
+    title: "Review changes with another model",
+    description: "A read-only reviewer from another model judges a commit range or the latest change.",
+    arguments: [{ name: "range", description: "A commit range such as main..HEAD. Default: the latest run's change." }],
+    text: (a) => (a.range ? `Have the commits ${a.range} reviewed: call pitroom_review with range "${a.range}".` : 'Have the latest change reviewed: call pitroom_review with run "last".') + "\n\nWeigh each finding against the code before acting on it: a reviewer can be wrong. Fix what is real, and say which findings you dropped and why."
+  },
+  {
+    name: "crew",
+    title: "Split work across workers",
+    description: "Independent tasks run in parallel as one group of workers.",
+    arguments: [{ name: "tasks", description: "The tasks, one per line.", required: true }],
+    text: (a) => `Run these independent tasks in parallel: call pitroom_run with "tasks" (one worker each):
+
+${a.tasks}
+
+Make each task self-contained. Use mode "isolate" if they change files, then read every patch (pitroom_show, patch: true) and apply them with pitroom_apply (group). Only split work that does not depend on each other.`
+  }
+];
+var TOOL_MAP = 'Through this MCP server the `pitroom` commands below are tools: `pitroom run` is pitroom_run (`-i` is mode "isolate", `-w` mode "write", `--continue` is continue, `--verify` is verify), `pitroom crew` is pitroom_run with tasks, `pitroom wait` pitroom_wait, `pitroom show`/`status` pitroom_show, `pitroom review` pitroom_review, `pitroom audit` pitroom_audit, `pitroom apply`/`discard`/`revert`/`stop` the tools of those names, `pitroom history`/`ls`/`models`/`doctor` pitroom_info. With a shell the commands work as well.';
+var skills;
+function skillPrompts() {
+  if (skills) return skills;
+  const found = [];
+  const root = packageRoot();
+  for (const name of skillNames(root)) {
+    try {
+      const text = fs25.readFileSync(path21.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.`;
+      const title = /^#\s+(.+)$/m.exec(body)?.[1]?.trim() ?? name;
+      found.push({
+        name,
+        title,
+        // the first sentence: prompts/list is read whole by some clients, so it stays short
+        description: `Skill: ${description.split(/(?<=\.)\s/)[0]}`,
+        arguments: [{ name: "task", description: "What you are about to do (optional)." }],
+        text: (a) => `${TOOL_MAP}
+
+${body}${a.task ? `
+
+---
+
+The task: ${a.task}` : ""}`
+      });
+    } catch {
+    }
+  }
+  skills = found.filter((p) => !PROMPTS.some((b) => b.name === p.name));
+  return skills;
+}
+var allPrompts = () => [...PROMPTS, ...skillPrompts()];
+var listPrompts = () => ({ prompts: allPrompts().map(({ name, title, description, arguments: args }) => ({ name, title, description, arguments: args })) });
+function getPrompt(name, given) {
+  const p = allPrompts().find((x) => x.name === name);
+  if (!p) throw new RpcError(-32602, `unknown prompt: ${String(name)}`);
+  const args = {};
+  const raw = given && typeof given === "object" && !Array.isArray(given) ? given : {};
+  for (const a of p.arguments) {
+    const v = raw[a.name];
+    if (typeof v === "string" && v.trim()) args[a.name] = v.trim();
+    else if (a.required) throw new RpcError(-32602, `missing argument: ${a.name}`);
+  }
+  return { description: p.description, messages: [{ role: "user", content: { type: "text", text: p.text(args) } }] };
 }
+
+// src/cli/mcp-tools.ts
 var WORKER_PROPS = {
-  worker: { type: "string", description: 'Worker target "backend[:model]", e.g. "opencode", "codex", "claude:haiku", "gemini:gemini-3.8-flash". Default: the configured worker.' },
-  model: { type: "string", description: "Model for the preferred worker." },
-  tier: { type: "string", description: "A worker tier from the config: cheap, standard, capable (an explicit worker wins)." },
-  effort: { type: "string", description: "Reasoning effort for the worker: low, medium, high, xhigh." },
-  dir: { type: "string", description: "Project directory (default: the directory the server was started in)." },
-  files: { type: "array", items: { type: "string" }, description: "Files to attach (paths)." },
-  verify: { type: "string", description: 'A command run after the worker finishes (e.g. "npm test"); a failing one is reported.' },
-  link: { type: "array", items: { type: "string" }, description: 'Ignored directories to link into an isolated copy so tests can run (e.g. ["node_modules"]).' },
-  web: { type: "boolean", description: "Let the worker use web tools." },
-  group: { type: "string", description: "A name to group related runs under." }
+  worker: { type: "string", description: 'Worker "backend[:model]", e.g. "opencode", "claude:haiku". Default: configured.' },
+  model: { type: "string", description: "Model for that worker." },
+  tier: { type: "string", description: "cheap, standard or capable (from the config)." },
+  effort: { type: "string", description: "low, medium, high, xhigh." },
+  dir: { type: "string", description: "Project directory (default: the server's)." },
+  files: { type: "array", items: { type: "string" }, description: "Files to attach." },
+  verify: { type: "string", description: 'Command run afterwards, e.g. "npm test".' },
+  link: { type: "array", items: { type: "string" }, description: 'Ignored dirs to link into an isolated copy, e.g. ["node_modules"].' },
+  web: { type: "boolean", description: "Allow web tools." },
+  group: { type: "string", description: "Group name for related runs." }
 };
-var WAIT_PROP = { waitSeconds: { type: "number", description: `How long to wait for the result before returning "still running" (default ${DEFAULT_WAIT}, at most ${MAX_WAIT}).` } };
-var RUN_ID2 = { type: "string", description: 'A run id as printed by a run, or "last".' };
+var WAIT_PROP = { waitSeconds: { type: "number", description: `Wait this long before returning "still running" (default ${DEFAULT_WAIT}, max ${MAX_WAIT}).` } };
+var RUN_ID2 = { type: "string", description: 'Run id, or "last".' };
+var READ_ONLY = { readOnlyHint: true, openWorldHint: false };
+var TOPICS = {
+  runs: ["running", "group"],
+  history: ["text", "state", "model", "since", "limit"],
+  stats: ["since"],
+  savings: ["since", "perModel"],
+  models: ["worker", "all"],
+  cooldown: [],
+  config: [],
+  doctor: []
+};
+function infoArgs(topic, a) {
+  const allowed = TOPICS[topic];
+  const stray = Object.keys(a).filter((k) => k !== "topic" && a[k] !== void 0 && a[k] !== null && !allowed.includes(k));
+  if (stray.length) throw new ToolError(`${stray.map((k) => `"${k}"`).join(", ")} ${stray.length > 1 ? "do" : "does"} not go with topic "${topic}" (${allowed.length ? `it takes ${allowed.join(", ")}` : "it takes no options"})`);
+  const group = str(a, "group");
+  const worker = str(a, "worker");
+  switch (topic) {
+    case "runs":
+      return { args: group ? ["status", "-g", group] : ["ls", ...bool(a, "running") ? ["--running"] : []] };
+    case "history": {
+      const limit = a.limit;
+      if (limit !== void 0 && (typeof limit !== "number" || !Number.isInteger(limit) || limit < 1 || limit > 200)) throw new ToolError('"limit" must be a whole number from 1 to 200');
+      const text = str(a, "text");
+      const state = str(a, "state");
+      const model = str(a, "model");
+      return { args: ["history", ...since(a), ...state ? ["--state", state] : [], ...model ? ["--model", model] : [], ...limit ? ["--limit", String(limit)] : [], ...text ? ["--", text] : []] };
+    }
+    case "stats":
+      return { args: ["history", "stats", ...since(a)] };
+    case "savings":
+      return { args: ["savings", ...since(a), ...bool(a, "perModel") ? ["--models"] : []] };
+    case "models":
+      return { args: ["models", ...worker ? [worker] : [], ...bool(a, "all") ? ["--all"] : []] };
+    case "doctor":
+      return { args: ["doctor"], timeoutMs: 12e4 };
+    case "cooldown":
+    case "config":
+      return { args: [topic] };
+    default:
+      throw new Error(`topic "${topic}" has no command`);
+  }
+}
 var TOOLS2 = [
   {
     name: "pitroom_run",
     title: "Run a worker",
-    description: 'Hand a bounded task to a cheaper worker agent. mode "read" (default) is read-only research that returns an answer whose file:line references are verified; "isolate" lets the worker edit a private copy and returns the exact diff (review it, then pitroom_apply or pitroom_discard); "write" edits the working tree in place and is undoable with the CLI (`pitroom revert`). Returns the worker\'s answer and a receipt, or "still running" with the run id.',
+    description: 'Hand a bounded task to a cheaper worker agent. mode "read" (default): read-only research, an answer with verified file:line references. "isolate": the worker edits a private copy and you get the exact diff (then pitroom_review, pitroom_apply or pitroom_discard). "write": edits the working tree (undo: pitroom_revert). Give "tasks" instead of "task" to run independent tasks in parallel (read or isolate). Returns the report(s) and a receipt (a read question asked before on the same code comes back cached), or "still running" for pitroom_wait. The using-pitroom skill (or prompt) says when and how to delegate. Cancelling the call stops the run.',
     inputSchema: {
       type: "object",
       properties: {
-        task: { type: "string", description: "What the worker should do, with the context it needs." },
-        mode: { type: "string", enum: ["read", "isolate", "write"], description: "read (default), isolate, or write." },
-        inPlace: { type: "boolean", description: "Read mode only: read the directory itself instead of a clean snapshot without secret-looking files." },
-        audit: { type: "boolean", description: "Read mode only: have another worker re-check the answer afterwards." },
+        task: { type: "string", description: "What to do, with the context the worker needs." },
+        tasks: { type: "array", items: { type: "string" }, minItems: 1, maxItems: MAX_TASKS, description: "Or several independent tasks, one worker each." },
+        mode: { type: "string", enum: ["read", "isolate", "write"] },
+        continue: { type: "string", description: "A finished run to follow up in the same worker session." },
+        inPlace: { type: "boolean", description: "Read: read the directory itself, not a snapshot without secret-looking files." },
+        audit: { type: "boolean", description: "Read: have another worker re-check the answer (each one, with tasks)." },
+        fresh: { type: "boolean", description: "Read: ask a worker even if this question was answered on the same code." },
         ...WORKER_PROPS,
         ...WAIT_PROP
-      },
-      required: ["task"]
+      }
     },
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
-    async call(a) {
-      const task = str(a, "task", true);
+    async call(a, ctx) {
+      const task = str(a, "task");
+      const tasks = strs(a, "tasks").filter((t) => t.trim());
+      if (!task && !tasks.length) throw new ToolError('give "task" (or "tasks" for parallel work)');
+      if (task && tasks.length) throw new ToolError('give "task" or "tasks", not both');
       const mode = oneOf(a, "mode", ["read", "isolate", "write"], "read");
       const flags = mode === "isolate" ? ["-i"] : mode === "write" ? ["-w"] : [];
       if (mode === "read") {
         if (bool(a, "inPlace")) flags.push("--in-place");
         if (bool(a, "audit")) flags.push("--audit");
+        if (bool(a, "fresh")) flags.push("--fresh");
+      }
+      const follow = str(a, "continue");
+      if (tasks.length) {
+        if (tasks.length > MAX_TASKS) throw new ToolError(`at most ${MAX_TASKS} tasks at once: start the rest when these are done`);
+        if (mode === "write") throw new ToolError('parallel workers never write in place: use mode "isolate" (each gets its own copy)');
+        if (follow) throw new ToolError('"continue" follows up one run: give "task"');
+        return startCrew([...flags, ...workerFlags(a)], tasks, waitSeconds(a), ctx);
       }
-      return startAndWait(["run", ...flags, ...workerFlags(a)], waitSeconds(a), task);
+      if (follow) flags.push("--continue", follow);
+      return startAndWait(["run", ...flags, ...workerFlags(a)], waitSeconds(a), ctx, task);
     }
   },
   {
     name: "pitroom_wait",
     title: "Wait for runs",
-    description: 'Wait for runs started earlier (a run that came back "still running") and return their reports.',
-    inputSchema: {
-      type: "object",
-      properties: { runs: { type: "array", items: { type: "string" }, description: "Run ids." }, group: { type: "string", description: "Or a group name." }, ...WAIT_PROP }
-    },
-    annotations: { readOnlyHint: true, openWorldHint: false },
-    async call(a) {
+    description: 'Wait for runs that came back "still running" and return their reports.',
+    inputSchema: { type: "object", properties: { runs: { type: "array", items: { type: "string" } }, group: { type: "string" }, ...WAIT_PROP } },
+    annotations: READ_ONLY,
+    async call(a, ctx) {
       const runs = strs(a, "runs");
       const group = str(a, "group");
       if (!runs.length && !group) throw new ToolError('give "runs" or "group"');
-      return waitFor(runs, waitSeconds(a), runs.length ? void 0 : group);
+      return waitFor(runs, waitSeconds(a), ctx, runs.length ? void 0 : group);
     }
   },
   {
-    name: "pitroom_status",
-    title: "Run status",
-    description: "The state and live progress of a run (default: the latest), or of a group.",
-    inputSchema: { type: "object", properties: { run: RUN_ID2, group: { type: "string", description: "A group name." } } },
-    annotations: { readOnlyHint: true, openWorldHint: false },
-    async call(a) {
-      const group = str(a, "group");
-      const run2 = str(a, "run");
-      return asResult(await pit(["status", ...group ? ["-g", group] : run2 ? [run2] : []], 6e4));
+    name: "pitroom_show",
+    title: "Show a run",
+    description: "A run's report (live progress while it runs); patch: the exact diff; full: the untruncated answer.",
+    inputSchema: { type: "object", properties: { run: RUN_ID2, patch: { type: "boolean" }, full: { type: "boolean" } } },
+    annotations: READ_ONLY,
+    async call(a, ctx) {
+      const run2 = str(a, "run") ?? "last";
+      return plain(["show", run2, ...bool(a, "patch") ? ["--patch"] : bool(a, "full") ? ["--full"] : []], ctx);
     }
   },
   {
-    name: "pitroom_show",
-    title: "Show a run",
-    description: "A finished run's report again; with patch the exact diff of an isolated change, with full the untruncated answer.",
-    inputSchema: { type: "object", properties: { run: RUN_ID2, patch: { type: "boolean" }, full: { type: "boolean" } }, required: ["run"] },
-    annotations: { readOnlyHint: true, openWorldHint: false },
-    async call(a) {
-      const run2 = str(a, "run", true);
-      return asResult(await pit(["show", run2, ...bool(a, "patch") ? ["--patch"] : bool(a, "full") ? ["--full"] : []], 6e4));
+    name: "pitroom_info",
+    title: "Pitroom information",
+    description: "Reports, changing nothing. topic: runs (latest runs; running, group), history (search earlier answers before asking again; text, state, model, since, limit), stats (success rate, time, tokens, audits per worker; since), savings (since, perModel), models (a backend's models and costs; worker, all), cooldown (rate-limited models being skipped), config, doctor (setup check).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        topic: { type: "string", enum: Object.keys(TOPICS) },
+        text: { type: "string" },
+        state: { type: "string" },
+        model: { type: "string" },
+        since: { type: "string", description: "7d, 30d, \u2026 or all." },
+        limit: { type: "number" },
+        running: { type: "boolean" },
+        group: { type: "string" },
+        worker: { type: "string" },
+        all: { type: "boolean" },
+        perModel: { type: "boolean" }
+      },
+      required: ["topic"]
+    },
+    annotations: READ_ONLY,
+    async call(a, ctx) {
+      if (str(a, "topic") === void 0) throw new ToolError(`"topic" is required: one of ${Object.keys(TOPICS).join(", ")}`);
+      const topic = oneOf(a, "topic", Object.keys(TOPICS), "runs");
+      const { args, timeoutMs } = infoArgs(topic, a);
+      return plain(args, ctx, timeoutMs);
     }
   },
   {
     name: "pitroom_review",
     title: "Review a change",
-    description: `A read-only reviewer (by default another worker than the implementer) judges one run's change, or a range of commits ("main..HEAD"). Returns findings with severities and a SPEC / QUALITY verdict.`,
+    description: `A read-only reviewer (another worker by default) judges a run's change or a commit range ("main..HEAD"): findings with severities and a SPEC / QUALITY verdict.`,
     inputSchema: {
       type: "object",
       properties: {
-        run: { ...RUN_ID2, description: "The run whose change to review (an isolated or in-place change)." },
+        run: RUN_ID2,
         range: { type: "string", description: 'Or a commit range "A..B".' },
-        plan: { type: "string", description: "With range: the plan file the commits implement." },
+        plan: { type: "string", description: "With range: the plan file it implements." },
         worker: WORKER_PROPS.worker,
         tier: WORKER_PROPS.tier,
         dir: WORKER_PROPS.dir,
@@ -4263,95 +4659,211 @@ var TOOLS2 = [
       }
     },
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
-    async call(a) {
+    async call(a, ctx) {
       const run2 = str(a, "run");
       const range = str(a, "range");
       if (!run2 === !range) throw new ToolError('give exactly one of "run" or "range"');
       const plan = str(a, "plan");
       const flags = workerFlags(a, ["worker", "tier", "dir", "group"]);
-      return startAndWait(["review", ...range ? ["--range", range, ...plan ? ["--plan", plan] : []] : [run2], ...flags], waitSeconds(a));
+      return startAndWait(["review", ...range ? ["--range", range, ...plan ? ["--plan", plan] : []] : [run2], ...flags], waitSeconds(a), ctx);
     }
   },
   {
     name: "pitroom_audit",
     title: "Audit an answer",
-    description: "Another worker re-checks a finished read run's answer against the project and says AGREE, PARTIAL or DISAGREE with the claims it disputes.",
+    description: "Another worker re-checks a read run's answer: AGREE, PARTIAL or DISAGREE, with the disputed claims.",
     inputSchema: { type: "object", properties: { run: RUN_ID2, worker: WORKER_PROPS.worker, ...WAIT_PROP }, required: ["run"] },
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
-    async call(a) {
+    async call(a, ctx) {
       const run2 = str(a, "run", true);
       const worker = str(a, "worker");
-      return startAndWait(["audit", run2, ...worker ? ["-W", worker] : []], waitSeconds(a));
+      return startAndWait(["audit", run2, ...worker ? ["-W", worker] : []], waitSeconds(a), ctx);
     }
   },
   {
     name: "pitroom_apply",
     title: "Apply an isolated change",
-    description: "Land an isolated run's patch on the user's working tree (checked first; refused if it no longer applies cleanly). A patch that deletes files is refused unless allowDelete is true: only pass it after checking the deletions are what the user asked for.",
+    description: "Land an isolated run's patch (or a group's, in order) on the working tree; checked first. A patch deleting files needs allowDelete: pass it only after checking the deletions were asked for.",
     inputSchema: { type: "object", properties: { run: RUN_ID2, group: { type: "string" }, allowDelete: { type: "boolean" } } },
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
-    async call(a) {
+    async call(a, ctx) {
       const group = str(a, "group");
       const run2 = str(a, "run");
       if (!run2 && !group) throw new ToolError('give "run" or "group"');
-      return asResult(await pit(["apply", ...group && !run2 ? ["-g", group] : [run2], ...bool(a, "allowDelete") ? ["--allow-delete"] : []], 12e4));
+      if (run2 && group) throw new ToolError('give "run" or "group", not both');
+      return plain(["apply", ...group ? ["-g", group] : [run2], ...bool(a, "allowDelete") ? ["--allow-delete"] : []], ctx, 12e4);
     }
   },
   {
     name: "pitroom_discard",
     title: "Discard an isolated change",
-    description: "Drop an isolated run's private copy (its patch is kept).",
+    description: "Drop an isolated run's private copy (the patch is kept).",
     inputSchema: { type: "object", properties: { run: RUN_ID2 }, required: ["run"] },
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    async call(a) {
-      return asResult(await pit(["discard", str(a, "run", true)], 6e4));
+    async call(a, ctx) {
+      return plain(["discard", str(a, "run", true)], ctx);
+    }
+  },
+  {
+    name: "pitroom_revert",
+    title: "Undo an in-place change",
+    description: `Undo a mode "write" run's changes (refused if the files changed since).`,
+    inputSchema: { type: "object", properties: { run: RUN_ID2 }, required: ["run"] },
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+    async call(a, ctx) {
+      return plain(["revert", str(a, "run", true)], ctx, 12e4);
     }
   },
   {
     name: "pitroom_stop",
     title: "Stop runs",
-    description: "Stop a running or queued run, or every run of a group.",
-    inputSchema: { type: "object", properties: { run: RUN_ID2, group: { type: "string" } } },
+    description: "Stop a running or queued run, or a group; cooldowns: try rate-limited models again now.",
+    inputSchema: { type: "object", properties: { run: RUN_ID2, group: { type: "string" }, cooldowns: { type: "boolean" } } },
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    async call(a) {
+    async call(a, ctx) {
       const run2 = str(a, "run");
       const group = str(a, "group");
-      if (!run2 && !group) throw new ToolError('give "run" or "group"');
-      return asResult(await pit(["stop", ...run2 ? [run2] : ["-g", group]], 6e4));
+      if (bool(a, "cooldowns")) {
+        if (run2 || group) throw new ToolError('"cooldowns" goes alone');
+        return plain(["cooldown", "--clear"], ctx);
+      }
+      if (!run2 && !group) throw new ToolError('give "run" or "group" (or "cooldowns": true)');
+      if (run2 && group) throw new ToolError('give "run" or "group", not both');
+      return plain(["stop", ...run2 ? [run2] : ["-g", group]], ctx);
     }
   }
 ];
-var log = (msg) => void process.stderr.write(`pitroom mcp: ${msg}
-`);
-var send = (msg) => void process.stdout.write(`${JSON.stringify(msg)}
-`);
-var RpcError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
+
+// src/cli/mcp-watch.ts
+var EVERY_MS = 2e3;
+var MAX_SUBSCRIPTIONS = 100;
+var watched = /* @__PURE__ */ new Set();
+var timer;
+var signature = (uri) => {
+  const id = runOfUri(uri);
+  if (!id) return void 0;
+  try {
+    const m = freshMeta(id);
+    return uri.endsWith("/patch") ? `${m.state}:${m.changes?.length ?? 0}` : m.state;
+  } catch {
+    return void 0;
   }
 };
-async function dispatch(method, params) {
-  switch (method) {
-    case "initialize": {
-      const asked = typeof params.protocolVersion === "string" ? params.protocolVersion : "";
-      return {
-        protocolVersion: PROTOCOLS.includes(asked) ? asked : PROTOCOLS[0],
-        capabilities: { tools: { listChanged: false } },
-        serverInfo: { name: "pitroom", title: "Pitroom", version: VERSION2 },
-        instructions: INSTRUCTIONS
-      };
+var newestRun = () => {
+  try {
+    return listRunIds().at(-1);
+  } catch {
+    return void 0;
+  }
+};
+function subscribe(session, uri) {
+  if (typeof uri !== "string") throw new RpcError(-32602, '"uri" is required');
+  if (!runOfUri(uri)) throw new RpcError(-32602, `only runs can be subscribed to (pitroom://run/<id>): ${uri}`);
+  if (!session.subscriptions.has(uri) && session.subscriptions.size >= MAX_SUBSCRIPTIONS) throw new RpcError(-32602, `at most ${MAX_SUBSCRIPTIONS} subscriptions: unsubscribe from finished runs first`);
+  const sig = signature(uri);
+  if (sig === void 0) throw new RpcError(-32002, `unknown resource: ${uri}`);
+  session.subscriptions.set(uri, sig);
+}
+function unsubscribe(session, uri) {
+  if (typeof uri !== "string") throw new RpcError(-32602, '"uri" is required');
+  session.subscriptions.delete(uri);
+}
+function tick() {
+  const listening = [...watched].filter((s) => s.push);
+  if (!listening.length) return;
+  const newest = newestRun();
+  const seen = /* @__PURE__ */ new Map();
+  for (const s of listening) {
+    const push = s.push;
+    if (newest !== s.newestRun) {
+      s.newestRun = newest;
+      push({ jsonrpc: "2.0", method: "notifications/resources/list_changed" });
     }
-    case "ping":
-      return {};
-    case "tools/list":
-      return { tools: TOOLS2.map(({ name, title, description, inputSchema, annotations }) => ({ name, title, description, inputSchema, annotations })) };
-    case "tools/call": {
-      const tool = TOOLS2.find((t) => t.name === params.name);
-      if (!tool) throw new RpcError(-32602, `unknown tool: ${String(params.name)}`);
-      const args = params.arguments && typeof params.arguments === "object" && !Array.isArray(params.arguments) ? params.arguments : {};
+    for (const [uri, last] of s.subscriptions) {
+      if (!seen.has(uri)) seen.set(uri, signature(uri));
+      const now = seen.get(uri);
+      if (now === last) continue;
+      if (now === void 0) s.subscriptions.delete(uri);
+      else s.subscriptions.set(uri, now);
+      push({ jsonrpc: "2.0", method: "notifications/resources/updated", params: { uri } });
+    }
+  }
+}
+function watch2(session) {
+  session.newestRun = newestRun();
+  watched.add(session);
+  if (!timer) {
+    timer = setInterval(tick, EVERY_MS);
+    timer.unref();
+  }
+}
+function unwatch(session) {
+  watched.delete(session);
+  session.subscriptions.clear();
+  if (!watched.size && timer) {
+    clearInterval(timer);
+    timer = void 0;
+  }
+}
+
+// src/cli/mcp.ts
+var PROTOCOLS = ["2025-06-18", "2025-03-26", "2024-11-05"];
+var INSTRUCTIONS = [
+  "Pitroom hands bounded work to cheaper worker agents and returns a verified answer, the exact diff and a cost receipt. You decide, verify and answer.",
+  'Use pitroom_run with mode "read" for research and locating code, mode "isolate" for code changes (the worker edits a copy; check it with pitroom_review, then pitroom_apply or pitroom_discard); pitroom_run with "tasks" for independent tasks in parallel; pitroom_info (topic history) finds an earlier answer before you ask again.',
+  'A run can take minutes: pitroom_run waits up to waitSeconds, then returns the run id as "still running"; call pitroom_wait with it.',
+  "Pitroom's skills (using-pitroom, pitroom-research, pitroom-implement, pitroom-review, pitroom-crew, pitroom-debugging, pitroom-tdd and more) say when to delegate and how to check what comes back: if you have them, use the matching one alongside these tools; if not, the prompts of the same names hold them.",
+  "It is optional: for a small task you can do yourself, skip it."
+].join(" ");
+var log = (msg) => void process.stderr.write(`pitroom mcp: ${msg}
+`);
+function newSession() {
+  const session = { inflight: /* @__PURE__ */ new Map(), subscriptions: /* @__PURE__ */ new Map() };
+  watch2(session);
+  return session;
+}
+function endSession(session) {
+  for (const { abort } of session.inflight.values()) abort.abort("closed");
+  unwatch(session);
+  session.push = void 0;
+}
+function progressToken(params) {
+  const meta = params && typeof params === "object" ? params._meta : void 0;
+  const token = meta && typeof meta === "object" ? meta.progressToken : void 0;
+  return typeof token === "string" || typeof token === "number" ? token : void 0;
+}
+function contextFor(params, abort, notify) {
+  const token = progressToken(params);
+  let n = 0;
+  return {
+    signal: abort.signal,
+    progress: (message) => {
+      if (token === void 0 || abort.signal.aborted) return;
+      notify({ jsonrpc: "2.0", method: "notifications/progress", params: { progressToken: token, progress: ++n, message } });
+    }
+  };
+}
+async function dispatch(method, params, ctx, session) {
+  switch (method) {
+    case "initialize": {
+      const asked = typeof params.protocolVersion === "string" ? params.protocolVersion : "";
+      return {
+        protocolVersion: PROTOCOLS.includes(asked) ? asked : PROTOCOLS[0],
+        capabilities: { tools: { listChanged: false }, resources: { listChanged: true, subscribe: true }, prompts: { listChanged: false } },
+        serverInfo: { name: "pitroom", title: "Pitroom", version: VERSION2 },
+        instructions: INSTRUCTIONS
+      };
+    }
+    case "ping":
+      return {};
+    case "tools/list":
+      return { tools: TOOLS2.map(({ name, title, description, inputSchema, annotations }) => ({ name, title, description, inputSchema, annotations })) };
+    case "tools/call": {
+      const tool = TOOLS2.find((t) => t.name === params.name);
+      if (!tool) throw new RpcError(-32602, `unknown tool: ${String(params.name)}`);
+      const args = params.arguments && typeof params.arguments === "object" && !Array.isArray(params.arguments) ? params.arguments : {};
       try {
-        const r = await tool.call(args);
+        const r = await tool.call(args, ctx);
         return { content: [{ type: "text", text: r.text }], isError: r.isError === true };
       } catch (e) {
         if (e instanceof ToolError) return { content: [{ type: "text", text: e.message }], isError: true };
@@ -4359,1194 +4871,1427 @@ async function dispatch(method, params) {
         return { content: [{ type: "text", text: `pitroom: ${e.message}` }], isError: true };
       }
     }
+    case "resources/list":
+      return listResources();
+    case "resources/templates/list":
+      return resourceTemplates();
+    case "resources/read":
+      if (typeof params.uri !== "string") throw new RpcError(-32602, '"uri" is required');
+      return readResource(params.uri, ctx);
+    case "resources/subscribe":
+      subscribe(session, params.uri);
+      return {};
+    case "resources/unsubscribe":
+      unsubscribe(session, params.uri);
+      return {};
+    case "prompts/list":
+      return listPrompts();
+    case "prompts/get":
+      return getPrompt(params.name, params.arguments);
     default:
       throw new RpcError(-32601, `method not found: ${method}`);
   }
 }
-async function handle(msg) {
+function cancel(session, params) {
+  const id = params.requestId;
+  if (typeof id !== "string" && typeof id !== "number") return;
+  session.inflight.get(id)?.abort.abort("cancelled");
+}
+async function handle(session, msg, notify) {
   if (!msg || typeof msg !== "object" || Array.isArray(msg)) return { jsonrpc: "2.0", id: null, error: { code: -32600, message: "invalid request" } };
   const m = msg;
   if (typeof m.method !== "string") return void 0;
-  const isRequest = m.id !== void 0 && m.id !== null;
+  const params = m.params && typeof m.params === "object" && !Array.isArray(m.params) ? m.params : {};
+  if (m.method === "notifications/cancelled") {
+    cancel(session, params);
+    return void 0;
+  }
+  const isRequest = typeof m.id === "string" || typeof m.id === "number";
+  const abort = new AbortController();
+  const entry = { abort, ctx: contextFor(params, abort, notify) };
+  if (isRequest) session.inflight.set(m.id, entry);
   try {
-    const result = await dispatch(m.method, m.params && typeof m.params === "object" ? m.params : {});
+    const result = await dispatch(m.method, params, entry.ctx, session);
+    if (abort.signal.aborted && abort.signal.reason === "cancelled") return void 0;
     return isRequest ? { jsonrpc: "2.0", id: m.id, result } : void 0;
   } catch (e) {
-    if (!isRequest) return void 0;
+    if (!isRequest || abort.signal.aborted && abort.signal.reason === "cancelled") return void 0;
     const code = e instanceof RpcError ? e.code : -32603;
     return { jsonrpc: "2.0", id: m.id, error: { code, message: e.message } };
+  } finally {
+    if (isRequest && session.inflight.get(m.id) === entry) session.inflight.delete(m.id);
   }
 }
-async function handleLine(line) {
-  let parsed;
-  try {
-    parsed = JSON.parse(line);
-  } catch {
-    send({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse error" } });
-    return;
-  }
+async function handlePayload(session, parsed, notify) {
   if (Array.isArray(parsed)) {
-    const replies = (await Promise.all(parsed.map(handle))).filter((r) => !!r);
-    if (replies.length) send(replies);
-    return;
+    const replies = (await Promise.all(parsed.map((m) => handle(session, m, notify)))).filter((r) => !!r);
+    return replies.length ? replies : void 0;
   }
-  const reply = await handle(parsed);
-  if (reply) send(reply);
+  return handle(session, parsed, notify);
 }
+var parseError = () => ({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse error" } });
 async function serveMcp() {
+  process.stdout.on("error", () => {
+  });
+  const send = (msg) => void process.stdout.write(`${JSON.stringify(msg)}
+`);
+  const session = newSession();
+  session.push = send;
   const rl = readline.createInterface({ input: process.stdin });
-  const inflight = /* @__PURE__ */ new Set();
+  const pending = /* @__PURE__ */ new Set();
+  const handleLine = async (line) => {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      send(parseError());
+      return;
+    }
+    const reply2 = await handlePayload(session, parsed, send);
+    if (reply2) send(reply2);
+  };
   rl.on("line", (line) => {
     if (!line.trim()) return;
     const p = handleLine(line).catch((e) => log(String(e.stack ?? e)));
-    inflight.add(p);
-    void p.finally(() => inflight.delete(p));
+    pending.add(p);
+    void p.finally(() => pending.delete(p));
   });
   await new Promise((resolve2) => rl.once("close", resolve2));
-  await Promise.allSettled([...inflight]);
+  unwatch(session);
+  await Promise.allSettled([...pending]);
   return 0;
 }
 
-// src/cli/commands.ts
-import { spawnSync as spawnSync8 } from "node:child_process";
-import fs30 from "node:fs";
-import path26 from "node:path";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
+// src/cli/mcp-http.ts
+import crypto7 from "node:crypto";
+import fs27 from "node:fs";
+import http2 from "node:http";
+import path23 from "node:path";
 
-// src/core/init.ts
-import fs25 from "node:fs";
-import path21 from "node:path";
-var FREE = /-free$/;
-var TIER_ORDER = [["cheap", "opencode"], ["standard", "codex"], ["capable", "claude"]];
-var isFound = (binary5) => path21.isAbsolute(binary5) && fs25.existsSync(binary5);
-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 notes = [];
-  const config = {};
-  let blocked;
-  let opencode2;
-  if (workers.find((w) => w.id === "opencode")?.found) {
-    const b = getBackend("opencode");
-    let models = [];
-    try {
-      models = b.catalog ? b.catalog().models.map((m) => m.id) : b.listModels?.() ?? [];
-    } catch {
-      notes.push("could not list OpenCode models (is it logged in?)");
-    }
-    const defaultModel4 = b.defaultModel?.();
-    const chosen = opts.model ?? defaultModel4;
-    const free = models.filter((m) => FREE.test(m) && m !== chosen);
-    opencode2 = { defaultModel: defaultModel4, 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) {
-      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);
-    for (const m of fallback) {
-      if (models.length && !models.includes(m)) throw new UserError(`"${m}" is not in \`opencode models\``);
-    }
-    if (fallback.length) {
-      config.fallback = fallback.map((m) => `opencode:${m}`);
-      if (!opts.fallback) notes.push(`fallback suggested from the free models in your catalogue: ${fallback.join(", ")} (change it with --fallback a,b)`);
-    } else {
-      notes.push("no fallback: no free OpenCode model found to suggest (pass --fallback a,b to name some)");
+// src/core/dash.ts
+import { spawn as spawn4 } from "node:child_process";
+import crypto6 from "node:crypto";
+import fs26 from "node:fs";
+import http from "node:http";
+import path22 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+
+// src/core/file-diff.ts
+var PREVIEW_LINES = 300;
+function gitPath(value, prefix = true) {
+  let path31 = value;
+  if (value.startsWith('"') && value.endsWith('"')) {
+    const bytes = [];
+    const escapes = { t: "	", n: "\n", r: "\r", b: "\b", f: "\f", v: "\v" };
+    for (const match of value.slice(1, -1).matchAll(/\\([0-7]{1,3}|.)|([^\\]+)/g)) {
+      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]));
     }
+    path31 = new TextDecoder().decode(new Uint8Array(bytes));
   }
-  const tiers = Object.fromEntries(TIER_ORDER.filter(([, id]) => workers.find((w) => w.id === id)?.found));
-  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: fs25.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 ${path21.basename(plan.path)}.bak)`);
-  fs25.mkdirSync(path21.dirname(plan.path), { recursive: true });
-  if (plan.exists) fs25.copyFileSync(plan.path, `${plan.path}.bak`);
-  fs25.writeFileSync(plan.path, `${JSON.stringify(plan.config, null, 2)}
-`);
-  return plan.path;
+  return prefix ? path31.replace(/^[ab]\//, "") : path31;
 }
-function formatInit(plan, written) {
-  const out = [bold("pitroom init") + dim(": worker CLIs on this machine")];
-  for (const w of plan.workers) out.push(`  ${w.found ? green("\u2714") : dim("\xB7")} ${w.name.padEnd(12)} ${w.found ? w.binary : dim("not found")}`);
-  if (plan.opencode) {
-    const o = plan.opencode;
-    out.push(`  OpenCode: ${o.models} models, default ${o.defaultModel ?? "none"}${o.free.length ? `, free: ${o.free.slice(0, 3).join(", ")}${o.free.length > 3 ? ", \u2026" : ""}` : ""}`);
-  }
-  out.push("", `config file: ${plan.path}${plan.exists ? " (exists)" : " (not present)"}`, JSON.stringify(plan.config, null, 2));
-  for (const n of plan.notes) out.push(`  note: ${n}`);
-  if (written) out.push("", green(`\u2714 written to ${written}`), dim("  next: pitroom doctor, then pitroom install"));
-  else if (plan.blocked) out.push("", yellow(`! ${plan.blocked}`));
-  else out.push("", `nothing written yet: pass --yes to write it${plan.exists ? " (with --force, since the file exists)" : ""}`);
-  return out.join("\n");
+function headerPath(header) {
+  const quoted = header.match(/^diff --git ("(?:[^"\\]|\\.)*"|\S+) ("(?:[^"\\]|\\.)*"|\S+)$/);
+  if (quoted) return gitPath(quoted[2]);
+  return gitPath(header.slice(header.lastIndexOf(" b/") + 1));
 }
-
-// src/core/group.ts
-function groupIds(group) {
-  return listRunIds().filter((id) => {
-    try {
-      return readMeta(id).group === group;
-    } catch {
-      return false;
+function fileDiffs(patch, changes, sourceTruncated = false) {
+  const files = [];
+  let file2;
+  let oldLine = 0;
+  let newLine = 0;
+  let oldLeft = 0;
+  let newLeft = 0;
+  let inHunk = false;
+  let row = 0;
+  const finishHunk = () => {
+    if (file2 && (oldLeft > 0 || newLeft > 0)) file2.incomplete = true;
+    oldLeft = newLeft = 0;
+    inHunk = false;
+  };
+  const add = (line) => {
+    if (!file2) return;
+    if (file2.lines.length < PREVIEW_LINES) file2.lines.push({ ...line, id: String(row) });
+    else file2.omittedLines++;
+    row++;
+  };
+  for (const line of patch.split("\n")) {
+    if (line.startsWith("diff --git ")) {
+      finishHunk();
+      file2 = { path: headerPath(line), status: "M", lines: [], additions: 0, deletions: 0, omittedLines: 0, binary: false, incomplete: false };
+      files.push(file2);
+      row = 0;
+      continue;
+    }
+    if (!file2) continue;
+    const hunk = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.exec(line);
+    if (hunk) {
+      finishHunk();
+      oldLine = Number(hunk[1]);
+      newLine = Number(hunk[3]);
+      oldLeft = Number(hunk[2] ?? 1);
+      newLeft = Number(hunk[4] ?? 1);
+      inHunk = true;
+      add({ type: "hunk", content: line });
+    } else if (inHunk && line.startsWith("\")) {
+      add({ type: "meta", content: line });
+    } else if (inHunk && (oldLeft > 0 || newLeft > 0)) {
+      if (line.startsWith("+") && newLeft > 0) {
+        file2.additions++;
+        newLeft--;
+        add({ type: "added", newLine: newLine++, content: line.slice(1) });
+      } else if (line.startsWith("-") && oldLeft > 0) {
+        file2.deletions++;
+        oldLeft--;
+        add({ type: "removed", oldLine: oldLine++, content: line.slice(1) });
+      } else if (line.startsWith(" ") && oldLeft > 0 && newLeft > 0) {
+        oldLeft--;
+        newLeft--;
+        add({ type: "context", oldLine: oldLine++, newLine: newLine++, content: line.slice(1) });
+      } else {
+        file2.incomplete = true;
+      }
+    } else if (!inHunk) {
+      if (line.startsWith("+++ ") && line !== "+++ /dev/null") file2.path = gitPath(line.slice(4).replace(/\t$/, ""));
+      else if (line.startsWith("--- ") && line !== "--- /dev/null") file2.path = gitPath(line.slice(4).replace(/\t$/, ""));
+      else if (/^(GIT binary patch|Binary files .* differ)$/.test(line)) file2.binary = true;
+      else if (/^(new file mode|deleted file mode|old mode|new mode|rename from|rename to|similarity index) /.test(line)) {
+        if (line.startsWith("new file mode ")) file2.status = "A";
+        if (line.startsWith("deleted file mode ")) file2.status = "D";
+        if (line.startsWith("rename to ")) {
+          file2.path = gitPath(line.slice(10), false);
+          file2.status = "R";
+        }
+        add({ type: "meta", content: line });
+      }
     }
+  }
+  finishHunk();
+  if (sourceTruncated && file2) file2.incomplete = true;
+  for (const f of files) {
+    if (f.incomplete || f.binary) f.additions = f.deletions = void 0;
+  }
+  const byPath = new Map(files.map((f) => [f.path, f]));
+  const result = changes.map((change) => {
+    const diff = byPath.get(change.path);
+    byPath.delete(change.path);
+    return diff ? { ...diff, status: change.status } : {
+      ...change,
+      lines: [],
+      omittedLines: 0,
+      binary: false,
+      incomplete: sourceTruncated,
+      unavailable: true
+    };
   });
+  return [...result, ...byPath.values()];
 }
-var oneLine5 = (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);
-}
-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);
-    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"];
-  const widths = head.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
-  const fmt = (r, header = false) => r.map((c, i) => {
-    const cell2 = i === r.length - 1 ? c : c.padEnd(widths[i]);
-    return header ? dim(cell2) : i === 1 ? stateColour(r[1], cell2) : cell2;
-  }).join("  ");
-  return [fmt(head, true), ...rows.map((r) => fmt(r))].join("\n");
-}
-var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
-async function waitMany(ids, opts) {
-  const deadline = Date.now() + opts.timeoutMs;
-  for (; ; ) {
-    const metas = ids.map((id) => freshMeta(id));
-    const done = metas.filter((m) => TERMINAL.includes(m.state)).length;
-    if (opts.any ? done > 0 : done === metas.length) return { metas, timedOut: false };
-    if (Date.now() >= deadline) return { metas, timedOut: true };
-    await sleep2(1500);
-  }
-}
-async function watch(select, opts) {
-  const seen = /* @__PURE__ */ new Map();
-  const line = (s) => opts.write(`${s}
-`);
-  const emit = (e, m) => {
-    if (!opts.brief) return opts.write(`${JSON.stringify(e)}
-`);
-    if (e.event === "started" && m) line(startedCard(m));
-    else if (e.event === "fallback" && m) line(`\u{1F3C1} Pitroom \u21BB ${m.id} fell back from ${String(e.failed)}: ${String(e.reason)}`);
-    else if (m && TERMINAL.includes(m.state)) line(endedCard(m));
-    else if (e.event === "all-done") line(`\u{1F3C1} Pitroom: ${String(e.runs)} run${e.runs === 1 ? "" : "s"} finished (${String(e.ok)} ok${e.failed ? `, ${String(e.failed)} not ok` : ""})`);
-  };
-  const deadline = opts.timeoutMs > 0 ? Date.now() + opts.timeoutMs : Infinity;
-  for (; ; ) {
-    const metas = select().map((id) => freshMeta(id));
-    if (opts.json || opts.brief) {
-      for (const m of metas) {
-        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) };
-        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);
-        }
-        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 });
-        }
-        if (TERMINAL.includes(m.state) && prev?.state !== m.state) {
-          emit({
-            event: m.state,
-            run: m.id,
-            time: duration(m),
-            worker: describeTarget(m.ran ?? m.worker),
-            summary: headline(m) || void 0,
-            error: m.error ? oneLine5(m.error, 160) : void 0,
-            refs: m.refs ? `${m.refs.valid}/${m.refs.total}` : void 0,
-            changes: m.changes?.length || void 0
-          }, m);
-        }
-        seen.set(m.id, { state: m.state, steps: l.steps, attempts });
-      }
-    } else {
-      opts.write(`\x1B[H\x1B[2J${table(metas)}
 
-${(/* @__PURE__ */ new Date()).toLocaleTimeString()} \xB7 Ctrl-C to stop watching (workers keep running)
-`);
-    }
-    const allDone = metas.length > 0 && metas.every((m) => TERMINAL.includes(m.state));
-    if (allDone || metas.length === 0 && seen.size === 0) {
-      if (opts.json || opts.brief) {
-        const ok = metas.filter((m) => m.state === "done").length;
-        emit({ event: "all-done", runs: metas.length, ok, failed: metas.length - ok });
-      }
-      return { metas, timedOut: false };
-    }
-    if (Date.now() >= deadline) return { metas, timedOut: true };
-    await sleep2(opts.intervalMs);
-  }
-}
+// src/core/dash-page.ts
+var THEME_SCRIPT = "(function(){try{var t=localStorage.getItem('pitroom-theme');var d=t?t==='dark':matchMedia('(prefers-color-scheme: dark)').matches;document.documentElement.classList.toggle('dark',d)}catch(e){}})()";
+var ICON3 = "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' rx='8' fill='%23ff6a2b'/%3E%3Cpath d='M9 8h4v4H9zm8 0h4v4h-4zm-4 4h4v4h-4zm8 0h4v4h-4zM9 16h4v4H9zm8 0h4v4h-4zm-4 4h4v4h-4zm8 0h4v4h-4z' fill='%23fff'/%3E%3C/svg%3E";
+var PAGE = `<!doctype html>
+<html lang="en" class="dark"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<meta name="color-scheme" content="dark light"><title>Pitroom</title><link rel="icon" href="${ICON3}">
+<script>${THEME_SCRIPT}</script><link rel="stylesheet" href="/assets/app.css"></head>
+<body><div id="root"></div><script type="module" src="/assets/app.js"></script></body></html>`;
+var MISSING = `<!doctype html><meta charset="utf-8"><title>Pitroom</title><body style="font:15px system-ui;padding:3rem;max-width:40rem;margin:auto"><h1>Pitroom dash</h1><p>The dashboard files are missing (dist/ui). Run <code>npm run build</code> in the Pitroom repository, or reinstall the package.</p></body>`;
 
-// src/core/mcp-install.ts
-import { spawnSync as spawnSync7 } from "node:child_process";
-import fs26 from "node:fs";
-import os10 from "node:os";
-import path22 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(path22.delimiter).filter(Boolean)) {
-    const p = path22.join(dir, process.platform === "win32" ? "pitroom.cmd" : "pitroom");
-    if (fs26.existsSync(p)) return { command: path22.resolve(p), args: ["mcp"] };
-  }
-  return { command: process.execPath, args: [process.argv[1] ?? "pitroom", "mcp"] };
-}
-var same = (a, b) => {
-  const o = b;
-  return !!o && o.command === a.command && Array.isArray(o.args) && o.args.join("\0") === a.args.join("\0");
+// src/core/dash.ts
+var DEFAULT_PORT = 7878;
+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) => {
+  const t = s.replace(/\s+/g, " ").trim();
+  return t.length > max ? `${t.slice(0, max - 1)}\u2026` : t;
 };
-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"] });
-  return { ok: r.status === 0 && !r.error, out: `${r.stdout ?? ""}${r.stderr ?? ""}`.trim() };
+function findings(m) {
+  const v = m.verdict;
+  if (!v) return "";
+  const parts = [v.critical && `${v.critical} critical`, v.important && `${v.important} important`, v.minor && `${v.minor} minor`].filter(Boolean);
+  return parts.length ? parts.join(" \xB7 ") : "no findings";
 }
-var runnable = (backendId) => run(backendId, ["--version"]).ok;
-var readJson = (file2) => {
-  try {
-    return JSON.parse(fs26.readFileSync(file2, "utf8"));
-  } catch {
-    return void 0;
-  }
-};
-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 = () => path22.join(process.env.GEMINI_CLI_HOME ?? home2(), ".gemini");
-function cliClient(id, backend, name, where, o) {
+function toRun(m) {
+  const l = m.state === "running" ? live(m) : void 0;
   return {
-    id,
-    name,
-    where,
-    found: () => runnable(backend),
-    state: o.state,
-    add: (c) => {
-      const r = run(backend, o.add(c));
-      return { ok: r.ok, message: r.ok ? where : r.out.split("\n")[0]?.trim() || `${name}'s command failed` };
-    },
-    remove: () => {
-      const r = run(backend, o.remove());
-      return { ok: r.ok, message: r.ok ? where : r.out.split("\n")[0]?.trim() || `${name}'s command failed` };
-    }
+    id: m.id,
+    state: m.state,
+    verifyFailed: m.verifyResult && !m.verifyResult.ok ? true : void 0,
+    kind: kind(m),
+    // the model that really ran, once the CLI has said which; until then just the worker, never a guess
+    worker: workerName(ranTarget(m)),
+    task: what(m),
+    group: m.group,
+    startedAt: m.startedAt,
+    time: elapsed(m),
+    steps: l ? l.steps : m.usage?.steps ?? 0,
+    tokens: m.usage?.total,
+    saved: m.savedUsd || void 0,
+    verdict: m.verdict ? `SPEC ${m.verdict.spec.toUpperCase()} \xB7 QUALITY ${m.verdict.quality.toUpperCase()}` : m.auditVerdict ? `AUDIT ${m.auditVerdict.toUpperCase()}` : void 0,
+    audit: auditBadge(m),
+    changes: m.changes?.length || void 0,
+    applied: m.applied || 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)
   };
 }
-function jsonClient(id, name, file2, dir) {
-  const rel = () => file2().replace(home2(), "~");
-  return {
-    id,
-    name,
-    found: () => fs26.existsSync(dir()),
-    state: (c) => jsonState(file2(), c),
-    add: (c) => {
-      let config = {};
-      if (fs26.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 (!fs26.existsSync(backup)) fs26.copyFileSync(file2(), backup);
-      }
-      config.mcpServers = { ...config.mcpServers ?? {}, [NAME]: { command: c.command, args: c.args } };
-      fs26.mkdirSync(path22.dirname(file2()), { recursive: true });
-      const tmp = `${file2()}.${process.pid}.tmp`;
-      fs26.writeFileSync(tmp, `${JSON.stringify(config, null, 2)}
-`);
-      fs26.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];
-      fs26.writeFileSync(file2(), `${JSON.stringify(config, null, 2)}
-`);
-      return { ok: true, message: rel() };
+function dashState(opts = {}) {
+  const limit = Math.min(Math.max(opts.limit ?? 40, 1), 200);
+  const runs = [];
+  const groups = /* @__PURE__ */ new Set();
+  for (const id of listRunIds().slice(-SCAN).reverse()) {
+    let m;
+    try {
+      m = freshMeta(id);
+    } catch {
+      continue;
     }
+    if (m.group) groups.add(m.group);
+    if (opts.group && m.group !== opts.group) continue;
+    if (runs.length < limit) runs.push(toRun(m));
+  }
+  return {
+    price: primaryPrice().name,
+    running: runs.filter((r) => r.state === "running" || r.state === "queued").length,
+    saved: totals(readLedger(Date.now() - WEEK_MS2)).saved,
+    groups: [...groups].sort(),
+    runs
   };
 }
-function desktopFile() {
-  if (process.platform === "darwin") return path22.join(home2(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
-  if (process.platform === "win32") return path22.join(process.env.APPDATA ?? path22.join(home2(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
-  return path22.join(process.env.XDG_CONFIG_HOME ?? path22.join(home2(), ".config"), "Claude", "claude_desktop_config.json");
-}
-function codexState(c) {
-  let text;
+var TASK_MAX = 6e3;
+var PATCH_LINES = 300;
+function runDetail(id) {
+  if (!RUN_ID3.test(id)) return void 0;
+  let m;
   try {
-    text = fs26.readFileSync(path22.join(process.env.CODEX_HOME ?? path22.join(home2(), ".codex"), "config.toml"), "utf8");
+    m = freshMeta(id);
   } catch {
-    return "absent";
+    return void 0;
   }
-  const at = text.search(/^\[mcp_servers\.pitroom\]\s*$/m);
-  if (at < 0) return "absent";
-  const table2 = text.slice(at).split(/\n(?=\[)/)[0] ?? "";
-  try {
-    const command = /^command\s*=\s*("(?:[^"\\]|\\.)*")/m.exec(table2)?.[1];
-    const args = /^args\s*=\s*(\[[^\n]*\])/m.exec(table2)?.[1];
-    return command && args && same(c, { command: JSON.parse(command), args: JSON.parse(args) }) ? "same" : "different";
+  const start = Date.parse(m.startedAt);
+  const kept = isActive(m.state) ? void 0 : archivedRun(id);
+  let steps = kept?.steps ?? [];
+  if (!steps.length) try {
+    const events = readRunFile(id, "events.jsonl");
+    steps = (events ? getBackend((m.ran ?? m.worker).backend).parse(events).timeline ?? [] : []).map((s) => ({
+      ...s,
+      t: s.at && Number.isFinite(start) ? Math.max(0, Math.round((s.at - start) / 1e3)) : void 0
+    }));
   } catch {
-    return "different";
   }
+  const rel = (t) => [m.cwd, m.dir].filter(Boolean).reduce((x, base2) => x.split(`${base2}/`).join(""), t);
+  steps = steps.map((x) => ({ ...x, text: rel(x.text) }));
+  const answer = isActive(m.state) ? "" : readSummary(m).replace(/^SUMMARY:\s*SPEC[^\n]*\n+/i, "").replace(/^DETAILS:[ \t]*\n+/i, "").trim();
+  const lastSay = steps.at(-1);
+  if (lastSay?.kind === "say" && answer && (answer.includes(lastSay.text.slice(0, 80)) || lastSay.text.includes(answer.slice(0, 80)))) steps.pop();
+  const fullPatch = readRunFile(id, "changes.patch");
+  const patch = fullPatch ?? kept?.patch ?? "";
+  const patchLines = patch.split("\n");
+  const u = m.usage;
+  return {
+    id,
+    state: m.state,
+    card: toRun(m),
+    task: (m.auditOf ? `Audit of ${m.auditOf}` : m.reviewOf ? `Review of ${m.reviewOf.replace(/\b([0-9a-f]{9})[0-9a-f]{31}\b/g, "$1")}` : m.task).slice(0, TASK_MAX),
+    steps,
+    answer,
+    changes: m.changes ?? [],
+    fileDiffs: fileDiffs(patch, m.changes ?? [], fullPatch === void 0 && kept?.patchTruncated),
+    patch: patch ? `${patchLines.slice(0, PATCH_LINES).join("\n")}${patchLines.length > PATCH_LINES ? `
+\u2026 ${patchLines.length - PATCH_LINES} more lines (pitroom show ${id} --patch)` : ""}` : void 0,
+    info: {
+      worker: (m.ran ?? m.worker).backend,
+      // the model has its own line
+      model: m.resolvedModel,
+      mode: m.mode,
+      started: m.startedAt,
+      time: elapsed(m),
+      steps: u?.steps,
+      toolCalls: u?.toolCalls,
+      tokens: u?.total,
+      returnedTokens: m.returnedTokens,
+      cost: u?.cost,
+      saved: m.savedUsd,
+      group: m.group,
+      directory: m.dir
+    },
+    attempts: m.attempts ?? [],
+    warnings: m.warnings ?? [],
+    refs: m.refs ? { valid: m.refs.valid, total: m.refs.total, invalid: m.refs.invalid.map((r) => `${r.ref} (${r.reason})`) } : void 0,
+    verify: m.verifyResult && m.verify ? { command: m.verify, ok: m.verifyResult.ok, tail: m.verifyResult.tail } : void 0,
+    error: m.error,
+    audit: m.auditOf ? m.state === "done" ? { state: m.state, verdict: m.auditVerdict, disputed: m.auditDisputed ?? [] } : void 0 : m.audit && { id: m.audit.id, state: m.audit.state, verdict: m.audit.verdict, disputed: m.audit.disputed ?? [] },
+    report: isActive(m.state) ? progress(m) : formatReport(m, void 0, 120)
+  };
 }
-function clients() {
-  return [
-    cliClient("claude-code", "claude", "Claude Code", "user settings (~/.claude.json)", {
-      state: (c) => jsonState(path22.join(home2(), ".claude.json"), c),
-      add: (c) => ["mcp", "add", "--scope", "user", NAME, "--", c.command, ...c.args],
-      remove: () => ["mcp", "remove", NAME, "--scope", "user"]
-    }),
-    cliClient("codex", "codex", "Codex", "~/.codex/config.toml", {
-      state: (c) => codexState(c),
-      add: (c) => ["mcp", "add", NAME, "--", c.command, ...c.args],
-      remove: () => ["mcp", "remove", NAME]
-    }),
-    cliClient("gemini", "gemini", "Gemini CLI", "user settings (~/.gemini/settings.json)", {
-      state: (c) => jsonState(path22.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", () => path22.join(home2(), ".cursor", "mcp.json"), () => path22.join(home2(), ".cursor")),
-    jsonClient("claude-desktop", "Claude Desktop", desktopFile, () => path22.dirname(desktopFile()))
-  ];
-}
-function attempt2(f) {
+var HEADERS = {
+  "cache-control": "no-store",
+  "x-content-type-options": "nosniff",
+  "referrer-policy": "no-referrer",
+  // Own files only, plus the hash of the one inline theme script; styles may be inline (the components position popups with them).
+  "content-security-policy": `default-src 'none'; script-src 'self' 'sha256-${crypto6.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 assetCache = /* @__PURE__ */ new Map();
+function readAsset(route) {
   try {
-    return f();
-  } catch (e) {
-    return { ok: false, message: e.message.split("\n")[0] ?? "failed" };
+    const file2 = path22.join(assetsDir(), path22.basename(route));
+    const { mtimeMs } = fs26.statSync(file2);
+    const hit = assetCache.get(route);
+    if (hit && hit.mtimeMs === mtimeMs) return hit.data;
+    const data = fs26.readFileSync(file2);
+    assetCache.set(route, { mtimeMs, data });
+    return data;
+  } catch {
+    return void 0;
   }
 }
-function installMcp(opts = {}) {
-  const c = mcpCommand();
-  const out = [];
-  for (const client of clients()) {
-    if (opts.only && !opts.only.includes(client.id)) continue;
-    const r = (state, message) => out.push({ id: client.id, name: client.name, state, message });
-    if (!client.found()) {
-      r("not-found", client.id === "cursor" || client.id === "claude-desktop" ? "not found on this machine" : "not installed (its command does not run)");
-      continue;
+function handler(touch2) {
+  const send = (res, code, type, body) => {
+    res.writeHead(code, { ...HEADERS, "content-type": type });
+    res.end(body);
+  };
+  const json = (res, code, value) => send(res, code, "application/json; charset=utf-8", JSON.stringify(value));
+  return (req, res) => {
+    touch2();
+    if (!LOCAL_HOST.test(req.headers.host ?? "")) return json(res, 403, { error: "forbidden host" });
+    if (req.method !== "GET" && req.method !== "HEAD") return json(res, 405, { error: "read-only" });
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    if (url.pathname === "/") return send(res, 200, "text/html; charset=utf-8", readAsset("/assets/app.js") ? PAGE : MISSING);
+    const type = ASSETS[url.pathname];
+    if (type) {
+      const data = readAsset(url.pathname);
+      if (!data) return json(res, 404, { error: "dashboard files missing" });
+      res.writeHead(200, { ...HEADERS, "content-type": type });
+      return void res.end(req.method === "HEAD" ? void 0 : data);
     }
-    const now = client.state(c);
-    if (now === "same" && !opts.force) {
-      r("already", "already registered");
-      continue;
+    if (url.pathname === "/api/state") {
+      const group = url.searchParams.get("group") ?? void 0;
+      const limit = Number(url.searchParams.get("limit") ?? 40);
+      return json(res, 200, dashState({ group: group && group.length <= 100 ? group : void 0, limit: Number.isFinite(limit) ? limit : 40 }));
     }
-    if (opts.dryRun) {
-      r("would-add", `would register ${[c.command, ...c.args].join(" ")}`);
-      continue;
+    if (url.pathname === "/api/history") {
+      const q = url.searchParams;
+      const days2 = Number(q.get("days") ?? 0);
+      return json(res, 200, listHistory({
+        text: (q.get("q") ?? "").slice(0, 200),
+        model: q.get("model") || void 0,
+        backend: q.get("backend") || void 0,
+        state: q.get("state") || void 0,
+        group: q.get("group") || void 0,
+        sinceMs: days2 > 0 ? Date.now() - days2 * 864e5 : void 0,
+        beforeId: RUN_ID3.test(q.get("before") ?? "") ? q.get("before") : void 0,
+        limit: Number(q.get("limit") ?? 30) || 30
+      }));
     }
-    if (now !== "absent") attempt2(() => client.remove());
-    const done = attempt2(() => client.add(c));
-    r(done.ok ? now === "absent" ? "added" : "updated" : "failed", done.ok ? `${now === "absent" ? "registered" : "updated"} in ${done.message}` : done.message);
-  }
-  return out;
-}
-function uninstallMcp() {
-  const c = mcpCommand();
-  const out = [];
-  for (const client of clients()) {
-    let has2 = false;
-    try {
-      has2 = client.state(c) !== "absent";
-    } catch {
-      has2 = false;
+    if (url.pathname === "/api/stats") {
+      const days2 = Number(url.searchParams.get("days") ?? 30);
+      return json(res, 200, { ...historyStats(days2 > 0 ? Date.now() - days2 * 864e5 : void 0), price: primaryPrice().name });
     }
-    if (!has2) continue;
-    const done = client.found() ? attempt2(() => client.remove()) : { ok: false, message: `its command does not run: remove the pitroom entry from its config by hand` };
-    out.push({ id: client.id, name: client.name, state: done.ok ? "removed" : "failed", message: done.ok ? `removed from ${done.message}` : done.message });
-  }
-  return out;
-}
-function mcpStatus() {
-  const c = mcpCommand();
-  return clients().map((client) => {
-    try {
-      return { id: client.id, name: client.name, state: client.state(c) };
-    } catch {
-      return { id: client.id, name: client.name, state: "absent" };
+    const m = /^\/api\/run\/([^/]+)$/.exec(url.pathname);
+    if (m) {
+      const d = runDetail(m[1]);
+      return d ? json(res, 200, d) : json(res, 404, { error: "no such run" });
     }
+    return json(res, 404, { error: "not found" });
+  };
+}
+function startDash(opts) {
+  let lastRequest = Date.now();
+  const server = http.createServer(handler(() => lastRequest = Date.now()));
+  return new Promise((resolve2, reject) => {
+    server.once("error", reject);
+    server.listen(opts.port, "127.0.0.1", () => {
+      const port = server.address().port;
+      let done;
+      const closed = new Promise((r) => done = r);
+      let timer2;
+      const close = () => {
+        if (timer2) clearInterval(timer2);
+        server.closeAllConnections?.();
+        return new Promise((r) => server.close(() => (done(), r())));
+      };
+      if (opts.idleMs && opts.idleMs > 0) {
+        timer2 = setInterval(() => Date.now() - lastRequest > opts.idleMs && void close(), Math.min(6e4, opts.idleMs));
+        timer2.unref();
+      }
+      resolve2({ port, url: `http://127.0.0.1:${port}/`, closed, close });
+    });
   });
 }
-var parseClients = (value) => {
-  if (!value) return void 0;
-  const wanted = value.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
-  const bad = wanted.filter((w) => !CLIENT_IDS.includes(w));
-  if (bad.length) throw new Error(`unknown client ${bad.join(", ")} (one of: ${CLIENT_IDS.join(", ")})`);
-  return wanted;
-};
-
-// src/core/plan-status.ts
-import crypto6 from "node:crypto";
-import fs27 from "node:fs";
-import path23 from "node:path";
-function notesFile(plan) {
-  const id = crypto6.createHash("sha1").update(plan.file).digest("hex").slice(0, 12);
-  return path23.join(home(), "plans", id, "notes.md");
+var registryFile = () => path22.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) });
+    return r.ok;
+  } catch {
+    return false;
+  }
 }
-function readNotes(plan) {
-  const f = notesFile(plan);
-  if (!fs27.existsSync(f)) return [];
-  return fs27.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 };
-  });
+async function runningDash() {
+  try {
+    const r = JSON.parse(fs26.readFileSync(registryFile(), "utf8"));
+    if (isAlive(r.pid) && await ping(r.port)) return { ...r, url: `http://127.0.0.1:${r.port}/` };
+  } catch {
+  }
+  fs26.rmSync(registryFile(), { force: true });
+  return void 0;
 }
-function addNote(planFile, text) {
-  const plan = loadPlan(planFile);
-  const f = notesFile(plan);
-  fs27.mkdirSync(path23.dirname(f), { recursive: true });
-  if (!fs27.existsSync(f)) fs27.writeFileSync(f, `# plan: ${plan.file}
-`);
-  const at = (/* @__PURE__ */ new Date()).toISOString().slice(0, 16).replace("T", " ");
-  fs27.appendFileSync(f, `${at} ${text.replace(/\s+/g, " ").trim()}
-`);
-  return f;
+function openBrowser(url) {
+  const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+  try {
+    spawn4(cmd, args, { stdio: "ignore", detached: true }).on("error", () => void 0).unref();
+  } catch {
+  }
 }
-function planStatus(planFile) {
-  const plan = loadPlan(planFile);
-  const runs = [];
-  for (const id of listRunIds()) {
-    try {
-      const m = freshMeta(id);
-      if (m.plan?.file === plan.file) runs.push(m);
-    } catch {
+async function dashCommand(o) {
+  const existing = await runningDash();
+  if (o.stop) {
+    if (!existing) throw new UserError("pitroom dash is not running");
+    process.kill(existing.pid, "SIGTERM");
+    fs26.rmSync(registryFile(), { force: true });
+    o.log(`stopped pitroom dash (${existing.url})`);
+    return 0;
+  }
+  if (existing && !o.serve) {
+    o.log(existing.url);
+    if (o.open) openBrowser(existing.url);
+    return 0;
+  }
+  if (o.detach) {
+    const child = spawn4(process.execPath, [process.argv[1], "dash", "--serve", ...o.port !== void 0 ? ["--port", String(o.port)] : [], "--idle", "1h"], {
+      detached: true,
+      stdio: "ignore",
+      env: process.env
+    });
+    child.on("error", () => void 0);
+    child.unref();
+    for (let i = 0; i < 60; i++) {
+      await new Promise((r2) => setTimeout(r2, 100));
+      const r = await runningDash();
+      if (r && r.pid === child.pid) {
+        o.log(r.url);
+        if (o.open) openBrowser(r.url);
+        return 0;
+      }
     }
+    throw new UserError("pitroom dash did not start (is the port taken? try --port 0)");
   }
-  const notes = readNotes(plan);
-  const tasks = plan.tasks.map((t) => {
-    const impl = runs.filter((m) => m.plan.step === t.step && !m.reviewOf);
-    const rev = runs.filter((m) => m.plan.step === t.step && m.reviewOf).at(-1);
-    const last = impl.at(-1);
-    return {
-      step: t.step,
-      title: t.title,
-      runs: impl.length,
-      last: last && { id: last.id, state: last.state, status: last.taskStatus },
-      review: rev && { id: rev.id, state: rev.state, kind: rev.reviewKind ?? "task", verdict: rev.verdict },
-      applied: impl.some((m) => m.applied || m.mode === "write" && m.state === "done" && !m.reverted && !!m.changes?.length),
-      note: [...notes].reverse().find((n) => n.text.startsWith(`Task ${t.step}:`))?.text
-    };
-  });
-  return { plan, tasks, rulings: notes.filter((n) => /\bRuling:/.test(n.text)), notesFile: notesFile(plan) };
-}
-var cell = (s, max) => {
-  const t = s.replace(/\s+/g, " ").trim();
-  return t.length > max ? `${t.slice(0, max - 1)}\u2026` : t;
-};
-function formatPlanStatus(s) {
-  const head = ["TASK", "STATE", "STATUS", "REVIEW", "ROUNDS", "APPLIED", "TITLE", "NOTE"];
-  const rows = s.tasks.map((t) => {
-    const v = t.review?.verdict;
-    const review = v ? `${v.spec}/${v.quality} (c${v.critical} i${v.important} m${v.minor})` : t.review?.state ?? "-";
-    return [
-      String(t.step),
-      t.last?.state ?? "-",
-      t.last?.status ?? "-",
-      review,
-      t.runs ? String(t.runs - 1) : "-",
-      t.runs ? t.applied ? "yes" : "no" : "-",
-      cell(t.title, 32),
-      cell(t.note ?? "", 60)
-    ];
-  });
-  const widths = head.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
-  const fmt = (r) => r.map((c, i) => i === r.length - 1 ? c : c.padEnd(widths[i])).join("  ").trimEnd();
-  const rulings = s.rulings.length ? s.rulings.map((n) => `  ${n.at} ${n.text}`).join("\n") : "  none";
-  return [
-    `plan ${s.plan.file} \xB7 ${s.plan.title || planName(s.plan.file)} \xB7 ${s.tasks.length} tasks`,
-    "",
-    fmt(head),
-    ...rows.map(fmt),
-    "",
-    `Rulings:
-${rulings}`,
-    `notes: ${s.notesFile}`
-  ].join("\n");
+  importRuns();
+  const explicit = o.port !== void 0;
+  let dash;
+  try {
+    dash = await startDash({ port: o.port ?? DEFAULT_PORT, idleMs: o.idleMs });
+  } catch (e) {
+    if (explicit || e.code !== "EADDRINUSE") throw new UserError(`pitroom dash: ${e.message}`);
+    dash = await startDash({ port: 0, idleMs: o.idleMs });
+  }
+  fs26.mkdirSync(home(), { recursive: true });
+  fs26.writeFileSync(registryFile(), JSON.stringify({ pid: process.pid, port: dash.port }));
+  const stop = () => void dash.close();
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+  if (!o.serve) o.log(`${dash.url}
+(read-only, this machine only; Ctrl-C stops it)`);
+  if (o.open) openBrowser(dash.url);
+  await dash.closed;
+  try {
+    if (JSON.parse(fs26.readFileSync(registryFile(), "utf8")).pid === process.pid) fs26.rmSync(registryFile(), { force: true });
+  } catch {
+  }
+  return 0;
 }
 
-// src/core/review.ts
-import crypto7 from "node:crypto";
-import fs28 from "node:fs";
-import path24 from "node:path";
-var TEMPLATE2 = { task: "task-reviewer", fix: "re-review", range: "code-reviewer" };
-var section = (title, body) => `## ${title}
-
-${body.trim() || "(empty)"}
-`;
-function ancestors(m) {
-  const out = [];
-  for (let id = m.parent; id; ) {
-    const a = readMeta(id);
-    out.push(a);
-    id = a.parent;
+// src/cli/mcp-http.ts
+var DEFAULT_PORT2 = 7117;
+var MAX_BODY = 4e6;
+var MAX_SESSIONS = 64;
+var IDLE_MS = 60 * 6e4;
+var PATH = "/mcp";
+var tokenFile = () => path23.join(home(), "mcp-token");
+var readToken = (file2) => {
+  try {
+    const kept = fs27.readFileSync(file2, "utf8").trim();
+    return kept.length >= 16 ? kept : void 0;
+  } catch {
+    return void 0;
   }
-  return out;
-}
-function briefOf(m) {
-  const root = [m, ...ancestors(m)].at(-1);
-  const f = runFile(root.id, "brief.md");
-  return fs28.existsSync(f) ? fs28.readFileSync(f, "utf8") : root.task;
-}
-function latestReview(ids) {
-  for (const id of listRunIds().reverse()) {
+};
+function mcpToken() {
+  const env = process.env.PITROOM_MCP_TOKEN?.trim();
+  if (env) {
+    if (env.length < 16) throw new UserError("PITROOM_MCP_TOKEN is too short to be a secret (16 characters at least)", 3);
+    return { token: env, from: "PITROOM_MCP_TOKEN" };
+  }
+  const file2 = tokenFile();
+  let token = readToken(file2);
+  if (!token) {
+    fs27.mkdirSync(path23.dirname(file2), { recursive: true });
+    token = crypto7.randomBytes(32).toString("hex");
     try {
-      const m = readMeta(id);
-      if (m.reviewOf && ids.includes(m.reviewOf) && m.state === "done") return m;
-    } catch {
+      fs27.writeFileSync(file2, `${token}
+`, { mode: 384, flag: "wx" });
+    } catch (e) {
+      if (e.code !== "EEXIST") throw e;
+      token = readToken(file2);
+      if (!token) throw new UserError(`${file2} holds no usable token: delete it and start again`, 3);
     }
   }
-  return void 0;
-}
-function diffOf(m, from = m.baseTree) {
-  const where = m.mode === "isolate" ? m.worktree : m.repoRoot;
-  if (where && fs28.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);
+  try {
+    fs27.chmodSync(file2, 384);
+  } catch {
   }
-  return readRunFile(m.id, "changes.patch") ?? archivedRun(m.id)?.patch ?? "";
+  return { token, from: file2 };
 }
-function runReview(id) {
-  const m = freshMeta(id);
-  if (isActive(m.state)) throw new UserError(`run ${m.id} is still ${m.state}; pitroom wait ${m.id} first`, 3);
-  if (m.reviewOf) throw new UserError(`run ${m.id} is itself a review`);
-  if (m.mode === "read") throw new UserError(`run ${m.id} was read-only; there is no change to review`);
-  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 && fs28.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) {
-    return {
-      ...job,
-      kind: "task",
-      package: [`# Review package \xB7 ${title}
-`, section("BRIEF", briefOf(m)), section("REPORT", readSummary(m)), section("DIFF", diffOf(m))].join("\n")
-    };
-  }
-  const reviewed = chain.find((a) => a.id === previous.reviewOf);
-  const from = m.mode === "isolate" ? reviewed.afterTree : m.baseTree;
-  return {
-    ...job,
-    kind: "fix",
-    package: [
-      `# Re-review package \xB7 ${title} \xB7 fix round after review ${previous.id}
-`,
-      section("BRIEF", briefOf(m)),
-      section("PREVIOUS FINDINGS", readSummary(previous)),
-      section("FIX REPORT", readSummary(m)),
-      section("FIX DIFF", diffOf(m, from))
-    ].join("\n")
-  };
+var LOCAL_ORIGIN = /^https?:\/\/(127\.0\.0\.1|localhost|\[::1\])(:\d+)?$/i;
+var sameSecret = (given, token) => {
+  const a = crypto7.createHash("sha256").update(given).digest();
+  const b = crypto7.createHash("sha256").update(token).digest();
+  return crypto7.timingSafeEqual(a, b);
+};
+var idleSince = (k) => Math.max(k.lastSeen, k.closeStream ? k.streamSeen ?? 0 : 0);
+function drop(sessions, id) {
+  const k = sessions.get(id);
+  if (!k) return;
+  k.closeStream?.();
+  endSession(k.session);
+  sessions.delete(id);
+}
+var PING_MS = 25e3;
+function reply(res, status, body, headers = {}) {
+  if (res.headersSent) return void res.end();
+  const text = body === void 0 ? "" : JSON.stringify(body);
+  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 } });
+function readBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (c) => {
+      size += c.length;
+      if (size <= MAX_BODY) chunks.push(c);
+    });
+    req.on("end", () => resolve2(size > MAX_BODY ? "too-big" : Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
 }
-function rangeReview(range, dir, planFile) {
-  const root = repoRoot(dir);
-  if (!root) throw new UserError("--range needs a git repository");
-  const i = range.indexOf("..");
-  const a = i > 0 ? range.slice(0, i) : "";
-  const b = i > 0 ? range.slice(i + 2) || "HEAD" : "";
-  if (!a || b.startsWith(".")) throw new UserError(`--range takes A..B (e.g. main..HEAD), not "${range}"`);
-  for (const ref of [a, b]) if (!commitOf(root, ref)) throw new UserError(`not a commit: ${ref}`);
-  const plan = planFile ? loadPlan(planFile) : void 0;
-  const notes = plan ? readNotes(plan) : [];
-  const requirements = plan ? [
-    `Plan: ${plan.file}`,
-    "### Global Constraints",
-    plan.constraints || "(none stated in the plan)",
-    "### Tasks",
-    plan.tasks.map((t) => `- Task ${t.step}: ${t.title}`).join("\n")
-  ].join("\n\n") : "(none given; judge the change on its own terms)";
-  return {
-    kind: "range",
-    of: `${a}..${b}`,
-    dir: root,
-    group: plan ? planName(plan.file) : void 0,
-    package: [
-      `# Review package \xB7 ${a}..${b}
-`,
-      section("WHAT WAS IMPLEMENTED", plan ? `${plan.title}
+var wantsStream = (parsed) => {
+  const messages = Array.isArray(parsed) ? parsed : [parsed];
+  return messages.some((m) => m && typeof m === "object" && m.id !== void 0 && m.id !== null && progressToken(m.params) !== void 0);
+};
+function evictIdle(sessions) {
+  let oldest;
+  for (const entry of sessions) if (!entry[1].session.inflight.size && (!oldest || idleSince(entry[1]) < idleSince(oldest[1]))) oldest = entry;
+  if (!oldest) return false;
+  drop(sessions, oldest[0]);
+  return true;
+}
+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"));
+    const origin = req.headers.origin;
+    if (origin !== void 0 && !LOCAL_ORIGIN.test(origin)) return reply(res, 403, failure5(-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" });
+    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"));
+      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"));
+      const kept2 = sessions.get(sid);
+      if (!kept2) return reply(res, 404, failure5(-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");
+      const open = () => !res.writableEnded && !res.destroyed;
+      const push = (msg) => {
+        if (!open()) return;
+        kept2.streamSeen = Date.now();
+        res.write(`event: message
+data: ${JSON.stringify(msg)}
 
-${plan.header}` : "The commits below."),
-      section("REQUIREMENTS", requirements),
-      ...notes.length ? [section("NOTES FROM EXECUTION", notes.map((n) => `- ${n.text}`).join("\n"))] : [],
-      rangeDiff(root, a, b)
-    ].join("\n")
+`);
+      };
+      const ping2 = setInterval(() => open() && res.write(": ping\n\n"), PING_MS);
+      ping2.unref();
+      res.on("error", () => {
+      });
+      kept2.streamSeen = Date.now();
+      const close = () => {
+        clearInterval(ping2);
+        if (kept2.session.push === push) kept2.session.push = void 0;
+        if (kept2.closeStream === close) kept2.closeStream = void 0;
+        if (!res.writableEnded) res.end();
+      };
+      kept2.session.push = push;
+      kept2.closeStream = close;
+      res.on("close", close);
+      return;
+    }
+    if (req.method !== "POST") return reply(res, 405, failure5(-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`));
+    let parsed;
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      return reply(res, 400, parseError());
+    }
+    const headers = {};
+    let kept;
+    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`));
+      const id = crypto7.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"));
+      kept = sessions.get(sid);
+      if (!kept) return reply(res, 404, failure5(-32600, "no such session: initialize again"));
+    }
+    kept.lastSeen = Date.now();
+    if (!wantsStream(parsed)) {
+      const out2 = await handlePayload(kept.session, parsed, () => {
+      });
+      kept.lastSeen = Date.now();
+      return out2 === void 0 ? reply(res, 202, void 0, headers) : reply(res, 200, out2, headers);
+    }
+    res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", ...headers });
+    const event = (msg) => {
+      if (!res.writableEnded && !res.destroyed) res.write(`event: message
+data: ${JSON.stringify(msg)}
+
+`);
+    };
+    const out = await handlePayload(kept.session, parsed, event);
+    if (out !== void 0) event(out);
+    kept.lastSeen = Date.now();
+    res.end();
   };
 }
-function pickReviewer(job) {
-  const eff = effective();
-  const tiers = eff.tiers.value;
-  if (job.kind === "range") return tiers.capable;
-  if (tiers.review) return tiers.review;
-  const implementer = job.implementer;
-  if (!implementer) return void 0;
-  const def = parseTarget(eff.worker.value, DEFAULT_BACKEND).backend;
-  const candidates = [tiers.standard, tiers.capable, ...eff.fallback.value, eff.worker.value].filter((s) => !!s);
-  return candidates.find((c) => parseTarget(c, def).backend !== implementer.backend);
-}
-function writePackage(job) {
-  const g = gitDir(job.dir);
-  if (!g) throw new UserError(`not a git repository: ${job.dir}`);
-  const file2 = path24.join(g, "pitroom", `review-${crypto7.randomBytes(4).toString("hex")}.md`);
-  fs28.mkdirSync(path24.dirname(file2), { recursive: true });
-  fs28.writeFileSync(file2, job.package);
-  return file2;
+async function serveMcpHttp(opts) {
+  const { token, from } = mcpToken();
+  const sessions = /* @__PURE__ */ new Map();
+  const handler2 = makeHandler(token, sessions);
+  const server = http2.createServer((req, res) => {
+    handler2(req, res).catch((e) => {
+      process.stderr.write(`pitroom mcp: ${String(e.stack ?? e)}
+`);
+      reply(res, 500, failure5(-32603, "internal error"));
+    });
+  });
+  const sweep = setInterval(() => {
+    for (const [id, k] of [...sessions]) if (Date.now() - idleSince(k) > IDLE_MS && !k.session.inflight.size) drop(sessions, id);
+  }, 6e4);
+  sweep.unref();
+  const port = await new Promise((resolve2, reject) => {
+    server.once("error", (e) => reject(e.code === "EADDRINUSE" ? new UserError(`port ${opts.port} is in use: pick another with --port N (0 picks a free one)`, 3) : e));
+    server.listen(opts.port, "127.0.0.1", () => resolve2(server.address().port));
+  });
+  const url = `http://127.0.0.1:${port}${PATH}`;
+  const secret = from === "PITROOM_MCP_TOKEN" ? "$PITROOM_MCP_TOKEN" : `$(cat "${from}")`;
+  console.log(`pitroom mcp: listening on ${url} (127.0.0.1 only; token from ${from})`);
+  console.log(`  working in ${process.cwd()} (-d DIR starts it in another project; the tools' "dir" argument picks one per call)`);
+  console.log(`  Claude Code: claude mcp add --transport http pitroom ${url} --header "Authorization: Bearer ${secret}"`);
+  console.log('  other clients: URL as above, header "Authorization: Bearer <the token>"');
+  console.log("  anyone with the token can run workers as you: keep it private");
+  await new Promise((resolve2) => {
+    const stop = () => resolve2();
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  });
+  clearInterval(sweep);
+  for (const id of [...sessions.keys()]) drop(sessions, id);
+  server.closeAllConnections();
+  await new Promise((resolve2) => server.close(() => resolve2()));
+  return 0;
 }
 
-// src/core/models.ts
-var base = (model) => (model ?? "").split("#")[0];
-function usage() {
-  const eff = effective();
-  const out = /* @__PURE__ */ new Map();
-  const add = (spec, label) => {
-    let t;
+// src/cli/commands.ts
+import { spawnSync as spawnSync8 } from "node:child_process";
+import fs33 from "node:fs";
+import path29 from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+
+// src/core/init.ts
+import fs28 from "node:fs";
+import path24 from "node:path";
+var FREE = /-free$/;
+var TIER_ORDER = [["cheap", "opencode"], ["standard", "codex"], ["capable", "claude"]];
+var isFound = (binary5) => path24.isAbsolute(binary5) && fs28.existsSync(binary5);
+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 notes = [];
+  const config = {};
+  let blocked;
+  let opencode2;
+  if (workers.find((w) => w.id === "opencode")?.found) {
+    const b = getBackend("opencode");
+    let models = [];
     try {
-      t = parseTarget(spec, "opencode");
+      models = b.catalog ? b.catalog().models.map((m) => m.id) : b.listModels?.() ?? [];
     } catch {
-      return;
+      notes.push("could not list OpenCode models (is it logged in?)");
     }
-    const model = base(t.model) || base(eff.models.value[t.backend]);
-    if (!model) return;
-    const key = `${t.backend}:${model}`;
-    out.set(key, [...out.get(key) ?? [], label]);
-  };
-  add(eff.worker.value, "default worker");
-  for (const [name, spec] of Object.entries(eff.tiers.value)) add(spec, `tier ${name}`);
-  eff.fallback.value.forEach((spec) => add(spec, "fallback"));
-  for (const [backend, model] of Object.entries(eff.models.value)) add(`${backend}:${model}`, "models");
-  return out;
-}
-function modelTable(opts = {}) {
-  const costs = effective().costs.value;
-  const used = usage();
-  const seen = /* @__PURE__ */ new Map();
-  for (const e of readLedger()) {
-    if (!e.backend || !e.model) continue;
-    const key = `${e.backend}:${base(e.model)}`;
-    const a = seen.get(key) ?? { runs: 0, tokens: 0, usd: 0 };
-    seen.set(key, { runs: a.runs + 1, tokens: a.tokens + e.tokens, usd: a.usd + e.workerCost });
-  }
-  const rows = [];
-  const sources = [];
-  let hiddenOpenCode = 0;
-  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 key = `${b.id}:${m.id}`;
-      known.add(key);
-      const s = seen.get(key);
-      const row = {
-        worker: b.id,
-        model: m.id,
-        efforts: m.efforts?.length ? m.efforts : void 0,
-        defaultEffort: m.defaultEffort,
-        cost: costs[key],
-        runs: s?.runs ?? 0,
-        avgTokens: s ? Math.round(s.tokens / s.runs) : void 0,
-        reportedUsdPerRun: s && s.usd > 0 ? s.usd / s.runs : void 0,
-        inUse: used.get(key) ?? []
-      };
-      const relevant = row.inUse.length || row.runs || row.cost !== void 0;
-      if (b.id === "opencode" && !opts.all && !relevant) hiddenOpenCode++;
-      else rows.push(row);
+    const defaultModel4 = b.defaultModel?.();
+    const chosen = opts.model ?? defaultModel4;
+    const free = models.filter((m) => FREE.test(m) && m !== chosen);
+    opencode2 = { defaultModel: defaultModel4, 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) {
+      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);
+    for (const m of fallback) {
+      if (models.length && !models.includes(m)) throw new UserError(`"${m}" is not in \`opencode models\``);
+    }
+    if (fallback.length) {
+      config.fallback = fallback.map((m) => `opencode:${m}`);
+      if (!opts.fallback) notes.push(`fallback suggested from the free models in your catalogue: ${fallback.join(", ")} (change it with --fallback a,b)`);
+    } else {
+      notes.push("no fallback: no free OpenCode model found to suggest (pass --fallback a,b to name some)");
     }
   }
-  for (const [key, labels] of used) {
-    const [worker, ...rest] = key.split(":");
-    if (known.has(key) || opts.backend && worker !== opts.backend) continue;
-    const s = seen.get(key);
-    rows.push({ worker, model: rest.join(":"), cost: costs[key], runs: s?.runs ?? 0, avgTokens: s ? Math.round(s.tokens / s.runs) : void 0, inUse: labels });
-  }
-  rows.sort(
-    (a, b) => a.worker.localeCompare(b.worker) || Number(b.inUse.length > 0) - Number(a.inUse.length > 0) || (a.cost ?? Infinity) - (b.cost ?? Infinity) || b.runs - a.runs || a.model.localeCompare(b.model)
-  );
-  return { rows, sources, hiddenOpenCode };
+  const tiers = Object.fromEntries(TIER_ORDER.filter(([, id]) => workers.find((w) => w.id === id)?.found));
+  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: fs28.existsSync(file2), workers, opencode: opencode2, config, blocked, notes };
 }
-var compact2 = (n) => n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1e3 ? `${Math.round(n / 1e3)}k` : String(n);
-function formatModels(t) {
-  const efforts = (r) => r.efforts ? r.efforts.map((e) => e === r.defaultEffort ? `${e}*` : e).join("/") : "-";
-  const cells = t.rows.map((r) => [
-    r.worker,
-    r.model,
-    efforts(r),
-    r.cost !== void 0 ? String(r.cost) : "?",
-    r.runs ? String(r.runs) : "-",
-    r.avgTokens !== void 0 ? compact2(r.avgTokens) : "-",
-    r.reportedUsdPerRun !== void 0 ? `$${r.reportedUsdPerRun.toFixed(3)}` : "-",
-    r.inUse.join(", ") || "-"
-  ]);
-  const head = ["worker", "model", "effort (* default)", "cost", "runs", "avg tokens", "$/run", "in use"];
-  const widths = head.map((h, i) => Math.max(h.length, ...cells.map((c) => c[i].length)));
-  const line = (c) => c.map((x, i) => x.padEnd(widths[i])).join("  ").trimEnd();
-  const out = [line(head), ...cells.map(line), ""];
-  out.push('cost: your relative cost from the config ("costs": {"codex:gpt-6-sol": 1, \u2026}); ? = not set. Pitroom cannot know vendor prices.');
-  out.push("runs, avg tokens, $/run: from your own runs (only Claude Code and OpenCode report dollars). Choose one with -W worker:model --effort LEVEL.");
-  if (t.hiddenOpenCode) out.push(`${t.hiddenOpenCode} more OpenCode models not shown (use --all).`);
-  out.push(...t.sources.map((s) => `source ${s}`));
+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 ${path24.basename(plan.path)}.bak)`);
+  fs28.mkdirSync(path24.dirname(plan.path), { recursive: true });
+  if (plan.exists) fs28.copyFileSync(plan.path, `${plan.path}.bak`);
+  fs28.writeFileSync(plan.path, `${JSON.stringify(plan.config, null, 2)}
+`);
+  return plan.path;
+}
+function formatInit(plan, written) {
+  const out = [bold("pitroom init") + dim(": worker CLIs on this machine")];
+  for (const w of plan.workers) out.push(`  ${w.found ? green("\u2714") : dim("\xB7")} ${w.name.padEnd(12)} ${w.found ? w.binary : dim("not found")}`);
+  if (plan.opencode) {
+    const o = plan.opencode;
+    out.push(`  OpenCode: ${o.models} models, default ${o.defaultModel ?? "none"}${o.free.length ? `, free: ${o.free.slice(0, 3).join(", ")}${o.free.length > 3 ? ", \u2026" : ""}` : ""}`);
+  }
+  out.push("", `config file: ${plan.path}${plan.exists ? " (exists)" : " (not present)"}`, JSON.stringify(plan.config, null, 2));
+  for (const n of plan.notes) out.push(`  note: ${n}`);
+  if (written) out.push("", green(`\u2714 written to ${written}`), dim("  next: pitroom doctor, then pitroom install"));
+  else if (plan.blocked) out.push("", yellow(`! ${plan.blocked}`));
+  else out.push("", `nothing written yet: pass --yes to write it${plan.exists ? " (with --force, since the file exists)" : ""}`);
   return out.join("\n");
 }
 
-// src/core/dash.ts
-import { spawn as spawn4 } from "node:child_process";
-import crypto8 from "node:crypto";
+// src/core/mcp-install.ts
+import { spawnSync as spawnSync7 } from "node:child_process";
 import fs29 from "node:fs";
-import http from "node:http";
+import os10 from "node:os";
 import path25 from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
-
-// src/core/file-diff.ts
-var PREVIEW_LINES = 300;
-function gitPath(value, prefix = true) {
-  let path28 = value;
-  if (value.startsWith('"') && value.endsWith('"')) {
-    const bytes = [];
-    const escapes = { t: "	", n: "\n", r: "\r", b: "\b", f: "\f", v: "\v" };
-    for (const match of value.slice(1, -1).matchAll(/\\([0-7]{1,3}|.)|([^\\]+)/g)) {
-      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]));
-    }
-    path28 = new TextDecoder().decode(new Uint8Array(bytes));
+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(path25.delimiter).filter(Boolean)) {
+    const p = path25.join(dir, process.platform === "win32" ? "pitroom.cmd" : "pitroom");
+    if (fs29.existsSync(p)) return { command: path25.resolve(p), args: ["mcp"] };
   }
-  return prefix ? path28.replace(/^[ab]\//, "") : path28;
+  return { command: process.execPath, args: [process.argv[1] ?? "pitroom", "mcp"] };
 }
-function headerPath(header) {
-  const quoted = header.match(/^diff --git ("(?:[^"\\]|\\.)*"|\S+) ("(?:[^"\\]|\\.)*"|\S+)$/);
-  if (quoted) return gitPath(quoted[2]);
-  return gitPath(header.slice(header.lastIndexOf(" b/") + 1));
+var same = (a, b) => {
+  const o = b;
+  return !!o && o.command === a.command && Array.isArray(o.args) && o.args.join("\0") === a.args.join("\0");
+};
+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"] });
+  return { ok: r.status === 0 && !r.error, out: `${r.stdout ?? ""}${r.stderr ?? ""}`.trim() };
 }
-function fileDiffs(patch, changes, sourceTruncated = false) {
-  const files = [];
-  let file2;
-  let oldLine = 0;
-  let newLine = 0;
-  let oldLeft = 0;
-  let newLeft = 0;
-  let inHunk = false;
-  let row = 0;
-  const finishHunk = () => {
-    if (file2 && (oldLeft > 0 || newLeft > 0)) file2.incomplete = true;
-    oldLeft = newLeft = 0;
-    inHunk = false;
+var runnable = (backendId) => run(backendId, ["--version"]).ok;
+var readJson = (file2) => {
+  try {
+    return JSON.parse(fs29.readFileSync(file2, "utf8"));
+  } catch {
+    return void 0;
+  }
+};
+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 = () => path25.join(process.env.GEMINI_CLI_HOME ?? home2(), ".gemini");
+function cliClient(id, backend, name, where, o) {
+  return {
+    id,
+    name,
+    where,
+    found: () => runnable(backend),
+    state: o.state,
+    add: (c) => {
+      const r = run(backend, o.add(c));
+      return { ok: r.ok, message: r.ok ? where : r.out.split("\n")[0]?.trim() || `${name}'s command failed` };
+    },
+    remove: () => {
+      const r = run(backend, o.remove());
+      return { ok: r.ok, message: r.ok ? where : r.out.split("\n")[0]?.trim() || `${name}'s command failed` };
+    }
   };
-  const add = (line) => {
-    if (!file2) return;
-    if (file2.lines.length < PREVIEW_LINES) file2.lines.push({ ...line, id: String(row) });
-    else file2.omittedLines++;
-    row++;
+}
+function jsonClient(id, name, file2, dir) {
+  const rel = () => file2().replace(home2(), "~");
+  return {
+    id,
+    name,
+    found: () => fs29.existsSync(dir()),
+    state: (c) => jsonState(file2(), c),
+    add: (c) => {
+      let config = {};
+      if (fs29.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 (!fs29.existsSync(backup)) fs29.copyFileSync(file2(), backup);
+      }
+      config.mcpServers = { ...config.mcpServers ?? {}, [NAME]: { command: c.command, args: c.args } };
+      fs29.mkdirSync(path25.dirname(file2()), { recursive: true });
+      const tmp = `${file2()}.${process.pid}.tmp`;
+      fs29.writeFileSync(tmp, `${JSON.stringify(config, null, 2)}
+`);
+      fs29.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];
+      fs29.writeFileSync(file2(), `${JSON.stringify(config, null, 2)}
+`);
+      return { ok: true, message: rel() };
+    }
   };
-  for (const line of patch.split("\n")) {
-    if (line.startsWith("diff --git ")) {
-      finishHunk();
-      file2 = { path: headerPath(line), status: "M", lines: [], additions: 0, deletions: 0, omittedLines: 0, binary: false, incomplete: false };
-      files.push(file2);
-      row = 0;
+}
+function desktopFile() {
+  if (process.platform === "darwin") return path25.join(home2(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  if (process.platform === "win32") return path25.join(process.env.APPDATA ?? path25.join(home2(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+  return path25.join(process.env.XDG_CONFIG_HOME ?? path25.join(home2(), ".config"), "Claude", "claude_desktop_config.json");
+}
+function codexState(c) {
+  let text;
+  try {
+    text = fs29.readFileSync(path25.join(process.env.CODEX_HOME ?? path25.join(home2(), ".codex"), "config.toml"), "utf8");
+  } catch {
+    return "absent";
+  }
+  const at = text.search(/^\[mcp_servers\.pitroom\]\s*$/m);
+  if (at < 0) return "absent";
+  const table2 = text.slice(at).split(/\n(?=\[)/)[0] ?? "";
+  try {
+    const command = /^command\s*=\s*("(?:[^"\\]|\\.)*")/m.exec(table2)?.[1];
+    const args = /^args\s*=\s*(\[[^\n]*\])/m.exec(table2)?.[1];
+    return command && args && same(c, { command: JSON.parse(command), args: JSON.parse(args) }) ? "same" : "different";
+  } catch {
+    return "different";
+  }
+}
+function clients() {
+  return [
+    cliClient("claude-code", "claude", "Claude Code", "user settings (~/.claude.json)", {
+      state: (c) => jsonState(path25.join(home2(), ".claude.json"), c),
+      add: (c) => ["mcp", "add", "--scope", "user", NAME, "--", c.command, ...c.args],
+      remove: () => ["mcp", "remove", NAME, "--scope", "user"]
+    }),
+    cliClient("codex", "codex", "Codex", "~/.codex/config.toml", {
+      state: (c) => codexState(c),
+      add: (c) => ["mcp", "add", NAME, "--", c.command, ...c.args],
+      remove: () => ["mcp", "remove", NAME]
+    }),
+    cliClient("gemini", "gemini", "Gemini CLI", "user settings (~/.gemini/settings.json)", {
+      state: (c) => jsonState(path25.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", () => path25.join(home2(), ".cursor", "mcp.json"), () => path25.join(home2(), ".cursor")),
+    jsonClient("claude-desktop", "Claude Desktop", desktopFile, () => path25.dirname(desktopFile()))
+  ];
+}
+function attempt2(f) {
+  try {
+    return f();
+  } catch (e) {
+    return { ok: false, message: e.message.split("\n")[0] ?? "failed" };
+  }
+}
+function installMcp(opts = {}) {
+  const c = mcpCommand();
+  const out = [];
+  for (const client of clients()) {
+    if (opts.only && !opts.only.includes(client.id)) continue;
+    const r = (state, message) => out.push({ id: client.id, name: client.name, state, message });
+    if (!client.found()) {
+      r("not-found", client.id === "cursor" || client.id === "claude-desktop" ? "not found on this machine" : "not installed (its command does not run)");
       continue;
     }
-    if (!file2) continue;
-    const hunk = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.exec(line);
-    if (hunk) {
-      finishHunk();
-      oldLine = Number(hunk[1]);
-      newLine = Number(hunk[3]);
-      oldLeft = Number(hunk[2] ?? 1);
-      newLeft = Number(hunk[4] ?? 1);
-      inHunk = true;
-      add({ type: "hunk", content: line });
-    } else if (inHunk && line.startsWith("\")) {
-      add({ type: "meta", content: line });
-    } else if (inHunk && (oldLeft > 0 || newLeft > 0)) {
-      if (line.startsWith("+") && newLeft > 0) {
-        file2.additions++;
-        newLeft--;
-        add({ type: "added", newLine: newLine++, content: line.slice(1) });
-      } else if (line.startsWith("-") && oldLeft > 0) {
-        file2.deletions++;
-        oldLeft--;
-        add({ type: "removed", oldLine: oldLine++, content: line.slice(1) });
-      } else if (line.startsWith(" ") && oldLeft > 0 && newLeft > 0) {
-        oldLeft--;
-        newLeft--;
-        add({ type: "context", oldLine: oldLine++, newLine: newLine++, content: line.slice(1) });
-      } else {
-        file2.incomplete = true;
-      }
-    } else if (!inHunk) {
-      if (line.startsWith("+++ ") && line !== "+++ /dev/null") file2.path = gitPath(line.slice(4).replace(/\t$/, ""));
-      else if (line.startsWith("--- ") && line !== "--- /dev/null") file2.path = gitPath(line.slice(4).replace(/\t$/, ""));
-      else if (/^(GIT binary patch|Binary files .* differ)$/.test(line)) file2.binary = true;
-      else if (/^(new file mode|deleted file mode|old mode|new mode|rename from|rename to|similarity index) /.test(line)) {
-        if (line.startsWith("new file mode ")) file2.status = "A";
-        if (line.startsWith("deleted file mode ")) file2.status = "D";
-        if (line.startsWith("rename to ")) {
-          file2.path = gitPath(line.slice(10), false);
-          file2.status = "R";
-        }
-        add({ type: "meta", content: line });
-      }
+    const now = client.state(c);
+    if (now === "same" && !opts.force) {
+      r("already", "already registered");
+      continue;
+    }
+    if (opts.dryRun) {
+      r("would-add", `would register ${[c.command, ...c.args].join(" ")}`);
+      continue;
     }
+    if (now !== "absent") attempt2(() => client.remove());
+    const done = attempt2(() => client.add(c));
+    r(done.ok ? now === "absent" ? "added" : "updated" : "failed", done.ok ? `${now === "absent" ? "registered" : "updated"} in ${done.message}` : done.message);
   }
-  finishHunk();
-  if (sourceTruncated && file2) file2.incomplete = true;
-  for (const f of files) {
-    if (f.incomplete || f.binary) f.additions = f.deletions = void 0;
+  return out;
+}
+function uninstallMcp() {
+  const c = mcpCommand();
+  const out = [];
+  for (const client of clients()) {
+    let has2 = false;
+    try {
+      has2 = client.state(c) !== "absent";
+    } catch {
+      has2 = false;
+    }
+    if (!has2) continue;
+    const done = client.found() ? attempt2(() => client.remove()) : { ok: false, message: `its command does not run: remove the pitroom entry from its config by hand` };
+    out.push({ id: client.id, name: client.name, state: done.ok ? "removed" : "failed", message: done.ok ? `removed from ${done.message}` : done.message });
   }
-  const byPath = new Map(files.map((f) => [f.path, f]));
-  const result = changes.map((change) => {
-    const diff = byPath.get(change.path);
-    byPath.delete(change.path);
-    return diff ? { ...diff, status: change.status } : {
-      ...change,
-      lines: [],
-      omittedLines: 0,
-      binary: false,
-      incomplete: sourceTruncated,
-      unavailable: true
-    };
-  });
-  return [...result, ...byPath.values()];
+  return out;
 }
-
-// src/core/dash-page.ts
-var THEME_SCRIPT = "(function(){try{var t=localStorage.getItem('pitroom-theme');var d=t?t==='dark':matchMedia('(prefers-color-scheme: dark)').matches;document.documentElement.classList.toggle('dark',d)}catch(e){}})()";
-var ICON3 = "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' rx='8' fill='%23ff6a2b'/%3E%3Cpath d='M9 8h4v4H9zm8 0h4v4h-4zm-4 4h4v4h-4zm8 0h4v4h-4zM9 16h4v4H9zm8 0h4v4h-4zm-4 4h4v4h-4zm8 0h4v4h-4z' fill='%23fff'/%3E%3C/svg%3E";
-var PAGE = `<!doctype html>
-<html lang="en" class="dark"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
-<meta name="color-scheme" content="dark light"><title>Pitroom</title><link rel="icon" href="${ICON3}">
-<script>${THEME_SCRIPT}</script><link rel="stylesheet" href="/assets/app.css"></head>
-<body><div id="root"></div><script type="module" src="/assets/app.js"></script></body></html>`;
-var MISSING = `<!doctype html><meta charset="utf-8"><title>Pitroom</title><body style="font:15px system-ui;padding:3rem;max-width:40rem;margin:auto"><h1>Pitroom dash</h1><p>The dashboard files are missing (dist/ui). Run <code>npm run build</code> in the Pitroom repository, or reinstall the package.</p></body>`;
-
-// src/core/dash.ts
-var DEFAULT_PORT = 7878;
-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 oneLine6 = (s, max) => {
-  const t = s.replace(/\s+/g, " ").trim();
-  return t.length > max ? `${t.slice(0, max - 1)}\u2026` : t;
-};
-function findings(m) {
-  const v = m.verdict;
-  if (!v) return "";
-  const parts = [v.critical && `${v.critical} critical`, v.important && `${v.important} important`, v.minor && `${v.minor} minor`].filter(Boolean);
-  return parts.length ? parts.join(" \xB7 ") : "no findings";
+function mcpStatus() {
+  const c = mcpCommand();
+  return clients().map((client) => {
+    try {
+      return { id: client.id, name: client.name, state: client.state(c) };
+    } catch {
+      return { id: client.id, name: client.name, state: "absent" };
+    }
+  });
 }
-function toRun(m) {
-  const l = m.state === "running" ? live(m) : void 0;
-  return {
-    id: m.id,
-    state: m.state,
-    kind: kind(m),
-    // the model that really ran, once the CLI has said which; until then just the worker, never a guess
-    worker: workerName(ranTarget(m)),
-    task: what(m),
-    group: m.group,
-    startedAt: m.startedAt,
-    time: elapsed(m),
-    steps: l ? l.steps : m.usage?.steps ?? 0,
-    tokens: m.usage?.total,
-    saved: m.savedUsd || void 0,
-    verdict: m.verdict ? `SPEC ${m.verdict.spec.toUpperCase()} \xB7 QUALITY ${m.verdict.quality.toUpperCase()}` : m.auditVerdict ? `AUDIT ${m.auditVerdict.toUpperCase()}` : void 0,
-    audit: auditBadge(m),
-    changes: m.changes?.length || void 0,
-    applied: m.applied || void 0,
-    note: l?.last ? oneLine6(String(l.last), 140) : isActive(m.state) ? "" : m.verdict ? findings(m) : m.auditOf && m.state === "done" ? m.auditDisputed?.length ? `${m.auditDisputed.length} disputed` : "nothing disputed" : headline(m, 200) || oneLine6(m.error ?? "", 200)
-  };
+var parseClients = (value) => {
+  if (!value) return void 0;
+  const wanted = value.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+  const bad = wanted.filter((w) => !CLIENT_IDS.includes(w));
+  if (bad.length) throw new Error(`unknown client ${bad.join(", ")} (one of: ${CLIENT_IDS.join(", ")})`);
+  return wanted;
+};
+
+// src/core/plan-status.ts
+import crypto8 from "node:crypto";
+import fs30 from "node:fs";
+import path26 from "node:path";
+function notesFile(plan) {
+  const id = crypto8.createHash("sha1").update(plan.file).digest("hex").slice(0, 12);
+  return path26.join(home(), "plans", id, "notes.md");
 }
-function dashState(opts = {}) {
-  const limit = Math.min(Math.max(opts.limit ?? 40, 1), 200);
+function readNotes(plan) {
+  const f = notesFile(plan);
+  if (!fs30.existsSync(f)) return [];
+  return fs30.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 };
+  });
+}
+function addNote(planFile, text) {
+  const plan = loadPlan(planFile);
+  const f = notesFile(plan);
+  fs30.mkdirSync(path26.dirname(f), { recursive: true });
+  if (!fs30.existsSync(f)) fs30.writeFileSync(f, `# plan: ${plan.file}
+`);
+  const at = (/* @__PURE__ */ new Date()).toISOString().slice(0, 16).replace("T", " ");
+  fs30.appendFileSync(f, `${at} ${text.replace(/\s+/g, " ").trim()}
+`);
+  return f;
+}
+function planStatus(planFile) {
+  const plan = loadPlan(planFile);
   const runs = [];
-  const groups = /* @__PURE__ */ new Set();
-  for (const id of listRunIds().slice(-SCAN).reverse()) {
-    let m;
+  for (const id of listRunIds()) {
     try {
-      m = freshMeta(id);
+      const m = freshMeta(id);
+      if (m.plan?.file === plan.file) runs.push(m);
     } catch {
-      continue;
     }
-    if (m.group) groups.add(m.group);
-    if (opts.group && m.group !== opts.group) continue;
-    if (runs.length < limit) runs.push(toRun(m));
   }
-  return {
-    price: primaryPrice().name,
-    running: runs.filter((r) => r.state === "running" || r.state === "queued").length,
-    saved: totals(readLedger(Date.now() - WEEK_MS2)).saved,
-    groups: [...groups].sort(),
-    runs
-  };
+  const notes = readNotes(plan);
+  const tasks = plan.tasks.map((t) => {
+    const impl = runs.filter((m) => m.plan.step === t.step && !m.reviewOf);
+    const rev = runs.filter((m) => m.plan.step === t.step && m.reviewOf).at(-1);
+    const last = impl.at(-1);
+    return {
+      step: t.step,
+      title: t.title,
+      runs: impl.length,
+      last: last && { id: last.id, state: last.state, status: last.taskStatus },
+      review: rev && { id: rev.id, state: rev.state, kind: rev.reviewKind ?? "task", verdict: rev.verdict },
+      applied: impl.some((m) => m.applied || m.mode === "write" && m.state === "done" && !m.reverted && !!m.changes?.length),
+      note: [...notes].reverse().find((n) => n.text.startsWith(`Task ${t.step}:`))?.text
+    };
+  });
+  return { plan, tasks, rulings: notes.filter((n) => /\bRuling:/.test(n.text)), notesFile: notesFile(plan) };
 }
-var TASK_MAX = 6e3;
-var PATCH_LINES = 300;
-function runDetail(id) {
-  if (!RUN_ID3.test(id)) return void 0;
-  let m;
+var cell = (s, max) => {
+  const t = s.replace(/\s+/g, " ").trim();
+  return t.length > max ? `${t.slice(0, max - 1)}\u2026` : t;
+};
+function formatPlanStatus(s) {
+  const head = ["TASK", "STATE", "STATUS", "REVIEW", "ROUNDS", "APPLIED", "TITLE", "NOTE"];
+  const rows = s.tasks.map((t) => {
+    const v = t.review?.verdict;
+    const review = v ? `${v.spec}/${v.quality} (c${v.critical} i${v.important} m${v.minor})` : t.review?.state ?? "-";
+    return [
+      String(t.step),
+      t.last?.state ?? "-",
+      t.last?.status ?? "-",
+      review,
+      t.runs ? String(t.runs - 1) : "-",
+      t.runs ? t.applied ? "yes" : "no" : "-",
+      cell(t.title, 32),
+      cell(t.note ?? "", 60)
+    ];
+  });
+  const widths = head.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
+  const fmt = (r) => r.map((c, i) => i === r.length - 1 ? c : c.padEnd(widths[i])).join("  ").trimEnd();
+  const rulings = s.rulings.length ? s.rulings.map((n) => `  ${n.at} ${n.text}`).join("\n") : "  none";
+  return [
+    `plan ${s.plan.file} \xB7 ${s.plan.title || planName(s.plan.file)} \xB7 ${s.tasks.length} tasks`,
+    "",
+    fmt(head),
+    ...rows.map(fmt),
+    "",
+    `Rulings:
+${rulings}`,
+    `notes: ${s.notesFile}`
+  ].join("\n");
+}
+
+// src/core/cache.ts
+import crypto9 from "node:crypto";
+import fs31 from "node:fs";
+import path27 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 = path27.resolve(o.dir);
+  const root = repoRoot(dir);
+  if (!root) return void 0;
   try {
-    m = freshMeta(id);
+    const tree = snapshotTree(root);
+    const head = commitOf(root, "HEAD") ?? "";
+    const files = o.files.map((f) => {
+      const abs = path27.resolve(f);
+      return [abs, crypto9.createHash("sha256").update(fs31.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 = crypto9.createHash("sha256").update(JSON.stringify([question, path27.relative(root, dir), files, where])).digest("hex");
+    return { key, state: `${head}:${tree}` };
   } catch {
     return void 0;
   }
-  const start = Date.parse(m.startedAt);
-  const kept = isActive(m.state) ? void 0 : archivedRun(id);
-  let steps = kept?.steps ?? [];
-  if (!steps.length) try {
-    const events = readRunFile(id, "events.jsonl");
-    steps = (events ? getBackend((m.ran ?? m.worker).backend).parse(events).timeline ?? [] : []).map((s) => ({
-      ...s,
-      t: s.at && Number.isFinite(start) ? Math.max(0, Math.round((s.at - start) / 1e3)) : void 0
-    }));
-  } catch {
-  }
-  const rel = (t) => [m.cwd, m.dir].filter(Boolean).reduce((x, base2) => x.split(`${base2}/`).join(""), t);
-  steps = steps.map((x) => ({ ...x, text: rel(x.text) }));
-  const answer = isActive(m.state) ? "" : readSummary(m).replace(/^SUMMARY:\s*SPEC[^\n]*\n+/i, "").replace(/^DETAILS:[ \t]*\n+/i, "").trim();
-  const lastSay = steps.at(-1);
-  if (lastSay?.kind === "say" && answer && (answer.includes(lastSay.text.slice(0, 80)) || lastSay.text.includes(answer.slice(0, 80)))) steps.pop();
-  const fullPatch = readRunFile(id, "changes.patch");
-  const patch = fullPatch ?? kept?.patch ?? "";
-  const patchLines = patch.split("\n");
-  const u = m.usage;
-  return {
-    id,
-    state: m.state,
-    card: toRun(m),
-    task: (m.auditOf ? `Audit of ${m.auditOf}` : m.reviewOf ? `Review of ${m.reviewOf.replace(/\b([0-9a-f]{9})[0-9a-f]{31}\b/g, "$1")}` : m.task).slice(0, TASK_MAX),
-    steps,
-    answer,
-    changes: m.changes ?? [],
-    fileDiffs: fileDiffs(patch, m.changes ?? [], fullPatch === void 0 && kept?.patchTruncated),
-    patch: patch ? `${patchLines.slice(0, PATCH_LINES).join("\n")}${patchLines.length > PATCH_LINES ? `
-\u2026 ${patchLines.length - PATCH_LINES} more lines (pitroom show ${id} --patch)` : ""}` : void 0,
-    info: {
-      worker: (m.ran ?? m.worker).backend,
-      // the model has its own line
-      model: m.resolvedModel,
-      mode: m.mode,
-      started: m.startedAt,
-      time: elapsed(m),
-      steps: u?.steps,
-      toolCalls: u?.toolCalls,
-      tokens: u?.total,
-      returnedTokens: m.returnedTokens,
-      cost: u?.cost,
-      saved: m.savedUsd,
-      group: m.group,
-      directory: m.dir
-    },
-    attempts: m.attempts ?? [],
-    warnings: m.warnings ?? [],
-    refs: m.refs ? { valid: m.refs.valid, total: m.refs.total, invalid: m.refs.invalid.map((r) => `${r.ref} (${r.reason})`) } : void 0,
-    verify: m.verifyResult && m.verify ? { command: m.verify, ok: m.verifyResult.ok, tail: m.verifyResult.tail } : void 0,
-    error: m.error,
-    audit: m.auditOf ? m.state === "done" ? { state: m.state, verdict: m.auditVerdict, disputed: m.auditDisputed ?? [] } : void 0 : m.audit && { id: m.audit.id, state: m.audit.state, verdict: m.audit.verdict, disputed: m.audit.disputed ?? [] },
-    report: isActive(m.state) ? progress(m) : formatReport(m, void 0, 120)
-  };
 }
-var HEADERS = {
-  "cache-control": "no-store",
-  "x-content-type-options": "nosniff",
-  "referrer-policy": "no-referrer",
-  // Own files only, plus the hash of the one inline theme script; styles may be inline (the components position popups with them).
-  "content-security-policy": `default-src 'none'; script-src 'self' 'sha256-${crypto8.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 assetCache = /* @__PURE__ */ new Map();
-function readAsset(route) {
+function heldUp(m) {
+  if (m.state !== "done" || m.mode !== "read" || m.reviewOf || m.auditOf) return false;
+  if (m.refs && m.refs.invalid.length) return false;
+  if (m.warnings.some((w) => w.startsWith("READ-ONLY VIOLATION"))) return false;
+  if (m.audit && (isActive(m.audit.state) || m.audit.verdict === "disagree" || m.audit.verdict === "partial")) return false;
   try {
-    const file2 = path25.join(assetsDir(), path25.basename(route));
-    const { mtimeMs } = fs29.statSync(file2);
-    const hit = assetCache.get(route);
-    if (hit && hit.mtimeMs === mtimeMs) return hit.data;
-    const data = fs29.readFileSync(file2);
-    assetCache.set(route, { mtimeMs, data });
-    return data;
+    return readSummary(m).trim() !== "";
   } catch {
-    return void 0;
+    return false;
   }
 }
-function handler(touch2) {
-  const send2 = (res, code, type, body) => {
-    res.writeHead(code, { ...HEADERS, "content-type": type });
-    res.end(body);
-  };
-  const json = (res, code, value) => send2(res, code, "application/json; charset=utf-8", JSON.stringify(value));
-  return (req, res) => {
-    touch2();
-    if (!LOCAL_HOST.test(req.headers.host ?? "")) return json(res, 403, { error: "forbidden host" });
-    if (req.method !== "GET" && req.method !== "HEAD") return json(res, 405, { error: "read-only" });
-    const url = new URL(req.url ?? "/", "http://127.0.0.1");
-    if (url.pathname === "/") return send2(res, 200, "text/html; charset=utf-8", readAsset("/assets/app.js") ? PAGE : MISSING);
-    const type = ASSETS[url.pathname];
-    if (type) {
-      const data = readAsset(url.pathname);
-      if (!data) return json(res, 404, { error: "dashboard files missing" });
-      res.writeHead(200, { ...HEADERS, "content-type": type });
-      return void res.end(req.method === "HEAD" ? void 0 : data);
-    }
-    if (url.pathname === "/api/state") {
-      const group = url.searchParams.get("group") ?? void 0;
-      const limit = Number(url.searchParams.get("limit") ?? 40);
-      return json(res, 200, dashState({ group: group && group.length <= 100 ? group : void 0, limit: Number.isFinite(limit) ? limit : 40 }));
-    }
-    if (url.pathname === "/api/history") {
-      const q = url.searchParams;
-      const days = Number(q.get("days") ?? 0);
-      return json(res, 200, listHistory({
-        text: (q.get("q") ?? "").slice(0, 200),
-        model: q.get("model") || void 0,
-        backend: q.get("backend") || void 0,
-        state: q.get("state") || void 0,
-        group: q.get("group") || void 0,
-        sinceMs: days > 0 ? Date.now() - days * 864e5 : void 0,
-        beforeId: RUN_ID3.test(q.get("before") ?? "") ? q.get("before") : void 0,
-        limit: Number(q.get("limit") ?? 30) || 30
-      }));
-    }
-    if (url.pathname === "/api/stats") {
-      const days = Number(url.searchParams.get("days") ?? 30);
-      return json(res, 200, { ...historyStats(days > 0 ? Date.now() - days * 864e5 : void 0), price: primaryPrice().name });
-    }
-    const m = /^\/api\/run\/([^/]+)$/.exec(url.pathname);
-    if (m) {
-      const d = runDetail(m[1]);
-      return d ? json(res, 200, d) : json(res, 404, { error: "no such run" });
+function findCached(k, now = Date.now()) {
+  const maxAge = effective().cacheDays.value * 864e5;
+  let best;
+  for (const id of listRunIds().slice(-SCAN2)) {
+    let m;
+    try {
+      m = readMeta(id);
+    } catch {
+      continue;
     }
-    return json(res, 404, { error: "not found" });
-  };
+    if (m.cache?.key !== k.key || m.cache.state !== k.state) continue;
+    const at = Date.parse(m.endedAt ?? m.startedAt);
+    if (now - at > maxAge || best && at <= best.at || !heldUp(m)) continue;
+    best = { m, at };
+  }
+  return best?.m;
 }
-function startDash(opts) {
-  let lastRequest = Date.now();
-  const server = http.createServer(handler(() => lastRequest = Date.now()));
-  return new Promise((resolve2, reject) => {
-    server.once("error", reject);
-    server.listen(opts.port, "127.0.0.1", () => {
-      const port = server.address().port;
-      let done;
-      const closed = new Promise((r) => done = r);
-      let timer;
-      const close = () => {
-        if (timer) clearInterval(timer);
-        server.closeAllConnections?.();
-        return new Promise((r) => server.close(() => (done(), r())));
-      };
-      if (opts.idleMs && opts.idleMs > 0) {
-        timer = setInterval(() => Date.now() - lastRequest > opts.idleMs && void close(), Math.min(6e4, opts.idleMs));
-        timer.unref();
-      }
-      resolve2({ port, url: `http://127.0.0.1:${port}/`, closed, close });
-    });
-  });
+function ago(iso, now = Date.now()) {
+  const s = Math.max(0, (now - Date.parse(iso)) / 1e3);
+  if (s < 3600) return `${Math.max(1, Math.round(s / 60))} min ago`;
+  if (s < 86400) return `${Math.round(s / 3600)} h ago`;
+  return `${Math.round(s / 86400)} d ago`;
 }
-var registryFile = () => path25.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) });
-    return r.ok;
-  } catch {
-    return false;
+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/review.ts
+import crypto10 from "node:crypto";
+import fs32 from "node:fs";
+import path28 from "node:path";
+var TEMPLATE2 = { task: "task-reviewer", fix: "re-review", range: "code-reviewer" };
+var section = (title, body) => `## ${title}
+
+${body.trim() || "(empty)"}
+`;
+function ancestors(m) {
+  const out = [];
+  for (let id = m.parent; id; ) {
+    const a = readMeta(id);
+    out.push(a);
+    id = a.parent;
   }
+  return out;
 }
-async function runningDash() {
-  try {
-    const r = JSON.parse(fs29.readFileSync(registryFile(), "utf8"));
-    if (isAlive(r.pid) && await ping(r.port)) return { ...r, url: `http://127.0.0.1:${r.port}/` };
-  } catch {
+function briefOf(m) {
+  const root = [m, ...ancestors(m)].at(-1);
+  const f = runFile(root.id, "brief.md");
+  return fs32.existsSync(f) ? fs32.readFileSync(f, "utf8") : root.task;
+}
+function latestReview(ids) {
+  for (const id of listRunIds().reverse()) {
+    try {
+      const m = readMeta(id);
+      if (m.reviewOf && ids.includes(m.reviewOf) && m.state === "done") return m;
+    } catch {
+    }
   }
-  fs29.rmSync(registryFile(), { force: true });
   return void 0;
 }
-function openBrowser(url) {
-  const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
-  try {
-    spawn4(cmd, args, { stdio: "ignore", detached: true }).on("error", () => void 0).unref();
-  } catch {
+function diffOf(m, from = m.baseTree) {
+  const where = m.mode === "isolate" ? m.worktree : m.repoRoot;
+  if (where && fs32.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);
   }
+  return readRunFile(m.id, "changes.patch") ?? archivedRun(m.id)?.patch ?? "";
 }
-async function dashCommand(o) {
-  const existing = await runningDash();
-  if (o.stop) {
-    if (!existing) throw new UserError("pitroom dash is not running");
-    process.kill(existing.pid, "SIGTERM");
-    fs29.rmSync(registryFile(), { force: true });
-    o.log(`stopped pitroom dash (${existing.url})`);
-    return 0;
-  }
-  if (existing && !o.serve) {
-    o.log(existing.url);
-    if (o.open) openBrowser(existing.url);
-    return 0;
+function runReview(id) {
+  const m = freshMeta(id);
+  if (isActive(m.state)) throw new UserError(`run ${m.id} is still ${m.state}; pitroom wait ${m.id} first`, 3);
+  if (m.reviewOf) throw new UserError(`run ${m.id} is itself a review`);
+  if (m.mode === "read") throw new UserError(`run ${m.id} was read-only; there is no change to review`);
+  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 && fs32.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) {
+    return {
+      ...job,
+      kind: "task",
+      package: [`# Review package \xB7 ${title}
+`, section("BRIEF", briefOf(m)), section("REPORT", readSummary(m)), section("DIFF", diffOf(m))].join("\n")
+    };
   }
-  if (o.detach) {
-    const child = spawn4(process.execPath, [process.argv[1], "dash", "--serve", ...o.port !== void 0 ? ["--port", String(o.port)] : [], "--idle", "1h"], {
-      detached: true,
-      stdio: "ignore",
-      env: process.env
-    });
-    child.on("error", () => void 0);
-    child.unref();
-    for (let i = 0; i < 60; i++) {
-      await new Promise((r2) => setTimeout(r2, 100));
-      const r = await runningDash();
-      if (r && r.pid === child.pid) {
-        o.log(r.url);
-        if (o.open) openBrowser(r.url);
-        return 0;
-      }
+  const reviewed = chain.find((a) => a.id === previous.reviewOf);
+  const from = m.mode === "isolate" ? reviewed.afterTree : m.baseTree;
+  return {
+    ...job,
+    kind: "fix",
+    package: [
+      `# Re-review package \xB7 ${title} \xB7 fix round after review ${previous.id}
+`,
+      section("BRIEF", briefOf(m)),
+      section("PREVIOUS FINDINGS", readSummary(previous)),
+      section("FIX REPORT", readSummary(m)),
+      section("FIX DIFF", diffOf(m, from))
+    ].join("\n")
+  };
+}
+function rangeReview(range, dir, planFile) {
+  const root = repoRoot(dir);
+  if (!root) throw new UserError("--range needs a git repository");
+  const i = range.indexOf("..");
+  const a = i > 0 ? range.slice(0, i) : "";
+  const b = i > 0 ? range.slice(i + 2) || "HEAD" : "";
+  if (!a || b.startsWith(".")) throw new UserError(`--range takes A..B (e.g. main..HEAD), not "${range}"`);
+  for (const ref of [a, b]) if (!commitOf(root, ref)) throw new UserError(`not a commit: ${ref}`);
+  const plan = planFile ? loadPlan(planFile) : void 0;
+  const notes = plan ? readNotes(plan) : [];
+  const requirements = plan ? [
+    `Plan: ${plan.file}`,
+    "### Global Constraints",
+    plan.constraints || "(none stated in the plan)",
+    "### Tasks",
+    plan.tasks.map((t) => `- Task ${t.step}: ${t.title}`).join("\n")
+  ].join("\n\n") : "(none given; judge the change on its own terms)";
+  return {
+    kind: "range",
+    of: `${a}..${b}`,
+    dir: root,
+    group: plan ? planName(plan.file) : void 0,
+    package: [
+      `# Review package \xB7 ${a}..${b}
+`,
+      section("WHAT WAS IMPLEMENTED", plan ? `${plan.title}
+
+${plan.header}` : "The commits below."),
+      section("REQUIREMENTS", requirements),
+      ...notes.length ? [section("NOTES FROM EXECUTION", notes.map((n) => `- ${n.text}`).join("\n"))] : [],
+      rangeDiff(root, a, b)
+    ].join("\n")
+  };
+}
+function pickReviewer(job) {
+  const eff = effective();
+  const tiers = eff.tiers.value;
+  if (job.kind === "range") return tiers.capable;
+  if (tiers.review) return tiers.review;
+  const implementer = job.implementer;
+  if (!implementer) return void 0;
+  const def = parseTarget(eff.worker.value, DEFAULT_BACKEND).backend;
+  const candidates = [tiers.standard, tiers.capable, ...eff.fallback.value, eff.worker.value].filter((s) => !!s);
+  return candidates.find((c) => parseTarget(c, def).backend !== implementer.backend);
+}
+function writePackage(job) {
+  const g = gitDir(job.dir);
+  const root = repoRoot(job.dir);
+  if (!g || !root) throw new UserError(`not a git repository: ${job.dir}`);
+  const name = `review-${crypto10.randomBytes(4).toString("hex")}.md`;
+  const inside2 = !path28.relative(fs32.realpathSync(root), fs32.realpathSync(g)).startsWith("..");
+  const file2 = inside2 ? path28.join(g, "pitroom", name) : path28.join(root, ".pitroom", name);
+  if (!inside2) ignoreInGit(root, "/.pitroom/");
+  fs32.mkdirSync(path28.dirname(file2), { recursive: true });
+  fs32.writeFileSync(file2, job.package);
+  return file2;
+}
+function ignoreInGit(root, pattern) {
+  const exclude = path28.resolve(root, git(root, ["rev-parse", "--git-path", "info/exclude"]).stdout.trim());
+  const text = fs32.existsSync(exclude) ? fs32.readFileSync(exclude, "utf8") : "";
+  if (text.split(/\r?\n/).includes(pattern)) return;
+  fs32.mkdirSync(path28.dirname(exclude), { recursive: true });
+  fs32.appendFileSync(exclude, `${text && !text.endsWith("\n") ? "\n" : ""}# Pitroom review packages in worktrees (removed after each review)
+${pattern}
+`);
+}
+
+// src/core/models.ts
+var base = (model) => (model ?? "").split("#")[0];
+function usage() {
+  const eff = effective();
+  const out = /* @__PURE__ */ new Map();
+  const add = (spec, label) => {
+    let t;
+    try {
+      t = parseTarget(spec, "opencode");
+    } catch {
+      return;
     }
-    throw new UserError("pitroom dash did not start (is the port taken? try --port 0)");
+    const model = base(t.model) || base(eff.models.value[t.backend]);
+    if (!model) return;
+    const key = `${t.backend}:${model}`;
+    out.set(key, [...out.get(key) ?? [], label]);
+  };
+  add(eff.worker.value, "default worker");
+  for (const [name, spec] of Object.entries(eff.tiers.value)) add(spec, `tier ${name}`);
+  eff.fallback.value.forEach((spec) => add(spec, "fallback"));
+  for (const [backend, model] of Object.entries(eff.models.value)) add(`${backend}:${model}`, "models");
+  return out;
+}
+function modelTable(opts = {}) {
+  const costs = effective().costs.value;
+  const used = usage();
+  const seen = /* @__PURE__ */ new Map();
+  for (const e of readLedger()) {
+    if (!e.backend || !e.model) continue;
+    const key = `${e.backend}:${base(e.model)}`;
+    const a = seen.get(key) ?? { runs: 0, tokens: 0, usd: 0 };
+    seen.set(key, { runs: a.runs + 1, tokens: a.tokens + e.tokens, usd: a.usd + e.workerCost });
   }
-  importRuns();
-  const explicit = o.port !== void 0;
-  let dash;
-  try {
-    dash = await startDash({ port: o.port ?? DEFAULT_PORT, idleMs: o.idleMs });
-  } catch (e) {
-    if (explicit || e.code !== "EADDRINUSE") throw new UserError(`pitroom dash: ${e.message}`);
-    dash = await startDash({ port: 0, idleMs: o.idleMs });
+  const rows = [];
+  const sources = [];
+  let hiddenOpenCode = 0;
+  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 key = `${b.id}:${m.id}`;
+      known.add(key);
+      const s = seen.get(key);
+      const row = {
+        worker: b.id,
+        model: m.id,
+        efforts: m.efforts?.length ? m.efforts : void 0,
+        defaultEffort: m.defaultEffort,
+        cost: costs[key],
+        runs: s?.runs ?? 0,
+        avgTokens: s ? Math.round(s.tokens / s.runs) : void 0,
+        reportedUsdPerRun: s && s.usd > 0 ? s.usd / s.runs : void 0,
+        inUse: used.get(key) ?? []
+      };
+      const relevant = row.inUse.length || row.runs || row.cost !== void 0;
+      if (b.id === "opencode" && !opts.all && !relevant) hiddenOpenCode++;
+      else rows.push(row);
+    }
   }
-  fs29.mkdirSync(home(), { recursive: true });
-  fs29.writeFileSync(registryFile(), JSON.stringify({ pid: process.pid, port: dash.port }));
-  const stop = () => void dash.close();
-  process.once("SIGINT", stop);
-  process.once("SIGTERM", stop);
-  if (!o.serve) o.log(`${dash.url}
-(read-only, this machine only; Ctrl-C stops it)`);
-  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 });
-  } catch {
+  for (const [key, labels] of used) {
+    const [worker, ...rest] = key.split(":");
+    if (known.has(key) || opts.backend && worker !== opts.backend) continue;
+    const s = seen.get(key);
+    rows.push({ worker, model: rest.join(":"), cost: costs[key], runs: s?.runs ?? 0, avgTokens: s ? Math.round(s.tokens / s.runs) : void 0, inUse: labels });
   }
-  return 0;
+  rows.sort(
+    (a, b) => a.worker.localeCompare(b.worker) || Number(b.inUse.length > 0) - Number(a.inUse.length > 0) || (a.cost ?? Infinity) - (b.cost ?? Infinity) || b.runs - a.runs || a.model.localeCompare(b.model)
+  );
+  return { rows, sources, hiddenOpenCode };
+}
+var compact2 = (n) => n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1e3 ? `${Math.round(n / 1e3)}k` : String(n);
+function formatModels(t) {
+  const efforts = (r) => r.efforts ? r.efforts.map((e) => e === r.defaultEffort ? `${e}*` : e).join("/") : "-";
+  const cells = t.rows.map((r) => [
+    r.worker,
+    r.model,
+    efforts(r),
+    r.cost !== void 0 ? String(r.cost) : "?",
+    r.runs ? String(r.runs) : "-",
+    r.avgTokens !== void 0 ? compact2(r.avgTokens) : "-",
+    r.reportedUsdPerRun !== void 0 ? `$${r.reportedUsdPerRun.toFixed(3)}` : "-",
+    r.inUse.join(", ") || "-"
+  ]);
+  const head = ["worker", "model", "effort (* default)", "cost", "runs", "avg tokens", "$/run", "in use"];
+  const widths = head.map((h, i) => Math.max(h.length, ...cells.map((c) => c[i].length)));
+  const line = (c) => c.map((x, i) => x.padEnd(widths[i])).join("  ").trimEnd();
+  const out = [line(head), ...cells.map(line), ""];
+  out.push('cost: your relative cost from the config ("costs": {"codex:gpt-6-sol": 1, \u2026}); ? = not set. Pitroom cannot know vendor prices.');
+  out.push("runs, avg tokens, $/run: from your own runs (only Claude Code and OpenCode report dollars). Choose one with -W worker:model --effort LEVEL.");
+  if (t.hiddenOpenCode) out.push(`${t.hiddenOpenCode} more OpenCode models not shown (use --all).`);
+  out.push(...t.sources.map((s) => `source ${s}`));
+  return out.join("\n");
 }
 
 // src/cli/commands.ts
@@ -5568,7 +6313,15 @@ warning: ${w}`).join("")
 async function cmdRun(p) {
   const opts = { ...runOptions(p, readTask(p)), plan: planStep(p) };
   if (!opts.task.trim() && !opts.plan) throw new UserError('no task given (pitroom "find where X is handled")');
-  return launch(p, prepareRun(opts));
+  const cache = cacheKey(opts);
+  const hit = cache && !has(p, "fresh") ? findCached(cache) : void 0;
+  if (hit) {
+    console.log(has(p, "json") ? JSON.stringify({ ...hit, cached: true }, null, 2) : `${cachedNote(hit)}
+
+${formatReport(hit)}`);
+    return exitCodeFor(hit);
+  }
+  return launch(p, prepareRun({ ...opts, cache }));
 }
 async function cmdReview(p) {
   const range = flag(p, "range");
@@ -5596,10 +6349,10 @@ async function cmdReview(p) {
       writeMeta(meta);
     }
   } catch (e) {
-    fs30.rmSync(packageFile, { force: true });
+    fs33.rmSync(packageFile, { force: true });
     throw e;
   }
-  fs30.writeFileSync(runFile(meta.id, "package.md"), job.package);
+  fs33.writeFileSync(runFile(meta.id, "package.md"), job.package);
   return launch(p, meta);
 }
 async function cmdAudit(p) {
@@ -5667,7 +6420,7 @@ function cmdPlan(p) {
 }
 function cmdCrew(p) {
   const file2 = flag(p, "task-file");
-  const tasks = (file2 ? fs30.readFileSync(file2, "utf8").split(/^\s*---\s*$/m) : p.positional).map((t) => t.trim()).filter(Boolean);
+  const tasks = (file2 ? fs33.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)");
@@ -5770,9 +6523,9 @@ function cmdHistory(p) {
     return 0;
   }
   importRuns();
-  const since = sinceMs(flag(p, "since"));
+  const since2 = sinceMs(flag(p, "since"));
   if (sub === "stats") {
-    const s = historyStats(since);
+    const s = historyStats(since2);
     if (has(p, "json")) return console.log(JSON.stringify(s, null, 2)), 0;
     const t = s.totals;
     console.log(`${t.runs} runs \xB7 ${t.ok} ok \xB7 ${t.failed} not ok \xB7 ${secs(t.seconds)} of worker time \xB7 ${(t.tokens / 1e6).toFixed(1)}M tokens \xB7 ~${usd(t.saved)} saved`);
@@ -5785,10 +6538,10 @@ ${[fmt2(head2), ...rows2.map(fmt2)].join("\n")}`);
     return 0;
   }
   const limit = flag(p, "limit") ? Number(flag(p, "limit")) : 20;
-  const { rows, total } = listHistory({ text: p.positional.join(" "), model: flag(p, "model"), state: flag(p, "state"), group: flag(p, "group"), sinceMs: since, limit });
+  const { rows, total } = listHistory({ text: p.positional.join(" "), model: flag(p, "model"), state: flag(p, "state"), group: flag(p, "group"), sinceMs: since2, limit });
   if (has(p, "json")) return console.log(JSON.stringify({ total, rows }, null, 2)), 0;
   if (!rows.length) return console.log(total ? "nothing on this page" : "no matching runs"), 0;
-  const body = rows.map((r) => [r.id, when(r.startedAt), r.state, `${r.backend}${r.model ? ` (${r.model.split("/").pop()})` : ""}`, secs(r.seconds), r.task.length > 60 ? `${r.task.slice(0, 59)}\u2026` : r.task]);
+  const body = rows.map((r) => [r.id, when(r.startedAt), r.verifyFailed ? "verify failed" : r.state, `${r.backend}${r.model ? ` (${r.model.split("/").pop()})` : ""}`, secs(r.seconds), r.task.length > 60 ? `${r.task.slice(0, 59)}\u2026` : r.task]);
   const head = ["RUN", "WHEN", "STATE", "WORKER", "TIME", "TASK"];
   const widths = head.map((h, i) => Math.max(h.length, ...body.map((r) => r[i].length)));
   const fmt = (r, header = false) => r.map((c, i) => {
@@ -5870,7 +6623,7 @@ 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 ? "" : fs30.readFileSync(0, "utf8");
+var readStdin = () => process.stdin.isTTY ? "" : fs33.readFileSync(0, "utf8");
 function cmdStatusline(p) {
   const input = readStdin();
   const lines = [];
@@ -5910,8 +6663,8 @@ function cmdModels(p) {
   return 0;
 }
 function cmdHookStart() {
-  const script = path26.join(path26.dirname(path26.dirname(fileURLToPath4(import.meta.url))), "hooks", "session-start.mjs");
-  if (fs30.existsSync(script)) spawnSync8(process.execPath, [script], { stdio: ["ignore", "inherit", "ignore"], env: process.env });
+  const script = path29.join(path29.dirname(path29.dirname(fileURLToPath4(import.meta.url))), "hooks", "session-start.mjs");
+  if (fs33.existsSync(script)) spawnSync8(process.execPath, [script], { stdio: ["ignore", "inherit", "ignore"], env: process.env });
   return 0;
 }
 function cmdInit(p) {
@@ -5922,11 +6675,11 @@ function cmdInit(p) {
   return 0;
 }
 function cmdSavings(p) {
-  const since = flag(p, "since") ?? "all";
-  const t = totals(readLedger(sinceMs(since)));
+  const since2 = flag(p, "since") ?? "all";
+  const t = totals(readLedger(sinceMs(since2)));
   if (has(p, "models")) {
     const by = /* @__PURE__ */ new Map();
-    for (const e of readLedger(sinceMs(since))) {
+    for (const e of readLedger(sinceMs(since2))) {
       const key = `${e.backend ?? "?"}  ${e.model ?? "(default model)"}`;
       const a = by.get(key) ?? { runs: 0, tokens: 0, returned: 0, cost: 0, saved: 0 };
       by.set(key, { runs: a.runs + 1, tokens: a.tokens + e.tokens, returned: a.returned + e.returned, cost: a.cost + e.workerCost, saved: a.saved + e.saved });
@@ -5938,7 +6691,7 @@ function cmdSavings(p) {
     }
     return 0;
   }
-  const period = since === "all" ? "all time" : `last ${since.replace("d", " days")}`;
+  const period = since2 === "all" ? "all time" : `last ${since2.replace("d", " days")}`;
   if (has(p, "json")) {
     console.log(JSON.stringify({ period, ...t, price: primaryPrice() }, null, 2));
     return 0;
@@ -5951,8 +6704,8 @@ function cmdSavings(p) {
   est. saved          ${usd(t.saved)}  (vs ${primaryPrice().name} list prices)`);
   const out = flag(p, "card");
   if (out) {
-    fs30.writeFileSync(out, card(t, period));
-    console.log(`card written to ${path26.resolve(out)}`);
+    fs33.writeFileSync(out, card(t, period));
+    console.log(`card written to ${path29.resolve(out)}`);
   }
   if (has(p, "badge")) console.log(`![pitroom](${badgeUrl(t)})`);
   return 0;
@@ -5994,7 +6747,7 @@ function cmdConfig(p) {
     console.log(JSON.stringify({ path: configPath(), settings: eff, warnings }, null, 2));
     return 0;
   }
-  console.log(`config file: ${configPath()}${fs30.existsSync(configPath()) ? "" : " (not present)"}`);
+  console.log(`config file: ${configPath()}${fs33.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})`);
@@ -6003,22 +6756,22 @@ function cmdConfig(p) {
   return 0;
 }
 function cmdClean(p) {
-  const days = Number(flag(p, "days") ?? 14);
-  const cutoff = Date.now() - days * 864e5;
+  const days2 = Number(flag(p, "days") ?? 14);
+  const cutoff = Date.now() - days2 * 864e5;
   const old = listRunIds().filter((id) => {
     const m = freshMeta(id);
     const pendingPatch = m.mode === "isolate" && !m.applied && !m.discarded && m.changes?.length;
     return TERMINAL.includes(m.state) && Date.parse(m.startedAt) < cutoff && !pendingPatch;
   });
   if (!has(p, "yes")) {
-    console.log(`${old.length} run(s) older than ${days} days would be removed (unapplied isolate patches are kept). Re-run with --yes.`);
+    console.log(`${old.length} run(s) older than ${days2} days would be removed (unapplied isolate patches are kept). Re-run with --yes.`);
     return 0;
   }
   for (const id of old) {
     const m = readMeta(id);
     if (m.mode === "isolate" && !m.discarded && !m.applied) discardRun(m);
     recordRun(m);
-    fs30.rmSync(runDir(id), { recursive: true, force: true });
+    fs33.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`);
@@ -6029,9 +6782,9 @@ var cmdDiscard = (p) => (console.log(discardRun(freshMeta(resolveRun(p.positiona
 
 // src/core/doctor.ts
 import { spawnSync as spawnSync9 } from "node:child_process";
-import fs31 from "node:fs";
+import fs34 from "node:fs";
 import os11 from "node:os";
-import path27 from "node:path";
+import path30 from "node:path";
 var MARK = { 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)" },
@@ -6041,10 +6794,10 @@ var NEXT = [
   { when: /Gemini CLI is not signed in|IneligibleTierError/, command: "export GEMINI_API_KEY=\u2026", why: "a Google AI Studio key for the Gemini worker" }
 ];
 function firstNodeOnPath() {
-  for (const dir of (process.env.PATH ?? "").split(path27.delimiter).filter(Boolean)) {
-    const file2 = path27.join(dir, process.platform === "win32" ? "node.exe" : "node");
+  for (const dir of (process.env.PATH ?? "").split(path30.delimiter).filter(Boolean)) {
+    const file2 = path30.join(dir, process.platform === "win32" ? "node.exe" : "node");
     try {
-      if (!fs31.statSync(file2).isFile()) continue;
+      if (!fs34.statSync(file2).isFile()) continue;
     } catch {
       continue;
     }
@@ -6071,12 +6824,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) && path27.resolve(onPath.path) !== path27.resolve(process.execPath)) {
+  if (onPath && onPath.version && tooOld(onPath.version) && path30.resolve(onPath.path) !== path30.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()}${fs31.existsSync(configPath()) ? "" : " (not present, defaults in use)"}`);
+  add(cfg.warnings.length ? "warn" : "ok", `config: ${configPath()}${fs34.existsSync(configPath()) ? "" : " (not present, defaults in use)"}`);
   for (const w of cfg.warnings) add("warn", w);
   if (process.platform !== "win32") {
     const guarded = guardEnv(process.env).PATH?.startsWith(shimDir());
@@ -6229,19 +6982,19 @@ 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(`${path27.sep}.agents${path27.sep}`) && i.names.length);
+    const linked = installedSkills().some((i) => i.base.includes(`${path30.sep}.agents${path30.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(`${path27.sep}.claude${path27.sep}`) && i.names.length);
+    const linked = installedSkills().some((i) => i.base.includes(`${path30.sep}.claude${path30.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 (fs31.existsSync(launcher)) {
+  if (fs34.existsSync(launcher)) {
     const r = spawnSync9(launcher, ["--version"], { encoding: "utf8", timeout: 3e4, stdio: ["ignore", "pipe", "pipe"] });
     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)}` }
@@ -6253,12 +7006,12 @@ function skillChecks() {
 }
 function geminiExtensionInstalled() {
   const home3 = process.env.GEMINI_CLI_HOME ?? os11.homedir();
-  return fs31.existsSync(path27.join(home3, ".gemini", "extensions", "pitroom"));
+  return fs34.existsSync(path30.join(home3, ".gemini", "extensions", "pitroom"));
 }
 function pluginInstalled() {
   try {
-    const f = path27.join(os11.homedir(), ".claude", "plugins", "installed_plugins.json");
-    const plugins = JSON.parse(fs31.readFileSync(f, "utf8")).plugins ?? {};
+    const f = path30.join(os11.homedir(), ".claude", "plugins", "installed_plugins.json");
+    const plugins = JSON.parse(fs34.readFileSync(f, "utf8")).plugins ?? {};
     return Object.keys(plugins).some((k) => k.startsWith("pitroom@"));
   } catch {
     return false;
@@ -6275,24 +7028,24 @@ function superpowersActive() {
   for (const p of openCodePlugins()) {
     if (/superpowers/i.test(p)) found.push(`OpenCode plugin ${p}`);
   }
-  for (const base2 of [path27.join(os11.homedir(), ".agents", "skills"), path27.join(os11.homedir(), ".claude", "skills")]) {
-    const dir = path27.join(base2, "using-superpowers");
-    if (fs31.existsSync(path27.join(dir, "SKILL.md"))) found.push(dir);
+  for (const base2 of [path30.join(os11.homedir(), ".agents", "skills"), path30.join(os11.homedir(), ".claude", "skills")]) {
+    const dir = path30.join(base2, "using-superpowers");
+    if (fs34.existsSync(path30.join(dir, "SKILL.md"))) found.push(dir);
   }
   return found;
 }
 function claudePlugins() {
   try {
-    const f = path27.join(os11.homedir(), ".claude", "plugins", "installed_plugins.json");
-    return Object.keys(JSON.parse(fs31.readFileSync(f, "utf8")).plugins ?? {});
+    const f = path30.join(os11.homedir(), ".claude", "plugins", "installed_plugins.json");
+    return Object.keys(JSON.parse(fs34.readFileSync(f, "utf8")).plugins ?? {});
   } catch {
     return [];
   }
 }
 function claudePluginEnabled(key) {
   try {
-    const f = path27.join(os11.homedir(), ".claude", "settings.json");
-    return JSON.parse(fs31.readFileSync(f, "utf8")).enabledPlugins?.[key] !== false;
+    const f = path30.join(os11.homedir(), ".claude", "settings.json");
+    return JSON.parse(fs34.readFileSync(f, "utf8")).enabledPlugins?.[key] !== false;
   } catch {
     return true;
   }
@@ -6301,7 +7054,7 @@ function codexPlugins() {
   const plugins = /* @__PURE__ */ new Map();
   let text;
   try {
-    text = fs31.readFileSync(path27.join(process.env.CODEX_HOME ?? path27.join(os11.homedir(), ".codex"), "config.toml"), "utf8");
+    text = fs34.readFileSync(path30.join(process.env.CODEX_HOME ?? path30.join(os11.homedir(), ".codex"), "config.toml"), "utf8");
   } catch {
     return plugins;
   }
@@ -6319,11 +7072,11 @@ function codexPlugins() {
   return plugins;
 }
 function openCodePlugins() {
-  const dir = path27.join(process.env.XDG_CONFIG_HOME ?? path27.join(os11.homedir(), ".config"), "opencode");
+  const dir = path30.join(process.env.XDG_CONFIG_HOME ?? path30.join(os11.homedir(), ".config"), "opencode");
   const plugins = [];
   for (const name of ["opencode.json", "opencode.jsonc"]) {
     try {
-      const text = fs31.readFileSync(path27.join(dir, name), "utf8").replace(/\/\*[\s\S]*?\*\/|^\s*\/\/.*$/gm, "");
+      const text = fs34.readFileSync(path30.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 {
@@ -6331,7 +7084,7 @@ function openCodePlugins() {
   }
   for (const folder of ["plugin", "plugins"]) {
     try {
-      for (const f of fs31.readdirSync(path27.join(dir, folder))) plugins.push(path27.join(dir, folder, f));
+      for (const f of fs34.readdirSync(path30.join(dir, folder))) plugins.push(path30.join(dir, folder, f));
     } catch {
     }
   }
@@ -6383,7 +7136,9 @@ Usage
   pitroom hook-start                    SessionStart hook: introduces Pitroom to the agent (Codex; Claude Code uses its plugin)
   pitroom cooldown [--clear]            models that said "rate limited" and are skipped for a while (a quota used up);
                                         --clear tries them again
-  pitroom mcp                           serve Pitroom as MCP tools on stdio (Cursor, Claude Desktop, Gemini CLI, \u2026)
+  pitroom mcp [-d DIR] [--http [--port N]]
+                                        serve Pitroom as MCP tools on stdio (Cursor, Claude Desktop, Gemini CLI, \u2026),
+                                        or with --http at http://127.0.0.1:7117/mcp (bearer token, local only)
   pitroom doctor [--probe]              check workers, models, permissions, skills
   pitroom config                        effective settings, where each comes from, config file path
   pitroom init [--model ID] [--fallback A,B] [--yes] [--force]
@@ -6409,6 +7164,7 @@ Run options
       --in-place        a read run reads the directory itself, not a clean snapshot (default: a snapshot without secret-looking
                         files when the directory has any; config "readIn": auto | snapshot | project)
       --audit           have another worker re-check this read run's answer; --no-audit skips it (default: the config's "audit")
+      --fresh           ask a worker even when the same read question was answered on the same code (config "cacheDays", default 7)
       --effort LEVEL    reasoning effort for the worker: low, medium, high, xhigh, \u2026 (model#level)
       --plan PLAN       with --step N: implement Task N of a plan (-i or -w); the task text is your notes
       --step N          the plan task for --plan
@@ -6430,16 +7186,27 @@ Exit codes: 0 ok \xB7 1 worker failed \xB7 2 usage \xB7 3 refused/setup \xB7 4 t
             5 read-only violation \xB7 6 verify failed \xB7 75 still running (wait again)
 Workers: ${backendIds().join(", ")} (targets: "opencode", "opencode:provider/model", or a bare model)
 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_PRIMARY=sonnet|opus|haiku|gpt-5, PITROOM_PRICE="in,out", PITROOM_HOME, PITROOM_CONFIG, PITROOM_CACHE_DAYS,
      PITROOM_<WORKER>_BIN
-Config: ~/.config/pitroom/config.json (worker, fallback, models, tiers, timeout, primary, price, link, web, maxParallel)`;
+Config: ~/.config/pitroom/config.json (worker, fallback, models, tiers, timeout, primary, price, link, web, maxParallel, audit, readIn, cacheDays)`;
 var COMMANDS = {
   run: cmdRun,
   crew: cmdCrew,
   review: cmdReview,
   audit: cmdAudit,
   cooldown: cmdCooldown,
-  mcp: () => serveMcp(),
+  mcp: (p) => {
+    const port = flag(p, "port");
+    if (port !== void 0 && !has(p, "http")) throw new UserError("--port goes with --http (on stdio there is no port)");
+    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 (!fs35.statSync(dir, { throwIfNoEntry: false })?.isDirectory()) throw new UserError(`-d ${dir}: no such directory`);
+      process.chdir(dir);
+      process.env.PWD = process.cwd();
+    }
+    return has(p, "http") ? serveMcpHttp({ port: port === void 0 ? DEFAULT_PORT2 : Number(port) }) : serveMcp();
+  },
   plan: cmdPlan,
   status: cmdStatus,
   wait: cmdWait,