pitroom 0.15.0 → 0.16.0

package/dist/pitroom.mjs

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
 
+// src/cli.ts
+import fs33 from "node:fs";
+
 // src/core/errors.ts
 var UserError = class extends Error {
   constructor(message, code = 2) {
@@ -1578,6 +1581,7 @@ var BOOL_FLAGS = {
   "--stop": "stop",
   "--open": "open",
   "--serve": "serve",
+  "--http": "http",
   "-h": "help",
   "--help": "help",
   "-v": "version",
@@ -1680,7 +1684,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
@@ -3129,12 +3132,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 {
     }
   }
@@ -3408,17 +3411,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 +3459,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);
@@ -3631,7 +3634,7 @@ function progress(meta) {
 }
 
 // src/core/run.ts
-var VERSION2 = true ? "0.15.0" : "0.0.0-dev";
+var VERSION2 = true ? "0.16.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");
@@ -4059,17 +4062,124 @@ 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-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 +4215,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 +4238,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 +4247,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 timer = 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);
+      signal?.removeEventListener("abort", stop);
       resolve2({ code, out: strip(out).trim(), err: strip(err).trim() });
     });
   });
@@ -4146,7 +4266,42 @@ function asResult(r, still) {
 ${still}`) };
   return { text: clip6(text), isError: r.code === 2 || r.code === 3 || 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 tick = () => {
+    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(tick, 800);
+  const timer = setInterval(tick, PROGRESS_EVERY_MS);
+  return () => {
+    clearTimeout(first);
+    clearInterval(timer);
+  };
+}
+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;
@@ -4155,14 +4310,117 @@ async function startAndWait(start, seconds, task) {
   } 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)) await stopQuietly(["stop", id]);
+  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.`);
+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;
+}
+
+// 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 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 with pitroom_crew (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 listPrompts = () => ({ prompts: PROMPTS.map(({ name, title, description, arguments: args }) => ({ name, title, description, arguments: args })) });
+function getPrompt(name, given) {
+  const p = PROMPTS.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." },
@@ -4177,16 +4435,19 @@ var WORKER_PROPS = {
 };
 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 SINCE = { type: "string", description: "A window: 7d, 30d, \u2026 or all." };
+var READ_ONLY = { readOnlyHint: true, openWorldHint: false };
 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) 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 pitroom_revert. Returns the worker's answer and a receipt, or "still running" with the run id. Progress is reported while it waits; 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." },
+        continue: { type: "string", description: "A finished run to follow up in the same worker session (the task is then the follow-up)." },
         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." },
         ...WORKER_PROPS,
