lobstah 0.5.12 → 0.5.13

package/dist/runner.js

@@ -1,6 +1,6 @@
 // packages/runner/src/index.ts
-import * as fs16 from "node:fs";
-import * as path14 from "node:path";
+import * as fs18 from "node:fs";
+import * as path16 from "node:path";
 
 // packages/core/dist/types.js
 var VERBS = ["working", "needs-decision", "blocked", "paused", "done", "failed"];
@@ -401,32 +401,65 @@ function mergeEvidence(id, lane, patch) {
 }
 
 // packages/core/dist/inbox.js
+import * as fs7 from "node:fs";
+import * as path5 from "node:path";
+
+// packages/core/dist/soak.js
 import * as fs6 from "node:fs";
 import * as path4 from "node:path";
+function regPath(trapId) {
+  return path4.join(soakingDir(), `${trapId}.json`);
+}
+function readTrap(trapId) {
+  try {
+    return JSON.parse(fs6.readFileSync(regPath(trapId), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function listTraps() {
+  try {
+    return fs6.readdirSync(soakingDir()).filter((f) => f.endsWith(".json")).map((f) => JSON.parse(fs6.readFileSync(path4.join(soakingDir(), f), "utf8"))).filter((r) => typeof r.trapId === "string");
+  } catch {
+    return [];
+  }
+}
+function claimPath(id, lane) {
+  return path4.join(laneDirs(lane).active, id, "claim.json");
+}
+function readSessionClaim(id, lane) {
+  try {
+    return JSON.parse(fs6.readFileSync(claimPath(id, lane), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+
+// packages/core/dist/inbox.js
 var metaName = (file) => file.replace(/\.msg$/, ".meta.json");
 function inboxDir(id, lane) {
-  return path4.join(laneDirs(lane).inbox, id);
+  return path5.join(laneDirs(lane).inbox, id);
 }
 function unhandled(id, lane) {
   const dir = inboxDir(id, lane);
-  if (!fs6.existsSync(dir))
+  if (!fs7.existsSync(dir))
     return [];
-  return fs6.readdirSync(dir).filter((f) => f.endsWith(".msg")).sort().map((f) => ({ file: f, text: fs6.readFileSync(path4.join(dir, f), "utf8") }));
+  return fs7.readdirSync(dir).filter((f) => f.endsWith(".msg")).sort().map((f) => ({ file: f, text: fs7.readFileSync(path5.join(dir, f), "utf8") }));
 }
 function acknowledge(id, lane, file) {
   const dir = inboxDir(id, lane);
-  fs6.mkdirSync(path4.join(dir, "handled"), { recursive: true });
-  fs6.renameSync(path4.join(dir, file), path4.join(dir, "handled", file));
+  fs7.mkdirSync(path5.join(dir, "handled"), { recursive: true });
+  fs7.renameSync(path5.join(dir, file), path5.join(dir, "handled", file));
   try {
-    fs6.renameSync(path4.join(dir, metaName(file)), path4.join(dir, "handled", metaName(file)));
+    fs7.renameSync(path5.join(dir, metaName(file)), path5.join(dir, "handled", metaName(file)));
   } catch {
   }
 }
 
 // packages/core/dist/config.js
-import * as fs7 from "node:fs";
+import * as fs8 from "node:fs";
 import * as os2 from "node:os";
-import * as path5 from "node:path";
+import * as path6 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;
@@ -1120,14 +1153,14 @@ var DEFAULT_LIMITS = {
   releaseOnMerge: false
 };
 function configPath() {
-  return path5.join(lobstahHome(), "config.toml");
+  return path6.join(lobstahHome(), "config.toml");
 }
 function expandHome(p) {
-  return p.startsWith("~/") ? path5.join(os2.homedir(), p.slice(2)) : p;
+  return p.startsWith("~/") ? path6.join(os2.homedir(), p.slice(2)) : p;
 }
 function loadConfig() {
   const file = configPath();
-  const raw = fs7.existsSync(file) ? parse(fs7.readFileSync(file, "utf8")) : {};
+  const raw = fs8.existsSync(file) ? parse(fs8.readFileSync(file, "utf8")) : {};
   const reposRaw = raw.repos ?? {};
   const repos = {};
   for (const [key, r] of Object.entries(reposRaw)) {
@@ -1185,21 +1218,21 @@ function resolveDispatch(d, cfg) {
 }
 
 // packages/core/dist/harness.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";
 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(path6.delimiter)) {
+  for (const dir of pathVar.split(path7.delimiter)) {
     if (!dir)
       continue;
     for (const name of names) {
-      const candidate = path6.join(dir, name);
+      const candidate = path7.join(dir, name);
       try {
-        fs8.accessSync(candidate, fs8.constants.X_OK);
-        if (fs8.statSync(candidate).isFile())
+        fs9.accessSync(candidate, fs9.constants.X_OK);
+        if (fs9.statSync(candidate).isFile())
           return candidate;
       } catch {
       }
@@ -1220,39 +1253,28 @@ function codexInvocation(argv) {
   } catch {
   }
   for (const dir of require_.resolve.paths("@openai/codex") ?? []) {
-    const cli = path6.join(dir, "@openai", "codex", "bin", "codex.js");
-    if (fs8.existsSync(cli))
+    const cli = path7.join(dir, "@openai", "codex", "bin", "codex.js");
+    if (fs9.existsSync(cli))
       return { file: process.execPath, argv: [cli, ...argv] };
   }
   return void 0;
 }
 
-// packages/core/dist/soak.js
-import * as fs9 from "node:fs";
-import * as path7 from "node:path";
-function regPath(trapId) {
-  return path7.join(soakingDir(), `${trapId}.json`);
+// packages/core/dist/watch.js
+import * as fs10 from "node:fs";
+import * as path8 from "node:path";
+function watchesDir() {
+  return path8.join(lobstahHome(), "watches");
 }
-function readTrap(trapId) {
-  try {
-    return JSON.parse(fs9.readFileSync(regPath(trapId), "utf8"));
-  } catch {
-    return void 0;
-  }
+function slug(key) {
+  return key.replace(/[^A-Za-z0-9._-]+/g, "-");
 }
-function listTraps() {
-  try {
-    return fs9.readdirSync(soakingDir()).filter((f) => f.endsWith(".json")).map((f) => JSON.parse(fs9.readFileSync(path7.join(soakingDir(), f), "utf8"))).filter((r) => typeof r.trapId === "string");
-  } catch {
-    return [];
-  }
+function watchPath(key) {
+  return path8.join(watchesDir(), `${slug(key)}.json`);
 }
-function claimPath(id, lane) {
-  return path7.join(laneDirs(lane).active, id, "claim.json");
-}
-function readSessionClaim(id, lane) {
+function readWatch(key) {
   try {
-    return JSON.parse(fs9.readFileSync(claimPath(id, lane), "utf8"));
+    return JSON.parse(fs10.readFileSync(watchPath(key), "utf8"));
   } catch {
     return void 0;
   }
@@ -1268,13 +1290,70 @@ var COMPILED_BINARY = (() => {
 })();
 
 // 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());
+  if (!m)
+    return void 0;
+  const [, owner, repo, n] = m;
+  const number = Number(n);
+  return { owner, repo, number, key: `pr:${owner}/${repo}#${number}`, url: `https://github.com/${owner}/${repo}/pull/${number}` };
+}
 var PR_VIEW_FIELDS = "state,isDraft,headRefOid,baseRefName,headRefName,mergeStateStatus,reviewDecision,statusCheckRollup,mergedAt,closedAt,updatedAt,reviews";
 var PR_VIEW_FIELDS_NO_CHECKS = PR_VIEW_FIELDS.split(",").filter((f) => f !== "statusCheckRollup").join(",");
 
+// packages/core/dist/prs.js
+import * as fs11 from "node:fs";
+import * as path9 from "node:path";
+function prsDir() {
+  return path9.join(lobstahHome(), "prs");
+}
+function readPrs() {
+  let files;
+  try {
+    files = fs11.readdirSync(prsDir()).filter((f) => f.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  return files.flatMap((f) => {
+    try {
+      const r = JSON.parse(fs11.readFileSync(path9.join(prsDir(), f), "utf8"));
+      return typeof r.key === "string" && typeof r.url === "string" ? [r] : [];
+    } catch {
+      return [];
+    }
+  });
+}
+
+// packages/core/dist/chain-pr.js
+function chainPr(id, lane) {
+  const ancestry = [];
+  const seen = /* @__PURE__ */ new Set();
+  let at = id;
+  while (at && !seen.has(at)) {
+    ancestry.push(at);
+    seen.add(at);
+    at = storedDescriptor(at, lane)?.followUp;
+  }
+  const records = readPrs();
+  for (const member of ancestry.reverse()) {
+    const evidence = readEvidence(member, lane);
+    const url = evidence.prUrl ?? evidence.pr?.url;
+    const ref = url && parsePrRef(url);
+    if (ref) {
+      const record2 = records.find((pr) => pr.key === ref.key);
+      return { url: ref.url, headRefName: record2?.headRefName ?? evidence.pr?.headRefName ?? evidence.branch };
+    }
+    const record = records.find((pr) => pr.dispatches.includes(member));
+    if (record)
+      return { url: record.url, headRefName: record.headRefName };
+  }
+  return void 0;
+}
+
 // packages/core/dist/resume.js
-import * as fs10 from "node:fs";
+import * as fs12 from "node:fs";
 import * as os3 from "node:os";
-import * as path8 from "node:path";
+import * as path10 from "node:path";
 import { spawnSync } 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) {
@@ -1285,7 +1364,7 @@ function claimOf(id, lane) {
   const dirs = laneDirs(lane);
   for (const dir of [dirs.active, dirs.done]) {
     try {
-      return JSON.parse(fs10.readFileSync(path8.join(dir, id, "claim.json"), "utf8"));
+      return JSON.parse(fs12.readFileSync(path10.join(dir, id, "claim.json"), "utf8"));
     } catch {
     }
   }
@@ -1335,7 +1414,7 @@ function isUnresumable(error) {
   return error !== void 0 && UNRESUMABLE.test(error);
 }
 function worktreeProgress(worktree, trunk) {
-  if (!worktree || !fs10.existsSync(worktree))
+  if (!worktree || !fs12.existsSync(worktree))
     return "No worktree progress recorded.";
   const git2 = (...a) => spawnSync("git", a, { cwd: worktree, encoding: "utf8" }).stdout?.trim() ?? "";
   const commits = trunk ? git2("log", "--oneline", `origin/${trunk}..HEAD`) : git2("log", "--oneline", "-15");
@@ -1368,31 +1447,31 @@ function handoffNote(fromHarness, progress, why) {
 ${progress}`;
 }
 function codexHome(env = process.env) {
-  return env.CODEX_HOME ?? path8.join(os3.homedir(), ".codex");
+  return env.CODEX_HOME ?? path10.join(os3.homedir(), ".codex");
 }
 function codexRolloutFile(threadId, home = codexHome()) {
   const suffix = `-${threadId}.jsonl`;
   const walk = (dir, depth) => {
     let entries;
     try {
-      entries = fs10.readdirSync(dir, { withFileTypes: true });
+      entries = fs12.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 path8.join(dir, e.name);
+        return path10.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(path8.join(dir, e.name), depth - 1);
+      const hit = walk(path10.join(dir, e.name), depth - 1);
       if (hit)
         return hit;
     }
     return void 0;
   };
-  return walk(path8.join(home, "sessions"), 3) ?? walk(path8.join(home, "archived_sessions"), 0);
+  return walk(path10.join(home, "sessions"), 3) ?? walk(path10.join(home, "archived_sessions"), 0);
 }
 function codexDesktopThread(threadId, home = codexHome()) {
   const file = codexRolloutFile(threadId, home);
@@ -1400,12 +1479,12 @@ function codexDesktopThread(threadId, home = codexHome()) {
     return void 0;
   let head = "";
   try {
-    const fd = fs10.openSync(file, "r");
+    const fd = fs12.openSync(file, "r");
     try {
       const buf = Buffer.alloc(4096);
-      head = buf.subarray(0, fs10.readSync(fd, buf, 0, buf.length, 0)).toString("utf8");
+      head = buf.subarray(0, fs12.readSync(fd, buf, 0, buf.length, 0)).toString("utf8");
     } finally {
-      fs10.closeSync(fd);
+      fs12.closeSync(fd);
     }
   } catch {
     return void 0;
@@ -1436,23 +1515,23 @@ function droppedModelNote(harness, dropped) {
 }
 
 // packages/core/dist/worktrees.js
-import * as fs11 from "node:fs";
-import * as path9 from "node:path";
+import * as fs13 from "node:fs";
+import * as path11 from "node:path";
 var LANES = ["work", "chore"];
 function worktreePath(id) {
-  return path9.join(lobstahHome(), "worktrees", id);
+  return path11.join(lobstahHome(), "worktrees", id);
 }
 function readRecord(file) {
   try {
-    const r = JSON.parse(fs11.readFileSync(file, "utf8"));
+    const r = JSON.parse(fs13.readFileSync(file, "utf8"));
     return typeof r.path === "string" ? r : void 0;
   } catch {
     return void 0;
   }
 }
 function ownerOfPath(p) {
-  const rel = path9.relative(path9.join(lobstahHome(), "worktrees"), p);
-  if (!rel || rel.startsWith("..") || path9.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];
 }
@@ -1465,7 +1544,7 @@ function dispatchWorktree(id, lane) {
     }
     const dirs = laneDirs(l);
     for (const dir of [dirs.active, dirs.done]) {
-      const rec = readRecord(path9.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 };
@@ -1477,7 +1556,7 @@ function dispatchWorktree(id, lane) {
 function laneOf2(id) {
   for (const l of LANES) {
     const d = laneDirs(l);
-    if (fs11.existsSync(path9.join(d.queue, `${id}.json`)) || fs11.existsSync(path9.join(d.active, id)) || fs11.existsSync(path9.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;
     }
   }
@@ -1497,39 +1576,39 @@ function followUpAncestors(id, lane) {
 function chainWorktree(followUp) {
   for (const id of [followUp, ...followUpAncestors(followUp)]) {
     const wt = dispatchWorktree(id, laneOf2(id));
-    if (fs11.existsSync(wt.path))
+    if (fs13.existsSync(wt.path))
       return { ...wt, from: id };
   }
   return void 0;
 }
 function worktreeGitDir(wt) {
-  const dotGit = path9.join(wt, ".git");
+  const dotGit = path11.join(wt, ".git");
   try {
-    const st = fs11.statSync(dotGit);
+    const st = fs13.statSync(dotGit);
     if (st.isDirectory())
       return dotGit;
-    const m = /^gitdir:\s*(.+?)\s*$/m.exec(fs11.readFileSync(dotGit, "utf8"));
-    return m ? path9.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 ? path9.join(gitDir, "lobstah.lock") : void 0;
+  return gitDir ? path11.join(gitDir, "lobstah.lock") : void 0;
 }
 function readWorktreeLock(wt) {
   const file = worktreeLockFile(wt);
   if (!file)
     return void 0;
   try {
-    return JSON.parse(fs11.readFileSync(file, "utf8"));
+    return JSON.parse(fs13.readFileSync(file, "utf8"));
   } catch {
     return void 0;
   }
 }
 function lockIsLive(lock) {
-  return fs11.existsSync(path9.join(laneDirs(lock.lane).active, lock.id));
+  return fs13.existsSync(path11.join(laneDirs(lock.lane).active, lock.id));
 }
 function worktreeHolder(wt) {
   const lock = readWorktreeLock(wt);
@@ -1542,7 +1621,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 {
-      fs11.writeFileSync(file, JSON.stringify(mine, null, 2), { flag: "wx" });
+      fs13.writeFileSync(file, JSON.stringify(mine, null, 2), { flag: "wx" });
       return void 0;
     } catch (err) {
       if (err.code !== "EEXIST")
@@ -1550,7 +1629,7 @@ function acquireWorktreeLock(wt, id, lane) {
     }
     let raw;
     try {
-      raw = fs11.readFileSync(file, "utf8");
+      raw = fs13.readFileSync(file, "utf8");
     } catch {
       continue;
     }
@@ -1561,14 +1640,14 @@ function acquireWorktreeLock(wt, id, lane) {
       held2 = void 0;
     }
     if (held2?.id === id) {
-      fs11.writeFileSync(file, JSON.stringify(mine, null, 2));
+      fs13.writeFileSync(file, JSON.stringify(mine, null, 2));
       return void 0;
     }
     if (held2 && lockIsLive(held2))
       return held2;
     try {
-      if (fs11.readFileSync(file, "utf8") === raw)
-        fs11.rmSync(file, { force: true });
+      if (fs13.readFileSync(file, "utf8") === raw)
+        fs13.rmSync(file, { force: true });
     } catch {
     }
   }
@@ -1580,7 +1659,7 @@ function releaseWorktreeLock(wt, id) {
   if (!file)
     return;
   if (readWorktreeLock(wt)?.id === id)
-    fs11.rmSync(file, { force: true });
+    fs13.rmSync(file, { force: true });
 }
 
 // packages/core/dist/slots.js
@@ -1589,8 +1668,8 @@ function isTrapCatch(id, lane) {
 }
 
 // packages/runner/src/run.ts
-import * as fs15 from "node:fs";
-import * as path13 from "node:path";
+import * as fs17 from "node:fs";
+import * as path15 from "node:path";
 import { execFileSync } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
@@ -1884,25 +1963,25 @@ function createClaudeAdapter() {
 }
 
 // packages/adapters/dist/codex.js
-import * as fs12 from "node:fs";
+import * as fs14 from "node:fs";
 import * as os4 from "node:os";
-import * as path10 from "node:path";
+import * as path12 from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 function isolatedCodexHome() {
-  const dir = path10.join(lobstahHome(), "codex-home");
-  fs12.mkdirSync(dir, { recursive: true });
-  const auth = path10.join(dir, "auth.json");
-  const realAuth = path10.join(os4.homedir(), ".codex", "auth.json");
-  if (!fs12.existsSync(auth) && fs12.existsSync(realAuth)) {
+  const dir = path12.join(lobstahHome(), "codex-home");
+  fs14.mkdirSync(dir, { recursive: true });
+  const auth = path12.join(dir, "auth.json");
+  const realAuth = path12.join(os4.homedir(), ".codex", "auth.json");
+  if (!fs14.existsSync(auth) && fs14.existsSync(realAuth)) {
     try {
-      fs12.symlinkSync(realAuth, auth);
+      fs14.symlinkSync(realAuth, auth);
     } catch {
-      fs12.copyFileSync(realAuth, auth);
+      fs14.copyFileSync(realAuth, auth);
     }
   }
-  const cfg = path10.join(dir, "config.toml");
-  if (!fs12.existsSync(cfg)) {
-    fs12.writeFileSync(cfg, "# lobstah-managed: auth inherited from ~/.codex, interactive config not\n");
+  const cfg = path12.join(dir, "config.toml");
+  if (!fs14.existsSync(cfg)) {
+    fs14.writeFileSync(cfg, "# lobstah-managed: auth inherited from ~/.codex, interactive config not\n");
   }
   return dir;
 }
@@ -2103,8 +2182,8 @@ function loadAdapter(name) {
 }
 
 // packages/worktree/dist/index.js
-import * as fs13 from "node:fs";
-import * as path11 from "node:path";
+import * as fs15 from "node:fs";
+import * as path13 from "node:path";
 import { createHash } from "node:crypto";
 import { exec, execFile } from "node:child_process";
 import { promisify } from "node:util";
@@ -2161,10 +2240,10 @@ ${gitStderr(err)}`, { cause: err });
 }
 async function allocate(repo, id) {
   const dir = worktreePath(id);
-  if (fs13.existsSync(dir)) {
+  if (fs15.existsSync(dir)) {
     throw new Error(`worktree for ${id} already exists at ${dir} \u2014 never allocate a second`);
   }
-  if (!fs13.existsSync(repo.path)) {
+  if (!fs15.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 });
@@ -2200,38 +2279,40 @@ function setupHash(repo, dir) {
   const h = createHash("sha256");
   h.update(JSON.stringify(repo.setup ?? []));
   for (const name of LOCKFILES) {
-    const file = path11.join(dir, name);
-    if (!fs13.existsSync(file))
+    const file = path13.join(dir, name);
+    if (!fs15.existsSync(file))
       continue;
     h.update(`\0${name}\0`);
-    h.update(fs13.readFileSync(file));
+    h.update(fs15.readFileSync(file));
   }
   return h.digest("hex");
 }
 function setupRecordFile(dir) {
   const gitDir = worktreeGitDir(dir);
-  return gitDir ? path11.join(gitDir, "lobstah-setup.json") : void 0;
+  return gitDir ? path13.join(gitDir, "lobstah-setup.json") : void 0;
 }
 function recordSetup(repo, dir) {
   const file = setupRecordFile(dir);
   if (file)
-    fs13.writeFileSync(file, JSON.stringify({ hash: setupHash(repo, dir), at: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
+    fs15.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(fs13.readFileSync(file, "utf8")).hash : void 0;
+    return file ? JSON.parse(fs15.readFileSync(file, "utf8")).hash : void 0;
   } catch {
     return void 0;
   }
 }
 var short = (s) => s.slice(0, 8);
 function realpath(p) {
+  let r;
   try {
-    return fs13.realpathSync(p);
+    r = fs15.realpathSync.native(p);
   } catch {
-    return path11.resolve(p);
+    r = path13.resolve(p);
   }
+  return process.platform === "win32" ? r.toLowerCase() : r;
 }
 function norm(p) {
   return p.replace(/^"(.*)"$/, "$1").replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
@@ -2271,8 +2352,8 @@ async function chooseWorktree(input) {
   for (const t of listTraps()) {
     if (typeof t.worktree !== "string")
       continue;
-    const rel = path11.relative(here, realpath(t.worktree));
-    if (!rel.startsWith("..") && !path11.isAbsolute(rel))
+    const rel = path13.relative(here, realpath(t.worktree));
+    if (!rel.startsWith("..") && !path13.isAbsolute(rel))
       return { reuse: false, reason: "origin worktree is a trap\u2019s" };
   }
   for (const l of ["work", "chore"]) {
@@ -2325,9 +2406,11 @@ function buildPrompt(brief, opts) {
     reporting,
     `Use \`needs-decision\` when you are blocked on a question only a human can answer, then stop. New operator messages may arrive between your turns as user messages; treat them as instructions from the dispatcher.`,
     `Before you wait on something outside lobstah (a human review, a PR review, a deploy), report \`lobstah report ${opts.id} paused "<note>" --waiting-on ${WAITING_ON.join("|")} --link <url>\`. Report \`working\` when you resume.`,
-    `Commit your work with clear messages. The runner pushes committed HEAD early and opens or adopts one draft PR for the branch when available; do not create a duplicate PR. When finished, mark the draft ready for review if appropriate, then report done with its URL. Do not merge anything.`,
+    opts.existingPr ? `Commit your work with clear messages. This chain already has PR ${opts.existingPr.url}. The runner does not push or open another PR. Push your changes to its existing head branch${opts.existingPr.headRefName ? ` ${opts.existingPr.headRefName}` : " (inspect the PR to find it)"}; do not create a duplicate PR. Report done with the same PR URL. Do not merge anything.` : `Commit your work with clear messages. The runner pushes committed HEAD early and opens or adopts one draft PR for the branch when available; do not create a duplicate PR. When finished, mark the draft ready for review if appropriate, then report done with its URL. Do not merge anything.`,
     `--- BRIEF ---`,
-    brief
+    opts.existingPr ? `${brief}
+
+Existing chain PR: ${opts.existingPr.url}. Head branch: ${opts.existingPr.headRefName ?? "inspect the PR"}. The runner will not push this follow-up.` : brief
   ];
   if (opts.attachments?.length) parts.push(attachmentBlock(opts.attachments));
   if (opts.nudge) parts.push(`--- SUPERVISOR NOTE ---`, opts.nudge);
@@ -2607,8 +2690,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 fs14 from "node:fs";
-import * as path12 from "node:path";
+import * as fs16 from "node:fs";
+import * as path14 from "node:path";
 var exec2 = promisify2(execFile2);
 function firstLine(err) {
   const stderr = err && typeof err === "object" && "stderr" in err ? String(err.stderr).trim() : "";
@@ -2623,9 +2706,9 @@ function checkpointAllowed(file) {
   return true;
 }
 function keepRemote(opts) {
-  const { id, lane, cwd, trunk, policy } = opts;
+  const { id, lane, cwd, trunk, policy, existingPrUrl } = opts;
   const command = async (bin, args, timeout = 12e4) => {
-    const file = bin === "gh" ? resolveOnPath("gh") ?? bin : bin;
+    const file = bin === "gh" || bin === "lobstah" ? resolveOnPath(bin) ?? bin : bin;
     return (await exec2(file, args, {
       cwd,
       encoding: "utf8",
@@ -2636,6 +2719,14 @@ function keepRemote(opts) {
   };
   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 = path14.resolve(path14.dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+    const localCli = path14.join(root, "apps", "cli", "dist", "main.js");
+    const args = ["watch", "add", url, "--for", id];
+    if (fs16.existsSync(localCli)) await command(process.execPath, [localCli, ...args], 15e3);
+    else await command("lobstah", args, 15e3);
+  };
   let lastSeenHead;
   let pushedHead;
   let busy;
@@ -2645,6 +2736,10 @@ function keepRemote(opts) {
   let pushProblem;
   let draftProblem;
   const trapClaimed = () => isTrapCatch(id, lane);
+  const existingWatch = existingPrUrl && parsePrRef(existingPrUrl);
+  const watching = existingWatch && !readWatch(existingWatch.key) ? (async () => {
+    await registerWatch(existingWatch.url).catch((err) => note(`PR watch unavailable: ${firstLine(err)}`));
+  })() : void 0;
   const branchName = async () => {
     const branch = await git2("symbolic-ref", "--quiet", "--short", "HEAD").catch(() => "");
     if (!branch || branch === trunk || branch === `origin/${trunk}`) return void 0;
@@ -2683,12 +2778,11 @@ function keepRemote(opts) {
     opened = true;
     draftProblem = void 0;
     mergeEvidence(id, lane, { prUrl: match[0] });
-    const bin = path12.resolve(path12.dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "bin", "lobstah");
-    await command(fs14.existsSync(bin) ? bin : "lobstah", ["watch", "add", match[0], "--for", id], 15e3).catch(() => {
+    await registerWatch(match[0]).catch(() => {
     });
   };
   const check = async () => {
-    if (!policy.pushEarly || trapClaimed()) return;
+    if (!policy.pushEarly || trapClaimed() || existingPrUrl) return;
     const branch = await branchName();
     if (!branch) return;
     const head = await git2("rev-parse", "HEAD");
@@ -2727,6 +2821,7 @@ function keepRemote(opts) {
       await busy;
       await check().catch((err) => note(`final push unavailable: ${firstLine(err)}`));
       await opening;
+      await watching;
     },
     saveBeforeStop: async () => {
       stopped = true;
@@ -2757,9 +2852,10 @@ function keepRemote(opts) {
       }
       await check().catch((err) => note(`final push unavailable: ${firstLine(err)}`));
       await opening;
+      await watching;
       const head = await git2("rev-parse", "--short", "HEAD").catch(() => "unknown");
       const pr = readEvidence(id, lane).prUrl;
-      const message = `${saved}; ${branch}@${head}${pr ? `; draft PR ${pr}` : ""}${pushProblem ? `; ${pushProblem}` : ""}${draftProblem ? `; ${draftProblem}` : ""}`;
+      const message = `${saved}; ${branch}@${head}${pr ? `; ${existingPrUrl ? "existing" : "draft"} PR ${pr}` : ""}${pushProblem ? `; ${pushProblem}` : ""}${draftProblem ? `; ${draftProblem}` : ""}`;
       note(message);
       return message;
     }
@@ -2776,23 +2872,23 @@ function coldNote(cold, cwd, trunk) {
 }
 async function main(activeDir, lane, seams = {}) {
   const deps = { ...defaultDeps, ...seams };
-  const id = path13.basename(activeDir);
+  const id = path15.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(fs15.readFileSync(path13.join(activeDir, "descriptor.json"), "utf8"));
+  const descriptor = JSON.parse(fs17.readFileSync(path15.join(activeDir, "descriptor.json"), "utf8"));
   const resolved = resolveDispatch(descriptor, cfg);
   const repo = cfg.repos[descriptor.repo];
-  const briefFile = path13.join(activeDir, "brief.md");
-  if (!fs15.existsSync(briefFile)) fs15.writeFileSync(briefFile, descriptor.brief);
-  const brief = fs15.readFileSync(briefFile, "utf8");
+  const briefFile = path15.join(activeDir, "brief.md");
+  if (!fs17.existsSync(briefFile)) fs17.writeFileSync(briefFile, descriptor.brief);
+  const brief = fs17.readFileSync(briefFile, "utf8");
   const attempts = Number(process.env.LOBSTAH_ATTEMPTS ?? "1");
   const runnerInfo = {
     pid: process.pid,
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     attempts
   };
-  fs15.writeFileSync(path13.join(activeDir, "runner.json"), JSON.stringify(runnerInfo, null, 2));
+  fs17.writeFileSync(path15.join(activeDir, "runner.json"), JSON.stringify(runnerInfo, null, 2));
   const plan = planStart({
     id,
     lane,
@@ -2801,13 +2897,13 @@ async function main(activeDir, lane, seams = {}) {
     resolvedHarness: resolved.harness,
     envResume: process.env.LOBSTAH_RESUME
   });
-  const wtFile = path13.join(activeDir, "worktree.json");
+  const wtFile = path15.join(activeDir, "worktree.json");
   let recorded;
   let choice;
-  if (fs15.existsSync(wtFile)) {
-    recorded = JSON.parse(fs15.readFileSync(wtFile, "utf8")).path;
-    if (!fs15.existsSync(recorded)) throw new Error(`recorded worktree ${recorded} is gone`);
-  } else if (fs15.existsSync(worktreePath(id))) {
+  if (fs17.existsSync(wtFile)) {
+    recorded = JSON.parse(fs17.readFileSync(wtFile, "utf8")).path;
+    if (!fs17.existsSync(recorded)) throw new Error(`recorded worktree ${recorded} is gone`);
+  } else if (fs17.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 });
@@ -2841,14 +2937,16 @@ async function main(activeDir, lane, seams = {}) {
       type: "runner",
       data: { worktree: cwd, worktreeOf: choice.owner, setupRan }
     });
-    fs15.writeFileSync(wtFile, JSON.stringify({ path: cwd, of: choice.owner }, null, 2));
+    fs17.writeFileSync(wtFile, JSON.stringify({ path: cwd, of: choice.owner }, null, 2));
   } else {
     cwd = await deps.allocate(repo, id);
     acquireWorktreeLock(cwd, id, lane);
-    fs15.writeFileSync(wtFile, JSON.stringify({ path: cwd }, null, 2));
+    fs17.writeFileSync(wtFile, JSON.stringify({ path: cwd }, null, 2));
   }
-  const worktreeOf = JSON.parse(fs15.readFileSync(wtFile, "utf8")).of;
+  const worktreeOf = JSON.parse(fs17.readFileSync(wtFile, "utf8")).of;
   mergeEvidence(id, lane, { worktree: cwd, worktreeOf });
+  const existingPr = descriptor.followUp ? chainPr(descriptor.followUp, lane) : void 0;
+  if (existingPr) mergeEvidence(id, lane, { prUrl: existingPr.url });
   const remotePolicy = {
     pushEarly: repo.pushEarly ?? cfg.limits.pushEarly,
     draftPr: repo.draftPr ?? cfg.limits.draftPr,
@@ -2861,19 +2959,20 @@ async function main(activeDir, lane, seams = {}) {
     cwd,
     trunk: repo.trunk,
     title: descriptor.brief.split("\n")[0]?.trim() || `Lobstah dispatch ${short3(id)}`,
-    policy: remotePolicy
+    policy: remotePolicy,
+    existingPrUrl: existingPr?.url
   });
   const envNudge = process.env.LOBSTAH_NUDGE;
   const planNudge = plan.cold && !envNudge ? coldNote(plan.cold, cwd, repo.trunk) : void 0;
-  const promptWith = (nudge) => buildPrompt(brief, { id, nudge, attachments: descriptor.attachments });
-  const binDir = path13.resolve(path13.dirname(fileURLToPath2(import.meta.url)), "..", "..", "..", "bin");
-  const workerPath = fs15.existsSync(path13.join(binDir, "lobstah")) ? `${binDir}${path13.delimiter}${process.env.PATH ?? ""}` : void 0;
+  const promptWith = (nudge) => buildPrompt(brief, { id, nudge, attachments: descriptor.attachments, existingPr });
+  const binDir = path15.resolve(path15.dirname(fileURLToPath2(import.meta.url)), "..", "..", "..", "bin");
+  const workerPath = fs17.existsSync(path15.join(binDir, "lobstah")) ? `${binDir}${path15.delimiter}${process.env.PATH ?? ""}` : void 0;
   let wallClockHit = false;
   let current;
-  const wallFile = path13.join(activeDir, "wallclock.json");
+  const wallFile = path15.join(activeDir, "wallclock.json");
   const wallState = (() => {
     try {
-      return JSON.parse(fs15.readFileSync(wallFile, "utf8"));
+      return JSON.parse(fs17.readFileSync(wallFile, "utf8"));
     } catch {
       return { elapsedMs: 0, windowMs: resolved.limits.wallClockSecs * 1e3 };
     }
@@ -2892,8 +2991,8 @@ async function main(activeDir, lane, seams = {}) {
   ) * 1e3;
   const persistWall = (elapsedMs, windowMs) => {
     const tmp = `${wallFile}.tmp-${process.pid}`;
-    fs15.writeFileSync(tmp, JSON.stringify({ ...wallState, elapsedMs, windowMs }));
-    fs15.renameSync(tmp, wallFile);
+    fs17.writeFileSync(tmp, JSON.stringify({ ...wallState, elapsedMs, windowMs }));
+    fs17.renameSync(tmp, wallFile);
   };
   const madeProgress = () => {
     const activity = readActivity(id, lane);
@@ -3013,10 +3112,10 @@ async function main(activeDir, lane, seams = {}) {
 function runRunner(activeDirArg2, laneArg2) {
   const lane = laneArg2 === "chore" ? "chore" : "work";
   main(activeDirArg2, lane).catch((err) => {
-    const id = path14.basename(activeDirArg2);
+    const id = path16.basename(activeDirArg2);
     try {
       appendStatus(id, lane, "failed", String(err instanceof Error ? err.message : err).slice(0, 500));
-      fs16.renameSync(activeDirArg2, path14.join(laneDirs(lane).done, id));
+      fs18.renameSync(activeDirArg2, path16.join(laneDirs(lane).done, id));
     } catch {
     }
     process.exitCode = 1;