pitroom 0.16.0 → 0.18.0

package/dist/pitroom.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import fs33 from "node:fs";
+import fs36 from "node:fs";
 
 // src/core/errors.ts
 var UserError = class extends Error {
@@ -555,16 +555,33 @@ var codex = {
 
 // src/backends/gemini/index.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import fs5 from "node:fs";
+import fs6 from "node:fs";
 import os5 from "node:os";
 import path5 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/core/store.ts
-import fs4 from "node:fs";
+import fs5 from "node:fs";
 import os4 from "node:os";
 import path4 from "node:path";
 import crypto from "node:crypto";
+
+// src/core/fs-atomic.ts
+import fs4 from "node:fs";
+var BUSY = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES"]);
+function renameOver(tmp, file2) {
+  for (let attempt3 = 0; ; attempt3++) {
+    try {
+      fs4.renameSync(tmp, file2);
+      return;
+    } catch (e) {
+      if (process.platform !== "win32" || !BUSY.has(e.code ?? "") || attempt3 >= 40) throw e;
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+    }
+  }
+}
+
+// src/core/store.ts
 var TERMINAL = ["done", "failed", "timeout", "stopped"];
 var isActive = (s) => !TERMINAL.includes(s);
 function home() {
@@ -591,11 +608,11 @@ function useArchive(hooks) {
   archive = { meta: hooks.meta, id: hooks.id };
 }
 function writeMeta(meta) {
-  fs4.mkdirSync(runDir(meta.id), { recursive: true });
+  fs5.mkdirSync(runDir(meta.id), { recursive: true });
   const file2 = runFile(meta.id, "meta.json");
   const tmp = `${file2}.${process.pid}.tmp`;
-  fs4.writeFileSync(tmp, JSON.stringify(meta, null, 2));
-  fs4.renameSync(tmp, file2);
+  fs5.writeFileSync(tmp, JSON.stringify(meta, null, 2));
+  renameOver(tmp, file2);
   if (TERMINAL.includes(meta.state)) {
     try {
       onFinished?.(meta);
@@ -605,11 +622,11 @@ function writeMeta(meta) {
 }
 function readMeta(id) {
   const file2 = runFile(id, "meta.json");
-  if (!fs4.existsSync(file2)) {
+  if (!fs5.existsSync(file2)) {
     const kept = archive?.meta(id);
     if (kept) return upgrade(kept);
   }
-  return upgrade(JSON.parse(fs4.readFileSync(file2, "utf8")));
+  return upgrade(JSON.parse(fs5.readFileSync(file2, "utf8")));
 }
 function upgrade(raw) {
   if (!raw.worker) raw.worker = raw.model ? { backend: "opencode", model: raw.model } : { backend: "opencode" };
@@ -622,8 +639,8 @@ function upgrade(raw) {
   return raw;
 }
 function listRunIds() {
-  if (!fs4.existsSync(runsDir())) return [];
-  return fs4.readdirSync(runsDir()).filter((d) => fs4.existsSync(runFile(d, "meta.json"))).sort();
+  if (!fs5.existsSync(runsDir())) return [];
+  return fs5.readdirSync(runsDir()).filter((d) => fs5.existsSync(runFile(d, "meta.json"))).sort();
 }
 function resolveRun(ref) {
   const ids = listRunIds();
@@ -649,13 +666,16 @@ function isAlive(pid) {
     return e.code === "EPERM";
   }
 }
+var STOP_FILE = "stop-requested";
+var requestStop = (id) => fs5.writeFileSync(runFile(id, STOP_FILE), "");
 function freshMeta(id) {
   const meta = readMeta(id);
   if (!TERMINAL.includes(meta.state) && meta.pid && !isAlive(meta.pid)) {
     const latest = readMeta(id);
     if (TERMINAL.includes(latest.state)) return latest;
-    latest.state = latest.stopRequested ? "stopped" : "failed";
-    if (!latest.stopRequested) latest.error ??= "worker process exited unexpectedly";
+    const stopped = latest.stopRequested || fs5.existsSync(runFile(id, STOP_FILE));
+    latest.state = stopped ? "stopped" : "failed";
+    if (!stopped) latest.error ??= "worker process exited unexpectedly";
     latest.endedAt ??= (/* @__PURE__ */ new Date()).toISOString();
     writeMeta(latest);
     return latest;
@@ -787,22 +807,22 @@ var policyDir = () => path5.resolve(path5.dirname(fileURLToPath(import.meta.url)
 function workerHome() {
   const root = path5.join(home(), "gemini-home");
   const dir = path5.join(root, ".gemini");
-  const base2 = JSON.parse(fs5.readFileSync(path5.join(policyDir(), "worker-settings.json"), "utf8"));
+  const base2 = JSON.parse(fs6.readFileSync(path5.join(policyDir(), "worker-settings.json"), "utf8"));
   const auth = settings().security?.auth;
   const body = `${JSON.stringify(auth ? { ...base2, security: { ...base2.security, auth } } : base2, null, 2)}
 `;
   const file2 = path5.join(dir, "settings.json");
   try {
-    if (fs5.readFileSync(file2, "utf8") === body) return root;
+    if (fs6.readFileSync(file2, "utf8") === body) return root;
   } catch {
   }
-  fs5.mkdirSync(dir, { recursive: true });
-  fs5.writeFileSync(file2, body);
+  fs6.mkdirSync(dir, { recursive: true });
+  fs6.writeFileSync(file2, body);
   for (const name of ["oauth_creds.json", "google_accounts.json"]) {
     const from = path5.join(geminiHome(), name);
     const to = path5.join(dir, name);
     try {
-      if (fs5.existsSync(from) && !fs5.existsSync(to)) fs5.symlinkSync(from, to);
+      if (fs6.existsSync(from) && !fs6.existsSync(to)) fs6.symlinkSync(from, to);
     } catch {
     }
   }
@@ -829,7 +849,7 @@ function invocation3(req) {
   const { command, prefix } = resolveCommand(binary3());
   const env = { GEMINI_CLI_HOME: workerHome() };
   const trusted = path5.join(geminiHome(), "trustedFolders.json");
-  if (fs5.existsSync(trusted)) env.GEMINI_CLI_TRUSTED_FOLDERS_PATH = trusted;
+  if (fs6.existsSync(trusted)) env.GEMINI_CLI_TRUSTED_FOLDERS_PATH = trusted;
   return { command, args: [...prefix, ...args], env };
 }
 function classify3(message) {
@@ -854,7 +874,7 @@ function geminiHome() {
 }
 function settings() {
   try {
-    return JSON.parse(fs5.readFileSync(path5.join(geminiHome(), "settings.json"), "utf8"));
+    return JSON.parse(fs6.readFileSync(path5.join(geminiHome(), "settings.json"), "utf8"));
   } catch {
     return {};
   }
@@ -873,7 +893,7 @@ function doctor3({ models, hasFallback }) {
   const checks = [{ level: "ok", message: `Gemini CLI ${version.out.trim()} at ${binary3()}` }];
   const key = process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY;
   const vertex = process.env.GOOGLE_GENAI_USE_VERTEXAI === "true" || process.env.GOOGLE_GENAI_USE_VERTEXAI === "1";
-  const signedIn = fs5.existsSync(path5.join(geminiHome(), "oauth_creds.json"));
+  const signedIn = fs6.existsSync(path5.join(geminiHome(), "oauth_creds.json"));
   const type = settings().security?.auth?.selectedType;
   if (key || vertex) {
     checks.push({ level: "ok", message: `Gemini CLI: ${key ? "an API key is set" : "Vertex AI is set up"}` });
@@ -1032,7 +1052,7 @@ function describe2(input) {
 }
 
 // src/backends/opencode/profiles.ts
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 import os6 from "node:os";
 import path6 from "node:path";
 var AGENT = { read: "pitroom-read", write: "pitroom-write" };
@@ -1143,7 +1163,7 @@ function scratchDirs() {
 }
 function realpath(p) {
   try {
-    return fs6.realpathSync(p);
+    return fs7.realpathSync(p);
   } catch {
     return p;
   }
@@ -1401,10 +1421,10 @@ function getBackend(id) {
 }
 
 // src/cli/args.ts
-import fs8 from "node:fs";
+import fs9 from "node:fs";
 
 // src/core/config.ts
-import fs7 from "node:fs";
+import fs8 from "node:fs";
 import os7 from "node:os";
 import path7 from "node:path";
 var SCHEMA = {
@@ -1420,7 +1440,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);
@@ -1433,10 +1454,10 @@ function loadConfig() {
   const file2 = configPath();
   const config = {};
   const warnings = [];
-  if (fs7.existsSync(file2)) {
+  if (fs8.existsSync(file2)) {
     let raw;
     try {
-      raw = JSON.parse(fs7.readFileSync(file2, "utf8"));
+      raw = JSON.parse(fs8.readFileSync(file2, "utf8"));
     } catch (e) {
       warnings.push(`${file2}: invalid JSON (${e.message}); ignored`);
     }
@@ -1478,6 +1499,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 +1529,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 +1607,7 @@ var BOOL_FLAGS = {
   "--stop": "stop",
   "--open": "open",
   "--serve": "serve",
+  "--fresh": "fresh",
   "--http": "http",
   "-h": "help",
   "--help": "help",
@@ -1637,9 +1664,9 @@ function exitCodeFor(meta) {
 }
 function readTask(p) {
   const file2 = flag(p, "task-file");
-  if (file2) return fs8.readFileSync(file2, "utf8");
+  if (file2) return fs9.readFileSync(file2, "utf8");
   const words = p.positional;
-  if (words.length === 1 && words[0] === "-") return fs8.readFileSync(0, "utf8");
+  if (words.length === 1 && words[0] === "-") return fs9.readFileSync(0, "utf8");
   return words.join(" ");
 }
 function runOptions(p, task) {
@@ -1688,13 +1715,13 @@ import readline from "node:readline";
 
 // src/core/run.ts
 import { spawn as spawn2, spawnSync as spawnSync6 } from "node:child_process";
-import fs24 from "node:fs";
+import fs25 from "node:fs";
 import path20 from "node:path";
 
 // src/vcs/git.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
 import crypto2 from "node:crypto";
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 import os8 from "node:os";
 import path8 from "node:path";
 var SAFE = [
@@ -1726,26 +1753,33 @@ function must(cwd, args, env) {
 function gitAvailable() {
   return git(process.cwd(), ["--version"]).code === 0;
 }
+function canonical(dir) {
+  try {
+    return fs10.realpathSync.native(dir);
+  } catch {
+    return dir;
+  }
+}
 function repoRoot(dir) {
   const r = git(dir, ["rev-parse", "--show-toplevel"]);
-  return r.code === 0 ? path8.resolve(r.stdout.trim()) : void 0;
+  return r.code === 0 ? canonical(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);
+    if (fs10.existsSync(real)) fs10.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();
   } finally {
-    fs9.rmSync(tmp, { force: true });
-    fs9.rmSync(`${tmp}.lock`, { force: true });
+    fs10.rmSync(tmp, { force: true });
+    fs10.rmSync(`${tmp}.lock`, { force: true });
   }
 }
 var DIFF = ["diff", "--no-ext-diff", "--no-textconv", "--no-renames"];
@@ -1766,9 +1800,9 @@ function diffTrees(root, a, b) {
 }
 function createIsolatedCopy(root, tree, dest) {
   const objects = path8.join(path8.resolve(root, must(root, ["rev-parse", "--git-common-dir"]).trim()), "objects");
-  fs9.mkdirSync(path8.dirname(dest), { recursive: true });
+  fs10.mkdirSync(path8.dirname(dest), { recursive: true });
   must(path8.dirname(dest), ["init", "--quiet", dest]);
-  fs9.writeFileSync(path8.join(dest, ".git", "objects", "info", "alternates"), `${objects}
+  fs10.writeFileSync(path8.join(dest, ".git", "objects", "info", "alternates"), `${objects}
 `);
   must(dest, ["read-tree", tree]);
   must(dest, ["checkout-index", "--all", "--force"]);
@@ -1776,16 +1810,16 @@ function createIsolatedCopy(root, tree, dest) {
 function removeIsolatedCopy(dest, ownedBy) {
   const rel = path8.relative(ownedBy, dest);
   if (!rel || rel.startsWith("..") || path8.isAbsolute(rel)) throw new Error(`refusing to remove ${dest}`);
-  fs9.rmSync(dest, { recursive: true, force: true });
+  fs10.rmSync(dest, { recursive: true, force: true });
 }
 function linkIntoWorktree(root, worktree, rels) {
   const linked = [];
   for (const rel of rels) {
     const src = path8.join(root, rel);
     const dst = path8.join(worktree, rel);
-    if (!fs9.existsSync(src) || fs9.existsSync(dst)) continue;
-    fs9.mkdirSync(path8.dirname(dst), { recursive: true });
-    fs9.symlinkSync(src, dst, process.platform === "win32" ? "junction" : void 0);
+    if (!fs10.existsSync(src) || fs10.existsSync(dst)) continue;
+    fs10.mkdirSync(path8.dirname(dst), { recursive: true });
+    fs10.symlinkSync(src, dst, process.platform === "win32" ? "junction" : void 0);
     linked.push(rel);
   }
   return linked;
@@ -1804,6 +1838,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 +1846,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) {
@@ -1890,10 +1925,10 @@ function resolveChain(flags = {}) {
 
 // src/core/process.ts
 import { spawn } from "node:child_process";
-import fs11 from "node:fs";
+import fs12 from "node:fs";
 
 // src/vcs/guard.ts
-import fs10 from "node:fs";
+import fs11 from "node:fs";
 import path9 from "node:path";
 var VERSION = 1;
 var SHIM = `#!/bin/sh
@@ -1976,8 +2011,8 @@ function findRealGit(skip) {
     if (path9.resolve(dir) === skip) continue;
     const p = path9.join(dir, "git");
     try {
-      fs10.accessSync(p, fs10.constants.X_OK);
-      if (fs10.statSync(p).isFile()) return p;
+      fs11.accessSync(p, fs11.constants.X_OK);
+      if (fs11.statSync(p).isFile()) return p;
     } catch {
     }
   }
@@ -1992,11 +2027,11 @@ exit 1
 `;
 var hooksDir = () => path9.join(home(), "git-hooks", `v${HOOK_VERSION}`);
 function writeIfChanged(file2, content) {
-  if (fs10.existsSync(file2) && fs10.readFileSync(file2, "utf8") === content) return;
-  fs10.mkdirSync(path9.dirname(file2), { recursive: true });
+  if (fs11.existsSync(file2) && fs11.readFileSync(file2, "utf8") === content) return;
+  fs11.mkdirSync(path9.dirname(file2), { recursive: true });
   const tmp = `${file2}.${process.pid}.tmp`;
-  fs10.writeFileSync(tmp, content, { mode: 493 });
-  fs10.renameSync(tmp, file2);
+  fs11.writeFileSync(tmp, content, { mode: 493 });
+  fs11.renameSync(tmp, file2);
 }
 function withGitConfig(env, entries) {
   const out = { ...env };
@@ -2032,8 +2067,8 @@ function guardEnv(env) {
 
 // src/core/process.ts
 async function spawnWorker(inv, opts) {
-  const out = fs11.openSync(opts.stdoutFile, "w");
-  const err = fs11.openSync(opts.stderrFile, "w");
+  const out = fs12.openSync(opts.stdoutFile, "w");
+  const err = fs12.openSync(opts.stderrFile, "w");
   const res = { code: null, timedOut: false, stopped: false };
   const child = spawn(inv.command, inv.args, {
     cwd: opts.cwd,
@@ -2049,24 +2084,24 @@ 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);
   }, opts.timeoutSec * 1e3);
   res.code = await new Promise((resolve2) => {
     child.on("error", (e) => {
-      res.spawnError = e.code === "ENOENT" ? `${inv.command} not found` : e.message;
+      res.spawnError = e.code === "ENOENT" ? fs12.existsSync(opts.cwd) ? `${inv.command} not found` : `the working directory ${opts.cwd} does not exist` : e.message;
       resolve2(127);
     });
     child.on("close", (c) => resolve2(c));
   });
-  clearTimeout(timer);
+  clearTimeout(timer2);
   if (killer) clearTimeout(killer);
   process.off("SIGINT", stop);
   process.off("SIGTERM", stop);
-  fs11.closeSync(out);
-  fs11.closeSync(err);
+  fs12.closeSync(out);
+  fs12.closeSync(err);
   return res;
 }
 
@@ -2098,7 +2133,7 @@ function parseAudit(text) {
 }
 
 // src/core/cooldown.ts
-import fs12 from "node:fs";
+import fs13 from "node:fs";
 import path10 from "node:path";
 var MAX_MS = 24 * 36e5;
 var OVERLOAD_MS = 20 * 6e4;
@@ -2126,18 +2161,18 @@ function cooldownMs(message) {
 }
 function read() {
   try {
-    const raw = JSON.parse(fs12.readFileSync(file(), "utf8"));
+    const raw = JSON.parse(fs13.readFileSync(file(), "utf8"));
     return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
   } catch {
     return {};
   }
 }
 function write(all) {
-  fs12.mkdirSync(path10.dirname(file()), { recursive: true });
+  fs13.mkdirSync(path10.dirname(file()), { recursive: true });
   const tmp = `${file()}.${process.pid}.tmp`;
-  fs12.writeFileSync(tmp, `${JSON.stringify(all, null, 2)}
+  fs13.writeFileSync(tmp, `${JSON.stringify(all, null, 2)}
 `);
-  fs12.renameSync(tmp, file());
+  renameOver(tmp, file());
 }
 function activeCooldowns(now = Date.now()) {
   return Object.fromEntries(Object.entries(read()).filter(([, c]) => Date.parse(c.until) > now));
@@ -2165,13 +2200,13 @@ function untilText(c, now = Date.now()) {
 }
 
 // src/core/snapshot.ts
-import fs14 from "node:fs";
+import fs15 from "node:fs";
 import path12 from "node:path";
 import crypto3 from "node:crypto";
 
 // src/core/secrets.ts
 import { execFileSync } from "node:child_process";
-import fs13 from "node:fs";
+import fs14 from "node:fs";
 import path11 from "node:path";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "out", ".next", "target", "vendor", ".venv", "venv", "__pycache__", "coverage", ".turbo", ".cache"]);
 var MAX_VISITED = 2e4;
@@ -2189,7 +2224,7 @@ function findSecretFiles(dir) {
     if (depth > MAX_DEPTH || visited > MAX_VISITED) return;
     let entries;
     try {
-      entries = fs13.readdirSync(d, { withFileTypes: true });
+      entries = fs14.readdirSync(d, { withFileTypes: true });
     } catch {
       return;
     }
@@ -2198,7 +2233,7 @@ function findSecretFiles(dir) {
       if (e.isDirectory()) {
         if (!SKIP_DIRS.has(e.name)) walk(path11.join(d, e.name), depth + 1);
       } else if (e.isFile() && looksSecret(e.name)) {
-        found.push(path11.relative(dir, path11.join(d, e.name)));
+        found.push(slash(path11.relative(dir, path11.join(d, e.name))));
       }
     }
   };
@@ -2208,7 +2243,7 @@ function findSecretFiles(dir) {
 function findSecretFilesInTree(root, dir) {
   try {
     const out = execFileSync("git", ["-C", root, "ls-files", "-z", "--cached", "--others", "--exclude-standard"], { encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
-    return out.split("\0").filter((f) => f && looksSecret(path11.basename(f)) && !path11.relative(dir, path11.join(root, f)).startsWith("..")).map((f) => path11.relative(dir, path11.join(root, f))).sort();
+    return out.split("\0").filter((f) => f && looksSecret(path11.basename(f)) && !path11.relative(dir, path11.join(root, f)).startsWith("..")).map((f) => slash(path11.relative(dir, path11.join(root, f)))).sort();
   } catch {
     return [];
   }
@@ -2220,6 +2255,7 @@ function secretWarning(files, mode) {
   const fix = mode === "isolate" ? "add them to .gitignore, or" : "use an isolated copy (-i, git-ignored files are left out) or a clean checkout, or";
   return `secret-looking files ${where} (${shown}): the worker is told not to read them, but nothing stops it, and its model may be hosted by a third party; ${fix} set PITROOM_NO_SECRET_WARNING=1 to silence this`;
 }
+var slash = (p) => p.split(path11.sep).join("/");
 
 // src/core/snapshot.ts
 var READ_IN = ["auto", "snapshot", "project"];
@@ -2234,10 +2270,10 @@ 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"))) {
+  if (fs15.existsSync(path12.join(dest, ".git"))) {
     touch(dest);
     return { dir: dest, tree, created: false };
   }
@@ -2246,9 +2282,9 @@ function readSnapshot(root) {
     createIsolatedCopy(root, tree, tmp);
     readOnly(tmp);
     try {
-      fs14.renameSync(tmp, dest);
+      fs15.renameSync(tmp, dest);
     } catch (e) {
-      if (!fs14.existsSync(path12.join(dest, ".git"))) throw e;
+      if (!fs15.existsSync(path12.join(dest, ".git"))) throw e;
       removeIsolatedCopy(tmp, snapshotsDir());
     }
   } catch (e) {
@@ -2264,17 +2300,17 @@ function readSnapshot(root) {
 function touch(dir) {
   try {
     const now = /* @__PURE__ */ new Date();
-    fs14.utimesSync(dir, now, now);
+    fs15.utimesSync(dir, now, now);
   } catch {
   }
 }
 function readOnly(dir) {
   const walk = (d) => {
-    for (const e of fs14.readdirSync(d, { withFileTypes: true })) {
+    for (const e of fs15.readdirSync(d, { withFileTypes: true })) {
       if (e.name === ".git") continue;
       const p = path12.join(d, e.name);
       if (e.isDirectory()) walk(p);
-      else if (e.isFile()) fs14.chmodSync(p, fs14.statSync(p).mode & ~146);
+      else if (e.isFile()) fs15.chmodSync(p, fs15.statSync(p).mode & ~146);
     }
   };
   try {
@@ -2285,7 +2321,7 @@ function readOnly(dir) {
 function prune(now = Date.now(), maxAgeMs = PRUNE_AGE_MS, keepNewest = KEEP_NEWEST) {
   let names;
   try {
-    names = fs14.readdirSync(snapshotsDir());
+    names = fs15.readdirSync(snapshotsDir());
   } catch {
     return 0;
   }
@@ -2300,7 +2336,7 @@ function prune(now = Date.now(), maxAgeMs = PRUNE_AGE_MS, keepNewest = KEEP_NEWE
   const entries = names.map((n) => {
     const dir = path12.join(snapshotsDir(), n);
     try {
-      return { n, dir, age: now - fs14.statSync(dir).mtimeMs };
+      return { n, dir, age: now - fs15.statSync(dir).mtimeMs };
     } catch {
       return void 0;
     }
@@ -2324,10 +2360,10 @@ function prune(now = Date.now(), maxAgeMs = PRUNE_AGE_MS, keepNewest = KEEP_NEWE
 }
 function makeWritable(dir) {
   const walk = (d) => {
-    for (const e of fs14.readdirSync(d, { withFileTypes: true })) {
+    for (const e of fs15.readdirSync(d, { withFileTypes: true })) {
       const p = path12.join(d, e.name);
       if (e.isDirectory()) walk(p);
-      else if (e.isFile()) fs14.chmodSync(p, fs14.statSync(p).mode | 128);
+      else if (e.isFile()) fs15.chmodSync(p, fs15.statSync(p).mode | 128);
     }
   };
   try {
@@ -2338,7 +2374,7 @@ function makeWritable(dir) {
 function backToProject(text, snapshotDir, root) {
   let real = snapshotDir;
   try {
-    real = fs14.realpathSync(snapshotDir);
+    real = fs15.realpathSync(snapshotDir);
   } catch {
   }
   let out = text;
@@ -2377,6 +2413,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 +2430,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");
 }
@@ -2416,7 +2455,7 @@ function auditBadge(meta) {
 }
 
 // src/core/plan.ts
-import fs15 from "node:fs";
+import fs16 from "node:fs";
 import path13 from "node:path";
 var FENCE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
 var RULE = /^ {0,3}([-*_])(\s*\1){2,}\s*$/;
@@ -2465,8 +2504,8 @@ function parsePlan(text, file2 = "") {
 }
 function loadPlan(file2) {
   const abs = path13.resolve(file2);
-  if (!fs15.existsSync(abs) || !fs15.statSync(abs).isFile()) throw new UserError(`plan not found: ${file2}`);
-  const plan = parsePlan(fs15.readFileSync(abs, "utf8"), fs15.realpathSync(abs));
+  if (!fs16.existsSync(abs) || !fs16.statSync(abs).isFile()) throw new UserError(`plan not found: ${file2}`);
+  const plan = parsePlan(fs16.readFileSync(abs, "utf8"), fs16.realpathSync(abs));
   if (!plan.tasks.length) throw new UserError(`${file2} has no "Task N" headings (see pitroom-writing-plans)`);
   return plan;
 }
@@ -2488,11 +2527,11 @@ function brief(plan, task) {
 var planName = (file2) => path13.basename(file2).replace(/\.md$/i, "");
 
 // src/core/templates.ts
-import fs17 from "node:fs";
+import fs18 from "node:fs";
 import path15 from "node:path";
 
 // src/core/install.ts
-import fs16 from "node:fs";
+import fs17 from "node:fs";
 import os9 from "node:os";
 import path14 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
@@ -2502,18 +2541,30 @@ function packageRoot() {
 }
 function skillNames(root = packageRoot()) {
   const dir = path14.join(root, "skills");
-  if (!fs16.existsSync(dir)) return [];
-  return fs16.readdirSync(dir).filter((d) => fs16.existsSync(path14.join(dir, d, "SKILL.md"))).sort();
+  if (!fs17.existsSync(dir)) return [];
+  return fs17.readdirSync(dir).filter((d) => fs17.existsSync(path14.join(dir, d, "SKILL.md"))).sort();
 }
 function skillTargets() {
   const home3 = os9.homedir();
   const targets = [path14.join(home3, ".agents", "skills")];
-  if (fs16.existsSync(path14.join(home3, ".claude"))) targets.push(path14.join(home3, ".claude", "skills"));
+  if (fs17.existsSync(path14.join(home3, ".claude"))) targets.push(path14.join(home3, ".claude", "skills"));
   return targets;
 }
-var launcherPath = () => path14.join(os9.homedir(), ".local", "bin", "pitroom");
+var launcherPath = () => path14.join(os9.homedir(), ".local", "bin", process.platform === "win32" ? "pitroom.cmd" : "pitroom");
 var LAUNCHER_MARK = "# pitroom launcher";
 function launcherScript(bundle) {
+  if (process.platform === "win32") {
+    const q2 = (v) => v.replace(/%/g, "%%");
+    return `@echo off\r
+rem ${LAUNCHER_MARK} (created by \`pitroom install\`; \`pitroom uninstall\` removes it)\r
+if defined PITROOM_NODE (\r
+  "%PITROOM_NODE%" "${q2(bundle)}" %*\r
+) else (\r
+  "${q2(process.execPath)}" "${q2(bundle)}" %*\r
+)\r
+exit /b %ERRORLEVEL%\r
+`;
+  }
   const q = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
   return `#!/bin/sh
 ${LAUNCHER_MARK} (created by \`pitroom install\`; \`pitroom uninstall\` removes it)
@@ -2529,7 +2580,7 @@ exit 127
 function isOurLauncher(file2, root) {
   if (linksInto(file2, root)) return true;
   try {
-    const s = fs16.readFileSync(file2, "utf8");
+    const s = fs17.readFileSync(file2, "utf8");
     return s.includes(LAUNCHER_MARK) && s.includes(root);
   } catch {
     return false;
@@ -2537,61 +2588,61 @@ function isOurLauncher(file2, root) {
 }
 function isPitroomLauncher(file2) {
   try {
-    return fs16.readFileSync(file2, "utf8").includes(LAUNCHER_MARK);
+    return fs17.readFileSync(file2, "utf8").includes(LAUNCHER_MARK);
   } catch {
     return false;
   }
 }
 function placeLauncher(bundle, root, force) {
   const dest = launcherPath();
-  fs16.mkdirSync(path14.dirname(dest), { recursive: true });
-  const exists = fs16.lstatSync(dest, { throwIfNoEntry: false });
+  fs17.mkdirSync(path14.dirname(dest), { recursive: true });
+  const exists = fs17.lstatSync(dest, { throwIfNoEntry: false });
   if (exists && !isOurLauncher(dest, root)) {
     if (!force) return `! ${dest} exists and is not Pitroom's launcher; kept (use --force to back it up and replace)`;
-    fs16.renameSync(dest, `${dest}.bak-${Date.now()}`);
+    fs17.renameSync(dest, `${dest}.bak-${Date.now()}`);
   } else if (exists) {
-    fs16.rmSync(dest, { force: true });
+    fs17.rmSync(dest, { force: true });
   }
-  fs16.writeFileSync(dest, launcherScript(bundle), { mode: 493 });
+  fs17.writeFileSync(dest, launcherScript(bundle), { mode: 493 });
   return `\u2714 ${dest} \u2192 launcher for ${bundle} (Node 22.13+)`;
 }
 function linksInto(link, dir) {
-  const st = fs16.lstatSync(link, { throwIfNoEntry: false });
+  const st = fs17.lstatSync(link, { throwIfNoEntry: false });
   if (!st?.isSymbolicLink()) return false;
-  const target = path14.resolve(path14.dirname(link), fs16.readlinkSync(link));
+  const target = path14.resolve(path14.dirname(link), fs17.readlinkSync(link));
   const rel = path14.relative(dir, target);
   return !rel.startsWith("..") && !path14.isAbsolute(rel);
 }
 function place(src, dest, opts) {
-  fs16.mkdirSync(path14.dirname(dest), { recursive: true });
-  const st = fs16.lstatSync(dest, { throwIfNoEntry: false });
+  fs17.mkdirSync(path14.dirname(dest), { recursive: true });
+  const st = fs17.lstatSync(dest, { throwIfNoEntry: false });
   if (st && !st.isSymbolicLink()) {
     if (!opts.force) return `! ${dest} exists and is not a link; kept (use --force to back it up and replace)`;
-    fs16.renameSync(dest, `${dest}.bak-${Date.now()}`);
+    fs17.renameSync(dest, `${dest}.bak-${Date.now()}`);
   } else if (st) {
-    fs16.unlinkSync(dest);
+    fs17.unlinkSync(dest);
   }
-  if (opts.copy) fs16.cpSync(src, dest, { recursive: true });
-  else fs16.symlinkSync(src, dest, process.platform === "win32" ? "junction" : fs16.statSync(src).isDirectory() ? "dir" : "file");
+  if (opts.copy) fs17.cpSync(src, dest, { recursive: true });
+  else fs17.symlinkSync(src, dest, process.platform === "win32" ? "junction" : fs17.statSync(src).isDirectory() ? "dir" : "file");
   return `\u2714 ${dest} \u2192 ${opts.copy ? "copied" : src}`;
 }
 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)) {
-        fs16.unlinkSync(l);
+      if (!skills2.includes(legacy) && linksInto(l, root)) {
+        fs17.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)) {
+  if (fs17.existsSync(bundle)) {
     out.push(placeLauncher(bundle, root, opts.force));
     const onPath = (process.env.PATH ?? "").split(path14.delimiter).some((d) => path14.resolve(d) === path14.dirname(launcherPath()));
     if (!onPath) out.push(`! ${path14.dirname(launcherPath())} is not on PATH; add it, or run ${launcherPath()} directly`);
@@ -2602,24 +2653,24 @@ function uninstall() {
   const root = packageRoot();
   const out = [];
   for (const base2 of skillTargets()) {
-    if (!fs16.existsSync(base2)) continue;
-    for (const name of fs16.readdirSync(base2)) {
+    if (!fs17.existsSync(base2)) continue;
+    for (const name of fs17.readdirSync(base2)) {
       const l = path14.join(base2, name);
       if (linksInto(l, root)) {
-        fs16.unlinkSync(l);
+        fs17.unlinkSync(l);
         out.push(`\u2714 removed ${l}`);
       }
     }
   }
   if (isOurLauncher(launcherPath(), root)) {
-    fs16.rmSync(launcherPath(), { force: true });
+    fs17.rmSync(launcherPath(), { force: true });
     out.push(`\u2714 removed ${launcherPath()}`);
   }
   return out.length ? out : ["nothing to remove"];
 }
 function installedSkills() {
   const names = skillNames();
-  return skillTargets().map((base2) => ({ base: base2, names: names.filter((n) => fs16.existsSync(path14.join(base2, n, "SKILL.md"))) }));
+  return skillTargets().map((base2) => ({ base: base2, names: names.filter((n) => fs17.existsSync(path14.join(base2, n, "SKILL.md"))) }));
 }
 
 // src/core/templates.ts
@@ -2631,8 +2682,8 @@ var FILES = {
 };
 function loadTemplate(name, root = packageRoot()) {
   const file2 = path15.join(root, "skills", FILES[name]);
-  if (!fs17.existsSync(file2)) throw new UserError(`template missing: ${file2} (broken install? run pitroom doctor)`, 3);
-  return fs17.readFileSync(file2, "utf8").replace(/^\s*<!--[\s\S]*?-->\s*/, "");
+  if (!fs18.existsSync(file2)) throw new UserError(`template missing: ${file2} (broken install? run pitroom doctor)`, 3);
+  return fs18.readFileSync(file2, "utf8").replace(/^\s*<!--[\s\S]*?-->\s*/, "");
 }
 function fill(template, values) {
   const missing = [...template.matchAll(/\{\{([A-Z_]+)\}\}/g)].map((m) => m[1]).filter((k) => !(k in values));
@@ -2642,7 +2693,7 @@ function fill(template, values) {
 
 // src/core/slots.ts
 import crypto5 from "node:crypto";
-import fs18 from "node:fs";
+import fs19 from "node:fs";
 import path16 from "node:path";
 var slotsDir = () => path16.join(home(), "slots");
 var locksDir = () => path16.join(home(), "locks");
@@ -2659,23 +2710,23 @@ function holderActive(runId, self) {
   }
 }
 function tryClaim(file2, runId) {
-  fs18.mkdirSync(path16.dirname(file2), { recursive: true });
+  fs19.mkdirSync(path16.dirname(file2), { recursive: true });
   try {
-    fs18.writeFileSync(file2, runId, { flag: "wx" });
+    fs19.writeFileSync(file2, runId, { flag: "wx" });
     return true;
   } catch (e) {
     if (e.code !== "EEXIST") throw e;
   }
   let owner = "";
   try {
-    owner = fs18.readFileSync(file2, "utf8").trim();
+    owner = fs19.readFileSync(file2, "utf8").trim();
   } catch {
   }
   if (owner === runId) return true;
   if (holderActive(owner, runId)) return false;
-  fs18.rmSync(file2, { force: true });
+  fs19.rmSync(file2, { force: true });
   try {
-    fs18.writeFileSync(file2, runId, { flag: "wx" });
+    fs19.writeFileSync(file2, runId, { flag: "wx" });
     return true;
   } catch {
     return false;
@@ -2684,7 +2735,7 @@ function tryClaim(file2, runId) {
 function releaseIfOwner(file2, runId) {
   if (!file2) return;
   try {
-    if (fs18.readFileSync(file2, "utf8").trim() === runId) fs18.rmSync(file2, { force: true });
+    if (fs19.readFileSync(file2, "utf8").trim() === runId) fs19.rmSync(file2, { force: true });
   } catch {
   }
 }
@@ -2702,7 +2753,7 @@ function acquireWriteLock(repoRoot2, runId) {
   if (tryClaim(file2, runId)) return;
   let owner = "";
   try {
-    owner = fs18.readFileSync(file2, "utf8").trim();
+    owner = fs19.readFileSync(file2, "utf8").trim();
   } catch {
   }
   throw new UserError(`another --write run (${owner}) is active in this repo; use --isolate for parallel changes`, 3);
@@ -2749,7 +2800,7 @@ ${task}`;
 }
 
 // src/core/receipt.ts
-import fs19 from "node:fs";
+import fs20 from "node:fs";
 import path17 from "node:path";
 var PRESETS = {
   sonnet: { name: "Claude Sonnet", input: 3, output: 15, cachedInput: 0.3 },
@@ -2786,13 +2837,13 @@ function record(meta) {
     saved: meta.savedUsd ?? 0,
     price: primaryPrice().name
   };
-  fs19.mkdirSync(path17.dirname(ledgerFile()), { recursive: true });
-  fs19.appendFileSync(ledgerFile(), `${JSON.stringify(entry)}
+  fs20.mkdirSync(path17.dirname(ledgerFile()), { recursive: true });
+  fs20.appendFileSync(ledgerFile(), `${JSON.stringify(entry)}
 `);
 }
 function readLedger(sinceMs2) {
-  if (!fs19.existsSync(ledgerFile())) return [];
-  return fs19.readFileSync(ledgerFile(), "utf8").split("\n").filter(Boolean).flatMap((l) => {
+  if (!fs20.existsSync(ledgerFile())) return [];
+  return fs20.readFileSync(ledgerFile(), "utf8").split("\n").filter(Boolean).flatMap((l) => {
     try {
       return [JSON.parse(l)];
     } catch {
@@ -2867,7 +2918,7 @@ ${tile(0, compact(t.tokens), "Tokens offloaded")}${tile(1, t.ratio ? `${Math.rou
 }
 
 // src/core/refs.ts
-import fs20 from "node:fs";
+import fs21 from "node:fs";
 import path18 from "node:path";
 var FILE_EXTENSIONS = new Set(
   "ts tsx mts cts js jsx mjs cjs json jsonc json5 md mdx txt rst py pyi rb go rs java kt kts swift c h cc cpp cxx hpp hh cs fs php lua r jl sh bash zsh fish ps1 bat yml yaml toml ini cfg conf env html htm css scss sass less vue svelte astro sql graphql gql proto lock xml svg csv tsv gradle tf hcl dart ex exs erl hs ml scala clj vim el mk cmake dockerfile gitignore gitattributes editorconfig npmrc nvmrc".split(" ")
@@ -2924,8 +2975,8 @@ function verifyRefs(refs, dirs) {
   const lineCache = /* @__PURE__ */ new Map();
   const load = (file2) => {
     if (!lineCache.has(file2)) {
-      const size = fs20.statSync(file2).size;
-      const lines = size > MAX_BYTES ? null : fs20.readFileSync(file2, "utf8").split("\n");
+      const size = fs21.statSync(file2).size;
+      const lines = size > MAX_BYTES ? null : fs21.readFileSync(file2, "utf8").split("\n");
       if (lines && lines[lines.length - 1] === "") lines.pop();
       lineCache.set(file2, lines);
     }
@@ -2938,7 +2989,7 @@ function verifyRefs(refs, dirs) {
     if (direct) return [direct];
     if (path18.isAbsolute(ref.file)) return [];
     const wanted = ref.file.replace(/^(\.{1,2}\/)+/, "");
-    return (byName().get(path18.basename(wanted)) ?? []).filter((f) => f.endsWith(`/${wanted}`) || path18.basename(f) === wanted).slice(0, 20);
+    return (byName().get(path18.basename(wanted)) ?? []).filter((f) => f.split(path18.sep).join("/").endsWith(`/${wanted}`) || path18.basename(f) === wanted).slice(0, 20);
   };
   const check = (file2, ref) => {
     const lines = load(file2);
@@ -2983,7 +3034,7 @@ function indexFiles(roots) {
   const walk = (dir) => {
     let entries;
     try {
-      entries = fs20.readdirSync(dir, { withFileTypes: true });
+      entries = fs21.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -3006,7 +3057,7 @@ function resolve(ref, roots) {
   const candidates = path18.isAbsolute(ref) ? inside(ref, roots) ? [ref] : [] : roots.map((r) => path18.join(r, ref));
   return candidates.find((c) => {
     try {
-      return fs20.statSync(c).isFile() && inside(c, roots);
+      return fs21.statSync(c).isFile() && inside(c, roots);
     } catch {
       return false;
     }
@@ -3021,13 +3072,13 @@ function inside(file2, roots) {
 var escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 
 // src/core/history.ts
-import fs22 from "node:fs";
+import fs23 from "node:fs";
 import { createRequire } from "node:module";
 import path19 from "node:path";
 import zlib from "node:zlib";
 
 // src/core/ui.ts
-import fs21 from "node:fs";
+import fs22 from "node:fs";
 var WEEK_MS = 7 * 24 * 3600 * 1e3;
 var RECENT = 40;
 var RECENT_HOURS = 1;
@@ -3118,9 +3169,9 @@ function cardsFor(m) {
   const out = [];
   for (const [phase, text] of phases) {
     const marker = runFile(m.id, `card-${phase}`);
-    if (fs21.existsSync(marker)) continue;
+    if (fs22.existsSync(marker)) continue;
     if (!(phase === "started" && !isActive(m.state))) out.push(text());
-    fs21.writeFileSync(marker, "");
+    fs22.writeFileSync(marker, "");
   }
   return out;
 }
@@ -3131,10 +3182,10 @@ function hookCards(input) {
   const response = event.tool_response;
   const output = typeof response === "string" ? response : [response?.stdout, response?.stderr].filter(Boolean).join("\n");
   const ids = [...new Set(`${command}
-${output}`.match(RUN_ID) ?? [])].filter((id) => fs21.existsSync(`${runsDir()}/${id}`));
+${output}`.match(RUN_ID) ?? [])].filter((id) => fs22.existsSync(`${runsDir()}/${id}`));
   const since2 = Date.now() - RECENT_HOURS * 36e5;
   for (const id of listRunIds().slice(-RECENT)) {
-    if (ids.includes(id) || fs21.existsSync(runFile(id, "card-ended"))) continue;
+    if (ids.includes(id) || fs22.existsSync(runFile(id, "card-ended"))) continue;
     try {
       const m = readMeta(id);
       if (!isActive(m.state) && Date.parse(m.endedAt ?? m.startedAt) > since2) ids.push(id);
@@ -3170,7 +3221,7 @@ function openDb() {
     } finally {
       process.emitWarning = emit;
     }
-    fs22.mkdirSync(path19.dirname(file2), { recursive: true });
+    fs23.mkdirSync(path19.dirname(file2), { recursive: true });
     db = new DatabaseSync(file2);
     db.exec("PRAGMA journal_mode=WAL; PRAGMA busy_timeout=5000; PRAGMA synchronous=NORMAL;");
     migrate(db);
@@ -3205,30 +3256,30 @@ function migrate(db) {
 function readRunFile(id, name) {
   const f = runFile(id, name);
   try {
-    if (fs22.existsSync(f)) return fs22.readFileSync(f, "utf8");
-    if (fs22.existsSync(`${f}.gz`)) return zlib.gunzipSync(fs22.readFileSync(`${f}.gz`)).toString("utf8");
+    if (fs23.existsSync(f)) return fs23.readFileSync(f, "utf8");
+    if (fs23.existsSync(`${f}.gz`)) return zlib.gunzipSync(fs23.readFileSync(`${f}.gz`)).toString("utf8");
   } catch {
   }
   return void 0;
 }
 function gzipFile(f) {
-  if (!fs22.existsSync(f)) return;
-  fs22.writeFileSync(`${f}.gz`, zlib.gzipSync(fs22.readFileSync(f)));
-  fs22.rmSync(f);
+  if (!fs23.existsSync(f)) return;
+  fs23.writeFileSync(`${f}.gz`, zlib.gzipSync(fs23.readFileSync(f)));
+  fs23.rmSync(f);
 }
 function compactRun(meta) {
   if (!TERMINAL.includes(meta.state)) return;
   const dir = path19.dirname(runFile(meta.id, "meta.json"));
   let names;
   try {
-    names = fs22.readdirSync(dir);
+    names = fs23.readdirSync(dir);
   } catch {
     return;
   }
   for (const n of names) {
     if (/^events(\.attempt-\d+)?\.jsonl$/.test(n)) gzipFile(path19.join(dir, n));
     else if (/^stderr(\.attempt-\d+)?\.log$/.test(n)) {
-      if (meta.state === "done" && !/attempt/.test(n)) fs22.rmSync(path19.join(dir, n), { force: true });
+      if (meta.state === "done" && !/attempt/.test(n)) fs23.rmSync(path19.join(dir, n), { force: true });
       else gzipFile(path19.join(dir, n));
     }
   }
@@ -3350,6 +3401,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 +3421,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) {
@@ -3383,8 +3435,8 @@ function listHistory(q = {}) {
   const base2 = where.length ? `WHERE ${where.join(" AND ")}` : "";
   try {
     const total = db.prepare(`SELECT COUNT(*) AS n FROM runs r ${base2}`).get(...args).n;
-    const page = q.beforeId ? `${base2 ? `${base2} AND` : "WHERE"} r.id < ?` : base2;
-    const rows = db.prepare(`SELECT r.*, 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 page2 = 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, ${VERIFY_FAILED} AS verify_failed FROM runs r ${page2} 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 +3450,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,
@@ -3480,7 +3533,7 @@ function historyStats(sinceMs2) {
 }
 
 // src/core/report.ts
-import fs23 from "node:fs";
+import fs24 from "node:fs";
 
 // src/core/style.ts
 var enabled = () => {
@@ -3540,11 +3593,13 @@ function duration(meta) {
 }
 function readSummary(meta) {
   const f = runFile(meta.id, "summary.md");
-  return fs23.existsSync(f) ? fs23.readFileSync(f, "utf8").trim() : archivedRun(meta.id)?.answer ?? "";
+  return fs24.existsSync(f) ? fs24.readFileSync(f, "utf8").trim() : archivedRun(meta.id)?.answer ?? "";
 }
 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 +3665,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|is not recognized as an internal or external command/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)) {
@@ -3622,8 +3679,8 @@ function formatReport(meta, finalText = readSummary(meta), maxLines = 400) {
 }
 function live(meta) {
   const f = runFile(meta.id, "events.jsonl");
-  if (!fs23.existsSync(f)) return { steps: 0, toolCalls: 0 };
-  const p = getBackend((meta.ran ?? meta.worker).backend).parse(fs23.readFileSync(f, "utf8"));
+  if (!fs24.existsSync(f)) return { steps: 0, toolCalls: 0 };
+  const p = getBackend((meta.ran ?? meta.worker).backend).parse(fs24.readFileSync(f, "utf8"));
   return { steps: p.usage.steps, toolCalls: p.usage.toolCalls, last: p.lastActivity };
 }
 function progress(meta) {
@@ -3634,7 +3691,7 @@ function progress(meta) {
 }
 
 // src/core/run.ts
-var VERSION2 = true ? "0.16.0" : "0.0.0-dev";
+var VERSION2 = true ? "0.18.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");
@@ -3666,7 +3723,7 @@ function prepareRun(o) {
     parent = readMeta(o.continueFrom);
     if (o.worker || o.tier || o.effort) throw new UserError("a follow-up runs on the same worker as its parent; drop --worker/--tier/--effort");
     if (!parent.sessionId) throw new UserError(`run ${parent.id} has no worker session to continue`, 3);
-    if (parent.mode === "isolate" && (!parent.worktree || !fs24.existsSync(parent.worktree))) {
+    if (parent.mode === "isolate" && (!parent.worktree || !fs25.existsSync(parent.worktree))) {
       throw new UserError(`the isolated copy of run ${parent.id} is gone (applied or discarded)`, 3);
     }
     const ran = parent.ran ?? parent.worker;
@@ -3685,18 +3742,18 @@ function prepareRun(o) {
     throw new UserError(`the ${backend.name} worker cannot attach files; put the content in the task`);
   }
   const mode = parent?.mode ?? o.mode;
-  const dir = path20.resolve(parent?.dir ?? o.dir);
-  if (!fs24.existsSync(dir) || !fs24.statSync(dir).isDirectory()) throw new UserError(`not a directory: ${dir}`);
+  const dir = canonical(path20.resolve(parent?.dir ?? o.dir));
+  if (!fs25.existsSync(dir) || !fs25.statSync(dir).isDirectory()) throw new UserError(`not a directory: ${dir}`);
   const root = repoRoot(dir);
   if (mode === "isolate" && !root) throw new UserError("--isolate needs a git repository", 3);
   if (mode === "write" && !root && !o.allowNonGit) {
     throw new UserError("--write outside a git repo cannot be tracked or reverted; pass --allow-non-git to accept that", 3);
   }
   const files = o.files.map((f) => path20.resolve(f));
-  for (const f of files) if (!fs24.existsSync(f)) throw new UserError(`file not found: ${f}`);
+  for (const f of files) if (!fs25.existsSync(f)) throw new UserError(`file not found: ${f}`);
   const readIn2 = READ_IN.includes(effective().readIn.value) ? effective().readIn.value : "auto";
   const snap = mode === "read" && !o.review && !o.inPlace && !parent ? wantSnapshot(readIn2, root, dir) : void 0;
-  if (parent?.snapshot?.dir && !fs24.existsSync(parent.snapshot.dir)) {
+  if (parent?.snapshot?.dir && !fs25.existsSync(parent.snapshot.dir)) {
     throw new UserError(`the read snapshot of run ${parent.id} is gone (cleaned up); ask the question again as a new run`, 3);
   }
   if (!parent && !snap && !process.env.PITROOM_NO_SECRET_WARNING) {
@@ -3732,6 +3789,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,
@@ -3742,13 +3800,13 @@ function prepareRun(o) {
     try {
       acquireWriteLock(root, meta.id);
     } catch (e) {
-      fs24.rmSync(runDir(meta.id), { recursive: true, force: true });
+      fs25.rmSync(runDir(meta.id), { recursive: true, force: true });
       throw e;
     }
   }
-  fs24.writeFileSync(runFile(meta.id, "task.md"), `${meta.task}
+  fs25.writeFileSync(runFile(meta.id, "task.md"), `${meta.task}
 `);
-  if (work.brief) fs24.writeFileSync(runFile(meta.id, "brief.md"), work.brief);
+  if (work.brief) fs25.writeFileSync(runFile(meta.id, "brief.md"), work.brief);
   return meta;
 }
 var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -3828,7 +3886,7 @@ async function execute(meta) {
       (meta.attempts ??= []).push({ target: describeTarget(target), error: why.message });
       for (const f of ["events.jsonl", "stderr.log"]) {
         const from = runFile(meta.id, f);
-        if (fs24.existsSync(from)) fs24.renameSync(from, runFile(meta.id, f.replace(".", `.attempt-${i + 1}.`)));
+        if (fs25.existsSync(from)) fs25.renameSync(from, runFile(meta.id, f.replace(".", `.attempt-${i + 1}.`)));
       }
       writeMeta(meta);
     }
@@ -3893,7 +3951,7 @@ function prepareTree(meta) {
       meta.snapshot.dir = s.dir;
       meta.snapshot.tree = s.tree;
       meta.cwd = path20.join(s.dir, path20.relative(root, meta.dir));
-      if (!fs24.existsSync(meta.cwd)) meta.cwd = s.dir;
+      if (!fs25.existsSync(meta.cwd)) meta.cwd = s.dir;
       if (shown) meta.warnings.push(`read in a clean snapshot of your project: the secret-looking files (${shown}) and git-ignored files are not in it; --in-place reads the directory itself`);
     } catch (e) {
       meta.snapshot = void 0;
@@ -3928,7 +3986,7 @@ function attempt(meta, backend, target) {
     timeoutSec: meta.timeoutSec
   });
 }
-var read2 = (f) => fs24.existsSync(f) ? fs24.readFileSync(f, "utf8") : "";
+var read2 = (f) => fs25.existsSync(f) ? fs25.readFileSync(f, "utf8") : "";
 function retryableFailure(meta, backend, res) {
   const run2 = backend.parse(read2(runFile(meta.id, "events.jsonl")));
   if (run2.usage.steps > 0) return void 0;
@@ -3948,12 +4006,12 @@ function finalize(meta, res) {
   if (meta.snapshot?.dir && meta.repoRoot) run2.finalText = backToProject(run2.finalText, meta.snapshot.dir, meta.repoRoot);
   meta.sessionId = run2.sessionId ?? meta.sessionId;
   meta.usage = run2.usage;
-  fs24.writeFileSync(runFile(meta.id, "summary.md"), `${run2.finalText}
+  fs25.writeFileSync(runFile(meta.id, "summary.md"), `${run2.finalText}
 `);
   if (meta.plan && !meta.reviewOf) meta.taskStatus = parseStatus(run2.finalText);
   if (meta.reviewOf) {
     meta.verdict = parseVerdict(run2.finalText);
-    if (meta.packageFile) fs24.rmSync(meta.packageFile, { force: true });
+    if (meta.packageFile) fs25.rmSync(meta.packageFile, { force: true });
   }
   if (!res.timedOut && !res.stopped && !meta.error) {
     const f = backend.failure(run2, read2(runFile(meta.id, "stderr.log")), res.code);
@@ -4001,7 +4059,13 @@ function captureChanges(meta) {
   const d = diffTrees(target, meta.baseTree, meta.afterTree);
   meta.changes = d.changes;
   meta.stats = d.stats;
-  fs24.writeFileSync(runFile(meta.id, "changes.patch"), d.patch);
+  fs25.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, {
@@ -4011,11 +4075,12 @@ 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);
-  return { ok: r.status === 0, code: r.status, tail: output.trimEnd().split("\n").slice(-25).join("\n") };
+  fs25.writeFileSync(runFile(meta.id, "verify.log"), output);
+  const notFound = process.platform === "win32" && r.status === 1 && /is not recognized as an internal or external command/.test(output);
+  return { ok: r.status === 0, code: notFound ? 127 : r.status, tail: output.trimEnd().split("\n").slice(-25).join("\n") };
 }
 function applyRun(meta, allowDelete = false) {
   if (meta.mode !== "isolate") throw new UserError(`run ${meta.id} edited your tree directly (${meta.mode}); nothing to apply`);
@@ -4051,6 +4116,15 @@ ${res.message}`, 1);
   writeMeta(meta);
   return `reverted ${meta.changes.length} file(s) changed by ${meta.id}`;
 }
+function stopRun(id) {
+  const meta = freshMeta(id);
+  if (!isActive(meta.state) || !isAlive(meta.pid)) return void 0;
+  requestStop(meta.id);
+  meta.stopRequested = true;
+  writeMeta(meta);
+  process.kill(meta.pid, "SIGTERM");
+  return meta;
+}
 function discardRun(meta) {
   if (meta.mode !== "isolate") throw new UserError("only --isolate runs have an isolated copy to discard");
   cleanupWorktree(meta);
@@ -4059,9 +4133,13 @@ function discardRun(meta) {
   return `discarded the isolated copy of ${meta.id}; the patch stays in ${runFile(meta.id, "changes.patch")}`;
 }
 function cleanupWorktree(meta) {
-  if (meta.worktree && fs24.existsSync(meta.worktree)) removeIsolatedCopy(meta.worktree, worktreesDir());
+  if (meta.worktree && fs25.existsSync(meta.worktree)) removeIsolatedCopy(meta.worktree, worktreesDir());
 }
 
+// src/cli/mcp-extras.ts
+import fs26 from "node:fs";
+import path21 from "node:path";
+
 // src/cli/mcp-support.ts
 import { spawn as spawn3 } from "node:child_process";
 
@@ -4248,12 +4326,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 +4342,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 +4354,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 +4383,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 +4419,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 +4482,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 = fs26.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 +4539,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 +4651,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 +4721,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 +4733,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 +4741,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 +4757,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 +4767,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 +4893,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 +4928,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 +4961,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 +4986,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 +5007,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 fs28 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 fs27 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 +5037,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+)$/);
@@ -4977,9 +5141,9 @@ function fileDiffs(patch, changes, sourceTruncated = false) {
 // src/core/dash-page.ts
 var THEME_SCRIPT = "(function(){try{var t=localStorage.getItem('pitroom-theme');var d=t?t==='dark':matchMedia('(prefers-color-scheme: dark)').matches;document.documentElement.classList.toggle('dark',d)}catch(e){}})()";
 var ICON3 = "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' rx='8' fill='%23ff6a2b'/%3E%3Cpath d='M9 8h4v4H9zm8 0h4v4h-4zm-4 4h4v4h-4zm8 0h4v4h-4zM9 16h4v4H9zm8 0h4v4h-4zm-4 4h4v4h-4zm8 0h4v4h-4z' fill='%23fff'/%3E%3C/svg%3E";
-var PAGE = `<!doctype html>
+var page = (token) => `<!doctype html>
 <html lang="en" class="dark"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
-<meta name="color-scheme" content="dark light"><title>Pitroom</title><link rel="icon" href="${ICON3}">
+<meta name="color-scheme" content="dark light"><meta name="pitroom-token" content="${token}"><title>Pitroom</title><link rel="icon" href="${ICON3}">
 <script>${THEME_SCRIPT}</script><link rel="stylesheet" href="/assets/app.css"></head>
 <body><div id="root"></div><script type="module" src="/assets/app.js"></script></body></html>`;
 var MISSING = `<!doctype html><meta charset="utf-8"><title>Pitroom</title><body style="font:15px system-ui;padding:3rem;max-width:40rem;margin:auto"><h1>Pitroom dash</h1><p>The dashboard files are missing (dist/ui). Run <code>npm run build</code> in the Pitroom repository, or reinstall the package.</p></body>`;
@@ -5000,11 +5164,13 @@ function findings(m) {
   const parts = [v.critical && `${v.critical} critical`, v.important && `${v.important} important`, v.minor && `${v.minor} minor`].filter(Boolean);
   return parts.length ? parts.join(" \xB7 ") : "no findings";
 }
+var canDiscard = (m) => m.mode === "isolate" && !isActive(m.state) && !m.applied && !m.discarded;
 function toRun(m) {
   const l = m.state === "running" ? live(m) : void 0;
   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 +5185,8 @@ 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)
+    discardable: canDiscard(m) || void 0,
+    note: l?.last ? oneLine7(String(l.last), 140) : isActive(m.state) ? "" : m.verifyResult && !m.verifyResult.ok ? `verify failed: ${m.verify ?? ""}` : m.verdict ? findings(m) : m.auditOf && m.state === "done" ? m.auditDisputed?.length ? `${m.auditDisputed.length} disputed` : "nothing disputed" : headline(m, 200) || oneLine7(m.error ?? "", 200)
   };
 }
 function dashState(opts = {}) {
@@ -5123,29 +5290,55 @@ 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 } = fs27.statSync(file2);
     const hit = assetCache.get(route);
     if (hit && hit.mtimeMs === mtimeMs) return hit.data;
-    const data = fs25.readFileSync(file2);
+    const data = fs27.readFileSync(file2);
     assetCache.set(route, { mtimeMs, data });
     return data;
   } catch {
     return void 0;
   }
 }
-function handler(touch2) {
+function handler(touch2, token) {
   const send = (res, code, type, body) => {
     res.writeHead(code, { ...HEADERS, "content-type": type });
     res.end(body);
   };
   const json = (res, code, value) => send(res, code, "application/json; charset=utf-8", JSON.stringify(value));
+  const tokenBuf = Buffer.from(token);
+  const act = (req, res, pathname) => {
+    req.resume();
+    const given = Buffer.from(String(req.headers["x-pitroom-token"] ?? ""));
+    if (given.length !== tokenBuf.length || !crypto6.timingSafeEqual(given, tokenBuf)) return json(res, 403, { error: "forbidden" });
+    if (req.headers.origin !== `http://${req.headers.host}`) return json(res, 403, { error: "forbidden origin" });
+    const m = /^\/api\/run\/([^/]+)\/(stop|discard)$/.exec(pathname);
+    if (!m) return json(res, 404, { error: "not found" });
+    let meta;
+    try {
+      if (!RUN_ID3.test(m[1])) throw new Error("bad id");
+      meta = freshMeta(m[1]);
+    } catch {
+      return json(res, 404, { error: "no such run" });
+    }
+    try {
+      if (m[2] === "stop") {
+        return stopRun(meta.id) ? json(res, 200, { ok: true, message: `stopping ${meta.id}` }) : json(res, 409, { error: "run is not active" });
+      }
+      if (!canDiscard(meta)) return json(res, 409, { error: "only a finished, not yet applied isolate run can be discarded" });
+      return json(res, 200, { ok: true, message: discardRun(meta) });
+    } catch (e) {
+      return json(res, 409, { error: e.message });
+    }
+  };
   return (req, res) => {
     touch2();
     if (!LOCAL_HOST.test(req.headers.host ?? "")) return json(res, 403, { error: "forbidden host" });
-    if (req.method !== "GET" && req.method !== "HEAD") return json(res, 405, { error: "read-only" });
     const url = new URL(req.url ?? "/", "http://127.0.0.1");
-    if (url.pathname === "/") return send(res, 200, "text/html; charset=utf-8", readAsset("/assets/app.js") ? PAGE : MISSING);
+    if (req.method === "POST") return act(req, res, url.pathname);
+    if (req.method !== "GET" && req.method !== "HEAD") return json(res, 405, { error: "read-only" });
+    if (url.pathname === "/") return send(res, 200, "text/html; charset=utf-8", readAsset("/assets/app.js") ? page(token) : MISSING);
     const type = ASSETS[url.pathname];
     if (type) {
       const data = readAsset(url.pathname);
@@ -5160,21 +5353,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) {
@@ -5186,28 +5379,28 @@ function handler(touch2) {
 }
 function startDash(opts) {
   let lastRequest = Date.now();
-  const server = http.createServer(handler(() => lastRequest = Date.now()));
+  const server = http.createServer(handler(() => lastRequest = Date.now(), crypto6.randomBytes(24).toString("hex")));
   return new Promise((resolve2, reject) => {
     server.once("error", reject);
     server.listen(opts.port, "127.0.0.1", () => {
       const port = server.address().port;
       let done;
       const closed = new Promise((r) => done = r);
-      let timer;
+      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 +5411,11 @@ async function ping(port) {
 }
 async function runningDash() {
   try {
-    const r = JSON.parse(fs25.readFileSync(registryFile(), "utf8"));
+    const r = JSON.parse(fs27.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 });
+  fs27.rmSync(registryFile(), { force: true });
   return void 0;
 }
 function openBrowser(url) {
@@ -5237,7 +5430,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 });
+    fs27.rmSync(registryFile(), { force: true });
     o.log(`stopped pitroom dash (${existing.url})`);
     return 0;
   }
@@ -5254,7 +5447,7 @@ async function dashCommand(o) {
     });
     child.on("error", () => void 0);
     child.unref();
-    for (let i = 0; i < 60; i++) {
+    for (let i = 0; i < 200; i++) {
       await new Promise((r2) => setTimeout(r2, 100));
       const r = await runningDash();
       if (r && r.pid === child.pid) {
@@ -5274,8 +5467,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 }));
+  fs27.mkdirSync(home(), { recursive: true });
+  fs27.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 +5477,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(fs27.readFileSync(registryFile(), "utf8")).pid === process.pid) fs27.rmSync(registryFile(), { force: true });
   } catch {
   }
   return 0;
@@ -5296,10 +5489,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 = fs28.readFileSync(file2, "utf8").trim();
     return kept.length >= 16 ? kept : void 0;
   } catch {
     return void 0;
@@ -5314,10 +5507,10 @@ function mcpToken() {
   const file2 = tokenFile();
   let token = readToken(file2);
   if (!token) {
-    fs26.mkdirSync(path22.dirname(file2), { recursive: true });
+    fs28.mkdirSync(path23.dirname(file2), { recursive: true });
     token = crypto7.randomBytes(32).toString("hex");
     try {
-      fs26.writeFileSync(file2, `${token}
+      fs28.writeFileSync(file2, `${token}
 `, { mode: 384, flag: "wx" });
     } catch (e) {
       if (e.code !== "EEXIST") throw e;
@@ -5326,7 +5519,7 @@ function mcpToken() {
     }
   }
   try {
-    fs26.chmodSync(file2, 384);
+    fs28.chmodSync(file2, 384);
   } catch {
   }
   return { token, from: file2 };
@@ -5337,6 +5530,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 +5564,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 +5580,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 +5630,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 +5673,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 +5693,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 +5701,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 fs34 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 fs29 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) && fs29.existsSync(binary5);
 function planInit(opts = {}) {
   const file2 = configPath();
   const workers = backendIds().map((id) => {
@@ -5527,15 +5756,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: fs29.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)`);
+  fs29.mkdirSync(path24.dirname(plan.path), { recursive: true });
+  if (plan.exists) fs29.copyFileSync(plan.path, `${plan.path}.bak`);
+  fs29.writeFileSync(plan.path, `${JSON.stringify(plan.config, null, 2)}
 `);
   return plan.path;
 }
@@ -5556,17 +5785,17 @@ function formatInit(plan, written) {
 
 // src/core/mcp-install.ts
 import { spawnSync as spawnSync7 } from "node:child_process";
-import fs28 from "node:fs";
+import fs30 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 (fs30.existsSync(p)) return { command: path25.resolve(p), args: ["mcp"] };
   }
   return { command: process.execPath, args: [process.argv[1] ?? "pitroom", "mcp"] };
 }
@@ -5582,7 +5811,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(fs30.readFileSync(file2, "utf8"));
   } catch {
     return void 0;
   }
@@ -5592,7 +5821,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 +5844,43 @@ function jsonClient(id, name, file2, dir) {
   return {
     id,
     name,
-    found: () => fs28.existsSync(dir()),
+    found: () => fs30.existsSync(dir()),
     state: (c) => jsonState(file2(), c),
     add: (c) => {
       let config = {};
-      if (fs28.existsSync(file2())) {
+      if (fs30.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 (!fs30.existsSync(backup)) fs30.copyFileSync(file2(), backup);
       }
       config.mcpServers = { ...config.mcpServers ?? {}, [NAME]: { command: c.command, args: c.args } };
-      fs28.mkdirSync(path24.dirname(file2()), { recursive: true });
+      fs30.mkdirSync(path25.dirname(file2()), { recursive: true });
       const tmp = `${file2()}.${process.pid}.tmp`;
-      fs28.writeFileSync(tmp, `${JSON.stringify(config, null, 2)}
+      fs30.writeFileSync(tmp, `${JSON.stringify(config, null, 2)}
 `);
-      fs28.renameSync(tmp, file2());
+      fs30.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)}
+      fs30.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 = fs30.readFileSync(path25.join(process.env.CODEX_HOME ?? path25.join(home2(), ".codex"), "config.toml"), "utf8");
   } catch {
     return "absent";
   }
@@ -5669,7 +5898,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 +5908,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 +5984,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 fs31 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 (!fs31.existsSync(f)) return [];
+  return fs31.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 +6001,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}
+  fs31.mkdirSync(path26.dirname(f), { recursive: true });
+  if (!fs31.existsSync(f)) fs31.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()}
+  fs31.appendFileSync(f, `${at} ${text.replace(/\s+/g, " ").trim()}
 `);
   return f;
 }
@@ -5842,10 +6071,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 fs32 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 = canonical(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(fs32.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 fs33 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 +6155,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 fs33.existsSync(f) ? fs33.readFileSync(f, "utf8") : root.task;
 }
 function latestReview(ids) {
   for (const id of listRunIds().reverse()) {
@@ -5877,7 +6169,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 && fs33.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 +6183,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 && fs33.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 +6256,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(fs33.realpathSync(root), fs33.realpathSync(g)).startsWith("..");
+  const file2 = inside2 ? path28.join(g, "pitroom", name) : path28.join(root, ".pitroom", name);
+  if (!inside2) ignoreInGit(root, "/.pitroom/");
+  fs33.mkdirSync(path28.dirname(file2), { recursive: true });
+  fs33.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 = fs33.existsSync(exclude) ? fs33.readFileSync(exclude, "utf8") : "";
+  if (text.split(/\r?\n/).includes(pattern)) return;
+  fs33.mkdirSync(path28.dirname(exclude), { recursive: true });
+  fs33.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 +6391,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 +6427,10 @@ async function cmdReview(p) {
       writeMeta(meta);
     }
   } catch (e) {
-    fs31.rmSync(packageFile, { force: true });
+    fs34.rmSync(packageFile, { force: true });
     throw e;
   }
-  fs31.writeFileSync(runFile(meta.id, "package.md"), job.package);
+  fs34.writeFileSync(runFile(meta.id, "package.md"), job.package);
   return launch(p, meta);
 }
 async function cmdAudit(p) {
@@ -6185,7 +6498,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 ? fs34.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 +6619,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) => {
@@ -6371,11 +6684,8 @@ function cmdStop(p) {
   const ids = selectIds(p, () => [resolveRun(void 0)]);
   let stopped = 0;
   for (const id of ids) {
-    const meta = freshMeta(id);
-    if (!isActive(meta.state) || !isAlive(meta.pid)) continue;
-    meta.stopRequested = true;
-    writeMeta(meta);
-    process.kill(meta.pid, "SIGTERM");
+    const meta = stopRun(id);
+    if (!meta) continue;
     console.log(`stopping ${meta.id} (${meta.state})`);
     stopped++;
   }
@@ -6388,13 +6698,13 @@ function sinceMs(s) {
   if (!m) throw new UserError("--since takes 7d, 30d, \u2026 or all");
   return Date.now() - Number(m[1]) * 864e5;
 }
-var readStdin = () => process.stdin.isTTY ? "" : fs31.readFileSync(0, "utf8");
+var readStdin = () => process.stdin.isTTY ? "" : fs34.readFileSync(0, "utf8");
 function cmdStatusline(p) {
   const input = readStdin();
   const lines = [];
   const then = flag(p, "then");
   if (then) {
-    const r = spawnSync8("/bin/sh", ["-c", then], { input, encoding: "utf8", timeout: 5e3 });
+    const r = process.platform === "win32" ? spawnSync8(then, { shell: true, input, encoding: "utf8", timeout: 5e3 }) : spawnSync8("/bin/sh", ["-c", then], { input, encoding: "utf8", timeout: 5e3 });
     if (r.stdout?.trimEnd()) lines.push(r.stdout.trimEnd());
   }
   try {
@@ -6428,8 +6738,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 (fs34.existsSync(script)) spawnSync8(process.execPath, [script], { stdio: ["ignore", "inherit", "ignore"], env: process.env });
   return 0;
 }
 function cmdInit(p) {
@@ -6469,8 +6779,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)}`);
+    fs34.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 +6822,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()}${fs34.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 +6831,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 });
+    fs34.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 +6857,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 fs35 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 +6869,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 (!fs35.statSync(file2).isFile()) continue;
     } catch {
       continue;
     }
@@ -6589,14 +6899,16 @@ 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()}${fs35.existsSync(configPath()) ? "" : " (not present, defaults in use)"}`);
   for (const w of cfg.warnings) add("warn", w);
-  if (process.platform !== "win32") {
+  if (process.platform === "win32") {
+    add("warn", "git guard: not available on Windows yet, so Pitroom does not block a worker's git history changes or pushes there (read-only runs are still limited by each worker CLI's own rules, and --isolate keeps edits in a copy); prefer --isolate and check the patch before apply");
+  } else {
     const guarded = guardEnv(process.env).PATH?.startsWith(shimDir());
     add(guarded ? "ok" : "warn", guarded ? "git guard shim ready" : "git guard unavailable (git not on PATH)");
   }
@@ -6747,20 +7059,20 @@ function skillChecks() {
     else if (!viaPlugin) checks.push({ level: "warn", message: `no Pitroom skills in ${base2}; run \`pitroom install\`` });
   }
   if (geminiExtensionInstalled()) {
-    const linked = installedSkills().some((i) => i.base.includes(`${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)) {
-    const r = spawnSync9(launcher, ["--version"], { encoding: "utf8", timeout: 3e4, stdio: ["ignore", "pipe", "pipe"] });
+  if (fs35.existsSync(launcher)) {
+    const r = spawnSync9(launcher, ["--version"], { encoding: "utf8", timeout: 3e4, stdio: ["ignore", "pipe", "pipe"], shell: process.platform === "win32" });
     checks.push(
       r.status === 0 ? { level: "ok", message: `launcher ${launcher} \u2192 pitroom ${r.stdout.trim()}` } : { level: "fail", message: `launcher ${launcher} does not start: ${(r.stderr || r.stdout).trim().slice(0, 200)}` }
     );
@@ -6771,12 +7083,12 @@ function skillChecks() {
 }
 function geminiExtensionInstalled() {
   const home3 = process.env.GEMINI_CLI_HOME ?? os11.homedir();
-  return fs32.existsSync(path28.join(home3, ".gemini", "extensions", "pitroom"));
+  return fs35.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(fs35.readFileSync(f, "utf8")).plugins ?? {};
     return Object.keys(plugins).some((k) => k.startsWith("pitroom@"));
   } catch {
     return false;
@@ -6793,24 +7105,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 (fs35.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(fs35.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(fs35.readFileSync(f, "utf8")).enabledPlugins?.[key] !== false;
   } catch {
     return true;
   }
@@ -6819,7 +7131,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 = fs35.readFileSync(path30.join(process.env.CODEX_HOME ?? path30.join(os11.homedir(), ".codex"), "config.toml"), "utf8");
   } catch {
     return plugins;
   }
@@ -6837,11 +7149,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 = fs35.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 +7161,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 fs35.readdirSync(path30.join(dir, folder))) plugins.push(path30.join(dir, folder, f));
     } catch {
     }
   }
@@ -6929,6 +7241,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 +7263,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 +7278,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 (!fs36.statSync(dir, { throwIfNoEntry: false })?.isDirectory()) throw new UserError(`-d ${dir}: no such directory`);
       process.chdir(dir);
       process.env.PWD = process.cwd();
     }