@@ -4195,15 +4456,40 @@ var TOOLS2 = [
       required: ["task"]
     },
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
-    async call(a) {
+    async call(a, ctx) {
       const task = str(a, "task", true);
       const mode = oneOf(a, "mode", ["read", "isolate", "write"], "read");
       const flags = mode === "isolate" ? ["-i"] : mode === "write" ? ["-w"] : [];
+      const follow = str(a, "continue");
+      if (follow) flags.push("--continue", follow);
       if (mode === "read") {
         if (bool(a, "inPlace")) flags.push("--in-place");
         if (bool(a, "audit")) flags.push("--audit");
       }
-      return startAndWait(["run", ...flags, ...workerFlags(a)], waitSeconds(a), task);
+      return startAndWait(["run", ...flags, ...workerFlags(a)], waitSeconds(a), ctx, task);
+    }
+  },
+  {
+    name: "pitroom_crew",
+    title: "Run workers in parallel",
+    description: 'Start several independent tasks at once as one group of workers (read, or isolate: each edits its own copy) and wait for the group. Returns every report, or "still running" with the group name for pitroom_wait. Only for tasks that do not depend on each other. Cancelling the call stops the group.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        tasks: { type: "array", items: { type: "string" }, minItems: 1, maxItems: MAX_TASKS, description: "One self-contained task per worker." },
+        mode: { type: "string", enum: ["read", "isolate"], description: "read (default) or isolate." },
+        ...WORKER_PROPS,
+        ...WAIT_PROP
+      },
+      required: ["tasks"]
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    async call(a, ctx) {
+      const tasks = strs(a, "tasks").filter((t) => t.trim());
+      if (!tasks.length) throw new ToolError('"tasks" needs at least one task');
+      if (tasks.length > MAX_TASKS) throw new ToolError(`at most ${MAX_TASKS} tasks at once: start the rest when these are done`);
+      const mode = oneOf(a, "mode", ["read", "isolate"], "read");
+      return startCrew([...mode === "isolate" ? ["-i"] : [], ...workerFlags(a)], tasks, waitSeconds(a), ctx);
     }
   },
   {
@@ -4214,12 +4500,12 @@ var TOOLS2 = [
       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) {
+    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);
     }
   },
   {
@@ -4227,11 +4513,23 @@ var TOOLS2 = [
     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) {
+    annotations: READ_ONLY,
+    async call(a, ctx) {
       const group = str(a, "group");
       const run2 = str(a, "run");
-      return asResult(await pit(["status", ...group ? ["-g", group] : run2 ? [run2] : []], 6e4));
+      if (group && run2) throw new ToolError('give "run" or "group", not both');
+      return plain(["status", ...group ? ["-g", group] : run2 ? [run2] : []], ctx);
+    }
+  },
+  {
+    name: "pitroom_list",
+    title: "List runs",
+    description: "The latest runs with their state, worker and task; with running only the active ones, or one group's.",
+    inputSchema: { type: "object", properties: { running: { type: "boolean", description: "Only runs that are queued or running." }, group: { type: "string", description: "A group name." } } },
+    annotations: READ_ONLY,
+    async call(a, ctx) {
+      const group = str(a, "group");
+      return plain(["ls", ...bool(a, "running") ? ["--running"] : [], ...group ? ["-g", group] : []], ctx);
     }
   },
   {
@@ -4239,10 +4537,85 @@ var TOOLS2 = [
     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) {
+    annotations: READ_ONLY,
+    async call(a, ctx) {
       const run2 = str(a, "run", true);
-      return asResult(await pit(["show", run2, ...bool(a, "patch") ? ["--patch"] : bool(a, "full") ? ["--full"] : []], 6e4));
+      return plain(["show", run2, ...bool(a, "patch") ? ["--patch"] : bool(a, "full") ? ["--full"] : []], ctx);
+    }
+  },
+  {
+    name: "pitroom_history",
+    title: "Search past runs",
+    description: "Finished runs from the history, searchable: full-text over the task, the answer and the steps. Use it to find an earlier answer before asking a worker again.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "Words to search for." },
+        state: { type: "string", description: "done, problem, failed, \u2026" },
+        model: { type: "string", description: "Only runs of this model." },
+        since: SINCE,
+        limit: { type: "number", description: "How many runs (default 20)." }
+      }
+    },
+    annotations: READ_ONLY,
+    async call(a, ctx) {
+      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 plain(["history", ...since(a), ...state ? ["--state", state] : [], ...model ? ["--model", model] : [], ...limit ? ["--limit", String(limit)] : [], ...text ? ["--", text] : []], ctx);
+    }
+  },
+  {
+    name: "pitroom_stats",
+    title: "Worker statistics",
+    description: "Runs, success rate, average time and tokens per worker and model, and how often their answers were confirmed by audits. Use it to pick a worker.",
+    inputSchema: { type: "object", properties: { since: SINCE } },
+    annotations: READ_ONLY,
+    async call(a, ctx) {
+      return plain(["history", "stats", ...since(a)], ctx);
+    }
+  },
+  {
+    name: "pitroom_savings",
+    title: "What the workers saved",
+    description: "The tokens and money workers took over from you, per model, from the receipts of the runs.",
+    inputSchema: { type: "object", properties: { since: SINCE, models: { type: "boolean", description: "Break it down per model." } } },
+    annotations: READ_ONLY,
+    async call(a, ctx) {
+      return plain(["savings", ...since(a), ...bool(a, "models") ? ["--models"] : []], ctx);
+    }
+  },
+  {
+    name: "pitroom_models",
+    title: "Worker models",
+    description: "The models a worker backend offers, with effort levels, the costs set in the config and recent usage. Use it to choose a model for pitroom_run.",
+    inputSchema: { type: "object", properties: { worker: { type: "string", description: "A backend: opencode, codex, claude, gemini. Default: the configured one." }, all: { type: "boolean", description: "Include models that are hidden by default." } } },
+    annotations: READ_ONLY,
+    async call(a, ctx) {
+      const worker = str(a, "worker");
+      return plain(["models", ...worker ? [worker] : [], ...bool(a, "all") ? ["--all"] : []], ctx);
+    }
+  },
+  {
+    name: "pitroom_cooldown",
+    title: "Rate-limited models",
+    description: 'The models that said "rate limited" and are being skipped for now (runs go to the next worker). With clear they are tried again immediately.',
+    inputSchema: { type: "object", properties: { clear: { type: "boolean", description: "Forget the cooldowns." } } },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    async call(a, ctx) {
+      return plain(["cooldown", ...bool(a, "clear") ? ["--clear"] : []], ctx);
+    }
+  },
+  {
+    name: "pitroom_doctor",
+    title: "Check the setup",
+    description: "Checks the setup without spending tokens: the workers found and their logins, the config, the skills, where the MCP server is registered. Use it when a run fails to start.",
+    inputSchema: { type: "object", properties: {} },
+    annotations: READ_ONLY,
+    async call(_a, ctx) {
+      return plain(["doctor"], ctx, 12e4);
     }
   },
   {
@@ -4263,13 +4636,13 @@ 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);
     }
   },
   {
@@ -4278,23 +4651,24 @@ var TOOLS2 = [
     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.",
     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 on the user's working tree (checked first; refused if it no longer applies cleanly), or every patch of a group in order. A patch that deletes files is refused unless allowDelete is true: only pass it after checking the deletions are what the user 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 && !run2 ? ["-g", group] : [run2], ...bool(a, "allowDelete") ? ["--allow-delete"] : []], ctx, 12e4);
     }
   },
   {
@@ -4303,8 +4677,18 @@ var TOOLS2 = [
     description: "Drop an isolated run's private copy (its 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 what a mode "write" run changed in the working tree (checked first; refused when 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);
     }
   },
   {
@@ -4313,31 +4697,53 @@ var TOOLS2 = [
     description: "Stop a running or queued run, or every run of a group.",
     inputSchema: { type: "object", properties: { run: RUN_ID2, group: { type: "string" } } },
     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 (run2 && group) throw new ToolError('give "run" or "group", not both');
+      return plain(["stop", ...run2 ? [run2] : ["-g", group]], ctx);
     }
   }
 ];
