lobstah 0.7.2 → 0.7.4

package/dist/runner.js

@@ -1,6 +1,6 @@
 // packages/runner/src/index.ts
-import * as fs21 from "node:fs";
-import * as path18 from "node:path";
+import * as fs27 from "node:fs";
+import * as path23 from "node:path";
 
 // packages/core/dist/types.js
 var VERBS = ["working", "needs-decision", "blocked", "paused", "done", "failed"];
@@ -9,13 +9,17 @@ var WAITING_ON = ["review", "pr", "deploy", "person", "external"];
 var WAITING_ON_VERBS = ["paused", "needs-decision", "blocked"];
 
 // packages/core/dist/stats.js
-import * as fs12 from "node:fs";
-import * as path10 from "node:path";
+import * as fs17 from "node:fs";
+import * as path14 from "node:path";
 
 // packages/core/dist/paths.js
 import * as os from "node:os";
 import * as path from "node:path";
 import * as fs from "node:fs";
+import { randomUUID } from "node:crypto";
+function uniqueTempPath(file2) {
+  return `${file2}.tmp-${process.pid}-${randomUUID()}`;
+}
 function readDirIfPresent(dir) {
   try {
     return fs.readdirSync(dir);
@@ -149,8 +153,8 @@ function sanitizeWorker(value) {
 }
 
 // packages/core/dist/soak.js
-import * as fs11 from "node:fs";
-import * as path9 from "node:path";
+import * as fs16 from "node:fs";
+import * as path13 from "node:path";
 
 // packages/core/dist/queue.js
 import * as fs4 from "node:fs";
@@ -175,8 +179,8 @@ var SECRET_PATTERNS = [
 function looksSecret(word) {
   if (SECRET_PATTERNS.some((re) => re.test(word)))
     return true;
-  for (const run2 of word.match(/[A-Za-z0-9+/_=-]{24,}/g) ?? []) {
-    if (/[0-9]/.test(run2) && /[A-Za-z]/.test(run2))
+  for (const run3 of word.match(/[A-Za-z0-9+/_=-]{24,}/g) ?? []) {
+    if (/[0-9]/.test(run3) && /[A-Za-z]/.test(run3))
       return true;
   }
   return false;
@@ -235,9 +239,9 @@ function toolTarget(input) {
     return void 0;
   const i = input;
   const str = (k) => typeof i[k] === "string" && i[k].length > 0 ? i[k] : void 0;
-  const file = str("file_path") ?? str("notebook_path") ?? str("path");
-  if (file)
-    return file;
+  const file2 = str("file_path") ?? str("notebook_path") ?? str("path");
+  if (file2)
+    return file2;
   const command = str("command") ?? (Array.isArray(i.command) ? i.command.map(String).join(" ") : void 0);
   if (command)
     return commandWord(command);
@@ -282,10 +286,10 @@ function activityFromEvent(ev, root) {
       return void 0;
   }
 }
-function atomicWrite(file, content) {
-  const tmp = `${file}.tmp-${process.pid}`;
+function atomicWrite(file2, content) {
+  const tmp = uniqueTempPath(file2);
   fs2.writeFileSync(tmp, content);
-  fs2.renameSync(tmp, file);
+  fs2.renameSync(tmp, file2);
 }
 function writeActivity(id, lane, a) {
   const safe = { at: a.at, kind: a.kind, summary: redactSummary(a.summary) };
@@ -436,10 +440,10 @@ function appendStatus(id, lane, verb, note, at, waiting, reported = false) {
   return entry;
 }
 function readStatusLog(id, lane) {
-  const file = statusPath(id, lane);
-  if (!fs3.existsSync(file))
+  const file2 = statusPath(id, lane);
+  if (!fs3.existsSync(file2))
     return [];
-  return fs3.readFileSync(file, "utf8").split("\n").filter(Boolean).flatMap((line) => {
+  return fs3.readFileSync(file2, "utf8").split("\n").filter(Boolean).flatMap((line) => {
     try {
       const parsed = JSON.parse(line);
       return isVerb(parsed.verb) ? [parsed] : [];
@@ -453,15 +457,21 @@ function pausedWaiting(entry) {
 }
 
 // packages/core/dist/queue.js
+function requeue(id, lane) {
+  const dirs = laneDirs(lane);
+  const activeDir = path3.join(dirs.active, id);
+  fs4.renameSync(path3.join(activeDir, "descriptor.json"), path3.join(dirs.queue, `${id}.json`));
+  fs4.rmSync(activeDir, { recursive: true, force: true });
+}
 function storedDescriptor(id, lane) {
   const dirs = laneDirs(lane);
-  for (const file of [
+  for (const file2 of [
     path3.join(dirs.queue, `${id}.json`),
     path3.join(dirs.active, id, "descriptor.json"),
     path3.join(dirs.done, id, "descriptor.json")
   ]) {
     try {
-      return JSON.parse(fs4.readFileSync(file, "utf8"));
+      return JSON.parse(fs4.readFileSync(file2, "utf8"));
     } catch {
     }
   }
@@ -488,10 +498,10 @@ function readEvidence(id, lane) {
   }
 }
 function mergeEvidence(id, lane, patch) {
-  const file = evidencePath(id, lane);
-  const tmp = `${file}.tmp-${process.pid}`;
+  const file2 = evidencePath(id, lane);
+  const tmp = uniqueTempPath(file2);
   fs5.writeFileSync(tmp, JSON.stringify({ ...readEvidence(id, lane), ...patch }, null, 2));
-  fs5.renameSync(tmp, file);
+  fs5.renameSync(tmp, file2);
 }
 
 // packages/core/dist/pushes.js
@@ -591,6 +601,10 @@ function recordPush(id, lane, branches, at = (/* @__PURE__ */ new Date()).toISOS
   mergeEvidence(id, lane, { pushes });
 }
 
+// packages/core/dist/notices.js
+import fs12 from "node:fs";
+import * as path10 from "node:path";
+
 // packages/core/dist/config.js
 import * as fs7 from "node:fs";
 import * as os2 from "node:os";
@@ -1242,6 +1256,30 @@ function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
 }
 
 // packages/core/dist/config.js
+var POOL_NAME = /^[A-Za-z0-9_-]+$/;
+function parsePools(raw, repos) {
+  const out = {};
+  if (raw === void 0)
+    return out;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    throw new Error(`[pools] must be a table of pools in ${configPath()}`);
+  for (const [name, p] of Object.entries(raw)) {
+    const where = `[pools.${name}] in ${configPath()}`;
+    if (!POOL_NAME.test(name))
+      throw new Error(`${where}: a pool name may use letters, digits, "-" and "_" only`);
+    const repo = String(p?.repo ?? "");
+    if (!repos[repo])
+      throw new Error(`${where}: repo "${repo}" is not a configured [repos.<key>]`);
+    const size = p.size ?? 1;
+    if (typeof size !== "number" || !Number.isInteger(size) || size < 1)
+      throw new Error(`${where}: size must be a positive integer`);
+    const overflow = p.overflow ?? "headless";
+    if (overflow !== "headless" && overflow !== "queue")
+      throw new Error(`${where}: overflow must be "headless" or "queue"`);
+    out[name] = { repo, size, overflow };
+  }
+  return out;
+}
 var BRIEF_KINDS = ["conflict", "checks", "review", "ciFix", "rebase"];
 function parseBriefHooks(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw))
@@ -1316,8 +1354,8 @@ function expandHome(p) {
   return p.startsWith("~/") ? path5.join(os2.homedir(), p.slice(2)) : p;
 }
 function loadConfig() {
-  const file = configPath();
-  const raw = fs7.existsSync(file) ? parse(fs7.readFileSync(file, "utf8")) : {};
+  const file2 = configPath();
+  const raw = fs7.existsSync(file2) ? parse(fs7.readFileSync(file2, "utf8")) : {};
   const watch = { ...DEFAULT_WATCH, ...raw.watch ?? {} };
   if (typeof watch.repairCooldownSecs !== "number" || !Number.isFinite(watch.repairCooldownSecs) || watch.repairCooldownSecs < 0) {
     throw new Error(`[watch].repairCooldownSecs must be a non-negative number in ${configPath()}`);
@@ -1342,7 +1380,8 @@ function loadConfig() {
       draftPr: r.draftPr === void 0 ? void 0 : Boolean(r.draftPr),
       checkpointOnStop: r.checkpointOnStop === void 0 ? void 0 : Boolean(r.checkpointOnStop),
       humanGateChecks: Array.isArray(r.humanGateChecks) ? r.humanGateChecks.map(String).filter(Boolean) : void 0,
-      briefHooks: parseBriefHooks(r.briefHooks)
+      briefHooks: parseBriefHooks(r.briefHooks),
+      poolKeep: Array.isArray(r.poolKeep) ? r.poolKeep.map(String).filter(Boolean) : void 0
     };
   }
   const groundsRaw = raw.grounds ?? {};
@@ -1359,6 +1398,7 @@ function loadConfig() {
     glass: { ...DEFAULT_GLASS, ...raw.glass ?? {} },
     watch,
     grounds,
+    pools: parsePools(raw.pools, repos),
     notifyCommand: raw.notifyCommand ? String(raw.notifyCommand) : void 0,
     notifyVerbs: Array.isArray(raw.notifyVerbs) ? raw.notifyVerbs.map(String) : void 0,
     remindSecs: raw.remindSecs !== void 0 ? Number(raw.remindSecs) : void 0,
@@ -1406,6 +1446,114 @@ function firstMeaningfulLine(...outputs) {
   return void 0;
 }
 
+// packages/core/dist/pr-poll.js
+import * as fs11 from "node:fs";
+import * as path9 from "node:path";
+
+// packages/core/dist/prs.js
+import * as fs8 from "node:fs";
+import * as path6 from "node:path";
+function prsDir() {
+  return path6.join(lobstahHome(), "prs");
+}
+function prRecordFile(key) {
+  const ref = parsePrRef(key);
+  if (!ref)
+    throw new Error(`not a PR key: ${key}`);
+  const safe = (s) => s.replace(/[^A-Za-z0-9._-]/g, "_");
+  return path6.join(prsDir(), `${safe(ref.owner)}__${safe(ref.repo)}__${ref.number}.json`);
+}
+function readPr(key) {
+  try {
+    return JSON.parse(fs8.readFileSync(prRecordFile(key), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function readPrs() {
+  let files;
+  try {
+    files = fs8.readdirSync(prsDir()).filter((f) => f.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  return files.flatMap((f) => {
+    try {
+      const r = JSON.parse(fs8.readFileSync(path6.join(prsDir(), f), "utf8"));
+      return typeof r.key === "string" && typeof r.url === "string" ? [r] : [];
+    } catch {
+      return [];
+    }
+  });
+}
+
+// packages/core/dist/watch.js
+import fs10 from "node:fs";
+import * as path8 from "node:path";
+
+// packages/core/dist/github-budget.js
+import * as fs9 from "node:fs";
+import * as path7 from "node:path";
+var file = () => path7.join(lobstahHome(), "github-budget.json");
+function read() {
+  try {
+    return JSON.parse(fs9.readFileSync(file(), "utf8"));
+  } catch {
+    return { resources: {} };
+  }
+}
+function githubBlockedUntil(now2 = Date.now()) {
+  const s = read();
+  const zeros = Object.values(s.resources).filter((b) => b.remaining === 0 && b.reset > now2).map((b) => b.reset);
+  const until2 = Math.max(s.retryAt ?? 0, ...zeros);
+  return until2 > now2 ? until2 : void 0;
+}
+
+// packages/core/dist/watch.js
+function watchesDir() {
+  return path8.join(lobstahHome(), "watches");
+}
+function slug(key) {
+  return key.replace(/[^A-Za-z0-9._-]+/g, "-");
+}
+function watchPath(key) {
+  return path8.join(watchesDir(), `${slug(key)}.json`);
+}
+function readWatch(key) {
+  try {
+    return JSON.parse(fs10.readFileSync(watchPath(key), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+
+// packages/core/dist/pr-poll.js
+var cycleFile = (repo) => path9.join(lobstahHome(), "pr-polls", `${repo.replace(/[^\w.-]/g, "_")}.json`);
+var readCycle = (repo) => {
+  try {
+    return JSON.parse(fs11.readFileSync(cycleFile(repo), "utf8"));
+  } catch {
+    return void 0;
+  }
+};
+var repoOf = (ref) => `${ref.owner}/${ref.repo}`;
+function cachedPrView(ref) {
+  if (process.env.LOBSTAH_PR_BATCH !== "1")
+    return void 0;
+  const blocked = githubBlockedUntil();
+  if (blocked)
+    throw new Error(`GitHub rate limit reached; retry after ${new Date(blocked).toISOString()}`);
+  const cycle = readCycle(repoOf(ref));
+  if (!cycle)
+    return void 0;
+  if (cycle.error)
+    throw new Error(cycle.error);
+  const cached = cycle.snapshots[ref.key];
+  if (cached?.error)
+    throw new Error(cached.error);
+  return cached ? { ...cached.view, fetchedAt: new Date(cached.at).toISOString() } : void 0;
+}
+
 // packages/core/dist/pr.js
 function parsePrRef(s) {
   const m = /^(?:pr:)?([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)#(\d+)$/.exec(s.trim()) ?? /^https?:\/\/github\.com\/([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)\/pull\/(\d+)(?:[/?#].*)?$/.exec(s.trim());
@@ -1419,6 +1567,9 @@ var PR_VIEW_FIELDS = "title,state,isDraft,isCrossRepository,headRefOid,baseRefNa
 var PR_VIEW_FIELDS_NO_CHECKS = PR_VIEW_FIELDS.split(",").filter((f) => f !== "statusCheckRollup").join(",");
 var FORBIDDEN = /resource not accessible by (integration|personal access token)/i;
 function ghPrView(ref) {
+  return cachedPrView(ref) ?? ghPrViewDirect(ref);
+}
+function ghPrViewDirect(ref) {
   const view1 = (fields2) => spawnSync("gh", ["pr", "view", String(ref.number), "--repo", `${ref.owner}/${ref.repo}`, "--json", fields2], {
     encoding: "utf8",
     timeout: 6e4
@@ -1453,6 +1604,7 @@ function ghPrView(ref) {
     if (threads !== void 0)
       view.unresolvedThreads = threads;
   }
+  view.fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
   return view;
 }
 var THREADS_QUERY = "query($owner:String!,$repo:String!,$n:Int!){repository(owner:$owner,name:$repo){pullRequest(number:$n){reviewThreads(first:100){nodes{isResolved}}}}}";
@@ -1471,41 +1623,40 @@ function parseUnresolvedThreads(stdout) {
   }
 }
 
-// packages/core/dist/prs.js
-import * as fs8 from "node:fs";
-import * as path6 from "node:path";
-function prsDir() {
-  return path6.join(lobstahHome(), "prs");
-}
-function prRecordFile(key) {
-  const ref = parsePrRef(key);
-  if (!ref)
-    throw new Error(`not a PR key: ${key}`);
-  const safe = (s) => s.replace(/[^A-Za-z0-9._-]/g, "_");
-  return path6.join(prsDir(), `${safe(ref.owner)}__${safe(ref.repo)}__${ref.number}.json`);
-}
-function readPr(key) {
-  try {
-    return JSON.parse(fs8.readFileSync(prRecordFile(key), "utf8"));
-  } catch {
-    return void 0;
-  }
-}
-function readPrs() {
-  let files;
-  try {
-    files = fs8.readdirSync(prsDir()).filter((f) => f.endsWith(".json"));
-  } catch {
-    return [];
-  }
-  return files.flatMap((f) => {
+// packages/core/dist/notices.js
+function noticesDir() {
+  return path10.join(lobstahHome(), "notices");
+}
+var counter = 0;
+function postNotice(n) {
+  const dir = noticesDir();
+  fs12.mkdirSync(dir, { recursive: true });
+  if (n.dedupeKey) {
+    const marker = path10.join(dir, `.dedupe-${n.dedupeKey.replace(/[^A-Za-z0-9_-]/g, "_")}`);
     try {
-      const r = JSON.parse(fs8.readFileSync(path6.join(prsDir(), f), "utf8"));
-      return typeof r.key === "string" && typeof r.url === "string" ? [r] : [];
+      fs12.writeFileSync(marker, "", { flag: "wx" });
     } catch {
-      return [];
+      return void 0;
     }
-  });
+  }
+  const seq = `${String(Date.now()).padStart(15, "0")}-${process.pid}-${String(counter++).padStart(8, "0")}`;
+  const notice = {
+    seq,
+    kind: n.kind,
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    text: n.text,
+    refId: n.refId,
+    ...n.url ? { url: n.url } : {},
+    repo: n.repo,
+    by: n.by,
+    ...n.quiet ? { quiet: true } : {},
+    ...n.stateHash ? { stateHash: n.stateHash } : {}
+  };
+  const file2 = path10.join(dir, `${seq}.json`);
+  const tmp = uniqueTempPath(file2);
+  fs12.writeFileSync(tmp, JSON.stringify(notice, null, 2));
+  fs12.renameSync(tmp, file2);
+  return notice;
 }
 
 // packages/core/dist/attachments.js
@@ -1520,23 +1671,23 @@ function attachmentBlock(attachments) {
 }
 
 // packages/core/dist/worktrees.js
-import * as fs9 from "node:fs";
-import * as path7 from "node:path";
+import * as fs13 from "node:fs";
+import * as path11 from "node:path";
 var LANES = ["work", "chore"];
 function worktreePath(id) {
-  return path7.join(lobstahHome(), "worktrees", id);
+  return path11.join(lobstahHome(), "worktrees", id);
 }
-function readRecord(file) {
+function readRecord(file2) {
   try {
-    const r = JSON.parse(fs9.readFileSync(file, "utf8"));
+    const r = JSON.parse(fs13.readFileSync(file2, "utf8"));
     return typeof r.path === "string" ? r : void 0;
   } catch {
     return void 0;
   }
 }
 function ownerOfPath(p) {
-  const rel = path7.relative(path7.join(lobstahHome(), "worktrees"), p);
-  if (!rel || rel.startsWith("..") || path7.isAbsolute(rel))
+  const rel = path11.relative(path11.join(lobstahHome(), "worktrees"), p);
+  if (!rel || rel.startsWith("..") || path11.isAbsolute(rel))
     return void 0;
   return rel.split(/[\\/]/)[0];
 }
@@ -1549,7 +1700,7 @@ function dispatchWorktree(id, lane) {
     }
     const dirs = laneDirs(l);
     for (const dir of [dirs.active, dirs.done]) {
-      const rec = readRecord(path7.join(dir, id, "worktree.json"));
+      const rec = readRecord(path11.join(dir, id, "worktree.json"));
       if (rec) {
         const owner = rec.of ?? ownerOfPath(rec.path) ?? id;
         return { path: rec.path, owner, reused: owner !== id };
@@ -1561,7 +1712,7 @@ function dispatchWorktree(id, lane) {
 function laneOf(id) {
   for (const l of LANES) {
     const d = laneDirs(l);
-    if (fs9.existsSync(path7.join(d.queue, `${id}.json`)) || fs9.existsSync(path7.join(d.active, id)) || fs9.existsSync(path7.join(d.done, id))) {
+    if (fs13.existsSync(path11.join(d.queue, `${id}.json`)) || fs13.existsSync(path11.join(d.active, id)) || fs13.existsSync(path11.join(d.done, id))) {
       return l;
     }
   }
@@ -1581,52 +1732,63 @@ function followUpAncestors(id, lane) {
 function chainWorktree(followUp) {
   for (const id of [followUp, ...followUpAncestors(followUp)]) {
     const wt = dispatchWorktree(id, laneOf(id));
-    if (fs9.existsSync(wt.path))
+    if (fs13.existsSync(wt.path))
       return { ...wt, from: id };
   }
   return void 0;
 }
+var WARM_LOCK_MAX_MS = 15 * 6e4;
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
 function worktreeGitDir(wt) {
-  const dotGit = path7.join(wt, ".git");
+  const dotGit = path11.join(wt, ".git");
   try {
-    const st = fs9.statSync(dotGit);
+    const st = fs13.statSync(dotGit);
     if (st.isDirectory())
       return dotGit;
-    const m = /^gitdir:\s*(.+?)\s*$/m.exec(fs9.readFileSync(dotGit, "utf8"));
-    return m ? path7.resolve(wt, m[1]) : void 0;
+    const m = /^gitdir:\s*(.+?)\s*$/m.exec(fs13.readFileSync(dotGit, "utf8"));
+    return m ? path11.resolve(wt, m[1]) : void 0;
   } catch {
     return void 0;
   }
 }
 function worktreeLockFile(wt) {
   const gitDir = worktreeGitDir(wt);
-  return gitDir ? path7.join(gitDir, "lobstah.lock") : void 0;
+  return gitDir ? path11.join(gitDir, "lobstah.lock") : void 0;
 }
 function readWorktreeLock(wt) {
-  const file = worktreeLockFile(wt);
-  if (!file)
+  const file2 = worktreeLockFile(wt);
+  if (!file2)
     return void 0;
   try {
-    return JSON.parse(fs9.readFileSync(file, "utf8"));
+    return JSON.parse(fs13.readFileSync(file2, "utf8"));
   } catch {
     return void 0;
   }
 }
 function lockIsLive(lock) {
-  return fs9.existsSync(path7.join(laneDirs(lock.lane).active, lock.id));
+  if (lock.kind === "warm")
+    return processAlive(lock.pid) && Date.now() - (Date.parse(lock.at) || 0) < WARM_LOCK_MAX_MS;
+  return fs13.existsSync(path11.join(laneDirs(lock.lane).active, lock.id));
 }
 function worktreeHolder(wt) {
   const lock = readWorktreeLock(wt);
   return lock && lockIsLive(lock) ? lock : void 0;
 }
-function acquireWorktreeLock(wt, id, lane) {
-  const file = worktreeLockFile(wt);
-  const mine = { id, lane, pid: process.pid, at: (/* @__PURE__ */ new Date()).toISOString() };
-  if (!file)
+function acquireWorktreeLock(wt, id, lane, kind) {
+  const file2 = worktreeLockFile(wt);
+  const mine = { id, lane, pid: process.pid, at: (/* @__PURE__ */ new Date()).toISOString(), ...kind ? { kind } : {} };
+  if (!file2)
     return { id: "(no git dir)", lane, pid: 0, at: mine.at };
   for (let attempt = 0; attempt < 3; attempt++) {
     try {
-      fs9.writeFileSync(file, JSON.stringify(mine, null, 2), { flag: "wx" });
+      fs13.writeFileSync(file2, JSON.stringify(mine, null, 2), { flag: "wx" });
       return void 0;
     } catch (err) {
       if (err.code !== "EEXIST")
@@ -1634,7 +1796,7 @@ function acquireWorktreeLock(wt, id, lane) {
     }
     let raw;
     try {
-      raw = fs9.readFileSync(file, "utf8");
+      raw = fs13.readFileSync(file2, "utf8");
     } catch {
       continue;
     }
@@ -1645,14 +1807,14 @@ function acquireWorktreeLock(wt, id, lane) {
       held2 = void 0;
     }
     if (held2?.id === id) {
-      fs9.writeFileSync(file, JSON.stringify(mine, null, 2));
+      fs13.writeFileSync(file2, JSON.stringify(mine, null, 2));
       return void 0;
     }
     if (held2 && lockIsLive(held2))
       return held2;
     try {
-      if (fs9.readFileSync(file, "utf8") === raw)
-        fs9.rmSync(file, { force: true });
+      if (fs13.readFileSync(file2, "utf8") === raw)
+        fs13.rmSync(file2, { force: true });
     } catch {
     }
   }
@@ -1660,60 +1822,205 @@ function acquireWorktreeLock(wt, id, lane) {
   return held ?? { id: "(contended)", lane, pid: 0, at: mine.at };
 }
 function releaseWorktreeLock(wt, id) {
-  const file = worktreeLockFile(wt);
-  if (!file)
+  const file2 = worktreeLockFile(wt);
+  if (!file2)
     return;
   if (readWorktreeLock(wt)?.id === id)
-    fs9.rmSync(file, { force: true });
+    fs13.rmSync(file2, { force: true });
 }
 
 // packages/core/dist/disk.js
+import * as fs14 from "node:fs";
 var GB = 1024 ** 3;
+var statfsFreeBytes = (dir) => {
+  const s = fs14.statfsSync(dir);
+  return Number(s.bavail) * Number(s.bsize);
+};
+function formatGB(bytes) {
+  return `${(bytes / GB).toFixed(1).replace(/\.0$/, "")} GB`;
+}
 
-// packages/core/dist/watch.js
-import * as fs10 from "node:fs";
-import * as path8 from "node:path";
-function watchesDir() {
-  return path8.join(lobstahHome(), "watches");
+// packages/core/dist/pools.js
+import * as fs15 from "node:fs";
+import * as path12 from "node:path";
+
+// packages/core/dist/slots.js
+function isTrapCatch(id, lane) {
+  return readSessionClaim(id, lane)?.by.startsWith("wt:") ?? false;
 }
-function slug(key) {
-  return key.replace(/[^A-Za-z0-9._-]+/g, "-");
+function isFinished(id, lane) {
+  const verb = readStatusLog(id, lane).at(-1)?.verb;
+  return verb !== void 0 && TERMINAL_VERBS.includes(verb);
 }
-function watchPath(key) {
-  return path8.join(watchesDir(), `${slug(key)}.json`);
+
+// packages/core/dist/pools.js
+function poolsRoot() {
+  return path12.join(lobstahHome(), "pools");
 }
-function readWatch(key) {
+function poolDir(pool) {
+  return path12.join(poolsRoot(), pool);
+}
+function poolSlotPath(pool, slot) {
+  return path12.join(poolDir(pool), String(slot));
+}
+function slotsDir(pool) {
+  return path12.join(poolDir(pool), ".slots");
+}
+function poolSlotOf(p) {
+  const real = (x) => {
+    try {
+      return fs15.realpathSync.native(x);
+    } catch {
+      return path12.resolve(x);
+    }
+  };
+  for (const [rootDir, dir] of [[poolsRoot(), path12.resolve(p)], [real(poolsRoot()), real(p)]]) {
+    const rel = path12.relative(rootDir, dir);
+    if (!rel || rel.startsWith("..") || path12.isAbsolute(rel))
+      continue;
+    const parts = rel.split(/[\\/]/);
+    if (parts.length !== 2 || !/^[1-9][0-9]*$/.test(parts[1]))
+      continue;
+    return { pool: parts[0], slot: Number(parts[1]) };
+  }
+  return void 0;
+}
+function poolSlotLabel(pool, slot) {
+  return `${pool}/${slot}`;
+}
+function readJson(file2) {
   try {
-    return JSON.parse(fs10.readFileSync(watchPath(key), "utf8"));
+    return JSON.parse(fs15.readFileSync(file2, "utf8"));
   } catch {
     return void 0;
   }
 }
+function writeJson(file2, value) {
+  fs15.mkdirSync(path12.dirname(file2), { recursive: true });
+  const tmp = uniqueTempPath(file2);
+  fs15.writeFileSync(tmp, JSON.stringify(value, null, 2));
+  fs15.renameSync(tmp, file2);
+}
+var metaFile = (pool, slot) => path12.join(slotsDir(pool), `${slot}.json`);
+var claimFile = (pool, slot) => path12.join(slotsDir(pool), `${slot}.claim.json`);
+var outFile = (pool, slot) => path12.join(slotsDir(pool), `${slot}.out.json`);
+function readSlotMeta(pool, slot) {
+  return readJson(metaFile(pool, slot)) ?? {};
+}
+function writeSlotMeta(pool, slot, meta) {
+  writeJson(metaFile(pool, slot), meta);
+}
+function readSlotClaim(pool, slot) {
+  return readJson(claimFile(pool, slot));
+}
+function writeSlotClaim(pool, slot, claim) {
+  writeJson(claimFile(pool, slot), claim);
+}
+function readSlotOut(pool, slot) {
+  return readJson(outFile(pool, slot));
+}
+function writeSlotOut(pool, slot, out) {
+  writeJson(outFile(pool, slot), out);
+}
+function clearSlotOut(pool, slot) {
+  fs15.rmSync(outFile(pool, slot), { force: true });
+}
+function dispatchHolder(dir) {
+  const lock = readWorktreeLock(dir);
+  return lock && lock.kind !== "warm" && lockIsLive(lock) ? lock : void 0;
+}
+function poolSlotView(pool, slot) {
+  const dir = poolSlotPath(pool, slot);
+  const lastClaim = readSlotClaim(pool, slot)?.id;
+  const base = { slot, path: dir, ...lastClaim ? { lastClaim } : {} };
+  if (!fs15.existsSync(dir)) {
+    const meta2 = readSlotMeta(pool, slot);
+    return { ...base, state: "missing", ...meta2.error ? { reason: meta2.error } : {} };
+  }
+  const holder = dispatchHolder(dir);
+  if (holder)
+    return { ...base, state: "claimed", dispatch: holder.id };
+  const out = readSlotOut(pool, slot);
+  if (out)
+    return { ...base, state: "out", reason: out.reason, ...out.dispatch ? { dispatch: out.dispatch } : {} };
+  const meta = readSlotMeta(pool, slot);
+  if (!meta.readyAt)
+    return { ...base, state: "warming", ...meta.error ? { reason: meta.error } : {} };
+  return { ...base, state: "free" };
+}
+var warmStateFile = (pool) => path12.join(poolDir(pool), ".warm-state.json");
+var warmLockFile = (pool) => path12.join(poolDir(pool), ".warm.lock");
+var POOL_WARM_MAX_MS = 60 * 6e4;
+function readPoolWarmState(pool) {
+  return readJson(warmStateFile(pool)) ?? {};
+}
+function writePoolWarmState(pool, state) {
+  writeJson(warmStateFile(pool), state);
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function poolWarmRunning(pool, now2 = Date.now()) {
+  const lock = readJson(warmLockFile(pool));
+  return !!lock && pidAlive(lock.pid) && now2 - (Date.parse(lock.at) || 0) < POOL_WARM_MAX_MS;
+}
+function takePoolWarmLock(pool) {
+  const file2 = warmLockFile(pool);
+  fs15.mkdirSync(path12.dirname(file2), { recursive: true });
+  const mine = JSON.stringify({ pid: process.pid, at: (/* @__PURE__ */ new Date()).toISOString() });
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      fs15.writeFileSync(file2, mine, { flag: "wx" });
+      return () => {
+        try {
+          if (fs15.readFileSync(file2, "utf8") === mine)
+            fs15.rmSync(file2, { force: true });
+        } catch {
+        }
+      };
+    } catch (err) {
+      if (err.code !== "EEXIST")
+        throw err;
+    }
+    if (poolWarmRunning(pool))
+      return void 0;
+    fs15.rmSync(file2, { force: true });
+  }
+  return void 0;
+}
+var POOL_RETRY_MS = 10 * 6e4;
+var POOL_FETCH_MS = 10 * 6e4;
+var POOL_RECHECK_MS = 5 * 6e4;
 
 // packages/core/dist/soak.js
 function regPath(trapId) {
-  return path9.join(soakingDir(), `${trapId}.json`);
+  return path13.join(soakingDir(), `${trapId}.json`);
 }
 function readTrap(trapId) {
   try {
-    return JSON.parse(fs11.readFileSync(regPath(trapId), "utf8"));
+    return JSON.parse(fs16.readFileSync(regPath(trapId), "utf8"));
   } catch {
     return void 0;
   }
 }
 function listTraps() {
   try {
-    return fs11.readdirSync(soakingDir()).filter((f) => f.endsWith(".json")).map((f) => JSON.parse(fs11.readFileSync(path9.join(soakingDir(), f), "utf8"))).filter((r) => typeof r.trapId === "string");
+    return fs16.readdirSync(soakingDir()).filter((f) => f.endsWith(".json")).map((f) => JSON.parse(fs16.readFileSync(path13.join(soakingDir(), f), "utf8"))).filter((r) => typeof r.trapId === "string");
   } catch {
     return [];
   }
 }
 function claimPath(id, lane) {
-  return path9.join(laneDirs(lane).active, id, "claim.json");
+  return path13.join(laneDirs(lane).active, id, "claim.json");
 }
 function readSessionClaim(id, lane) {
   try {
-    return JSON.parse(fs11.readFileSync(claimPath(id, lane), "utf8"));
+    return JSON.parse(fs16.readFileSync(claimPath(id, lane), "utf8"));
   } catch {
     return void 0;
   }
@@ -1722,7 +2029,7 @@ function readSessionClaim(id, lane) {
 // packages/core/dist/stats.js
 var DAILY_RETENTION_DAYS = 400;
 function statsPath() {
-  return path10.join(lobstahHome(), "stats.json");
+  return path14.join(lobstahHome(), "stats.json");
 }
 function shiftDay(day, days) {
   const [y, m, d] = day.split("-").map(Number);
@@ -1735,7 +2042,7 @@ function localDay(at = Date.now()) {
 function readCatchFacts(stateDir, id) {
   let last;
   try {
-    for (const line of fs12.readFileSync(path10.join(stateDir, `${id}.status`), "utf8").split("\n")) {
+    for (const line of fs17.readFileSync(path14.join(stateDir, `${id}.status`), "utf8").split("\n")) {
       if (!line.trim())
         continue;
       try {
@@ -1751,7 +2058,7 @@ function readCatchFacts(stateDir, id) {
   let trap;
   let worker = workerProfile();
   try {
-    const evidence = JSON.parse(fs12.readFileSync(path10.join(stateDir, `${id}.evidence`), "utf8"));
+    const evidence = JSON.parse(fs17.readFileSync(path14.join(stateDir, `${id}.evidence`), "utf8"));
     const to = evidence.deliveredTo;
     if (typeof to === "string" && to.startsWith("wt:"))
       trap = to;
@@ -1824,17 +2131,17 @@ function add(store, facts, now2) {
 }
 function backfillSources() {
   const live = ["work", "chore"].map((lane) => ({ dir: laneDirs(lane).state, live: true }));
-  const backups = readDirIfPresent(lobstahHome()).filter((name) => name.startsWith("state-backup-")).sort().map((name) => ({ dir: path10.join(lobstahHome(), name), live: false })).filter((s) => fs12.statSync(s.dir).isDirectory());
+  const backups = readDirIfPresent(lobstahHome()).filter((name) => name.startsWith("state-backup-")).sort().map((name) => ({ dir: path14.join(lobstahHome(), name), live: false })).filter((s) => fs17.statSync(s.dir).isDirectory());
   return [...live, ...backups];
 }
 function backfillStats(now2 = Date.now(), alreadyCounted) {
   const store = emptyStore(now2);
   const seen = /* @__PURE__ */ new Set();
   for (const { dir, live } of backfillSources()) {
-    for (const file of readDirIfPresent(dir).sort()) {
-      if (!file.endsWith(".status"))
+    for (const file2 of readDirIfPresent(dir).sort()) {
+      if (!file2.endsWith(".status"))
         continue;
-      const id = file.slice(0, -".status".length);
+      const id = file2.slice(0, -".status".length);
       if (seen.has(id))
         continue;
       seen.add(id);
@@ -1856,10 +2163,10 @@ function backfillDaily(store, now2 = Date.now()) {
   const seen = /* @__PURE__ */ new Set();
   const into = { ...store, daily };
   for (const { dir, live } of backfillSources()) {
-    for (const file of readDirIfPresent(dir).sort()) {
-      if (!file.endsWith(".status"))
+    for (const file2 of readDirIfPresent(dir).sort()) {
+      if (!file2.endsWith(".status"))
         continue;
-      const id = file.slice(0, -".status".length);
+      const id = file2.slice(0, -".status".length);
       if (seen.has(id))
         continue;
       seen.add(id);
@@ -1895,26 +2202,26 @@ function parseStore(text) {
 }
 var complete2 = (s) => !!s && s.daily !== void 0;
 function writeStore(store) {
-  const file = statsPath();
-  fs12.mkdirSync(path10.dirname(file), { recursive: true });
-  const tmp = `${file}.tmp-${process.pid}`;
-  fs12.writeFileSync(tmp, JSON.stringify(store));
-  fs12.renameSync(tmp, file);
+  const file2 = statsPath();
+  fs17.mkdirSync(path14.dirname(file2), { recursive: true });
+  const tmp = uniqueTempPath(file2);
+  fs17.writeFileSync(tmp, JSON.stringify(store));
+  fs17.renameSync(tmp, file2);
 }
 function withStatsLock(action) {
-  fs12.mkdirSync(lobstahHome(), { recursive: true });
+  fs17.mkdirSync(lobstahHome(), { recursive: true });
   const lock = `${statsPath()}.lock`;
   const deadline = Date.now() + 1e4;
   for (; ; ) {
     try {
-      fs12.mkdirSync(lock);
+      fs17.mkdirSync(lock);
       break;
     } catch (err) {
       if (err.code !== "EEXIST")
         throw err;
       try {
-        if (Date.now() - fs12.statSync(lock).mtimeMs > 12e4)
-          fs12.rmdirSync(lock);
+        if (Date.now() - fs17.statSync(lock).mtimeMs > 12e4)
+          fs17.rmdirSync(lock);
       } catch {
       }
       if (Date.now() >= deadline)
@@ -1925,13 +2232,13 @@ function withStatsLock(action) {
   try {
     return action();
   } finally {
-    fs12.rmdirSync(lock);
+    fs17.rmdirSync(lock);
   }
 }
 function loadOrBackfill(now2) {
   let text;
   try {
-    text = fs12.readFileSync(statsPath(), "utf8");
+    text = fs17.readFileSync(statsPath(), "utf8");
   } catch (err) {
     if (err.code !== "ENOENT")
       throw err;
@@ -1958,7 +2265,7 @@ function loadOrBackfill(now2) {
     return store2;
   }
   if (text !== void 0)
-    fs12.renameSync(statsPath(), `${statsPath()}.unreadable-${now2}`);
+    fs17.renameSync(statsPath(), `${statsPath()}.unreadable-${now2}`);
   const store = backfillStats(now2);
   writeStore(store);
   return store;
@@ -2001,58 +2308,58 @@ var ANSWER_TYPES = {
 var ANSWER_EXTENSIONS = Object.keys(ANSWER_TYPES);
 
 // packages/core/dist/inbox.js
-import * as fs13 from "node:fs";
-import * as path11 from "node:path";
-var metaName = (file) => file.replace(/\.msg$/, ".meta.json");
+import * as fs18 from "node:fs";
+import * as path15 from "node:path";
+var metaName = (file2) => file2.replace(/\.msg$/, ".meta.json");
 function inboxDir(id, lane) {
-  return path11.join(laneDirs(lane).inbox, id);
+  return path15.join(laneDirs(lane).inbox, id);
 }
 function unhandled(id, lane) {
   const dir = inboxDir(id, lane);
-  return readDirIfPresent(dir).filter((f) => f.endsWith(".msg")).sort().map((f) => ({ file: f, text: fs13.readFileSync(path11.join(dir, f), "utf8") }));
+  return readDirIfPresent(dir).filter((f) => f.endsWith(".msg")).sort().map((f) => ({ file: f, text: fs18.readFileSync(path15.join(dir, f), "utf8") }));
 }
-function acknowledge(id, lane, file) {
+function acknowledge(id, lane, file2) {
   const dir = inboxDir(id, lane);
-  fs13.mkdirSync(path11.join(dir, "handled"), { recursive: true });
-  fs13.renameSync(path11.join(dir, file), path11.join(dir, "handled", file));
+  fs18.mkdirSync(path15.join(dir, "handled"), { recursive: true });
+  fs18.renameSync(path15.join(dir, file2), path15.join(dir, "handled", file2));
   try {
-    fs13.renameSync(path11.join(dir, metaName(file)), path11.join(dir, "handled", metaName(file)));
+    fs18.renameSync(path15.join(dir, metaName(file2)), path15.join(dir, "handled", metaName(file2)));
   } catch {
   }
 }
 
 // packages/core/dist/events.js
-import * as fs14 from "node:fs";
+import * as fs19 from "node:fs";
 function appendEvent(id, lane, ev) {
-  fs14.appendFileSync(eventsPath(id, lane), `${JSON.stringify(ev)}
+  fs19.appendFileSync(eventsPath(id, lane), `${JSON.stringify(ev)}
 `);
 }
 function touchEvents(id, lane, at = /* @__PURE__ */ new Date()) {
-  const file = eventsPath(id, lane);
+  const file2 = eventsPath(id, lane);
   try {
-    fs14.utimesSync(file, at, at);
+    fs19.utimesSync(file2, at, at);
   } catch {
-    fs14.appendFileSync(file, "");
-    fs14.utimesSync(file, at, at);
+    fs19.appendFileSync(file2, "");
+    fs19.utimesSync(file2, at, at);
   }
 }
 
 // packages/core/dist/harness.js
-import * as fs15 from "node:fs";
-import * as path12 from "node:path";
+import * as fs20 from "node:fs";
+import * as path16 from "node:path";
 import { createRequire } from "node:module";
 function resolveOnPath(bin, pathVar = process.env.PATH) {
   if (!pathVar)
     return void 0;
   const names = process.platform === "win32" ? [bin, `${bin}.exe`, `${bin}.cmd`, `${bin}.bat`] : [bin];
-  for (const dir of pathVar.split(path12.delimiter)) {
+  for (const dir of pathVar.split(path16.delimiter)) {
     if (!dir)
       continue;
     for (const name of names) {
-      const candidate = path12.join(dir, name);
+      const candidate = path16.join(dir, name);
       try {
-        fs15.accessSync(candidate, fs15.constants.X_OK);
-        if (fs15.statSync(candidate).isFile())
+        fs20.accessSync(candidate, fs20.constants.X_OK);
+        if (fs20.statSync(candidate).isFile())
           return candidate;
       } catch {
       }
@@ -2073,8 +2380,8 @@ function codexInvocation(argv) {
   } catch {
   }
   for (const dir of require_.resolve.paths("@openai/codex") ?? []) {
-    const cli = path12.join(dir, "@openai", "codex", "bin", "codex.js");
-    if (fs15.existsSync(cli))
+    const cli = path16.join(dir, "@openai", "codex", "bin", "codex.js");
+    if (fs20.existsSync(cli))
       return { file: process.execPath, argv: [cli, ...argv] };
   }
   return void 0;
@@ -2127,9 +2434,9 @@ function pushRule(branch, id = "<dispatch id>", mode = "rebase", also = []) {
 }
 
 // packages/core/dist/resume.js
-import * as fs16 from "node:fs";
+import * as fs21 from "node:fs";
 import * as os3 from "node:os";
-import * as path13 from "node:path";
+import * as path17 from "node:path";
 import { spawnSync as spawnSync2 } from "node:child_process";
 var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-([0-9a-f])[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 function harnessFromSessionId(sessionId) {
@@ -2140,7 +2447,7 @@ function claimOf(id, lane) {
   const dirs = laneDirs(lane);
   for (const dir of [dirs.active, dirs.done]) {
     try {
-      return JSON.parse(fs16.readFileSync(path13.join(dir, id, "claim.json"), "utf8"));
+      return JSON.parse(fs21.readFileSync(path17.join(dir, id, "claim.json"), "utf8"));
     } catch {
     }
   }
@@ -2190,7 +2497,7 @@ function isUnresumable(error) {
   return error !== void 0 && UNRESUMABLE.test(error);
 }
 function worktreeProgress(worktree, trunk) {
-  if (!worktree || !fs16.existsSync(worktree))
+  if (!worktree || !fs21.existsSync(worktree))
     return "No worktree progress recorded.";
   const git2 = (...a) => spawnSync2("git", a, { cwd: worktree, encoding: "utf8" }).stdout?.trim() ?? "";
   const commits = trunk ? git2("log", "--oneline", `origin/${trunk}..HEAD`) : git2("log", "--oneline", "-15");
@@ -2223,44 +2530,44 @@ function handoffNote(fromHarness, progress, why) {
 ${progress}`;
 }
 function codexHome(env = process.env) {
-  return env.CODEX_HOME ?? path13.join(os3.homedir(), ".codex");
+  return env.CODEX_HOME ?? path17.join(os3.homedir(), ".codex");
 }
 function codexRolloutFile(threadId, home = codexHome()) {
   const suffix = `-${threadId}.jsonl`;
   const walk = (dir, depth) => {
     let entries;
     try {
-      entries = fs16.readdirSync(dir, { withFileTypes: true });
+      entries = fs21.readdirSync(dir, { withFileTypes: true });
     } catch {
       return void 0;
     }
     for (const e of entries) {
       if (e.isFile() && e.name.startsWith("rollout-") && e.name.endsWith(suffix))
-        return path13.join(dir, e.name);
+        return path17.join(dir, e.name);
     }
     if (depth === 0)
       return void 0;
     for (const e of entries.filter((x) => x.isDirectory()).sort((a, b) => b.name.localeCompare(a.name))) {
-      const hit = walk(path13.join(dir, e.name), depth - 1);
+      const hit = walk(path17.join(dir, e.name), depth - 1);
       if (hit)
         return hit;
     }
     return void 0;
   };
-  return walk(path13.join(home, "sessions"), 3) ?? walk(path13.join(home, "archived_sessions"), 0);
+  return walk(path17.join(home, "sessions"), 3) ?? walk(path17.join(home, "archived_sessions"), 0);
 }
 function codexDesktopThread(threadId, home = codexHome()) {
-  const file = codexRolloutFile(threadId, home);
-  if (!file)
+  const file2 = codexRolloutFile(threadId, home);
+  if (!file2)
     return void 0;
   let head = "";
   try {
-    const fd = fs16.openSync(file, "r");
+    const fd = fs21.openSync(file2, "r");
     try {
       const buf = Buffer.alloc(4096);
-      head = buf.subarray(0, fs16.readSync(fd, buf, 0, buf.length, 0)).toString("utf8");
+      head = buf.subarray(0, fs21.readSync(fd, buf, 0, buf.length, 0)).toString("utf8");
     } finally {
-      fs16.closeSync(fd);
+      fs21.closeSync(fd);
     }
   } catch {
     return void 0;
@@ -2290,18 +2597,9 @@ function droppedModelNote(harness, dropped) {
   return `model ${dropped.model} is a ${dropped.owner} model \u2014 dropped, using ${harness}'s default`;
 }
 
-// packages/core/dist/slots.js
-function isTrapCatch(id, lane) {
-  return readSessionClaim(id, lane)?.by.startsWith("wt:") ?? false;
-}
-function isFinished(id, lane) {
-  const verb = readStatusLog(id, lane).at(-1)?.verb;
-  return verb !== void 0 && TERMINAL_VERBS.includes(verb);
-}
-
 // packages/runner/src/run.ts
-import * as fs20 from "node:fs";
-import * as path17 from "node:path";
+import * as fs26 from "node:fs";
+import * as path22 from "node:path";
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
@@ -2335,7 +2633,7 @@ var AsyncQueue = class {
           return Promise.resolve({ value: item, done: false });
         if (this.closed)
           return Promise.resolve({ value: void 0, done: true });
-        return new Promise((resolve7) => this.waiters.push(resolve7));
+        return new Promise((resolve9) => this.waiters.push(resolve9));
       }
     };
   }
@@ -2360,7 +2658,7 @@ var InputGate = class {
         return msg;
       if (this.ended)
         return void 0;
-      await new Promise((resolve7) => this.waiter = resolve7);
+      await new Promise((resolve9) => this.waiter = resolve9);
       this.waiter = null;
     }
   }
@@ -2505,20 +2803,20 @@ function startClaudeCli(invocation, opts) {
       }
     }
   });
-  const done = new Promise((resolve7) => {
+  const done = new Promise((resolve9) => {
     child.on("error", (err) => {
       events.push({ at: now(), type: "error", data: { message: err.message } });
       events.close();
-      resolve7({ sessionId, error: err.message });
+      resolve9({ sessionId, error: err.message });
     });
     child.on("exit", (code) => {
       events.close();
       if (code === 0)
-        resolve7({ sessionId });
+        resolve9({ sessionId });
       else {
         const detail = stderrTail.trim().split("\n").at(-1);
         const error = `claude exited ${code}${detail ? ` \u2014 ${detail}` : ""}`;
-        resolve7({ sessionId, error });
+        resolve9({ sessionId, error });
       }
     });
   });
@@ -2597,25 +2895,25 @@ function createClaudeAdapter() {
 }
 
 // packages/adapters/dist/codex.js
-import * as fs17 from "node:fs";
+import * as fs22 from "node:fs";
 import * as os4 from "node:os";
-import * as path14 from "node:path";
+import * as path18 from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 function isolatedCodexHome() {
-  const dir = path14.join(lobstahHome(), "codex-home");
-  fs17.mkdirSync(dir, { recursive: true });
-  const auth = path14.join(dir, "auth.json");
-  const realAuth = path14.join(os4.homedir(), ".codex", "auth.json");
-  if (!fs17.existsSync(auth) && fs17.existsSync(realAuth)) {
+  const dir = path18.join(lobstahHome(), "codex-home");
+  fs22.mkdirSync(dir, { recursive: true });
+  const auth = path18.join(dir, "auth.json");
+  const realAuth = path18.join(os4.homedir(), ".codex", "auth.json");
+  if (!fs22.existsSync(auth) && fs22.existsSync(realAuth)) {
     try {
-      fs17.symlinkSync(realAuth, auth);
+      fs22.symlinkSync(realAuth, auth);
     } catch {
-      fs17.copyFileSync(realAuth, auth);
+      fs22.copyFileSync(realAuth, auth);
     }
   }
-  const cfg = path14.join(dir, "config.toml");
-  if (!fs17.existsSync(cfg)) {
-    fs17.writeFileSync(cfg, "# lobstah-managed: auth inherited from ~/.codex, interactive config not\n");
+  const cfg = path18.join(dir, "config.toml");
+  if (!fs22.existsSync(cfg)) {
+    fs22.writeFileSync(cfg, "# lobstah-managed: auth inherited from ~/.codex, interactive config not\n");
   }
   return dir;
 }
@@ -2667,7 +2965,7 @@ function startCodexCli(invoke, opts) {
   let current;
   let killed = false;
   function runTurn(prompt, resumeThread) {
-    return new Promise((resolve7) => {
+    return new Promise((resolve9) => {
       const inv = invoke(codexExecArgs(opts, prompt, resumeThread));
       const child = spawn2(inv.file, inv.argv, {
         cwd: opts.cwd,
@@ -2698,14 +2996,14 @@ function startCodexCli(invoke, opts) {
           }
         }
       });
-      child.on("error", (err) => resolve7(err.message));
+      child.on("error", (err) => resolve9(err.message));
       child.on("exit", (code) => {
         if (turnError)
-          return resolve7(turnError);
+          return resolve9(turnError);
         if (code === 0 || killed)
-          return resolve7(void 0);
+          return resolve9(void 0);
         const detail = stderrTail.trim().split("\n").at(-1);
-        resolve7(`codex exited ${code}${detail ? ` \u2014 ${detail}` : ""}`);
+        resolve9(`codex exited ${code}${detail ? ` \u2014 ${detail}` : ""}`);
       });
     });
   }
@@ -2818,15 +3116,256 @@ function loadAdapter(name) {
 }
 
 // packages/worktree/dist/index.js
-import * as fs18 from "node:fs";
-import * as path15 from "node:path";
+import * as fs24 from "node:fs";
+import * as path20 from "node:path";
 import { createHash } from "node:crypto";
-import { exec, execFile, execFileSync } from "node:child_process";
+import { exec, execFile as execFile2, execFileSync } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+
+// packages/worktree/dist/pool.js
+import * as fs23 from "node:fs";
+import * as path19 from "node:path";
+import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 var run = promisify(execFile);
-var shell = promisify(exec);
+var DEFAULT_POOL_KEEP = [
+  // dependencies
+  "node_modules/",
+  ".pnpm-store/",
+  ".venv/",
+  "vendor/bundle/",
+  "Pods/",
+  // build caches
+  ".turbo/",
+  ".next/cache/",
+  ".nx/cache/",
+  ".cache/",
+  "*.tsbuildinfo",
+  "target/",
+  ".gradle/",
+  ".build/",
+  // local env files
+  ".env*",
+  ".dev.vars"
+];
+var PRODUCTION_ENV_PATHSPEC = ":(glob,icase)**/.env*prod*";
+function poolKeep(repo) {
+  return [.../* @__PURE__ */ new Set([...DEFAULT_POOL_KEEP, ...repo.poolKeep ?? []])];
+}
+async function poolUnsafe(repo, dir) {
+  const status = await tryGit(dir, "status", "--porcelain");
+  if (!status.ok)
+    return `cannot read git status: ${status.err.split("\n")[0]}`;
+  if (!onlyScratch(status.out, repo.scratch)) {
+    const lines = status.out.split("\n").filter((l) => l.trim() !== "");
+    const paths = lines.map((l) => l.slice(3));
+    return `uncommitted changes in ${lines.length} file(s): ${paths.slice(0, 3).join(", ")}${paths.length > 3 ? `, and ${paths.length - 3} more` : ""}`;
+  }
+  const unpushed = await tryGit(dir, "rev-list", "--count", "HEAD", "--not", "--remotes");
+  if (!unpushed.ok)
+    return `cannot tell which commits are on a remote: ${unpushed.err.split("\n")[0]}`;
+  const n = Number(unpushed.out);
+  if (!Number.isFinite(n))
+    return "cannot tell which commits are on a remote";
+  if (n > 0)
+    return `${n} commit(s) on no remote branch`;
+  return void 0;
+}
+function takeOut(name, pool, slot, reason, dispatch, notice = true) {
+  const label = poolSlotLabel(name, slot);
+  writeSlotOut(name, slot, { reason, at: (/* @__PURE__ */ new Date()).toISOString(), ...dispatch ? { dispatch } : {} });
+  if (!notice)
+    return;
+  postNotice({
+    kind: "pool-out",
+    text: `pool worktree ${label} (${poolSlotPath(name, slot)}) is out of rotation: ${reason}` + (dispatch ? ` (last used by ${dispatch.slice(0, 8)})` : "") + " \u2014 commit and push or discard the work there; the pool takes it back once it is clean and pushed",
+    refId: label,
+    repo: pool.repo
+  });
+}
+function trapIn(dir) {
+  const real = (p) => {
+    try {
+      return fs23.realpathSync.native(p);
+    } catch {
+      return path19.resolve(p);
+    }
+  };
+  const here = real(dir);
+  return listTraps().some((t) => {
+    if (typeof t.worktree !== "string")
+      return false;
+    const rel = path19.relative(here, real(t.worktree));
+    return rel === "" || !rel.startsWith("..") && !path19.isAbsolute(rel);
+  });
+}
+async function claimPoolSlot(input) {
+  const { name, pool, repo, id, lane } = input;
+  const refused = [];
+  for (let slot = 1; slot <= pool.size; slot++) {
+    const dir = poolSlotPath(name, slot);
+    if (fs23.existsSync(dir) && readWorktreeLock(dir)?.id === id && readWorktreeLock(dir)?.kind !== "warm") {
+      writeSlotClaim(name, slot, { id, lane, at: (/* @__PURE__ */ new Date()).toISOString() });
+      return { claimed: true, dir, slot, label: poolSlotLabel(name, slot) };
+    }
+  }
+  const deadline = Date.now() + (input.warmWaitMs ?? 6e4);
+  for (; ; ) {
+    let warmHeld = false;
+    for (let slot = 1; slot <= pool.size; slot++) {
+      if (poolSlotView(name, slot).state !== "free")
+        continue;
+      const dir = poolSlotPath(name, slot);
+      if (trapIn(dir))
+        continue;
+      const held = acquireWorktreeLock(dir, id, lane);
+      if (held) {
+        if (held.kind === "warm")
+          warmHeld = true;
+        continue;
+      }
+      const why = await poolUnsafe(repo, dir);
+      if (why) {
+        takeOut(name, pool, slot, why, readSlotClaim(name, slot)?.id);
+        releaseWorktreeLock(dir, id);
+        refused.push(`${poolSlotLabel(name, slot)}: ${why}`);
+        continue;
+      }
+      writeSlotClaim(name, slot, { id, lane, at: (/* @__PURE__ */ new Date()).toISOString() });
+      return { claimed: true, dir, slot, label: poolSlotLabel(name, slot) };
+    }
+    if (!warmHeld || Date.now() >= deadline)
+      return { claimed: false, refused };
+    await new Promise((r) => setTimeout(r, 500));
+  }
+}
+async function resetPoolWorktree(repo, dir, id, fromRemoteBranch = repo.trunk) {
+  await fetchShared(repo.path, "origin", fromRemoteBranch);
+  await oneAtATime(repo.path, async () => {
+    await gitShared(dir, "checkout", "--quiet", "--force", "--no-track", "-B", `lobstah/${id}`, `origin/${fromRemoteBranch}`);
+  });
+  const keep = poolKeep(repo);
+  await run("git", ["clean", "-ffdxq", ...keep.flatMap((p) => ["-e", p])], { cwd: dir, env: process.env });
+  const dirs = keep.filter((p) => p.endsWith("/"));
+  await run("git", ["clean", "-ffdxq", ...dirs.flatMap((p) => ["-e", p]), "--", PRODUCTION_ENV_PATHSPEC], { cwd: dir, env: process.env });
+  await runSetup(repo, dir);
+}
+var WARM_ID = "pool-warm";
+async function createSlot(repo, dir) {
+  fs23.mkdirSync(path19.dirname(dir), { recursive: true });
+  await oneAtATime(repo.path, async () => {
+    await tryGit(repo.path, "worktree", "prune");
+    await gitShared(repo.path, "worktree", "add", "--detach", dir, `origin/${repo.trunk}`);
+  });
+  await runSetup(repo, dir);
+}
+async function warmPool(name, opts = {}) {
+  const log = opts.log ?? (() => {
+  });
+  const now2 = () => new Date(opts.now?.() ?? Date.now()).toISOString();
+  const cfg = loadConfig();
+  const pool = cfg.pools[name];
+  if (!pool) {
+    log(`pool ${name}: not configured`);
+    return true;
+  }
+  const repo = cfg.repos[pool.repo];
+  const release = takePoolWarmLock(name);
+  if (!release)
+    return false;
+  try {
+    if (!fs23.existsSync(repo.path)) {
+      if (!repo.origin)
+        throw new Error(`repo path ${repo.path} missing and no origin configured`);
+      await run("git", ["clone", repo.origin, repo.path], { env: process.env });
+    }
+    await fetchShared(repo.path, "origin", repo.trunk);
+    writePoolWarmState(name, { ...readPoolWarmState(name), fetchedAt: now2() });
+    const need = (cfg.limits.minFreeGB ?? 0) * GB;
+    const read2 = opts.freeBytes ?? statfsFreeBytes;
+    for (let slot = 1; slot <= pool.size; slot++) {
+      const dir = poolSlotPath(name, slot);
+      const label = poolSlotLabel(name, slot);
+      const meta = readSlotMeta(name, slot);
+      if (!fs23.existsSync(dir)) {
+        fs23.mkdirSync(poolsRoot(), { recursive: true });
+        let free = Infinity;
+        try {
+          free = need > 0 ? read2(poolsRoot()) : Infinity;
+        } catch {
+        }
+        if (free < need) {
+          const error = `not created: ${formatGB(free)} free, needs ${formatGB(need)} ([limits].minFreeGB)`;
+          writeSlotMeta(name, slot, { ...meta, error, errorAt: now2() });
+          log(`pool ${label}: ${error}`);
+          continue;
+        }
+        try {
+          await createSlot(repo, dir);
+          writeSlotMeta(name, slot, { readyAt: now2() });
+          log(`pool ${label}: created at ${dir}`);
+        } catch (err) {
+          const error = `create failed: ${err instanceof Error ? err.message.split("\n")[0] : String(err)}`.slice(0, 300);
+          writeSlotMeta(name, slot, { ...meta, error, errorAt: now2() });
+          log(`pool ${label}: ${error}`);
+        }
+        continue;
+      }
+      if (trapIn(dir))
+        continue;
+      const held = acquireWorktreeLock(dir, WARM_ID, "work", "warm");
+      if (held)
+        continue;
+      try {
+        if (!meta.readyAt) {
+          try {
+            await runSetup(repo, dir);
+            writeSlotMeta(name, slot, { readyAt: now2() });
+            log(`pool ${label}: setup finished`);
+          } catch (err) {
+            const error = `setup failed: ${err instanceof Error ? err.message.split("\n")[0] : String(err)}`.slice(0, 300);
+            writeSlotMeta(name, slot, { ...meta, error, errorAt: now2() });
+            log(`pool ${label}: ${error}`);
+          }
+          continue;
+        }
+        const claim = readSlotClaim(name, slot);
+        const out = readSlotOut(name, slot);
+        if (!out && (!claim || claim.id === meta.verifiedClaim))
+          continue;
+        const why = await poolUnsafe(repo, dir);
+        if (why) {
+          if (!out) {
+            takeOut(name, pool, slot, why, claim?.id);
+            log(`pool ${label}: out of rotation \u2014 ${why}`);
+          } else if (out.reason !== why) {
+            takeOut(name, pool, slot, why, out.dispatch ?? claim?.id, false);
+          }
+          writeSlotMeta(name, slot, { ...meta, checkedAt: now2() });
+          continue;
+        }
+        if (out) {
+          clearSlotOut(name, slot);
+          postNotice({ kind: "pool-returned", text: `pool worktree ${label} is back in rotation: clean and pushed`, refId: label, repo: pool.repo, quiet: true });
+          log(`pool ${label}: back in rotation`);
+        }
+        writeSlotMeta(name, slot, { ...meta, ...claim ? { verifiedClaim: claim.id } : {}, checkedAt: now2() });
+      } finally {
+        releaseWorktreeLock(dir, WARM_ID);
+      }
+    }
+    writePoolWarmState(name, { ...readPoolWarmState(name), finishedAt: now2() });
+    return true;
+  } finally {
+    release();
+  }
+}
+
+// packages/worktree/dist/index.js
+var run2 = promisify2(execFile2);
+var shell = promisify2(exec);
 async function git(cwd, ...args) {
-  const { stdout } = await run("git", args, { cwd, env: process.env });
+  const { stdout } = await run2("git", args, { cwd, env: process.env });
   return stdout.trim();
 }
 var LOCK_CONTENTION = [
@@ -2881,7 +3420,7 @@ ${gitStderr(err)}`, { cause: err });
 }
 var REPO_LOCK_WAIT_MS = 5 * 6e4;
 var repoQueues = /* @__PURE__ */ new Map();
-function pidAlive(pid) {
+function pidAlive2(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -2890,9 +3429,9 @@ function pidAlive(pid) {
   }
 }
 var BUSY = /* @__PURE__ */ new Set(["EPERM", "EACCES", "EBUSY"]);
-function takeRepoLock(file, mine) {
+function takeRepoLock(file2, mine) {
   try {
-    fs18.writeFileSync(file, mine, { flag: "wx" });
+    fs24.writeFileSync(file2, mine, { flag: "wx" });
     return { state: "held" };
   } catch (err) {
     const code = err.code ?? "";
@@ -2902,8 +3441,8 @@ function takeRepoLock(file, mine) {
   let raw = "";
   let age = 0;
   try {
-    raw = fs18.readFileSync(file, "utf8");
-    age = Date.now() - fs18.statSync(file).mtimeMs;
+    raw = fs24.readFileSync(file2, "utf8");
+    age = Date.now() - fs24.statSync(file2).mtimeMs;
   } catch {
     return { state: "retry" };
   }
@@ -2913,31 +3452,31 @@ function takeRepoLock(file, mine) {
   } catch {
     holder = void 0;
   }
-  const stale = age > REPO_LOCK_WAIT_MS || (holder ? !pidAlive(holder.pid) : age > 5e3);
+  const stale = age > REPO_LOCK_WAIT_MS || (holder ? !pidAlive2(holder.pid) : age > 5e3);
   if (stale) {
     try {
-      if (fs18.readFileSync(file, "utf8") === raw)
-        fs18.rmSync(file, { force: true });
+      if (fs24.readFileSync(file2, "utf8") === raw)
+        fs24.rmSync(file2, { force: true });
     } catch {
     }
     return { state: "retry" };
   }
   return { state: "wait", ...holder ? { holder: holder.pid } : {} };
 }
-function releaseRepoLock(file, mine) {
+function releaseRepoLock(file2, mine) {
   try {
-    if (fs18.readFileSync(file, "utf8") === mine)
-      fs18.rmSync(file, { force: true, recursive: true, maxRetries: 5 });
+    if (fs24.readFileSync(file2, "utf8") === mine)
+      fs24.rmSync(file2, { force: true, recursive: true, maxRetries: 5 });
   } catch {
   }
 }
 async function withRepoLock(common, fn) {
-  const file = path15.join(common, "lobstah-git.lock");
+  const file2 = path20.join(common, "lobstah-git.lock");
   const mine = JSON.stringify({ pid: process.pid, at: (/* @__PURE__ */ new Date()).toISOString() });
   const deadline = Date.now() + REPO_LOCK_WAIT_MS;
   let held = false;
   while (Date.now() < deadline) {
-    const took = takeRepoLock(file, mine);
+    const took = takeRepoLock(file2, mine);
     if (took.state === "held") {
       held = true;
       break;
@@ -2949,18 +3488,18 @@ async function withRepoLock(common, fn) {
     await fn();
   } finally {
     if (held)
-      releaseRepoLock(file, mine);
+      releaseRepoLock(file2, mine);
   }
 }
 async function oneAtATime(cwd, fn) {
   const common = await git(cwd, "rev-parse", "--path-format=absolute", "--git-common-dir");
   const key = realpath(common);
-  const run2 = (repoQueues.get(key) ?? Promise.resolve()).then(() => withRepoLock(common, () => fn(common)));
-  const tail = run2.catch(() => {
+  const run3 = (repoQueues.get(key) ?? Promise.resolve()).then(() => withRepoLock(common, () => fn(common)));
+  const tail = run3.catch(() => {
   });
   repoQueues.set(key, tail);
   try {
-    await run2;
+    await run3;
   } finally {
     if (repoQueues.get(key) === tail)
       repoQueues.delete(key);
@@ -2968,7 +3507,7 @@ async function oneAtATime(cwd, fn) {
 }
 function fetchStamps(common) {
   try {
-    return JSON.parse(fs18.readFileSync(path15.join(common, "lobstah-fetch.json"), "utf8"));
+    return JSON.parse(fs24.readFileSync(path20.join(common, "lobstah-fetch.json"), "utf8"));
   } catch {
     return {};
   }
@@ -2982,18 +3521,18 @@ async function fetchShared(cwd, remote, ref) {
     const started = Date.now();
     await gitShared(cwd, "fetch", remote, ref);
     const stamps = { ...fetchStamps(common), [key]: started };
-    fs18.writeFileSync(path15.join(common, "lobstah-fetch.json"), JSON.stringify(stamps, null, 2));
+    fs24.writeFileSync(path20.join(common, "lobstah-fetch.json"), JSON.stringify(stamps, null, 2));
   });
 }
 async function allocate(repo, id, fromRemoteBranch = repo.trunk) {
   const dir = worktreePath(id);
-  if (fs18.existsSync(dir)) {
+  if (fs24.existsSync(dir)) {
     throw new Error(`worktree for ${id} already exists at ${dir} \u2014 never allocate a second`);
   }
-  if (!fs18.existsSync(repo.path)) {
+  if (!fs24.existsSync(repo.path)) {
     if (!repo.origin)
       throw new Error(`repo path ${repo.path} missing and no origin configured`);
-    await run("git", ["clone", repo.origin, repo.path], { env: process.env });
+    await run2("git", ["clone", repo.origin, repo.path], { env: process.env });
   }
   await fetchShared(repo.path, "origin", fromRemoteBranch);
   await oneAtATime(repo.path, async () => {
@@ -3005,7 +3544,7 @@ async function allocate(repo, id, fromRemoteBranch = repo.trunk) {
 async function recoverWorktree(repo, id) {
   const dir = worktreePath(id);
   try {
-    if (fs18.statSync(path15.join(dir, ".git")).isFile()) {
+    if (fs24.statSync(path20.join(dir, ".git")).isFile()) {
       const branch = await git(dir, "symbolic-ref", "--quiet", "HEAD");
       const root = await git(dir, "rev-parse", "--show-toplevel");
       const common = await git(dir, "rev-parse", "--path-format=absolute", "--git-common-dir");
@@ -3043,38 +3582,42 @@ function setupHash(repo, dir) {
   const h = createHash("sha256");
   h.update(JSON.stringify(repo.setup ?? []));
   for (const name of LOCKFILES) {
-    const file = path15.join(dir, name);
-    if (!fs18.existsSync(file))
+    const file2 = path20.join(dir, name);
+    if (!fs24.existsSync(file2))
       continue;
     h.update(`\0${name}\0`);
-    h.update(fs18.readFileSync(file));
+    h.update(fs24.readFileSync(file2));
   }
   return h.digest("hex");
 }
 function setupRecordFile(dir) {
   const gitDir = worktreeGitDir(dir);
-  return gitDir ? path15.join(gitDir, "lobstah-setup.json") : void 0;
+  return gitDir ? path20.join(gitDir, "lobstah-setup.json") : void 0;
 }
 function recordSetup(repo, dir) {
-  const file = setupRecordFile(dir);
-  if (file)
-    fs18.writeFileSync(file, JSON.stringify({ hash: setupHash(repo, dir), at: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
+  const file2 = setupRecordFile(dir);
+  if (file2)
+    fs24.writeFileSync(file2, JSON.stringify({ hash: setupHash(repo, dir), at: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
 }
 function recordedSetupHash(dir) {
-  const file = setupRecordFile(dir);
+  const file2 = setupRecordFile(dir);
   try {
-    return file ? JSON.parse(fs18.readFileSync(file, "utf8")).hash : void 0;
+    return file2 ? JSON.parse(fs24.readFileSync(file2, "utf8")).hash : void 0;
   } catch {
     return void 0;
   }
 }
 var short = (s) => s.slice(0, 8);
+function poolReused(slot, by) {
+  const label = poolSlotLabel(slot.pool, slot.slot);
+  return by ? `origin pool worktree ${label} was reused by ${short(by)}` : `origin pool worktree ${label} cannot be traced to it`;
+}
 function realpath(p) {
   let r;
   try {
-    r = fs18.realpathSync.native(p);
+    r = fs24.realpathSync.native(p);
   } catch {
-    r = path15.resolve(p);
+    r = path20.resolve(p);
   }
   return process.platform === "win32" ? r.toLowerCase() : r;
 }
@@ -3112,12 +3655,18 @@ async function chooseWorktree(input) {
   } catch {
     return { reuse: false, reason: "origin worktree is not a readable git checkout" };
   }
+  const slot = poolSlotOf(found.path);
+  if (slot) {
+    const claim = readSlotClaim(slot.pool, slot.slot);
+    if (claim?.id !== found.from && claim?.id !== id)
+      return { reuse: false, reason: poolReused(slot, claim?.id) };
+  }
   const here = realpath(found.path);
   for (const t of listTraps()) {
     if (typeof t.worktree !== "string")
       continue;
-    const rel = path15.relative(here, realpath(t.worktree));
-    if (!rel.startsWith("..") && !path15.isAbsolute(rel))
+    const rel = path20.relative(here, realpath(t.worktree));
+    if (!rel.startsWith("..") && !path20.isAbsolute(rel))
       return { reuse: false, reason: "origin worktree is a trap\u2019s" };
   }
   for (const l of ["work", "chore"]) {
@@ -3144,6 +3693,14 @@ async function chooseWorktree(input) {
   const held = acquireWorktreeLock(found.path, id, lane);
   if (held)
     return { reuse: false, reason: `origin worktree is in use by ${short(held.id)}` };
+  if (slot) {
+    const claim = readSlotClaim(slot.pool, slot.slot);
+    if (claim?.id !== found.from && claim?.id !== id) {
+      releaseWorktreeLock(found.path, id);
+      return { reuse: false, reason: poolReused(slot, claim?.id) };
+    }
+    writeSlotClaim(slot.pool, slot.slot, { id, lane, at: (/* @__PURE__ */ new Date()).toISOString() });
+  }
   return { reuse: true, path: found.path, owner: found.owner, from: found.from };
 }
 async function prepareReuse(repo, dir) {
@@ -3160,6 +3717,14 @@ async function collectEvidence(repo, dir) {
   const log = await git(dir, "log", "--oneline", `origin/${repo.trunk}..HEAD`);
   return { branch, commits: log ? log.split("\n") : [] };
 }
+async function tryGit(cwd, ...args) {
+  try {
+    const { stdout, stderr } = await run2("git", args, { cwd, env: process.env });
+    return { ok: true, out: stdout.trimEnd(), err: stderr.trim() };
+  } catch (e) {
+    return { ok: false, out: (e.stdout ?? "").trim(), err: gitStderr(e) };
+  }
+}
 
 // packages/runner/src/contract.ts
 function buildPrompt(brief, opts) {
@@ -3199,16 +3764,16 @@ async function* until(source, stop) {
     yield next.value;
   }
 }
-var sleep = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
-function deliver(run2, id, lane) {
+var sleep = (ms) => new Promise((resolve9) => setTimeout(resolve9, ms));
+function deliver(run3, id, lane) {
   const msgs = unhandled(id, lane);
   for (const m of msgs) {
-    run2.send(m.text);
+    run3.send(m.text);
     acknowledge(id, lane, m.file);
   }
   return msgs.length;
 }
-async function drive(run2, opts) {
+async function drive(run3, opts) {
   const {
     id,
     lane,
@@ -3229,12 +3794,12 @@ async function drive(run2, opts) {
   let cancelled = false;
   let activity = 0;
   let finished = false;
-  void run2.done.then(() => finished = true);
+  void run3.done.then(() => finished = true);
   let killed = false;
   const kill = () => {
     if (killed) return;
     killed = true;
-    run2.kill();
+    run3.kill();
   };
   const cancel = () => {
     cancelled = true;
@@ -3245,7 +3810,7 @@ async function drive(run2, opts) {
   let finalAt = 0;
   let exit;
   let abandon;
-  const abandoned = new Promise((resolve7) => abandon = resolve7);
+  const abandoned = new Promise((resolve9) => abandon = resolve9);
   const clearExit = () => {
     if (!exit) return;
     clearInterval(exit.poll);
@@ -3273,7 +3838,7 @@ async function drive(run2, opts) {
       opts.onFinal?.();
     }
     finalAt = Date.now();
-    run2.end();
+    run3.end();
     const poll = setInterval(() => {
       if (cancelRequested(id, lane)) stopHarness("cancel");
     }, Math.min(pollMs, exitGraceMs));
@@ -3290,7 +3855,7 @@ async function drive(run2, opts) {
     while (true) {
       if (stopped() || finished) return;
       if (cancelRequested(id, lane)) return cancel();
-      if (deliver(run2, id, lane) > 0) return answered(verb);
+      if (deliver(run3, id, lane) > 0) return answered(verb);
       touchEvents(id, lane);
       await sleep(pollMs);
     }
@@ -3309,11 +3874,11 @@ async function drive(run2, opts) {
     if (!nudged) {
       nudged = true;
       runnerEvent({ nudged: "unreported" });
-      run2.send(unreportedNudge(id));
+      run3.send(unreportedNudge(id));
       return;
     }
     appendStatus(id, lane, "failed", "ended without reporting a result, after being asked to");
-    run2.end();
+    run3.end();
   };
   const holdOpen = (ms) => {
     releaseHold();
@@ -3332,7 +3897,7 @@ async function drive(run2, opts) {
     }, ms);
     hold = { heartbeat, expiry };
   };
-  for await (const ev of until(run2.events, abandoned)) {
+  for await (const ev of until(run3.events, abandoned)) {
     record(ev);
     if (ev.type === "background") {
       liveBackground = Number(ev.data?.live ?? 0);
@@ -3362,7 +3927,7 @@ async function drive(run2, opts) {
       continue;
     }
     const waiting = lastVerb !== void 0 && WAITING_VERBS.includes(lastVerb);
-    if (deliver(run2, id, lane) > 0) {
+    if (deliver(run3, id, lane) > 0) {
       if (waiting) answered(lastVerb);
       continue;
     }
@@ -3376,7 +3941,7 @@ async function drive(run2, opts) {
     }
     const subtype = ev.data?.subtype;
     if (subtype !== void 0 && subtype !== "success") {
-      run2.end();
+      run3.end();
       continue;
     }
     if (liveBackground > 0) {
@@ -3526,18 +4091,18 @@ function startWallClock(opts) {
 }
 
 // packages/runner/src/remote.ts
-import { execFile as execFile2 } from "node:child_process";
-import { promisify as promisify2 } from "node:util";
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
 import { fileURLToPath } from "node:url";
-import * as fs19 from "node:fs";
-import * as path16 from "node:path";
-var exec2 = promisify2(execFile2);
+import * as fs25 from "node:fs";
+import * as path21 from "node:path";
+var exec2 = promisify3(execFile3);
 function firstLine(err) {
   const stderr = err && typeof err === "object" && "stderr" in err ? String(err.stderr).trim() : "";
   return (stderr || (err instanceof Error ? err.message : String(err))).replace(/\s+/g, " ").slice(0, 240);
 }
-function checkpointAllowed(file) {
-  const parts = file.toLowerCase().split("/");
+function checkpointAllowed(file2) {
+  const parts = file2.toLowerCase().split("/");
   const base = parts.at(-1) ?? "";
   if (parts.some((p) => [".git", "node_modules", "dist", "build", "coverage", ".next", ".turbo"].includes(p))) return false;
   if (base === ".env" || base.startsWith(".env.") || base.endsWith(".pem") || base.endsWith(".key") || base.endsWith(".p12")) return false;
@@ -3547,23 +4112,23 @@ function checkpointAllowed(file) {
 function keepRemote(opts) {
   const { id, lane, cwd, trunk, policy, existingPrUrl } = opts;
   const command = async (bin, args, timeout = 12e4) => {
-    const file = bin === "gh" || bin === "lobstah" ? resolveOnPath(bin) ?? bin : bin;
-    return (await exec2(file, args, {
+    const file2 = bin === "gh" || bin === "lobstah" ? resolveOnPath(bin) ?? bin : bin;
+    return (await exec2(file2, args, {
       cwd,
       encoding: "utf8",
       timeout,
       maxBuffer: 4 * 1024 * 1024,
-      shell: process.platform === "win32" && /\.(?:cmd|bat)$/i.test(file)
+      shell: process.platform === "win32" && /\.(?:cmd|bat)$/i.test(file2)
     })).stdout.trim();
   };
   const git2 = (...args) => command("git", args);
   const note = (message) => mergeEvidence(id, lane, { note: message.slice(0, 300) });
   if (existingPrUrl) mergeEvidence(id, lane, { prUrl: existingPrUrl });
   const registerWatch = async (url) => {
-    const root = path16.resolve(path16.dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
-    const localCli = path16.join(root, "apps", "cli", "dist", "main.js");
+    const root = path21.resolve(path21.dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+    const localCli = path21.join(root, "apps", "cli", "dist", "main.js");
     const args = ["watch", "add", url, "--for", id];
-    if (fs19.existsSync(localCli)) await command(process.execPath, [localCli, ...args], 15e3);
+    if (fs25.existsSync(localCli)) await command(process.execPath, [localCli, ...args], 15e3);
     else await command("lobstah", args, 15e3);
   };
   let lastSeenHead;
@@ -3718,13 +4283,15 @@ var defaultDeps = {
   chooseWorktree,
   prepareReuse,
   collectEvidence,
+  claimPool: claimPoolSlot,
+  resetPool: resetPoolWorktree,
   reap: async () => 0,
   prState: livePrState
 };
 var DONE_WAIT_MS = 2e3;
 function within(p, ms, fallback) {
   let timer;
-  const late = new Promise((resolve7) => timer = setTimeout(() => resolve7(fallback), ms));
+  const late = new Promise((resolve9) => timer = setTimeout(() => resolve9(fallback), ms));
   return Promise.race([p, late]).finally(() => clearTimeout(timer));
 }
 var short3 = (s) => s.slice(0, 8);
@@ -3742,16 +4309,16 @@ function coldNote(cold, cwd, trunk) {
 }
 async function main(activeDir, lane, seams = {}) {
   const deps = { ...defaultDeps, ...seams };
-  const id = path17.basename(activeDir);
+  const id = path22.basename(activeDir);
   if (isTrapCatch(id, lane)) throw new Error(`refusing headless runner for trap catch ${id}`);
   const status = (verb, note) => appendStatus(id, lane, verb, note);
   const cfg = loadConfig();
-  const descriptor = JSON.parse(fs20.readFileSync(path17.join(activeDir, "descriptor.json"), "utf8"));
+  const descriptor = JSON.parse(fs26.readFileSync(path22.join(activeDir, "descriptor.json"), "utf8"));
   const resolved = resolveDispatch(descriptor, cfg);
   const repo = cfg.repos[descriptor.repo];
-  const briefFile = path17.join(activeDir, "brief.md");
-  if (!fs20.existsSync(briefFile)) fs20.writeFileSync(briefFile, descriptor.brief);
-  const brief = fs20.readFileSync(briefFile, "utf8");
+  const briefFile = path22.join(activeDir, "brief.md");
+  if (!fs26.existsSync(briefFile)) fs26.writeFileSync(briefFile, descriptor.brief);
+  const brief = fs26.readFileSync(briefFile, "utf8");
   const attempts = Number(process.env.LOBSTAH_ATTEMPTS ?? "1");
   const wake = process.env.LOBSTAH_WAKE;
   const runnerInfo = {
@@ -3759,7 +4326,7 @@ async function main(activeDir, lane, seams = {}) {
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     attempts
   };
-  fs20.writeFileSync(path17.join(activeDir, "runner.json"), JSON.stringify(runnerInfo, null, 2));
+  fs26.writeFileSync(path22.join(activeDir, "runner.json"), JSON.stringify(runnerInfo, null, 2));
   if (descriptor.systemRepair && descriptor.pr?.url) {
     const state = deps.prState(descriptor.pr.url) ?? readPr(parsePrRef(descriptor.pr.url)?.key ?? "")?.state;
     if (state === "MERGED" || state === "CLOSED") {
@@ -3776,20 +4343,46 @@ async function main(activeDir, lane, seams = {}) {
     resolvedHarness: resolved.harness,
     envResume: process.env.LOBSTAH_RESUME
   });
-  const wtFile = path17.join(activeDir, "worktree.json");
+  const wtFile = path22.join(activeDir, "worktree.json");
   let recorded;
   let recovered = false;
   let choice3;
-  if (fs20.existsSync(wtFile)) {
-    recorded = JSON.parse(fs20.readFileSync(wtFile, "utf8")).path;
-    if (!fs20.existsSync(recorded)) throw new Error(`recorded worktree ${recorded} is gone`);
-  } else if (fs20.existsSync(worktreePath(id))) {
+  if (fs26.existsSync(wtFile)) {
+    recorded = JSON.parse(fs26.readFileSync(wtFile, "utf8")).path;
+    if (!fs26.existsSync(recorded)) throw new Error(`recorded worktree ${recorded} is gone`);
+  } else if (fs26.existsSync(worktreePath(id))) {
     recorded = await recoverWorktree(repo, id);
     recovered = true;
   } else if (descriptor.followUp && cfg.limits.reuseWorktree !== false) {
     choice3 = await deps.chooseWorktree({ id, lane, repoKey: descriptor.repo, repo, followUp: descriptor.followUp });
   }
-  const worktreeNote = choice3 ? choice3.reuse ? `reusing worktree of ${short3(choice3.from)}` : `fresh worktree (${choice3.reason})` : recovered ? "recovered own unrecorded worktree" : void 0;
+  let poolClaim;
+  let poolNote;
+  if (!recorded && !choice3?.reuse && descriptor.pool) {
+    const pool = cfg.pools[descriptor.pool];
+    if (!pool) throw new Error(`unknown pool "${descriptor.pool}" \u2014 add [pools.${descriptor.pool}] to ${configPath()}`);
+    if (pool.repo !== descriptor.repo) throw new Error(`pool ${descriptor.pool} serves repo ${pool.repo}, not ${descriptor.repo}`);
+    const got = await deps.claimPool({ name: descriptor.pool, pool, repo, id, lane });
+    if (got.claimed) {
+      poolClaim = got;
+      poolNote = `pool worktree ${got.label}`;
+    } else if (pool.overflow === "queue") {
+      if (cancelRequested(id, lane)) {
+        status("failed", `cancelled by request while waiting for a pool ${descriptor.pool} worktree`);
+        complete(id, lane);
+        return;
+      }
+      requeue(id, lane);
+      console.log(`[runner] pool ${descriptor.pool} has no free worktree: back in the queue`);
+      return;
+    } else {
+      poolNote = `pool ${descriptor.pool} full${got.refused.length ? ` (${got.refused.join("; ")})` : ""}: cold worktree`;
+    }
+  }
+  const worktreeNote = [
+    choice3 ? choice3.reuse ? `reusing worktree of ${short3(choice3.from)}` : `fresh worktree (${choice3.reason})` : recovered ? "recovered own unrecorded worktree" : void 0,
+    poolNote
+  ].filter(Boolean).join("; ") || void 0;
   const firstModel = modelForHarness(plan.harness, resolved.model);
   const firstNote = [
     wake ? `woke from pause: ${wake}` : attempts > 1 ? `attempt ${attempts}` : void 0,
@@ -3812,7 +4405,7 @@ async function main(activeDir, lane, seams = {}) {
     if (held) throw new Error(`worktree at ${cwd} is in use by ${held.id} \u2014 wait for that dispatch to release it before retrying`);
     if (recovered) {
       await deps.prepareReuse(repo, cwd);
-      fs20.writeFileSync(wtFile, JSON.stringify({ path: cwd }, null, 2));
+      fs26.writeFileSync(wtFile, JSON.stringify({ path: cwd }, null, 2));
     }
   } else if (choice3?.reuse) {
     cwd = choice3.path;
@@ -3823,14 +4416,19 @@ async function main(activeDir, lane, seams = {}) {
       type: "runner",
       data: { worktree: cwd, worktreeOf: choice3.owner, setupRan }
     });
-    fs20.writeFileSync(wtFile, JSON.stringify({ path: cwd, of: choice3.owner }, null, 2));
+    fs26.writeFileSync(wtFile, JSON.stringify({ path: cwd, of: choice3.owner }, null, 2));
+  } else if (poolClaim) {
+    cwd = poolClaim.dir;
+    await deps.resetPool(repo, cwd, id, descriptor.systemRepair ? descriptor.pr?.headRefName : void 0);
+    fs26.writeFileSync(wtFile, JSON.stringify({ path: cwd, pool: poolClaim.label }, null, 2));
   } else {
     cwd = await deps.allocate(repo, id, descriptor.systemRepair ? descriptor.pr?.headRefName : void 0);
     acquireWorktreeLock(cwd, id, lane);
-    fs20.writeFileSync(wtFile, JSON.stringify({ path: cwd }, null, 2));
+    fs26.writeFileSync(wtFile, JSON.stringify({ path: cwd }, null, 2));
   }
-  const worktreeOf = JSON.parse(fs20.readFileSync(wtFile, "utf8")).of;
-  mergeEvidence(id, lane, { worktree: cwd, worktreeOf });
+  const worktreeOf = JSON.parse(fs26.readFileSync(wtFile, "utf8")).of;
+  const inPool = poolSlotOf(cwd);
+  mergeEvidence(id, lane, { worktree: cwd, worktreeOf, ...inPool ? { pool: poolSlotLabel(inPool.pool, inPool.slot) } : {} });
   const existingPr = boundPr(descriptor, lane);
   if (existingPr) mergeEvidence(id, lane, { prUrl: existingPr.url });
   const remotePolicy = {
@@ -3860,14 +4458,14 @@ async function main(activeDir, lane, seams = {}) {
   const envNudge = [process.env.LOBSTAH_NUDGE, wakeNote()].filter(Boolean).join("\n\n") || void 0;
   const planNudge = plan.cold && !envNudge ? coldNote(plan.cold, cwd, repo.trunk) : void 0;
   const promptWith = (nudge) => buildPrompt(brief, { id, nudge, attachments: descriptor.attachments, existingPr });
-  const binDir = path17.resolve(path17.dirname(fileURLToPath2(import.meta.url)), "..", "..", "..", "bin");
-  const workerPath = fs20.existsSync(path17.join(binDir, "lobstah")) ? `${binDir}${path17.delimiter}${process.env.PATH ?? ""}` : void 0;
+  const binDir = path22.resolve(path22.dirname(fileURLToPath2(import.meta.url)), "..", "..", "..", "bin");
+  const workerPath = fs26.existsSync(path22.join(binDir, "lobstah")) ? `${binDir}${path22.delimiter}${process.env.PATH ?? ""}` : void 0;
   let wallClockHit = false;
   let current;
-  const wallFile = path17.join(activeDir, "wallclock.json");
+  const wallFile = path22.join(activeDir, "wallclock.json");
   const wallState = (() => {
     try {
-      return JSON.parse(fs20.readFileSync(wallFile, "utf8"));
+      return JSON.parse(fs26.readFileSync(wallFile, "utf8"));
     } catch {
       return { elapsedMs: 0, windowMs: resolved.limits.wallClockSecs * 1e3 };
     }
@@ -3885,9 +4483,9 @@ async function main(activeDir, lane, seams = {}) {
     cfg.limits.maxWallClockSecs ?? (resolved.limits.wallClockSecs ?? 0) * 4
   ) * 1e3;
   const persistWall = (elapsedMs, windowMs) => {
-    const tmp = `${wallFile}.tmp-${process.pid}`;
-    fs20.writeFileSync(tmp, JSON.stringify({ ...wallState, elapsedMs, windowMs }));
-    fs20.renameSync(tmp, wallFile);
+    const tmp = uniqueTempPath(wallFile);
+    fs26.writeFileSync(tmp, JSON.stringify({ ...wallState, elapsedMs, windowMs }));
+    fs26.renameSync(tmp, wallFile);
   };
   const madeProgress = () => {
     const activity = readActivity(id, lane);
@@ -3939,7 +4537,7 @@ async function main(activeDir, lane, seams = {}) {
       model: explicit ? modelForHarness(harness, resolved.model).model : void 0,
       config: { effort: explicit ? resolved.effort : null, permissionMode: explicit && harness === "claude" ? "bypassPermissions" : null }
     }) });
-    const run2 = await deps.loadAdapter(harness).start({
+    const run3 = await deps.loadAdapter(harness).start({
       id,
       cwd,
       prompt,
@@ -3954,8 +4552,8 @@ async function main(activeDir, lane, seams = {}) {
       flags: resolved.flags,
       resumeSession
     });
-    current = run2;
-    const driven = await drive(run2, {
+    current = run3;
+    const driven = await drive(run3, {
       id,
       lane,
       cwd,
@@ -3977,7 +4575,7 @@ async function main(activeDir, lane, seams = {}) {
         }
       });
     }
-    const result = driven.final || parked ? await within(run2.done, DONE_WAIT_MS, {}) : await run2.done;
+    const result = driven.final || parked ? await within(run3.done, DONE_WAIT_MS, {}) : await run3.done;
     return { cancelled, activity, parked: parked === true, result };
   };
   let finalReport = false;
@@ -4144,13 +4742,13 @@ async function reapStarted(root = process.pid, graceMs) {
 var EXIT_LINGER_MS = 5e3;
 function runRunner(activeDirArg2, laneArg2) {
   const lane = laneArg2 === "chore" ? "chore" : "work";
-  const id = path18.basename(activeDirArg2);
+  const id = path23.basename(activeDirArg2);
   main(activeDirArg2, lane, { reap: () => reapStarted(process.pid) }).catch((err) => {
     try {
       if (!isFinished(id, lane)) {
         appendStatus(id, lane, "failed", String(err instanceof Error ? err.message : err).slice(0, 500));
       }
-      fs21.renameSync(activeDirArg2, path18.join(laneDirs(lane).done, id));
+      fs27.renameSync(activeDirArg2, path23.join(laneDirs(lane).done, id));
     } catch {
     }
     process.exitCode = 1;
@@ -4158,13 +4756,27 @@ function runRunner(activeDirArg2, laneArg2) {
     setTimeout(() => process.exit(), EXIT_LINGER_MS).unref();
   });
 }
+function runPoolWarm(name) {
+  const log = (m) => console.log(`[pool-warm] ${(/* @__PURE__ */ new Date()).toISOString()} ${m}`);
+  warmPool(name, { log }).then((ran) => {
+    if (!ran) log(`pool ${name}: another warm-up is running`);
+  }).catch((err) => {
+    log(`pool ${name}: warm-up failed: ${err instanceof Error ? err.message : String(err)}`);
+    process.exitCode = 1;
+  }).finally(() => {
+    setTimeout(() => process.exit(), EXIT_LINGER_MS).unref();
+  });
+}
 var [activeDirArg, laneArg] = process.argv.slice(2);
-if (activeDirArg && activeDirArg !== "__runner") runRunner(activeDirArg, laneArg);
+if (activeDirArg === "--pool-warm") {
+  if (laneArg) runPoolWarm(laneArg);
+} else if (activeDirArg && activeDirArg !== "__runner" && activeDirArg !== "__pool-warm") runRunner(activeDirArg, laneArg);
 export {
   listProcesses,
   main,
   planStart,
   reapStarted,
+  runPoolWarm,
   runRunner,
   startedBy,
   stopPids