pitroom 0.16.0 → 0.17.0

package/dist/pitroom.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import fs33 from "node:fs";
+import fs35 from "node:fs";
 
 // src/core/errors.ts
 var UserError = class extends Error {
@@ -1420,7 +1420,8 @@ var SCHEMA = {
   tiers: "record",
   costs: "numbers",
   audit: "number",
-  readIn: "string"
+  readIn: "string",
+  cacheDays: "number"
 };
 function configPath() {
   if (process.env.PITROOM_CONFIG) return path7.resolve(process.env.PITROOM_CONFIG);
@@ -1478,6 +1479,10 @@ var rate = (v) => {
   const n = typeof v === "string" && v.trim() !== "" ? Number(v) : v;
   return typeof n === "number" && Number.isFinite(n) && n >= 0 ? Math.min(n, 1) : void 0;
 };
+var days = (v) => {
+  const n = typeof v === "string" && v.trim() !== "" ? Number(v) : v;
+  return typeof n === "number" && Number.isInteger(n) && n >= 0 ? n : void 0;
+};
 var readIn = (v) => v === "auto" || v === "snapshot" || v === "project" ? v : void 0;
 var list = (s) => s?.split(",").map((x) => x.trim()).filter(Boolean);
 function setting(flag2, env, conf, fallback) {
@@ -1504,7 +1509,8 @@ function effective(flags = {}) {
     tiers: setting(void 0, void 0, c.tiers, {}),
     costs: setting(void 0, void 0, c.costs, {}),
     audit: setting(void 0, rate(e.PITROOM_AUDIT), rate(c.audit), 0),
-    readIn: setting(void 0, readIn(e.PITROOM_READ_IN), readIn(c.readIn), "auto")
+    readIn: setting(void 0, readIn(e.PITROOM_READ_IN), readIn(c.readIn), "auto"),
+    cacheDays: setting(void 0, days(e.PITROOM_CACHE_DAYS), days(c.cacheDays), 7)
   };
 }
 
@@ -1581,6 +1587,7 @@ var BOOL_FLAGS = {
   "--stop": "stop",
   "--open": "open",
   "--serve": "serve",
+  "--fresh": "fresh",
   "--http": "http",
   "-h": "help",
   "--help": "help",
@@ -1730,16 +1737,16 @@ function repoRoot(dir) {
   const r = git(dir, ["rev-parse", "--show-toplevel"]);
   return r.code === 0 ? path8.resolve(r.stdout.trim()) : void 0;
 }
-function snapshotTree(root, exclude = [], drop = []) {
+function snapshotTree(root, exclude = [], drop2 = []) {
   const tmp = path8.join(os8.tmpdir(), `pitroom-index-${process.pid}-${crypto2.randomBytes(4).toString("hex")}`);
   const real = path8.resolve(root, must(root, ["rev-parse", "--git-path", "index"]).trim());
   const env = { ...process.env, GIT_INDEX_FILE: tmp };
   try {
     if (fs9.existsSync(real)) fs9.copyFileSync(real, tmp);
     else must(root, ["read-tree", "--empty"], env);
-    must(root, ["add", "-A", "--", ":/", ...exclude.map((p) => `:(top,exclude)${p}`), ...drop.map((p) => `:(top,literal,exclude)${p}`)], env);
-    if (drop.length) {
-      const r = spawnSync5("git", ["update-index", "--force-remove", "-z", "--stdin"], { cwd: root, env, input: `${drop.join("\0")}\0`, encoding: "utf8" });
+    must(root, ["add", "-A", "--", ":/", ...exclude.map((p) => `:(top,exclude)${p}`), ...drop2.map((p) => `:(top,literal,exclude)${p}`)], env);
+    if (drop2.length) {
+      const r = spawnSync5("git", ["update-index", "--force-remove", "-z", "--stdin"], { cwd: root, env, input: `${drop2.join("\0")}\0`, encoding: "utf8" });
       if (r.status !== 0) throw new Error(`git update-index failed: ${r.stderr.trim()}`);
     }
     return must(root, ["write-tree"], env).trim();
@@ -1804,6 +1811,7 @@ ${must(root, [...DIFF, "-U10", a, b])}`;
 }
 function rangeDiff(root, a, b) {
   const range = `${a}..${b}`;
+  const since2 = git(root, ["merge-base", a, b]).code === 0 ? `${a}...${b}` : range;
   const log2 = must(root, ["log", "--oneline", "--no-decorate", range]).trim();
   return [
     `## COMMITS
@@ -1811,10 +1819,10 @@ function rangeDiff(root, a, b) {
 ${log2 || "(none)"}`,
     `## FILES CHANGED
 
-${must(root, [...DIFF, "--stat", range]).trim() || "(none)"}`,
+${must(root, [...DIFF, "--stat", since2]).trim() || "(none)"}`,
     `## DIFF
 
-${must(root, [...DIFF, "-U10", range])}`
+${must(root, [...DIFF, "-U10", since2])}`
   ].join("\n\n");
 }
 function commitOf(root, ref) {
@@ -2049,7 +2057,7 @@ async function spawnWorker(inv, opts) {
   process.once("SIGINT", stop);
   process.once("SIGTERM", stop);
   let killer;
-  const timer = setTimeout(() => {
+  const timer2 = setTimeout(() => {
     res.timedOut = true;
     child.kill("SIGTERM");
     killer = setTimeout(() => child.kill("SIGKILL"), 1e4);
@@ -2061,7 +2069,7 @@ async function spawnWorker(inv, opts) {
     });
     child.on("close", (c) => resolve2(c));
   });
-  clearTimeout(timer);
+  clearTimeout(timer2);
   if (killer) clearTimeout(killer);
   process.off("SIGINT", stop);
   process.off("SIGTERM", stop);
@@ -2234,8 +2242,8 @@ function wantSnapshot(readIn2, root, dir) {
   return readIn2 === "snapshot" || secrets.length ? { secrets } : void 0;
 }
 function readSnapshot(root) {
-  const drop = findSecretFilesInTree(root, root);
-  const tree = snapshotTree(root, [], drop);
+  const drop2 = findSecretFilesInTree(root, root);
+  const tree = snapshotTree(root, [], drop2);
   const dest = path12.join(snapshotsDir(), tree);
   if (fs14.existsSync(path12.join(dest, ".git"))) {
     touch(dest);
@@ -2377,6 +2385,9 @@ function auditTask(meta, answer) {
   return [
     "You are auditing another worker's answer to a read-only question about this project. Do not take the answer on trust:",
     "check its key claims yourself against the files here (open the cited files and lines, search for what it says exists or is missing).",
+    "Check the answer against the QUESTION, not only its own claims: every condition the question sets (a directory or scope,",
+    'what to leave out, "all", "only", "exactly", a count) must hold. Valid references do not make an answer right:',
+    "for a list, look for items that are missing and items that do not belong; for a count, count again yourself.",
     "Do not edit anything and do not run anything that changes files.",
     "",
     "QUESTION:",
@@ -2391,7 +2402,7 @@ function auditTask(meta, answer) {
     "DISPUTED:",
     "- <the claim> \u2014 <what is actually true, with path:line>",
     "",
-    "AGREE: every key claim you checked holds. PARTIAL: some are wrong or could not be verified. DISAGREE: the main conclusion is wrong.",
+    "AGREE: every key claim you checked holds and the answer meets every condition of the question (no extra or missing items, the right count). PARTIAL: some are wrong, unverified, or the answer goes beyond or falls short of the question's scope. DISAGREE: the main conclusion is wrong.",
     'Under DISPUTED list only claims you checked and found wrong or unsupported; write "- (none)" when there are none.'
   ].join("\n");
 }
@@ -2577,18 +2588,18 @@ function place(src, dest, opts) {
 }
 function install(opts) {
   const root = packageRoot();
-  const skills = opts.skills === false ? [] : skillNames(root);
-  if (opts.skills !== false && !skills.length) throw new Error(`no skills found under ${path14.join(root, "skills")}`);
+  const skills2 = opts.skills === false ? [] : skillNames(root);
+  if (opts.skills !== false && !skills2.length) throw new Error(`no skills found under ${path14.join(root, "skills")}`);
   const out = [];
   for (const base2 of opts.skills === false ? [] : skillTargets()) {
     for (const legacy of LEGACY) {
       const l = path14.join(base2, legacy);
-      if (!skills.includes(legacy) && linksInto(l, root)) {
+      if (!skills2.includes(legacy) && linksInto(l, root)) {
         fs16.unlinkSync(l);
         out.push(`\u2714 removed old link ${l}`);
       }
     }
-    for (const name of skills) out.push(place(path14.join(root, "skills", name), path14.join(base2, name), opts));
+    for (const name of skills2) out.push(place(path14.join(root, "skills", name), path14.join(base2, name), opts));
   }
   const bundle = path14.join(root, "dist", "pitroom.mjs");
   if (fs16.existsSync(bundle)) {
@@ -3350,6 +3361,7 @@ function archivedId(ref) {
     return void 0;
   }
 }
+var VERIFY_FAILED = "(r.state = 'done' AND json_extract(r.meta_json, '$.verifyResult.ok') = 0)";
 var ftsQuery = (text) => text.split(/\s+/).filter(Boolean).map((w) => `"${w.replace(/"/g, '""')}"*`).join(" ");
 function listHistory(q = {}) {
   const db = openDb();
@@ -3369,7 +3381,7 @@ function listHistory(q = {}) {
     args.push(q.backend);
   }
   if (q.state) {
-    where.push(q.state === "problem" ? "r.state IN ('failed','timeout','stopped')" : "r.state = ?");
+    where.push(q.state === "problem" ? `(r.state IN ('failed','timeout','stopped') OR ${VERIFY_FAILED})` : "r.state = ?");
     if (q.state !== "problem") args.push(q.state);
   }
   if (q.group) {
@@ -3384,7 +3396,7 @@ function listHistory(q = {}) {
   try {
     const total = db.prepare(`SELECT COUNT(*) AS n FROM runs r ${base2}`).get(...args).n;
     const page = q.beforeId ? `${base2 ? `${base2} AND` : "WHERE"} r.id < ?` : base2;
-    const rows = db.prepare(`SELECT r.*, json_extract(r.meta_json, '$.audit.state') AS audit_state, json_extract(r.meta_json, '$.audit.verdict') AS audit_verdict FROM runs r ${page} ORDER BY r.id DESC LIMIT ?`).all(...args, ...q.beforeId ? [q.beforeId] : [], Math.min(Math.max(q.limit ?? 30, 1), 200));
+    const rows = db.prepare(`SELECT r.*, json_extract(r.meta_json, '$.audit.state') AS audit_state, json_extract(r.meta_json, '$.audit.verdict') AS audit_verdict, ${VERIFY_FAILED} AS verify_failed FROM runs r ${page} ORDER BY r.id DESC LIMIT ?`).all(...args, ...q.beforeId ? [q.beforeId] : [], Math.min(Math.max(q.limit ?? 30, 1), 200));
     return {
       total,
       rows: rows.map((r) => ({
@@ -3398,6 +3410,7 @@ function listHistory(q = {}) {
         group: r.grp ?? void 0,
         verdict: r.verdict ?? void 0,
         audit: auditBadge({ audit: r.audit_state ? { id: "", state: r.audit_state, verdict: r.audit_verdict ?? void 0 } : void 0 }),
+        verifyFailed: r.verify_failed ? true : void 0,
         seconds: r.seconds ?? void 0,
         steps: r.steps ?? void 0,
         tokens: r.tokens ?? void 0,
@@ -3544,7 +3557,9 @@ function readSummary(meta) {
 }
 function formatReport(meta, finalText = readSummary(meta), maxLines = 400) {
   const out = [];
-  out.push(`${bold("pitroom")} ${stateColour(meta.state, `${ICON2[meta.state]} ${meta.state}`)} \xB7 ${meta.mode} \xB7 ${duration(meta)} \xB7 run ${dim(meta.id)}`);
+  const verifyFailed = meta.state === "done" && meta.verifyResult && !meta.verifyResult.ok;
+  const head = verifyFailed ? stateColour("failed", "\u26A0 done \xB7 verify failed") : stateColour(meta.state, `${ICON2[meta.state]} ${meta.state}`);
+  out.push(`${bold("pitroom")} ${head} \xB7 ${meta.mode} \xB7 ${duration(meta)} \xB7 run ${dim(meta.id)}`);
   const ran = meta.ran ?? meta.worker;
   const ids = [`worker ${ran.backend}`, meta.resolvedModel && `model ${meta.resolvedModel}`, meta.sessionId && `session ${meta.sessionId}`];
   out.push(ids.filter(Boolean).join(" \xB7 "));
@@ -3610,7 +3625,9 @@ function formatReport(meta, finalText = readSummary(meta), maxLines = 400) {
   }
   if (meta.verifyResult) {
     const v = meta.verifyResult;
-    out.push(`\u2500\u2500 verify: \`${meta.verify}\` ${v.ok ? "\u2714 passed" : `\u2718 failed (exit ${v.code})`}`);
+    const notFound = !v.ok && v.code === 127 && /not found|no such file/i.test(v.tail);
+    out.push(`\u2500\u2500 verify: \`${meta.verify}\` ${v.ok ? "\u2714 passed" : notFound ? "\u2718 could not run (exit 127: command not found)" : `\u2718 failed (exit ${v.code})`}`);
+    if (notFound) out.push("   the command is not on the PATH Pitroom runs with (an app such as an MCP client may start it without your shell's PATH): give its full path, or set PATH in the command");
     if (!v.ok && v.tail) out.push(...v.tail.split("\n").map((l) => `   ${l}`));
   }
   if (isActive(meta.state)) {
@@ -3634,7 +3651,7 @@ function progress(meta) {
 }
 
 // src/core/run.ts
-var VERSION2 = true ? "0.16.0" : "0.0.0-dev";
+var VERSION2 = true ? "0.17.0" : "0.0.0-dev";
 function planWork(o) {
   if (!o.plan) return { task: o.task.trim(), tier: o.tier };
   if (o.continueFrom) throw new UserError("a follow-up continues its parent's task; drop --plan/--step");
@@ -3732,6 +3749,7 @@ function prepareRun(o) {
     auditOf: o.audit?.of,
     auditRate: o.auditRate,
     inPlace: o.inPlace || void 0,
+    cache: o.cache,
     snapshot: parent?.snapshot ?? (snap ? { dir: "", tree: "", left: snap.secrets } : void 0),
     plan: work.plan ?? o.review?.plan ?? parent?.plan,
     reviewKind: o.review?.kind,
@@ -4003,6 +4021,12 @@ function captureChanges(meta) {
   meta.stats = d.stats;
   fs24.writeFileSync(runFile(meta.id, "changes.patch"), d.patch);
 }
+function verifyPath() {
+  const extra = [path20.dirname(process.execPath), "/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"];
+  const parts = (process.env.PATH ?? "").split(path20.delimiter).filter(Boolean);
+  for (const d of process.platform === "win32" ? [path20.dirname(process.execPath)] : extra) if (!parts.includes(d)) parts.push(d);
+  return parts.join(path20.delimiter);
+}
 function runVerify(meta) {
   const r = spawnSync6(meta.verify, {
     cwd: meta.cwd,
@@ -4011,7 +4035,7 @@ function runVerify(meta) {
     timeout: 15 * 6e4,
     stdio: ["ignore", "pipe", "pipe"],
     maxBuffer: 64 * 1024 * 1024,
-    env: { ...process.env, PWD: meta.cwd, PITROOM_ACTIVE: "1" }
+    env: { ...process.env, PATH: verifyPath(), PWD: meta.cwd, PITROOM_ACTIVE: "1" }
   });
   const output = `${r.stdout ?? ""}${r.stderr ?? ""}`;
   fs24.writeFileSync(runFile(meta.id, "verify.log"), output);
@@ -4062,6 +4086,10 @@ function cleanupWorktree(meta) {
   if (meta.worktree && fs24.existsSync(meta.worktree)) removeIsolatedCopy(meta.worktree, worktreesDir());
 }
 
+// src/cli/mcp-extras.ts
+import fs25 from "node:fs";
+import path21 from "node:path";
+
 // src/cli/mcp-support.ts
 import { spawn as spawn3 } from "node:child_process";
 
@@ -4248,12 +4276,12 @@ function pit(args, timeoutMs = 60 * 6e4, signal) {
     child.stdout.on("data", (d) => out += d);
     child.stderr.on("data", (d) => err += d);
     const stop = () => child.kill("SIGTERM");
-    const timer = setTimeout(stop, timeoutMs);
+    const timer2 = setTimeout(stop, timeoutMs);
     signal?.addEventListener("abort", stop, { once: true });
     if (signal?.aborted) stop();
     child.on("error", (e) => resolve2({ code: 1, out, err: err || String(e.message) }));
     child.on("close", (code) => {
-      clearTimeout(timer);
+      clearTimeout(timer2);
       signal?.removeEventListener("abort", stop);
       resolve2({ code, out: strip(out).trim(), err: strip(err).trim() });
     });
@@ -4264,11 +4292,11 @@ function asResult(r, still) {
   if (r.code === 75 && still) return { text: clip6(`${text}
 
 ${still}`) };
-  return { text: clip6(text), isError: r.code === 2 || r.code === 3 || r.code === 1 && !r.out };
+  return { text: clip6(text), isError: r.code === 2 || r.code === 3 || r.code === 5 || r.code === 6 || r.code === 1 && !r.out };
 }
 var plain = async (args, ctx, timeoutMs = 6e4) => asResult(await pit(args, timeoutMs, ctx.signal));
 function trackProgress(ctx, ids) {
-  const tick = () => {
+  const tick2 = () => {
     try {
       const lines = ids().map((id) => freshMeta(id)).filter((m) => isActive(m.state)).map((m) => progress(m).replace(/^pitroom\s+/, ""));
       if (lines.length) ctx.progress(lines.slice(0, 3).join("\n") + (lines.length > 3 ? `
@@ -4276,11 +4304,11 @@ function trackProgress(ctx, ids) {
     } catch {
     }
   };
-  const first = setTimeout(tick, 800);
-  const timer = setInterval(tick, PROGRESS_EVERY_MS);
+  const first = setTimeout(tick2, 800);
+  const timer2 = setInterval(tick2, PROGRESS_EVERY_MS);
   return () => {
     clearTimeout(first);
-    clearInterval(timer);
+    clearInterval(timer2);
   };
 }
 async function waitFor(ids, seconds, ctx, group) {
@@ -4305,13 +4333,17 @@ async function startAndWait(start, seconds, ctx, task) {
   const started = await pit([...start, "--bg", "--json", ...task === void 0 ? [] : ["--", task]]);
   if (started.code !== 0) return asResult(started);
   let id;
+  let cached3 = false;
   try {
-    id = JSON.parse(started.out).id;
+    ({ id, cached: cached3 = false } = JSON.parse(started.out));
   } catch {
     return { text: `could not read the run id from: ${started.out.slice(0, 200)}`, isError: true };
   }
   const result = await waitFor([id], seconds, ctx);
-  if (cancelled(ctx)) await stopQuietly(["stop", id]);
+  if (cancelled(ctx) && !cached3) await stopQuietly(["stop", id]);
+  if (cached3) result.text = `Cached answer: the same question on the same code as run ${id}; no worker ran (fresh: true asks one).
+
+${result.text}`;
   return result;
 }
 async function startCrew(flags, tasks, seconds, ctx) {
@@ -4337,6 +4369,7 @@ var RpcError = class extends Error {
 };
 var RUN = /^pitroom:\/\/run\/(\d{8}-\d{6}-[0-9a-f]{4})(\/patch)?$/;
 var LISTED = 30;
+var runOfUri = (uri) => RUN.exec(uri)?.[1];
 var oneLine6 = (text, n) => {
   const flat = text.replace(/\s+/g, " ").trim();
   return flat.length > n ? `${flat.slice(0, n - 1)}\u2026` : flat;
@@ -4399,16 +4432,50 @@ Call pitroom_run with mode "isolate" (add "verify" with the project's test comma
     title: "Split work across workers",
     description: "Independent tasks run in parallel as one group of workers.",
     arguments: [{ name: "tasks", description: "The tasks, one per line.", required: true }],
-    text: (a) => `Run these independent tasks in parallel with pitroom_crew (one worker each):
+    text: (a) => `Run these independent tasks in parallel: call pitroom_run with "tasks" (one worker each):
 
 ${a.tasks}
 
 Make each task self-contained. Use mode "isolate" if they change files, then read every patch (pitroom_show, patch: true) and apply them with pitroom_apply (group). Only split work that does not depend on each other.`
   }
 ];
-var listPrompts = () => ({ prompts: PROMPTS.map(({ name, title, description, arguments: args }) => ({ name, title, description, arguments: args })) });
+var TOOL_MAP = 'Through this MCP server the `pitroom` commands below are tools: `pitroom run` is pitroom_run (`-i` is mode "isolate", `-w` mode "write", `--continue` is continue, `--verify` is verify), `pitroom crew` is pitroom_run with tasks, `pitroom wait` pitroom_wait, `pitroom show`/`status` pitroom_show, `pitroom review` pitroom_review, `pitroom audit` pitroom_audit, `pitroom apply`/`discard`/`revert`/`stop` the tools of those names, `pitroom history`/`ls`/`models`/`doctor` pitroom_info. With a shell the commands work as well.';
+var skills;
+function skillPrompts() {
+  if (skills) return skills;
+  const found = [];
+  const root = packageRoot();
+  for (const name of skillNames(root)) {
+    try {
+      const text = fs25.readFileSync(path21.join(root, "skills", name, "SKILL.md"), "utf8");
+      const front = /^---\n([\s\S]*?)\n---\n/.exec(text);
+      const body = (front ? text.slice(front[0].length) : text).trim();
+      const description = /^description:\s*(.+)$/m.exec(front?.[1] ?? "")?.[1]?.trim() ?? `The ${name} skill.`;
+      const title = /^#\s+(.+)$/m.exec(body)?.[1]?.trim() ?? name;
+      found.push({
+        name,
+        title,
+        // the first sentence: prompts/list is read whole by some clients, so it stays short
+        description: `Skill: ${description.split(/(?<=\.)\s/)[0]}`,
+        arguments: [{ name: "task", description: "What you are about to do (optional)." }],
+        text: (a) => `${TOOL_MAP}
+
+${body}${a.task ? `
+
+---
+
+The task: ${a.task}` : ""}`
+      });
+    } catch {
+    }
+  }
+  skills = found.filter((p) => !PROMPTS.some((b) => b.name === p.name));
+  return skills;
+}
+var allPrompts = () => [...PROMPTS, ...skillPrompts()];
+var listPrompts = () => ({ prompts: allPrompts().map(({ name, title, description, arguments: args }) => ({ name, title, description, arguments: args })) });
 function getPrompt(name, given) {
-  const p = PROMPTS.find((x) => x.name === name);
+  const p = allPrompts().find((x) => x.name === name);
   if (!p) throw new RpcError(-32602, `unknown prompt: ${String(name)}`);
   const args = {};
   const raw = given && typeof given === "object" && !Array.isArray(given) ? given : {};
@@ -4422,84 +4489,110 @@ function getPrompt(name, given) {
 
 // src/cli/mcp-tools.ts
 var WORKER_PROPS = {
-  worker: { type: "string", description: 'Worker target "backend[:model]", e.g. "opencode", "codex", "claude:haiku", "gemini:gemini-3.8-flash". Default: the configured worker.' },
-  model: { type: "string", description: "Model for the preferred worker." },
-  tier: { type: "string", description: "A worker tier from the config: cheap, standard, capable (an explicit worker wins)." },
-  effort: { type: "string", description: "Reasoning effort for the worker: low, medium, high, xhigh." },
-  dir: { type: "string", description: "Project directory (default: the directory the server was started in)." },
-  files: { type: "array", items: { type: "string" }, description: "Files to attach (paths)." },
-  verify: { type: "string", description: 'A command run after the worker finishes (e.g. "npm test"); a failing one is reported.' },
-  link: { type: "array", items: { type: "string" }, description: 'Ignored directories to link into an isolated copy so tests can run (e.g. ["node_modules"]).' },
-  web: { type: "boolean", description: "Let the worker use web tools." },
-  group: { type: "string", description: "A name to group related runs under." }
+  worker: { type: "string", description: 'Worker "backend[:model]", e.g. "opencode", "claude:haiku". Default: configured.' },
+  model: { type: "string", description: "Model for that worker." },
+  tier: { type: "string", description: "cheap, standard or capable (from the config)." },
+  effort: { type: "string", description: "low, medium, high, xhigh." },
+  dir: { type: "string", description: "Project directory (default: the server's)." },
+  files: { type: "array", items: { type: "string" }, description: "Files to attach." },
+  verify: { type: "string", description: 'Command run afterwards, e.g. "npm test".' },
+  link: { type: "array", items: { type: "string" }, description: 'Ignored dirs to link into an isolated copy, e.g. ["node_modules"].' },
+  web: { type: "boolean", description: "Allow web tools." },
+  group: { type: "string", description: "Group name for related runs." }
 };
-var WAIT_PROP = { waitSeconds: { type: "number", description: `How long to wait for the result before returning "still running" (default ${DEFAULT_WAIT}, at most ${MAX_WAIT}).` } };
-var RUN_ID2 = { type: "string", description: 'A run id as printed by a run, or "last".' };
-var SINCE = { type: "string", description: "A window: 7d, 30d, \u2026 or all." };
+var WAIT_PROP = { waitSeconds: { type: "number", description: `Wait this long before returning "still running" (default ${DEFAULT_WAIT}, max ${MAX_WAIT}).` } };
+var RUN_ID2 = { type: "string", description: 'Run id, or "last".' };
 var READ_ONLY = { readOnlyHint: true, openWorldHint: false };
+var TOPICS = {
+  runs: ["running", "group"],
+  history: ["text", "state", "model", "since", "limit"],
+  stats: ["since"],
+  savings: ["since", "perModel"],
+  models: ["worker", "all"],
+  cooldown: [],
+  config: [],
+  doctor: []
+};
+function infoArgs(topic, a) {
+  const allowed = TOPICS[topic];
+  const stray = Object.keys(a).filter((k) => k !== "topic" && a[k] !== void 0 && a[k] !== null && !allowed.includes(k));
+  if (stray.length) throw new ToolError(`${stray.map((k) => `"${k}"`).join(", ")} ${stray.length > 1 ? "do" : "does"} not go with topic "${topic}" (${allowed.length ? `it takes ${allowed.join(", ")}` : "it takes no options"})`);
+  const group = str(a, "group");
+  const worker = str(a, "worker");
+  switch (topic) {
+    case "runs":
+      return { args: group ? ["status", "-g", group] : ["ls", ...bool(a, "running") ? ["--running"] : []] };
+    case "history": {
+      const limit = a.limit;
+      if (limit !== void 0 && (typeof limit !== "number" || !Number.isInteger(limit) || limit < 1 || limit > 200)) throw new ToolError('"limit" must be a whole number from 1 to 200');
+      const text = str(a, "text");
+      const state = str(a, "state");
+      const model = str(a, "model");
+      return { args: ["history", ...since(a), ...state ? ["--state", state] : [], ...model ? ["--model", model] : [], ...limit ? ["--limit", String(limit)] : [], ...text ? ["--", text] : []] };
+    }
+    case "stats":
+      return { args: ["history", "stats", ...since(a)] };
+    case "savings":
+      return { args: ["savings", ...since(a), ...bool(a, "perModel") ? ["--models"] : []] };
+    case "models":
+      return { args: ["models", ...worker ? [worker] : [], ...bool(a, "all") ? ["--all"] : []] };
+    case "doctor":
+      return { args: ["doctor"], timeoutMs: 12e4 };
+    case "cooldown":
+    case "config":
+      return { args: [topic] };
+    default:
+      throw new Error(`topic "${topic}" has no command`);
+  }
+}
 var TOOLS2 = [
   {
     name: "pitroom_run",
     title: "Run a worker",
-    description: `Hand a bounded task to a cheaper worker agent. mode "read" (default) is read-only research that returns an answer whose file:line references are verified; "isolate" lets the worker edit a private copy and returns the exact diff (review it, then pitroom_apply or pitroom_discard); "write" edits the working tree in place and is undoable with pitroom_revert. Returns the worker's answer and a receipt, or "still running" with the run id. Progress is reported while it waits; cancelling the call stops the run.`,
+    description: 'Hand a bounded task to a cheaper worker agent. mode "read" (default): read-only research, an answer with verified file:line references. "isolate": the worker edits a private copy and you get the exact diff (then pitroom_review, pitroom_apply or pitroom_discard). "write": edits the working tree (undo: pitroom_revert). Give "tasks" instead of "task" to run independent tasks in parallel (read or isolate). Returns the report(s) and a receipt (a read question asked before on the same code comes back cached), or "still running" for pitroom_wait. The using-pitroom skill (or prompt) says when and how to delegate. Cancelling the call stops the run.',
     inputSchema: {
       type: "object",
       properties: {
-        task: { type: "string", description: "What the worker should do, with the context it needs." },
-        mode: { type: "string", enum: ["read", "isolate", "write"], description: "read (default), isolate, or write." },
-        continue: { type: "string", description: "A finished run to follow up in the same worker session (the task is then the follow-up)." },
-        inPlace: { type: "boolean", description: "Read mode only: read the directory itself instead of a clean snapshot without secret-looking files." },
-        audit: { type: "boolean", description: "Read mode only: have another worker re-check the answer afterwards." },
+        task: { type: "string", description: "What to do, with the context the worker needs." },
+        tasks: { type: "array", items: { type: "string" }, minItems: 1, maxItems: MAX_TASKS, description: "Or several independent tasks, one worker each." },
+        mode: { type: "string", enum: ["read", "isolate", "write"] },
+        continue: { type: "string", description: "A finished run to follow up in the same worker session." },
+        inPlace: { type: "boolean", description: "Read: read the directory itself, not a snapshot without secret-looking files." },
+        audit: { type: "boolean", description: "Read: have another worker re-check the answer (each one, with tasks)." },
+        fresh: { type: "boolean", description: "Read: ask a worker even if this question was answered on the same code." },
         ...WORKER_PROPS,
         ...WAIT_PROP
-      },
-      required: ["task"]
+      }
     },
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
     async call(a, ctx) {
-      const task = str(a, "task", true);
+      const task = str(a, "task");
+      const tasks = strs(a, "tasks").filter((t) => t.trim());
+      if (!task && !tasks.length) throw new ToolError('give "task" (or "tasks" for parallel work)');
+      if (task && tasks.length) throw new ToolError('give "task" or "tasks", not both');
       const mode = oneOf(a, "mode", ["read", "isolate", "write"], "read");
       const flags = mode === "isolate" ? ["-i"] : mode === "write" ? ["-w"] : [];
-      const follow = str(a, "continue");
-      if (follow) flags.push("--continue", follow);
       if (mode === "read") {
         if (bool(a, "inPlace")) flags.push("--in-place");
         if (bool(a, "audit")) flags.push("--audit");
+        if (bool(a, "fresh")) flags.push("--fresh");
+      }
+      const follow = str(a, "continue");
+      if (tasks.length) {
+        if (tasks.length > MAX_TASKS) throw new ToolError(`at most ${MAX_TASKS} tasks at once: start the rest when these are done`);
+        if (mode === "write") throw new ToolError('parallel workers never write in place: use mode "isolate" (each gets its own copy)');
+        if (follow) throw new ToolError('"continue" follows up one run: give "task"');
+        return startCrew([...flags, ...workerFlags(a)], tasks, waitSeconds(a), ctx);
       }
+      if (follow) flags.push("--continue", follow);
       return startAndWait(["run", ...flags, ...workerFlags(a)], waitSeconds(a), ctx, task);
     }
   },
-  {
-    name: "pitroom_crew",
-    title: "Run workers in parallel",
-    description: 'Start several independent tasks at once as one group of workers (read, or isolate: each edits its own copy) and wait for the group. Returns every report, or "still running" with the group name for pitroom_wait. Only for tasks that do not depend on each other. Cancelling the call stops the group.',
-    inputSchema: {
-      type: "object",
-      properties: {
-        tasks: { type: "array", items: { type: "string" }, minItems: 1, maxItems: MAX_TASKS, description: "One self-contained task per worker." },
-        mode: { type: "string", enum: ["read", "isolate"], description: "read (default) or isolate." },
-        ...WORKER_PROPS,
-        ...WAIT_PROP
-      },
-      required: ["tasks"]
-    },
-    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
-    async call(a, ctx) {
-      const tasks = strs(a, "tasks").filter((t) => t.trim());
-      if (!tasks.length) throw new ToolError('"tasks" needs at least one task');
-      if (tasks.length > MAX_TASKS) throw new ToolError(`at most ${MAX_TASKS} tasks at once: start the rest when these are done`);
-      const mode = oneOf(a, "mode", ["read", "isolate"], "read");
-      return startCrew([...mode === "isolate" ? ["-i"] : [], ...workerFlags(a)], tasks, waitSeconds(a), ctx);
-    }
-  },
   {
     name: "pitroom_wait",
     title: "Wait for runs",
-    description: 'Wait for runs started earlier (a run that came back "still running") and return their reports.',
-    inputSchema: {
-      type: "object",
-      properties: { runs: { type: "array", items: { type: "string" }, description: "Run ids." }, group: { type: "string", description: "Or a group name." }, ...WAIT_PROP }
-    },
+    description: 'Wait for runs that came back "still running" and return their reports.',
+    inputSchema: { type: "object", properties: { runs: { type: "array", items: { type: "string" } }, group: { type: "string" }, ...WAIT_PROP } },
     annotations: READ_ONLY,
     async call(a, ctx) {
       const runs = strs(a, "runs");
@@ -4508,126 +4601,56 @@ var TOOLS2 = [
       return waitFor(runs, waitSeconds(a), ctx, runs.length ? void 0 : group);
     }
   },
-  {
-    name: "pitroom_status",
-    title: "Run status",
-    description: "The state and live progress of a run (default: the latest), or of a group.",
-    inputSchema: { type: "object", properties: { run: RUN_ID2, group: { type: "string", description: "A group name." } } },
-    annotations: READ_ONLY,
-    async call(a, ctx) {
-      const group = str(a, "group");
-      const run2 = str(a, "run");
-      if (group && run2) throw new ToolError('give "run" or "group", not both');
-      return plain(["status", ...group ? ["-g", group] : run2 ? [run2] : []], ctx);
-    }
-  },
-  {
-    name: "pitroom_list",
-    title: "List runs",
-    description: "The latest runs with their state, worker and task; with running only the active ones, or one group's.",
-    inputSchema: { type: "object", properties: { running: { type: "boolean", description: "Only runs that are queued or running." }, group: { type: "string", description: "A group name." } } },
-    annotations: READ_ONLY,
-    async call(a, ctx) {
-      const group = str(a, "group");
-      return plain(["ls", ...bool(a, "running") ? ["--running"] : [], ...group ? ["-g", group] : []], ctx);
-    }
-  },
   {
     name: "pitroom_show",
     title: "Show a run",
-    description: "A finished run's report again; with patch the exact diff of an isolated change, with full the untruncated answer.",
-    inputSchema: { type: "object", properties: { run: RUN_ID2, patch: { type: "boolean" }, full: { type: "boolean" } }, required: ["run"] },
+    description: "A run's report (live progress while it runs); patch: the exact diff; full: the untruncated answer.",
+    inputSchema: { type: "object", properties: { run: RUN_ID2, patch: { type: "boolean" }, full: { type: "boolean" } } },
     annotations: READ_ONLY,
     async call(a, ctx) {
-      const run2 = str(a, "run", true);
+      const run2 = str(a, "run") ?? "last";
       return plain(["show", run2, ...bool(a, "patch") ? ["--patch"] : bool(a, "full") ? ["--full"] : []], ctx);
     }
   },
   {
-    name: "pitroom_history",
-    title: "Search past runs",
-    description: "Finished runs from the history, searchable: full-text over the task, the answer and the steps. Use it to find an earlier answer before asking a worker again.",
+    name: "pitroom_info",
+    title: "Pitroom information",
+    description: "Reports, changing nothing. topic: runs (latest runs; running, group), history (search earlier answers before asking again; text, state, model, since, limit), stats (success rate, time, tokens, audits per worker; since), savings (since, perModel), models (a backend's models and costs; worker, all), cooldown (rate-limited models being skipped), config, doctor (setup check).",
     inputSchema: {
       type: "object",
       properties: {
-        text: { type: "string", description: "Words to search for." },
-        state: { type: "string", description: "done, problem, failed, \u2026" },
-        model: { type: "string", description: "Only runs of this model." },
-        since: SINCE,
-        limit: { type: "number", description: "How many runs (default 20)." }
-      }
+        topic: { type: "string", enum: Object.keys(TOPICS) },
+        text: { type: "string" },
+        state: { type: "string" },
+        model: { type: "string" },
+        since: { type: "string", description: "7d, 30d, \u2026 or all." },
+        limit: { type: "number" },
+        running: { type: "boolean" },
+        group: { type: "string" },
+        worker: { type: "string" },
+        all: { type: "boolean" },
+        perModel: { type: "boolean" }
+      },
+      required: ["topic"]
     },
     annotations: READ_ONLY,
     async call(a, ctx) {
-      const limit = a.limit;
-      if (limit !== void 0 && (typeof limit !== "number" || !Number.isInteger(limit) || limit < 1 || limit > 200)) throw new ToolError('"limit" must be a whole number from 1 to 200');
-      const text = str(a, "text");
-      const state = str(a, "state");
-      const model = str(a, "model");
-      return plain(["history", ...since(a), ...state ? ["--state", state] : [], ...model ? ["--model", model] : [], ...limit ? ["--limit", String(limit)] : [], ...text ? ["--", text] : []], ctx);
-    }
-  },
-  {
-    name: "pitroom_stats",
-    title: "Worker statistics",
-    description: "Runs, success rate, average time and tokens per worker and model, and how often their answers were confirmed by audits. Use it to pick a worker.",
-    inputSchema: { type: "object", properties: { since: SINCE } },
-    annotations: READ_ONLY,
-    async call(a, ctx) {
-      return plain(["history", "stats", ...since(a)], ctx);
-    }
-  },
-  {
-    name: "pitroom_savings",
-    title: "What the workers saved",
-    description: "The tokens and money workers took over from you, per model, from the receipts of the runs.",
-    inputSchema: { type: "object", properties: { since: SINCE, models: { type: "boolean", description: "Break it down per model." } } },
-    annotations: READ_ONLY,
-    async call(a, ctx) {
-      return plain(["savings", ...since(a), ...bool(a, "models") ? ["--models"] : []], ctx);
-    }
-  },
-  {
-    name: "pitroom_models",
-    title: "Worker models",
-    description: "The models a worker backend offers, with effort levels, the costs set in the config and recent usage. Use it to choose a model for pitroom_run.",
-    inputSchema: { type: "object", properties: { worker: { type: "string", description: "A backend: opencode, codex, claude, gemini. Default: the configured one." }, all: { type: "boolean", description: "Include models that are hidden by default." } } },
-    annotations: READ_ONLY,
-    async call(a, ctx) {
-      const worker = str(a, "worker");
-      return plain(["models", ...worker ? [worker] : [], ...bool(a, "all") ? ["--all"] : []], ctx);
-    }
-  },
-  {
-    name: "pitroom_cooldown",
-    title: "Rate-limited models",
-    description: 'The models that said "rate limited" and are being skipped for now (runs go to the next worker). With clear they are tried again immediately.',
-    inputSchema: { type: "object", properties: { clear: { type: "boolean", description: "Forget the cooldowns." } } },
-    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    async call(a, ctx) {
-      return plain(["cooldown", ...bool(a, "clear") ? ["--clear"] : []], ctx);
-    }
-  },
-  {
-    name: "pitroom_doctor",
-    title: "Check the setup",
-    description: "Checks the setup without spending tokens: the workers found and their logins, the config, the skills, where the MCP server is registered. Use it when a run fails to start.",
-    inputSchema: { type: "object", properties: {} },
-    annotations: READ_ONLY,
-    async call(_a, ctx) {
-      return plain(["doctor"], ctx, 12e4);
+      if (str(a, "topic") === void 0) throw new ToolError(`"topic" is required: one of ${Object.keys(TOPICS).join(", ")}`);
+      const topic = oneOf(a, "topic", Object.keys(TOPICS), "runs");
+      const { args, timeoutMs } = infoArgs(topic, a);
+      return plain(args, ctx, timeoutMs);
     }
   },
   {
     name: "pitroom_review",
     title: "Review a change",
-    description: `A read-only reviewer (by default another worker than the implementer) judges one run's change, or a range of commits ("main..HEAD"). Returns findings with severities and a SPEC / QUALITY verdict.`,
+    description: `A read-only reviewer (another worker by default) judges a run's change or a commit range ("main..HEAD"): findings with severities and a SPEC / QUALITY verdict.`,
     inputSchema: {
       type: "object",
       properties: {
-        run: { ...RUN_ID2, description: "The run whose change to review (an isolated or in-place change)." },
+        run: RUN_ID2,
         range: { type: "string", description: 'Or a commit range "A..B".' },
-        plan: { type: "string", description: "With range: the plan file the commits implement." },
+        plan: { type: "string", description: "With range: the plan file it implements." },
         worker: WORKER_PROPS.worker,
         tier: WORKER_PROPS.tier,
         dir: WORKER_PROPS.dir,
@@ -4648,7 +4671,7 @@ var TOOLS2 = [
   {
     name: "pitroom_audit",
     title: "Audit an answer",
-    description: "Another worker re-checks a finished read run's answer against the project and says AGREE, PARTIAL or DISAGREE with the claims it disputes.",
+    description: "Another worker re-checks a read run's answer: AGREE, PARTIAL or DISAGREE, with the disputed claims.",
     inputSchema: { type: "object", properties: { run: RUN_ID2, worker: WORKER_PROPS.worker, ...WAIT_PROP }, required: ["run"] },
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
     async call(a, ctx) {
@@ -4660,7 +4683,7 @@ var TOOLS2 = [
   {
     name: "pitroom_apply",
     title: "Apply an isolated change",
-    description: "Land an isolated run's patch on the user's working tree (checked first; refused if it no longer applies cleanly), or every patch of a group in order. A patch that deletes files is refused unless allowDelete is true: only pass it after checking the deletions are what the user asked for.",
+    description: "Land an isolated run's patch (or a group's, in order) on the working tree; checked first. A patch deleting files needs allowDelete: pass it only after checking the deletions were asked for.",
     inputSchema: { type: "object", properties: { run: RUN_ID2, group: { type: "string" }, allowDelete: { type: "boolean" } } },
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
     async call(a, ctx) {
@@ -4668,13 +4691,13 @@ var TOOLS2 = [
       const run2 = str(a, "run");
       if (!run2 && !group) throw new ToolError('give "run" or "group"');
       if (run2 && group) throw new ToolError('give "run" or "group", not both');
-      return plain(["apply", ...group && !run2 ? ["-g", group] : [run2], ...bool(a, "allowDelete") ? ["--allow-delete"] : []], ctx, 12e4);
+      return plain(["apply", ...group ? ["-g", group] : [run2], ...bool(a, "allowDelete") ? ["--allow-delete"] : []], ctx, 12e4);
     }
   },
   {
     name: "pitroom_discard",
     title: "Discard an isolated change",
-    description: "Drop an isolated run's private copy (its patch is kept).",
+    description: "Drop an isolated run's private copy (the patch is kept).",
     inputSchema: { type: "object", properties: { run: RUN_ID2 }, required: ["run"] },
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     async call(a, ctx) {
@@ -4684,7 +4707,7 @@ var TOOLS2 = [
   {
     name: "pitroom_revert",
     title: "Undo an in-place change",
-    description: 'Undo what a mode "write" run changed in the working tree (checked first; refused when the files changed since).',
+    description: `Undo a mode "write" run's changes (refused if the files changed since).`,
     inputSchema: { type: "object", properties: { run: RUN_ID2 }, required: ["run"] },
     annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
     async call(a, ctx) {
@@ -4694,32 +4717,115 @@ var TOOLS2 = [
   {
     name: "pitroom_stop",
     title: "Stop runs",
-    description: "Stop a running or queued run, or every run of a group.",
-    inputSchema: { type: "object", properties: { run: RUN_ID2, group: { type: "string" } } },
+    description: "Stop a running or queued run, or a group; cooldowns: try rate-limited models again now.",
+    inputSchema: { type: "object", properties: { run: RUN_ID2, group: { type: "string" }, cooldowns: { type: "boolean" } } },
     annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     async call(a, ctx) {
       const run2 = str(a, "run");
       const group = str(a, "group");
-      if (!run2 && !group) throw new ToolError('give "run" or "group"');
+      if (bool(a, "cooldowns")) {
+        if (run2 || group) throw new ToolError('"cooldowns" goes alone');
+        return plain(["cooldown", "--clear"], ctx);
+      }
+      if (!run2 && !group) throw new ToolError('give "run" or "group" (or "cooldowns": true)');
       if (run2 && group) throw new ToolError('give "run" or "group", not both');
       return plain(["stop", ...run2 ? [run2] : ["-g", group]], ctx);
     }
   }
 ];
 
+// src/cli/mcp-watch.ts
+var EVERY_MS = 2e3;
+var MAX_SUBSCRIPTIONS = 100;
+var watched = /* @__PURE__ */ new Set();
+var timer;
+var signature = (uri) => {
+  const id = runOfUri(uri);
+  if (!id) return void 0;
+  try {
+    const m = freshMeta(id);
+    return uri.endsWith("/patch") ? `${m.state}:${m.changes?.length ?? 0}` : m.state;
+  } catch {
+    return void 0;
+  }
+};
+var newestRun = () => {
+  try {
+    return listRunIds().at(-1);
+  } catch {
+    return void 0;
+  }
+};
+function subscribe(session, uri) {
+  if (typeof uri !== "string") throw new RpcError(-32602, '"uri" is required');
+  if (!runOfUri(uri)) throw new RpcError(-32602, `only runs can be subscribed to (pitroom://run/<id>): ${uri}`);
+  if (!session.subscriptions.has(uri) && session.subscriptions.size >= MAX_SUBSCRIPTIONS) throw new RpcError(-32602, `at most ${MAX_SUBSCRIPTIONS} subscriptions: unsubscribe from finished runs first`);
+  const sig = signature(uri);
+  if (sig === void 0) throw new RpcError(-32002, `unknown resource: ${uri}`);
+  session.subscriptions.set(uri, sig);
+}
+function unsubscribe(session, uri) {
+  if (typeof uri !== "string") throw new RpcError(-32602, '"uri" is required');
+  session.subscriptions.delete(uri);
+}
+function tick() {
+  const listening = [...watched].filter((s) => s.push);
+  if (!listening.length) return;
+  const newest = newestRun();
+  const seen = /* @__PURE__ */ new Map();
+  for (const s of listening) {
+    const push = s.push;
+    if (newest !== s.newestRun) {
+      s.newestRun = newest;
+      push({ jsonrpc: "2.0", method: "notifications/resources/list_changed" });
+    }
+    for (const [uri, last] of s.subscriptions) {
+      if (!seen.has(uri)) seen.set(uri, signature(uri));
+      const now = seen.get(uri);
+      if (now === last) continue;
+      if (now === void 0) s.subscriptions.delete(uri);
+      else s.subscriptions.set(uri, now);
+      push({ jsonrpc: "2.0", method: "notifications/resources/updated", params: { uri } });
+    }
+  }
+}
+function watch2(session) {
+  session.newestRun = newestRun();
+  watched.add(session);
+  if (!timer) {
+    timer = setInterval(tick, EVERY_MS);
+    timer.unref();
+  }
+}
+function unwatch(session) {
+  watched.delete(session);
+  session.subscriptions.clear();
+  if (!watched.size && timer) {
+    clearInterval(timer);
+    timer = void 0;
+  }
+}
+
 // src/cli/mcp.ts
 var PROTOCOLS = ["2025-06-18", "2025-03-26", "2024-11-05"];
 var INSTRUCTIONS = [
   "Pitroom hands bounded work to cheaper worker agents and returns a verified answer, the exact diff and a cost receipt. You decide, verify and answer.",
-  'Use pitroom_run with mode "read" for research and locating code, mode "isolate" for code changes (the worker edits a copy; check it with pitroom_review, then pitroom_apply or pitroom_discard); pitroom_crew for independent tasks in parallel.',
+  'Use pitroom_run with mode "read" for research and locating code, mode "isolate" for code changes (the worker edits a copy; check it with pitroom_review, then pitroom_apply or pitroom_discard); pitroom_run with "tasks" for independent tasks in parallel; pitroom_info (topic history) finds an earlier answer before you ask again.',
   'A run can take minutes: pitroom_run waits up to waitSeconds, then returns the run id as "still running"; call pitroom_wait with it.',
+  "Pitroom's skills (using-pitroom, pitroom-research, pitroom-implement, pitroom-review, pitroom-crew, pitroom-debugging, pitroom-tdd and more) say when to delegate and how to check what comes back: if you have them, use the matching one alongside these tools; if not, the prompts of the same names hold them.",
   "It is optional: for a small task you can do yourself, skip it."
 ].join(" ");
 var log = (msg) => void process.stderr.write(`pitroom mcp: ${msg}
 `);
-var newSession = () => ({ inflight: /* @__PURE__ */ new Map() });
+function newSession() {
+  const session = { inflight: /* @__PURE__ */ new Map(), subscriptions: /* @__PURE__ */ new Map() };
+  watch2(session);
+  return session;
+}
 function endSession(session) {
   for (const { abort } of session.inflight.values()) abort.abort("closed");
+  unwatch(session);
+  session.push = void 0;
 }
 function progressToken(params) {
   const meta = params && typeof params === "object" ? params._meta : void 0;
@@ -4737,13 +4843,13 @@ function contextFor(params, abort, notify) {
     }
   };
 }
-async function dispatch(method, params, ctx) {
+async function dispatch(method, params, ctx, session) {
   switch (method) {
     case "initialize": {
       const asked = typeof params.protocolVersion === "string" ? params.protocolVersion : "";
       return {
         protocolVersion: PROTOCOLS.includes(asked) ? asked : PROTOCOLS[0],
-        capabilities: { tools: { listChanged: false }, resources: { listChanged: false, subscribe: false }, prompts: { listChanged: false } },
+        capabilities: { tools: { listChanged: false }, resources: { listChanged: true, subscribe: true }, prompts: { listChanged: false } },
         serverInfo: { name: "pitroom", title: "Pitroom", version: VERSION2 },
         instructions: INSTRUCTIONS
       };
@@ -4772,6 +4878,12 @@ async function dispatch(method, params, ctx) {
     case "resources/read":
       if (typeof params.uri !== "string") throw new RpcError(-32602, '"uri" is required');
       return readResource(params.uri, ctx);
+    case "resources/subscribe":
+      subscribe(session, params.uri);
+      return {};
+    case "resources/unsubscribe":
+      unsubscribe(session, params.uri);
+      return {};
     case "prompts/list":
       return listPrompts();
     case "prompts/get":
@@ -4799,7 +4911,7 @@ async function handle(session, msg, notify) {
   const entry = { abort, ctx: contextFor(params, abort, notify) };
   if (isRequest) session.inflight.set(m.id, entry);
   try {
-    const result = await dispatch(m.method, params, entry.ctx);
+    const result = await dispatch(m.method, params, entry.ctx, session);
     if (abort.signal.aborted && abort.signal.reason === "cancelled") return void 0;
     return isRequest ? { jsonrpc: "2.0", id: m.id, result } : void 0;
   } catch (e) {
@@ -4824,6 +4936,7 @@ async function serveMcp() {
   const send = (msg) => void process.stdout.write(`${JSON.stringify(msg)}
 `);
   const session = newSession();
+  session.push = send;
   const rl = readline.createInterface({ input: process.stdin });
   const pending = /* @__PURE__ */ new Set();
   const handleLine = async (line) => {
@@ -4844,28 +4957,29 @@ async function serveMcp() {
     void p.finally(() => pending.delete(p));
   });
   await new Promise((resolve2) => rl.once("close", resolve2));
+  unwatch(session);
   await Promise.allSettled([...pending]);
   return 0;
 }
 
 // src/cli/mcp-http.ts
 import crypto7 from "node:crypto";
-import fs26 from "node:fs";
+import fs27 from "node:fs";
 import http2 from "node:http";
-import path22 from "node:path";
+import path23 from "node:path";
 
 // src/core/dash.ts
 import { spawn as spawn4 } from "node:child_process";
 import crypto6 from "node:crypto";
-import fs25 from "node:fs";
+import fs26 from "node:fs";
 import http from "node:http";
-import path21 from "node:path";
+import path22 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/core/file-diff.ts
 var PREVIEW_LINES = 300;
 function gitPath(value, prefix = true) {
-  let path29 = value;
+  let path31 = value;
   if (value.startsWith('"') && value.endsWith('"')) {
     const bytes = [];
     const escapes = { t: "	", n: "\n", r: "\r", b: "\b", f: "\f", v: "\v" };
@@ -4873,9 +4987,9 @@ function gitPath(value, prefix = true) {
       if (match[1] && /^[0-7]+$/.test(match[1])) bytes.push(parseInt(match[1], 8));
       else bytes.push(...new TextEncoder().encode(match[2] ?? escapes[match[1]] ?? match[1]));
     }
-    path29 = new TextDecoder().decode(new Uint8Array(bytes));
+    path31 = new TextDecoder().decode(new Uint8Array(bytes));
   }
-  return prefix ? path29.replace(/^[ab]\//, "") : path29;
+  return prefix ? path31.replace(/^[ab]\//, "") : path31;
 }
 function headerPath(header) {
   const quoted = header.match(/^diff --git ("(?:[^"\\]|\\.)*"|\S+) ("(?:[^"\\]|\\.)*"|\S+)$/);
@@ -5005,6 +5119,7 @@ function toRun(m) {
   return {
     id: m.id,
     state: m.state,
+    verifyFailed: m.verifyResult && !m.verifyResult.ok ? true : void 0,
     kind: kind(m),
     // the model that really ran, once the CLI has said which; until then just the worker, never a guess
     worker: workerName(ranTarget(m)),
@@ -5019,7 +5134,7 @@ function toRun(m) {
     audit: auditBadge(m),
     changes: m.changes?.length || void 0,
     applied: m.applied || void 0,
-    note: l?.last ? oneLine7(String(l.last), 140) : isActive(m.state) ? "" : m.verdict ? findings(m) : m.auditOf && m.state === "done" ? m.auditDisputed?.length ? `${m.auditDisputed.length} disputed` : "nothing disputed" : headline(m, 200) || oneLine7(m.error ?? "", 200)
+    note: l?.last ? oneLine7(String(l.last), 140) : isActive(m.state) ? "" : m.verifyResult && !m.verifyResult.ok ? `verify failed: ${m.verify ?? ""}` : m.verdict ? findings(m) : m.auditOf && m.state === "done" ? m.auditDisputed?.length ? `${m.auditDisputed.length} disputed` : "nothing disputed" : headline(m, 200) || oneLine7(m.error ?? "", 200)
   };
 }
 function dashState(opts = {}) {
@@ -5123,11 +5238,11 @@ var assetsDir = () => fileURLToPath3(new URL("./ui/", import.meta.url));
 var assetCache = /* @__PURE__ */ new Map();
 function readAsset(route) {
   try {
-    const file2 = path21.join(assetsDir(), path21.basename(route));
-    const { mtimeMs } = fs25.statSync(file2);
+    const file2 = path22.join(assetsDir(), path22.basename(route));
+    const { mtimeMs } = fs26.statSync(file2);
     const hit = assetCache.get(route);
     if (hit && hit.mtimeMs === mtimeMs) return hit.data;
-    const data = fs25.readFileSync(file2);
+    const data = fs26.readFileSync(file2);
     assetCache.set(route, { mtimeMs, data });
     return data;
   } catch {
@@ -5160,21 +5275,21 @@ function handler(touch2) {
     }
     if (url.pathname === "/api/history") {
       const q = url.searchParams;
-      const days = Number(q.get("days") ?? 0);
+      const days2 = Number(q.get("days") ?? 0);
       return json(res, 200, listHistory({
         text: (q.get("q") ?? "").slice(0, 200),
         model: q.get("model") || void 0,
         backend: q.get("backend") || void 0,
         state: q.get("state") || void 0,
         group: q.get("group") || void 0,
-        sinceMs: days > 0 ? Date.now() - days * 864e5 : void 0,
+        sinceMs: days2 > 0 ? Date.now() - days2 * 864e5 : void 0,
         beforeId: RUN_ID3.test(q.get("before") ?? "") ? q.get("before") : void 0,
         limit: Number(q.get("limit") ?? 30) || 30
       }));
     }
     if (url.pathname === "/api/stats") {
-      const days = Number(url.searchParams.get("days") ?? 30);
-      return json(res, 200, { ...historyStats(days > 0 ? Date.now() - days * 864e5 : void 0), price: primaryPrice().name });
+      const days2 = Number(url.searchParams.get("days") ?? 30);
+      return json(res, 200, { ...historyStats(days2 > 0 ? Date.now() - days2 * 864e5 : void 0), price: primaryPrice().name });
     }
     const m = /^\/api\/run\/([^/]+)$/.exec(url.pathname);
     if (m) {
@@ -5193,21 +5308,21 @@ function startDash(opts) {
       const port = server.address().port;
       let done;
       const closed = new Promise((r) => done = r);
-      let timer;
+      let timer2;
       const close = () => {
-        if (timer) clearInterval(timer);
+        if (timer2) clearInterval(timer2);
         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();
+        timer2 = setInterval(() => Date.now() - lastRequest > opts.idleMs && void close(), Math.min(6e4, opts.idleMs));
+        timer2.unref();
       }
       resolve2({ port, url: `http://127.0.0.1:${port}/`, closed, close });
     });
   });
 }
-var registryFile = () => path21.join(home(), "dash.json");
+var registryFile = () => path22.join(home(), "dash.json");
 async function ping(port) {
   try {
     const r = await fetch(`http://127.0.0.1:${port}/api/state?limit=1`, { signal: AbortSignal.timeout(1500) });
@@ -5218,11 +5333,11 @@ async function ping(port) {
 }
 async function runningDash() {
   try {
-    const r = JSON.parse(fs25.readFileSync(registryFile(), "utf8"));
+    const r = JSON.parse(fs26.readFileSync(registryFile(), "utf8"));
     if (isAlive(r.pid) && await ping(r.port)) return { ...r, url: `http://127.0.0.1:${r.port}/` };
   } catch {
   }
-  fs25.rmSync(registryFile(), { force: true });
+  fs26.rmSync(registryFile(), { force: true });
   return void 0;
 }
 function openBrowser(url) {
@@ -5237,7 +5352,7 @@ async function dashCommand(o) {
   if (o.stop) {
     if (!existing) throw new UserError("pitroom dash is not running");
     process.kill(existing.pid, "SIGTERM");
-    fs25.rmSync(registryFile(), { force: true });
+    fs26.rmSync(registryFile(), { force: true });
     o.log(`stopped pitroom dash (${existing.url})`);
     return 0;
   }
@@ -5274,8 +5389,8 @@ async function dashCommand(o) {
     if (explicit || e.code !== "EADDRINUSE") throw new UserError(`pitroom dash: ${e.message}`);
     dash = await startDash({ port: 0, idleMs: o.idleMs });
   }
-  fs25.mkdirSync(home(), { recursive: true });
-  fs25.writeFileSync(registryFile(), JSON.stringify({ pid: process.pid, port: dash.port }));
+  fs26.mkdirSync(home(), { recursive: true });
+  fs26.writeFileSync(registryFile(), JSON.stringify({ pid: process.pid, port: dash.port }));
   const stop = () => void dash.close();
   process.once("SIGINT", stop);
   process.once("SIGTERM", stop);
@@ -5284,7 +5399,7 @@ async function dashCommand(o) {
   if (o.open) openBrowser(dash.url);
   await dash.closed;
   try {
-    if (JSON.parse(fs25.readFileSync(registryFile(), "utf8")).pid === process.pid) fs25.rmSync(registryFile(), { force: true });
+    if (JSON.parse(fs26.readFileSync(registryFile(), "utf8")).pid === process.pid) fs26.rmSync(registryFile(), { force: true });
   } catch {
   }
   return 0;
@@ -5296,10 +5411,10 @@ var MAX_BODY = 4e6;
 var MAX_SESSIONS = 64;
 var IDLE_MS = 60 * 6e4;
 var PATH = "/mcp";
-var tokenFile = () => path22.join(home(), "mcp-token");
+var tokenFile = () => path23.join(home(), "mcp-token");
 var readToken = (file2) => {
   try {
-    const kept = fs26.readFileSync(file2, "utf8").trim();
+    const kept = fs27.readFileSync(file2, "utf8").trim();
     return kept.length >= 16 ? kept : void 0;
   } catch {
     return void 0;
@@ -5314,10 +5429,10 @@ function mcpToken() {
   const file2 = tokenFile();
   let token = readToken(file2);
   if (!token) {
-    fs26.mkdirSync(path22.dirname(file2), { recursive: true });
+    fs27.mkdirSync(path23.dirname(file2), { recursive: true });
     token = crypto7.randomBytes(32).toString("hex");
     try {
-      fs26.writeFileSync(file2, `${token}
+      fs27.writeFileSync(file2, `${token}
 `, { mode: 384, flag: "wx" });
     } catch (e) {
       if (e.code !== "EEXIST") throw e;
@@ -5326,7 +5441,7 @@ function mcpToken() {
     }
   }
   try {
-    fs26.chmodSync(file2, 384);
+    fs27.chmodSync(file2, 384);
   } catch {
   }
   return { token, from: file2 };
@@ -5337,6 +5452,15 @@ var sameSecret = (given, token) => {
   const b = crypto7.createHash("sha256").update(token).digest();
   return crypto7.timingSafeEqual(a, b);
 };
+var idleSince = (k) => Math.max(k.lastSeen, k.closeStream ? k.streamSeen ?? 0 : 0);
+function drop(sessions, id) {
+  const k = sessions.get(id);
+  if (!k) return;
+  k.closeStream?.();
+  endSession(k.session);
+  sessions.delete(id);
+}
+var PING_MS = 25e3;
 function reply(res, status, body, headers = {}) {
   if (res.headersSent) return void res.end();
   const text = body === void 0 ? "" : JSON.stringify(body);
@@ -5362,9 +5486,9 @@ var wantsStream = (parsed) => {
 };
 function evictIdle(sessions) {
   let oldest;
-  for (const entry of sessions) if (!entry[1].session.inflight.size && (!oldest || entry[1].lastSeen < oldest[1].lastSeen)) oldest = entry;
+  for (const entry of sessions) if (!entry[1].session.inflight.size && (!oldest || idleSince(entry[1]) < idleSince(oldest[1]))) oldest = entry;
   if (!oldest) return false;
-  sessions.delete(oldest[0]);
+  drop(sessions, oldest[0]);
   return true;
 }
 function makeHandler(token, sessions) {
@@ -5378,13 +5502,44 @@ function makeHandler(token, sessions) {
     if (!auth || !sameSecret(auth, token)) return reply(res, 401, failure5(-32001, "a bearer token is needed"), { "WWW-Authenticate": "Bearer" });
     const sid = typeof req.headers["mcp-session-id"] === "string" ? req.headers["mcp-session-id"] : void 0;
     if (req.method === "DELETE") {
-      const kept2 = sid ? sessions.get(sid) : void 0;
-      if (!kept2) return reply(res, 404, failure5(-32600, "no such session"));
-      endSession(kept2.session);
-      sessions.delete(sid);
+      if (!sid || !sessions.has(sid)) return reply(res, 404, failure5(-32600, "no such session"));
+      drop(sessions, sid);
       return reply(res, 204);
     }
-    if (req.method !== "POST") return reply(res, 405, failure5(-32600, "POST requests only"), { Allow: "POST, DELETE" });
+    if (req.method === "GET") {
+      if (!/text\/event-stream|\*\/\*/.test(req.headers.accept ?? "")) return reply(res, 406, failure5(-32600, "a GET opens the event stream: send Accept: text/event-stream"));
+      if (!sid) return reply(res, 400, failure5(-32600, "Mcp-Session-Id is missing: initialize first"));
+      const kept2 = sessions.get(sid);
+      if (!kept2) return reply(res, 404, failure5(-32600, "no such session: initialize again"));
+      kept2.closeStream?.();
+      res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache" });
+      res.write(": open\n\n");
+      const open = () => !res.writableEnded && !res.destroyed;
+      const push = (msg) => {
+        if (!open()) return;
+        kept2.streamSeen = Date.now();
+        res.write(`event: message
+data: ${JSON.stringify(msg)}
+
+`);
+      };
+      const ping2 = setInterval(() => open() && res.write(": ping\n\n"), PING_MS);
+      ping2.unref();
+      res.on("error", () => {
+      });
+      kept2.streamSeen = Date.now();
+      const close = () => {
+        clearInterval(ping2);
+        if (kept2.session.push === push) kept2.session.push = void 0;
+        if (kept2.closeStream === close) kept2.closeStream = void 0;
+        if (!res.writableEnded) res.end();
+      };
+      kept2.session.push = push;
+      kept2.closeStream = close;
+      res.on("close", close);
+      return;
+    }
+    if (req.method !== "POST") return reply(res, 405, failure5(-32600, "GET, POST or DELETE"), { Allow: "GET, POST, DELETE" });
     const body = await readBody(req);
     if (body === "too-big") return reply(res, 413, failure5(-32600, `a request body is at most ${MAX_BODY} bytes`));
     let parsed;
@@ -5397,12 +5552,8 @@ function makeHandler(token, sessions) {
     let kept;
     const single = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
     if (single?.method === "initialize") {
-      const old = sid ? sessions.get(sid) : void 0;
-      if (old) {
-        endSession(old.session);
-        sessions.delete(sid);
-      }
-      if (sessions.size >= MAX_SESSIONS && !evictIdle(sessions)) return reply(res, 503, failure5(-32e3, "too many sessions with requests in flight"));
+      if (sid) drop(sessions, sid);
+      if (sessions.size >= MAX_SESSIONS && !evictIdle(sessions)) return reply(res, 503, failure5(-32e3, `${MAX_SESSIONS} sessions are busy with requests: try again when one ends`));
       const id = crypto7.randomUUID();
       kept = { session: newSession(), lastSeen: Date.now() };
       sessions.set(id, kept);
@@ -5444,7 +5595,7 @@ async function serveMcpHttp(opts) {
     });
   });
   const sweep = setInterval(() => {
-    for (const [id, k] of sessions) if (Date.now() - k.lastSeen > IDLE_MS && !k.session.inflight.size) sessions.delete(id);
+    for (const [id, k] of [...sessions]) if (Date.now() - idleSince(k) > IDLE_MS && !k.session.inflight.size) drop(sessions, id);
   }, 6e4);
   sweep.unref();
   const port = await new Promise((resolve2, reject) => {
@@ -5464,7 +5615,7 @@ async function serveMcpHttp(opts) {
     process.once("SIGTERM", stop);
   });
   clearInterval(sweep);
-  for (const k of sessions.values()) endSession(k.session);
+  for (const id of [...sessions.keys()]) drop(sessions, id);
   server.closeAllConnections();
   await new Promise((resolve2) => server.close(() => resolve2()));
   return 0;
@@ -5472,16 +5623,16 @@ async function serveMcpHttp(opts) {
 
 // src/cli/commands.ts
 import { spawnSync as spawnSync8 } from "node:child_process";
-import fs31 from "node:fs";
-import path27 from "node:path";
+import fs33 from "node:fs";
+import path29 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // src/core/init.ts
-import fs27 from "node:fs";
-import path23 from "node:path";
+import fs28 from "node:fs";
+import path24 from "node:path";
 var FREE = /-free$/;
 var TIER_ORDER = [["cheap", "opencode"], ["standard", "codex"], ["capable", "claude"]];
-var isFound = (binary5) => path23.isAbsolute(binary5) && fs27.existsSync(binary5);
+var isFound = (binary5) => path24.isAbsolute(binary5) && fs28.existsSync(binary5);
 function planInit(opts = {}) {
   const file2 = configPath();
   const workers = backendIds().map((id) => {
@@ -5527,15 +5678,15 @@ function planInit(opts = {}) {
   if (Object.keys(tiers).length > 1) config.tiers = tiers;
   if (!workers.some((w) => w.found)) blocked = "no worker CLI found: install OpenCode (https://opencode.ai), Codex CLI, Claude Code or Gemini CLI first";
   else if (!blocked && !Object.keys(config).length) notes.push("nothing to propose: the default model and the single worker need no config");
-  return { path: file2, exists: fs27.existsSync(file2), workers, opencode: opencode2, config, blocked, notes };
+  return { path: file2, exists: fs28.existsSync(file2), workers, opencode: opencode2, config, blocked, notes };
 }
 function writeInit(plan, force) {
   if (plan.blocked) throw new UserError(plan.blocked);
   if (!Object.keys(plan.config).length) throw new UserError("nothing to write: the proposal is empty");
-  if (plan.exists && !force) throw new UserError(`${plan.path} already exists: pass --force to replace it (the old file is kept as ${path23.basename(plan.path)}.bak)`);
-  fs27.mkdirSync(path23.dirname(plan.path), { recursive: true });
-  if (plan.exists) fs27.copyFileSync(plan.path, `${plan.path}.bak`);
-  fs27.writeFileSync(plan.path, `${JSON.stringify(plan.config, null, 2)}
+  if (plan.exists && !force) throw new UserError(`${plan.path} already exists: pass --force to replace it (the old file is kept as ${path24.basename(plan.path)}.bak)`);
+  fs28.mkdirSync(path24.dirname(plan.path), { recursive: true });
+  if (plan.exists) fs28.copyFileSync(plan.path, `${plan.path}.bak`);
+  fs28.writeFileSync(plan.path, `${JSON.stringify(plan.config, null, 2)}
 `);
   return plan.path;
 }
@@ -5556,17 +5707,17 @@ function formatInit(plan, written) {
 
 // src/core/mcp-install.ts
 import { spawnSync as spawnSync7 } from "node:child_process";
-import fs28 from "node:fs";
+import fs29 from "node:fs";
 import os10 from "node:os";
-import path24 from "node:path";
+import path25 from "node:path";
 var CLIENT_IDS = ["claude-code", "codex", "gemini", "cursor", "claude-desktop"];
 var NAME = "pitroom";
 function mcpCommand() {
   const launcher = launcherPath();
   if (isPitroomLauncher(launcher)) return { command: launcher, args: ["mcp"] };
-  for (const dir of (process.env.PATH ?? "").split(path24.delimiter).filter(Boolean)) {
-    const p = path24.join(dir, process.platform === "win32" ? "pitroom.cmd" : "pitroom");
-    if (fs28.existsSync(p)) return { command: path24.resolve(p), args: ["mcp"] };
+  for (const dir of (process.env.PATH ?? "").split(path25.delimiter).filter(Boolean)) {
+    const p = path25.join(dir, process.platform === "win32" ? "pitroom.cmd" : "pitroom");
+    if (fs29.existsSync(p)) return { command: path25.resolve(p), args: ["mcp"] };
   }
   return { command: process.execPath, args: [process.argv[1] ?? "pitroom", "mcp"] };
 }
@@ -5582,7 +5733,7 @@ function run(backendId, args) {
 var runnable = (backendId) => run(backendId, ["--version"]).ok;
 var readJson = (file2) => {
   try {
-    return JSON.parse(fs28.readFileSync(file2, "utf8"));
+    return JSON.parse(fs29.readFileSync(file2, "utf8"));
   } catch {
     return void 0;
   }
@@ -5592,7 +5743,7 @@ var jsonState = (file2, c) => {
   return entry === void 0 ? "absent" : same(c, entry) ? "same" : "different";
 };
 var home2 = () => os10.homedir();
-var geminiDir = () => path24.join(process.env.GEMINI_CLI_HOME ?? home2(), ".gemini");
+var geminiDir = () => path25.join(process.env.GEMINI_CLI_HOME ?? home2(), ".gemini");
 function cliClient(id, backend, name, where, o) {
   return {
     id,
@@ -5615,43 +5766,43 @@ function jsonClient(id, name, file2, dir) {
   return {
     id,
     name,
-    found: () => fs28.existsSync(dir()),
+    found: () => fs29.existsSync(dir()),
     state: (c) => jsonState(file2(), c),
     add: (c) => {
       let config = {};
-      if (fs28.existsSync(file2())) {
+      if (fs29.existsSync(file2())) {
         config = readJson(file2());
         if (!config || typeof config !== "object" || Array.isArray(config)) return { ok: false, message: `${rel()} is not valid JSON: left alone` };
         const backup = `${file2()}.bak-pitroom`;
-        if (!fs28.existsSync(backup)) fs28.copyFileSync(file2(), backup);
+        if (!fs29.existsSync(backup)) fs29.copyFileSync(file2(), backup);
       }
       config.mcpServers = { ...config.mcpServers ?? {}, [NAME]: { command: c.command, args: c.args } };
-      fs28.mkdirSync(path24.dirname(file2()), { recursive: true });
+      fs29.mkdirSync(path25.dirname(file2()), { recursive: true });
       const tmp = `${file2()}.${process.pid}.tmp`;
-      fs28.writeFileSync(tmp, `${JSON.stringify(config, null, 2)}
+      fs29.writeFileSync(tmp, `${JSON.stringify(config, null, 2)}
 `);
-      fs28.renameSync(tmp, file2());
+      fs29.renameSync(tmp, file2());
       return { ok: true, message: rel() };
     },
     remove: () => {
       const config = readJson(file2());
       if (!config?.mcpServers?.[NAME]) return { ok: true, message: rel() };
       delete config.mcpServers[NAME];
-      fs28.writeFileSync(file2(), `${JSON.stringify(config, null, 2)}
+      fs29.writeFileSync(file2(), `${JSON.stringify(config, null, 2)}
 `);
       return { ok: true, message: rel() };
     }
   };
 }
 function desktopFile() {
-  if (process.platform === "darwin") return path24.join(home2(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
-  if (process.platform === "win32") return path24.join(process.env.APPDATA ?? path24.join(home2(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
-  return path24.join(process.env.XDG_CONFIG_HOME ?? path24.join(home2(), ".config"), "Claude", "claude_desktop_config.json");
+  if (process.platform === "darwin") return path25.join(home2(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  if (process.platform === "win32") return path25.join(process.env.APPDATA ?? path25.join(home2(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+  return path25.join(process.env.XDG_CONFIG_HOME ?? path25.join(home2(), ".config"), "Claude", "claude_desktop_config.json");
 }
 function codexState(c) {
   let text;
   try {
-    text = fs28.readFileSync(path24.join(process.env.CODEX_HOME ?? path24.join(home2(), ".codex"), "config.toml"), "utf8");
+    text = fs29.readFileSync(path25.join(process.env.CODEX_HOME ?? path25.join(home2(), ".codex"), "config.toml"), "utf8");
   } catch {
     return "absent";
   }
@@ -5669,7 +5820,7 @@ function codexState(c) {
 function clients() {
   return [
     cliClient("claude-code", "claude", "Claude Code", "user settings (~/.claude.json)", {
-      state: (c) => jsonState(path24.join(home2(), ".claude.json"), c),
+      state: (c) => jsonState(path25.join(home2(), ".claude.json"), c),
       add: (c) => ["mcp", "add", "--scope", "user", NAME, "--", c.command, ...c.args],
       remove: () => ["mcp", "remove", NAME, "--scope", "user"]
     }),
@@ -5679,12 +5830,12 @@ function clients() {
       remove: () => ["mcp", "remove", NAME]
     }),
     cliClient("gemini", "gemini", "Gemini CLI", "user settings (~/.gemini/settings.json)", {
-      state: (c) => jsonState(path24.join(geminiDir(), "settings.json"), c),
+      state: (c) => jsonState(path25.join(geminiDir(), "settings.json"), c),
       add: (c) => ["mcp", "add", "--scope", "user", NAME, c.command, ...c.args],
       remove: () => ["mcp", "remove", "--scope", "user", NAME]
     }),
-    jsonClient("cursor", "Cursor", () => path24.join(home2(), ".cursor", "mcp.json"), () => path24.join(home2(), ".cursor")),
-    jsonClient("claude-desktop", "Claude Desktop", desktopFile, () => path24.dirname(desktopFile()))
+    jsonClient("cursor", "Cursor", () => path25.join(home2(), ".cursor", "mcp.json"), () => path25.join(home2(), ".cursor")),
+    jsonClient("claude-desktop", "Claude Desktop", desktopFile, () => path25.dirname(desktopFile()))
   ];
 }
 function attempt2(f) {
@@ -5755,16 +5906,16 @@ var parseClients = (value) => {
 
 // src/core/plan-status.ts
 import crypto8 from "node:crypto";
-import fs29 from "node:fs";
-import path25 from "node:path";
+import fs30 from "node:fs";
+import path26 from "node:path";
 function notesFile(plan) {
   const id = crypto8.createHash("sha1").update(plan.file).digest("hex").slice(0, 12);
-  return path25.join(home(), "plans", id, "notes.md");
+  return path26.join(home(), "plans", id, "notes.md");
 }
 function readNotes(plan) {
   const f = notesFile(plan);
-  if (!fs29.existsSync(f)) return [];
-  return fs29.readFileSync(f, "utf8").split("\n").slice(1).filter(Boolean).map((l) => {
+  if (!fs30.existsSync(f)) return [];
+  return fs30.readFileSync(f, "utf8").split("\n").slice(1).filter(Boolean).map((l) => {
     const m = /^(\d{4}-\d\d-\d\d \d\d:\d\d) (.*)$/.exec(l);
     return m ? { at: m[1], text: m[2] } : { at: "", text: l };
   });
@@ -5772,11 +5923,11 @@ function readNotes(plan) {
 function addNote(planFile, text) {
   const plan = loadPlan(planFile);
   const f = notesFile(plan);
-  fs29.mkdirSync(path25.dirname(f), { recursive: true });
-  if (!fs29.existsSync(f)) fs29.writeFileSync(f, `# plan: ${plan.file}
+  fs30.mkdirSync(path26.dirname(f), { recursive: true });
+  if (!fs30.existsSync(f)) fs30.writeFileSync(f, `# plan: ${plan.file}
 `);
   const at = (/* @__PURE__ */ new Date()).toISOString().slice(0, 16).replace("T", " ");
-  fs29.appendFileSync(f, `${at} ${text.replace(/\s+/g, " ").trim()}
+  fs30.appendFileSync(f, `${at} ${text.replace(/\s+/g, " ").trim()}
 `);
   return f;
 }
@@ -5842,10 +5993,73 @@ ${rulings}`,
   ].join("\n");
 }
 
-// src/core/review.ts
+// src/core/cache.ts
 import crypto9 from "node:crypto";
-import fs30 from "node:fs";
-import path26 from "node:path";
+import fs31 from "node:fs";
+import path27 from "node:path";
+var SCAN2 = 500;
+function cacheKey(o) {
+  if (o.verify || o.mode !== "read" || o.continueFrom || o.web || o.plan || o.review || o.audit || o.auditRate === 1) return void 0;
+  if (!(effective().cacheDays.value > 0)) return void 0;
+  const dir = path27.resolve(o.dir);
+  const root = repoRoot(dir);
+  if (!root) return void 0;
+  try {
+    const tree = snapshotTree(root);
+    const head = commitOf(root, "HEAD") ?? "";
+    const files = o.files.map((f) => {
+      const abs = path27.resolve(f);
+      return [abs, crypto9.createHash("sha256").update(fs31.readFileSync(abs)).digest("hex")];
+    });
+    const question = o.task.replace(/\s+/g, " ").trim();
+    const readIn2 = READ_IN.includes(effective().readIn.value) ? effective().readIn.value : "auto";
+    const where = !o.inPlace && wantSnapshot(readIn2, root, dir) ? "snapshot" : "project";
+    const key = crypto9.createHash("sha256").update(JSON.stringify([question, path27.relative(root, dir), files, where])).digest("hex");
+    return { key, state: `${head}:${tree}` };
+  } catch {
+    return void 0;
+  }
+}
+function heldUp(m) {
+  if (m.state !== "done" || m.mode !== "read" || m.reviewOf || m.auditOf) return false;
+  if (m.refs && m.refs.invalid.length) return false;
+  if (m.warnings.some((w) => w.startsWith("READ-ONLY VIOLATION"))) return false;
+  if (m.audit && (isActive(m.audit.state) || m.audit.verdict === "disagree" || m.audit.verdict === "partial")) return false;
+  try {
+    return readSummary(m).trim() !== "";
+  } catch {
+    return false;
+  }
+}
+function findCached(k, now = Date.now()) {
+  const maxAge = effective().cacheDays.value * 864e5;
+  let best;
+  for (const id of listRunIds().slice(-SCAN2)) {
+    let m;
+    try {
+      m = readMeta(id);
+    } catch {
+      continue;
+    }
+    if (m.cache?.key !== k.key || m.cache.state !== k.state) continue;
+    const at = Date.parse(m.endedAt ?? m.startedAt);
+    if (now - at > maxAge || best && at <= best.at || !heldUp(m)) continue;
+    best = { m, at };
+  }
+  return best?.m;
+}
+function ago(iso, now = Date.now()) {
+  const s = Math.max(0, (now - Date.parse(iso)) / 1e3);
+  if (s < 3600) return `${Math.max(1, Math.round(s / 60))} min ago`;
+  if (s < 86400) return `${Math.round(s / 3600)} h ago`;
+  return `${Math.round(s / 86400)} d ago`;
+}
+var cachedNote = (m) => `pitroom \u27F2 cached answer \xB7 the same question on the same code as run ${m.id} (${ago(m.endedAt ?? m.startedAt)}) \xB7 no worker ran \xB7 --fresh asks one again`;
+
+// src/core/review.ts
+import crypto10 from "node:crypto";
+import fs32 from "node:fs";
+import path28 from "node:path";
 var TEMPLATE2 = { task: "task-reviewer", fix: "re-review", range: "code-reviewer" };
 var section = (title, body) => `## ${title}
 
@@ -5863,7 +6077,7 @@ function ancestors(m) {
 function briefOf(m) {
   const root = [m, ...ancestors(m)].at(-1);
   const f = runFile(root.id, "brief.md");
-  return fs30.existsSync(f) ? fs30.readFileSync(f, "utf8") : root.task;
+  return fs32.existsSync(f) ? fs32.readFileSync(f, "utf8") : root.task;
 }
 function latestReview(ids) {
   for (const id of listRunIds().reverse()) {
@@ -5877,7 +6091,7 @@ function latestReview(ids) {
 }
 function diffOf(m, from = m.baseTree) {
   const where = m.mode === "isolate" ? m.worktree : m.repoRoot;
-  if (where && fs30.existsSync(where) && from && m.afterTree) return reviewDiff(where, from, m.afterTree);
+  if (where && fs32.existsSync(where) && from && m.afterTree) return reviewDiff(where, from, m.afterTree);
   if (from !== m.baseTree) {
     throw new UserError(`the isolated copy of ${m.id} is gone, so its fix round cannot be shown on its own; review a run that is not applied yet`, 3);
   }
@@ -5891,7 +6105,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 && fs30.existsSync(m.worktree) ? m.cwd : m.dir;
+  const dir = m.mode === "isolate" && m.worktree && fs32.existsSync(m.worktree) ? m.cwd : m.dir;
   const job = { of: m.id, dir, implementer: m.ran ?? m.worker, group: m.group, plan: m.plan };
   const title = m.plan ? `Task ${m.plan.step}: ${m.plan.title}` : `run ${m.id}`;
   if (!previous) {
@@ -5964,12 +6178,25 @@ function pickReviewer(job) {
 }
 function writePackage(job) {
   const g = gitDir(job.dir);
-  if (!g) throw new UserError(`not a git repository: ${job.dir}`);
-  const file2 = path26.join(g, "pitroom", `review-${crypto9.randomBytes(4).toString("hex")}.md`);
-  fs30.mkdirSync(path26.dirname(file2), { recursive: true });
-  fs30.writeFileSync(file2, job.package);
+  const root = repoRoot(job.dir);
+  if (!g || !root) throw new UserError(`not a git repository: ${job.dir}`);
+  const name = `review-${crypto10.randomBytes(4).toString("hex")}.md`;
+  const inside2 = !path28.relative(fs32.realpathSync(root), fs32.realpathSync(g)).startsWith("..");
+  const file2 = inside2 ? path28.join(g, "pitroom", name) : path28.join(root, ".pitroom", name);
+  if (!inside2) ignoreInGit(root, "/.pitroom/");
+  fs32.mkdirSync(path28.dirname(file2), { recursive: true });
+  fs32.writeFileSync(file2, job.package);
   return file2;
 }
+function ignoreInGit(root, pattern) {
+  const exclude = path28.resolve(root, git(root, ["rev-parse", "--git-path", "info/exclude"]).stdout.trim());
+  const text = fs32.existsSync(exclude) ? fs32.readFileSync(exclude, "utf8") : "";
+  if (text.split(/\r?\n/).includes(pattern)) return;
+  fs32.mkdirSync(path28.dirname(exclude), { recursive: true });
+  fs32.appendFileSync(exclude, `${text && !text.endsWith("\n") ? "\n" : ""}# Pitroom review packages in worktrees (removed after each review)
+${pattern}
+`);
+}
 
 // src/core/models.ts
 var base = (model) => (model ?? "").split("#")[0];
@@ -6086,7 +6313,15 @@ warning: ${w}`).join("")
 async function cmdRun(p) {
   const opts = { ...runOptions(p, readTask(p)), plan: planStep(p) };
   if (!opts.task.trim() && !opts.plan) throw new UserError('no task given (pitroom "find where X is handled")');
-  return launch(p, prepareRun(opts));
+  const cache = cacheKey(opts);
+  const hit = cache && !has(p, "fresh") ? findCached(cache) : void 0;
+  if (hit) {
+    console.log(has(p, "json") ? JSON.stringify({ ...hit, cached: true }, null, 2) : `${cachedNote(hit)}
+
+${formatReport(hit)}`);
+    return exitCodeFor(hit);
+  }
+  return launch(p, prepareRun({ ...opts, cache }));
 }
 async function cmdReview(p) {
   const range = flag(p, "range");
@@ -6114,10 +6349,10 @@ async function cmdReview(p) {
       writeMeta(meta);
     }
   } catch (e) {
-    fs31.rmSync(packageFile, { force: true });
+    fs33.rmSync(packageFile, { force: true });
     throw e;
   }
-  fs31.writeFileSync(runFile(meta.id, "package.md"), job.package);
+  fs33.writeFileSync(runFile(meta.id, "package.md"), job.package);
   return launch(p, meta);
 }
 async function cmdAudit(p) {
@@ -6185,7 +6420,7 @@ function cmdPlan(p) {
 }
 function cmdCrew(p) {
   const file2 = flag(p, "task-file");
-  const tasks = (file2 ? fs31.readFileSync(file2, "utf8").split(/^\s*---\s*$/m) : p.positional).map((t) => t.trim()).filter(Boolean);
+  const tasks = (file2 ? fs33.readFileSync(file2, "utf8").split(/^\s*---\s*$/m) : p.positional).map((t) => t.trim()).filter(Boolean);
   if (!tasks.length) throw new UserError('crew needs tasks: pitroom crew -g NAME "task 1" "task 2" (or --task-file with --- separators)');
   if (has(p, "write") && tasks.length > 1) {
     throw new UserError("parallel --write runs would edit the same tree; use --isolate (each worker gets its own isolated copy)");
@@ -6306,7 +6541,7 @@ ${[fmt2(head2), ...rows2.map(fmt2)].join("\n")}`);
   const { rows, total } = listHistory({ text: p.positional.join(" "), model: flag(p, "model"), state: flag(p, "state"), group: flag(p, "group"), sinceMs: since2, limit });
   if (has(p, "json")) return console.log(JSON.stringify({ total, rows }, null, 2)), 0;
   if (!rows.length) return console.log(total ? "nothing on this page" : "no matching runs"), 0;
-  const body = rows.map((r) => [r.id, when(r.startedAt), r.state, `${r.backend}${r.model ? ` (${r.model.split("/").pop()})` : ""}`, secs(r.seconds), r.task.length > 60 ? `${r.task.slice(0, 59)}\u2026` : r.task]);
+  const body = rows.map((r) => [r.id, when(r.startedAt), r.verifyFailed ? "verify failed" : r.state, `${r.backend}${r.model ? ` (${r.model.split("/").pop()})` : ""}`, secs(r.seconds), r.task.length > 60 ? `${r.task.slice(0, 59)}\u2026` : r.task]);
   const head = ["RUN", "WHEN", "STATE", "WORKER", "TIME", "TASK"];
   const widths = head.map((h, i) => Math.max(h.length, ...body.map((r) => r[i].length)));
   const fmt = (r, header = false) => r.map((c, i) => {
@@ -6388,7 +6623,7 @@ function sinceMs(s) {
   if (!m) throw new UserError("--since takes 7d, 30d, \u2026 or all");
   return Date.now() - Number(m[1]) * 864e5;
 }
-var readStdin = () => process.stdin.isTTY ? "" : fs31.readFileSync(0, "utf8");
+var readStdin = () => process.stdin.isTTY ? "" : fs33.readFileSync(0, "utf8");
 function cmdStatusline(p) {
   const input = readStdin();
   const lines = [];
@@ -6428,8 +6663,8 @@ function cmdModels(p) {
   return 0;
 }
 function cmdHookStart() {
-  const script = path27.join(path27.dirname(path27.dirname(fileURLToPath4(import.meta.url))), "hooks", "session-start.mjs");
-  if (fs31.existsSync(script)) spawnSync8(process.execPath, [script], { stdio: ["ignore", "inherit", "ignore"], env: process.env });
+  const script = path29.join(path29.dirname(path29.dirname(fileURLToPath4(import.meta.url))), "hooks", "session-start.mjs");
+  if (fs33.existsSync(script)) spawnSync8(process.execPath, [script], { stdio: ["ignore", "inherit", "ignore"], env: process.env });
   return 0;
 }
 function cmdInit(p) {
@@ -6469,8 +6704,8 @@ function cmdSavings(p) {
   est. saved          ${usd(t.saved)}  (vs ${primaryPrice().name} list prices)`);
   const out = flag(p, "card");
   if (out) {
-    fs31.writeFileSync(out, card(t, period));
-    console.log(`card written to ${path27.resolve(out)}`);
+    fs33.writeFileSync(out, card(t, period));
+    console.log(`card written to ${path29.resolve(out)}`);
   }
   if (has(p, "badge")) console.log(`![pitroom](${badgeUrl(t)})`);
   return 0;
@@ -6512,7 +6747,7 @@ function cmdConfig(p) {
     console.log(JSON.stringify({ path: configPath(), settings: eff, warnings }, null, 2));
     return 0;
   }
-  console.log(`config file: ${configPath()}${fs31.existsSync(configPath()) ? "" : " (not present)"}`);
+  console.log(`config file: ${configPath()}${fs33.existsSync(configPath()) ? "" : " (not present)"}`);
   for (const [key, s] of Object.entries(eff)) {
     const v = Array.isArray(s.value) ? s.value.join(", ") || "\u2014" : s.value && typeof s.value === "object" ? Object.entries(s.value).map(([k, m]) => `${k}=${m}`).join(", ") || "\u2014" : s.value === void 0 ? key === "model" ? "the worker's default" : "\u2014" : String(s.value);
     console.log(`  ${key.padEnd(15)} ${v}  (${s.source})`);
@@ -6521,22 +6756,22 @@ function cmdConfig(p) {
   return 0;
 }
 function cmdClean(p) {
-  const days = Number(flag(p, "days") ?? 14);
-  const cutoff = Date.now() - days * 864e5;
+  const days2 = Number(flag(p, "days") ?? 14);
+  const cutoff = Date.now() - days2 * 864e5;
   const old = listRunIds().filter((id) => {
     const m = freshMeta(id);
     const pendingPatch = m.mode === "isolate" && !m.applied && !m.discarded && m.changes?.length;
     return TERMINAL.includes(m.state) && Date.parse(m.startedAt) < cutoff && !pendingPatch;
   });
   if (!has(p, "yes")) {
-    console.log(`${old.length} run(s) older than ${days} days would be removed (unapplied isolate patches are kept). Re-run with --yes.`);
+    console.log(`${old.length} run(s) older than ${days2} days would be removed (unapplied isolate patches are kept). Re-run with --yes.`);
     return 0;
   }
   for (const id of old) {
     const m = readMeta(id);
     if (m.mode === "isolate" && !m.discarded && !m.applied) discardRun(m);
     recordRun(m);
-    fs31.rmSync(runDir(id), { recursive: true, force: true });
+    fs33.rmSync(runDir(id), { recursive: true, force: true });
   }
   const snapshots = prune(Date.now(), 0);
   console.log(`removed ${old.length} run(s)${snapshots ? ` and ${snapshots} read snapshot${snapshots === 1 ? "" : "s"}` : ""}; the history and the savings ledger are kept`);
@@ -6547,9 +6782,9 @@ var cmdDiscard = (p) => (console.log(discardRun(freshMeta(resolveRun(p.positiona
 
 // src/core/doctor.ts
 import { spawnSync as spawnSync9 } from "node:child_process";
-import fs32 from "node:fs";
+import fs34 from "node:fs";
 import os11 from "node:os";
-import path28 from "node:path";
+import path30 from "node:path";
 var MARK = { ok: () => green("\u2714"), warn: () => yellow("!"), fail: () => red("\u2718") };
 var NEXT = [
   { when: /no default model|no fallback workers/, command: "pitroom init", why: "propose a starter config (fallback models from your catalogue)" },
@@ -6559,10 +6794,10 @@ var NEXT = [
   { when: /Gemini CLI is not signed in|IneligibleTierError/, command: "export GEMINI_API_KEY=\u2026", why: "a Google AI Studio key for the Gemini worker" }
 ];
 function firstNodeOnPath() {
-  for (const dir of (process.env.PATH ?? "").split(path28.delimiter).filter(Boolean)) {
-    const file2 = path28.join(dir, process.platform === "win32" ? "node.exe" : "node");
+  for (const dir of (process.env.PATH ?? "").split(path30.delimiter).filter(Boolean)) {
+    const file2 = path30.join(dir, process.platform === "win32" ? "node.exe" : "node");
     try {
-      if (!fs32.statSync(file2).isFile()) continue;
+      if (!fs34.statSync(file2).isFile()) continue;
     } catch {
       continue;
     }
@@ -6589,12 +6824,12 @@ function doctor5(probe) {
   const addAll = (list2) => list2.forEach((c) => add(c.level, c.message));
   add("ok", `pitroom ${VERSION2} \xB7 node ${process.versions.node} \xB7 state in ${home()}`);
   const onPath = firstNodeOnPath();
-  if (onPath && onPath.version && tooOld(onPath.version) && path28.resolve(onPath.path) !== path28.resolve(process.execPath)) {
+  if (onPath && onPath.version && tooOld(onPath.version) && path30.resolve(onPath.path) !== path30.resolve(process.execPath)) {
     add("warn", `the first \`node\` on PATH is v${onPath.version} (${onPath.path}), older than the 22.13 Pitroom needs: shells that agent apps start may use it (the pitroom command finds a newer Node itself; other tools may not)`);
   }
   add(gitAvailable() ? "ok" : "warn", gitAvailable() ? "git available" : "git not found: --write/--isolate tracking disabled");
   const cfg = loadConfig();
-  add(cfg.warnings.length ? "warn" : "ok", `config: ${configPath()}${fs32.existsSync(configPath()) ? "" : " (not present, defaults in use)"}`);
+  add(cfg.warnings.length ? "warn" : "ok", `config: ${configPath()}${fs34.existsSync(configPath()) ? "" : " (not present, defaults in use)"}`);
   for (const w of cfg.warnings) add("warn", w);
   if (process.platform !== "win32") {
     const guarded = guardEnv(process.env).PATH?.startsWith(shimDir());
@@ -6747,19 +6982,19 @@ function skillChecks() {
     else if (!viaPlugin) checks.push({ level: "warn", message: `no Pitroom skills in ${base2}; run \`pitroom install\`` });
   }
   if (geminiExtensionInstalled()) {
-    const linked = installedSkills().some((i) => i.base.includes(`${path28.sep}.agents${path28.sep}`) && i.names.length);
+    const linked = installedSkills().some((i) => i.base.includes(`${path30.sep}.agents${path30.sep}`) && i.names.length);
     checks.push(
       linked ? { level: "warn", message: "Pitroom is installed as a Gemini CLI extension and linked into ~/.agents/skills: Gemini loads the skills twice; run `pitroom uninstall` or `gemini extensions uninstall pitroom`" } : { level: "ok", message: "Gemini CLI extension installed (skills + context)" }
     );
   }
   if (viaPlugin) {
-    const linked = installedSkills().some((i) => i.base.includes(`${path28.sep}.claude${path28.sep}`) && i.names.length);
+    const linked = installedSkills().some((i) => i.base.includes(`${path30.sep}.claude${path30.sep}`) && i.names.length);
     checks.push(
       linked ? { level: "warn", message: "Pitroom is installed as a Claude Code plugin and linked into ~/.claude/skills: skills load twice; run `pitroom uninstall` or remove the plugin" } : { level: "ok", message: "Claude Code plugin installed (skills + session-start hook)" }
     );
   }
   const launcher = launcherPath();
-  if (fs32.existsSync(launcher)) {
+  if (fs34.existsSync(launcher)) {
     const r = spawnSync9(launcher, ["--version"], { encoding: "utf8", timeout: 3e4, stdio: ["ignore", "pipe", "pipe"] });
     checks.push(
       r.status === 0 ? { level: "ok", message: `launcher ${launcher} \u2192 pitroom ${r.stdout.trim()}` } : { level: "fail", message: `launcher ${launcher} does not start: ${(r.stderr || r.stdout).trim().slice(0, 200)}` }
@@ -6771,12 +7006,12 @@ function skillChecks() {
 }
 function geminiExtensionInstalled() {
   const home3 = process.env.GEMINI_CLI_HOME ?? os11.homedir();
-  return fs32.existsSync(path28.join(home3, ".gemini", "extensions", "pitroom"));
+  return fs34.existsSync(path30.join(home3, ".gemini", "extensions", "pitroom"));
 }
 function pluginInstalled() {
   try {
-    const f = path28.join(os11.homedir(), ".claude", "plugins", "installed_plugins.json");
-    const plugins = JSON.parse(fs32.readFileSync(f, "utf8")).plugins ?? {};
+    const f = path30.join(os11.homedir(), ".claude", "plugins", "installed_plugins.json");
+    const plugins = JSON.parse(fs34.readFileSync(f, "utf8")).plugins ?? {};
     return Object.keys(plugins).some((k) => k.startsWith("pitroom@"));
   } catch {
     return false;
@@ -6793,24 +7028,24 @@ function superpowersActive() {
   for (const p of openCodePlugins()) {
     if (/superpowers/i.test(p)) found.push(`OpenCode plugin ${p}`);
   }
-  for (const base2 of [path28.join(os11.homedir(), ".agents", "skills"), path28.join(os11.homedir(), ".claude", "skills")]) {
-    const dir = path28.join(base2, "using-superpowers");
-    if (fs32.existsSync(path28.join(dir, "SKILL.md"))) found.push(dir);
+  for (const base2 of [path30.join(os11.homedir(), ".agents", "skills"), path30.join(os11.homedir(), ".claude", "skills")]) {
+    const dir = path30.join(base2, "using-superpowers");
+    if (fs34.existsSync(path30.join(dir, "SKILL.md"))) found.push(dir);
   }
   return found;
 }
 function claudePlugins() {
   try {
-    const f = path28.join(os11.homedir(), ".claude", "plugins", "installed_plugins.json");
-    return Object.keys(JSON.parse(fs32.readFileSync(f, "utf8")).plugins ?? {});
+    const f = path30.join(os11.homedir(), ".claude", "plugins", "installed_plugins.json");
+    return Object.keys(JSON.parse(fs34.readFileSync(f, "utf8")).plugins ?? {});
   } catch {
     return [];
   }
 }
 function claudePluginEnabled(key) {
   try {
-    const f = path28.join(os11.homedir(), ".claude", "settings.json");
-    return JSON.parse(fs32.readFileSync(f, "utf8")).enabledPlugins?.[key] !== false;
+    const f = path30.join(os11.homedir(), ".claude", "settings.json");
+    return JSON.parse(fs34.readFileSync(f, "utf8")).enabledPlugins?.[key] !== false;
   } catch {
     return true;
   }
@@ -6819,7 +7054,7 @@ function codexPlugins() {
   const plugins = /* @__PURE__ */ new Map();
   let text;
   try {
-    text = fs32.readFileSync(path28.join(process.env.CODEX_HOME ?? path28.join(os11.homedir(), ".codex"), "config.toml"), "utf8");
+    text = fs34.readFileSync(path30.join(process.env.CODEX_HOME ?? path30.join(os11.homedir(), ".codex"), "config.toml"), "utf8");
   } catch {
     return plugins;
   }
@@ -6837,11 +7072,11 @@ function codexPlugins() {
   return plugins;
 }
 function openCodePlugins() {
-  const dir = path28.join(process.env.XDG_CONFIG_HOME ?? path28.join(os11.homedir(), ".config"), "opencode");
+  const dir = path30.join(process.env.XDG_CONFIG_HOME ?? path30.join(os11.homedir(), ".config"), "opencode");
   const plugins = [];
   for (const name of ["opencode.json", "opencode.jsonc"]) {
     try {
-      const text = fs32.readFileSync(path28.join(dir, name), "utf8").replace(/\/\*[\s\S]*?\*\/|^\s*\/\/.*$/gm, "");
+      const text = fs34.readFileSync(path30.join(dir, name), "utf8").replace(/\/\*[\s\S]*?\*\/|^\s*\/\/.*$/gm, "");
       const list2 = JSON.parse(text).plugin;
       if (Array.isArray(list2)) plugins.push(...list2.filter((p) => typeof p === "string"));
     } catch {
@@ -6849,7 +7084,7 @@ function openCodePlugins() {
   }
   for (const folder of ["plugin", "plugins"]) {
     try {
-      for (const f of fs32.readdirSync(path28.join(dir, folder))) plugins.push(path28.join(dir, folder, f));
+      for (const f of fs34.readdirSync(path30.join(dir, folder))) plugins.push(path30.join(dir, folder, f));
     } catch {
     }
   }
@@ -6929,6 +7164,7 @@ Run options
       --in-place        a read run reads the directory itself, not a clean snapshot (default: a snapshot without secret-looking
                         files when the directory has any; config "readIn": auto | snapshot | project)
       --audit           have another worker re-check this read run's answer; --no-audit skips it (default: the config's "audit")
+      --fresh           ask a worker even when the same read question was answered on the same code (config "cacheDays", default 7)
       --effort LEVEL    reasoning effort for the worker: low, medium, high, xhigh, \u2026 (model#level)
       --plan PLAN       with --step N: implement Task N of a plan (-i or -w); the task text is your notes
       --step N          the plan task for --plan
@@ -6950,9 +7186,9 @@ Exit codes: 0 ok \xB7 1 worker failed \xB7 2 usage \xB7 3 refused/setup \xB7 4 t
             5 read-only violation \xB7 6 verify failed \xB7 75 still running (wait again)
 Workers: ${backendIds().join(", ")} (targets: "opencode", "opencode:provider/model", or a bare model)
 Env: PITROOM_WORKER, PITROOM_MODEL, PITROOM_FALLBACK="t1,t2", PITROOM_TIMEOUT, PITROOM_MAX_PARALLEL,
-     PITROOM_PRIMARY=sonnet|opus|haiku|gpt-5, PITROOM_PRICE="in,out", PITROOM_HOME, PITROOM_CONFIG,
+     PITROOM_PRIMARY=sonnet|opus|haiku|gpt-5, PITROOM_PRICE="in,out", PITROOM_HOME, PITROOM_CONFIG, PITROOM_CACHE_DAYS,
      PITROOM_<WORKER>_BIN
-Config: ~/.config/pitroom/config.json (worker, fallback, models, tiers, timeout, primary, price, link, web, maxParallel)`;
+Config: ~/.config/pitroom/config.json (worker, fallback, models, tiers, timeout, primary, price, link, web, maxParallel, audit, readIn, cacheDays)`;
 var COMMANDS = {
   run: cmdRun,
   crew: cmdCrew,
@@ -6965,7 +7201,7 @@ var COMMANDS = {
     if (port !== void 0 && !(/^\d+$/.test(port) && Number(port) <= 65535)) throw new UserError("--port takes a number from 0 to 65535 (0 picks a free one)");
     const dir = flag(p, "dir");
     if (dir !== void 0) {
-      if (!fs33.statSync(dir, { throwIfNoEntry: false })?.isDirectory()) throw new UserError(`-d ${dir}: no such directory`);
+      if (!fs35.statSync(dir, { throwIfNoEntry: false })?.isDirectory()) throw new UserError(`-d ${dir}: no such directory`);
       process.chdir(dir);
       process.env.PWD = process.cwd();
     }