+
+// 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_crew for independent tasks in parallel.',
+  '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 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;
-  }
-};
-async function dispatch(method, params) {
+var newSession = () => ({ inflight: /* @__PURE__ */ new Map() });
+function endSession(session) {
+  for (const { abort } of session.inflight.values()) abort.abort("closed");
+}
+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) {
   switch (method) {
     case "initialize": {
       const asked = typeof params.protocolVersion === "string" ? params.protocolVersion : "";
       return {
         protocolVersion: PROTOCOLS.includes(asked) ? asked : PROTOCOLS[0],
-        capabilities: { tools: { listChanged: false } },
+        capabilities: { tools: { listChanged: false }, resources: { listChanged: false, subscribe: false }, prompts: { listChanged: false } },
         serverInfo: { name: "pitroom", title: "Pitroom", version: VERSION2 },
         instructions: INSTRUCTIONS
       };
@@ -4351,7 +4757,7 @@ async function dispatch(method, params) {
       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 +4765,1306 @@ 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 "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);
+    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();
   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]);
+  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 fs26 from "node:fs";
+import http2 from "node:http";
+import path22 from "node:path";
 
-// src/core/init.ts
+// src/core/dash.ts
+import { spawn as spawn4 } from "node:child_process";
+import crypto6 from "node:crypto";
 import fs25 from "node:fs";
+import http from "node:http";
 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)");
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+
+// src/core/file-diff.ts
+var PREVIEW_LINES = 300;
+function gitPath(value, prefix = true) {
+  let path29 = 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]));
     }
+    path29 = 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 ? path29.replace(/^[ab]\//, "") : path29;
 }
-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) => {
+
+// 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 oneLine7 = (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 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 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");
+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 ? oneLine7(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) || oneLine7(m.error ?? "", 200)
+  };
 }
