pitroom 0.6.4 → 0.6.6

package/dist/pitroom.mjs

@@ -57,11 +57,14 @@ function resolveCommand(bin) {
   return { command: bin, prefix: [] };
 }
 
+// src/backends/types.ts
+var MAX_STEPS = 400;
+
 // src/backends/claude/events.ts
 var EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
 var DENIED = /permission|not allowed|denied|blocked|disallowed/i;
 function parseEvents(jsonl) {
-  const usage = {
+  const usage2 = {
     input: 0,
     output: 0,
     reasoning: 0,
@@ -75,6 +78,8 @@ function parseEvents(jsonl) {
   const tools = {};
   const edits = [];
   const pendingEdits = /* @__PURE__ */ new Map();
+  const timeline = [];
+  const stepOf = /* @__PURE__ */ new Map();
   const steps = /* @__PURE__ */ new Set();
   let sessionId;
   let model;
@@ -105,34 +110,42 @@ function parseEvents(jsonl) {
         if (c.type === "text" && String(c.text ?? "").trim()) {
           lastText = String(c.text).trim();
           lastActivity = `says: ${oneLine(lastText)}`;
+          if (timeline.length < MAX_STEPS) timeline.push({ kind: "say", text: clip(lastText, 600) });
         } else if (c.type === "tool_use") {
-          usage.toolCalls++;
+          usage2.toolCalls++;
           tools[c.name] = (tools[c.name] ?? 0) + 1;
           const target = c.input?.file_path ?? c.input?.path ?? c.input?.pattern ?? c.input?.command ?? c.input?.url;
           lastActivity = `${c.name} ${target ? oneLine(String(target), 60) : ""}`.trim();
           if (EDIT_TOOLS.has(c.name) && c.input?.file_path) pendingEdits.set(c.id, String(c.input.file_path));
+          if (timeline.length < MAX_STEPS) {
+            const step = { kind: EDIT_TOOLS.has(c.name) ? "edit" : c.name === "Bash" ? "shell" : "tool", name: c.name, text: clip(String(target ?? ""), 240) };
+            timeline.push(step);
+            stepOf.set(String(c.id), step);
+          }
         }
       }
     } else if (e.type === "user") {
       for (const c of e.message?.content ?? []) {
         if (c?.type !== "tool_result") continue;
         const text = typeof c.content === "string" ? c.content : JSON.stringify(c.content ?? "");
+        const step = stepOf.get(String(c.tool_use_id));
+        if (step) step.ok = !c.is_error;
         if (c.is_error) {
-          if (DENIED.test(text)) usage.denied++;
+          if (DENIED.test(text)) usage2.denied++;
         } else if (pendingEdits.has(c.tool_use_id)) {
           edits.push(pendingEdits.get(c.tool_use_id));
         }
       }
     } else if (e.type === "result") {
       const u = e.usage ?? {};
-      usage.input += num(u.input_tokens);
-      usage.cacheRead += num(u.cache_read_input_tokens);
-      usage.cacheWrite += num(u.cache_creation_input_tokens);
-      usage.reasoning += num(u.output_tokens_details?.thinking_tokens);
-      usage.output += Math.max(0, num(u.output_tokens) - num(u.output_tokens_details?.thinking_tokens));
-      usage.total += num(u.input_tokens) + num(u.cache_read_input_tokens) + num(u.cache_creation_input_tokens) + num(u.output_tokens);
-      usage.cost = (usage.cost ?? 0) + num(e.total_cost_usd);
-      usage.denied = Math.max(usage.denied, Array.isArray(e.permission_denials) ? e.permission_denials.length : 0);
+      usage2.input += num(u.input_tokens);
+      usage2.cacheRead += num(u.cache_read_input_tokens);
+      usage2.cacheWrite += num(u.cache_creation_input_tokens);
+      usage2.reasoning += num(u.output_tokens_details?.thinking_tokens);
+      usage2.output += Math.max(0, num(u.output_tokens) - num(u.output_tokens_details?.thinking_tokens));
+      usage2.total += num(u.input_tokens) + num(u.cache_read_input_tokens) + num(u.cache_creation_input_tokens) + num(u.output_tokens);
+      usage2.cost = (usage2.cost ?? 0) + num(e.total_cost_usd);
+      usage2.denied = Math.max(usage2.denied, Array.isArray(e.permission_denials) ? e.permission_denials.length : 0);
       if (e.is_error) {
         const tags = [e.terminal_reason, e.api_error_status && `HTTP ${e.api_error_status}`].filter(Boolean);
         error ??= `${String(e.result ?? e.subtype ?? "Claude Code error")}${tags.length ? ` [${tags.join(", ")}]` : ""}`;
@@ -141,9 +154,10 @@ function parseEvents(jsonl) {
       }
     }
   }
-  usage.steps = steps.size;
-  return { sessionId, model, finalText: finalText ?? (error ? "" : lastText), usage, tools, edits, lastActivity, error };
+  usage2.steps = steps.size;
+  return { sessionId, model, finalText: finalText ?? (error ? "" : lastText), usage: usage2, tools, edits, lastActivity, timeline, error };
 }
+var clip = (s, n) => s.length > n ? `${s.slice(0, n - 1)}\u2026` : s;
 function num(v) {
   return typeof v === "number" && Number.isFinite(v) ? v : 0;
 }
@@ -231,7 +245,9 @@ function invocation(req) {
     "stream-json",
     "--verbose"
   );
-  if (req.model) args.push("--model", req.model);
+  const [model, effort] = (req.model ?? "").split("#");
+  if (model) args.push("--model", model);
+  if (effort) args.push("--effort", effort);
   if (req.sessionId) args.push("--resume", req.sessionId);
   args.push("--", req.prompt);
   const { command, prefix } = resolveCommand(binary());
@@ -284,11 +300,19 @@ function doctor({ models, hasFallback }) {
   if (!hasFallback) checks.push({ level: "warn", message: "no fallback workers configured for Claude Code runs" });
   return checks;
 }
+var CLAUDE_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+function catalog() {
+  const def = defaultModel();
+  const models = ["haiku", "sonnet", "opus"].map((id) => ({ id, efforts: CLAUDE_EFFORTS }));
+  if (def && !models.some((m) => m.id === def)) models.push({ id: def, efforts: CLAUDE_EFFORTS });
+  return { models, source: "Claude Code aliases (latest of each size) and --effort levels from `claude --help`" };
+}
 var claude = {
   id: "claude",
   name: "Claude Code",
   capabilities: { readOnly: "tool-allowlist", resume: "by-id", reportsCost: true, attachFiles: false },
   binary,
+  catalog,
   invocation,
   parse: parseEvents,
   failure,
@@ -306,7 +330,7 @@ import path3 from "node:path";
 var WORK = /* @__PURE__ */ new Set(["agent_message", "reasoning", "command_execution", "file_change", "mcp_tool_call", "web_search", "todo_list"]);
 var TOOLS = /* @__PURE__ */ new Set(["command_execution", "file_change", "mcp_tool_call", "web_search"]);
 function parseEvents2(jsonl) {
-  const usage = {
+  const usage2 = {
     input: 0,
     output: 0,
     reasoning: 0,
@@ -319,6 +343,7 @@ function parseEvents2(jsonl) {
   };
   const tools = {};
   const edits = [];
+  const timeline = [];
   let sessionId;
   let finalText = "";
   let lastActivity;
@@ -338,35 +363,38 @@ function parseEvents2(jsonl) {
       case "item.completed": {
         const it = e.item ?? {};
         if (!WORK.has(it.type)) break;
-        usage.steps++;
+        usage2.steps++;
         if (TOOLS.has(it.type)) {
-          usage.toolCalls++;
+          usage2.toolCalls++;
           tools[it.type] = (tools[it.type] ?? 0) + 1;
         }
         if (it.type === "agent_message" && String(it.text ?? "").trim()) {
           finalText = String(it.text).trim();
           lastActivity = `says: ${oneLine2(finalText)}`;
+          if (timeline.length < MAX_STEPS) timeline.push({ kind: "say", text: clip2(finalText, 600) });
         } else if (it.type === "command_execution") {
-          if (it.status === "declined" || /operation not permitted|sandbox/i.test(String(it.aggregated_output ?? ""))) usage.denied++;
+          if (it.status === "declined" || /operation not permitted|sandbox/i.test(String(it.aggregated_output ?? ""))) usage2.denied++;
           lastActivity = `shell ${oneLine2(String(it.command ?? ""), 60)}`;
+          if (timeline.length < MAX_STEPS) timeline.push({ kind: "shell", name: "shell", text: clip2(String(it.command ?? "").replace(/^\/bin\/\w+ -lc /, ""), 240), ok: it.exit_code === 0 });
         } else if (it.type === "file_change") {
           const paths = (it.changes ?? []).map((c) => String(c.path));
           if (it.status !== "failed" && it.status !== "declined") edits.push(...paths);
-          else usage.denied++;
+          else usage2.denied++;
           lastActivity = `edit ${oneLine2(paths.join(", "), 60)}`;
+          if (timeline.length < MAX_STEPS) timeline.push({ kind: "edit", name: "edit", text: clip2(paths.join(", "), 240), ok: it.status !== "failed" && it.status !== "declined" });
         }
         break;
       }
       case "turn.completed": {
         const u = e.usage ?? {};
-        const cached2 = num2(u.cached_input_tokens);
+        const cached3 = num2(u.cached_input_tokens);
         const reasoning = num2(u.reasoning_output_tokens);
-        usage.input += Math.max(0, num2(u.input_tokens) - cached2);
-        usage.cacheRead += cached2;
-        usage.cacheWrite += num2(u.cache_write_input_tokens);
-        usage.output += Math.max(0, num2(u.output_tokens) - reasoning);
-        usage.reasoning += reasoning;
-        usage.total += num2(u.input_tokens) + num2(u.output_tokens);
+        usage2.input += Math.max(0, num2(u.input_tokens) - cached3);
+        usage2.cacheRead += cached3;
+        usage2.cacheWrite += num2(u.cache_write_input_tokens);
+        usage2.output += Math.max(0, num2(u.output_tokens) - reasoning);
+        usage2.reasoning += reasoning;
+        usage2.total += num2(u.input_tokens) + num2(u.output_tokens);
         break;
       }
       case "error":
@@ -377,7 +405,7 @@ function parseEvents2(jsonl) {
         break;
     }
   }
-  return { sessionId, finalText, usage, tools, edits, lastActivity, error };
+  return { sessionId, finalText, usage: usage2, tools, edits, lastActivity, timeline, error };
 }
 function describe(raw) {
   const s = String(raw ?? "unknown Codex error");
@@ -397,6 +425,7 @@ function oneLine2(s, max = 80) {
   const t = s.replace(/\s+/g, " ").trim();
   return t.length > max ? `${t.slice(0, max - 1)}\u2026` : t;
 }
+var clip2 = (s, n) => s.length > n ? `${s.slice(0, n - 1)}\u2026` : s;
 
 // src/backends/codex/index.ts
 var binary2 = () => findBinary("codex", "PITROOM_CODEX_BIN");
@@ -482,17 +511,35 @@ function doctor2({ models, hasFallback }) {
     login.ok && /logged in/i.test(login.out) ? { level: "ok", message: `Codex: ${login.out.trim().split("\n")[0]}` } : { level: "fail", message: "Codex is not logged in: run `codex login`" }
   );
   for (const m of models) {
+    const pinned = m?.replace(/#.*$/, "");
     checks.push({
-      level: "ok",
-      message: m ? `Codex model: ${m} (checked on first use; unsupported models fail over)` : "Codex model: Codex's built-in default (your ~/.codex/config.toml is ignored for workers; pick one with -W codex:<model>)"
+      level: pinned ? "ok" : "warn",
+      message: pinned ? `Codex model: ${pinned} (checked on first use; unsupported models fail over)` : 'Codex model: none pinned, so Codex runs its own default (it can change and cost more); set "models": {"codex": "<model>"} or use -W codex:<model>'
     });
   }
   if (!hasFallback) checks.push({ level: "warn", message: "no fallback workers configured for Codex runs" });
   return checks;
 }
+function catalog2() {
+  const file = path3.join(codexHome(), "models_cache.json");
+  try {
+    const raw = JSON.parse(fs3.readFileSync(file, "utf8"));
+    const models = (raw.models ?? []).filter((m) => m.visibility !== "hide" && typeof m.slug === "string").map((m) => ({
+      id: m.slug,
+      efforts: (m.supported_reasoning_levels ?? []).map(
+        (l) => typeof l === "string" ? l : l.effort ?? ""
+      ).filter(Boolean),
+      defaultEffort: typeof m.default_reasoning_level === "string" ? m.default_reasoning_level : void 0
+    }));
+    return { models, source: `Codex model cache${raw.fetched_at ? `, fetched ${raw.fetched_at.slice(0, 10)}` : ""}` };
+  } catch {
+    return { models: [], source: "no Codex model cache found (run codex once)" };
+  }
+}
 var codex = {
   id: "codex",
   name: "Codex",
+  catalog: catalog2,
   capabilities: { readOnly: "os-sandbox", resume: "by-id", reportsCost: false, attachFiles: false },
   binary: binary2,
   invocation: invocation2,
@@ -509,7 +556,7 @@ import { spawnSync as spawnSync3 } from "node:child_process";
 var EDIT_TOOLS2 = /* @__PURE__ */ new Set(["edit", "write", "patch", "multiedit", "apply_patch"]);
 var DENIED2 = /rule which prevents you|permission denied|permission\.rejected/i;
 function parseEvents3(ndjson) {
-  const usage = {
+  const usage2 = {
     input: 0,
     output: 0,
     reasoning: 0,
@@ -523,6 +570,7 @@ function parseEvents3(ndjson) {
   };
   const tools = {};
   const edits = [];
+  const timeline = [];
   const textByMessage = /* @__PURE__ */ new Map();
   let sessionId;
   let lastActivity;
@@ -545,30 +593,36 @@ function parseEvents3(ndjson) {
         if (!textByMessage.has(key)) textByMessage.set(key, []);
         textByMessage.get(key).push(text);
         lastActivity = `says: ${oneLine3(text)}`;
+        if (timeline.length < MAX_STEPS) timeline.push({ kind: "say", text: clip3(text.trim(), 600), at: stamp(e.timestamp) });
         break;
       }
       case "tool_use": {
         const name = String(p.tool ?? "tool");
         const st = p.state ?? {};
-        usage.toolCalls++;
+        usage2.toolCalls++;
         tools[name] = (tools[name] ?? 0) + 1;
-        if (st.status === "error" && DENIED2.test(String(st.error ?? ""))) usage.denied++;
+        if (st.status === "error" && DENIED2.test(String(st.error ?? ""))) usage2.denied++;
         if (st.status === "completed" && EDIT_TOOLS2.has(name)) {
           edits.push(String(st.input?.filePath ?? st.input?.path ?? name));
         }
         lastActivity = `${name} ${describe2(st.input)}`.trim();
+        if (timeline.length < MAX_STEPS) {
+          const kind2 = EDIT_TOOLS2.has(name) ? "edit" : /^(bash|shell)$/.test(name) ? "shell" : "tool";
+          const text = kind2 === "shell" ? String(st.input?.command ?? "") : String(st.input?.filePath ?? st.input?.path ?? st.input?.pattern ?? st.input?.url ?? "") || describe2(st.input);
+          timeline.push({ kind: kind2, name, text: clip3(text, 240), ok: st.status === "completed" ? true : st.status === "error" ? false : void 0, at: stamp(e.timestamp) });
+        }
         break;
       }
       case "step_finish": {
         const t = p.tokens ?? {};
-        usage.steps++;
-        usage.input += num3(t.input);
-        usage.output += num3(t.output);
-        usage.reasoning += num3(t.reasoning);
-        usage.cacheRead += num3(t.cache?.read);
-        usage.cacheWrite += num3(t.cache?.write);
-        usage.total += num3(t.total) || num3(t.input) + num3(t.output) + num3(t.reasoning) + num3(t.cache?.read);
-        usage.cost = (usage.cost ?? 0) + num3(p.cost);
+        usage2.steps++;
+        usage2.input += num3(t.input);
+        usage2.output += num3(t.output);
+        usage2.reasoning += num3(t.reasoning);
+        usage2.cacheRead += num3(t.cache?.read);
+        usage2.cacheWrite += num3(t.cache?.write);
+        usage2.total += num3(t.total) || num3(t.input) + num3(t.output) + num3(t.reasoning) + num3(t.cache?.read);
+        usage2.cost = (usage2.cost ?? 0) + num3(p.cost);
         break;
       }
       case "error": {
@@ -579,7 +633,7 @@ function parseEvents3(ndjson) {
   }
   const groups = [...textByMessage.values()];
   const finalText = (groups[groups.length - 1] ?? []).join("\n").trim();
-  return { sessionId, finalText, usage, tools, edits, lastActivity, error };
+  return { sessionId, finalText, usage: usage2, tools, edits, lastActivity, timeline, error };
 }
 function describeError(err) {
   if (!err || typeof err !== "object") return "unknown OpenCode error";
@@ -592,6 +646,8 @@ function describeError(err) {
   const tags = [err.type, inner, err.status && `HTTP ${err.status}`].filter(Boolean);
   return tags.length ? `${message} [${tags.join(", ")}]` : message;
 }
+var clip3 = (s, n) => s.length > n ? `${s.slice(0, n - 1)}\u2026` : s;
+var stamp = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
 function num3(v) {
   return typeof v === "number" && Number.isFinite(v) ? v : 0;
 }
@@ -784,15 +840,15 @@ function configContent(existing, allowWeb = false) {
       }
     }
   };
-  let base = {};
+  let base2 = {};
   if (existing?.trim()) {
     try {
-      base = JSON.parse(existing);
+      base2 = JSON.parse(existing);
     } catch {
-      base = {};
+      base2 = {};
     }
   }
-  return JSON.stringify(deepMerge(base, ours));
+  return JSON.stringify(deepMerge(base2, ours));
 }
 function deepMerge(a, b) {
   if (!isObject(a) || !isObject(b)) return b;
@@ -897,6 +953,13 @@ function resolveModel2(sessionId) {
     return void 0;
   }
 }
+function catalog3() {
+  const ids = listModels();
+  return {
+    models: (ids.length ? ids : listModels()).map((id) => ({ id })),
+    source: "`opencode models` (reasoning variants are provider-specific: provider/model#variant)"
+  };
+}
 function listModels() {
   return oc(["models"]).out.split("\n").map((s) => s.trim()).filter(Boolean);
 }
@@ -946,6 +1009,7 @@ var opencode = {
   defaultModel: defaultModel2,
   resolveModel: resolveModel2,
   listModels,
+  catalog: catalog3,
   doctor: doctor3
 };
 
@@ -954,6 +1018,7 @@ var REGISTRY = new Map([opencode, codex, claude].map((b) => [b.id, b]));
 var DEFAULT_BACKEND = opencode.id;
 var PLANNED = ["gemini"];
 var backendIds = () => [...REGISTRY.keys()];
+var allBackends = () => [...REGISTRY.values()];
 var isBackendId = (id) => REGISTRY.has(id) || PLANNED.includes(id);
 function getBackend(id) {
   const backend = REGISTRY.get(id);
@@ -982,12 +1047,13 @@ var SCHEMA = {
   web: "boolean",
   maxParallel: "number",
   models: "record",
-  tiers: "record"
+  tiers: "record",
+  costs: "numbers"
 };
 function configPath() {
   if (process.env.PITROOM_CONFIG) return path5.resolve(process.env.PITROOM_CONFIG);
-  const base = process.platform === "win32" ? process.env.APPDATA ?? path5.join(os5.homedir(), "AppData", "Roaming") : process.env.XDG_CONFIG_HOME ?? path5.join(os5.homedir(), ".config");
-  return path5.join(base, "pitroom", "config.json");
+  const base2 = process.platform === "win32" ? process.env.APPDATA ?? path5.join(os5.homedir(), "AppData", "Roaming") : process.env.XDG_CONFIG_HOME ?? path5.join(os5.homedir(), ".config");
+  return path5.join(base2, "pitroom", "config.json");
 }
 var cached;
 function loadConfig() {
@@ -1023,8 +1089,14 @@ function matches(v, type) {
   if (type === "record") {
     return typeof v === "object" && v !== null && !Array.isArray(v) && Object.values(v).every((s) => typeof s === "string");
   }
+  if (type === "numbers") {
+    return typeof v === "object" && v !== null && !Array.isArray(v) && Object.values(v).every((n) => typeof n === "number" && Number.isFinite(n) && n >= 0);
+  }
   return typeof v === type;
 }
+var DEFAULT_PARALLEL = 20;
+var MAX_PARALLEL_LIMIT = 30;
+var clampParallel = (s) => ({ ...s, value: Math.min(s.value, MAX_PARALLEL_LIMIT) });
 var positiveInt = (v) => {
   const n = Number(v);
   return v !== void 0 && v !== "" && Number.isInteger(n) && n > 0 ? n : void 0;
@@ -1049,9 +1121,10 @@ function effective(flags = {}) {
     price: setting(void 0, e.PITROOM_PRICE, c.price, void 0),
     link: setting(void 0, void 0, c.link, []),
     web: setting(void 0, void 0, c.web, false),
-    maxParallel: setting(void 0, positiveInt(e.PITROOM_MAX_PARALLEL), positiveInt(c.maxParallel), 4),
+    maxParallel: clampParallel(setting(void 0, positiveInt(e.PITROOM_MAX_PARALLEL), positiveInt(c.maxParallel), DEFAULT_PARALLEL)),
     models: setting(void 0, void 0, c.models, {}),
-    tiers: setting(void 0, void 0, c.tiers, {})
+    tiers: setting(void 0, void 0, c.tiers, {}),
+    costs: setting(void 0, void 0, c.costs, {})
   };
 }
 
@@ -1076,8 +1149,14 @@ var runDir = (id) => path6.join(runsDir(), id);
 var runFile = (id, name) => path6.join(runDir(id), name);
 function newRunId(now = /* @__PURE__ */ new Date()) {
   const p = (n) => String(n).padStart(2, "0");
-  const stamp = `${now.getFullYear()}${p(now.getMonth() + 1)}${p(now.getDate())}-${p(now.getHours())}${p(now.getMinutes())}${p(now.getSeconds())}`;
-  return `${stamp}-${crypto.randomBytes(2).toString("hex")}`;
+  const stamp2 = `${now.getFullYear()}${p(now.getMonth() + 1)}${p(now.getDate())}-${p(now.getHours())}${p(now.getMinutes())}${p(now.getSeconds())}`;
+  return `${stamp2}-${crypto.randomBytes(2).toString("hex")}`;
+}
+var onFinished;
+var archive;
+function useArchive(hooks) {
+  onFinished = hooks.onFinished;
+  archive = { meta: hooks.meta, id: hooks.id };
 }
 function writeMeta(meta) {
   fs6.mkdirSync(runDir(meta.id), { recursive: true });
@@ -1085,9 +1164,20 @@ function writeMeta(meta) {
   const tmp = `${file}.${process.pid}.tmp`;
   fs6.writeFileSync(tmp, JSON.stringify(meta, null, 2));
   fs6.renameSync(tmp, file);
+  if (TERMINAL.includes(meta.state)) {
+    try {
+      onFinished?.(meta);
+    } catch {
+    }
+  }
 }
 function readMeta(id) {
-  return upgrade(JSON.parse(fs6.readFileSync(runFile(id, "meta.json"), "utf8")));
+  const file = runFile(id, "meta.json");
+  if (!fs6.existsSync(file)) {
+    const kept = archive?.meta(id);
+    if (kept) return upgrade(kept);
+  }
+  return upgrade(JSON.parse(fs6.readFileSync(file, "utf8")));
 }
 function upgrade(raw) {
   if (!raw.worker) raw.worker = raw.model ? { backend: "opencode", model: raw.model } : { backend: "opencode" };
@@ -1105,12 +1195,18 @@ function listRunIds() {
 }
 function resolveRun(ref) {
   const ids = listRunIds();
-  if (!ids.length) throw new UserError("no runs yet");
-  if (!ref || ref === "latest" || ref === "last") return ids[ids.length - 1];
+  if (!ref || ref === "latest" || ref === "last") {
+    if (!ids.length) throw new UserError("no runs yet");
+    return ids[ids.length - 1];
+  }
   if (ids.includes(ref)) return ref;
   const hits = ids.filter((id) => id.startsWith(ref) || id.endsWith(ref));
   if (hits.length === 1) return hits[0];
-  throw new UserError(hits.length ? `ambiguous run "${ref}": ${hits.join(", ")}` : `unknown run "${ref}"`);
+  if (!hits.length) {
+    const kept = archive?.id(ref);
+    if (kept) return kept;
+  }
+  throw new UserError(hits.length ? `ambiguous run "${ref}": ${hits.join(", ")}` : ids.length ? `unknown run "${ref}"` : "no runs yet");
 }
 function isAlive(pid) {
   if (!pid) return false;
@@ -1143,6 +1239,7 @@ var VALUE_FLAGS = {
   "-W": "worker",
   "--worker": "worker",
   "--tier": "tier",
+  "--effort": "effort",
   "-g": "group",
   "--group": "group",
   "-t": "timeout",
@@ -1158,6 +1255,10 @@ var VALUE_FLAGS = {
   "--interval": "interval",
   "--range": "range",
   "--then": "then",
+  "--port": "port",
+  "--idle": "idle",
+  "--state": "state",
+  "--limit": "limit",
   "--plan": "plan",
   "--step": "step"
 };
@@ -1179,12 +1280,18 @@ var BOOL_FLAGS = {
   "--badge": "badge",
   "--probe": "probe",
   "--copy": "copy",
+  "--all": "all",
+  "--models": "models",
   "--force": "force",
   "--allow-delete": "allow-delete",
   "--yes": "yes",
   "--any": "any",
   "--brief": "brief",
   "--running": "running",
+  "--detach": "detach",
+  "--stop": "stop",
+  "--open": "open",
+  "--serve": "serve",
   "-h": "help",
   "--help": "help",
   "-v": "version",
@@ -1258,6 +1365,7 @@ function runOptions(p, task) {
     worker: flag(p, "worker"),
     model: flag(p, "model"),
     tier: flag(p, "tier"),
+    effort: effortFlag(p),
     timeoutSec: parseDuration(effective({ timeout: flag(p, "timeout") }).timeout.value),
     verify: flag(p, "verify"),
     continueFrom: cont ? resolveRun(cont) : void 0,
@@ -1275,90 +1383,29 @@ function planStep(p) {
   if (!/^\d+$/.test(step)) throw new UserError(`--step takes a task number, not "${step}"`);
   return { file, step: Number(step) };
 }
+function effortFlag(p) {
+  const v = flag(p, "effort");
+  if (v !== void 0 && !/^[a-z][a-z0-9-]*$/i.test(v)) throw new UserError(`--effort takes a level such as low, medium, high or xhigh, not "${v}"`);
+  return v?.toLowerCase();
+}
 
 // src/cli/commands.ts
 import { spawnSync as spawnSync6 } from "node:child_process";
-import fs22 from "node:fs";
-import path18 from "node:path";
+import fs24 from "node:fs";
+import path20 from "node:path";
 
-// src/core/report.ts
+// src/core/history.ts
 import fs10 from "node:fs";
+import { createRequire } from "node:module";
+import path8 from "node:path";
+import zlib from "node:zlib";
 
-// src/core/plan.ts
-import fs8 from "node:fs";
-import path7 from "node:path";
-var FENCE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
-var RULE = /^ {0,3}([-*_])(\s*\1){2,}\s*$/;
-function structure(lines) {
-  const headings = [];
-  const rules = [];
-  const fenced = [];
-  let open;
-  lines.forEach((l, i) => {
-    const f = FENCE.exec(l);
-    if (f) {
-      fenced[i] = true;
-      const mark = f[1];
-      if (!open) open = mark;
-      else if (mark[0] === open[0] && mark.length >= open.length && !f[2].trim()) open = void 0;
-      return;
-    }
-    fenced[i] = !!open;
-    if (open) return;
-    const h = /^ {0,3}(#{1,6})\s+(.*?)\s*#*\s*$/.exec(l);
-    if (h) headings.push({ line: i, level: h[1].length, text: h[2] });
-    else if (RULE.test(l)) rules.push(i);
-  });
-  return { headings, rules, fenced };
-}
-function parsePlan(text, file = "") {
-  const lines = text.replace(/\r\n?/g, "\n").split("\n");
-  const { headings, rules, fenced } = structure(lines);
-  const after = (line) => Math.min(headings.find((h) => h.line > line)?.line ?? lines.length, rules.find((r) => r > line) ?? lines.length);
-  const titleHeading = headings.find((h) => h.level === 1);
-  const start = titleHeading ? titleHeading.line + 1 : 0;
-  const header = lines.slice(start, after(start - 1)).filter((l) => !/^\s*>/.test(l)).join("\n").trim();
-  const gc = headings.find((h) => /^global constraints\b/i.test(h.text));
-  const constraints = gc ? lines.slice(gc.line + 1, after(gc.line)).join("\n").trim() : "";
-  const tasks = [];
-  for (const h of headings) {
-    const m = /^Task\s+(\d+)\b\s*[:.)\-–—]?\s*(.*)$/i.exec(h.text);
-    if (!m) continue;
-    const end = headings.find((o) => o.line > h.line && o.level <= h.level)?.line ?? lines.length;
-    const body = lines.slice(h.line, end).join("\n").replace(/(\n\s*(?:---|\*\*\*|___)\s*)+$/, "").trimEnd();
-    const unfenced = lines.slice(h.line, end).filter((_, j) => !fenced[h.line + j]).join("\n");
-    const tier = /^\s*[-*]?\s*\*\*Worker:\*\*\s*`?([\w-]+)`?/m.exec(unfenced)?.[1]?.toLowerCase();
-    tasks.push({ step: Number(m[1]), title: m[2].trim(), text: body, ...tier ? { tier } : {} });
-  }
-  return { file, title: titleHeading?.text ?? "", header, constraints, tasks };
-}
-function loadPlan(file) {
-  const abs = path7.resolve(file);
-  if (!fs8.existsSync(abs) || !fs8.statSync(abs).isFile()) throw new UserError(`plan not found: ${file}`);
-  const plan = parsePlan(fs8.readFileSync(abs, "utf8"), fs8.realpathSync(abs));
-  if (!plan.tasks.length) throw new UserError(`${file} has no "Task N" headings (see pitroom-writing-plans)`);
-  return plan;
-}
-function planTask(plan, step) {
-  const t = plan.tasks.find((x) => x.step === step);
-  if (!t) throw new UserError(`no Task ${step} in ${plan.file}; it has ${plan.tasks.map((x) => `Task ${x.step}`).join(", ")}`);
-  return t;
-}
-function brief(plan, task) {
-  return `${[
-    `# ${plan.title || planName(plan.file)}`,
-    plan.header,
-    "## Global Constraints",
-    plan.constraints || "(none stated in the plan)",
-    task.text
-  ].filter(Boolean).join("\n\n")}
-`;
-}
-var planName = (file) => path7.basename(file).replace(/\.md$/i, "");
+// src/core/ui.ts
+import fs9 from "node:fs";
 
 // src/core/receipt.ts
-import fs9 from "node:fs";
-import path8 from "node:path";
+import fs8 from "node:fs";
+import path7 from "node:path";
 var PRESETS = {
   sonnet: { name: "Claude Sonnet", input: 3, output: 15, cachedInput: 0.3 },
   opus: { name: "Claude Opus", input: 5, output: 25, cachedInput: 0.5 },
@@ -1374,10 +1421,10 @@ function primaryPrice() {
   return PRESETS[eff.primary.value.toLowerCase()] ?? PRESETS.sonnet;
 }
 var estimateTokens = (text) => Math.ceil(text.length / 4);
-function savedUsd(usage, returnedTokens, price = primaryPrice()) {
-  const wouldCost = (usage.input * price.input + usage.cacheRead * price.cachedInput + (usage.output + usage.reasoning) * price.output) / 1e6;
+function savedUsd(usage2, returnedTokens, price = primaryPrice()) {
+  const wouldCost = (usage2.input * price.input + usage2.cacheRead * price.cachedInput + (usage2.output + usage2.reasoning) * price.output) / 1e6;
   const readingTheReport = returnedTokens * price.input / 1e6;
-  return Math.max(0, wouldCost - (usage.cost ?? 0) - readingTheReport);
+  return Math.max(0, wouldCost - (usage2.cost ?? 0) - readingTheReport);
 }
 function record(meta) {
   if (!meta.usage?.steps) return;
@@ -1394,13 +1441,13 @@ function record(meta) {
     saved: meta.savedUsd ?? 0,
     price: primaryPrice().name
   };
-  fs9.mkdirSync(path8.dirname(ledgerFile()), { recursive: true });
-  fs9.appendFileSync(ledgerFile(), `${JSON.stringify(entry)}
+  fs8.mkdirSync(path7.dirname(ledgerFile()), { recursive: true });
+  fs8.appendFileSync(ledgerFile(), `${JSON.stringify(entry)}
 `);
 }
 function readLedger(sinceMs2) {
-  if (!fs9.existsSync(ledgerFile())) return [];
-  return fs9.readFileSync(ledgerFile(), "utf8").split("\n").filter(Boolean).flatMap((l) => {
+  if (!fs8.existsSync(ledgerFile())) return [];
+  return fs8.readFileSync(ledgerFile(), "utf8").split("\n").filter(Boolean).flatMap((l) => {
     try {
       return [JSON.parse(l)];
     } catch {
@@ -1428,38 +1475,507 @@ function compact(n) {
   if (n >= 1e3) return `${fmt(n / 1e3)}k`;
   return String(Math.round(n));
 }
-function badgeUrl(t) {
-  const msg = encodeURIComponent(`saved ${usd(t.saved)} \xB7 ${compact(t.tokens)} tokens offloaded`).replace(/-/g, "--");
-  return `https://img.shields.io/badge/pitroom-${msg}-7c3aed`;
+function badgeUrl(t) {
+  const msg = encodeURIComponent(`saved ${usd(t.saved)} \xB7 ${compact(t.tokens)} tokens offloaded`).replace(/-/g, "--");
+  return `https://img.shields.io/badge/pitroom-${msg}-7c3aed`;
+}
+var esc = (s) => s.replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c]);
+function card(t, period) {
+  const stat = (x, value, label) => `<text x="${x}" y="148" class="v">${esc(value)}</text><text x="${x}" y="170" class="l">${esc(label)}</text>`;
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="600" height="220" viewBox="0 0 600 220" role="img" aria-label="pitroom saved ${esc(usd(t.saved))}">
+<style>
+text{font-family:ui-sans-serif,-apple-system,Segoe UI,Helvetica,Arial,sans-serif;fill:#ede9fe}
+.h{font-size:15px;font-weight:600;fill:#a78bfa;letter-spacing:.08em}
+.big{font-size:54px;font-weight:800;fill:#fff}
+.sub{font-size:15px;fill:#c4b5fd}
+.v{font-size:22px;font-weight:700;fill:#fff}
+.l{font-size:12px;fill:#a78bfa}
+.f{font-size:11px;fill:#8b5cf6}
+</style>
+<defs><linearGradient id="g" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#1e1b4b"/><stop offset="1" stop-color="#3b0764"/></linearGradient></defs>
+<rect width="600" height="220" rx="18" fill="url(#g)"/>
+<text x="32" y="42" class="h">PITROOM \xB7 ${esc(period.toUpperCase())}</text>
+<text x="32" y="98" class="big">${esc(usd(t.saved))}</text>
+<text x="${Math.min(60 + usd(t.saved).length * 30, 330)}" y="98" class="sub">saved on my main coding agent</text>
+${stat(32, compact(t.tokens), "tokens offloaded")}
+${stat(200, t.ratio ? `${Math.round(t.ratio)}\xD7` : "\u2014", "context compression")}
+${stat(380, String(t.runs), "delegated tasks")}
+<text x="32" y="202" class="f">estimated vs. ${esc(primaryPrice().name)} pricing \xB7 npx pitroom</text>
+</svg>
+`;
+}
+
+// src/core/ui.ts
+var WEEK_MS = 7 * 24 * 3600 * 1e3;
+var RECENT = 40;
+var RECENT_HOURS = 1;
+var MAX_CARDS = 5;
+function activeRuns() {
+  const out = [];
+  for (const id of listRunIds().slice(-RECENT)) {
+    try {
+      const m = readMeta(id);
+      if (isActive(m.state) && (m.state === "queued" || isAlive(m.pid))) out.push(m);
+    } catch {
+    }
+  }
+  return out;
+}
+function statusLine() {
+  const running = activeRuns();
+  const saved = totals(readLedger(Date.now() - WEEK_MS)).saved;
+  if (!running.length && !saved) return "";
+  const parts = ["\u{1F3C1} pitroom"];
+  if (running.length) {
+    const who = [...new Set(running.map((m) => (m.ran ?? m.worker).backend))].join(", ");
+    parts.push(`${running.length} running (${who})`);
+  }
+  if (saved) parts.push(`~${usd(saved)} saved this week`);
+  return parts.join(" \xB7 ");
+}
+var RUN_ID = /\b\d{8}-\d{6}-[0-9a-f]{4}\b/g;
+var PITROOM_CALL = /(^|[\s;&|(`])(\S*\/)?pitroom(\.mjs)?(\s|$)/;
+var ICON = { done: "\u2714", failed: "\u2718", timeout: "\u23F1", stopped: "\u25A0" };
+function kind(m) {
+  if (m.reviewOf) return m.reviewKind === "range" ? "branch review" : m.reviewKind === "fix" ? "re-review" : "review";
+  return m.mode === "read" ? "research" : m.mode === "isolate" ? "change (isolated copy)" : "change";
+}
+var SUBJECT_MAX = 48;
+function short(text) {
+  const s = text.replace(/`/g, "").replace(/^#+\s*/, "").replace(/\s+/g, " ").trim();
+  if (s.length <= SUBJECT_MAX) return s;
+  const cut = s.slice(0, SUBJECT_MAX);
+  const space = cut.lastIndexOf(" ");
+  return `${(space > SUBJECT_MAX / 2 ? cut.slice(0, space) : cut).replace(/[\s,.;:·-]+$/, "")}\u2026`;
+}
+var MODEL_MAX = 24;
+function workerName(t) {
+  if (!t.model) return t.backend;
+  const model = (t.model.split("/").pop() ?? t.model).replace(/-(contributor-)?free$/, "").replace(/-\d+\.\d+$/, "");
+  return `${t.backend} (${model.length > MODEL_MAX ? `${model.slice(0, MODEL_MAX - 1)}\u2026` : model})`;
+}
+function what(m) {
+  if (m.plan) return short(`Task ${m.plan.step}: ${m.plan.title}`);
+  if (m.reviewOf) return `of ${m.reviewOf.replace(/\b([0-9a-f]{9})[0-9a-f]{31}\b/g, "$1")}`;
+  const line = m.task.split("\n").find((l) => l.trim()) ?? "";
+  const brief2 = /^You are implementing Task (\d+)\b.*?\bplan\s+(\S+)/i.exec(line);
+  if (brief2) return short(`Task ${brief2[1]} \xB7 ${brief2[2].split("/").pop().replace(/\.md\W*$/, "")}`);
+  return short(line);
+}
+function elapsed(m) {
+  const s = Math.round((Date.parse(m.endedAt ?? "") - Date.parse(m.startedAt)) / 1e3);
+  if (!Number.isFinite(s) || s < 0) return "";
+  return s >= 60 ? `${Math.floor(s / 60)}m${String(s % 60).padStart(2, "0")}s` : `${s}s`;
+}
+var startedCard = (m) => `\u{1F3C1} Pitroom \u25B6 ${kind(m)} on ${workerName(m.worker)} \xB7 ${what(m)}  (${m.id})`;
+function endedCard(m) {
+  const v = m.verdict;
+  const bits = [
+    `\u{1F3C1} Pitroom ${ICON[m.state] ?? "\u2022"} ${kind(m)} ${m.state} on ${workerName(m.ran ?? m.worker)}`,
+    what(m),
+    elapsed(m),
+    v && `SPEC ${v.spec.toUpperCase()} \xB7 QUALITY ${v.quality.toUpperCase()}`,
+    m.changes?.length ? `${m.changes.length} file${m.changes.length === 1 ? "" : "s"} changed` : "",
+    m.savedUsd ? `~${usd(m.savedUsd)} saved` : ""
+  ];
+  return `${bits.filter(Boolean).join(" \xB7 ")}  (${m.id})`;
+}
+function cardsFor(m) {
+  const phases = [["started", () => startedCard(m)]];
+  if (!isActive(m.state)) phases.push(["ended", () => endedCard(m)]);
+  if (m.applied) {
+    phases.push(["applied", () => `\u{1F3C1} Pitroom \u2935 applied ${m.changes?.length ?? 0} file(s) from ${m.id} to your tree`]);
+  }
+  const out = [];
+  for (const [phase, text] of phases) {
+    const marker = runFile(m.id, `card-${phase}`);
+    if (fs9.existsSync(marker)) continue;
+    if (!(phase === "started" && !isActive(m.state))) out.push(text());
+    fs9.writeFileSync(marker, "");
+  }
+  return out;
+}
+function hookCards(input) {
+  const event = JSON.parse(input);
+  const command = event.tool_input?.command ?? "";
+  if (event.tool_name !== "Bash" || !PITROOM_CALL.test(command)) return "";
+  const response = event.tool_response;
+  const output = typeof response === "string" ? response : [response?.stdout, response?.stderr].filter(Boolean).join("\n");
+  const ids = [...new Set(`${command}
+${output}`.match(RUN_ID) ?? [])].filter((id) => fs9.existsSync(`${runsDir()}/${id}`));
+  const since = Date.now() - RECENT_HOURS * 36e5;
+  for (const id of listRunIds().slice(-RECENT)) {
+    if (ids.includes(id) || fs9.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);
+    } catch {
+    }
+  }
+  const cards = [];
+  for (const id of ids.slice(0, MAX_CARDS)) {
+    try {
+      cards.push(...cardsFor(readMeta(id)));
+    } catch {
+    }
+  }
+  return cards.join("\n");
+}
+
+// src/core/history.ts
+var SCHEMA_VERSION = 1;
+var PATCH_MAX = 1e6;
+var ANSWER_MAX = 2e5;
+var cached2;
+var historyFile = () => path8.join(home(), "history.db");
+function openDb() {
+  const file = historyFile();
+  if (cached2?.file === file) return cached2.db;
+  let db;
+  try {
+    const emit = process.emitWarning;
+    process.emitWarning = ((w, ...rest) => /SQLite/i.test(String(w?.message ?? w)) ? void 0 : emit.call(process, w, ...rest));
+    let DatabaseSync;
+    try {
+      ({ DatabaseSync } = createRequire(import.meta.url)("node:sqlite"));
+    } finally {
+      process.emitWarning = emit;
+    }
+    fs10.mkdirSync(path8.dirname(file), { recursive: true });
+    db = new DatabaseSync(file);
+    db.exec("PRAGMA journal_mode=WAL; PRAGMA busy_timeout=5000; PRAGMA synchronous=NORMAL;");
+    migrate(db);
+  } catch {
+    db = void 0;
+  }
+  cached2 = { file, db };
+  return db;
+}
+function migrate(db) {
+  const v = db.prepare("PRAGMA user_version").get()?.user_version ?? 0;
+  if (v >= SCHEMA_VERSION) return;
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS runs (
+      id TEXT PRIMARY KEY, started_at TEXT NOT NULL, ended_at TEXT, state TEXT NOT NULL, mode TEXT, kind TEXT,
+      backend TEXT, model TEXT, task TEXT, grp TEXT, dir TEXT, review_of TEXT, verdict TEXT,
+      seconds INTEGER, steps INTEGER, tool_calls INTEGER, tokens INTEGER, returned_tokens INTEGER,
+      cost REAL, saved REAL, files_changed INTEGER, applied INTEGER, error TEXT,
+      answer TEXT, patch TEXT, meta_json TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS runs_started ON runs(started_at);
+    CREATE INDEX IF NOT EXISTS runs_model ON runs(backend, model);
+    CREATE INDEX IF NOT EXISTS runs_grp ON runs(grp);
+    CREATE TABLE IF NOT EXISTS steps (
+      run_id TEXT NOT NULL, n INTEGER NOT NULL, kind TEXT, name TEXT, text TEXT, ok INTEGER, at INTEGER,
+      PRIMARY KEY (run_id, n)
+    ) WITHOUT ROWID;
+    CREATE VIRTUAL TABLE IF NOT EXISTS runs_fts USING fts5(id UNINDEXED, task, answer, steps);
+    PRAGMA user_version = ${SCHEMA_VERSION};
+  `);
+}
+function readRunFile(id, name) {
+  const f = runFile(id, name);
+  try {
+    if (fs10.existsSync(f)) return fs10.readFileSync(f, "utf8");
+    if (fs10.existsSync(`${f}.gz`)) return zlib.gunzipSync(fs10.readFileSync(`${f}.gz`)).toString("utf8");
+  } catch {
+  }
+  return void 0;
+}
+function gzipFile(f) {
+  if (!fs10.existsSync(f)) return;
+  fs10.writeFileSync(`${f}.gz`, zlib.gzipSync(fs10.readFileSync(f)));
+  fs10.rmSync(f);
+}
+function compactRun(meta) {
+  if (!TERMINAL.includes(meta.state)) return;
+  const dir = path8.dirname(runFile(meta.id, "meta.json"));
+  let names;
+  try {
+    names = fs10.readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const n of names) {
+    if (/^events(\.attempt-\d+)?\.jsonl$/.test(n)) gzipFile(path8.join(dir, n));
+    else if (/^stderr(\.attempt-\d+)?\.log$/.test(n)) {
+      if (meta.state === "done" && !/attempt/.test(n)) fs10.rmSync(path8.join(dir, n), { force: true });
+      else gzipFile(path8.join(dir, n));
+    }
+  }
+}
+var clip4 = (s, n) => s && s.length > n ? s.slice(0, n) : s;
+function timelineOf(meta) {
+  const raw = readRunFile(meta.id, "events.jsonl");
+  if (!raw) return [];
+  try {
+    return getBackend((meta.ran ?? meta.worker).backend).parse(raw).timeline ?? [];
+  } catch {
+    return [];
+  }
+}
+function recordRun(meta) {
+  if (!TERMINAL.includes(meta.state)) return;
+  const db = openDb();
+  if (!db) return;
+  try {
+    const u = meta.usage;
+    const known = db.prepare("SELECT answer IS NOT NULL AS has FROM runs WHERE id = ?").get(meta.id);
+    const answer = known?.has ? void 0 : clip4(readRunFile(meta.id, "summary.md")?.trim(), ANSWER_MAX);
+    const patch = known?.has ? void 0 : clip4(readRunFile(meta.id, "changes.patch"), PATCH_MAX);
+    const seconds = meta.endedAt ? Math.max(0, Math.round((Date.parse(meta.endedAt) - Date.parse(meta.startedAt)) / 1e3)) : null;
+    const t = meta.ran ?? meta.worker;
+    const fields = {
+      id: meta.id,
+      started_at: meta.startedAt,
+      ended_at: meta.endedAt ?? null,
+      state: meta.state,
+      mode: meta.mode,
+      kind: kind(meta),
+      backend: t.backend,
+      model: meta.resolvedModel ?? t.model ?? null,
+      task: clip4(meta.task, 2e4) ?? "",
+      grp: meta.group ?? null,
+      dir: meta.dir,
+      review_of: meta.reviewOf ?? null,
+      verdict: meta.verdict ? `SPEC ${meta.verdict.spec.toUpperCase()} \xB7 QUALITY ${meta.verdict.quality.toUpperCase()}` : null,
+      seconds,
+      steps: u?.steps ?? null,
+      tool_calls: u?.toolCalls ?? null,
+      tokens: u?.total ?? null,
+      returned_tokens: meta.returnedTokens ?? null,
+      cost: u?.cost ?? null,
+      saved: meta.savedUsd ?? null,
+      files_changed: meta.changes?.length ?? 0,
+      applied: meta.applied ? 1 : 0,
+      error: clip4(meta.error, 2e3) ?? null,
+      meta_json: JSON.stringify(meta)
+    };
+    db.exec("BEGIN IMMEDIATE");
+    try {
+      const cols = Object.keys(fields);
+      db.prepare(`INSERT INTO runs (${cols.join(",")}) VALUES (${cols.map(() => "?").join(",")})
+        ON CONFLICT(id) DO UPDATE SET ${cols.filter((c) => c !== "id").map((c) => `${c}=excluded.${c}`).join(",")}`).run(...Object.values(fields));
+      if (!known?.has) {
+        const steps = timelineOf(meta);
+        db.prepare("UPDATE runs SET answer = ?, patch = ? WHERE id = ?").run(answer ?? "", patch ?? null, meta.id);
+        db.prepare("DELETE FROM steps WHERE run_id = ?").run(meta.id);
+        const ins = db.prepare("INSERT INTO steps (run_id, n, kind, name, text, ok, at) VALUES (?,?,?,?,?,?,?)");
+        steps.forEach((s, n) => ins.run(meta.id, n, s.kind, s.name ?? null, s.text, s.ok === void 0 ? null : s.ok ? 1 : 0, s.at ?? null));
+        db.prepare("DELETE FROM runs_fts WHERE id = ?").run(meta.id);
+        db.prepare("INSERT INTO runs_fts (id, task, answer, steps) VALUES (?,?,?,?)").run(meta.id, fields.task, answer ?? "", steps.map((s) => s.text).join("\n"));
+      }
+      db.exec("COMMIT");
+    } catch (e) {
+      db.exec("ROLLBACK");
+      throw e;
+    }
+    compactRun(meta);
+  } catch {
+  }
+}
+function importRuns() {
+  const db = openDb();
+  if (!db) return { imported: 0, known: 0 };
+  const have = new Set(db.prepare("SELECT id FROM runs").all().map((r) => r.id));
+  let imported = 0;
+  for (const id of listRunIds()) {
+    if (have.has(id)) continue;
+    try {
+      const m = readMeta(id);
+      if (!TERMINAL.includes(m.state)) continue;
+      recordRun(m);
+      imported++;
+    } catch {
+    }
+  }
+  return { imported, known: have.size };
+}
+function archivedRun(id) {
+  const db = openDb();
+  if (!db) return void 0;
+  try {
+    const r = db.prepare("SELECT meta_json, answer, patch, started_at FROM runs WHERE id = ?").get(id);
+    if (!r) return void 0;
+    const start = Date.parse(r.started_at);
+    const steps = db.prepare("SELECT kind, name, text, ok, at FROM steps WHERE run_id = ? ORDER BY n").all(id).map((s) => ({
+      kind: s.kind,
+      name: s.name ?? void 0,
+      text: s.text,
+      ok: s.ok === null ? void 0 : !!s.ok,
+      at: s.at ?? void 0,
+      t: s.at && Number.isFinite(start) ? Math.max(0, Math.round((s.at - start) / 1e3)) : void 0
+    }));
+    return { meta: JSON.parse(r.meta_json), answer: r.answer ?? "", patch: r.patch ?? void 0, steps };
+  } catch {
+    return void 0;
+  }
+}
+function archivedId(ref) {
+  const db = openDb();
+  if (!db || !/^[\w-]{3,}$/.test(ref)) return void 0;
+  try {
+    const rows = db.prepare("SELECT id FROM runs WHERE id = ? OR id LIKE ? OR id LIKE ? ORDER BY id").all(ref, `${ref}%`, `%${ref}`);
+    return rows.length === 1 ? rows[0].id : rows.find((r) => r.id === ref)?.id;
+  } catch {
+    return void 0;
+  }
+}
+var ftsQuery = (text) => text.split(/\s+/).filter(Boolean).map((w) => `"${w.replace(/"/g, '""')}"*`).join(" ");
+function listHistory(q = {}) {
+  const db = openDb();
+  if (!db) return { rows: [], total: 0 };
+  const where = [];
+  const args = [];
+  if (q.text?.trim()) {
+    where.push("r.id IN (SELECT id FROM runs_fts WHERE runs_fts MATCH ?)");
+    args.push(ftsQuery(q.text));
+  }
+  if (q.model) {
+    where.push("r.model = ?");
+    args.push(q.model);
+  }
+  if (q.backend) {
+    where.push("r.backend = ?");
+    args.push(q.backend);
+  }
+  if (q.state) {
+    where.push(q.state === "problem" ? "r.state IN ('failed','timeout','stopped')" : "r.state = ?");
+    if (q.state !== "problem") args.push(q.state);
+  }
+  if (q.group) {
+    where.push("r.grp = ?");
+    args.push(q.group);
+  }
+  if (q.sinceMs) {
+    where.push("r.started_at >= ?");
+    args.push(new Date(q.sinceMs).toISOString());
+  }
+  const base2 = where.length ? `WHERE ${where.join(" AND ")}` : "";
+  try {
+    const total = db.prepare(`SELECT COUNT(*) AS n FROM runs r ${base2}`).get(...args).n;
+    const page = q.beforeId ? `${base2 ? `${base2} AND` : "WHERE"} r.id < ?` : base2;
+    const rows = db.prepare(`SELECT r.* FROM runs r ${page} ORDER BY r.id DESC LIMIT ?`).all(...args, ...q.beforeId ? [q.beforeId] : [], Math.min(Math.max(q.limit ?? 30, 1), 200));
+    return {
+      total,
+      rows: rows.map((r) => ({
+        id: r.id,
+        startedAt: r.started_at,
+        state: r.state,
+        kind: r.kind,
+        backend: r.backend,
+        model: r.model ?? void 0,
+        task: r.review_of ? `of ${r.review_of.replace(/\b([0-9a-f]{9})[0-9a-f]{31}\b/g, "$1")}` : r.task.split("\n").find((l) => l.trim()) ?? "",
+        group: r.grp ?? void 0,
+        verdict: r.verdict ?? void 0,
+        seconds: r.seconds ?? void 0,
+        steps: r.steps ?? void 0,
+        tokens: r.tokens ?? void 0,
+        saved: r.saved ?? void 0,
+        files: r.files_changed ?? 0,
+        applied: !!r.applied
+      }))
+    };
+  } catch {
+    return { rows: [], total: 0 };
+  }
+}
+function historyStats(sinceMs2) {
+  const empty = { totals: { runs: 0, ok: 0, failed: 0, seconds: 0, tokens: 0, saved: 0 }, byWorker: [], byDay: [] };
+  const db = openDb();
+  if (!db) return empty;
+  const since = 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 >= ?").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 >= ? 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 >= ? GROUP BY day ORDER BY day DESC LIMIT 60").all(since);
+    return {
+      totals: { runs: t.runs, ok: t.ok, failed: t.runs - t.ok, seconds: t.seconds, tokens: t.tokens, saved: t.saved },
+      byWorker: w.map((r) => ({ backend: r.backend, model: r.model ?? void 0, runs: r.runs, ok: r.ok ?? 0, avgSeconds: r.avg_s, avgTokens: r.avg_t, saved: r.saved })),
+      byDay: d.reverse().map((r) => ({ day: r.day, runs: r.runs, ok: r.ok ?? 0, saved: r.saved }))
+    };
+  } catch {
+    return empty;
+  }
+}
+
+// src/core/report.ts
+import fs12 from "node:fs";
+
+// src/core/plan.ts
+import fs11 from "node:fs";
+import path9 from "node:path";
+var FENCE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
+var RULE = /^ {0,3}([-*_])(\s*\1){2,}\s*$/;
+function structure(lines) {
+  const headings = [];
+  const rules = [];
+  const fenced = [];
+  let open;
+  lines.forEach((l, i) => {
+    const f = FENCE.exec(l);
+    if (f) {
+      fenced[i] = true;
+      const mark = f[1];
+      if (!open) open = mark;
+      else if (mark[0] === open[0] && mark.length >= open.length && !f[2].trim()) open = void 0;
+      return;
+    }
+    fenced[i] = !!open;
+    if (open) return;
+    const h = /^ {0,3}(#{1,6})\s+(.*?)\s*#*\s*$/.exec(l);
+    if (h) headings.push({ line: i, level: h[1].length, text: h[2] });
+    else if (RULE.test(l)) rules.push(i);
+  });
+  return { headings, rules, fenced };
+}
+function parsePlan(text, file = "") {
+  const lines = text.replace(/\r\n?/g, "\n").split("\n");
+  const { headings, rules, fenced } = structure(lines);
+  const after = (line) => Math.min(headings.find((h) => h.line > line)?.line ?? lines.length, rules.find((r) => r > line) ?? lines.length);
+  const titleHeading = headings.find((h) => h.level === 1);
+  const start = titleHeading ? titleHeading.line + 1 : 0;
+  const header = lines.slice(start, after(start - 1)).filter((l) => !/^\s*>/.test(l)).join("\n").trim();
+  const gc = headings.find((h) => /^global constraints\b/i.test(h.text));
+  const constraints = gc ? lines.slice(gc.line + 1, after(gc.line)).join("\n").trim() : "";
+  const tasks = [];
+  for (const h of headings) {
+    const m = /^Task\s+(\d+)\b\s*[:.)\-–—]?\s*(.*)$/i.exec(h.text);
+    if (!m) continue;
+    const end = headings.find((o) => o.line > h.line && o.level <= h.level)?.line ?? lines.length;
+    const body = lines.slice(h.line, end).join("\n").replace(/(\n\s*(?:---|\*\*\*|___)\s*)+$/, "").trimEnd();
+    const unfenced = lines.slice(h.line, end).filter((_, j) => !fenced[h.line + j]).join("\n");
+    const tier = /^\s*[-*]?\s*\*\*Worker:\*\*\s*`?([\w-]+)`?/m.exec(unfenced)?.[1]?.toLowerCase();
+    tasks.push({ step: Number(m[1]), title: m[2].trim(), text: body, ...tier ? { tier } : {} });
+  }
+  return { file, title: titleHeading?.text ?? "", header, constraints, tasks };
+}
+function loadPlan(file) {
+  const abs = path9.resolve(file);
+  if (!fs11.existsSync(abs) || !fs11.statSync(abs).isFile()) throw new UserError(`plan not found: ${file}`);
+  const plan = parsePlan(fs11.readFileSync(abs, "utf8"), fs11.realpathSync(abs));
+  if (!plan.tasks.length) throw new UserError(`${file} has no "Task N" headings (see pitroom-writing-plans)`);
+  return plan;
+}
+function planTask(plan, step) {
+  const t = plan.tasks.find((x) => x.step === step);
+  if (!t) throw new UserError(`no Task ${step} in ${plan.file}; it has ${plan.tasks.map((x) => `Task ${x.step}`).join(", ")}`);
+  return t;
 }
-var esc = (s) => s.replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c]);
-function card(t, period) {
-  const stat = (x, value, label) => `<text x="${x}" y="148" class="v">${esc(value)}</text><text x="${x}" y="170" class="l">${esc(label)}</text>`;
-  return `<svg xmlns="http://www.w3.org/2000/svg" width="600" height="220" viewBox="0 0 600 220" role="img" aria-label="pitroom saved ${esc(usd(t.saved))}">
-<style>
-text{font-family:ui-sans-serif,-apple-system,Segoe UI,Helvetica,Arial,sans-serif;fill:#ede9fe}
-.h{font-size:15px;font-weight:600;fill:#a78bfa;letter-spacing:.08em}
-.big{font-size:54px;font-weight:800;fill:#fff}
-.sub{font-size:15px;fill:#c4b5fd}
-.v{font-size:22px;font-weight:700;fill:#fff}
-.l{font-size:12px;fill:#a78bfa}
-.f{font-size:11px;fill:#8b5cf6}
-</style>
-<defs><linearGradient id="g" x1="0" y1="0" x2="1" y2="1"><stop offset="0" stop-color="#1e1b4b"/><stop offset="1" stop-color="#3b0764"/></linearGradient></defs>
-<rect width="600" height="220" rx="18" fill="url(#g)"/>
-<text x="32" y="42" class="h">PITROOM \xB7 ${esc(period.toUpperCase())}</text>
-<text x="32" y="98" class="big">${esc(usd(t.saved))}</text>
-<text x="${Math.min(60 + usd(t.saved).length * 30, 330)}" y="98" class="sub">saved on my main coding agent</text>
-${stat(32, compact(t.tokens), "tokens offloaded")}
-${stat(200, t.ratio ? `${Math.round(t.ratio)}\xD7` : "\u2014", "context compression")}
-${stat(380, String(t.runs), "delegated tasks")}
-<text x="32" y="202" class="f">estimated vs. ${esc(primaryPrice().name)} pricing \xB7 npx pitroom</text>
-</svg>
+function brief(plan, task) {
+  return `${[
+    `# ${plan.title || planName(plan.file)}`,
+    plan.header,
+    "## Global Constraints",
+    plan.constraints || "(none stated in the plan)",
+    task.text
+  ].filter(Boolean).join("\n\n")}
 `;
 }
+var planName = (file) => path9.basename(file).replace(/\.md$/i, "");
 
 // src/core/report.ts
-var ICON = {
+var ICON2 = {
   queued: "\u22EF",
   running: "\u2026",
   done: "\u2714",
@@ -1475,11 +1991,11 @@ function duration(meta) {
 }
 function readSummary(meta) {
   const f = runFile(meta.id, "summary.md");
-  return fs10.existsSync(f) ? fs10.readFileSync(f, "utf8").trim() : "";
+  return fs12.existsSync(f) ? fs12.readFileSync(f, "utf8").trim() : archivedRun(meta.id)?.answer ?? "";
 }
 function formatReport(meta, finalText = readSummary(meta), maxLines = 400) {
   const out = [];
-  out.push(`pitroom ${ICON[meta.state]} ${meta.state} \xB7 ${meta.mode} \xB7 ${duration(meta)} \xB7 run ${meta.id}`);
+  out.push(`pitroom ${ICON2[meta.state]} ${meta.state} \xB7 ${meta.mode} \xB7 ${duration(meta)} \xB7 run ${meta.id}`);
   const ran = meta.ran ?? meta.worker;
   const ids = [`worker ${ran.backend}`, meta.resolvedModel && `model ${meta.resolvedModel}`, meta.sessionId && `session ${meta.sessionId}`];
   out.push(ids.filter(Boolean).join(" \xB7 "));
@@ -1550,8 +2066,8 @@ function formatReport(meta, finalText = readSummary(meta), maxLines = 400) {
 }
 function live(meta) {
   const f = runFile(meta.id, "events.jsonl");
-  if (!fs10.existsSync(f)) return { steps: 0, toolCalls: 0 };
-  const p = getBackend((meta.ran ?? meta.worker).backend).parse(fs10.readFileSync(f, "utf8"));
+  if (!fs12.existsSync(f)) return { steps: 0, toolCalls: 0 };
+  const p = getBackend((meta.ran ?? meta.worker).backend).parse(fs12.readFileSync(f, "utf8"));
   return { steps: p.usage.steps, toolCalls: p.usage.toolCalls, last: p.lastActivity };
 }
 function progress(meta) {
@@ -1622,22 +2138,30 @@ async function waitMany(ids, opts) {
 }
 async function watch(select, opts) {
   const seen = /* @__PURE__ */ new Map();
-  const emit = (e) => opts.write(`${JSON.stringify(e)}
+  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) {
+    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 base = { run: m.id, mode: m.mode, task: oneLine4(m.task, 60) };
-        if (!prev) emit({ event: m.state === "queued" ? "queued" : "started", ...base });
-        else if (prev.state === "queued" && m.state === "running") emit({ event: "started", ...base });
+        const base2 = { run: m.id, mode: m.mode, task: oneLine4(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: oneLine4(a.error, 120) });
+          emit({ event: "fallback", run: m.id, failed: a.target, reason: oneLine4(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 ? oneLine4(String(l.last), 80) : void 0 });
@@ -1652,7 +2176,7 @@ async function watch(select, opts) {
             error: m.error ? oneLine4(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 });
       }
@@ -1664,7 +2188,7 @@ ${(/* @__PURE__ */ new Date()).toLocaleTimeString()} \xB7 Ctrl-C to stop watchin
     }
     const allDone = metas.length > 0 && metas.every((m) => TERMINAL.includes(m.state));
     if (allDone || metas.length === 0 && seen.size === 0) {
-      if (opts.json) {
+      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 });
       }
@@ -1676,44 +2200,44 @@ ${(/* @__PURE__ */ new Date()).toLocaleTimeString()} \xB7 Ctrl-C to stop watchin
 }
 
 // src/core/install.ts
-import fs11 from "node:fs";
+import fs13 from "node:fs";
 import os7 from "node:os";
-import path9 from "node:path";
+import path10 from "node:path";
 import { fileURLToPath } from "node:url";
 var LEGACY = ["pitroom", "opencode-worker"];
 function packageRoot() {
-  return path9.resolve(path9.dirname(fileURLToPath(import.meta.url)), "..");
+  return path10.resolve(path10.dirname(fileURLToPath(import.meta.url)), "..");
 }
 function skillNames(root = packageRoot()) {
-  const dir = path9.join(root, "skills");
-  if (!fs11.existsSync(dir)) return [];
-  return fs11.readdirSync(dir).filter((d) => fs11.existsSync(path9.join(dir, d, "SKILL.md"))).sort();
+  const dir = path10.join(root, "skills");
+  if (!fs13.existsSync(dir)) return [];
+  return fs13.readdirSync(dir).filter((d) => fs13.existsSync(path10.join(dir, d, "SKILL.md"))).sort();
 }
 function skillTargets() {
   const home2 = os7.homedir();
-  const targets = [path9.join(home2, ".agents", "skills")];
-  if (fs11.existsSync(path9.join(home2, ".claude"))) targets.push(path9.join(home2, ".claude", "skills"));
+  const targets = [path10.join(home2, ".agents", "skills")];
+  if (fs13.existsSync(path10.join(home2, ".claude"))) targets.push(path10.join(home2, ".claude", "skills"));
   return targets;
 }
-var launcherPath = () => path9.join(os7.homedir(), ".local", "bin", "pitroom");
+var launcherPath = () => path10.join(os7.homedir(), ".local", "bin", "pitroom");
 var LAUNCHER_MARK = "# pitroom launcher";
 function launcherScript(bundle) {
   const q = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
   return `#!/bin/sh
 ${LAUNCHER_MARK} (created by \`pitroom install\`; \`pitroom uninstall\` removes it)
 cli=${q(bundle)}
-ok() { [ -n "$1" ] && [ -x "$1" ] && "$1" -e 'process.exit(+process.versions.node.split(".")[0] >= 18 ? 0 : 1)' 2>/dev/null; }
+ok() { [ -n "$1" ] && [ -x "$1" ] && "$1" -e 'const [a,b]=process.versions.node.split(".").map(Number);process.exit(a>22||(a===22&&b>=13)?0:1)' 2>/dev/null; }
 for n in "\${PITROOM_NODE:-}" ${q(process.execPath)} "$(command -v node 2>/dev/null)" "$HOME"/.nvm/versions/node/*/bin/node /opt/homebrew/bin/node /usr/local/bin/node; do
   if ok "$n"; then exec "$n" "$cli" "$@"; fi
 done
-echo "pitroom: needs Node.js 18 or newer (set PITROOM_NODE to its path)" >&2
+echo "pitroom: needs Node.js 22.13 or newer (set PITROOM_NODE to its path)" >&2
 exit 127
 `;
 }
 function isOurLauncher(file, root) {
   if (linksInto(file, root)) return true;
   try {
-    const s = fs11.readFileSync(file, "utf8");
+    const s = fs13.readFileSync(file, "utf8");
     return s.includes(LAUNCHER_MARK) && s.includes(root);
   } catch {
     return false;
@@ -1721,96 +2245,96 @@ function isOurLauncher(file, root) {
 }
 function placeLauncher(bundle, root, force) {
   const dest = launcherPath();
-  fs11.mkdirSync(path9.dirname(dest), { recursive: true });
-  const exists = fs11.lstatSync(dest, { throwIfNoEntry: false });
+  fs13.mkdirSync(path10.dirname(dest), { recursive: true });
+  const exists = fs13.lstatSync(dest, { throwIfNoEntry: false });
   if (exists && !isOurLauncher(dest, root)) {
     if (!force) return `! ${dest} exists and is not Pitroom's launcher; kept (use --force to back it up and replace)`;
-    fs11.renameSync(dest, `${dest}.bak-${Date.now()}`);
+    fs13.renameSync(dest, `${dest}.bak-${Date.now()}`);
   } else if (exists) {
-    fs11.rmSync(dest, { force: true });
+    fs13.rmSync(dest, { force: true });
   }
-  fs11.writeFileSync(dest, launcherScript(bundle), { mode: 493 });
-  return `\u2714 ${dest} \u2192 launcher for ${bundle} (Node 18+)`;
+  fs13.writeFileSync(dest, launcherScript(bundle), { mode: 493 });
+  return `\u2714 ${dest} \u2192 launcher for ${bundle} (Node 22.13+)`;
 }
 function linksInto(link, dir) {
-  const st = fs11.lstatSync(link, { throwIfNoEntry: false });
+  const st = fs13.lstatSync(link, { throwIfNoEntry: false });
   if (!st?.isSymbolicLink()) return false;
-  const target = path9.resolve(path9.dirname(link), fs11.readlinkSync(link));
-  const rel = path9.relative(dir, target);
-  return !rel.startsWith("..") && !path9.isAbsolute(rel);
+  const target = path10.resolve(path10.dirname(link), fs13.readlinkSync(link));
+  const rel = path10.relative(dir, target);
+  return !rel.startsWith("..") && !path10.isAbsolute(rel);
 }
 function place(src, dest, opts) {
-  fs11.mkdirSync(path9.dirname(dest), { recursive: true });
-  const st = fs11.lstatSync(dest, { throwIfNoEntry: false });
+  fs13.mkdirSync(path10.dirname(dest), { recursive: true });
+  const st = fs13.lstatSync(dest, { throwIfNoEntry: false });
   if (st && !st.isSymbolicLink()) {
     if (!opts.force) return `! ${dest} exists and is not a link; kept (use --force to back it up and replace)`;
-    fs11.renameSync(dest, `${dest}.bak-${Date.now()}`);
+    fs13.renameSync(dest, `${dest}.bak-${Date.now()}`);
   } else if (st) {
-    fs11.unlinkSync(dest);
+    fs13.unlinkSync(dest);
   }
-  if (opts.copy) fs11.cpSync(src, dest, { recursive: true });
-  else fs11.symlinkSync(src, dest, process.platform === "win32" ? "junction" : fs11.statSync(src).isDirectory() ? "dir" : "file");
+  if (opts.copy) fs13.cpSync(src, dest, { recursive: true });
+  else fs13.symlinkSync(src, dest, process.platform === "win32" ? "junction" : fs13.statSync(src).isDirectory() ? "dir" : "file");
   return `\u2714 ${dest} \u2192 ${opts.copy ? "copied" : src}`;
 }
 function install(opts) {
   const root = packageRoot();
   const skills = skillNames(root);
-  if (!skills.length) throw new Error(`no skills found under ${path9.join(root, "skills")}`);
+  if (!skills.length) throw new Error(`no skills found under ${path10.join(root, "skills")}`);
   const out = [];
-  for (const base of skillTargets()) {
+  for (const base2 of skillTargets()) {
     for (const legacy of LEGACY) {
-      const l = path9.join(base, legacy);
+      const l = path10.join(base2, legacy);
       if (!skills.includes(legacy) && linksInto(l, root)) {
-        fs11.unlinkSync(l);
+        fs13.unlinkSync(l);
         out.push(`\u2714 removed old link ${l}`);
       }
     }
-    for (const name of skills) out.push(place(path9.join(root, "skills", name), path9.join(base, name), opts));
+    for (const name of skills) out.push(place(path10.join(root, "skills", name), path10.join(base2, name), opts));
   }
-  const bundle = path9.join(root, "dist", "pitroom.mjs");
-  if (fs11.existsSync(bundle)) {
+  const bundle = path10.join(root, "dist", "pitroom.mjs");
+  if (fs13.existsSync(bundle)) {
     out.push(placeLauncher(bundle, root, opts.force));
-    const onPath = (process.env.PATH ?? "").split(path9.delimiter).some((d) => path9.resolve(d) === path9.dirname(launcherPath()));
-    if (!onPath) out.push(`! ${path9.dirname(launcherPath())} is not on PATH; add it, or run ${launcherPath()} directly`);
+    const onPath = (process.env.PATH ?? "").split(path10.delimiter).some((d) => path10.resolve(d) === path10.dirname(launcherPath()));
+    if (!onPath) out.push(`! ${path10.dirname(launcherPath())} is not on PATH; add it, or run ${launcherPath()} directly`);
   }
   return out;
 }
 function uninstall() {
   const root = packageRoot();
   const out = [];
-  for (const base of skillTargets()) {
-    if (!fs11.existsSync(base)) continue;
-    for (const name of fs11.readdirSync(base)) {
-      const l = path9.join(base, name);
+  for (const base2 of skillTargets()) {
+    if (!fs13.existsSync(base2)) continue;
+    for (const name of fs13.readdirSync(base2)) {
+      const l = path10.join(base2, name);
       if (linksInto(l, root)) {
-        fs11.unlinkSync(l);
+        fs13.unlinkSync(l);
         out.push(`\u2714 removed ${l}`);
       }
     }
   }
   if (isOurLauncher(launcherPath(), root)) {
-    fs11.rmSync(launcherPath(), { force: true });
+    fs13.rmSync(launcherPath(), { force: true });
     out.push(`\u2714 removed ${launcherPath()}`);
   }
   return out.length ? out : ["nothing to remove"];
 }
 function installedSkills() {
   const names = skillNames();
-  return skillTargets().map((base) => ({ base, names: names.filter((n) => fs11.existsSync(path9.join(base, n, "SKILL.md"))) }));
+  return skillTargets().map((base2) => ({ base: base2, names: names.filter((n) => fs13.existsSync(path10.join(base2, n, "SKILL.md"))) }));
 }
 
 // src/core/plan-status.ts
 import crypto2 from "node:crypto";
-import fs12 from "node:fs";
-import path10 from "node:path";
+import fs14 from "node:fs";
+import path11 from "node:path";
 function notesFile(plan) {
   const id = crypto2.createHash("sha1").update(plan.file).digest("hex").slice(0, 12);
-  return path10.join(home(), "plans", id, "notes.md");
+  return path11.join(home(), "plans", id, "notes.md");
 }
 function readNotes(plan) {
   const f = notesFile(plan);
-  if (!fs12.existsSync(f)) return [];
-  return fs12.readFileSync(f, "utf8").split("\n").slice(1).filter(Boolean).map((l) => {
+  if (!fs14.existsSync(f)) return [];
+  return fs14.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 };
   });
@@ -1818,11 +2342,11 @@ function readNotes(plan) {
 function addNote(planFile, text) {
   const plan = loadPlan(planFile);
   const f = notesFile(plan);
-  fs12.mkdirSync(path10.dirname(f), { recursive: true });
-  if (!fs12.existsSync(f)) fs12.writeFileSync(f, `# plan: ${plan.file}
+  fs14.mkdirSync(path11.dirname(f), { recursive: true });
+  if (!fs14.existsSync(f)) fs14.writeFileSync(f, `# plan: ${plan.file}
 `);
   const at = (/* @__PURE__ */ new Date()).toISOString().slice(0, 16).replace("T", " ");
-  fs12.appendFileSync(f, `${at} ${text.replace(/\s+/g, " ").trim()}
+  fs14.appendFileSync(f, `${at} ${text.replace(/\s+/g, " ").trim()}
 `);
   return f;
 }
@@ -1890,15 +2414,15 @@ ${rulings}`,
 
 // src/core/review.ts
 import crypto4 from "node:crypto";
-import fs14 from "node:fs";
-import path12 from "node:path";
+import fs16 from "node:fs";
+import path13 from "node:path";
 
 // src/vcs/git.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
 import crypto3 from "node:crypto";
-import fs13 from "node:fs";
+import fs15 from "node:fs";
 import os8 from "node:os";
-import path11 from "node:path";
+import path12 from "node:path";
 var SAFE = [
   "-c",
   "color.ui=false",
@@ -1930,20 +2454,20 @@ function gitAvailable() {
 }
 function repoRoot(dir) {
   const r = git(dir, ["rev-parse", "--show-toplevel"]);
-  return r.code === 0 ? path11.resolve(r.stdout.trim()) : void 0;
+  return r.code === 0 ? path12.resolve(r.stdout.trim()) : void 0;
 }
 function snapshotTree(root, exclude = []) {
-  const tmp = path11.join(os8.tmpdir(), `pitroom-index-${process.pid}-${crypto3.randomBytes(4).toString("hex")}`);
-  const real = path11.resolve(root, must(root, ["rev-parse", "--git-path", "index"]).trim());
+  const tmp = path12.join(os8.tmpdir(), `pitroom-index-${process.pid}-${crypto3.randomBytes(4).toString("hex")}`);
+  const real = path12.resolve(root, must(root, ["rev-parse", "--git-path", "index"]).trim());
   const env = { ...process.env, GIT_INDEX_FILE: tmp };
   try {
-    if (fs13.existsSync(real)) fs13.copyFileSync(real, tmp);
+    if (fs15.existsSync(real)) fs15.copyFileSync(real, tmp);
     else must(root, ["read-tree", "--empty"], env);
     must(root, ["add", "-A", "--", ":/", ...exclude.map((p) => `:(top,exclude)${p}`)], env);
     return must(root, ["write-tree"], env).trim();
   } finally {
-    fs13.rmSync(tmp, { force: true });
-    fs13.rmSync(`${tmp}.lock`, { force: true });
+    fs15.rmSync(tmp, { force: true });
+    fs15.rmSync(`${tmp}.lock`, { force: true });
   }
 }
 var DIFF = ["diff", "--no-ext-diff", "--no-textconv", "--no-renames"];
@@ -1963,27 +2487,27 @@ function diffTrees(root, a, b) {
   return { changes, stats: { files: changes.length, insertions, deletions }, patch };
 }
 function createIsolatedCopy(root, tree, dest) {
-  const objects = path11.join(path11.resolve(root, must(root, ["rev-parse", "--git-common-dir"]).trim()), "objects");
-  fs13.mkdirSync(path11.dirname(dest), { recursive: true });
-  must(path11.dirname(dest), ["init", "--quiet", dest]);
-  fs13.writeFileSync(path11.join(dest, ".git", "objects", "info", "alternates"), `${objects}
+  const objects = path12.join(path12.resolve(root, must(root, ["rev-parse", "--git-common-dir"]).trim()), "objects");
+  fs15.mkdirSync(path12.dirname(dest), { recursive: true });
+  must(path12.dirname(dest), ["init", "--quiet", dest]);
+  fs15.writeFileSync(path12.join(dest, ".git", "objects", "info", "alternates"), `${objects}
 `);
   must(dest, ["read-tree", tree]);
   must(dest, ["checkout-index", "--all", "--force"]);
 }
 function removeIsolatedCopy(dest, ownedBy) {
-  const rel = path11.relative(ownedBy, dest);
-  if (!rel || rel.startsWith("..") || path11.isAbsolute(rel)) throw new Error(`refusing to remove ${dest}`);
-  fs13.rmSync(dest, { recursive: true, force: true });
+  const rel = path12.relative(ownedBy, dest);
+  if (!rel || rel.startsWith("..") || path12.isAbsolute(rel)) throw new Error(`refusing to remove ${dest}`);
+  fs15.rmSync(dest, { recursive: true, force: true });
 }
 function linkIntoWorktree(root, worktree, rels) {
   const linked = [];
   for (const rel of rels) {
-    const src = path11.join(root, rel);
-    const dst = path11.join(worktree, rel);
-    if (!fs13.existsSync(src) || fs13.existsSync(dst)) continue;
-    fs13.mkdirSync(path11.dirname(dst), { recursive: true });
-    fs13.symlinkSync(src, dst, process.platform === "win32" ? "junction" : void 0);
+    const src = path12.join(root, rel);
+    const dst = path12.join(worktree, rel);
+    if (!fs15.existsSync(src) || fs15.existsSync(dst)) continue;
+    fs15.mkdirSync(path12.dirname(dst), { recursive: true });
+    fs15.symlinkSync(src, dst, process.platform === "win32" ? "junction" : void 0);
     linked.push(rel);
   }
   return linked;
@@ -2042,7 +2566,7 @@ function ancestors(m) {
 function briefOf(m) {
   const root = [m, ...ancestors(m)].at(-1);
   const f = runFile(root.id, "brief.md");
-  return fs14.existsSync(f) ? fs14.readFileSync(f, "utf8") : root.task;
+  return fs16.existsSync(f) ? fs16.readFileSync(f, "utf8") : root.task;
 }
 function latestReview(ids) {
   for (const id of listRunIds().reverse()) {
@@ -2056,11 +2580,11 @@ function latestReview(ids) {
 }
 function diffOf(m, from = m.baseTree) {
   const where = m.mode === "isolate" ? m.worktree : m.repoRoot;
-  if (where && fs14.existsSync(where) && from && m.afterTree) return reviewDiff(where, from, m.afterTree);
+  if (where && fs16.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 fs14.readFileSync(runFile(m.id, "changes.patch"), "utf8");
+  return readRunFile(m.id, "changes.patch") ?? archivedRun(m.id)?.patch ?? "";
 }
 function runReview(id) {
   const m = freshMeta(id);
@@ -2070,7 +2594,7 @@ function runReview(id) {
   if (!m.changes?.length) throw new UserError(`run ${m.id} made no changes; nothing to review`);
   const chain = ancestors(m);
   const previous = latestReview(chain.map((a) => a.id));
-  const dir = m.mode === "isolate" && m.worktree && fs14.existsSync(m.worktree) ? m.cwd : m.dir;
+  const dir = m.mode === "isolate" && m.worktree && fs16.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) {
@@ -2134,6 +2658,7 @@ 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;
@@ -2143,15 +2668,15 @@ function pickReviewer(job) {
 function writePackage(job) {
   const g = gitDir(job.dir);
   if (!g) throw new UserError(`not a git repository: ${job.dir}`);
-  const file = path12.join(g, "pitroom", `review-${crypto4.randomBytes(4).toString("hex")}.md`);
-  fs14.mkdirSync(path12.dirname(file), { recursive: true });
-  fs14.writeFileSync(file, job.package);
+  const file = path13.join(g, "pitroom", `review-${crypto4.randomBytes(4).toString("hex")}.md`);
+  fs16.mkdirSync(path13.dirname(file), { recursive: true });
+  fs16.writeFileSync(file, job.package);
   return file;
 }
 
 // src/core/templates.ts
-import fs15 from "node:fs";
-import path13 from "node:path";
+import fs17 from "node:fs";
+import path14 from "node:path";
 var FILES = {
   implementer: "pitroom-driven-development/implementer-prompt.md",
   "task-reviewer": "pitroom-driven-development/task-reviewer-prompt.md",
@@ -2159,9 +2684,9 @@ var FILES = {
   "code-reviewer": "pitroom-review/code-reviewer.md"
 };
 function loadTemplate(name, root = packageRoot()) {
-  const file = path13.join(root, "skills", FILES[name]);
-  if (!fs15.existsSync(file)) throw new UserError(`template missing: ${file} (broken install? run pitroom doctor)`, 3);
-  return fs15.readFileSync(file, "utf8").replace(/^\s*<!--[\s\S]*?-->\s*/, "");
+  const file = path14.join(root, "skills", FILES[name]);
+  if (!fs17.existsSync(file)) throw new UserError(`template missing: ${file} (broken install? run pitroom doctor)`, 3);
+  return fs17.readFileSync(file, "utf8").replace(/^\s*<!--[\s\S]*?-->\s*/, "");
 }
 function fill(template, values) {
   const missing = [...template.matchAll(/\{\{([A-Z_]+)\}\}/g)].map((m) => m[1]).filter((k) => !(k in values));
@@ -2169,122 +2694,425 @@ function fill(template, values) {
   return template.replace(/\{\{([A-Z_]+)\}\}/g, (_, key) => values[key]);
 }
 
-// src/core/ui.ts
-import fs16 from "node:fs";
-var WEEK_MS = 7 * 24 * 3600 * 1e3;
-var RECENT = 40;
-function activeRuns() {
-  const out = [];
-  for (const id of listRunIds().slice(-RECENT)) {
+// 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 {
-      const m = readMeta(id);
-      if (isActive(m.state) && (m.state === "queued" || isAlive(m.pid))) out.push(m);
+      t = parseTarget(spec, "opencode");
     } catch {
+      return;
     }
-  }
+    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 statusLine() {
-  const running = activeRuns();
-  const saved = totals(readLedger(Date.now() - WEEK_MS)).saved;
-  if (!running.length && !saved) return "";
-  const parts = ["\u{1F3C1} pitroom"];
-  if (running.length) {
-    const who = [...new Set(running.map((m) => (m.ran ?? m.worker).backend))].join(", ");
-    parts.push(`${running.length} running (${who})`);
+function modelTable(opts = {}) {
+  const costs = effective().costs.value;
+  const used = usage();
+  const seen = /* @__PURE__ */ new Map();
+  for (const e of readLedger()) {
+    if (!e.backend || !e.model) continue;
+    const key = `${e.backend}:${base(e.model)}`;
+    const a = seen.get(key) ?? { runs: 0, tokens: 0, usd: 0 };
+    seen.set(key, { runs: a.runs + 1, tokens: a.tokens + e.tokens, usd: a.usd + e.workerCost });
+  }
+  const rows = [];
+  const sources = [];
+  let hiddenOpenCode = 0;
+  const known = /* @__PURE__ */ new Set();
+  for (const b of allBackends()) {
+    if (opts.backend && b.id !== opts.backend) continue;
+    const catalog4 = b.catalog?.() ?? { models: [], source: "no model list for this worker" };
+    sources.push(`${b.id}: ${catalog4.source}`);
+    for (const m of catalog4.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);
+    }
   }
-  if (saved) parts.push(`~${usd(saved)} saved this week`);
-  return parts.join(" \xB7 ");
+  for (const [key, labels] of used) {
+    const [worker, ...rest] = key.split(":");
+    if (known.has(key) || opts.backend && worker !== opts.backend) continue;
+    const s = seen.get(key);
+    rows.push({ worker, model: rest.join(":"), cost: costs[key], runs: s?.runs ?? 0, avgTokens: s ? Math.round(s.tokens / s.runs) : void 0, inUse: labels });
+  }
+  rows.sort(
+    (a, b) => a.worker.localeCompare(b.worker) || Number(b.inUse.length > 0) - Number(a.inUse.length > 0) || (a.cost ?? Infinity) - (b.cost ?? Infinity) || b.runs - a.runs || a.model.localeCompare(b.model)
+  );
+  return { rows, sources, hiddenOpenCode };
+}
+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");
 }
-var RUN_ID = /\b\d{8}-\d{6}-[0-9a-f]{4}\b/g;
-var PITROOM_CALL = /(^|[\s;&|(`])(\S*\/)?pitroom(\.mjs)?(\s|$)/;
-var ICON2 = { done: "\u2714", failed: "\u2718", timeout: "\u23F1", stopped: "\u25A0" };
-function kind(m) {
-  if (m.reviewOf) return m.reviewKind === "range" ? "branch review" : m.reviewKind === "fix" ? "re-review" : "review";
-  return m.mode === "read" ? "research" : m.mode === "isolate" ? "change (isolated copy)" : "change";
+
+// src/core/dash.ts
+import { spawn } from "node:child_process";
+import crypto5 from "node:crypto";
+import fs18 from "node:fs";
+import http from "node:http";
+import path15 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// 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_ID2 = /^\d{8}-\d{6}-[0-9a-f]{4}$/;
+var LOCAL_HOST = /^(127\.0\.0\.1|localhost|\[::1\]):\d+$/i;
+var oneLine5 = (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),
+    worker: workerName(m.ran ?? m.worker),
+    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()}` : void 0,
+    changes: m.changes?.length || void 0,
+    applied: m.applied || void 0,
+    note: l?.last ? oneLine5(String(l.last), 140) : isActive(m.state) ? "" : m.verdict ? findings(m) : headline(m, 200) || oneLine5(m.error ?? "", 200)
+  };
 }
-var SUBJECT_MAX = 48;
-function short(text) {
-  const s = text.replace(/`/g, "").replace(/^#+\s*/, "").replace(/\s+/g, " ").trim();
-  if (s.length <= SUBJECT_MAX) return s;
-  const cut = s.slice(0, SUBJECT_MAX);
-  const space = cut.lastIndexOf(" ");
-  return `${(space > SUBJECT_MAX / 2 ? cut.slice(0, space) : cut).replace(/[\s,.;:·-]+$/, "")}\u2026`;
+function dashState(opts = {}) {
+  const limit = Math.min(Math.max(opts.limit ?? 40, 1), 200);
+  const runs = [];
+  const groups = /* @__PURE__ */ new Set();
+  for (const id of listRunIds().slice(-SCAN).reverse()) {
+    let m;
+    try {
+      m = freshMeta(id);
+    } catch {
+      continue;
+    }
+    if (m.group) groups.add(m.group);
+    if (opts.group && m.group !== opts.group) continue;
+    if (runs.length < limit) runs.push(toRun(m));
+  }
+  return {
+    running: runs.filter((r) => r.state === "running" || r.state === "queued").length,
+    saved: totals(readLedger(Date.now() - WEEK_MS2)).saved,
+    groups: [...groups].sort(),
+    runs
+  };
 }
-var MODEL_MAX = 24;
-function workerName(t) {
-  if (!t.model) return t.backend;
-  const model = (t.model.split("/").pop() ?? t.model).replace(/-(contributor-)?free$/, "").replace(/-\d+\.\d+$/, "");
-  return `${t.backend} (${model.length > MODEL_MAX ? `${model.slice(0, MODEL_MAX - 1)}\u2026` : model})`;
+var TASK_MAX = 6e3;
+var PATCH_LINES = 300;
+function readFile(id, name) {
+  const f = runFile(id, name);
+  return fs18.existsSync(f) ? fs18.readFileSync(f, "utf8") : "";
 }
-function what(m) {
-  if (m.plan) return short(`Task ${m.plan.step}: ${m.plan.title}`);
-  if (m.reviewOf) return `of ${m.reviewOf}`;
-  const line = m.task.split("\n").find((l) => l.trim()) ?? "";
-  const brief2 = /^You are implementing Task (\d+)\b.*?\bplan\s+(\S+)/i.exec(line);
-  if (brief2) return short(`Task ${brief2[1]} \xB7 ${brief2[2].split("/").pop().replace(/\.md\W*$/, "")}`);
-  return short(line);
+function runDetail(id) {
+  if (!RUN_ID2.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 patch = kept?.patch ?? readFile(id, "changes.patch");
+  const patchLines = patch.split("\n");
+  const u = m.usage;
+  return {
+    id,
+    state: m.state,
+    task: (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 ?? [],
+    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,
+    report: isActive(m.state) ? progress(m) : formatReport(m, void 0, 120)
+  };
 }
-function duration2(m) {
-  const s = Math.round((Date.parse(m.endedAt ?? "") - Date.parse(m.startedAt)) / 1e3);
-  if (!Number.isFinite(s) || s < 0) return "";
-  return s >= 60 ? `${Math.floor(s / 60)}m${String(s % 60).padStart(2, "0")}s` : `${s}s`;
+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-${crypto5.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 = () => fileURLToPath2(new URL("./ui/", import.meta.url));
+var assetCache = /* @__PURE__ */ new Map();
+function readAsset(route) {
+  const hit = assetCache.get(route);
+  if (hit) return hit;
+  try {
+    const data = fs18.readFileSync(path15.join(assetsDir(), path15.basename(route)));
+    assetCache.set(route, data);
+    return data;
+  } catch {
+    return void 0;
+  }
 }
-function cardsFor(m) {
-  const phases = [
-    ["started", () => `\u{1F3C1} Pitroom \u25B6 ${kind(m)} on ${workerName(m.worker)} \xB7 ${what(m)}  (${m.id})`]
-  ];
-  if (!isActive(m.state)) {
-    phases.push([
-      "ended",
-      () => {
-        const v = m.verdict;
-        const bits = [
-          `\u{1F3C1} Pitroom ${ICON2[m.state] ?? "\u2022"} ${kind(m)} ${m.state} on ${workerName(m.ran ?? m.worker)}`,
-          what(m),
-          duration2(m),
-          v && `SPEC ${v.spec.toUpperCase()} \xB7 QUALITY ${v.quality.toUpperCase()}`,
-          m.changes?.length ? `${m.changes.length} file${m.changes.length === 1 ? "" : "s"} changed` : "",
-          m.savedUsd ? `~${usd(m.savedUsd)} saved` : ""
-        ];
-        return `${bits.filter(Boolean).join(" \xB7 ")}  (${m.id})`;
+function handler(touch) {
+  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) => {
+    touch();
+    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);
+    }
+    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_ID2.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));
+    }
+    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 = () => path15.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;
   }
-  if (m.applied) {
-    phases.push(["applied", () => `\u{1F3C1} Pitroom \u2935 applied ${m.changes?.length ?? 0} file(s) from ${m.id} to your tree`]);
+}
+async function runningDash() {
+  try {
+    const r = JSON.parse(fs18.readFileSync(registryFile(), "utf8"));
+    if (isAlive(r.pid) && await ping(r.port)) return { ...r, url: `http://127.0.0.1:${r.port}/` };
+  } catch {
   }
-  const out = [];
-  for (const [phase, text] of phases) {
-    const marker = runFile(m.id, `card-${phase}`);
-    if (fs16.existsSync(marker)) continue;
-    if (!(phase === "started" && !isActive(m.state))) out.push(text());
-    fs16.writeFileSync(marker, "");
+  fs18.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 {
+    spawn(cmd, args, { stdio: "ignore", detached: true }).on("error", () => void 0).unref();
+  } catch {
   }
-  return out;
 }
-function hookCards(input) {
-  const event = JSON.parse(input);
-  const command = event.tool_input?.command ?? "";
-  if (event.tool_name !== "Bash" || !PITROOM_CALL.test(command)) return "";
-  const response = event.tool_response;
-  const output = typeof response === "string" ? response : [response?.stdout, response?.stderr].filter(Boolean).join("\n");
-  const ids = [...new Set(`${command}
-${output}`.match(RUN_ID) ?? [])].filter((id) => fs16.existsSync(`${runsDir()}/${id}`));
-  const cards = [];
-  for (const id of ids) {
-    try {
-      cards.push(...cardsFor(readMeta(id)));
-    } 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");
+    fs18.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 = spawn(process.execPath, [process.argv[1], "dash", "--serve", ...o.port !== void 0 ? ["--port", String(o.port)] : [], "--idle", "4h"], {
+      detached: true,
+      stdio: "ignore",
+      env: process.env
+    });
+    child.on("error", () => void 0);
+    child.unref();
+    for (let i = 0; i < 60; i++) {
+      await new Promise((r2) => setTimeout(r2, 100));
+      const r = await runningDash();
+      if (r && r.pid === child.pid) {
+        o.log(r.url);
+        if (o.open) openBrowser(r.url);
+        return 0;
+      }
     }
+    throw new UserError("pitroom dash did not start (is the port taken? try --port 0)");
   }
-  return cards.join("\n");
+  importRuns();
+  const explicit = o.port !== void 0;
+  let dash;
+  try {
+    dash = await startDash({ port: o.port ?? DEFAULT_PORT, idleMs: o.idleMs });
+  } catch (e) {
+    if (explicit || e.code !== "EADDRINUSE") throw new UserError(`pitroom dash: ${e.message}`);
+    dash = await startDash({ port: 0, idleMs: o.idleMs });
+  }
+  fs18.mkdirSync(home(), { recursive: true });
+  fs18.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(fs18.readFileSync(registryFile(), "utf8")).pid === process.pid) fs18.rmSync(registryFile(), { force: true });
+  } catch {
+  }
+  return 0;
 }
 
 // src/core/run.ts
-import { spawn as spawn2, spawnSync as spawnSync5 } from "node:child_process";
-import fs21 from "node:fs";
-import path17 from "node:path";
+import { spawn as spawn3, spawnSync as spawnSync5 } from "node:child_process";
+import fs23 from "node:fs";
+import path19 from "node:path";
 
 // src/core/chain.ts
 function resolveChain(flags = {}) {
@@ -2297,10 +3125,28 @@ function resolveChain(flags = {}) {
   }
   const eff = effective({ worker: spec, model: flags.model });
   const models = eff.models.value;
-  const withDefault = (t) => t.model || !models[t.backend] ? t : { ...t, model: models[t.backend] };
+  const withDefault = (t) => {
+    const pinned = models[t.backend];
+    if (!pinned) return t;
+    if (!t.model) return { ...t, model: pinned };
+    return t.model.startsWith("#") ? { ...t, model: `${pinned}${t.model}` } : t;
+  };
   let worker = parseTarget(eff.worker.value, DEFAULT_BACKEND);
   if (eff.model.value) worker = { ...worker, model: eff.model.value };
   worker = withDefault(worker);
+  if (flags.effort) {
+    const base2 = (worker.model ?? "").split("#")[0];
+    if (worker.backend === "opencode" && !base2) {
+      warnings.push("--effort needs a model for OpenCode (provider/model#variant): set one in the config or pass -m; ignored");
+    } else {
+      worker = { ...worker, model: `${base2}#${flags.effort}` };
+    }
+  }
+  if ((worker.backend === "codex" || worker.backend === "claude") && !(worker.model ?? "").replace(/#.*$/, "")) {
+    warnings.push(
+      `${worker.backend} has no pinned model, so it runs its own default (which can change and cost more): set "models": {"${worker.backend}": "<model>"} in the pitroom config, or pass -W ${worker.backend}:<model>`
+    );
+  }
   const fallback = [];
   if (!flags.noFallback) {
     for (const s of eff.fallback.value) {
@@ -2317,12 +3163,12 @@ function resolveChain(flags = {}) {
 }
 
 // src/core/process.ts
-import { spawn } from "node:child_process";
-import fs18 from "node:fs";
+import { spawn as spawn2 } from "node:child_process";
+import fs20 from "node:fs";
 
 // src/vcs/guard.ts
-import fs17 from "node:fs";
-import path14 from "node:path";
+import fs19 from "node:fs";
+import path16 from "node:path";
 var VERSION = 1;
 var SHIM = `#!/bin/sh
 # pitroom git guard v${VERSION}. Blocks git commands that change history, refs, the
@@ -2397,15 +3243,15 @@ esac
 exec "$real" "$@"
 `;
 function shimDir() {
-  return path14.join(home(), "shim", `v${VERSION}`);
+  return path16.join(home(), "shim", `v${VERSION}`);
 }
 function findRealGit(skip) {
-  for (const dir of (process.env.PATH ?? "").split(path14.delimiter).filter(Boolean)) {
-    if (path14.resolve(dir) === skip) continue;
-    const p = path14.join(dir, "git");
+  for (const dir of (process.env.PATH ?? "").split(path16.delimiter).filter(Boolean)) {
+    if (path16.resolve(dir) === skip) continue;
+    const p = path16.join(dir, "git");
     try {
-      fs17.accessSync(p, fs17.constants.X_OK);
-      if (fs17.statSync(p).isFile()) return p;
+      fs19.accessSync(p, fs19.constants.X_OK);
+      if (fs19.statSync(p).isFile()) return p;
     } catch {
     }
   }
@@ -2418,13 +3264,13 @@ var REF_HOOK = `#!/bin/sh
 echo "pitroom: git ref updates (commit, reset, branch, tag, stash, rebase, merge) are blocked for workers" >&2
 exit 1
 `;
-var hooksDir = () => path14.join(home(), "git-hooks", `v${HOOK_VERSION}`);
+var hooksDir = () => path16.join(home(), "git-hooks", `v${HOOK_VERSION}`);
 function writeIfChanged(file, content) {
-  if (fs17.existsSync(file) && fs17.readFileSync(file, "utf8") === content) return;
-  fs17.mkdirSync(path14.dirname(file), { recursive: true });
+  if (fs19.existsSync(file) && fs19.readFileSync(file, "utf8") === content) return;
+  fs19.mkdirSync(path16.dirname(file), { recursive: true });
   const tmp = `${file}.${process.pid}.tmp`;
-  fs17.writeFileSync(tmp, content, { mode: 493 });
-  fs17.renameSync(tmp, file);
+  fs19.writeFileSync(tmp, content, { mode: 493 });
+  fs19.renameSync(tmp, file);
 }
 function withGitConfig(env, entries) {
   const out = { ...env };
@@ -2446,7 +3292,7 @@ function guardEnv(env) {
     PAGER: "cat"
   };
   if (process.platform === "win32") return { ...env, ...quiet };
-  writeIfChanged(path14.join(hooksDir(), "reference-transaction"), REF_HOOK);
+  writeIfChanged(path16.join(hooksDir(), "reference-transaction"), REF_HOOK);
   env = withGitConfig(env, [
     ["core.hooksPath", hooksDir()],
     ["url.pitroom-push-blocked://.pushInsteadOf", ""]
@@ -2454,16 +3300,16 @@ function guardEnv(env) {
   const dir = shimDir();
   const real = findRealGit(dir);
   if (!real) return { ...env, ...quiet };
-  writeIfChanged(path14.join(dir, "git"), SHIM);
-  return { ...env, ...quiet, PITROOM_REAL_GIT: real, PATH: `${dir}${path14.delimiter}${env.PATH ?? ""}` };
+  writeIfChanged(path16.join(dir, "git"), SHIM);
+  return { ...env, ...quiet, PITROOM_REAL_GIT: real, PATH: `${dir}${path16.delimiter}${env.PATH ?? ""}` };
 }
 
 // src/core/process.ts
 async function spawnWorker(inv, opts) {
-  const out = fs18.openSync(opts.stdoutFile, "w");
-  const err = fs18.openSync(opts.stderrFile, "w");
+  const out = fs20.openSync(opts.stdoutFile, "w");
+  const err = fs20.openSync(opts.stderrFile, "w");
   const res = { code: null, timedOut: false, stopped: false };
-  const child = spawn(inv.command, inv.args, {
+  const child = spawn2(inv.command, inv.args, {
     cwd: opts.cwd,
     stdio: ["ignore", out, err],
     // OpenCode v2 takes its workspace from $PWD, not the process cwd: without this a worker
@@ -2493,8 +3339,8 @@ async function spawnWorker(inv, opts) {
   if (killer) clearTimeout(killer);
   process.off("SIGINT", stop);
   process.off("SIGTERM", stop);
-  fs18.closeSync(out);
-  fs18.closeSync(err);
+  fs20.closeSync(out);
+  fs20.closeSync(err);
   return res;
 }
 
@@ -2519,11 +3365,11 @@ function parseVerdict(text) {
 }
 
 // src/core/slots.ts
-import crypto5 from "node:crypto";
-import fs19 from "node:fs";
-import path15 from "node:path";
-var slotsDir = () => path15.join(home(), "slots");
-var locksDir = () => path15.join(home(), "locks");
+import crypto6 from "node:crypto";
+import fs21 from "node:fs";
+import path17 from "node:path";
+var slotsDir = () => path17.join(home(), "slots");
+var locksDir = () => path17.join(home(), "locks");
 var STARTUP_GRACE_MS = 3e4;
 function holderActive(runId, self) {
   if (!runId || runId === self) return false;
@@ -2537,23 +3383,23 @@ function holderActive(runId, self) {
   }
 }
 function tryClaim(file, runId) {
-  fs19.mkdirSync(path15.dirname(file), { recursive: true });
+  fs21.mkdirSync(path17.dirname(file), { recursive: true });
   try {
-    fs19.writeFileSync(file, runId, { flag: "wx" });
+    fs21.writeFileSync(file, runId, { flag: "wx" });
     return true;
   } catch (e) {
     if (e.code !== "EEXIST") throw e;
   }
   let owner = "";
   try {
-    owner = fs19.readFileSync(file, "utf8").trim();
+    owner = fs21.readFileSync(file, "utf8").trim();
   } catch {
   }
   if (owner === runId) return true;
   if (holderActive(owner, runId)) return false;
-  fs19.rmSync(file, { force: true });
+  fs21.rmSync(file, { force: true });
   try {
-    fs19.writeFileSync(file, runId, { flag: "wx" });
+    fs21.writeFileSync(file, runId, { flag: "wx" });
     return true;
   } catch {
     return false;
@@ -2562,25 +3408,25 @@ function tryClaim(file, runId) {
 function releaseIfOwner(file, runId) {
   if (!file) return;
   try {
-    if (fs19.readFileSync(file, "utf8").trim() === runId) fs19.rmSync(file, { force: true });
+    if (fs21.readFileSync(file, "utf8").trim() === runId) fs21.rmSync(file, { force: true });
   } catch {
   }
 }
 function tryAcquireSlot(runId, maxParallel) {
   for (let n = 0; n < Math.max(1, maxParallel); n++) {
-    const file = path15.join(slotsDir(), `slot-${n}`);
+    const file = path17.join(slotsDir(), `slot-${n}`);
     if (tryClaim(file, runId)) return file;
   }
   return void 0;
 }
 var releaseSlot = (file, runId) => releaseIfOwner(file, runId);
-var lockFile = (repoRoot2) => path15.join(locksDir(), `write-${crypto5.createHash("sha1").update(path15.resolve(repoRoot2)).digest("hex").slice(0, 16)}`);
+var lockFile = (repoRoot2) => path17.join(locksDir(), `write-${crypto6.createHash("sha1").update(path17.resolve(repoRoot2)).digest("hex").slice(0, 16)}`);
 function acquireWriteLock(repoRoot2, runId) {
   const file = lockFile(repoRoot2);
   if (tryClaim(file, runId)) return;
   let owner = "";
   try {
-    owner = fs19.readFileSync(file, "utf8").trim();
+    owner = fs21.readFileSync(file, "utf8").trim();
   } catch {
   }
   throw new UserError(`another --write run (${owner}) is active in this repo; use --isolate for parallel changes`, 3);
@@ -2627,8 +3473,8 @@ ${task}`;
 }
 
 // src/core/refs.ts
-import fs20 from "node:fs";
-import path16 from "node:path";
+import fs22 from "node:fs";
+import path18 from "node:path";
 var EXTENSIONLESS = "Makefile|Dockerfile|Containerfile|Gemfile|Rakefile|Procfile|Justfile|Vagrantfile|BUILD|WORKSPACE";
 var REF = new RegExp(
   String.raw`(?<![\w/:.-])(\.{0,2}/?(?:[\w@.+-]+/)*(?:[\w@+-][\w@.+-]*\.[A-Za-z][A-Za-z0-9]{0,7}|${EXTENSIONLESS})):(\d+)(?:[-–](\d+))?`,
@@ -2674,13 +3520,13 @@ function extractRefs(answer) {
   return [...seen.values()];
 }
 function verifyRefs(refs, dirs) {
-  const roots = [...new Set(dirs.filter(Boolean).map((d) => path16.resolve(d)))];
+  const roots = [...new Set(dirs.filter(Boolean).map((d) => path18.resolve(d)))];
   const invalid = [];
   const lineCache = /* @__PURE__ */ new Map();
   const load = (file) => {
     if (!lineCache.has(file)) {
-      const size = fs20.statSync(file).size;
-      const lines = size > MAX_BYTES ? null : fs20.readFileSync(file, "utf8").split("\n");
+      const size = fs22.statSync(file).size;
+      const lines = size > MAX_BYTES ? null : fs22.readFileSync(file, "utf8").split("\n");
       if (lines && lines[lines.length - 1] === "") lines.pop();
       lineCache.set(file, lines);
     }
@@ -2689,7 +3535,7 @@ function verifyRefs(refs, dirs) {
   for (const ref of refs) {
     const file = resolve(ref.file, roots);
     if (!file) {
-      invalid.push({ ref: ref.text, reason: path16.isAbsolute(ref.file) && !inside(ref.file, roots) ? "outside the project" : "file not found" });
+      invalid.push({ ref: ref.text, reason: path18.isAbsolute(ref.file) && !inside(ref.file, roots) ? "outside the project" : "file not found" });
       continue;
     }
     const lines = load(file);
@@ -2716,10 +3562,10 @@ function enclosedBy(lines, ref) {
   return lines.slice(Math.max(0, ref.start - 1 - DEFINITION_LOOKBACK), ref.start).some((l) => def.test(l));
 }
 function resolve(ref, roots) {
-  const candidates = path16.isAbsolute(ref) ? inside(ref, roots) ? [ref] : [] : roots.map((r) => path16.join(r, ref));
+  const candidates = path18.isAbsolute(ref) ? inside(ref, roots) ? [ref] : [] : roots.map((r) => path18.join(r, ref));
   return candidates.find((c) => {
     try {
-      return fs20.statSync(c).isFile() && inside(c, roots);
+      return fs22.statSync(c).isFile() && inside(c, roots);
     } catch {
       return false;
     }
@@ -2727,14 +3573,14 @@ function resolve(ref, roots) {
 }
 function inside(file, roots) {
   return roots.some((r) => {
-    const rel = path16.relative(r, path16.resolve(file));
-    return rel !== "" && !rel.startsWith("..") && !path16.isAbsolute(rel);
+    const rel = path18.relative(r, path18.resolve(file));
+    return rel !== "" && !rel.startsWith("..") && !path18.isAbsolute(rel);
   });
 }
 var escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 
 // src/core/run.ts
-var VERSION2 = true ? "0.6.4" : "0.0.0-dev";
+var VERSION2 = true ? "0.6.6" : "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");
@@ -2764,16 +3610,16 @@ function prepareRun(o) {
   let fallback;
   if (o.continueFrom) {
     parent = readMeta(o.continueFrom);
-    if (o.worker || o.tier) throw new UserError("a follow-up runs on the same worker as its parent; drop --worker/--tier");
+    if (o.worker || o.tier || o.effort) throw new UserError("a follow-up runs on the same worker as its parent; drop --worker/--tier/--effort");
     if (!parent.sessionId) throw new UserError(`run ${parent.id} has no worker session to continue`, 3);
-    if (parent.mode === "isolate" && (!parent.worktree || !fs21.existsSync(parent.worktree))) {
+    if (parent.mode === "isolate" && (!parent.worktree || !fs23.existsSync(parent.worktree))) {
       throw new UserError(`the isolated copy of run ${parent.id} is gone (applied or discarded)`, 3);
     }
     const ran = parent.ran ?? parent.worker;
     worker = o.model ? { ...ran, model: o.model } : ran;
     fallback = o.noFallback ? [] : parent.fallback.filter((t) => t.backend === ran.backend);
   } else {
-    const chain = resolveChain({ worker: o.worker, model: o.model, tier: work.tier, noFallback: o.noFallback });
+    const chain = resolveChain({ worker: o.worker, model: o.model, tier: work.tier, effort: o.effort, noFallback: o.noFallback });
     ({ worker, fallback } = chain);
     warnings.push(...chain.warnings);
   }
@@ -2785,15 +3631,15 @@ function prepareRun(o) {
     throw new UserError(`the ${backend.name} worker cannot attach files; put the content in the task`);
   }
   const mode = parent?.mode ?? o.mode;
-  const dir = path17.resolve(parent?.dir ?? o.dir);
-  if (!fs21.existsSync(dir) || !fs21.statSync(dir).isDirectory()) throw new UserError(`not a directory: ${dir}`);
+  const dir = path19.resolve(parent?.dir ?? o.dir);
+  if (!fs23.existsSync(dir) || !fs23.statSync(dir).isDirectory()) throw new UserError(`not a directory: ${dir}`);
   const root = repoRoot(dir);
   if (mode === "isolate" && !root) throw new UserError("--isolate needs a git repository", 3);
   if (mode === "write" && !root && !o.allowNonGit) {
     throw new UserError("--write outside a git repo cannot be tracked or reverted; pass --allow-non-git to accept that", 3);
   }
-  const files = o.files.map((f) => path17.resolve(f));
-  for (const f of files) if (!fs21.existsSync(f)) throw new UserError(`file not found: ${f}`);
+  const files = o.files.map((f) => path19.resolve(f));
+  for (const f of files) if (!fs23.existsSync(f)) throw new UserError(`file not found: ${f}`);
   const meta = {
     id: newRunId(),
     version: VERSION2,
@@ -2828,13 +3674,13 @@ function prepareRun(o) {
     try {
       acquireWriteLock(root, meta.id);
     } catch (e) {
-      fs21.rmSync(runDir(meta.id), { recursive: true, force: true });
+      fs23.rmSync(runDir(meta.id), { recursive: true, force: true });
       throw e;
     }
   }
-  fs21.writeFileSync(runFile(meta.id, "task.md"), `${meta.task}
+  fs23.writeFileSync(runFile(meta.id, "task.md"), `${meta.task}
 `);
-  if (work.brief) fs21.writeFileSync(runFile(meta.id, "brief.md"), work.brief);
+  if (work.brief) fs23.writeFileSync(runFile(meta.id, "brief.md"), work.brief);
   return meta;
 }
 var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -2862,7 +3708,7 @@ async function waitForSlot(meta) {
 function startInBackground(meta) {
   const script = process.argv[1];
   if (!script) throw new Error("cannot locate the pitroom executable");
-  const child = spawn2(process.execPath, [script, "__exec", meta.id], {
+  const child = spawn3(process.execPath, [script, "__exec", meta.id], {
     detached: true,
     stdio: "ignore",
     cwd: meta.dir,
@@ -2907,7 +3753,7 @@ async function execute(meta) {
       (meta.attempts ??= []).push({ target: describeTarget(target), error: why.message });
       for (const f of ["events.jsonl", "stderr.log"]) {
         const from = runFile(meta.id, f);
-        if (fs21.existsSync(from)) fs21.renameSync(from, runFile(meta.id, f.replace(".", `.attempt-${i + 1}.`)));
+        if (fs23.existsSync(from)) fs23.renameSync(from, runFile(meta.id, f.replace(".", `.attempt-${i + 1}.`)));
       }
       writeMeta(meta);
     }
@@ -2927,9 +3773,9 @@ function prepareTree(meta) {
   if (root && meta.mode === "write") meta.baseTree = snapshotTree(root);
   if (root && meta.mode === "isolate" && !meta.worktree) {
     meta.baseTree = snapshotTree(root);
-    meta.worktree = path17.join(worktreesDir(), meta.id);
+    meta.worktree = path19.join(worktreesDir(), meta.id);
     createIsolatedCopy(root, meta.baseTree, meta.worktree);
-    meta.cwd = path17.join(meta.worktree, path17.relative(root, meta.dir));
+    meta.cwd = path19.join(meta.worktree, path19.relative(root, meta.dir));
     const linked = linkIntoWorktree(root, meta.worktree, meta.link);
     if (linked.length) meta.warnings.push(`linked into the isolated copy (shared with your tree): ${linked.join(", ")}`);
   }
@@ -2952,7 +3798,7 @@ function attempt(meta, backend, target) {
     timeoutSec: meta.timeoutSec
   });
 }
-var read = (f) => fs21.existsSync(f) ? fs21.readFileSync(f, "utf8") : "";
+var read = (f) => fs23.existsSync(f) ? fs23.readFileSync(f, "utf8") : "";
 function retryableFailure(meta, backend, res) {
   const run = backend.parse(read(runFile(meta.id, "events.jsonl")));
   if (run.usage.steps > 0) return void 0;
@@ -2971,12 +3817,12 @@ function finalize(meta, res) {
   const run = backend.parse(read(runFile(meta.id, "events.jsonl")));
   meta.sessionId = run.sessionId ?? meta.sessionId;
   meta.usage = run.usage;
-  fs21.writeFileSync(runFile(meta.id, "summary.md"), `${run.finalText}
+  fs23.writeFileSync(runFile(meta.id, "summary.md"), `${run.finalText}
 `);
   if (meta.plan && !meta.reviewOf) meta.taskStatus = parseStatus(run.finalText);
   if (meta.reviewOf) {
     meta.verdict = parseVerdict(run.finalText);
-    if (meta.packageFile) fs21.rmSync(meta.packageFile, { force: true });
+    if (meta.packageFile) fs23.rmSync(meta.packageFile, { force: true });
   }
   if (!res.timedOut && !res.stopped && !meta.error) {
     const f = backend.failure(run, read(runFile(meta.id, "stderr.log")), res.code);
@@ -3018,7 +3864,7 @@ function captureChanges(meta) {
   const d = diffTrees(target, meta.baseTree, meta.afterTree);
   meta.changes = d.changes;
   meta.stats = d.stats;
-  fs21.writeFileSync(runFile(meta.id, "changes.patch"), d.patch);
+  fs23.writeFileSync(runFile(meta.id, "changes.patch"), d.patch);
 }
 function runVerify(meta) {
   const r = spawnSync5(meta.verify, {
@@ -3031,7 +3877,7 @@ function runVerify(meta) {
     env: { ...process.env, PWD: meta.cwd, PITROOM_ACTIVE: "1" }
   });
   const output = `${r.stdout ?? ""}${r.stderr ?? ""}`;
-  fs21.writeFileSync(runFile(meta.id, "verify.log"), output);
+  fs23.writeFileSync(runFile(meta.id, "verify.log"), output);
   return { ok: r.status === 0, code: r.status, tail: output.trimEnd().split("\n").slice(-25).join("\n") };
 }
 function applyRun(meta, allowDelete = false) {
@@ -3076,7 +3922,7 @@ function discardRun(meta) {
   return `discarded the isolated copy of ${meta.id}; the patch stays in ${runFile(meta.id, "changes.patch")}`;
 }
 function cleanupWorktree(meta) {
-  if (meta.worktree && fs21.existsSync(meta.worktree)) removeIsolatedCopy(meta.worktree, worktreesDir());
+  if (meta.worktree && fs23.existsSync(meta.worktree)) removeIsolatedCopy(meta.worktree, worktreesDir());
 }
 
 // src/cli/commands.ts
@@ -3117,7 +3963,7 @@ async function cmdReview(p) {
       group: flag(p, "group") ?? job.group,
       review: { of: job.of, kind: job.kind, packageFile, plan: job.plan }
     });
-    const automatic = !range && !flag(p, "worker") && !flag(p, "tier");
+    const automatic = !range && !flag(p, "worker") && !flag(p, "tier") && !effective().tiers.value.review;
     if (automatic && job.implementer && meta.worker.backend === job.implementer.backend) {
       meta.warnings.push(
         `reviewer runs on the same backend as the implementer (${job.implementer.backend}); configure tiers "standard" or "capable" for a second model`
@@ -3125,10 +3971,10 @@ async function cmdReview(p) {
       writeMeta(meta);
     }
   } catch (e) {
-    fs22.rmSync(packageFile, { force: true });
+    fs24.rmSync(packageFile, { force: true });
     throw e;
   }
-  fs22.writeFileSync(runFile(meta.id, "package.md"), job.package);
+  fs24.writeFileSync(runFile(meta.id, "package.md"), job.package);
   return launch(p, meta);
 }
 function cmdPlan(p) {
@@ -3148,7 +3994,7 @@ function cmdPlan(p) {
 }
 function cmdCrew(p) {
   const file = flag(p, "task-file");
-  const tasks = (file ? fs22.readFileSync(file, "utf8").split(/^\s*---\s*$/m) : p.positional).map((t) => t.trim()).filter(Boolean);
+  const tasks = (file ? fs24.readFileSync(file, "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)");
@@ -3216,8 +4062,10 @@ async function cmdWatch(p) {
     console.log(group ? `no runs in group "${group}"` : "nothing is running");
     return 0;
   }
+  const brief2 = has(p, "brief");
   const { metas, timedOut } = await watch(group ? () => groupIds(group) : () => initial, {
-    json: has(p, "json") || !process.stdout.isTTY,
+    json: !brief2 && (has(p, "json") || !process.stdout.isTTY),
+    brief: brief2,
     intervalMs: parseDuration(flag(p, "interval") ?? "2") * 1e3,
     timeoutMs: flag(p, "timeout") ? parseDuration(flag(p, "timeout")) * 1e3 : 0,
     write: (s) => process.stdout.write(s)
@@ -3225,11 +4073,62 @@ async function cmdWatch(p) {
   if (timedOut) return 75;
   return metas.some((m) => m.state !== "done") ? 1 : 0;
 }
+async function cmdDash(p) {
+  const port = flag(p, "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)");
+  return dashCommand({
+    port: port === void 0 ? void 0 : Number(port),
+    idleMs: flag(p, "idle") ? parseDuration(flag(p, "idle")) * 1e3 : void 0,
+    detach: has(p, "detach"),
+    stop: has(p, "stop"),
+    open: has(p, "open"),
+    serve: has(p, "serve"),
+    log: (s) => console.log(s)
+  });
+}
+var when = (iso) => new Date(iso).toLocaleString([], { month: "short", day: "numeric", hour: "2-digit", minute: "2-digit" });
+var secs = (s) => s == null ? "-" : s >= 3600 ? `${Math.floor(s / 3600)}h${String(Math.floor(s % 3600 / 60)).padStart(2, "0")}m` : s >= 60 ? `${Math.floor(s / 60)}m${String(Math.round(s % 60)).padStart(2, "0")}s` : `${Math.round(s)}s`;
+function cmdHistory(p) {
+  if (!openDb()) throw new UserError("the history needs Node.js 22.13+ (node:sqlite)", 3);
+  const sub = p.positional[0];
+  if (sub === "import") {
+    const r = importRuns();
+    console.log(`imported ${r.imported} run(s); ${r.known} were already in the history (${historyFile()})`);
+    return 0;
+  }
+  importRuns();
+  const since = sinceMs(flag(p, "since"));
+  if (sub === "stats") {
+    const s = historyStats(since);
+    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`);
+    const rows2 = s.byWorker.map((w) => [`${w.backend}${w.model ? `:${w.model}` : ""}`, String(w.runs), `${Math.round(100 * w.ok / w.runs)}%`, secs(w.avgSeconds), w.avgTokens ? `${Math.round(w.avgTokens / 1e3)}k` : "-", `~${usd(w.saved)}`]);
+    const head2 = ["WORKER", "RUNS", "OK", "AVG TIME", "AVG TOKENS", "SAVED"];
+    const widths2 = head2.map((h, i) => Math.max(h.length, ...rows2.map((r) => r[i].length)));
+    const fmt2 = (r) => r.map((c, i) => i === 0 ? c.padEnd(widths2[i]) : c.padStart(widths2[i])).join("  ");
+    if (rows2.length) console.log(`
+${[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 });
+  if (has(p, "json")) return console.log(JSON.stringify({ total, rows }, null, 2)), 0;
+  if (!rows.length) return console.log(total ? "nothing on this page" : "no matching runs"), 0;
+  const body = rows.map((r) => [r.id, when(r.startedAt), r.state, `${r.backend}${r.model ? ` (${r.model.split("/").pop()})` : ""}`, secs(r.seconds), r.task.length > 60 ? `${r.task.slice(0, 59)}\u2026` : r.task]);
+  const head = ["RUN", "WHEN", "STATE", "WORKER", "TIME", "TASK"];
+  const widths = head.map((h, i) => Math.max(h.length, ...body.map((r) => r[i].length)));
+  const fmt = (r) => r.map((c, i) => i === r.length - 1 ? c : c.padEnd(widths[i])).join("  ");
+  console.log([fmt(head), ...body.map(fmt)].join("\n"));
+  if (total > rows.length) console.log(`
+${rows.length} of ${total} \xB7 --limit N for more \xB7 pitroom show <run> for one`);
+  return 0;
+}
 function cmdShow(p) {
   const meta = freshMeta(resolveRun(p.positional[0]));
   const dump = (name) => {
-    const f = runFile(meta.id, name);
-    process.stdout.write(fs22.existsSync(f) ? fs22.readFileSync(f, "utf8") : `(no ${name})
+    const text = readRunFile(meta.id, name) ?? (name === "changes.patch" ? archivedRun(meta.id)?.patch : void 0);
+    process.stdout.write(text ?? `(no ${name}${name === "events.jsonl" ? ": the raw stream was removed, the history keeps the steps" : ""})
 `);
   };
   if (has(p, "patch")) dump("changes.patch");
@@ -3293,7 +4192,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 ? "" : fs22.readFileSync(0, "utf8");
+var readStdin = () => process.stdin.isTTY ? "" : fs24.readFileSync(0, "utf8");
 function cmdStatusline(p) {
   const input = readStdin();
   const lines = [];
@@ -3313,14 +4212,42 @@ function cmdStatusline(p) {
 function cmdHookCard() {
   try {
     const cards = hookCards(readStdin());
-    if (cards) console.log(JSON.stringify({ systemMessage: cards }));
+    if (cards) {
+      console.log(
+        JSON.stringify({
+          systemMessage: cards,
+          hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext: `Pitroom, for the user:
+${cards}` }
+        })
+      );
+    }
   } catch {
   }
   return 0;
 }
+function cmdModels(p) {
+  const backend = p.positional[0];
+  const table2 = modelTable({ backend, all: has(p, "all") });
+  console.log(has(p, "json") ? JSON.stringify(table2, null, 2) : formatModels(table2));
+  return 0;
+}
 function cmdSavings(p) {
   const since = flag(p, "since") ?? "all";
   const t = totals(readLedger(sinceMs(since)));
+  if (has(p, "models")) {
+    const by = /* @__PURE__ */ new Map();
+    for (const e of readLedger(sinceMs(since))) {
+      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 });
+    }
+    const width = Math.max(12, ...[...by.keys()].map((k) => k.length));
+    console.log(`${"worker  model".padEnd(width)}  ${"runs".padStart(5)} ${"processed".padStart(10)} ${"returned".padStart(9)} ${"cost".padStart(8)} ${"saved".padStart(8)}`);
+    for (const [key, a] of [...by].sort((x, y) => y[1].runs - x[1].runs)) {
+      console.log(`${key.padEnd(width)}  ${String(a.runs).padStart(5)} ${compact(a.tokens).padStart(10)} ${compact(a.returned).padStart(9)} ${usd(a.cost).padStart(8)} ${usd(a.saved).padStart(8)}`);
+    }
+    return 0;
+  }
   const period = since === "all" ? "all time" : `last ${since.replace("d", " days")}`;
   if (has(p, "json")) {
     console.log(JSON.stringify({ period, ...t, price: primaryPrice() }, null, 2));
@@ -3334,8 +4261,8 @@ function cmdSavings(p) {
   est. saved          ${usd(t.saved)}  (vs ${primaryPrice().name} list prices)`);
   const out = flag(p, "card");
   if (out) {
-    fs22.writeFileSync(out, card(t, period));
-    console.log(`card written to ${path18.resolve(out)}`);
+    fs24.writeFileSync(out, card(t, period));
+    console.log(`card written to ${path20.resolve(out)}`);
   }
   if (has(p, "badge")) console.log(`![pitroom](${badgeUrl(t)})`);
   return 0;
@@ -3355,7 +4282,7 @@ function cmdConfig(p) {
     console.log(JSON.stringify({ path: configPath(), settings: eff, warnings }, null, 2));
     return 0;
   }
-  console.log(`config file: ${configPath()}${fs22.existsSync(configPath()) ? "" : " (not present)"}`);
+  console.log(`config file: ${configPath()}${fs24.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})`);
@@ -3378,9 +4305,10 @@ function cmdClean(p) {
   for (const id of old) {
     const m = readMeta(id);
     if (m.mode === "isolate" && !m.discarded && !m.applied) discardRun(m);
-    fs22.rmSync(runDir(id), { recursive: true, force: true });
+    recordRun(m);
+    fs24.rmSync(runDir(id), { recursive: true, force: true });
   }
-  console.log(`removed ${old.length} run(s); the savings ledger is kept`);
+  console.log(`removed ${old.length} run(s); the history and the savings ledger are kept`);
   return 0;
 }
 var cmdRevert = (p) => (console.log(revertRun(freshMeta(resolveRun(p.positional[0])))), 0);
@@ -3388,9 +4316,9 @@ var cmdDiscard = (p) => (console.log(discardRun(freshMeta(resolveRun(p.positiona
 
 // src/core/doctor.ts
 import { spawnSync as spawnSync7 } from "node:child_process";
-import fs23 from "node:fs";
+import fs25 from "node:fs";
 import os9 from "node:os";
-import path19 from "node:path";
+import path21 from "node:path";
 var MARK = { ok: "\u2714", warn: "!", fail: "\u2718" };
 var READ_ONLY_HOW = {
   "permission-rules": "per-run permission rules",
@@ -3404,7 +4332,7 @@ function doctor4(probe) {
   add("ok", `pitroom ${VERSION2} \xB7 node ${process.versions.node} \xB7 state in ${home()}`);
   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()}${fs23.existsSync(configPath()) ? "" : " (not present, defaults in use)"}`);
+  add(cfg.warnings.length ? "warn" : "ok", `config: ${configPath()}${fs25.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());
@@ -3430,6 +4358,16 @@ function doctor4(probe) {
     }
   }
   if (tierNames.length) add("ok", `tiers: ${tierNames.map((name, i) => `${name}=${describeTarget(tierTargets[i])}`).join(", ")}`);
+  const costs = effective().costs.value;
+  if (Object.keys(costs).length) {
+    for (const t of [...chain, ...tierTargets]) {
+      const key = `${t.backend}:${(t.model ?? "").split("#")[0]}`;
+      const mine = costs[key];
+      if (mine === void 0) continue;
+      const cheaper = Object.entries(costs).filter(([k, v]) => k.startsWith(`${t.backend}:`) && v < mine).sort((a, b) => a[1] - b[1])[0];
+      add("ok", `cost: ${key} = ${mine}${cheaper ? `; you priced ${cheaper[0]} cheaper (${cheaper[1]}): is the dearer one needed?` : ""}`);
+    }
+  }
   const byBackend = /* @__PURE__ */ new Map();
   for (const t of [...chain, ...tierTargets]) byBackend.set(t.backend, [...byBackend.get(t.backend) ?? [], t.model]);
   for (const [id, models] of byBackend) {
@@ -3472,11 +4410,11 @@ function liveProbe(target) {
     maxBuffer: 64 * 1024 * 1024,
     env: guardEnv({ ...process.env, ...inv.env, PWD: process.cwd(), PITROOM_ACTIVE: "1" })
   });
-  const secs = ((Date.now() - t0) / 1e3).toFixed(1);
+  const secs2 = ((Date.now() - t0) / 1e3).toFixed(1);
   const run = backend.parse(r.stdout ?? "");
-  if (run.finalText.includes("PONG")) return { level: "ok", message: `live probe (${describeTarget(target)}) answered in ${secs}s` };
+  if (run.finalText.includes("PONG")) return { level: "ok", message: `live probe (${describeTarget(target)}) answered in ${secs2}s` };
   const why = backend.failure(run, r.stderr ?? "", r.status)?.message ?? run.finalText.slice(0, 200);
-  return { level: "fail", message: `live probe (${describeTarget(target)}) failed after ${secs}s: ${why}` };
+  return { level: "fail", message: `live probe (${describeTarget(target)}) failed after ${secs2}s: ${why}` };
 }
 function skillChecks() {
   const checks = [];
@@ -3489,19 +4427,19 @@ function skillChecks() {
       message: `superpowers is installed too (${superpowers.join(", ")}): two bootstraps compete for the same work; keep one (Pitroom includes the superpowers workflow)`
     });
   }
-  for (const { base, names } of installedSkills()) {
-    if (names.length === all.length) checks.push({ level: "ok", message: `skills in ${base}: ${names.join(", ")}` });
-    else if (names.length) checks.push({ level: "warn", message: `skills in ${base}: only ${names.join(", ")} of ${all.length}; run \`pitroom install\`` });
-    else if (!viaPlugin) checks.push({ level: "warn", message: `no Pitroom skills in ${base}; run \`pitroom install\`` });
+  for (const { base: base2, names } of installedSkills()) {
+    if (names.length === all.length) checks.push({ level: "ok", message: `skills in ${base2}: ${names.join(", ")}` });
+    else if (names.length) checks.push({ level: "warn", message: `skills in ${base2}: only ${names.join(", ")} of ${all.length}; run \`pitroom install\`` });
+    else if (!viaPlugin) checks.push({ level: "warn", message: `no Pitroom skills in ${base2}; run \`pitroom install\`` });
   }
   if (viaPlugin) {
-    const linked = installedSkills().some((i) => i.base.includes(`${path19.sep}.claude${path19.sep}`) && i.names.length);
+    const linked = installedSkills().some((i) => i.base.includes(`${path21.sep}.claude${path21.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 (fs23.existsSync(launcher)) {
+  if (fs25.existsSync(launcher)) {
     const r = spawnSync7(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)}` }
@@ -3513,8 +4451,8 @@ function skillChecks() {
 }
 function pluginInstalled() {
   try {
-    const f = path19.join(os9.homedir(), ".claude", "plugins", "installed_plugins.json");
-    const plugins = JSON.parse(fs23.readFileSync(f, "utf8")).plugins ?? {};
+    const f = path21.join(os9.homedir(), ".claude", "plugins", "installed_plugins.json");
+    const plugins = JSON.parse(fs25.readFileSync(f, "utf8")).plugins ?? {};
     return Object.keys(plugins).some((k) => k.startsWith("pitroom@"));
   } catch {
     return false;
@@ -3531,24 +4469,24 @@ function superpowersActive() {
   for (const p of openCodePlugins()) {
     if (/superpowers/i.test(p)) found.push(`OpenCode plugin ${p}`);
   }
-  for (const base of [path19.join(os9.homedir(), ".agents", "skills"), path19.join(os9.homedir(), ".claude", "skills")]) {
-    const dir = path19.join(base, "using-superpowers");
-    if (fs23.existsSync(path19.join(dir, "SKILL.md"))) found.push(dir);
+  for (const base2 of [path21.join(os9.homedir(), ".agents", "skills"), path21.join(os9.homedir(), ".claude", "skills")]) {
+    const dir = path21.join(base2, "using-superpowers");
+    if (fs25.existsSync(path21.join(dir, "SKILL.md"))) found.push(dir);
   }
   return found;
 }
 function claudePlugins() {
   try {
-    const f = path19.join(os9.homedir(), ".claude", "plugins", "installed_plugins.json");
-    return Object.keys(JSON.parse(fs23.readFileSync(f, "utf8")).plugins ?? {});
+    const f = path21.join(os9.homedir(), ".claude", "plugins", "installed_plugins.json");
+    return Object.keys(JSON.parse(fs25.readFileSync(f, "utf8")).plugins ?? {});
   } catch {
     return [];
   }
 }
 function claudePluginEnabled(key) {
   try {
-    const f = path19.join(os9.homedir(), ".claude", "settings.json");
-    return JSON.parse(fs23.readFileSync(f, "utf8")).enabledPlugins?.[key] !== false;
+    const f = path21.join(os9.homedir(), ".claude", "settings.json");
+    return JSON.parse(fs25.readFileSync(f, "utf8")).enabledPlugins?.[key] !== false;
   } catch {
     return true;
   }
@@ -3557,7 +4495,7 @@ function codexPlugins() {
   const plugins = /* @__PURE__ */ new Map();
   let text;
   try {
-    text = fs23.readFileSync(path19.join(process.env.CODEX_HOME ?? path19.join(os9.homedir(), ".codex"), "config.toml"), "utf8");
+    text = fs25.readFileSync(path21.join(process.env.CODEX_HOME ?? path21.join(os9.homedir(), ".codex"), "config.toml"), "utf8");
   } catch {
     return plugins;
   }
@@ -3575,11 +4513,11 @@ function codexPlugins() {
   return plugins;
 }
 function openCodePlugins() {
-  const dir = path19.join(process.env.XDG_CONFIG_HOME ?? path19.join(os9.homedir(), ".config"), "opencode");
+  const dir = path21.join(process.env.XDG_CONFIG_HOME ?? path21.join(os9.homedir(), ".config"), "opencode");
   const plugins = [];
   for (const name of ["opencode.json", "opencode.jsonc"]) {
     try {
-      const text = fs23.readFileSync(path19.join(dir, name), "utf8").replace(/\/\*[\s\S]*?\*\/|^\s*\/\/.*$/gm, "");
+      const text = fs25.readFileSync(path21.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 {
@@ -3587,7 +4525,7 @@ function openCodePlugins() {
   }
   for (const folder of ["plugin", "plugins"]) {
     try {
-      for (const f of fs23.readdirSync(path19.join(dir, folder))) plugins.push(path19.join(dir, folder, f));
+      for (const f of fs25.readdirSync(path21.join(dir, folder))) plugins.push(path21.join(dir, folder, f));
     } catch {
     }
   }
@@ -3595,6 +4533,7 @@ function openCodePlugins() {
 }
 
 // src/cli.ts
+useArchive({ onFinished: recordRun, meta: (id) => archivedRun(id)?.meta, id: archivedId });
 var HELP = `pitroom ${VERSION2} \u2014 a free pit crew for your expensive coding agent.
 Delegates bounded tasks to a worker agent CLI (${backendIds().join(", ")}), using the
 worker's own default model, and returns a compact answer, exact changes and a receipt.
@@ -3611,7 +4550,14 @@ Usage
   pitroom status [run | -g NAME]        state / live progress (default: latest run)
   pitroom wait [run\u2026 | -g NAME] [--any] [--brief] [--timeout 540]
                                         block until all (or any) are done, then print reports
-  pitroom watch [run\u2026 | -g NAME] [--json] [--interval 2]
+  pitroom watch [run\u2026 | -g NAME] [--json | --brief] [--interval 2]
+                                        --brief: one card line per start and end (made for Claude Code's Monitor tool)
+  pitroom history [TEXT] [--model M] [--state S] [--since 30d] [--limit N] [--json]
+                                        every finished run, searchable (SQLite); "history stats" per worker and model,
+                                        "history import" takes in runs from before the history existed
+  pitroom dash [--detach] [--port N] [--open] [--stop]
+                                        a live page of the runs on 127.0.0.1 (read-only): open it in any browser
+                                        or an agent app's browser pane; --detach runs it in the background
                                         live table (TTY) or one JSON line per change, until done
   pitroom show [run] [--patch|--events|--full|--json]
   pitroom ls [--running] [-g NAME]      recent runs
@@ -3621,7 +4567,9 @@ Usage
   pitroom discard [run]                 drop an --isolate run's copy (the patch is kept)
   pitroom revert [run]                  undo the changes of a --write run (checked first)
   pitroom stop [run | -g NAME]          stop running or queued workers
-  pitroom savings [--since 7d|30d|all] [--card file.svg] [--badge]
+  pitroom savings [--since 7d|30d|all] [--models] [--card file.svg] [--badge]
+  pitroom models [worker] [--all] [--json]
+                                        models each worker offers, with effort levels, your costs and usage
   pitroom statusline [--then CMD]       status-bar line: running workers, savings this week (after CMD's)
   pitroom hook-card                     PostToolUse hook: a card after each Bash \`pitroom\` command
   pitroom doctor [--probe]              check workers, models, permissions, skills
@@ -3640,6 +4588,7 @@ Run options
   -W, --worker T        worker target "backend[:model]" (default: config "worker", else opencode)
   -m, --model M         model for that worker (default: the worker CLI's own default)
       --tier NAME       a worker from the config's "tiers" (e.g. cheap, standard, capable); -W wins
+      --effort LEVEL    reasoning effort for the worker: low, medium, high, xhigh, \u2026 (model#level)
       --plan PLAN       with --step N: implement Task N of a plan (-i or -w); the task text is your notes
       --step N          the plan task for --plan
   -t, --timeout DUR     e.g. 900, 20m, 1h (default 30m, or PITROOM_TIMEOUT)
@@ -3654,7 +4603,7 @@ Run options
       --task-file PATH  read the task from a file (crew: tasks separated by --- lines)
       --allow-non-git   allow --write outside a git repository (no tracking/revert)
 
-Parallel: at most maxParallel workers (default 4, PITROOM_MAX_PARALLEL) run at once; others queue.
+Parallel: at most maxParallel workers (default 20, up to 30; PITROOM_MAX_PARALLEL) run at once; others queue.
           One --write run per repository; use --isolate for parallel changes.
 Exit codes: 0 ok \xB7 1 worker failed \xB7 2 usage \xB7 3 refused/setup \xB7 4 timeout
             5 read-only violation \xB7 6 verify failed \xB7 75 still running (wait again)
@@ -3671,6 +4620,8 @@ var COMMANDS = {
   status: cmdStatus,
   wait: cmdWait,
   watch: cmdWatch,
+  dash: cmdDash,
+  history: cmdHistory,
   show: cmdShow,
   ls: cmdLs,
   list: cmdLs,
@@ -3679,6 +4630,7 @@ var COMMANDS = {
   discard: cmdDiscard,
   stop: cmdStop,
   savings: cmdSavings,
+  models: cmdModels,
   statusline: cmdStatusline,
   "hook-card": cmdHookCard,
   doctor: (p) => doctor4(has(p, "probe")),