lobstah 0.6.6 → 0.6.7

package/dist/runner.js

@@ -1,6 +1,6 @@
 // packages/runner/src/index.ts
-import * as fs20 from "node:fs";
-import * as path17 from "node:path";
+import * as fs21 from "node:fs";
+import * as path18 from "node:path";
 
 // packages/core/dist/types.js
 var VERBS = ["working", "needs-decision", "blocked", "paused", "done", "failed"];
@@ -8,6 +8,10 @@ var TERMINAL_VERBS = ["done", "failed"];
 var WAITING_ON = ["review", "pr", "deploy", "person", "external"];
 var WAITING_ON_VERBS = ["paused", "needs-decision", "blocked"];
 
+// packages/core/dist/stats.js
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+
 // packages/core/dist/paths.js
 import * as os from "node:os";
 import * as path from "node:path";
@@ -54,6 +58,156 @@ function evidencePath(id, lane) {
   return path.join(laneDirs(lane).state, `${id}.evidence`);
 }
 
+// packages/core/dist/stats.js
+function statsPath() {
+  return path2.join(lobstahHome(), "stats.json");
+}
+function localDay(at = Date.now()) {
+  const d = new Date(at);
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+function readCatchFacts(stateDir, id) {
+  let last;
+  try {
+    for (const line of fs2.readFileSync(path2.join(stateDir, `${id}.status`), "utf8").split("\n")) {
+      if (!line.trim())
+        continue;
+      try {
+        last = JSON.parse(line);
+      } catch {
+      }
+    }
+  } catch {
+    return { done: false };
+  }
+  if (last?.verb !== "done")
+    return { done: false };
+  let trap;
+  try {
+    const to = JSON.parse(fs2.readFileSync(path2.join(stateDir, `${id}.evidence`), "utf8")).deliveredTo;
+    if (typeof to === "string" && to.startsWith("wt:"))
+      trap = to;
+  } catch {
+  }
+  return { done: true, ...typeof last.at === "string" ? { at: last.at } : {}, ...trap ? { trap } : {} };
+}
+function emptyStore(now2) {
+  return { version: 1, totalCatches: 0, perTrap: {}, day: localDay(now2), catchesToday: 0, counted: [] };
+}
+function add(store, facts, now2) {
+  store.totalCatches++;
+  if (facts.trap)
+    store.perTrap[facts.trap] = (store.perTrap[facts.trap] ?? 0) + 1;
+  const today = localDay(now2);
+  if (store.day !== today) {
+    store.day = today;
+    store.catchesToday = 0;
+  }
+  const at = facts.at && Number.isFinite(Date.parse(facts.at)) ? facts.at : void 0;
+  if ((at ? localDay(at) : today) === today)
+    store.catchesToday++;
+}
+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: path2.join(lobstahHome(), name), live: false })).filter((s) => fs2.statSync(s.dir).isDirectory());
+  return [...live, ...backups];
+}
+function backfillStats(now2 = Date.now()) {
+  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"))
+        continue;
+      const id = file.slice(0, -".status".length);
+      if (seen.has(id))
+        continue;
+      seen.add(id);
+      const facts = readCatchFacts(dir, id);
+      if (!facts.done)
+        continue;
+      add(store, facts, now2);
+      if (live)
+        store.counted.push(id);
+    }
+  }
+  return store;
+}
+function parseStore(text) {
+  try {
+    const s = JSON.parse(text);
+    if (s.version !== 1 || typeof s.totalCatches !== "number" || typeof s.catchesToday !== "number" || typeof s.day !== "string")
+      return void 0;
+    return { version: 1, totalCatches: s.totalCatches, perTrap: s.perTrap ?? {}, day: s.day, catchesToday: s.catchesToday, counted: s.counted ?? [] };
+  } catch {
+    return void 0;
+  }
+}
+function writeStore(store) {
+  const file = statsPath();
+  fs2.mkdirSync(path2.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}`;
+  fs2.writeFileSync(tmp, JSON.stringify(store));
+  fs2.renameSync(tmp, file);
+}
+function withStatsLock(action) {
+  fs2.mkdirSync(lobstahHome(), { recursive: true });
+  const lock = `${statsPath()}.lock`;
+  const deadline = Date.now() + 1e4;
+  for (; ; ) {
+    try {
+      fs2.mkdirSync(lock);
+      break;
+    } catch (err) {
+      if (err.code !== "EEXIST")
+        throw err;
+      try {
+        if (Date.now() - fs2.statSync(lock).mtimeMs > 12e4)
+          fs2.rmdirSync(lock);
+      } catch {
+      }
+      if (Date.now() >= deadline)
+        throw new Error("stats store locked");
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+    }
+  }
+  try {
+    return action();
+  } finally {
+    fs2.rmdirSync(lock);
+  }
+}
+function loadOrBackfill(now2) {
+  let text;
+  try {
+    text = fs2.readFileSync(statsPath(), "utf8");
+  } catch (err) {
+    if (err.code !== "ENOENT")
+      throw err;
+  }
+  const saved = text === void 0 ? void 0 : parseStore(text);
+  if (saved)
+    return saved;
+  if (text !== void 0)
+    fs2.renameSync(statsPath(), `${statsPath()}.unreadable-${now2}`);
+  const store = backfillStats(now2);
+  writeStore(store);
+  return store;
+}
+function recordCatch(id, lane, now2 = Date.now()) {
+  withStatsLock(() => {
+    const store = loadOrBackfill(now2);
+    if (store.counted.includes(id))
+      return;
+    const facts = readCatchFacts(laneDirs(lane).state, id);
+    if (!facts.done)
+      return;
+    add(store, facts, now2);
+    store.counted.push(id);
+    writeStore(store);
+  });
+}
+
 // packages/core/dist/attachments.js
 function attachmentBlock(attachments) {
   if (attachments.length === 0)
@@ -89,9 +243,9 @@ var ANSWER_TYPES = {
 var ANSWER_EXTENSIONS = Object.keys(ANSWER_TYPES);
 
 // packages/core/dist/config.js
-import * as fs2 from "node:fs";
+import * as fs3 from "node:fs";
 import * as os2 from "node:os";
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 
 // node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/date.js
 var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
@@ -799,14 +953,14 @@ var DEFAULT_LIMITS = {
   releaseOnMerge: false
 };
 function configPath() {
-  return path2.join(lobstahHome(), "config.toml");
+  return path3.join(lobstahHome(), "config.toml");
 }
 function expandHome(p) {
-  return p.startsWith("~/") ? path2.join(os2.homedir(), p.slice(2)) : p;
+  return p.startsWith("~/") ? path3.join(os2.homedir(), p.slice(2)) : p;
 }
 function loadConfig() {
   const file = configPath();
-  const raw = fs2.existsSync(file) ? parse(fs2.readFileSync(file, "utf8")) : {};
+  const raw = fs3.existsSync(file) ? parse(fs3.readFileSync(file, "utf8")) : {};
   const reposRaw = raw.repos ?? {};
   const repos = {};
   for (const [key, r] of Object.entries(reposRaw)) {
@@ -869,8 +1023,8 @@ function resolveDispatch(d, cfg) {
 var GB = 1024 ** 3;
 
 // packages/core/dist/watch.js
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
 
 // packages/core/dist/gh-errors.js
 function firstMeaningfulLine(...outputs) {
@@ -892,40 +1046,40 @@ function firstMeaningfulLine(...outputs) {
 
 // packages/core/dist/watch.js
 function watchesDir() {
-  return path3.join(lobstahHome(), "watches");
+  return path4.join(lobstahHome(), "watches");
 }
 function slug(key) {
   return key.replace(/[^A-Za-z0-9._-]+/g, "-");
 }
 function watchPath(key) {
-  return path3.join(watchesDir(), `${slug(key)}.json`);
+  return path4.join(watchesDir(), `${slug(key)}.json`);
 }
 function readWatch(key) {
   try {
-    return JSON.parse(fs3.readFileSync(watchPath(key), "utf8"));
+    return JSON.parse(fs4.readFileSync(watchPath(key), "utf8"));
   } catch {
     return void 0;
   }
 }
 
 // packages/core/dist/inbox.js
-import * as fs11 from "node:fs";
-import * as path9 from "node:path";
+import * as fs12 from "node:fs";
+import * as path10 from "node:path";
 
 // packages/core/dist/soak.js
-import * as fs10 from "node:fs";
-import * as path8 from "node:path";
+import * as fs11 from "node:fs";
+import * as path9 from "node:path";
 
 // packages/core/dist/queue.js
-import * as fs6 from "node:fs";
-import * as path5 from "node:path";
+import * as fs7 from "node:fs";
+import * as path6 from "node:path";
 
 // packages/core/dist/status.js
-import * as fs5 from "node:fs";
+import * as fs6 from "node:fs";
 
 // packages/core/dist/activity.js
-import * as fs4 from "node:fs";
-import * as path4 from "node:path";
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
 var ACTIVITY_KINDS = ["tool", "message", "thinking", "waiting"];
 var ACTIVITY_SUMMARY_MAX = 80;
 var SECRET_PATTERNS = [
@@ -979,7 +1133,7 @@ function relativeTarget(p, root) {
   if (!root)
     return baseName(p);
   const win = isWindowsPath(p) || isWindowsPath(root);
-  const lib = win ? path4.win32 : path4.posix;
+  const lib = win ? path5.win32 : path5.posix;
   if (!lib.isAbsolute(p))
     return p.replace(/\\/g, "/");
   const rel = lib.relative(win ? root : root.replace(/\\/g, "/"), p);
@@ -1048,8 +1202,8 @@ function activityFromEvent(ev, root) {
 }
 function atomicWrite(file, content) {
   const tmp = `${file}.tmp-${process.pid}`;
-  fs4.writeFileSync(tmp, content);
-  fs4.renameSync(tmp, file);
+  fs5.writeFileSync(tmp, content);
+  fs5.renameSync(tmp, file);
 }
 function writeActivity(id, lane, a) {
   const safe = { at: a.at, kind: a.kind, summary: redactSummary(a.summary) };
@@ -1057,7 +1211,7 @@ function writeActivity(id, lane, a) {
 }
 function readActivity(id, lane) {
   try {
-    const parsed = JSON.parse(fs4.readFileSync(activityPath(id, lane), "utf8"));
+    const parsed = JSON.parse(fs5.readFileSync(activityPath(id, lane), "utf8"));
     if (typeof parsed.at !== "string" || typeof parsed.summary !== "string")
       return void 0;
     if (!ACTIVITY_KINDS.includes(parsed.kind))
@@ -1189,15 +1343,21 @@ function appendStatus(id, lane, verb, note, at, waiting, reported = false) {
     ...extra,
     ...reported ? { reported: true } : {}
   };
-  fs5.appendFileSync(statusPath(id, lane), `${JSON.stringify(entry)}
+  fs6.appendFileSync(statusPath(id, lane), `${JSON.stringify(entry)}
 `);
+  if (verb === "done") {
+    try {
+      recordCatch(id, lane);
+    } catch {
+    }
+  }
   return entry;
 }
 function readStatusLog(id, lane) {
   const file = statusPath(id, lane);
-  if (!fs5.existsSync(file))
+  if (!fs6.existsSync(file))
     return [];
-  return fs5.readFileSync(file, "utf8").split("\n").filter(Boolean).flatMap((line) => {
+  return fs6.readFileSync(file, "utf8").split("\n").filter(Boolean).flatMap((line) => {
     try {
       const parsed = JSON.parse(line);
       return isVerb(parsed.verb) ? [parsed] : [];
@@ -1214,12 +1374,12 @@ function pausedWaiting(entry) {
 function storedDescriptor(id, lane) {
   const dirs = laneDirs(lane);
   for (const file of [
-    path5.join(dirs.queue, `${id}.json`),
-    path5.join(dirs.active, id, "descriptor.json"),
-    path5.join(dirs.done, id, "descriptor.json")
+    path6.join(dirs.queue, `${id}.json`),
+    path6.join(dirs.active, id, "descriptor.json"),
+    path6.join(dirs.done, id, "descriptor.json")
   ]) {
     try {
-      return JSON.parse(fs6.readFileSync(file, "utf8"));
+      return JSON.parse(fs7.readFileSync(file, "utf8"));
     } catch {
     }
   }
@@ -1230,17 +1390,17 @@ function activeIds(lane) {
 }
 function complete(id, lane) {
   const dirs = laneDirs(lane);
-  fs6.renameSync(path5.join(dirs.active, id), path5.join(dirs.done, id));
+  fs7.renameSync(path6.join(dirs.active, id), path6.join(dirs.done, id));
 }
 function cancelRequested(id, lane) {
-  return fs6.existsSync(path5.join(laneDirs(lane).active, id, "cancel"));
+  return fs7.existsSync(path6.join(laneDirs(lane).active, id, "cancel"));
 }
 
 // packages/core/dist/evidence.js
-import * as fs7 from "node:fs";
+import * as fs8 from "node:fs";
 function readEvidence(id, lane) {
   try {
-    return JSON.parse(fs7.readFileSync(evidencePath(id, lane), "utf8"));
+    return JSON.parse(fs8.readFileSync(evidencePath(id, lane), "utf8"));
   } catch {
     return {};
   }
@@ -1248,13 +1408,13 @@ function readEvidence(id, lane) {
 function mergeEvidence(id, lane, patch) {
   const file = evidencePath(id, lane);
   const tmp = `${file}.tmp-${process.pid}`;
-  fs7.writeFileSync(tmp, JSON.stringify({ ...readEvidence(id, lane), ...patch }, null, 2));
-  fs7.renameSync(tmp, file);
+  fs8.writeFileSync(tmp, JSON.stringify({ ...readEvidence(id, lane), ...patch }, null, 2));
+  fs8.renameSync(tmp, file);
 }
 
 // packages/core/dist/pushes.js
-import * as fs8 from "node:fs";
-import * as path6 from "node:path";
+import * as fs9 from "node:fs";
+import * as path7 from "node:path";
 var MAX_PUSHES = 20;
 var PUSH_HEAD = "HEAD";
 var VALUE_OPTIONS = /* @__PURE__ */ new Set(["-o", "--push-option", "--repo", "--receive-pack", "--exec"]);
@@ -1309,18 +1469,18 @@ function gitPushTargets(command) {
   return found ? [...new Set(targets)] : void 0;
 }
 function gitDirAt(dir) {
-  let at = path6.resolve(dir);
+  let at = path7.resolve(dir);
   for (; ; ) {
-    const dotGit = path6.join(at, ".git");
+    const dotGit = path7.join(at, ".git");
     try {
-      const stat = fs8.statSync(dotGit);
+      const stat = fs9.statSync(dotGit);
       if (stat.isDirectory())
         return dotGit;
-      const m = /^gitdir:\s*(.+)$/m.exec(fs8.readFileSync(dotGit, "utf8"));
-      return m ? path6.resolve(at, m[1].trim()) : void 0;
+      const m = /^gitdir:\s*(.+)$/m.exec(fs9.readFileSync(dotGit, "utf8"));
+      return m ? path7.resolve(at, m[1].trim()) : void 0;
     } catch {
     }
-    const up = path6.dirname(at);
+    const up = path7.dirname(at);
     if (up === at)
       return void 0;
     at = up;
@@ -1331,7 +1491,7 @@ function currentBranchAt(dir) {
   if (!gitDir)
     return void 0;
   try {
-    const m = /^ref:\s*refs\/heads\/(.+)$/m.exec(fs8.readFileSync(path6.join(gitDir, "HEAD"), "utf8"));
+    const m = /^ref:\s*refs\/heads\/(.+)$/m.exec(fs9.readFileSync(path7.join(gitDir, "HEAD"), "utf8"));
     return m ? m[1].trim() : void 0;
   } catch {
     return void 0;
@@ -1350,23 +1510,23 @@ function recordPush(id, lane, branches, at = (/* @__PURE__ */ new Date()).toISOS
 }
 
 // packages/core/dist/worktrees.js
-import * as fs9 from "node:fs";
-import * as path7 from "node:path";
+import * as fs10 from "node:fs";
+import * as path8 from "node:path";
 var LANES = ["work", "chore"];
 function worktreePath(id) {
-  return path7.join(lobstahHome(), "worktrees", id);
+  return path8.join(lobstahHome(), "worktrees", id);
 }
 function readRecord(file) {
   try {
-    const r = JSON.parse(fs9.readFileSync(file, "utf8"));
+    const r = JSON.parse(fs10.readFileSync(file, "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 = path8.relative(path8.join(lobstahHome(), "worktrees"), p);
+  if (!rel || rel.startsWith("..") || path8.isAbsolute(rel))
     return void 0;
   return rel.split(/[\\/]/)[0];
 }
@@ -1379,7 +1539,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(path8.join(dir, id, "worktree.json"));
       if (rec) {
         const owner = rec.of ?? ownerOfPath(rec.path) ?? id;
         return { path: rec.path, owner, reused: owner !== id };
@@ -1391,7 +1551,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 (fs10.existsSync(path8.join(d.queue, `${id}.json`)) || fs10.existsSync(path8.join(d.active, id)) || fs10.existsSync(path8.join(d.done, id))) {
       return l;
     }
   }
@@ -1411,39 +1571,39 @@ 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 (fs10.existsSync(wt.path))
       return { ...wt, from: id };
   }
   return void 0;
 }
 function worktreeGitDir(wt) {
-  const dotGit = path7.join(wt, ".git");
+  const dotGit = path8.join(wt, ".git");
   try {
-    const st = fs9.statSync(dotGit);
+    const st = fs10.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(fs10.readFileSync(dotGit, "utf8"));
+    return m ? path8.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 ? path8.join(gitDir, "lobstah.lock") : void 0;
 }
 function readWorktreeLock(wt) {
   const file = worktreeLockFile(wt);
   if (!file)
     return void 0;
   try {
-    return JSON.parse(fs9.readFileSync(file, "utf8"));
+    return JSON.parse(fs10.readFileSync(file, "utf8"));
   } catch {
     return void 0;
   }
 }
 function lockIsLive(lock) {
-  return fs9.existsSync(path7.join(laneDirs(lock.lane).active, lock.id));
+  return fs10.existsSync(path8.join(laneDirs(lock.lane).active, lock.id));
 }
 function worktreeHolder(wt) {
   const lock = readWorktreeLock(wt);
@@ -1456,7 +1616,7 @@ function acquireWorktreeLock(wt, id, lane) {
     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" });
+      fs10.writeFileSync(file, JSON.stringify(mine, null, 2), { flag: "wx" });
       return void 0;
     } catch (err) {
       if (err.code !== "EEXIST")
@@ -1464,7 +1624,7 @@ function acquireWorktreeLock(wt, id, lane) {
     }
     let raw;
     try {
-      raw = fs9.readFileSync(file, "utf8");
+      raw = fs10.readFileSync(file, "utf8");
     } catch {
       continue;
     }
@@ -1475,14 +1635,14 @@ function acquireWorktreeLock(wt, id, lane) {
       held2 = void 0;
     }
     if (held2?.id === id) {
-      fs9.writeFileSync(file, JSON.stringify(mine, null, 2));
+      fs10.writeFileSync(file, 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 (fs10.readFileSync(file, "utf8") === raw)
+        fs10.rmSync(file, { force: true });
     } catch {
     }
   }
@@ -1494,33 +1654,33 @@ function releaseWorktreeLock(wt, id) {
   if (!file)
     return;
   if (readWorktreeLock(wt)?.id === id)
-    fs9.rmSync(file, { force: true });
+    fs10.rmSync(file, { force: true });
 }
 
 // packages/core/dist/soak.js
 function regPath(trapId) {
-  return path8.join(soakingDir(), `${trapId}.json`);
+  return path9.join(soakingDir(), `${trapId}.json`);
 }
 function readTrap(trapId) {
   try {
-    return JSON.parse(fs10.readFileSync(regPath(trapId), "utf8"));
+    return JSON.parse(fs11.readFileSync(regPath(trapId), "utf8"));
   } catch {
     return void 0;
   }
 }
 function listTraps() {
   try {
-    return fs10.readdirSync(soakingDir()).filter((f) => f.endsWith(".json")).map((f) => JSON.parse(fs10.readFileSync(path8.join(soakingDir(), f), "utf8"))).filter((r) => typeof r.trapId === "string");
+    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");
   } catch {
     return [];
   }
 }
 function claimPath(id, lane) {
-  return path8.join(laneDirs(lane).active, id, "claim.json");
+  return path9.join(laneDirs(lane).active, id, "claim.json");
 }
 function readSessionClaim(id, lane) {
   try {
-    return JSON.parse(fs10.readFileSync(claimPath(id, lane), "utf8"));
+    return JSON.parse(fs11.readFileSync(claimPath(id, lane), "utf8"));
   } catch {
     return void 0;
   }
@@ -1529,54 +1689,54 @@ function readSessionClaim(id, lane) {
 // packages/core/dist/inbox.js
 var metaName = (file) => file.replace(/\.msg$/, ".meta.json");
 function inboxDir(id, lane) {
-  return path9.join(laneDirs(lane).inbox, id);
+  return path10.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: fs11.readFileSync(path9.join(dir, f), "utf8") }));
+  return readDirIfPresent(dir).filter((f) => f.endsWith(".msg")).sort().map((f) => ({ file: f, text: fs12.readFileSync(path10.join(dir, f), "utf8") }));
 }
 function acknowledge(id, lane, file) {
   const dir = inboxDir(id, lane);
-  fs11.mkdirSync(path9.join(dir, "handled"), { recursive: true });
-  fs11.renameSync(path9.join(dir, file), path9.join(dir, "handled", file));
+  fs12.mkdirSync(path10.join(dir, "handled"), { recursive: true });
+  fs12.renameSync(path10.join(dir, file), path10.join(dir, "handled", file));
   try {
-    fs11.renameSync(path9.join(dir, metaName(file)), path9.join(dir, "handled", metaName(file)));
+    fs12.renameSync(path10.join(dir, metaName(file)), path10.join(dir, "handled", metaName(file)));
   } catch {
   }
 }
 
 // packages/core/dist/events.js
-import * as fs12 from "node:fs";
+import * as fs13 from "node:fs";
 function appendEvent(id, lane, ev) {
-  fs12.appendFileSync(eventsPath(id, lane), `${JSON.stringify(ev)}
+  fs13.appendFileSync(eventsPath(id, lane), `${JSON.stringify(ev)}
 `);
 }
 function touchEvents(id, lane, at = /* @__PURE__ */ new Date()) {
   const file = eventsPath(id, lane);
   try {
-    fs12.utimesSync(file, at, at);
+    fs13.utimesSync(file, at, at);
   } catch {
-    fs12.appendFileSync(file, "");
-    fs12.utimesSync(file, at, at);
+    fs13.appendFileSync(file, "");
+    fs13.utimesSync(file, at, at);
   }
 }
 
 // packages/core/dist/harness.js
-import * as fs13 from "node:fs";
-import * as path10 from "node:path";
+import * as fs14 from "node:fs";
+import * as path11 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(path10.delimiter)) {
+  for (const dir of pathVar.split(path11.delimiter)) {
     if (!dir)
       continue;
     for (const name of names) {
-      const candidate = path10.join(dir, name);
+      const candidate = path11.join(dir, name);
       try {
-        fs13.accessSync(candidate, fs13.constants.X_OK);
-        if (fs13.statSync(candidate).isFile())
+        fs14.accessSync(candidate, fs14.constants.X_OK);
+        if (fs14.statSync(candidate).isFile())
           return candidate;
       } catch {
       }
@@ -1597,8 +1757,8 @@ function codexInvocation(argv) {
   } catch {
   }
   for (const dir of require_.resolve.paths("@openai/codex") ?? []) {
-    const cli = path10.join(dir, "@openai", "codex", "bin", "codex.js");
-    if (fs13.existsSync(cli))
+    const cli = path11.join(dir, "@openai", "codex", "bin", "codex.js");
+    if (fs14.existsSync(cli))
       return { file: process.execPath, argv: [cli, ...argv] };
   }
   return void 0;
@@ -1677,21 +1837,21 @@ function parseUnresolvedThreads(stdout) {
 }
 
 // packages/core/dist/prs.js
-import * as fs14 from "node:fs";
-import * as path11 from "node:path";
+import * as fs15 from "node:fs";
+import * as path12 from "node:path";
 function prsDir() {
-  return path11.join(lobstahHome(), "prs");
+  return path12.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 path11.join(prsDir(), `${safe(ref.owner)}__${safe(ref.repo)}__${ref.number}.json`);
+  return path12.join(prsDir(), `${safe(ref.owner)}__${safe(ref.repo)}__${ref.number}.json`);
 }
 function readPr(key) {
   try {
-    return JSON.parse(fs14.readFileSync(prRecordFile(key), "utf8"));
+    return JSON.parse(fs15.readFileSync(prRecordFile(key), "utf8"));
   } catch {
     return void 0;
   }
@@ -1699,13 +1859,13 @@ function readPr(key) {
 function readPrs() {
   let files;
   try {
-    files = fs14.readdirSync(prsDir()).filter((f) => f.endsWith(".json"));
+    files = fs15.readdirSync(prsDir()).filter((f) => f.endsWith(".json"));
   } catch {
     return [];
   }
   return files.flatMap((f) => {
     try {
-      const r = JSON.parse(fs14.readFileSync(path11.join(prsDir(), f), "utf8"));
+      const r = JSON.parse(fs15.readFileSync(path12.join(prsDir(), f), "utf8"));
       return typeof r.key === "string" && typeof r.url === "string" ? [r] : [];
     } catch {
       return [];
@@ -1754,9 +1914,9 @@ function pushRule(branch, id = "<dispatch id>", mode = "rebase", also = []) {
 }
 
 // packages/core/dist/resume.js
-import * as fs15 from "node:fs";
+import * as fs16 from "node:fs";
 import * as os3 from "node:os";
-import * as path12 from "node:path";
+import * as path13 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) {
@@ -1767,7 +1927,7 @@ function claimOf(id, lane) {
   const dirs = laneDirs(lane);
   for (const dir of [dirs.active, dirs.done]) {
     try {
-      return JSON.parse(fs15.readFileSync(path12.join(dir, id, "claim.json"), "utf8"));
+      return JSON.parse(fs16.readFileSync(path13.join(dir, id, "claim.json"), "utf8"));
     } catch {
     }
   }
@@ -1817,7 +1977,7 @@ function isUnresumable(error) {
   return error !== void 0 && UNRESUMABLE.test(error);
 }
 function worktreeProgress(worktree, trunk) {
-  if (!worktree || !fs15.existsSync(worktree))
+  if (!worktree || !fs16.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");
@@ -1850,31 +2010,31 @@ function handoffNote(fromHarness, progress, why) {
 ${progress}`;
 }
 function codexHome(env = process.env) {
-  return env.CODEX_HOME ?? path12.join(os3.homedir(), ".codex");
+  return env.CODEX_HOME ?? path13.join(os3.homedir(), ".codex");
 }
 function codexRolloutFile(threadId, home = codexHome()) {
   const suffix = `-${threadId}.jsonl`;
   const walk = (dir, depth) => {
     let entries;
     try {
-      entries = fs15.readdirSync(dir, { withFileTypes: true });
+      entries = fs16.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 path12.join(dir, e.name);
+        return path13.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(path12.join(dir, e.name), depth - 1);
+      const hit = walk(path13.join(dir, e.name), depth - 1);
       if (hit)
         return hit;
     }
     return void 0;
   };
-  return walk(path12.join(home, "sessions"), 3) ?? walk(path12.join(home, "archived_sessions"), 0);
+  return walk(path13.join(home, "sessions"), 3) ?? walk(path13.join(home, "archived_sessions"), 0);
 }
 function codexDesktopThread(threadId, home = codexHome()) {
   const file = codexRolloutFile(threadId, home);
@@ -1882,12 +2042,12 @@ function codexDesktopThread(threadId, home = codexHome()) {
     return void 0;
   let head = "";
   try {
-    const fd = fs15.openSync(file, "r");
+    const fd = fs16.openSync(file, "r");
     try {
       const buf = Buffer.alloc(4096);
-      head = buf.subarray(0, fs15.readSync(fd, buf, 0, buf.length, 0)).toString("utf8");
+      head = buf.subarray(0, fs16.readSync(fd, buf, 0, buf.length, 0)).toString("utf8");
     } finally {
-      fs15.closeSync(fd);
+      fs16.closeSync(fd);
     }
   } catch {
     return void 0;
@@ -1927,8 +2087,8 @@ function isFinished(id, lane) {
 }
 
 // packages/runner/src/run.ts
-import * as fs19 from "node:fs";
-import * as path16 from "node:path";
+import * as fs20 from "node:fs";
+import * as path17 from "node:path";
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
@@ -2224,25 +2384,25 @@ function createClaudeAdapter() {
 }
 
 // packages/adapters/dist/codex.js
-import * as fs16 from "node:fs";
+import * as fs17 from "node:fs";
 import * as os4 from "node:os";
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 function isolatedCodexHome() {
-  const dir = path13.join(lobstahHome(), "codex-home");
-  fs16.mkdirSync(dir, { recursive: true });
-  const auth = path13.join(dir, "auth.json");
-  const realAuth = path13.join(os4.homedir(), ".codex", "auth.json");
-  if (!fs16.existsSync(auth) && fs16.existsSync(realAuth)) {
+  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)) {
     try {
-      fs16.symlinkSync(realAuth, auth);
+      fs17.symlinkSync(realAuth, auth);
     } catch {
-      fs16.copyFileSync(realAuth, auth);
+      fs17.copyFileSync(realAuth, auth);
     }
   }
-  const cfg = path13.join(dir, "config.toml");
-  if (!fs16.existsSync(cfg)) {
-    fs16.writeFileSync(cfg, "# lobstah-managed: auth inherited from ~/.codex, interactive config not\n");
+  const cfg = path14.join(dir, "config.toml");
+  if (!fs17.existsSync(cfg)) {
+    fs17.writeFileSync(cfg, "# lobstah-managed: auth inherited from ~/.codex, interactive config not\n");
   }
   return dir;
 }
@@ -2445,8 +2605,8 @@ function loadAdapter(name) {
 }
 
 // packages/worktree/dist/index.js
-import * as fs17 from "node:fs";
-import * as path14 from "node:path";
+import * as fs18 from "node:fs";
+import * as path15 from "node:path";
 import { createHash } from "node:crypto";
 import { exec, execFile, execFileSync } from "node:child_process";
 import { promisify } from "node:util";
@@ -2519,7 +2679,7 @@ function pidAlive(pid) {
 var BUSY = /* @__PURE__ */ new Set(["EPERM", "EACCES", "EBUSY"]);
 function takeRepoLock(file, mine) {
   try {
-    fs17.writeFileSync(file, mine, { flag: "wx" });
+    fs18.writeFileSync(file, mine, { flag: "wx" });
     return { state: "held" };
   } catch (err) {
     const code = err.code ?? "";
@@ -2529,8 +2689,8 @@ function takeRepoLock(file, mine) {
   let raw = "";
   let age = 0;
   try {
-    raw = fs17.readFileSync(file, "utf8");
-    age = Date.now() - fs17.statSync(file).mtimeMs;
+    raw = fs18.readFileSync(file, "utf8");
+    age = Date.now() - fs18.statSync(file).mtimeMs;
   } catch {
     return { state: "retry" };
   }
@@ -2543,8 +2703,8 @@ function takeRepoLock(file, mine) {
   const stale = age > REPO_LOCK_WAIT_MS || (holder ? !pidAlive(holder.pid) : age > 5e3);
   if (stale) {
     try {
-      if (fs17.readFileSync(file, "utf8") === raw)
-        fs17.rmSync(file, { force: true });
+      if (fs18.readFileSync(file, "utf8") === raw)
+        fs18.rmSync(file, { force: true });
     } catch {
     }
     return { state: "retry" };
@@ -2553,13 +2713,13 @@ function takeRepoLock(file, mine) {
 }
 function releaseRepoLock(file, mine) {
   try {
-    if (fs17.readFileSync(file, "utf8") === mine)
-      fs17.rmSync(file, { force: true, recursive: true, maxRetries: 5 });
+    if (fs18.readFileSync(file, "utf8") === mine)
+      fs18.rmSync(file, { force: true, recursive: true, maxRetries: 5 });
   } catch {
   }
 }
 async function withRepoLock(common, fn) {
-  const file = path14.join(common, "lobstah-git.lock");
+  const file = path15.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;
@@ -2595,7 +2755,7 @@ async function oneAtATime(cwd, fn) {
 }
 function fetchStamps(common) {
   try {
-    return JSON.parse(fs17.readFileSync(path14.join(common, "lobstah-fetch.json"), "utf8"));
+    return JSON.parse(fs18.readFileSync(path15.join(common, "lobstah-fetch.json"), "utf8"));
   } catch {
     return {};
   }
@@ -2609,15 +2769,15 @@ async function fetchShared(cwd, remote, ref) {
     const started = Date.now();
     await gitShared(cwd, "fetch", remote, ref);
     const stamps = { ...fetchStamps(common), [key]: started };
-    fs17.writeFileSync(path14.join(common, "lobstah-fetch.json"), JSON.stringify(stamps, null, 2));
+    fs18.writeFileSync(path15.join(common, "lobstah-fetch.json"), JSON.stringify(stamps, null, 2));
   });
 }
 async function allocate(repo, id, fromRemoteBranch = repo.trunk) {
   const dir = worktreePath(id);
-  if (fs17.existsSync(dir)) {
+  if (fs18.existsSync(dir)) {
     throw new Error(`worktree for ${id} already exists at ${dir} \u2014 never allocate a second`);
   }
-  if (!fs17.existsSync(repo.path)) {
+  if (!fs18.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 });
@@ -2655,27 +2815,27 @@ function setupHash(repo, dir) {
   const h = createHash("sha256");
   h.update(JSON.stringify(repo.setup ?? []));
   for (const name of LOCKFILES) {
-    const file = path14.join(dir, name);
-    if (!fs17.existsSync(file))
+    const file = path15.join(dir, name);
+    if (!fs18.existsSync(file))
       continue;
     h.update(`\0${name}\0`);
-    h.update(fs17.readFileSync(file));
+    h.update(fs18.readFileSync(file));
   }
   return h.digest("hex");
 }
 function setupRecordFile(dir) {
   const gitDir = worktreeGitDir(dir);
-  return gitDir ? path14.join(gitDir, "lobstah-setup.json") : void 0;
+  return gitDir ? path15.join(gitDir, "lobstah-setup.json") : void 0;
 }
 function recordSetup(repo, dir) {
   const file = setupRecordFile(dir);
   if (file)
-    fs17.writeFileSync(file, JSON.stringify({ hash: setupHash(repo, dir), at: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
+    fs18.writeFileSync(file, JSON.stringify({ hash: setupHash(repo, dir), at: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
 }
 function recordedSetupHash(dir) {
   const file = setupRecordFile(dir);
   try {
-    return file ? JSON.parse(fs17.readFileSync(file, "utf8")).hash : void 0;
+    return file ? JSON.parse(fs18.readFileSync(file, "utf8")).hash : void 0;
   } catch {
     return void 0;
   }
@@ -2684,9 +2844,9 @@ var short = (s) => s.slice(0, 8);
 function realpath(p) {
   let r;
   try {
-    r = fs17.realpathSync.native(p);
+    r = fs18.realpathSync.native(p);
   } catch {
-    r = path14.resolve(p);
+    r = path15.resolve(p);
   }
   return process.platform === "win32" ? r.toLowerCase() : r;
 }
@@ -2728,8 +2888,8 @@ async function chooseWorktree(input) {
   for (const t of listTraps()) {
     if (typeof t.worktree !== "string")
       continue;
-    const rel = path14.relative(here, realpath(t.worktree));
-    if (!rel.startsWith("..") && !path14.isAbsolute(rel))
+    const rel = path15.relative(here, realpath(t.worktree));
+    if (!rel.startsWith("..") && !path15.isAbsolute(rel))
       return { reuse: false, reason: "origin worktree is a trap\u2019s" };
   }
   for (const l of ["work", "chore"]) {
@@ -3137,8 +3297,8 @@ function startWallClock(opts) {
 import { execFile as execFile2 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
 import { fileURLToPath } from "node:url";
-import * as fs18 from "node:fs";
-import * as path15 from "node:path";
+import * as fs19 from "node:fs";
+import * as path16 from "node:path";
 var exec2 = promisify2(execFile2);
 function firstLine(err) {
   const stderr = err && typeof err === "object" && "stderr" in err ? String(err.stderr).trim() : "";
@@ -3168,10 +3328,10 @@ function keepRemote(opts) {
   const note = (message) => mergeEvidence(id, lane, { note: message.slice(0, 300) });
   if (existingPrUrl) mergeEvidence(id, lane, { prUrl: existingPrUrl });
   const registerWatch = async (url) => {
-    const root = path15.resolve(path15.dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
-    const localCli = path15.join(root, "apps", "cli", "dist", "main.js");
+    const root = path16.resolve(path16.dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+    const localCli = path16.join(root, "apps", "cli", "dist", "main.js");
     const args = ["watch", "add", url, "--for", id];
-    if (fs18.existsSync(localCli)) await command(process.execPath, [localCli, ...args], 15e3);
+    if (fs19.existsSync(localCli)) await command(process.execPath, [localCli, ...args], 15e3);
     else await command("lobstah", args, 15e3);
   };
   let lastSeenHead;
@@ -3350,16 +3510,16 @@ function coldNote(cold, cwd, trunk) {
 }
 async function main(activeDir, lane, seams = {}) {
   const deps = { ...defaultDeps, ...seams };
-  const id = path16.basename(activeDir);
+  const id = path17.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(fs19.readFileSync(path16.join(activeDir, "descriptor.json"), "utf8"));
+  const descriptor = JSON.parse(fs20.readFileSync(path17.join(activeDir, "descriptor.json"), "utf8"));
   const resolved = resolveDispatch(descriptor, cfg);
   const repo = cfg.repos[descriptor.repo];
-  const briefFile = path16.join(activeDir, "brief.md");
-  if (!fs19.existsSync(briefFile)) fs19.writeFileSync(briefFile, descriptor.brief);
-  const brief = fs19.readFileSync(briefFile, "utf8");
+  const briefFile = path17.join(activeDir, "brief.md");
+  if (!fs20.existsSync(briefFile)) fs20.writeFileSync(briefFile, descriptor.brief);
+  const brief = fs20.readFileSync(briefFile, "utf8");
   const attempts = Number(process.env.LOBSTAH_ATTEMPTS ?? "1");
   const wake = process.env.LOBSTAH_WAKE;
   const runnerInfo = {
@@ -3367,7 +3527,7 @@ async function main(activeDir, lane, seams = {}) {
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     attempts
   };
-  fs19.writeFileSync(path16.join(activeDir, "runner.json"), JSON.stringify(runnerInfo, null, 2));
+  fs20.writeFileSync(path17.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") {
@@ -3384,13 +3544,13 @@ async function main(activeDir, lane, seams = {}) {
     resolvedHarness: resolved.harness,
     envResume: process.env.LOBSTAH_RESUME
   });
-  const wtFile = path16.join(activeDir, "worktree.json");
+  const wtFile = path17.join(activeDir, "worktree.json");
   let recorded;
   let choice;
-  if (fs19.existsSync(wtFile)) {
-    recorded = JSON.parse(fs19.readFileSync(wtFile, "utf8")).path;
-    if (!fs19.existsSync(recorded)) throw new Error(`recorded worktree ${recorded} is gone`);
-  } else if (fs19.existsSync(worktreePath(id))) {
+  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))) {
     throw new Error(`unrecorded worktree already exists for ${id} \u2014 refusing to proceed`);
   } else if (descriptor.followUp && cfg.limits.reuseWorktree !== false) {
     choice = await deps.chooseWorktree({ id, lane, repoKey: descriptor.repo, repo, followUp: descriptor.followUp });
@@ -3424,13 +3584,13 @@ async function main(activeDir, lane, seams = {}) {
       type: "runner",
       data: { worktree: cwd, worktreeOf: choice.owner, setupRan }
     });
-    fs19.writeFileSync(wtFile, JSON.stringify({ path: cwd, of: choice.owner }, null, 2));
+    fs20.writeFileSync(wtFile, JSON.stringify({ path: cwd, of: choice.owner }, null, 2));
   } else {
     cwd = await deps.allocate(repo, id, descriptor.systemRepair ? descriptor.pr?.headRefName : void 0);
     acquireWorktreeLock(cwd, id, lane);
-    fs19.writeFileSync(wtFile, JSON.stringify({ path: cwd }, null, 2));
+    fs20.writeFileSync(wtFile, JSON.stringify({ path: cwd }, null, 2));
   }
-  const worktreeOf = JSON.parse(fs19.readFileSync(wtFile, "utf8")).of;
+  const worktreeOf = JSON.parse(fs20.readFileSync(wtFile, "utf8")).of;
   mergeEvidence(id, lane, { worktree: cwd, worktreeOf });
   const existingPr = boundPr(descriptor, lane);
   if (existingPr) mergeEvidence(id, lane, { prUrl: existingPr.url });
@@ -3461,14 +3621,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 = path16.resolve(path16.dirname(fileURLToPath2(import.meta.url)), "..", "..", "..", "bin");
-  const workerPath = fs19.existsSync(path16.join(binDir, "lobstah")) ? `${binDir}${path16.delimiter}${process.env.PATH ?? ""}` : void 0;
+  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;
   let wallClockHit = false;
   let current;
-  const wallFile = path16.join(activeDir, "wallclock.json");
+  const wallFile = path17.join(activeDir, "wallclock.json");
   const wallState = (() => {
     try {
-      return JSON.parse(fs19.readFileSync(wallFile, "utf8"));
+      return JSON.parse(fs20.readFileSync(wallFile, "utf8"));
     } catch {
       return { elapsedMs: 0, windowMs: resolved.limits.wallClockSecs * 1e3 };
     }
@@ -3487,8 +3647,8 @@ async function main(activeDir, lane, seams = {}) {
   ) * 1e3;
   const persistWall = (elapsedMs, windowMs) => {
     const tmp = `${wallFile}.tmp-${process.pid}`;
-    fs19.writeFileSync(tmp, JSON.stringify({ ...wallState, elapsedMs, windowMs }));
-    fs19.renameSync(tmp, wallFile);
+    fs20.writeFileSync(tmp, JSON.stringify({ ...wallState, elapsedMs, windowMs }));
+    fs20.renameSync(tmp, wallFile);
   };
   const madeProgress = () => {
     const activity = readActivity(id, lane);
@@ -3738,13 +3898,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 = path17.basename(activeDirArg2);
+  const id = path18.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));
       }
-      fs20.renameSync(activeDirArg2, path17.join(laneDirs(lane).done, id));
+      fs21.renameSync(activeDirArg2, path18.join(laneDirs(lane).done, id));
     } catch {
     }
     process.exitCode = 1;