-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 };
+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 (Date.now() >= deadline) return { metas, timedOut: true };
-    await sleep2(opts.intervalMs);
-  }
-}
-
-// 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"] };
+    if (m.group) groups.add(m.group);
+    if (opts.group && m.group !== opts.group) continue;
+    if (runs.length < limit) runs.push(toRun(m));
   }
-  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");
-};
-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() };
+  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
+  };
 }
-var runnable = (backendId) => run(backendId, ["--version"]).ok;
-var readJson = (file2) => {
+var TASK_MAX = 6e3;
+var PATCH_LINES = 300;
+function runDetail(id) {
+  if (!RUN_ID3.test(id)) return void 0;
+  let m;
   try {
-    return JSON.parse(fs26.readFileSync(file2, "utf8"));
+    m = freshMeta(id);
   } 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) {
-  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` };
-    }
-  };
-}
-function jsonClient(id, name, file2, dir) {
-  const rel = () => file2().replace(home2(), "~");
+  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,
-    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() };
+    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
     },
-    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() };
-    }
+    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 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;
-  try {
-    text = fs26.readFileSync(path22.join(process.env.CODEX_HOME ?? path22.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] ?? "";
+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 {
-    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 file2 = path21.join(assetsDir(), path21.basename(route));
+    const { mtimeMs } = fs25.statSync(file2);
+    const hit = assetCache.get(route);
+    if (hit && hit.mtimeMs === mtimeMs) return hit.data;
+    const data = fs25.readFileSync(file2);
+    assetCache.set(route, { mtimeMs, data });
+    return data;
   } catch {
-    return "different";
+    return void 0;
   }
 }
-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) {
-  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;
+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 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 (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);
+    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" });
+    }
+    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 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 });
+    });
+  });
+}
+var registryFile = () => path21.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;
   }
-  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;
+async function runningDash() {
+  try {
+    const r = JSON.parse(fs25.readFileSync(registryFile(), "utf8"));
+    if (isAlive(r.pid) && await ping(r.port)) return { ...r, url: `http://127.0.0.1:${r.port}/` };
+  } catch {
+  }
+  fs25.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 {
+  }
+}
+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");
+    fs25.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;
+      }
     }
-    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 });
+    throw new UserError("pitroom dash did not start (is the port taken? try --port 0)");
   }
-  return out;
+  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 });
+  }
+  fs25.mkdirSync(home(), { recursive: true });
+  fs25.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(fs25.readFileSync(registryFile(), "utf8")).pid === process.pid) fs25.rmSync(registryFile(), { force: true });
+  } catch {
+  }
+  return 0;
 }
-function mcpStatus() {
-  const c = mcpCommand();
-  return clients().map((client) => {
+
+// 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 = () => path22.join(home(), "mcp-token");
+var readToken = (file2) => {
+  try {
+    const kept = fs26.readFileSync(file2, "utf8").trim();
+    return kept.length >= 16 ? kept : void 0;
+  } catch {
+    return void 0;
+  }
+};
+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) {
+    fs26.mkdirSync(path22.dirname(file2), { recursive: true });
+    token = crypto7.randomBytes(32).toString("hex");
     try {
-      return { id: client.id, name: client.name, state: client.state(c) };
-    } catch {
-      return { id: client.id, name: client.name, state: "absent" };
+      fs26.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);
     }
-  });
+  }
+  try {
+    fs26.chmodSync(file2, 384);
+  } catch {
+  }
+  return { token, from: file2 };
 }
-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;
+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);
 };
