pitroom 0.26.0 → 0.27.0

package/dist/pitroom.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import fs43 from "node:fs";
+import fs44 from "node:fs";
 
 // src/core/errors.ts
 var UserError = class extends Error {
@@ -558,7 +558,7 @@ function denyCommandRules() {
     "command(eval)"
   ];
 }
-function workerSettings(workspace, workerHome3, reads = []) {
+function workerSettings(workspace, workerHome3, reads = [], writes = false) {
   const real = (p) => {
     try {
       return fs6.realpathSync.native(p);
@@ -582,6 +582,8 @@ function workerSettings(workspace, workerHome3, reads = []) {
       allow: [
         "command(*)",
         ...both(path5.join(dataDir(workerHome3), "brain")).map((p) => `write_file(${rulePath(p)})`),
+        // agy 1.4 asks for edits in the workspace too, --mode accept-edits or not, and a headless run cannot ask
+        ...writes ? both(workspace).map((p) => `write_file(${rulePath(p)})`) : [],
         ...toolchains().flatMap(both).map((p) => `read_file(${rulePath(p)})`),
         // what the task names outside the workspace: a headless agy cannot ask, and would end the turn unanswered
         ...reads.map((r) => r.path).flatMap(both).map((p) => `read_file(${rulePath(p)})`)
@@ -707,12 +709,12 @@ function baseSettings() {
 }
 var rulePath = (p) => p.replace(/^[A-Za-z]:(?=[\\/])/, "").replace(/\\/g, "/");
 var HOMES_KEPT_DAYS = 14;
-function workerHome(workspace, reads = []) {
+function workerHome(workspace, reads = [], writes = false) {
   const root = path5.join(home(), "antigravity-home");
   const id2 = crypto3.createHash("sha256").update(path5.resolve(workspace)).digest("hex").slice(0, 16);
   const dir = path5.join(root, id2);
   fs6.mkdirSync(dataDir(dir), { recursive: true });
-  writeIfChanged(path5.join(dataDir(dir), "settings.json"), `${JSON.stringify(workerSettings(workspace, dir, reads), null, 2)}
+  writeIfChanged(path5.join(dataDir(dir), "settings.json"), `${JSON.stringify(workerSettings(workspace, dir, reads, writes), null, 2)}
 `);
   if (process.platform === "darwin") {
     fs6.mkdirSync(path5.join(dir, "Library"), { recursive: true });
@@ -769,7 +771,7 @@ function invocation(req) {
   if (model) args.push("--model", model);
   if (effort) args.push("--effort", effort);
   const { command, prefix } = resolveCommand(binary());
-  const workerDir = workerHome(req.cwd, outsideReads(prompt, req.cwd, req.project?.root));
+  const workerDir = workerHome(req.cwd, outsideReads(prompt, req.cwd, req.project?.root), req.mode !== "read");
   const env = { HOME: workerDir };
   if (process.platform === "win32") env.USERPROFILE = workerDir;
   return { command, args: [...prefix, ...args], env };
@@ -826,9 +828,10 @@ function doctor({ models, hasFallback }) {
   }
   const checks = [
     { level: "ok", message: `Antigravity CLI ${version.out.trim().split("\n")[0]} at ${binary()}` },
-    {
+    // checked on macOS (agy 1.4.7, scripts/check-worker.mjs); Linux and Windows not run yet
+    process.platform === "darwin" ? { level: "ok", message: "agy has no read-only mode for headless runs, so its read runs always read a snapshot of the project; prefer -i for changes" } : {
       level: "warn",
-      message: "the Antigravity worker is in beta (checked against agy 1.3.5). agy has no read-only mode for headless runs, so its read runs always read a snapshot of the project; prefer -i for changes"
+      message: `the Antigravity worker is in beta on ${process.platform === "win32" ? "Windows" : "Linux"} (checked on macOS only; node scripts/check-worker.mjs antigravity tries it here). agy has no read-only mode for headless runs, so its read runs always read a snapshot of the project; prefer -i for changes`
     }
   ];
   if (process.platform === "win32") {
@@ -2343,7 +2346,8 @@ var SCHEMA = {
   priceFeedUrl: "string",
   priceFeedHours: "number",
   budgetDaily: "number",
-  rankWorkers: "boolean"
+  rankWorkers: "boolean",
+  autoFallback: "boolean"
 };
 function configPath() {
   if (process.env.PITROOM_CONFIG) return path12.resolve(process.env.PITROOM_CONFIG);
@@ -2453,6 +2457,7 @@ function effective(flags = {}) {
     priceFeedUrl: setting(void 0, e.PITROOM_PRICE_FEED_URL?.trim() || void 0, c.priceFeedUrl?.trim() || void 0, "https://models.dev/api.json"),
     priceFeedHours: setting(void 0, positiveInt(e.PITROOM_PRICE_FEED_HOURS), positiveInt(c.priceFeedHours), 24),
     rankWorkers: setting(void 0, flag01(e.PITROOM_RANK_WORKERS), c.rankWorkers, false),
+    autoFallback: setting(void 0, flag01(e.PITROOM_AUTO_FALLBACK), c.autoFallback, false),
     budgetDaily: setting(void 0, amount(e.PITROOM_BUDGET_DAILY), amount(c.budgetDaily), void 0)
   };
 }
@@ -2639,9 +2644,9 @@ function effortFlag(p) {
 import readline from "node:readline";
 
 // src/core/run.ts
-import { spawn as spawn4, spawnSync as spawnSync9 } from "node:child_process";
-import fs31 from "node:fs";
-import path27 from "node:path";
+import { spawn as spawn4, spawnSync as spawnSync10 } from "node:child_process";
+import fs32 from "node:fs";
+import path28 from "node:path";
 
 // src/vcs/git.ts
 import { spawnSync as spawnSync8 } from "node:child_process";
@@ -2772,7 +2777,29 @@ function applyPatch(root, patchFile, reverse) {
 function reviewDiff(root, a, b) {
   return `${must(root, [...DIFF, "--stat", a, b]).trim()}
 
-${must(root, [...DIFF, "-U10", a, b])}`;
+${numberDiff(must(root, [...DIFF, "-U10", a, b]))}`;
+}
+var NUMBERED = "Each line of a hunk starts with its line number in the file after the change (a removed line has none): cite those.";
+function numberDiff(diff) {
+  let next = 0;
+  let width = 0;
+  let inHunk = false;
+  return diff.split("\n").map((l) => {
+    if (l.startsWith("diff --git")) {
+      inHunk = false;
+      return l;
+    }
+    const hunk = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/.exec(l);
+    if (hunk) {
+      inHunk = true;
+      next = Number(hunk[1]);
+      width = String(next + Number(hunk[2] ?? 1)).length;
+      return l;
+    }
+    if (!inHunk || !l || !"+- ".includes(l[0])) return l;
+    if (l[0] === "-") return `-${" ".repeat(width)}| ${l.slice(1)}`;
+    return `${l[0]}${String(next++).padStart(width)}| ${l.slice(1)}`;
+  }).join("\n");
 }
 function rangeDiff(root, a, b) {
   const range = `${a}..${b}`;
@@ -2787,7 +2814,9 @@ ${log2 || "(none)"}`,
 ${must(root, [...DIFF, "--stat", since2]).trim() || "(none)"}`,
     `## DIFF
 
-${must(root, [...DIFF, "-U10", since2])}`
+${NUMBERED}
+
+${numberDiff(must(root, [...DIFF, "-U10", since2]))}`
   ].join("\n\n");
 }
 function commitOf(root, ref) {
@@ -2799,6 +2828,10 @@ function gitDir(dir) {
   return r.code === 0 ? r.stdout.trim() : void 0;
 }
 
+// src/core/chain.ts
+import fs15 from "node:fs";
+import path14 from "node:path";
+
 // src/core/target.ts
 function parseTarget(spec, defaultBackend) {
   const s = spec.trim();
@@ -2857,17 +2890,52 @@ function resolveChain(flags = {}) {
         warnings2.push(`fallback ${s} skipped: ${e.message}`);
       }
     }
+    if (!fallback.length && eff.autoFallback.value) fallback.push(...autoFallback(worker, withDefault));
   }
   return { worker, fallback, warnings: warnings2 };
 }
+var AUTO_MAX = 4;
+var bare = (t) => `${t.backend}:${(t.model ?? "").split("#")[0]}`;
+function installed(backend) {
+  try {
+    const bin = getBackend(backend).binary();
+    return path14.isAbsolute(bin) && fs15.statSync(bin).isFile();
+  } catch {
+    return false;
+  }
+}
+function autoFallback(worker, withDefault = (t) => t) {
+  const eff = effective();
+  const named = [
+    ...Object.values(eff.tiers.value),
+    ...Object.entries(eff.models.value).map(([backend, model]) => `${backend}:${model}`),
+    eff.worker.value
+  ];
+  const costs = eff.costs.value;
+  const out = [];
+  for (const spec of named) {
+    let t;
+    try {
+      t = withDefault(parseTarget(spec, worker.backend));
+      getBackend(t.backend);
+    } catch {
+      continue;
+    }
+    if (bare(t) === bare(worker) || out.some((o) => bare(o) === bare(t)) || !installed(t.backend)) continue;
+    out.push(t);
+  }
+  const cost = (t) => costs[bare(t)] ?? Infinity;
+  return out.map((t, i) => ({ t, i })).sort((a, b) => cost(a.t) - cost(b.t) || a.i - b.i).slice(0, AUTO_MAX).map((x) => x.t);
+}
 
 // src/core/process.ts
 import { spawn } from "node:child_process";
-import fs16 from "node:fs";
+import fs17 from "node:fs";
 
 // src/vcs/guard.ts
-import fs15 from "node:fs";
-import path14 from "node:path";
+import { spawnSync as spawnSync9 } from "node:child_process";
+import fs16 from "node:fs";
+import path15 from "node:path";
 var VERSION = 2;
 var WINDOWS = process.platform === "win32";
 var fwd = (p) => WINDOWS ? p.replace(/\\/g, "/") : p;
@@ -2944,38 +3012,38 @@ esac
 exec "$real" "$@"
 `;
 function shimDir() {
-  return path14.join(home(), "shim", `v${VERSION}`);
+  return path15.join(home(), "shim", `v${VERSION}`);
 }
 function scoopTarget(exe) {
   try {
-    const text = fs15.readFileSync(exe.replace(/\.exe$/i, ".shim"), "utf8");
+    const text = fs16.readFileSync(exe.replace(/\.exe$/i, ".shim"), "utf8");
     const target = /^\s*path\s*=\s*"?([^"\r\n]+?)"?\s*$/m.exec(text)?.[1];
-    return target && fs15.statSync(target).isFile() ? target : void 0;
+    return target && fs16.statSync(target).isFile() ? target : void 0;
   } catch {
     return void 0;
   }
 }
 function findRealGit(skip) {
   const same2 = (a, b) => WINDOWS ? a.toLowerCase() === b.toLowerCase() : a === b;
-  for (const dir of (process.env.PATH ?? "").split(path14.delimiter).filter(Boolean)) {
-    if (same2(path14.resolve(dir), skip)) continue;
-    const p = path14.join(dir, WINDOWS ? "git.exe" : "git");
+  for (const dir of (process.env.PATH ?? "").split(path15.delimiter).filter(Boolean)) {
+    if (same2(path15.resolve(dir), skip)) continue;
+    const p = path15.join(dir, WINDOWS ? "git.exe" : "git");
     try {
-      fs15.accessSync(p, fs15.constants.X_OK);
-      if (fs15.statSync(p).isFile()) return WINDOWS && scoopTarget(p) || p;
+      fs16.accessSync(p, fs16.constants.X_OK);
+      if (fs16.statSync(p).isFile()) return WINDOWS && scoopTarget(p) || p;
     } catch {
     }
   }
   return void 0;
 }
 function findGitSh(realGit) {
-  let dir = path14.dirname(realGit);
+  let dir = path15.dirname(realGit);
   for (let i = 0; i < 4; i++) {
     for (const rel of ["bin/sh.exe", "usr/bin/sh.exe"]) {
-      const p = path14.join(dir, rel);
-      if (fs15.existsSync(p)) return p;
+      const p = path15.join(dir, rel);
+      if (fs16.existsSync(p)) return p;
     }
-    const up = path14.dirname(dir);
+    const up = path15.dirname(dir);
     if (up === dir) break;
     dir = up;
   }
@@ -3003,6 +3071,63 @@ var cmdShim = (sh) => [
   "exit /b %errorlevel%",
   ""
 ].join("\r\n");
+var launcherSource = (sh) => `// pitroom git guard: git.exe launcher v${VERSION} (generated; edit src/vcs/guard.ts)
+using System;
+using System.Diagnostics;
+using System.IO;
+
+static class PitroomGit {
+  const string Sh = @"${sh.replace(/"/g, '""')}";
+
+  static int Main() {
+    string line = Environment.CommandLine;
+    // this program's own name, as Windows reads it: up to the closing quote when it starts with one, else to a space
+    int i = 0;
+    if (line.Length > 0 && line[0] == '"') { int q = line.IndexOf('"', 1); i = q < 0 ? line.Length : q + 1; }
+    else { while (i < line.Length && line[i] != ' ' && line[i] != '\\t') i++; }
+    string script = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "git");
+    ProcessStartInfo start = new ProcessStartInfo(Sh, "\\"" + script + "\\"" + line.Substring(i));
+    start.UseShellExecute = false;
+    start.EnvironmentVariables["MSYS2_ARG_CONV_EXCL"] = "*";
+    // Ctrl+C reaches git too: wait for it to end and pass its exit code on
+    Console.CancelKeyPress += delegate (object o, ConsoleCancelEventArgs e) { e.Cancel = true; };
+    using (Process git = Process.Start(start)) {
+      git.WaitForExit();
+      return git.ExitCode;
+    }
+  }
+}
+`;
+function findCsc() {
+  const windir = process.env.WINDIR ?? process.env.SystemRoot ?? "C:\\Windows";
+  for (const fw of ["Framework64", "Framework"]) {
+    const p = path15.join(windir, "Microsoft.NET", fw, "v4.0.30319", "csc.exe");
+    if (fs16.existsSync(p)) return p;
+  }
+  return void 0;
+}
+function buildLauncher(dir, sh) {
+  const source = launcherSource(sh);
+  const src = path15.join(dir, "git-launcher.cs");
+  const exe = path15.join(dir, "git.exe");
+  if (fs16.existsSync(exe) && fs16.existsSync(src) && fs16.readFileSync(src, "utf8") === source) return;
+  const csc = findCsc();
+  if (!csc) return;
+  const tmp = path15.join(dir, `git.${process.pid}.tmp.exe`);
+  const tmpSrc = `${src}.${process.pid}.tmp`;
+  try {
+    fs16.mkdirSync(dir, { recursive: true });
+    fs16.writeFileSync(tmpSrc, source);
+    const r = spawnSync9(csc, ["/nologo", "/optimize+", "/target:exe", `/out:${tmp}`, tmpSrc], { encoding: "utf8", timeout: 6e4, windowsHide: true });
+    if (r.status !== 0 || !fs16.existsSync(tmp)) return;
+    renameOver(tmp, exe);
+    renameOver(tmpSrc, src);
+  } catch {
+  } finally {
+    fs16.rmSync(tmp, { force: true });
+    fs16.rmSync(tmpSrc, { force: true });
+  }
+}
 var HOOK_VERSION = 1;
 var REF_HOOK = `#!/bin/sh
 # pitroom git guard (layer 2, v${HOOK_VERSION}): refuse ref updates made by workers.
@@ -3010,12 +3135,12 @@ var REF_HOOK = `#!/bin/sh
 echo "pitroom: git ref updates (commit, reset, branch, tag, stash, rebase, merge) are blocked for workers" >&2
 exit 1
 `;
-var hooksDir = () => path14.join(home(), "git-hooks", `v${HOOK_VERSION}`);
+var hooksDir = () => path15.join(home(), "git-hooks", `v${HOOK_VERSION}`);
 function writeIfChanged2(file2, content) {
-  if (fs15.existsSync(file2) && fs15.readFileSync(file2, "utf8") === content) return;
-  fs15.mkdirSync(path14.dirname(file2), { recursive: true });
+  if (fs16.existsSync(file2) && fs16.readFileSync(file2, "utf8") === content) return;
+  fs16.mkdirSync(path15.dirname(file2), { recursive: true });
   const tmp = `${file2}.${process.pid}.tmp`;
-  fs15.writeFileSync(tmp, content, { mode: 493 });
+  fs16.writeFileSync(tmp, content, { mode: 493 });
   renameOver(tmp, file2);
 }
 function pathKey(env) {
@@ -3047,7 +3172,7 @@ function guardEnv(env) {
     GIT_PAGER: "cat",
     PAGER: "cat"
   };
-  writeIfChanged2(path14.join(hooksDir(), "reference-transaction"), REF_HOOK);
+  writeIfChanged2(path15.join(hooksDir(), "reference-transaction"), REF_HOOK);
   env = withGitConfig(onePath(env), [
     ["core.hooksPath", fwd(hooksDir())],
     ["url.pitroom-push-blocked://.pushInsteadOf", ""]
@@ -3059,11 +3184,12 @@ function guardEnv(env) {
   if (WINDOWS) {
     sh = findGitSh(real);
     if (!sh) return { ...env, ...quiet };
-    writeIfChanged2(path14.join(dir, "git.cmd"), cmdShim(sh));
+    writeIfChanged2(path15.join(dir, "git.cmd"), cmdShim(sh));
+    buildLauncher(dir, sh);
   }
-  writeIfChanged2(path14.join(dir, "git"), SHIM);
+  writeIfChanged2(path15.join(dir, "git"), SHIM);
   const key = pathKey(env);
-  return { ...env, ...quiet, PITROOM_REAL_GIT: fwd(real), [key]: `${dir}${path14.delimiter}${env[key] ?? ""}` };
+  return { ...env, ...quiet, PITROOM_REAL_GIT: fwd(real), [key]: `${dir}${path15.delimiter}${env[key] ?? ""}` };
 }
 function shimReady() {
   const env = guardEnv({ ...process.env });
@@ -3072,8 +3198,8 @@ function shimReady() {
 
 // src/core/process.ts
 async function spawnWorker(inv, opts) {
-  const out = fs16.openSync(opts.stdoutFile, "w");
-  const err = fs16.openSync(opts.stderrFile, "w");
+  const out = fs17.openSync(opts.stdoutFile, "w");
+  const err = fs17.openSync(opts.stderrFile, "w");
   const res = { code: null, timedOut: false, stopped: false };
   const child = spawn(inv.command, inv.args, {
     cwd: opts.cwd,
@@ -3096,7 +3222,7 @@ async function spawnWorker(inv, opts) {
   }, opts.timeoutSec * 1e3);
   res.code = await new Promise((resolve2) => {
     child.on("error", (e) => {
-      res.spawnError = e.code === "ENOENT" ? fs16.existsSync(opts.cwd) ? `${inv.command} not found` : `the working directory ${opts.cwd} does not exist` : e.message;
+      res.spawnError = e.code === "ENOENT" ? fs17.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));
@@ -3105,8 +3231,8 @@ async function spawnWorker(inv, opts) {
   if (killer) clearTimeout(killer);
   process.off("SIGINT", stop);
   process.off("SIGTERM", stop);
-  fs16.closeSync(out);
-  fs16.closeSync(err);
+  fs17.closeSync(out);
+  fs17.closeSync(err);
   return res;
 }
 
@@ -3138,13 +3264,13 @@ function parseAudit(text) {
 }
 
 // src/core/cooldown.ts
-import fs17 from "node:fs";
-import path15 from "node:path";
+import fs18 from "node:fs";
+import path16 from "node:path";
 var MAX_MS = 24 * 36e5;
 var OVERLOAD_MS = 20 * 6e4;
 var USAGE_MS = 36e5;
 var DAILY_MS = 4 * 36e5;
-var file = () => path15.join(home(), "cooldowns.json");
+var file = () => path16.join(home(), "cooldowns.json");
 function cooldownKey(target, backend) {
   const model = (target.model ?? backend.defaultModel?.() ?? "").split("#")[0];
   return `${target.backend}:${model}`;
@@ -3198,16 +3324,16 @@ function cooldownMs(message, now = Date.now()) {
 }
 function read() {
   try {
-    const raw = JSON.parse(fs17.readFileSync(file(), "utf8"));
+    const raw = JSON.parse(fs18.readFileSync(file(), "utf8"));
     return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
   } catch {
     return {};
   }
 }
 function write(all) {
-  fs17.mkdirSync(path15.dirname(file()), { recursive: true });
+  fs18.mkdirSync(path16.dirname(file()), { recursive: true });
   const tmp = `${file()}.${process.pid}.tmp`;
-  fs17.writeFileSync(tmp, `${JSON.stringify(all, null, 2)}
+  fs18.writeFileSync(tmp, `${JSON.stringify(all, null, 2)}
 `);
   renameOver(tmp, file());
 }
@@ -3237,15 +3363,15 @@ function untilText(c, now = Date.now()) {
 }
 
 // src/core/snapshot.ts
-import fs18 from "node:fs";
-import path16 from "node:path";
+import fs19 from "node:fs";
+import path17 from "node:path";
 import crypto5 from "node:crypto";
 var READ_IN = ["auto", "snapshot", "project"];
 var KEEP_MS = 24 * 36e5;
 var PRUNE_AGE_MS = 3 * 24 * 36e5;
 var KEEP_NEWEST = 6;
 var JUST_USED_MS = 10 * 6e4;
-var snapshotsDir = () => path16.join(home(), "snapshots");
+var snapshotsDir = () => path17.join(home(), "snapshots");
 function wantSnapshot(readIn2, root, dir) {
   if (!root || readIn2 === "project") return void 0;
   const secrets = findSecretFiles(dir);
@@ -3254,8 +3380,8 @@ function wantSnapshot(readIn2, root, dir) {
 function readSnapshot(root, owner) {
   const drop2 = findSecretFilesInTree(root, root);
   const tree = snapshotTree(root, [], drop2);
-  const dest = path16.join(snapshotsDir(), owner ? `${tree}-${owner}` : tree);
-  if (fs18.existsSync(path16.join(dest, ".git"))) {
+  const dest = path17.join(snapshotsDir(), owner ? `${tree}-${owner}` : tree);
+  if (fs19.existsSync(path17.join(dest, ".git"))) {
     touch(dest);
     return { dir: dest, tree, created: false };
   }
@@ -3264,19 +3390,19 @@ function readSnapshot(root, owner) {
   return { dir: dest, tree, created: true };
 }
 function restoreSnapshot(root, dir, tree) {
-  const rel = path16.relative(snapshotsDir(), dir);
-  if (!rel || rel.startsWith("..") || path16.isAbsolute(rel)) throw new Error(`not a snapshot: ${dir}`);
-  if (!fs18.existsSync(path16.join(dir, ".git"))) materialize(root, tree, dir);
+  const rel = path17.relative(snapshotsDir(), dir);
+  if (!rel || rel.startsWith("..") || path17.isAbsolute(rel)) throw new Error(`not a snapshot: ${dir}`);
+  if (!fs19.existsSync(path17.join(dir, ".git"))) materialize(root, tree, dir);
 }
 function materialize(root, tree, dest) {
-  const tmp = path16.join(snapshotsDir(), `.tmp-${process.pid}-${crypto5.randomBytes(3).toString("hex")}`);
+  const tmp = path17.join(snapshotsDir(), `.tmp-${process.pid}-${crypto5.randomBytes(3).toString("hex")}`);
   try {
     createIsolatedCopy(root, tree, tmp);
     readOnly(tmp);
     try {
-      fs18.renameSync(tmp, dest);
+      fs19.renameSync(tmp, dest);
     } catch (e) {
-      if (!fs18.existsSync(path16.join(dest, ".git"))) throw e;
+      if (!fs19.existsSync(path17.join(dest, ".git"))) throw e;
       removeIsolatedCopy(tmp, snapshotsDir());
     }
   } catch (e) {
@@ -3290,17 +3416,17 @@ function materialize(root, tree, dest) {
 function touch(dir) {
   try {
     const now = /* @__PURE__ */ new Date();
-    fs18.utimesSync(dir, now, now);
+    fs19.utimesSync(dir, now, now);
   } catch {
   }
 }
 function readOnly(dir) {
   const walk = (d) => {
-    for (const e of fs18.readdirSync(d, { withFileTypes: true })) {
+    for (const e of fs19.readdirSync(d, { withFileTypes: true })) {
       if (e.name === ".git") continue;
-      const p = path16.join(d, e.name);
+      const p = path17.join(d, e.name);
       if (e.isDirectory()) walk(p);
-      else if (e.isFile()) fs18.chmodSync(p, fs18.statSync(p).mode & ~146);
+      else if (e.isFile()) fs19.chmodSync(p, fs19.statSync(p).mode & ~146);
     }
   };
   try {
@@ -3311,7 +3437,7 @@ function readOnly(dir) {
 function prune(now = Date.now(), maxAgeMs = PRUNE_AGE_MS, keepNewest = KEEP_NEWEST) {
   let names;
   try {
-    names = fs18.readdirSync(snapshotsDir());
+    names = fs19.readdirSync(snapshotsDir());
   } catch {
     return 0;
   }
@@ -3319,14 +3445,14 @@ function prune(now = Date.now(), maxAgeMs = PRUNE_AGE_MS, keepNewest = KEEP_NEWE
   for (const id2 of listRunIds()) {
     try {
       const m = readMeta(id2);
-      if (m.snapshot?.dir && isActive(m.state)) inUse.add(path16.resolve(m.snapshot.dir));
+      if (m.snapshot?.dir && isActive(m.state)) inUse.add(path17.resolve(m.snapshot.dir));
     } catch {
     }
   }
   const entries = names.map((n) => {
-    const dir = path16.join(snapshotsDir(), n);
+    const dir = path17.join(snapshotsDir(), n);
     try {
-      return { n, dir, age: now - fs18.statSync(dir).mtimeMs };
+      return { n, dir, age: now - fs19.statSync(dir).mtimeMs };
     } catch {
       return void 0;
     }
@@ -3334,7 +3460,7 @@ function prune(now = Date.now(), maxAgeMs = PRUNE_AGE_MS, keepNewest = KEEP_NEWE
   let removed = 0;
   const rank = { shared: 0, own: 0 };
   for (const e of entries) {
-    if (inUse.has(path16.resolve(e.dir))) continue;
+    if (inUse.has(path17.resolve(e.dir))) continue;
     const half = e.n.startsWith(".tmp-");
     const old = e.age >= (half ? KEEP_MS : maxAgeMs);
     const surplus = !half && ++rank[e.n.includes("-") ? "own" : "shared"] > keepNewest && e.age >= JUST_USED_MS;
@@ -3350,10 +3476,10 @@ function prune(now = Date.now(), maxAgeMs = PRUNE_AGE_MS, keepNewest = KEEP_NEWE
 }
 function makeWritable(dir) {
   const walk = (d) => {
-    for (const e of fs18.readdirSync(d, { withFileTypes: true })) {
-      const p = path16.join(d, e.name);
+    for (const e of fs19.readdirSync(d, { withFileTypes: true })) {
+      const p = path17.join(d, e.name);
       if (e.isDirectory()) walk(p);
-      else if (e.isFile()) fs18.chmodSync(p, fs18.statSync(p).mode | 128);
+      else if (e.isFile()) fs19.chmodSync(p, fs19.statSync(p).mode | 128);
     }
   };
   try {
@@ -3364,17 +3490,17 @@ function makeWritable(dir) {
 function backToProject(text, snapshotDir, root) {
   let real = snapshotDir;
   try {
-    real = fs18.realpathSync(snapshotDir);
+    real = fs19.realpathSync(snapshotDir);
   } catch {
   }
   let out = text;
-  for (const dir of /* @__PURE__ */ new Set([real, snapshotDir])) out = out.split(`${dir}${path16.sep}`).join(`${root}${path16.sep}`).split(dir).join(root);
+  for (const dir of /* @__PURE__ */ new Set([real, snapshotDir])) out = out.split(`${dir}${path17.sep}`).join(`${root}${path17.sep}`).split(dir).join(root);
   return out;
 }
 
 // src/core/audit.ts
 import crypto6 from "node:crypto";
-import path17 from "node:path";
+import path18 from "node:path";
 var ANSWER_MAX = 8e3;
 function auditRate(meta) {
   return meta.auditRate ?? effective().audit.value;
@@ -3414,12 +3540,12 @@ function auditors(meta) {
   const tiers = eff.tiers.value;
   const def = parseTarget(eff.worker.value, DEFAULT_BACKEND).backend;
   const ran = meta.ran ?? meta.worker;
-  const bare = (t) => ({ backend: t.backend, model: t.model?.split("#")[0] || void 0 });
+  const bare2 = (t) => ({ backend: t.backend, model: t.model?.split("#")[0] || void 0 });
   const candidates = [tiers.audit, tiers.cheap, ...eff.fallback.value, eff.worker.value].filter((s) => !!s);
   const out = [];
   for (const c of candidates) {
-    const t = bare(parseTarget(c, def));
-    if (sameTarget(t, bare(ran)) || out.some((o) => sameTarget(bare(parseTarget(o, def)), t))) continue;
+    const t = bare2(parseTarget(c, def));
+    if (sameTarget(t, bare2(ran)) || out.some((o) => sameTarget(bare2(parseTarget(o, def)), t))) continue;
     out.push(c);
   }
   return out;
@@ -3428,9 +3554,9 @@ function relativeToAuditor(answer, meta) {
   let out = answer;
   const roots = [...new Set([meta.dir, meta.repoRoot].filter((r) => !!r))].sort((a, b) => b.length - a.length);
   for (const root of roots) {
-    const rel = path17.relative(meta.dir, root);
-    const prefix = rel ? `${rel.split(path17.sep).join("/")}/` : "";
-    out = out.split(`${root}${path17.sep}`).join(prefix).replace(new RegExp(`${root.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\w.-])`, "g"), rel || ".");
+    const rel = path18.relative(meta.dir, root);
+    const prefix = rel ? `${rel.split(path18.sep).join("/")}/` : "";
+    out = out.split(`${root}${path18.sep}`).join(prefix).replace(new RegExp(`${root.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\w.-])`, "g"), rel || ".");
   }
   return out;
 }
@@ -3500,19 +3626,19 @@ function auditBadge(meta) {
 }
 
 // src/core/history.ts
-import fs22 from "node:fs";
+import fs23 from "node:fs";
 import { createRequire } from "node:module";
-import path20 from "node:path";
+import path21 from "node:path";
 import zlib from "node:zlib";
 
 // src/core/receipt.ts
-import fs20 from "node:fs";
-import path19 from "node:path";
+import fs21 from "node:fs";
+import path20 from "node:path";
 
 // src/core/prices.ts
 import { spawn as spawn2 } from "node:child_process";
-import fs19 from "node:fs";
-import path18 from "node:path";
+import fs20 from "node:fs";
+import path19 from "node:path";
 var DEFAULT_URL = "https://models.dev/api.json";
 var RETRY_AFTER_FAILURE_MS = 60 * 6e4;
 var MIN_MODELS = 100;
@@ -3525,8 +3651,8 @@ function catalogLabel() {
     return url;
   }
 }
-var catalogFile = () => path18.join(home(), "prices.json");
-var attemptFile = () => path18.join(home(), "prices.attempt");
+var catalogFile = () => path19.join(home(), "prices.json");
+var attemptFile = () => path19.join(home(), "prices.attempt");
 function trim(raw) {
   const out = {};
   if (!raw || typeof raw !== "object") return out;
@@ -3544,9 +3670,9 @@ var cached2;
 function readCatalog() {
   const file2 = catalogFile();
   try {
-    const { mtimeMs } = fs19.statSync(file2);
+    const { mtimeMs } = fs20.statSync(file2);
     if (cached2?.file === file2 && cached2.mtimeMs === mtimeMs) return cached2.catalog;
-    const parsed = JSON.parse(fs19.readFileSync(file2, "utf8"));
+    const parsed = JSON.parse(fs20.readFileSync(file2, "utf8"));
     const catalog6 = parsed && typeof parsed.models === "object" && parsed.models && Number.isFinite(Date.parse(parsed.fetchedAt)) ? parsed : void 0;
     cached2 = { file: file2, mtimeMs, catalog: catalog6 };
     return catalog6;
@@ -3556,7 +3682,7 @@ function readCatalog() {
 }
 var ageMs = (file2) => {
   try {
-    return Date.now() - fs19.statSync(file2).mtimeMs;
+    return Date.now() - fs20.statSync(file2).mtimeMs;
   } catch {
     return Infinity;
   }
@@ -3575,17 +3701,17 @@ async function refreshCatalog() {
     const models = trim(await r.json());
     const n = Object.keys(models).length;
     if (n < MIN_MODELS) throw new Error(`only ${n} priced models in it (a catalog has thousands): not used`);
-    fs19.mkdirSync(home(), { recursive: true });
+    fs20.mkdirSync(home(), { recursive: true });
     const tmp = `${catalogFile()}.${process.pid}.tmp`;
     const catalog6 = { fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), source: url, models };
-    fs19.writeFileSync(tmp, JSON.stringify(catalog6));
+    fs20.writeFileSync(tmp, JSON.stringify(catalog6));
     renameOver(tmp, catalogFile());
-    fs19.rmSync(attemptFile(), { force: true });
+    fs20.rmSync(attemptFile(), { force: true });
     return { state: "updated", models: n };
   } catch (e) {
     try {
-      fs19.mkdirSync(home(), { recursive: true });
-      fs19.writeFileSync(attemptFile(), `${(/* @__PURE__ */ new Date()).toISOString()} ${e.message}
+      fs20.mkdirSync(home(), { recursive: true });
+      fs20.writeFileSync(attemptFile(), `${(/* @__PURE__ */ new Date()).toISOString()} ${e.message}
 `);
     } catch {
     }
@@ -3597,8 +3723,8 @@ function refreshInBackground() {
     if (!refreshDue()) return;
     const script = process.argv[1];
     if (!script) return;
-    fs19.mkdirSync(home(), { recursive: true });
-    fs19.writeFileSync(attemptFile(), `${(/* @__PURE__ */ new Date()).toISOString()} refresh started
+    fs20.mkdirSync(home(), { recursive: true });
+    fs20.writeFileSync(attemptFile(), `${(/* @__PURE__ */ new Date()).toISOString()} refresh started
 `);
     const child = spawn2(process.execPath, [script, "prices", "--refresh", "--quiet"], { detached: true, stdio: "ignore", env: process.env });
     child.on("error", () => void 0);
@@ -3628,7 +3754,7 @@ function catalogStatus() {
   const c = readCatalog();
   let lastFailure;
   try {
-    const t = fs19.readFileSync(attemptFile(), "utf8").trim();
+    const t = fs20.readFileSync(attemptFile(), "utf8").trim();
     if (t && !t.endsWith("refresh started")) lastFailure = t;
   } catch {
   }
@@ -3708,8 +3834,8 @@ function record(meta) {
     saved: meta.savedUsd ?? 0,
     price: primaryPrice().name
   };
-  fs20.mkdirSync(path19.dirname(ledgerFile()), { recursive: true });
-  fs20.appendFileSync(ledgerFile(), `${JSON.stringify(entry)}
+  fs21.mkdirSync(path20.dirname(ledgerFile()), { recursive: true });
+  fs21.appendFileSync(ledgerFile(), `${JSON.stringify(entry)}
 `);
   return true;
 }
@@ -3736,9 +3862,9 @@ function* finishedRuns() {
   }
 }
 function readLedger(sinceMs2) {
-  if (!fs20.existsSync(ledgerFile())) return [];
+  if (!fs21.existsSync(ledgerFile())) return [];
   const seen = /* @__PURE__ */ new Set();
-  return fs20.readFileSync(ledgerFile(), "utf8").split("\n").filter(Boolean).flatMap((l) => {
+  return fs21.readFileSync(ledgerFile(), "utf8").split("\n").filter(Boolean).flatMap((l) => {
     try {
       const e = JSON.parse(l);
       if (seen.has(e.id)) return [];
@@ -3816,7 +3942,7 @@ ${tile(0, compact(t.tokens), "Tokens offloaded")}${tile(1, t.ratio ? `${Math.rou
 }
 
 // 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;
@@ -3907,9 +4033,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;
 }
@@ -3920,10 +4046,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((id2) => fs21.existsSync(`${runsDir()}/${id2}`));
+${output}`.match(RUN_ID) ?? [])].filter((id2) => fs22.existsSync(`${runsDir()}/${id2}`));
   const since2 = Date.now() - RECENT_HOURS * 36e5;
   for (const id2 of listRunIds().slice(-RECENT)) {
-    if (ids.includes(id2) || fs21.existsSync(runFile(id2, "card-ended"))) continue;
+    if (ids.includes(id2) || fs22.existsSync(runFile(id2, "card-ended"))) continue;
     try {
       const m = readMeta(id2);
       if (!isActive(m.state) && Date.parse(m.endedAt ?? m.startedAt) > since2) ids.push(id2);
@@ -3945,7 +4071,7 @@ var SCHEMA_VERSION = 1;
 var PATCH_MAX = 1e6;
 var ANSWER_MAX2 = 2e5;
 var cached3;
-var historyFile = () => path20.join(home(), "history.db");
+var historyFile = () => path21.join(home(), "history.db");
 function openDb() {
   const file2 = historyFile();
   if (cached3?.file === file2) return cached3.db;
@@ -3959,7 +4085,7 @@ function openDb() {
     } finally {
       process.emitWarning = emit;
     }
-    fs22.mkdirSync(path20.dirname(file2), { recursive: true });
+    fs23.mkdirSync(path21.dirname(file2), { recursive: true });
     db = new DatabaseSync(file2);
     db.exec("PRAGMA journal_mode=WAL; PRAGMA busy_timeout=5000; PRAGMA synchronous=NORMAL;");
     migrate(db);
@@ -3994,31 +4120,31 @@ function migrate(db) {
 function readRunFile(id2, name) {
   const f = runFile(id2, 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 = path20.dirname(runFile(meta.id, "meta.json"));
+  const dir = path21.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(path20.join(dir, n));
+    if (/^events(\.attempt-\d+)?\.jsonl$/.test(n)) gzipFile(path21.join(dir, n));
     else if (/^stderr(\.attempt-\d+)?\.log$/.test(n)) {
-      if (meta.state === "done" && !/attempt/.test(n)) fs22.rmSync(path20.join(dir, n), { force: true });
-      else gzipFile(path20.join(dir, n));
+      if (meta.state === "done" && !/attempt/.test(n)) fs23.rmSync(path21.join(dir, n), { force: true });
+      else gzipFile(path21.join(dir, n));
     }
   }
 }
@@ -4338,7 +4464,7 @@ function historyStats(sinceMs2) {
 }
 
 // src/core/budget.ts
-import fs23 from "node:fs";
+import fs24 from "node:fs";
 var startOfDay = (now = /* @__PURE__ */ new Date()) => new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
 function activeSpend(sinceMs2) {
   let total = 0;
@@ -4348,8 +4474,8 @@ function activeSpend(sinceMs2) {
       if (!isActive(m.state) || Date.parse(m.startedAt) < sinceMs2) continue;
       const target = m.ran ?? m.worker;
       const events = runFile(id2, "events.jsonl");
-      if (!fs23.existsSync(events)) continue;
-      const run2 = getBackend(target.backend).parse(fs23.readFileSync(events, "utf8"));
+      if (!fs24.existsSync(events)) continue;
+      const run2 = getBackend(target.backend).parse(fs24.readFileSync(events, "utf8"));
       if (run2.usage.cost !== void 0) total += run2.usage.cost;
       else {
         const price = workerPrice(target.backend, run2.model, target.model);
@@ -4418,15 +4544,15 @@ function rankChain(chain, recordOf, work) {
 // src/core/notify.ts
 import { spawn as spawn3 } from "node:child_process";
 import crypto7 from "node:crypto";
-import fs26 from "node:fs";
-import path22 from "node:path";
+import fs27 from "node:fs";
+import path23 from "node:path";
 
 // src/core/report.ts
-import fs25 from "node:fs";
+import fs26 from "node:fs";
 
 // src/core/plan.ts
-import fs24 from "node:fs";
-import path21 from "node:path";
+import fs25 from "node:fs";
+import path22 from "node:path";
 var FENCE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
 var RULE = /^ {0,3}([-*_])(\s*\1){2,}\s*$/;
 function structure(lines) {
@@ -4473,9 +4599,9 @@ function parsePlan(text, file2 = "") {
   return { file: file2, title: titleHeading?.text ?? "", header, constraints, tasks };
 }
 function loadPlan(file2) {
-  const abs = path21.resolve(file2);
-  if (!fs24.existsSync(abs) || !fs24.statSync(abs).isFile()) throw new UserError(`plan not found: ${file2}`);
-  const plan = parsePlan(fs24.readFileSync(abs, "utf8"), fs24.realpathSync(abs));
+  const abs = path22.resolve(file2);
+  if (!fs25.existsSync(abs) || !fs25.statSync(abs).isFile()) throw new UserError(`plan not found: ${file2}`);
+  const plan = parsePlan(fs25.readFileSync(abs, "utf8"), fs25.realpathSync(abs));
   if (!plan.tasks.length) throw new UserError(`${file2} has no "Task N" headings (see pitroom-writing-plans)`);
   return plan;
 }
@@ -4494,7 +4620,7 @@ function brief(plan, task) {
   ].filter(Boolean).join("\n\n")}
 `;
 }
-var planName = (file2) => path21.basename(file2).replace(/\.md$/i, "");
+var planName = (file2) => path22.basename(file2).replace(/\.md$/i, "");
 
 // src/core/style.ts
 var enabled = () => {
@@ -4554,7 +4680,7 @@ function duration(meta) {
 }
 function readSummary(meta) {
   const f = runFile(meta.id, "summary.md");
-  return fs25.existsSync(f) ? fs25.readFileSync(f, "utf8").trim() : archivedRun(meta.id)?.answer ?? "";
+  return fs26.existsSync(f) ? fs26.readFileSync(f, "utf8").trim() : archivedRun(meta.id)?.answer ?? "";
 }
 function formatReport(meta, finalText = readSummary(meta), maxLines = 400) {
   const out = [];
@@ -4640,8 +4766,8 @@ function formatReport(meta, finalText = readSummary(meta), maxLines = 400) {
 }
 function live(meta) {
   const f = runFile(meta.id, "events.jsonl");
-  if (!fs25.existsSync(f)) return { steps: 0, toolCalls: 0 };
-  const p = getBackend((meta.ran ?? meta.worker).backend).parse(fs25.readFileSync(f, "utf8"));
+  if (!fs26.existsSync(f)) return { steps: 0, toolCalls: 0 };
+  const p = getBackend((meta.ran ?? meta.worker).backend).parse(fs26.readFileSync(f, "utf8"));
   return { steps: p.usage.steps, toolCalls: p.usage.toolCalls, last: p.lastActivity };
 }
 function progress(meta) {
@@ -4813,12 +4939,12 @@ function claimGroup(group) {
   try {
     const ids = groupIds(group).sort();
     if (ids.length < 2) return true;
-    const dir = path22.join(home(), "notified");
-    fs26.mkdirSync(dir, { recursive: true });
-    for (const f of fs26.readdirSync(dir)) {
-      if (Date.now() - fs26.statSync(path22.join(dir, f)).mtimeMs > 30 * 864e5) fs26.rmSync(path22.join(dir, f), { force: true });
+    const dir = path23.join(home(), "notified");
+    fs27.mkdirSync(dir, { recursive: true });
+    for (const f of fs27.readdirSync(dir)) {
+      if (Date.now() - fs27.statSync(path23.join(dir, f)).mtimeMs > 30 * 864e5) fs27.rmSync(path23.join(dir, f), { force: true });
     }
-    fs26.writeFileSync(path22.join(dir, crypto7.createHash("sha1").update(ids.join(",")).digest("hex").slice(0, 16)), "", { flag: "wx" });
+    fs27.writeFileSync(path23.join(dir, crypto7.createHash("sha1").update(ids.join(",")).digest("hex").slice(0, 16)), "", { flag: "wx" });
     return true;
   } catch {
     return false;
@@ -4852,30 +4978,30 @@ function notifyEnded(meta) {
 }
 
 // src/core/templates.ts
-import fs28 from "node:fs";
-import path24 from "node:path";
+import fs29 from "node:fs";
+import path25 from "node:path";
 
 // src/core/install.ts
-import fs27 from "node:fs";
+import fs28 from "node:fs";
 import os11 from "node:os";
-import path23 from "node:path";
+import path24 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var LEGACY = ["pitroom", "opencode-worker"];
 function packageRoot() {
-  return path23.resolve(path23.dirname(fileURLToPath3(import.meta.url)), "..");
+  return path24.resolve(path24.dirname(fileURLToPath3(import.meta.url)), "..");
 }
 function skillNames(root = packageRoot()) {
-  const dir = path23.join(root, "skills");
-  if (!fs27.existsSync(dir)) return [];
-  return fs27.readdirSync(dir).filter((d) => fs27.existsSync(path23.join(dir, d, "SKILL.md"))).sort();
+  const dir = path24.join(root, "skills");
+  if (!fs28.existsSync(dir)) return [];
+  return fs28.readdirSync(dir).filter((d) => fs28.existsSync(path24.join(dir, d, "SKILL.md"))).sort();
 }
 function skillTargets() {
   const home3 = os11.homedir();
-  const targets = [path23.join(home3, ".agents", "skills")];
-  if (fs27.existsSync(path23.join(home3, ".claude"))) targets.push(path23.join(home3, ".claude", "skills"));
+  const targets = [path24.join(home3, ".agents", "skills")];
+  if (fs28.existsSync(path24.join(home3, ".claude"))) targets.push(path24.join(home3, ".claude", "skills"));
   return targets;
 }
-var launcherPath = () => path23.join(os11.homedir(), ".local", "bin", process.platform === "win32" ? "pitroom.cmd" : "pitroom");
+var launcherPath = () => path24.join(os11.homedir(), ".local", "bin", process.platform === "win32" ? "pitroom.cmd" : "pitroom");
 var LAUNCHER_MARK = "# pitroom launcher";
 function launcherScript(bundle) {
   if (process.platform === "win32") {
@@ -4905,7 +5031,7 @@ exit 127
 function isOurLauncher(file2, root) {
   if (linksInto(file2, root)) return true;
   try {
-    const s = fs27.readFileSync(file2, "utf8");
+    const s = fs28.readFileSync(file2, "utf8");
     return s.includes(LAUNCHER_MARK) && s.includes(root);
   } catch {
     return false;
@@ -4913,64 +5039,64 @@ function isOurLauncher(file2, root) {
 }
 function isPitroomLauncher(file2) {
   try {
-    return fs27.readFileSync(file2, "utf8").includes(LAUNCHER_MARK);
+    return fs28.readFileSync(file2, "utf8").includes(LAUNCHER_MARK);
   } catch {
     return false;
   }
 }
 function placeLauncher(bundle, root, force) {
   const dest = launcherPath();
-  fs27.mkdirSync(path23.dirname(dest), { recursive: true });
-  const exists = fs27.lstatSync(dest, { throwIfNoEntry: false });
+  fs28.mkdirSync(path24.dirname(dest), { recursive: true });
+  const exists = fs28.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)`;
-    fs27.renameSync(dest, `${dest}.bak-${Date.now()}`);
+    fs28.renameSync(dest, `${dest}.bak-${Date.now()}`);
   } else if (exists) {
-    fs27.rmSync(dest, { force: true });
+    fs28.rmSync(dest, { force: true });
   }
-  fs27.writeFileSync(dest, launcherScript(bundle), { mode: 493 });
+  fs28.writeFileSync(dest, launcherScript(bundle), { mode: 493 });
   return `\u2714 ${dest} \u2192 launcher for ${bundle} (Node 22.13+)`;
 }
 function linksInto(link, dir) {
-  const st = fs27.lstatSync(link, { throwIfNoEntry: false });
+  const st = fs28.lstatSync(link, { throwIfNoEntry: false });
   if (!st?.isSymbolicLink()) return false;
-  const target = path23.resolve(path23.dirname(link), fs27.readlinkSync(link));
-  const rel = path23.relative(dir, target);
-  return !rel.startsWith("..") && !path23.isAbsolute(rel);
+  const target = path24.resolve(path24.dirname(link), fs28.readlinkSync(link));
+  const rel = path24.relative(dir, target);
+  return !rel.startsWith("..") && !path24.isAbsolute(rel);
 }
 function place(src, dest, opts) {
-  fs27.mkdirSync(path23.dirname(dest), { recursive: true });
-  const st = fs27.lstatSync(dest, { throwIfNoEntry: false });
+  fs28.mkdirSync(path24.dirname(dest), { recursive: true });
+  const st = fs28.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)`;
-    fs27.renameSync(dest, `${dest}.bak-${Date.now()}`);
+    fs28.renameSync(dest, `${dest}.bak-${Date.now()}`);
   } else if (st) {
-    fs27.unlinkSync(dest);
+    fs28.unlinkSync(dest);
   }
-  if (opts.copy) fs27.cpSync(src, dest, { recursive: true });
-  else fs27.symlinkSync(src, dest, process.platform === "win32" ? "junction" : fs27.statSync(src).isDirectory() ? "dir" : "file");
+  if (opts.copy) fs28.cpSync(src, dest, { recursive: true });
+  else fs28.symlinkSync(src, dest, process.platform === "win32" ? "junction" : fs28.statSync(src).isDirectory() ? "dir" : "file");
   return `\u2714 ${dest} \u2192 ${opts.copy ? "copied" : src}`;
 }
 function install(opts) {
   const root = packageRoot();
   const skills2 = opts.skills === false ? [] : skillNames(root);
-  if (opts.skills !== false && !skills2.length) throw new Error(`no skills found under ${path23.join(root, "skills")}`);
+  if (opts.skills !== false && !skills2.length) throw new Error(`no skills found under ${path24.join(root, "skills")}`);
   const out = [];
   for (const base2 of opts.skills === false ? [] : skillTargets()) {
     for (const legacy of LEGACY) {
-      const l = path23.join(base2, legacy);
+      const l = path24.join(base2, legacy);
       if (!skills2.includes(legacy) && linksInto(l, root)) {
-        fs27.unlinkSync(l);
+        fs28.unlinkSync(l);
         out.push(`\u2714 removed old link ${l}`);
       }
     }
-    for (const name of skills2) out.push(place(path23.join(root, "skills", name), path23.join(base2, name), opts));
+    for (const name of skills2) out.push(place(path24.join(root, "skills", name), path24.join(base2, name), opts));
   }
-  const bundle = path23.join(root, "dist", "pitroom.mjs");
-  if (fs27.existsSync(bundle)) {
+  const bundle = path24.join(root, "dist", "pitroom.mjs");
+  if (fs28.existsSync(bundle)) {
     out.push(placeLauncher(bundle, root, opts.force));
-    const onPath = (process.env.PATH ?? "").split(path23.delimiter).some((d) => path23.resolve(d) === path23.dirname(launcherPath()));
-    if (!onPath) out.push(`! ${path23.dirname(launcherPath())} is not on PATH; add it, or run ${launcherPath()} directly`);
+    const onPath = (process.env.PATH ?? "").split(path24.delimiter).some((d) => path24.resolve(d) === path24.dirname(launcherPath()));
+    if (!onPath) out.push(`! ${path24.dirname(launcherPath())} is not on PATH; add it, or run ${launcherPath()} directly`);
   }
   return out;
 }
@@ -4978,24 +5104,24 @@ function uninstall() {
   const root = packageRoot();
   const out = [];
   for (const base2 of skillTargets()) {
-    if (!fs27.existsSync(base2)) continue;
-    for (const name of fs27.readdirSync(base2)) {
-      const l = path23.join(base2, name);
+    if (!fs28.existsSync(base2)) continue;
+    for (const name of fs28.readdirSync(base2)) {
+      const l = path24.join(base2, name);
       if (linksInto(l, root)) {
-        fs27.unlinkSync(l);
+        fs28.unlinkSync(l);
         out.push(`\u2714 removed ${l}`);
       }
     }
   }
   if (isOurLauncher(launcherPath(), root)) {
-    fs27.rmSync(launcherPath(), { force: true });
+    fs28.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) => fs27.existsSync(path23.join(base2, n, "SKILL.md"))) }));
+  return skillTargets().map((base2) => ({ base: base2, names: names.filter((n) => fs28.existsSync(path24.join(base2, n, "SKILL.md"))) }));
 }
 
 // src/core/templates.ts
@@ -5006,9 +5132,9 @@ var FILES = {
   "code-reviewer": "pitroom-review/code-reviewer.md"
 };
 function loadTemplate(name, root = packageRoot()) {
-  const file2 = path24.join(root, "skills", FILES[name]);
-  if (!fs28.existsSync(file2)) throw new UserError(`template missing: ${file2} (broken install? run pitroom doctor)`, 3);
-  return fs28.readFileSync(file2, "utf8").replace(/^\s*<!--[\s\S]*?-->\s*/, "");
+  const file2 = path25.join(root, "skills", FILES[name]);
+  if (!fs29.existsSync(file2)) throw new UserError(`template missing: ${file2} (broken install? run pitroom doctor)`, 3);
+  return fs29.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));
@@ -5018,10 +5144,10 @@ function fill(template, values) {
 
 // src/core/slots.ts
 import crypto8 from "node:crypto";
-import fs29 from "node:fs";
-import path25 from "node:path";
-var slotsDir = () => path25.join(home(), "slots");
-var locksDir = () => path25.join(home(), "locks");
+import fs30 from "node:fs";
+import path26 from "node:path";
+var slotsDir = () => path26.join(home(), "slots");
+var locksDir = () => path26.join(home(), "locks");
 var STARTUP_GRACE_MS = 3e4;
 function holderActive(runId, self) {
   if (!runId || runId === self) return false;
@@ -5035,23 +5161,23 @@ function holderActive(runId, self) {
   }
 }
 function tryClaim(file2, runId) {
-  fs29.mkdirSync(path25.dirname(file2), { recursive: true });
+  fs30.mkdirSync(path26.dirname(file2), { recursive: true });
   try {
-    fs29.writeFileSync(file2, runId, { flag: "wx" });
+    fs30.writeFileSync(file2, runId, { flag: "wx" });
     return true;
   } catch (e) {
     if (e.code !== "EEXIST") throw e;
   }
   let owner = "";
   try {
-    owner = fs29.readFileSync(file2, "utf8").trim();
+    owner = fs30.readFileSync(file2, "utf8").trim();
   } catch {
   }
   if (owner === runId) return true;
   if (holderActive(owner, runId)) return false;
-  fs29.rmSync(file2, { force: true });
+  fs30.rmSync(file2, { force: true });
   try {
-    fs29.writeFileSync(file2, runId, { flag: "wx" });
+    fs30.writeFileSync(file2, runId, { flag: "wx" });
     return true;
   } catch {
     return false;
@@ -5060,25 +5186,25 @@ function tryClaim(file2, runId) {
 function releaseIfOwner(file2, runId) {
   if (!file2) return;
   try {
-    if (fs29.readFileSync(file2, "utf8").trim() === runId) fs29.rmSync(file2, { force: true });
+    if (fs30.readFileSync(file2, "utf8").trim() === runId) fs30.rmSync(file2, { force: true });
   } catch {
   }
 }
 function tryAcquireSlot(runId, maxParallel) {
   for (let n = 0; n < Math.max(1, maxParallel); n++) {
-    const file2 = path25.join(slotsDir(), `slot-${n}`);
+    const file2 = path26.join(slotsDir(), `slot-${n}`);
     if (tryClaim(file2, runId)) return file2;
   }
   return void 0;
 }
 var releaseSlot = (file2, runId) => releaseIfOwner(file2, runId);
-var lockFile = (repoRoot2) => path25.join(locksDir(), `write-${crypto8.createHash("sha1").update(path25.resolve(repoRoot2)).digest("hex").slice(0, 16)}`);
+var lockFile = (repoRoot2) => path26.join(locksDir(), `write-${crypto8.createHash("sha1").update(path26.resolve(repoRoot2)).digest("hex").slice(0, 16)}`);
 function acquireWriteLock(repoRoot2, runId) {
   const file2 = lockFile(repoRoot2);
   if (tryClaim(file2, runId)) return;
   let owner = "";
   try {
-    owner = fs29.readFileSync(file2, "utf8").trim();
+    owner = fs30.readFileSync(file2, "utf8").trim();
   } catch {
   }
   throw new UserError(`another --write run (${owner}) is active in this repo; use --isolate for parallel changes`, 3);
@@ -5128,13 +5254,14 @@ ${task}`;
 }
 
 // src/core/refs.ts
-import fs30 from "node:fs";
-import path26 from "node:path";
+import fs31 from "node:fs";
+import path27 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(" ")
 );
 var SKIP_DIRS2 = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "out", ".next", ".nuxt", "target", "vendor", ".venv", "venv", "__pycache__", "coverage", ".turbo", ".cache"]);
 var MAX_INDEXED = 6e4;
+var MAX_SKIPPED = 3e5;
 var EXTENSIONLESS = "Makefile|Dockerfile|Containerfile|Gemfile|Rakefile|Procfile|Justfile|Vagrantfile|BUILD|WORKSPACE";
 var REF = new RegExp(
   String.raw`(?<![\w/:.-])(\.{0,2}/?(?:[\w@.+-]+/)*(?:[\w@+-][\w@.+-]*\.[A-Za-z][A-Za-z0-9]{0,7}|${EXTENSIONLESS})):(\d+)(?:[-–](\d+))?`,
@@ -5180,26 +5307,30 @@ function extractRefs(answer) {
   return [...seen.values()];
 }
 function verifyRefs(refs, dirs) {
-  const roots = [...new Set(dirs.filter(Boolean).map((d) => path26.resolve(d)))];
+  const roots = [...new Set(dirs.filter(Boolean).map((d) => path27.resolve(d)))];
   const invalid = [];
   const lineCache = /* @__PURE__ */ new Map();
   const load = (file2) => {
     if (!lineCache.has(file2)) {
-      const size = fs30.statSync(file2).size;
-      const lines = size > MAX_BYTES ? null : fs30.readFileSync(file2, "utf8").split("\n");
+      const size = fs31.statSync(file2).size;
+      const lines = size > MAX_BYTES ? null : fs31.readFileSync(file2, "utf8").split("\n");
       if (lines && lines[lines.length - 1] === "") lines.pop();
       lineCache.set(file2, lines);
     }
     return lineCache.get(file2);
   };
   let index;
+  let skipped;
   const byName = () => index ??= indexFiles(roots);
+  const inSkipped = () => skipped ??= indexFiles(roots, true);
   const candidates = (ref) => {
     const direct = resolve(ref.file, roots);
     if (direct) return [direct];
-    if (path26.isAbsolute(ref.file)) return [];
+    if (path27.isAbsolute(ref.file)) return [];
     const wanted = ref.file.replace(/^(\.{1,2}\/)+/, "");
-    return (byName().get(path26.basename(wanted)) ?? []).filter((f) => f.split(path26.sep).join("/").endsWith(`/${wanted}`) || path26.basename(f) === wanted).slice(0, 20);
+    const fits = (f) => path27.basename(f) === wanted || foldersInOrder(f.split(path27.sep).join("/"), wanted);
+    const own = (byName().get(path27.basename(wanted)) ?? []).filter(fits);
+    return (own.length || !isFileName(wanted) ? own : (inSkipped().get(path27.basename(wanted)) ?? []).filter(fits)).slice(0, 20);
   };
   const check = (file2, ref) => {
     const lines = load(file2);
@@ -5214,7 +5345,7 @@ function verifyRefs(refs, dirs) {
     if (!files.length) {
       if (!ref.file.includes("/") && !isFileName(ref.file)) continue;
       total++;
-      invalid.push({ ref: ref.text, reason: path26.isAbsolute(ref.file) && !inside2(ref.file, roots) ? "outside the project" : "file not found" });
+      invalid.push({ ref: ref.text, reason: path27.isAbsolute(ref.file) && !inside2(ref.file, roots) ? "outside the project" : "file not found" });
       continue;
     }
     total++;
@@ -5235,39 +5366,54 @@ function enclosedBy(lines, ref) {
   return lines.slice(Math.max(0, ref.start - 1 - DEFINITION_LOOKBACK), ref.start).some((l) => def.test(l));
 }
 var isFileName = (name) => {
-  const base2 = path26.basename(name);
+  const base2 = path27.basename(name);
   return !base2.includes(".") || new RegExp(`^(${EXTENSIONLESS})$`).test(base2) || FILE_EXTENSIONS.has(base2.split(".").pop().toLowerCase());
 };
-function indexFiles(roots) {
+function foldersInOrder(file2, wanted) {
+  const want = wanted.split("/");
+  const have = file2.split("/");
+  if (have.at(-1) !== want.at(-1)) return false;
+  let i = have.length - 2;
+  for (let j = want.length - 2; j >= 0; j--) {
+    while (i >= 0 && have[i] !== want[j]) i--;
+    if (i < 0) return false;
+    i--;
+  }
+  return true;
+}
+function indexFiles(roots, skipped = false) {
   const index = /* @__PURE__ */ new Map();
+  const cap = skipped ? MAX_SKIPPED : MAX_INDEXED;
   let count = 0;
-  const walk = (dir) => {
+  const walk = (dir, within) => {
     let entries;
     try {
-      entries = fs30.readdirSync(dir, { withFileTypes: true });
+      entries = fs31.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
-      if (count >= MAX_INDEXED) return;
+      if (count >= cap) return;
       if (e.isDirectory()) {
-        if (!SKIP_DIRS2.has(e.name)) walk(path26.join(dir, e.name));
-      } else if (e.isFile()) {
+        if (e.name === ".git") continue;
+        const skip = SKIP_DIRS2.has(e.name);
+        if (skipped || !skip) walk(path27.join(dir, e.name), within || skip);
+      } else if (e.isFile() && within === skipped) {
         count++;
         const list2 = index.get(e.name);
-        if (list2) list2.push(path26.join(dir, e.name));
-        else index.set(e.name, [path26.join(dir, e.name)]);
+        if (list2) list2.push(path27.join(dir, e.name));
+        else index.set(e.name, [path27.join(dir, e.name)]);
       }
     }
   };
-  for (const r of roots) walk(r);
+  for (const r of roots) walk(r, false);
   return index;
 }
 function resolve(ref, roots) {
-  const candidates = path26.isAbsolute(ref) ? inside2(ref, roots) ? [ref] : [] : roots.map((r) => path26.join(r, ref));
+  const candidates = path27.isAbsolute(ref) ? inside2(ref, roots) ? [ref] : [] : roots.map((r) => path27.join(r, ref));
   return candidates.find((c) => {
     try {
-      return fs30.statSync(c).isFile() && inside2(c, roots);
+      return fs31.statSync(c).isFile() && inside2(c, roots);
     } catch {
       return false;
     }
@@ -5275,14 +5421,14 @@ function resolve(ref, roots) {
 }
 function inside2(file2, roots) {
   return roots.some((r) => {
-    const rel = path26.relative(r, path26.resolve(file2));
-    return rel !== "" && !rel.startsWith("..") && !path26.isAbsolute(rel);
+    const rel = path27.relative(r, path27.resolve(file2));
+    return rel !== "" && !rel.startsWith("..") && !path27.isAbsolute(rel);
   });
 }
 var escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 
 // src/core/run.ts
-var VERSION2 = true ? "0.26.0" : "0.0.0-dev";
+var VERSION2 = true ? "0.27.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");
@@ -5314,7 +5460,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 || !fs31.existsSync(parent.worktree))) {
+    if (parent.mode === "isolate" && (!parent.worktree || !fs32.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;
@@ -5344,22 +5490,22 @@ 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 = canonical(path27.resolve(parent?.dir ?? o.dir));
-  if (!fs31.existsSync(dir) || !fs31.statSync(dir).isDirectory()) throw new UserError(`not a directory: ${dir}`);
+  const dir = canonical(path28.resolve(parent?.dir ?? o.dir));
+  if (!fs32.existsSync(dir) || !fs32.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) => path27.resolve(f));
-  for (const f of files) if (!fs31.existsSync(f)) throw new UserError(`file not found: ${f}`);
+  const files = o.files.map((f) => path28.resolve(f));
+  for (const f of files) if (!fs32.existsSync(f)) throw new UserError(`file not found: ${f}`);
   const readIn2 = READ_IN.includes(effective().readIn.value) ? effective().readIn.value : "auto";
   const untrusted = [worker, ...fallback].map((t) => getBackend(t.backend)).find(readsOwnSnapshot);
   const snap = mode === "read" && !o.review && !o.inPlace && !parent ? wantSnapshot(readIn2, root, dir) : void 0;
   if (untrusted && mode === "read" && !parent && (o.review || o.inPlace || !root)) {
     warnings2.push(`this read run is not in a snapshot${root ? "" : " (not a git repository)"}, and ${untrusted.name} does not reliably stay read-only: it could change files here`);
   }
-  if (parent?.snapshot?.dir && !fs31.existsSync(parent.snapshot.dir)) {
+  if (parent?.snapshot?.dir && !fs32.existsSync(parent.snapshot.dir)) {
     let restored = false;
     if (parent.snapshot.private && root && parent.snapshot.tree) {
       try {
@@ -5416,13 +5562,13 @@ function prepareRun(o) {
     try {
       acquireWriteLock(root, meta.id);
     } catch (e) {
-      fs31.rmSync(runDir(meta.id), { recursive: true, force: true });
+      fs32.rmSync(runDir(meta.id), { recursive: true, force: true });
       throw e;
     }
   }
-  fs31.writeFileSync(runFile(meta.id, "task.md"), `${meta.task}
+  fs32.writeFileSync(runFile(meta.id, "task.md"), `${meta.task}
 `);
-  if (work.brief) fs31.writeFileSync(runFile(meta.id, "brief.md"), work.brief);
+  if (work.brief) fs32.writeFileSync(runFile(meta.id, "brief.md"), work.brief);
   return meta;
 }
 var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -5523,7 +5669,7 @@ async function execute(meta) {
       (meta.attempts ??= []).push({ target: describeTarget(target), error: why.message, ...why.partial ? { partial: true } : {} });
       for (const f of ["events.jsonl", "stderr.log"]) {
         const from = runFile(meta.id, f);
-        if (fs31.existsSync(from)) fs31.renameSync(from, runFile(meta.id, f.replace(".", `.attempt-${i + 1}.`)));
+        if (fs32.existsSync(from)) fs32.renameSync(from, runFile(meta.id, f.replace(".", `.attempt-${i + 1}.`)));
       }
       writeMeta(meta);
     }
@@ -5620,9 +5766,9 @@ function prepareTree(meta) {
   if (root && meta.mode === "write") meta.baseTree = snapshotTree(root);
   if (root && meta.mode === "isolate" && !meta.worktree) {
     meta.baseTree = snapshotTree(root);
-    meta.worktree = path27.join(worktreesDir(), meta.id);
+    meta.worktree = path28.join(worktreesDir(), meta.id);
     createIsolatedCopy(root, meta.baseTree, meta.worktree);
-    meta.cwd = path27.join(meta.worktree, path27.relative(root, meta.dir));
+    meta.cwd = path28.join(meta.worktree, path28.relative(root, meta.dir));
     const linked = linkIntoWorktree(root, meta.worktree, meta.link);
     if (linked.length) meta.warnings.push(`linked into the isolated copy (shared with your tree): ${linked.join(", ")}`);
   }
@@ -5653,8 +5799,8 @@ function ownSnapshot(meta, root, backend, planned, attemptNo) {
   try {
     const s = readSnapshot(root, planned.own ? `${meta.id}-${attemptNo}` : meta.id);
     meta.snapshot = { dir: s.dir, tree: s.tree, left, private: true };
-    meta.cwd = path27.join(s.dir, path27.relative(root, meta.dir));
-    if (!fs31.existsSync(meta.cwd)) meta.cwd = s.dir;
+    meta.cwd = path28.join(s.dir, path28.relative(root, meta.dir));
+    if (!fs32.existsSync(meta.cwd)) meta.cwd = s.dir;
     planned.own = { snapshot: { ...meta.snapshot }, cwd: meta.cwd };
     const note = `${backend.name} reads a snapshot of your project of its own (it does not reliably stay read-only)`;
     if (!meta.warnings.some((w) => w.startsWith(note))) {
@@ -5686,8 +5832,8 @@ function sharedSnapshot(meta, root) {
     const s = readSnapshot(root);
     snapshot.dir = s.dir;
     snapshot.tree = s.tree;
-    meta.cwd = path27.join(s.dir, path27.relative(root, meta.dir));
-    if (!fs31.existsSync(meta.cwd)) meta.cwd = s.dir;
+    meta.cwd = path28.join(s.dir, path28.relative(root, meta.dir));
+    if (!fs32.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;
@@ -5715,7 +5861,7 @@ ${meta.handoff}` : meta.task, !!meta.parent, !!meta.auditOf),
     timeoutSec: meta.timeoutSec
   });
 }
-var read2 = (f) => fs31.existsSync(f) ? fs31.readFileSync(f, "utf8") : "";
+var read2 = (f) => fs32.existsSync(f) ? fs32.readFileSync(f, "utf8") : "";
 function retryableFailure(meta, backend, res) {
   const run2 = backend.parse(read2(runFile(meta.id, "events.jsonl")));
   const f = backend.failure(run2, read2(runFile(meta.id, "stderr.log")), res.code);
@@ -5754,12 +5900,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;
-  fs31.writeFileSync(runFile(meta.id, "summary.md"), `${run2.finalText}
+  fs32.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) fs31.rmSync(meta.packageFile, { force: true });
+    if (meta.packageFile) fs32.rmSync(meta.packageFile, { force: true });
   }
   for (const w of backend.warnings?.(run2, read2(runFile(meta.id, "stderr.log"))) ?? []) {
     if (!meta.warnings.includes(w)) meta.warnings.push(w);
@@ -5824,16 +5970,16 @@ function captureChanges(meta) {
   const d = diffTrees(target, meta.baseTree, meta.afterTree);
   meta.changes = d.changes;
   meta.stats = d.stats;
-  fs31.writeFileSync(runFile(meta.id, "changes.patch"), d.patch);
+  fs32.writeFileSync(runFile(meta.id, "changes.patch"), d.patch);
 }
 function verifyPath() {
-  const extra = [path27.dirname(process.execPath), "/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"];
-  const parts = (process.env.PATH ?? "").split(path27.delimiter).filter(Boolean);
-  for (const d of process.platform === "win32" ? [path27.dirname(process.execPath)] : extra) if (!parts.includes(d)) parts.push(d);
-  return parts.join(path27.delimiter);
+  const extra = [path28.dirname(process.execPath), "/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"];
+  const parts = (process.env.PATH ?? "").split(path28.delimiter).filter(Boolean);
+  for (const d of process.platform === "win32" ? [path28.dirname(process.execPath)] : extra) if (!parts.includes(d)) parts.push(d);
+  return parts.join(path28.delimiter);
 }
 function runVerify(meta) {
-  const r = spawnSync9(meta.verify, {
+  const r = spawnSync10(meta.verify, {
     cwd: meta.cwd,
     shell: true,
     encoding: "utf8",
@@ -5843,7 +5989,7 @@ function runVerify(meta) {
     env: { ...process.env, PATH: verifyPath(), PWD: meta.cwd, PITROOM_ACTIVE: "1" }
   });
   const output = `${r.stdout ?? ""}${r.stderr ?? ""}`;
-  fs31.writeFileSync(runFile(meta.id, "verify.log"), output);
+  fs32.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") };
 }
@@ -5898,12 +6044,12 @@ 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 && fs31.existsSync(meta.worktree)) removeIsolatedCopy(meta.worktree, worktreesDir());
+  if (meta.worktree && fs32.existsSync(meta.worktree)) removeIsolatedCopy(meta.worktree, worktreesDir());
 }
 
 // src/cli/mcp-extras.ts
-import fs32 from "node:fs";
-import path28 from "node:path";
+import fs33 from "node:fs";
+import path29 from "node:path";
 
 // src/cli/mcp-support.ts
 import { spawn as spawn5 } from "node:child_process";
@@ -6188,7 +6334,7 @@ function skillPrompts() {
   const root = packageRoot();
   for (const name of skillNames(root)) {
     try {
-      const text = fs32.readFileSync(path28.join(root, "skills", name, "SKILL.md"), "utf8");
+      const text = fs33.readFileSync(path29.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.`;
@@ -6709,22 +6855,22 @@ async function serveMcp() {
 
 // src/cli/mcp-http.ts
 import crypto10 from "node:crypto";
-import fs34 from "node:fs";
+import fs35 from "node:fs";
 import http2 from "node:http";
-import path30 from "node:path";
+import path31 from "node:path";
 
 // src/core/dash.ts
 import { spawn as spawn6 } from "node:child_process";
 import crypto9 from "node:crypto";
-import fs33 from "node:fs";
+import fs34 from "node:fs";
 import http from "node:http";
-import path29 from "node:path";
+import path30 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // src/core/file-diff.ts
 var PREVIEW_LINES = 300;
 function gitPath(value, prefix = true) {
-  let path38 = value;
+  let path39 = value;
   if (value.startsWith('"') && value.endsWith('"')) {
     const bytes = [];
     const escapes = { t: "	", n: "\n", r: "\r", b: "\b", f: "\f", v: "\v" };
@@ -6732,9 +6878,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]));
     }
-    path38 = new TextDecoder().decode(new Uint8Array(bytes));
+    path39 = new TextDecoder().decode(new Uint8Array(bytes));
   }
-  return prefix ? path38.replace(/^[ab]\//, "") : path38;
+  return prefix ? path39.replace(/^[ab]\//, "") : path39;
 }
 function headerPath(header) {
   const quoted = header.match(/^diff --git ("(?:[^"\\]|\\.)*"|\S+) ("(?:[^"\\]|\\.)*"|\S+)$/);
@@ -7015,11 +7161,11 @@ var assetsDir = () => fileURLToPath4(new URL("./ui/", import.meta.url));
 var assetCache = /* @__PURE__ */ new Map();
 function readAsset(route) {
   try {
-    const file2 = path29.join(assetsDir(), path29.basename(route));
-    const { mtimeMs } = fs33.statSync(file2);
+    const file2 = path30.join(assetsDir(), path30.basename(route));
+    const { mtimeMs } = fs34.statSync(file2);
     const hit = assetCache.get(route);
     if (hit && hit.mtimeMs === mtimeMs) return hit.data;
-    const data = fs33.readFileSync(file2);
+    const data = fs34.readFileSync(file2);
     assetCache.set(route, { mtimeMs, data });
     return data;
   } catch {
@@ -7148,7 +7294,7 @@ function startDash(opts) {
     });
   });
 }
-var registryFile = () => path29.join(home(), "dash.json");
+var registryFile = () => path30.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) });
@@ -7160,12 +7306,12 @@ async function ping(port) {
 async function runningDash() {
   let r;
   try {
-    r = JSON.parse(fs33.readFileSync(registryFile(), "utf8"));
+    r = JSON.parse(fs34.readFileSync(registryFile(), "utf8"));
   } catch {
     return void 0;
   }
   if (!isAlive(r.pid)) {
-    fs33.rmSync(registryFile(), { force: true });
+    fs34.rmSync(registryFile(), { force: true });
     return void 0;
   }
   return await ping(r.port) ? { ...r, url: `http://127.0.0.1:${r.port}/` } : void 0;
@@ -7182,7 +7328,7 @@ async function dashCommand(o) {
   if (o.stop) {
     if (!existing) throw new UserError("pitroom dash is not running");
     process.kill(existing.pid, "SIGTERM");
-    fs33.rmSync(registryFile(), { force: true });
+    fs34.rmSync(registryFile(), { force: true });
     o.log(`stopped pitroom dash (${existing.url})`);
     return 0;
   }
@@ -7220,9 +7366,9 @@ async function dashCommand(o) {
     if (explicit || e.code !== "EADDRINUSE") throw new UserError(`pitroom dash: ${e.message}`);
     dash = await startDash({ port: 0, idleMs: o.idleMs });
   }
-  fs33.mkdirSync(home(), { recursive: true });
+  fs34.mkdirSync(home(), { recursive: true });
   const tmp = `${registryFile()}.${process.pid}.tmp`;
-  fs33.writeFileSync(tmp, JSON.stringify({ pid: process.pid, port: dash.port }));
+  fs34.writeFileSync(tmp, JSON.stringify({ pid: process.pid, port: dash.port }));
   renameOver(tmp, registryFile());
   const stop = () => void dash.close();
   process.once("SIGINT", stop);
@@ -7232,7 +7378,7 @@ async function dashCommand(o) {
   if (o.open) openBrowser(dash.url);
   await dash.closed;
   try {
-    if (JSON.parse(fs33.readFileSync(registryFile(), "utf8")).pid === process.pid) fs33.rmSync(registryFile(), { force: true });
+    if (JSON.parse(fs34.readFileSync(registryFile(), "utf8")).pid === process.pid) fs34.rmSync(registryFile(), { force: true });
   } catch {
   }
   return 0;
@@ -7244,10 +7390,10 @@ var MAX_BODY = 4e6;
 var MAX_SESSIONS = 64;
 var IDLE_MS = 60 * 6e4;
 var PATH = "/mcp";
-var tokenFile = () => path30.join(home(), "mcp-token");
+var tokenFile = () => path31.join(home(), "mcp-token");
 var readToken = (file2) => {
   try {
-    const kept = fs34.readFileSync(file2, "utf8").trim();
+    const kept = fs35.readFileSync(file2, "utf8").trim();
     return kept.length >= 16 ? kept : void 0;
   } catch {
     return void 0;
@@ -7262,10 +7408,10 @@ function mcpToken() {
   const file2 = tokenFile();
   let token = readToken(file2);
   if (!token) {
-    fs34.mkdirSync(path30.dirname(file2), { recursive: true });
+    fs35.mkdirSync(path31.dirname(file2), { recursive: true });
     token = crypto10.randomBytes(32).toString("hex");
     try {
-      fs34.writeFileSync(file2, `${token}
+      fs35.writeFileSync(file2, `${token}
 `, { mode: 384, flag: "wx" });
     } catch (e) {
       if (e.code !== "EEXIST") throw e;
@@ -7274,7 +7420,7 @@ function mcpToken() {
     }
   }
   try {
-    fs34.chmodSync(file2, 384);
+    fs35.chmodSync(file2, 384);
   } catch {
   }
   return { token, from: file2 };
@@ -7455,17 +7601,17 @@ async function serveMcpHttp(opts) {
 }
 
 // src/cli/commands.ts
-import { spawnSync as spawnSync12 } from "node:child_process";
-import fs41 from "node:fs";
-import path36 from "node:path";
+import { spawnSync as spawnSync13 } from "node:child_process";
+import fs42 from "node:fs";
+import path37 from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // src/core/init.ts
-import fs35 from "node:fs";
-import path31 from "node:path";
+import fs36 from "node:fs";
+import path32 from "node:path";
 var FREE = /-free$/;
 var TIER_ORDER = [["cheap", "opencode"], ["standard", "codex"], ["capable", "claude"]];
-var isFound = (binary8) => path31.isAbsolute(binary8) && fs35.existsSync(binary8);
+var isFound = (binary8) => path32.isAbsolute(binary8) && fs36.existsSync(binary8);
 function planInit(opts = {}) {
   const file2 = configPath();
   const workers = backendIds().map((id2) => {
@@ -7511,15 +7657,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: fs35.existsSync(file2), workers, opencode: opencode2, config, blocked, notes };
+  return { path: file2, exists: fs36.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 ${path31.basename(plan.path)}.bak)`);
-  fs35.mkdirSync(path31.dirname(plan.path), { recursive: true });
-  if (plan.exists) fs35.copyFileSync(plan.path, `${plan.path}.bak`);
-  fs35.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 ${path32.basename(plan.path)}.bak)`);
+  fs36.mkdirSync(path32.dirname(plan.path), { recursive: true });
+  if (plan.exists) fs36.copyFileSync(plan.path, `${plan.path}.bak`);
+  fs36.writeFileSync(plan.path, `${JSON.stringify(plan.config, null, 2)}
 `);
   return plan.path;
 }
@@ -7539,18 +7685,18 @@ function formatInit(plan, written) {
 }
 
 // src/core/mcp-install.ts
-import { spawnSync as spawnSync10 } from "node:child_process";
-import fs36 from "node:fs";
+import { spawnSync as spawnSync11 } from "node:child_process";
+import fs37 from "node:fs";
 import os12 from "node:os";
-import path32 from "node:path";
+import path33 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(path32.delimiter).filter(Boolean)) {
-    const p = path32.join(dir, process.platform === "win32" ? "pitroom.cmd" : "pitroom");
-    if (fs36.existsSync(p)) return { command: path32.resolve(p), args: ["mcp"] };
+  for (const dir of (process.env.PATH ?? "").split(path33.delimiter).filter(Boolean)) {
+    const p = path33.join(dir, process.platform === "win32" ? "pitroom.cmd" : "pitroom");
+    if (fs37.existsSync(p)) return { command: path33.resolve(p), args: ["mcp"] };
   }
   return { command: process.execPath, args: [process.argv[1] ?? "pitroom", "mcp"] };
 }
@@ -7560,13 +7706,13 @@ var same = (a, b) => {
 };
 function run(backendId, args) {
   const { command, prefix } = resolveCommand(getBackend(backendId).binary());
-  const r = spawnSync10(command, [...prefix, ...args], { encoding: "utf8", timeout: 6e4, stdio: ["ignore", "pipe", "pipe"] });
+  const r = spawnSync11(command, [...prefix, ...args], { encoding: "utf8", timeout: 6e4, stdio: ["ignore", "pipe", "pipe"] });
   return { ok: r.status === 0 && !r.error, out: `${r.stdout ?? ""}${r.stderr ?? ""}`.trim() };
 }
 var runnable = (backendId) => run(backendId, ["--version"]).ok;
 var readJson = (file2) => {
   try {
-    return JSON.parse(fs36.readFileSync(file2, "utf8"));
+    return JSON.parse(fs37.readFileSync(file2, "utf8"));
   } catch {
     return void 0;
   }
@@ -7576,7 +7722,7 @@ var jsonState = (file2, c) => {
   return entry === void 0 ? "absent" : same(c, entry) ? "same" : "different";
 };
 var home2 = () => os12.homedir();
-var geminiDir = () => path32.join(process.env.GEMINI_CLI_HOME ?? home2(), ".gemini");
+var geminiDir = () => path33.join(process.env.GEMINI_CLI_HOME ?? home2(), ".gemini");
 function cliClient(id2, backend, name, where, o) {
   return {
     id: id2,
@@ -7599,43 +7745,43 @@ function jsonClient(id2, name, file2, dir) {
   return {
     id: id2,
     name,
-    found: () => fs36.existsSync(dir()),
+    found: () => fs37.existsSync(dir()),
     state: (c) => jsonState(file2(), c),
     add: (c) => {
       let config = {};
-      if (fs36.existsSync(file2())) {
+      if (fs37.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 (!fs36.existsSync(backup)) fs36.copyFileSync(file2(), backup);
+        if (!fs37.existsSync(backup)) fs37.copyFileSync(file2(), backup);
       }
       config.mcpServers = { ...config.mcpServers ?? {}, [NAME]: { command: c.command, args: c.args } };
-      fs36.mkdirSync(path32.dirname(file2()), { recursive: true });
+      fs37.mkdirSync(path33.dirname(file2()), { recursive: true });
       const tmp = `${file2()}.${process.pid}.tmp`;
-      fs36.writeFileSync(tmp, `${JSON.stringify(config, null, 2)}
+      fs37.writeFileSync(tmp, `${JSON.stringify(config, null, 2)}
 `);
-      fs36.renameSync(tmp, file2());
+      fs37.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];
-      fs36.writeFileSync(file2(), `${JSON.stringify(config, null, 2)}
+      fs37.writeFileSync(file2(), `${JSON.stringify(config, null, 2)}
 `);
       return { ok: true, message: rel() };
     }
   };
 }
 function desktopFile() {
-  if (process.platform === "darwin") return path32.join(home2(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
-  if (process.platform === "win32") return path32.join(process.env.APPDATA ?? path32.join(home2(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
-  return path32.join(process.env.XDG_CONFIG_HOME ?? path32.join(home2(), ".config"), "Claude", "claude_desktop_config.json");
+  if (process.platform === "darwin") return path33.join(home2(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  if (process.platform === "win32") return path33.join(process.env.APPDATA ?? path33.join(home2(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+  return path33.join(process.env.XDG_CONFIG_HOME ?? path33.join(home2(), ".config"), "Claude", "claude_desktop_config.json");
 }
 function codexState(c) {
   let text;
   try {
-    text = fs36.readFileSync(path32.join(process.env.CODEX_HOME ?? path32.join(home2(), ".codex"), "config.toml"), "utf8");
+    text = fs37.readFileSync(path33.join(process.env.CODEX_HOME ?? path33.join(home2(), ".codex"), "config.toml"), "utf8");
   } catch {
     return "absent";
   }
@@ -7653,7 +7799,7 @@ function codexState(c) {
 function clients() {
   return [
     cliClient("claude-code", "claude", "Claude Code", "user settings (~/.claude.json)", {
-      state: (c) => jsonState(path32.join(home2(), ".claude.json"), c),
+      state: (c) => jsonState(path33.join(home2(), ".claude.json"), c),
       add: (c) => ["mcp", "add", "--scope", "user", NAME, "--", c.command, ...c.args],
       remove: () => ["mcp", "remove", NAME, "--scope", "user"]
     }),
@@ -7663,12 +7809,12 @@ function clients() {
       remove: () => ["mcp", "remove", NAME]
     }),
     cliClient("gemini", "gemini", "Gemini CLI", "user settings (~/.gemini/settings.json)", {
-      state: (c) => jsonState(path32.join(geminiDir(), "settings.json"), c),
+      state: (c) => jsonState(path33.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", () => path32.join(home2(), ".cursor", "mcp.json"), () => path32.join(home2(), ".cursor")),
-    jsonClient("claude-desktop", "Claude Desktop", desktopFile, () => path32.dirname(desktopFile()))
+    jsonClient("cursor", "Cursor", () => path33.join(home2(), ".cursor", "mcp.json"), () => path33.join(home2(), ".cursor")),
+    jsonClient("claude-desktop", "Claude Desktop", desktopFile, () => path33.dirname(desktopFile()))
   ];
 }
 function attempt2(f) {
@@ -7739,16 +7885,16 @@ var parseClients = (value) => {
 
 // src/core/plan-status.ts
 import crypto11 from "node:crypto";
-import fs37 from "node:fs";
-import path33 from "node:path";
+import fs38 from "node:fs";
+import path34 from "node:path";
 function notesFile(plan) {
   const id2 = crypto11.createHash("sha1").update(plan.file).digest("hex").slice(0, 12);
-  return path33.join(home(), "plans", id2, "notes.md");
+  return path34.join(home(), "plans", id2, "notes.md");
 }
 function readNotes(plan) {
   const f = notesFile(plan);
-  if (!fs37.existsSync(f)) return [];
-  return fs37.readFileSync(f, "utf8").split("\n").slice(1).filter(Boolean).map((l) => {
+  if (!fs38.existsSync(f)) return [];
+  return fs38.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 };
   });
@@ -7756,11 +7902,11 @@ function readNotes(plan) {
 function addNote(planFile, text) {
   const plan = loadPlan(planFile);
   const f = notesFile(plan);
-  fs37.mkdirSync(path33.dirname(f), { recursive: true });
-  if (!fs37.existsSync(f)) fs37.writeFileSync(f, `# plan: ${plan.file}
+  fs38.mkdirSync(path34.dirname(f), { recursive: true });
+  if (!fs38.existsSync(f)) fs38.writeFileSync(f, `# plan: ${plan.file}
 `);
   const at = (/* @__PURE__ */ new Date()).toISOString().slice(0, 16).replace("T", " ");
-  fs37.appendFileSync(f, `${at} ${text.replace(/\s+/g, " ").trim()}
+  fs38.appendFileSync(f, `${at} ${text.replace(/\s+/g, " ").trim()}
 `);
   return f;
 }
@@ -7828,8 +7974,8 @@ ${rulings}`,
 
 // src/core/cache.ts
 import crypto12 from "node:crypto";
-import fs38 from "node:fs";
-import path34 from "node:path";
+import fs39 from "node:fs";
+import path35 from "node:path";
 function preferredReadsOwnSnapshot(o) {
   try {
     const preferred = effective().worker.value;
@@ -7842,20 +7988,20 @@ 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(path34.resolve(o.dir));
+  const dir = canonical(path35.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 = path34.resolve(f);
-      return [abs, crypto12.createHash("sha256").update(fs38.readFileSync(abs)).digest("hex")];
+      const abs = path35.resolve(f);
+      return [abs, crypto12.createHash("sha256").update(fs39.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 && (preferredReadsOwnSnapshot(o) || wantSnapshot(readIn2, root, dir)) ? "snapshot" : "project";
-    const key = crypto12.createHash("sha256").update(JSON.stringify([question, path34.relative(root, dir), files, where])).digest("hex");
+    const key = crypto12.createHash("sha256").update(JSON.stringify([question, path35.relative(root, dir), files, where])).digest("hex");
     return { key, state: `${head}:${tree}`, where };
   } catch {
     return void 0;
@@ -7898,13 +8044,13 @@ function ago(iso, now = Date.now()) {
 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/eval.ts
-import { spawnSync as spawnSync11 } from "node:child_process";
-import fs39 from "node:fs";
+import { spawnSync as spawnSync12 } from "node:child_process";
+import fs40 from "node:fs";
 var KINDS = ["definition", "count", "set"];
 function loadEval(file2) {
   let raw;
   try {
-    raw = JSON.parse(fs39.readFileSync(file2, "utf8"));
+    raw = JSON.parse(fs40.readFileSync(file2, "utf8"));
   } catch (e) {
     throw new UserError(`cannot read ${file2}: ${e.message}`);
   }
@@ -7931,7 +8077,7 @@ function loadEval(file2) {
 }
 var clean = (p) => p.replace(/\\/g, "/").replace(/^\.?\//, "");
 function gitGrep(root, flags, t) {
-  const r = spawnSync11("git", ["-C", root, "grep", ...flags, t.regex ? "-E" : "-F", ...t.word ? ["-w"] : [], "-e", t.grep, "--", t.dir ?? "."], {
+  const r = spawnSync12("git", ["-C", root, "grep", ...flags, t.regex ? "-E" : "-F", ...t.word ? ["-w"] : [], "-e", t.grep, "--", t.dir ?? "."], {
     encoding: "utf8",
     maxBuffer: 64 * 1024 * 1024
   });
@@ -8027,13 +8173,16 @@ function formatEval(rows, group) {
 
 // src/core/review.ts
 import crypto13 from "node:crypto";
-import fs40 from "node:fs";
-import path35 from "node:path";
+import fs41 from "node:fs";
+import path36 from "node:path";
 var TEMPLATE2 = { task: "task-reviewer", fix: "re-review", range: "code-reviewer" };
 var section = (title, body) => `## ${title}
 
 ${body.trim() || "(empty)"}
 `;
+var numbered = (diff) => diff.trim() ? `${NUMBERED}
+
+${/^[+ -]\s*\d+\| /m.test(diff) ? diff : numberDiff(diff)}` : diff;
 function ancestors(m) {
   const out = [];
   for (let id2 = m.parent; id2; ) {
@@ -8046,7 +8195,7 @@ function ancestors(m) {
 function briefOf(m) {
   const root = [m, ...ancestors(m)].at(-1);
   const f = runFile(root.id, "brief.md");
-  return fs40.existsSync(f) ? fs40.readFileSync(f, "utf8") : root.task;
+  return fs41.existsSync(f) ? fs41.readFileSync(f, "utf8") : root.task;
 }
 function latestReview(ids) {
   for (const id2 of listRunIds().reverse()) {
@@ -8060,7 +8209,7 @@ function latestReview(ids) {
 }
 function diffOf(m, from = m.baseTree) {
   const where = m.mode === "isolate" ? m.worktree : m.repoRoot;
-  if (where && fs40.existsSync(where) && from && m.afterTree) return reviewDiff(where, from, m.afterTree);
+  if (where && fs41.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);
   }
@@ -8074,7 +8223,7 @@ function runReview(id2) {
   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 && fs40.existsSync(m.worktree) ? m.cwd : m.dir;
+  const dir = m.mode === "isolate" && m.worktree && fs41.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) {
@@ -8082,7 +8231,7 @@ function runReview(id2) {
       ...job,
       kind: "task",
       package: [`# Review package \xB7 ${title}
-`, section("BRIEF", briefOf(m)), section("REPORT", readSummary(m)), section("DIFF", diffOf(m))].join("\n")
+`, section("BRIEF", briefOf(m)), section("REPORT", readSummary(m)), section("DIFF", numbered(diffOf(m)))].join("\n")
     };
   }
   const reviewed = chain.find((a) => a.id === previous.reviewOf);
@@ -8096,7 +8245,7 @@ function runReview(id2) {
       section("BRIEF", briefOf(m)),
       section("PREVIOUS FINDINGS", readSummary(previous)),
       section("FIX REPORT", readSummary(m)),
-      section("FIX DIFF", diffOf(m, from))
+      section("FIX DIFF", numbered(diffOf(m, from)))
     ].join("\n")
   };
 }
@@ -8150,19 +8299,19 @@ function writePackage(job) {
   const root = repoRoot(job.dir);
   if (!g || !root) throw new UserError(`not a git repository: ${job.dir}`);
   const name = `review-${crypto13.randomBytes(4).toString("hex")}.md`;
-  const inside3 = !path35.relative(fs40.realpathSync(root), fs40.realpathSync(g)).startsWith("..");
-  const file2 = inside3 ? path35.join(g, "pitroom", name) : path35.join(root, ".pitroom", name);
+  const inside3 = !path36.relative(fs41.realpathSync(root), fs41.realpathSync(g)).startsWith("..");
+  const file2 = inside3 ? path36.join(g, "pitroom", name) : path36.join(root, ".pitroom", name);
   if (!inside3) ignoreInGit(root, "/.pitroom/");
-  fs40.mkdirSync(path35.dirname(file2), { recursive: true });
-  fs40.writeFileSync(file2, job.package);
+  fs41.mkdirSync(path36.dirname(file2), { recursive: true });
+  fs41.writeFileSync(file2, job.package);
   return file2;
 }
 function ignoreInGit(root, pattern) {
-  const exclude = path35.resolve(root, git(root, ["rev-parse", "--git-path", "info/exclude"]).stdout.trim());
-  const text = fs40.existsSync(exclude) ? fs40.readFileSync(exclude, "utf8") : "";
+  const exclude = path36.resolve(root, git(root, ["rev-parse", "--git-path", "info/exclude"]).stdout.trim());
+  const text = fs41.existsSync(exclude) ? fs41.readFileSync(exclude, "utf8") : "";
   if (text.split(/\r?\n/).includes(pattern)) return;
-  fs40.mkdirSync(path35.dirname(exclude), { recursive: true });
-  fs40.appendFileSync(exclude, `${text && !text.endsWith("\n") ? "\n" : ""}# Pitroom review packages in worktrees (removed after each review)
+  fs41.mkdirSync(path36.dirname(exclude), { recursive: true });
+  fs41.appendFileSync(exclude, `${text && !text.endsWith("\n") ? "\n" : ""}# Pitroom review packages in worktrees (removed after each review)
 ${pattern}
 `);
 }
@@ -8318,10 +8467,10 @@ async function cmdReview(p) {
       writeMeta(meta);
     }
   } catch (e) {
-    fs41.rmSync(packageFile, { force: true });
+    fs42.rmSync(packageFile, { force: true });
     throw e;
   }
-  fs41.writeFileSync(runFile(meta.id, "package.md"), job.package);
+  fs42.writeFileSync(runFile(meta.id, "package.md"), job.package);
   return launch(p, meta);
 }
 async function cmdAudit(p) {
@@ -8436,7 +8585,7 @@ function cmdPlan(p) {
 }
 function cmdCrew(p) {
   const file2 = flag(p, "task-file");
-  const tasks = (file2 ? fs41.readFileSync(file2, "utf8").split(/^\s*---\s*$/m) : p.positional).map((t) => t.trim()).filter(Boolean);
+  const tasks = (file2 ? fs42.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)");
@@ -8463,7 +8612,7 @@ async function cmdEval(p) {
   if (has(p, "write") || has(p, "isolate") || has(p, "continue") || has(p, "plan")) throw new UserError("eval asks read questions: drop -w/-i/--continue/--plan");
   const questions = loadEval(file2);
   const base2 = runOptions(p, "eval");
-  const root = repoRoot(path36.resolve(base2.dir));
+  const root = repoRoot(path37.resolve(base2.dir));
   const truths = new Map(questions.map((q) => [q.id, truthOf(q, root)]));
   const workers = [...new Set(p.flags.get("worker") ?? [effective().worker.value])];
   const group = flag(p, "group") ?? `eval-${(/* @__PURE__ */ new Date()).toISOString().slice(11, 19).replace(/:/g, "")}`;
@@ -8666,13 +8815,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 ? "" : fs41.readFileSync(0, "utf8");
+var readStdin = () => process.stdin.isTTY ? "" : fs42.readFileSync(0, "utf8");
 function cmdStatusline(p) {
   const input = readStdin();
   const lines = [];
   const then = flag(p, "then");
   if (then) {
-    const r = process.platform === "win32" ? spawnSync12(then, { shell: true, input, encoding: "utf8", timeout: 5e3 }) : spawnSync12("/bin/sh", ["-c", then], { input, encoding: "utf8", timeout: 5e3 });
+    const r = process.platform === "win32" ? spawnSync13(then, { shell: true, input, encoding: "utf8", timeout: 5e3 }) : spawnSync13("/bin/sh", ["-c", then], { input, encoding: "utf8", timeout: 5e3 });
     if (r.stdout?.trimEnd()) lines.push(r.stdout.trimEnd());
   }
   try {
@@ -8706,8 +8855,8 @@ function cmdModels(p) {
   return 0;
 }
 function cmdHookStart() {
-  const script = path36.join(path36.dirname(path36.dirname(fileURLToPath5(import.meta.url))), "hooks", "session-start.mjs");
-  if (fs41.existsSync(script)) spawnSync12(process.execPath, [script], { stdio: ["ignore", "inherit", "ignore"], env: process.env });
+  const script = path37.join(path37.dirname(path37.dirname(fileURLToPath5(import.meta.url))), "hooks", "session-start.mjs");
+  if (fs42.existsSync(script)) spawnSync13(process.execPath, [script], { stdio: ["ignore", "inherit", "ignore"], env: process.env });
   return 0;
 }
 function cmdInit(p) {
@@ -8749,8 +8898,8 @@ function cmdSavings(p) {
   est. saved          ${usd(t.saved)}  (vs ${primaryPrice().name} list prices)`);
   const out = flag(p, "card");
   if (out) {
-    fs41.writeFileSync(out, card(t, period));
-    console.log(`card written to ${path36.resolve(out)}`);
+    fs42.writeFileSync(out, card(t, period));
+    console.log(`card written to ${path37.resolve(out)}`);
   }
   if (has(p, "badge")) console.log(`![pitroom](${badgeUrl(t)})`);
   return 0;
@@ -8792,7 +8941,7 @@ function cmdConfig(p) {
     console.log(JSON.stringify({ path: configPath(), settings: eff, warnings: warnings2 }, null, 2));
     return 0;
   }
-  console.log(`config file: ${configPath()}${fs41.existsSync(configPath()) ? "" : " (not present)"}`);
+  console.log(`config file: ${configPath()}${fs42.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})`);
@@ -8816,7 +8965,7 @@ function cmdClean(p) {
     const m = readMeta(id2);
     if (m.mode === "isolate" && !m.discarded && !m.applied) discardRun(m);
     recordRun(m);
-    fs41.rmSync(runDir(id2), { recursive: true, force: true });
+    fs42.rmSync(runDir(id2), { 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`);
@@ -8826,10 +8975,10 @@ var cmdRevert = (p) => (console.log(revertRun(freshMeta(resolveRun(p.positional[
 var cmdDiscard = (p) => (console.log(discardRun(freshMeta(resolveRun(p.positional[0])))), 0);
 
 // src/core/doctor.ts
-import { spawnSync as spawnSync13 } from "node:child_process";
-import fs42 from "node:fs";
+import { spawnSync as spawnSync14 } from "node:child_process";
+import fs43 from "node:fs";
 import os13 from "node:os";
-import path37 from "node:path";
+import path38 from "node:path";
 var MARK2 = { 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)" },
@@ -8852,14 +9001,14 @@ function usageLine() {
   return `${ids.length} run${ids.length === 1 ? "" : "s"} so far${when2} (pitroom savings shows what they saved)`;
 }
 function firstNodeOnPath() {
-  for (const dir of (process.env.PATH ?? "").split(path37.delimiter).filter(Boolean)) {
-    const file2 = path37.join(dir, process.platform === "win32" ? "node.exe" : "node");
+  for (const dir of (process.env.PATH ?? "").split(path38.delimiter).filter(Boolean)) {
+    const file2 = path38.join(dir, process.platform === "win32" ? "node.exe" : "node");
     try {
-      if (!fs42.statSync(file2).isFile()) continue;
+      if (!fs43.statSync(file2).isFile()) continue;
     } catch {
       continue;
     }
-    const r = spawnSync13(file2, ["-p", "process.versions.node"], { encoding: "utf8", timeout: 5e3 });
+    const r = spawnSync14(file2, ["-p", "process.versions.node"], { encoding: "utf8", timeout: 5e3 });
     return r.status === 0 ? { path: file2, version: r.stdout.trim() } : { path: file2, version: "" };
   }
   return void 0;
@@ -8883,14 +9032,16 @@ function doctor8(probe2) {
   const addAll = (list2) => list2.forEach((c) => add2(c.level, c.message));
   add2("ok", `pitroom ${VERSION2} \xB7 node ${process.versions.node} \xB7 state in ${home()}`);
   const onPath = firstNodeOnPath();
-  if (onPath && onPath.version && tooOld(onPath.version) && path37.resolve(onPath.path) !== path37.resolve(process.execPath)) {
+  if (onPath && onPath.version && tooOld(onPath.version) && path38.resolve(onPath.path) !== path38.resolve(process.execPath)) {
     add2("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)`);
   }
   add2(gitAvailable() ? "ok" : "warn", gitAvailable() ? "git available" : "git not found: --write/--isolate tracking disabled");
   const cfg = loadConfig();
-  add2(cfg.warnings.length ? "warn" : "ok", `config: ${configPath()}${fs42.existsSync(configPath()) ? "" : " (not present, defaults in use)"}`);
+  add2(cfg.warnings.length ? "warn" : "ok", `config: ${configPath()}${fs43.existsSync(configPath()) ? "" : " (not present, defaults in use)"}`);
   for (const w of cfg.warnings) add2("warn", w);
-  if (shimReady()) add2("ok", "git guard shim ready");
+  if (shimReady() && process.platform === "win32" && !fs43.existsSync(path38.join(shimDir(), "git.exe"))) {
+    add2("warn", "git guard shim ready as git.cmd only (no C# compiler of .NET Framework 4 to build git.exe): a program that starts git without a shell skips it, and PowerShell's unquoted & | < > reach git changed");
+  } else if (shimReady()) add2("ok", "git guard shim ready");
   else if (process.platform === "win32") add2("warn", "git guard: the ref and push guard is on, but the git shim needs the sh.exe of Git for Windows next to git (not found), so a worker's `git add`, `restore` or `clean` is not blocked; prefer --isolate and check the patch before apply");
   else add2("warn", "git guard unavailable (git not on PATH)");
   section2("Worker chain");
@@ -8902,7 +9053,8 @@ function doctor8(probe2) {
   } catch (e) {
     add2("fail", e.message);
   }
-  if (chain.length) add2("ok", `worker chain: ${chain.map(describeTarget).join(" \u2192 ")}`);
+  const auto = chain.length > 1 && !effective().fallback.value.length;
+  if (chain.length) add2("ok", `worker chain: ${chain.map(describeTarget).join(" \u2192 ")}${auto ? ' (fallbacks from "autoFallback": the other workers your config names)' : ""}`);
   const rate2 = effective().audit.value;
   if (rate2 > 0 && chain.length) {
     const auditor = pickAuditor({ worker: chain[0], fallback: chain.slice(1) });
@@ -9021,12 +9173,12 @@ function liveProbe(target) {
   } catch (e) {
     return { level: "fail", message: e.message };
   }
-  const scratch = readsOwnSnapshot(backend) ? fs42.mkdtempSync(path37.join(os13.tmpdir(), "pitroom-probe-")) : void 0;
+  const scratch = readsOwnSnapshot(backend) ? fs43.mkdtempSync(path38.join(os13.tmpdir(), "pitroom-probe-")) : void 0;
   const cwd = scratch ?? process.cwd();
   try {
     return probe(backend, target, cwd);
   } finally {
-    if (scratch) fs42.rmSync(scratch, { recursive: true, force: true });
+    if (scratch) fs43.rmSync(scratch, { recursive: true, force: true });
   }
 }
 function probe(backend, target, cwd) {
@@ -9040,7 +9192,7 @@ function probe(backend, target, cwd) {
     title: "pitroom doctor probe"
   });
   const t0 = Date.now();
-  const r = spawnSync13(inv.command, inv.args, {
+  const r = spawnSync14(inv.command, inv.args, {
     encoding: "utf8",
     timeout: 3e5,
     stdio: ["ignore", "pipe", "pipe"],
@@ -9071,20 +9223,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(`${path37.sep}.agents${path37.sep}`) && i.names.length);
+    const linked = installedSkills().some((i) => i.base.includes(`${path38.sep}.agents${path38.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(`${path37.sep}.claude${path37.sep}`) && i.names.length);
+    const linked = installedSkills().some((i) => i.base.includes(`${path38.sep}.claude${path38.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 (fs42.existsSync(launcher)) {
-    const r = spawnSync13(launcher, ["--version"], { encoding: "utf8", timeout: 3e4, stdio: ["ignore", "pipe", "pipe"], shell: process.platform === "win32" });
+  if (fs43.existsSync(launcher)) {
+    const r = spawnSync14(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)}` }
     );
@@ -9095,12 +9247,12 @@ function skillChecks() {
 }
 function geminiExtensionInstalled() {
   const home3 = process.env.GEMINI_CLI_HOME ?? os13.homedir();
-  return fs42.existsSync(path37.join(home3, ".gemini", "extensions", "pitroom"));
+  return fs43.existsSync(path38.join(home3, ".gemini", "extensions", "pitroom"));
 }
 function pluginInstalled() {
   try {
-    const f = path37.join(os13.homedir(), ".claude", "plugins", "installed_plugins.json");
-    const plugins = JSON.parse(fs42.readFileSync(f, "utf8")).plugins ?? {};
+    const f = path38.join(os13.homedir(), ".claude", "plugins", "installed_plugins.json");
+    const plugins = JSON.parse(fs43.readFileSync(f, "utf8")).plugins ?? {};
     return Object.keys(plugins).some((k) => k.startsWith("pitroom@"));
   } catch {
     return false;
@@ -9117,24 +9269,24 @@ function superpowersActive() {
   for (const p of openCodePlugins()) {
     if (/superpowers/i.test(p)) found.push(`OpenCode plugin ${p}`);
   }
-  for (const base2 of [path37.join(os13.homedir(), ".agents", "skills"), path37.join(os13.homedir(), ".claude", "skills")]) {
-    const dir = path37.join(base2, "using-superpowers");
-    if (fs42.existsSync(path37.join(dir, "SKILL.md"))) found.push(dir);
+  for (const base2 of [path38.join(os13.homedir(), ".agents", "skills"), path38.join(os13.homedir(), ".claude", "skills")]) {
+    const dir = path38.join(base2, "using-superpowers");
+    if (fs43.existsSync(path38.join(dir, "SKILL.md"))) found.push(dir);
   }
   return found;
 }
 function claudePlugins() {
   try {
-    const f = path37.join(os13.homedir(), ".claude", "plugins", "installed_plugins.json");
-    return Object.keys(JSON.parse(fs42.readFileSync(f, "utf8")).plugins ?? {});
+    const f = path38.join(os13.homedir(), ".claude", "plugins", "installed_plugins.json");
+    return Object.keys(JSON.parse(fs43.readFileSync(f, "utf8")).plugins ?? {});
   } catch {
     return [];
   }
 }
 function claudePluginEnabled(key) {
   try {
-    const f = path37.join(os13.homedir(), ".claude", "settings.json");
-    return JSON.parse(fs42.readFileSync(f, "utf8")).enabledPlugins?.[key] !== false;
+    const f = path38.join(os13.homedir(), ".claude", "settings.json");
+    return JSON.parse(fs43.readFileSync(f, "utf8")).enabledPlugins?.[key] !== false;
   } catch {
     return true;
   }
@@ -9143,7 +9295,7 @@ function codexPlugins() {
   const plugins = /* @__PURE__ */ new Map();
   let text;
   try {
-    text = fs42.readFileSync(path37.join(process.env.CODEX_HOME ?? path37.join(os13.homedir(), ".codex"), "config.toml"), "utf8");
+    text = fs43.readFileSync(path38.join(process.env.CODEX_HOME ?? path38.join(os13.homedir(), ".codex"), "config.toml"), "utf8");
   } catch {
     return plugins;
   }
@@ -9161,11 +9313,11 @@ function codexPlugins() {
   return plugins;
 }
 function openCodePlugins() {
-  const dir = path37.join(process.env.XDG_CONFIG_HOME ?? path37.join(os13.homedir(), ".config"), "opencode");
+  const dir = path38.join(process.env.XDG_CONFIG_HOME ?? path38.join(os13.homedir(), ".config"), "opencode");
   const plugins = [];
   for (const name of ["opencode.json", "opencode.jsonc"]) {
     try {
-      const text = fs42.readFileSync(path37.join(dir, name), "utf8").replace(/\/\*[\s\S]*?\*\/|^\s*\/\/.*$/gm, "");
+      const text = fs43.readFileSync(path38.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 {
@@ -9173,7 +9325,7 @@ function openCodePlugins() {
   }
   for (const folder of ["plugin", "plugins"]) {
     try {
-      for (const f of fs42.readdirSync(path37.join(dir, folder))) plugins.push(path37.join(dir, folder, f));
+      for (const f of fs43.readdirSync(path38.join(dir, folder))) plugins.push(path38.join(dir, folder, f));
     } catch {
     }
   }
@@ -9300,7 +9452,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 (!fs43.statSync(dir, { throwIfNoEntry: false })?.isDirectory()) throw new UserError(`-d ${dir}: no such directory`);
+      if (!fs44.statSync(dir, { throwIfNoEntry: false })?.isDirectory()) throw new UserError(`-d ${dir}: no such directory`);
       process.chdir(dir);
       process.env.PWD = process.cwd();
     }