-
-// 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");
-}
-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 };
+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 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 planStatus(planFile) {
-  const plan = loadPlan(planFile);
-  const runs = [];
-  for (const id of listRunIds()) {
+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 || entry[1].lastSeen < oldest[1].lastSeen)) oldest = entry;
+  if (!oldest) return false;
+  sessions.delete(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") {
+      const kept2 = sid ? sessions.get(sid) : void 0;
+      if (!kept2) return reply(res, 404, failure5(-32600, "no such session"));
+      endSession(kept2.session);
+      sessions.delete(sid);
+      return reply(res, 204);
+    }
+    if (req.method !== "POST") return reply(res, 405, failure5(-32600, "POST requests only"), { Allow: "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 {
-      const m = freshMeta(id);
-      if (m.plan?.file === plan.file) runs.push(m);
+      parsed = JSON.parse(body);
     } catch {
+      return reply(res, 400, parseError());
     }
-  }
-  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
+    const headers = {};
+    let kept;
+    const single = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+    if (single?.method === "initialize") {
+      const old = sid ? sessions.get(sid) : void 0;
+      if (old) {
+        endSession(old.session);
+        sessions.delete(sid);
+      }
+      if (sessions.size >= MAX_SESSIONS && !evictIdle(sessions)) return reply(res, 503, failure5(-32e3, "too many sessions with requests in flight"));
+      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)}
+
+`);
     };
-  });
-  return { plan, tasks, rulings: notes.filter((n) => /\bRuling:/.test(n.text)), notesFile: notesFile(plan) };
+    const out = await handlePayload(kept.session, parsed, event);
+    if (out !== void 0) event(out);
+    kept.lastSeen = Date.now();
+    res.end();
+  };
 }
-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)
-    ];
+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 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");
+  const sweep = setInterval(() => {
+    for (const [id, k] of sessions) if (Date.now() - k.lastSeen > IDLE_MS && !k.session.inflight.size) sessions.delete(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 k of sessions.values()) endSession(k.session);
+  server.closeAllConnections();
+  await new Promise((resolve2) => server.close(() => resolve2()));
+  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}
+// src/cli/commands.ts
+import { spawnSync as spawnSync8 } from "node:child_process";
+import fs31 from "node:fs";
+import path27 from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 
-${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;
-}
-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()) {
+// src/core/init.ts
+import fs27 from "node:fs";
+import path23 from "node:path";
+var FREE = /-free$/;
+var TIER_ORDER = [["cheap", "opencode"], ["standard", "codex"], ["capable", "claude"]];
+var isFound = (binary5) => path23.isAbsolute(binary5) && fs27.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 {
-      const m = readMeta(id);
-      if (m.reviewOf && ids.includes(m.reviewOf) && m.state === "done") return m;
+      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)");
     }
   }
-  return void 0;
+  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: fs27.existsSync(file2), workers, opencode: opencode2, config, blocked, notes };
 }
-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);
+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 ${path23.basename(plan.path)}.bak)`);
+  fs27.mkdirSync(path23.dirname(plan.path), { recursive: true });
+  if (plan.exists) fs27.copyFileSync(plan.path, `${plan.path}.bak`);
+  fs27.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" : ""}` : ""}`);
   }
-  return readRunFile(m.id, "changes.patch") ?? archivedRun(m.id)?.patch ?? "";
+  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 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")
-    };
+
+// src/core/mcp-install.ts
+import { spawnSync as spawnSync7 } from "node:child_process";
+import fs28 from "node:fs";
+import os10 from "node:os";
+import path24 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(path24.delimiter).filter(Boolean)) {
+    const p = path24.join(dir, process.platform === "win32" ? "pitroom.cmd" : "pitroom");
+    if (fs28.existsSync(p)) return { command: path24.resolve(p), args: ["mcp"] };
   }
-  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")
-  };
+  return { command: process.execPath, args: [process.argv[1] ?? "pitroom", "mcp"] };
 }
-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)";
+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() };
+}
+var runnable = (backendId) => run(backendId, ["--version"]).ok;
+var readJson = (file2) => {
+  try {
+    return JSON.parse(fs28.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 = () => path24.join(process.env.GEMINI_CLI_HOME ?? home2(), ".gemini");
+function cliClient(id, backend, name, where, o) {
   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")
+    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` };
+    }
   };
 }
-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;
-}
-
-// 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;
+function jsonClient(id, name, file2, dir) {
+  const rel = () => file2().replace(home2(), "~");
+  return {
+    id,
+    name,
+    found: () => fs28.existsSync(dir()),
+    state: (c) => jsonState(file2(), c),
+    add: (c) => {
+      let config = {};
+      if (fs28.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 (!fs28.existsSync(backup)) fs28.copyFileSync(file2(), backup);
+      }
+      config.mcpServers = { ...config.mcpServers ?? {}, [NAME]: { command: c.command, args: c.args } };
+      fs28.mkdirSync(path24.dirname(file2()), { recursive: true });
+      const tmp = `${file2()}.${process.pid}.tmp`;
+      fs28.writeFileSync(tmp, `${JSON.stringify(config, null, 2)}
+`);
+      fs28.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];
+      fs28.writeFileSync(file2(), `${JSON.stringify(config, null, 2)}
+`);
+      return { ok: true, message: rel() };
     }
-    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 });
+function desktopFile() {
+  if (process.platform === "darwin") return path24.join(home2(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  if (process.platform === "win32") return path24.join(process.env.APPDATA ?? path24.join(home2(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+  return path24.join(process.env.XDG_CONFIG_HOME ?? path24.join(home2(), ".config"), "Claude", "claude_desktop_config.json");
+}
+function codexState(c) {
+  let text;
+  try {
+    text = fs28.readFileSync(path24.join(process.env.CODEX_HOME ?? path24.join(home2(), ".codex"), "config.toml"), "utf8");
+  } catch {
+    return "absent";
   }
-  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 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(path24.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(path24.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", () => path24.join(home2(), ".cursor", "mcp.json"), () => path24.join(home2(), ".cursor")),
+    jsonClient("claude-desktop", "Claude Desktop", desktopFile, () => path24.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;
+    }
+    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);
   }
-  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 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 });
   }
-  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 };
+  return out;
 }
-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");
+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" };
+    }
+  });
 }
+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/dash.ts
-import { spawn as spawn4 } from "node:child_process";
+// src/core/plan-status.ts
 import crypto8 from "node:crypto";
 import fs29 from "node:fs";
-import http from "node:http";
 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));
-  }
-  return prefix ? path28.replace(/^[ab]\//, "") : path28;
+function notesFile(plan) {
+  const id = crypto8.createHash("sha1").update(plan.file).digest("hex").slice(0, 12);
+  return path25.join(home(), "plans", id, "notes.md");
 }
-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));
+function readNotes(plan) {
+  const f = notesFile(plan);
+  if (!fs29.existsSync(f)) return [];
+  return fs29.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 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()];
-}
-
-// 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 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)
-  };
+function addNote(planFile, text) {
+  const plan = loadPlan(planFile);
+  const f = notesFile(plan);
+  fs29.mkdirSync(path25.dirname(f), { recursive: true });
+  if (!fs29.existsSync(f)) fs29.writeFileSync(f, `# plan: ${plan.file}
+`);
+  const at = (/* @__PURE__ */ new Date()).toISOString().slice(0, 16).replace("T", " ");
+  fs29.appendFileSync(f, `${at} ${text.replace(/\s+/g, " ").trim()}
+`);
+  return f;
 }
-function dashState(opts = {}) {
-  const limit = Math.min(Math.max(opts.limit ?? 40, 1), 200);
+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
-  };
-}
-var TASK_MAX = 6e3;
-var PATCH_LINES = 300;
-function runDetail(id) {
-  if (!RUN_ID3.test(id)) return void 0;
-  let m;
-  try {
-    m = freshMeta(id);
-  } 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)
-  };
+  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 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 cell = (s, max) => {
+  const t = s.replace(/\s+/g, " ").trim();
+  return t.length > max ? `${t.slice(0, max - 1)}\u2026` : t;
 };
-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 {
-    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;
-  } catch {
-    return void 0;
-  }
-}
-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" });
-    }
-    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 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 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");
 }
-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;
+
+// src/core/review.ts
+import crypto9 from "node:crypto";
+import fs30 from "node:fs";
+import path26 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 fs30.existsSync(f) ? fs30.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 && fs30.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 && fs30.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);
+  if (!g) throw new UserError(`not a git repository: ${job.dir}`);
+  const file2 = path26.join(g, "pitroom", `review-${crypto9.randomBytes(4).toString("hex")}.md`);
+  fs30.mkdirSync(path26.dirname(file2), { recursive: true });
+  fs30.writeFileSync(file2, job.package);
+  return file2;
+}
+
+// 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
@@ -5596,10 +6114,10 @@ async function cmdReview(p) {
       writeMeta(meta);
     }
   } catch (e) {
-    fs30.rmSync(packageFile, { force: true });
+    fs31.rmSync(packageFile, { force: true });
     throw e;
   }
-  fs30.writeFileSync(runFile(meta.id, "package.md"), job.package);
+  fs31.writeFileSync(runFile(meta.id, "package.md"), job.package);
   return launch(p, meta);
 }
 async function cmdAudit(p) {
@@ -5667,7 +6185,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 ? fs31.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 +6288,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,7 +6303,7 @@ ${[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]);
@@ -5870,7 +6388,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 ? "" : fs31.readFileSync(0, "utf8");
 function cmdStatusline(p) {
   const input = readStdin();
   const lines = [];
@@ -5910,8 +6428,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 = path27.join(path27.dirname(path27.dirname(fileURLToPath4(import.meta.url))), "hooks", "session-start.mjs");
+  if (fs31.existsSync(script)) spawnSync8(process.execPath, [script], { stdio: ["ignore", "inherit", "ignore"], env: process.env });
   return 0;
 }
 function cmdInit(p) {
@@ -5922,11 +6440,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 +6456,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 +6469,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)}`);
+    fs31.writeFileSync(out, card(t, period));
+    console.log(`card written to ${path27.resolve(out)}`);
   }
   if (has(p, "badge")) console.log(`![pitroom](${badgeUrl(t)})`);
   return 0;
@@ -5994,7 +6512,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()}${fs31.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})`);
@@ -6018,7 +6536,7 @@ function cmdClean(p) {
     const m = readMeta(id);
     if (m.mode === "isolate" && !m.discarded && !m.applied) discardRun(m);
     recordRun(m);
-    fs30.rmSync(runDir(id), { recursive: true, force: true });
+    fs31.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 +6547,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 fs32 from "node:fs";
 import os11 from "node:os";
-import path27 from "node:path";
+import path28 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 +6559,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(path28.delimiter).filter(Boolean)) {
+    const file2 = path28.join(dir, process.platform === "win32" ? "node.exe" : "node");
     try {
-      if (!fs31.statSync(file2).isFile()) continue;
+      if (!fs32.statSync(file2).isFile()) continue;
     } catch {
       continue;
     }
@@ -6071,12 +6589,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) && path28.resolve(onPath.path) !== path28.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()}${fs32.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 +6747,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(`${path28.sep}.agents${path28.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(`${path28.sep}.claude${path28.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 (fs32.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 +6771,12 @@ function skillChecks() {
 }
 function geminiExtensionInstalled() {
   const home3 = process.env.GEMINI_CLI_HOME ?? os11.homedir();
-  return fs31.existsSync(path27.join(home3, ".gemini", "extensions", "pitroom"));
+  return fs32.existsSync(path28.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 = path28.join(os11.homedir(), ".claude", "plugins", "installed_plugins.json");
+    const plugins = JSON.parse(fs32.readFileSync(f, "utf8")).plugins ?? {};
     return Object.keys(plugins).some((k) => k.startsWith("pitroom@"));
   } catch {
     return false;
@@ -6275,24 +6793,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 [path28.join(os11.homedir(), ".agents", "skills"), path28.join(os11.homedir(), ".claude", "skills")]) {
+    const dir = path28.join(base2, "using-superpowers");
+    if (fs32.existsSync(path28.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 = path28.join(os11.homedir(), ".claude", "plugins", "installed_plugins.json");
+    return Object.keys(JSON.parse(fs32.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 = path28.join(os11.homedir(), ".claude", "settings.json");
+    return JSON.parse(fs32.readFileSync(f, "utf8")).enabledPlugins?.[key] !== false;
   } catch {
     return true;
   }
@@ -6301,7 +6819,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 = fs32.readFileSync(path28.join(process.env.CODEX_HOME ?? path28.join(os11.homedir(), ".codex"), "config.toml"), "utf8");
   } catch {
     return plugins;
   }
@@ -6319,11 +6837,11 @@ function codexPlugins() {
   return plugins;
 }
 function openCodePlugins() {
-  const dir = path27.join(process.env.XDG_CONFIG_HOME ?? path27.join(os11.homedir(), ".config"), "opencode");
+  const dir = path28.join(process.env.XDG_CONFIG_HOME ?? path28.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 = fs32.readFileSync(path28.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 +6849,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 fs32.readdirSync(path28.join(dir, folder))) plugins.push(path28.join(dir, folder, f));
     } catch {
     }
   }
@@ -6383,7 +6901,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]
@@ -6439,7 +6959,18 @@ var COMMANDS = {
   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 (!fs33.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,