lobstah 0.6.2 → 0.6.3

package/dist/main.js

@@ -649,6 +649,9 @@ function checkOptions(raw) {
   return options;
 }
 function askDecision(opts) {
+  if (opts.replace !== void 0 && !standingDecisions().some((d) => d.key === opts.replace)) {
+    throw new DecisionError(`no standing decision ${opts.replace} to replace \u2014 \`lobstah man tend\` lists them`);
+  }
   const title = checkTitle(opts.title);
   const options = checkOptions(opts.options ?? []);
   let detail = opts.detailText ?? "";
@@ -709,7 +712,7 @@ ${title}`).digest("hex").slice(0, 16)
   writeAtomic(path6.join(dir, DETAIL_MD), detail);
   writeAtomic(path6.join(dir, DECISION_JSON), `${JSON.stringify(meta, null, 2)}
 `);
-  const replaced = opts.dispatch && opts.replace !== false ? standingDecisions().filter((d) => d.key !== key && d.dispatch === opts.dispatch && d.lane === opts.lane).map((d) => d.key) : [];
+  const replaced = opts.replace !== void 0 && opts.replace !== key ? [opts.replace] : [];
   for (const old of replaced)
     fs6.rmSync(decisionDir(old), { recursive: true, force: true });
   return { meta, replaced };
@@ -4205,6 +4208,35 @@ function bounceTrapMessages(trapId) {
   }
   return msgs.length;
 }
+function messageTexts(id, lane) {
+  const dir = inboxDir(id, lane);
+  const texts = [];
+  for (const d of [dir, path19.join(dir, "handled")]) {
+    let files;
+    try {
+      files = fs21.readdirSync(d).filter((f) => f.endsWith(".msg"));
+    } catch {
+      continue;
+    }
+    for (const f of files) {
+      try {
+        texts.push(fs21.readFileSync(path19.join(d, f), "utf8"));
+      } catch {
+      }
+    }
+  }
+  return texts;
+}
+function trapMessageTexts(trapId, sinceMs = 0) {
+  return messageTexts(trapKey(trapId), "work").flatMap((raw) => {
+    try {
+      const m = JSON.parse(raw);
+      return (Date.parse(m.at ?? "") || 0) >= sinceMs ? [m.text ?? ""] : [];
+    } catch {
+      return sinceMs > 0 ? [] : [raw];
+    }
+  });
+}
 var metaName, trapKey;
 var init_inbox = __esm({
   "packages/core/dist/inbox.js"() {
@@ -5602,7 +5634,7 @@ var init_dist2 = __esm({
 import * as fs30 from "node:fs";
 import * as path26 from "node:path";
 import { createHash as createHash6 } from "node:crypto";
-import { exec, execFile } from "node:child_process";
+import { exec, execFile, execFileSync as execFileSync3 } from "node:child_process";
 import { promisify } from "node:util";
 async function git2(cwd, ...args) {
   const { stdout } = await run("git", args, { cwd, env: process.env });
@@ -5632,6 +5664,140 @@ ${gitStderr(err)}`, { cause: err });
     }
   }
 }
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function takeRepoLock(file, mine) {
+  try {
+    fs30.writeFileSync(file, mine, { flag: "wx" });
+    return { state: "held" };
+  } catch (err) {
+    const code = err.code ?? "";
+    if (code !== "EEXIST" && !BUSY.has(code))
+      throw err;
+  }
+  let raw = "";
+  let age2 = 0;
+  try {
+    raw = fs30.readFileSync(file, "utf8");
+    age2 = Date.now() - fs30.statSync(file).mtimeMs;
+  } catch {
+    return { state: "retry" };
+  }
+  let holder;
+  try {
+    holder = JSON.parse(raw);
+  } catch {
+    holder = void 0;
+  }
+  const stale = age2 > REPO_LOCK_WAIT_MS || (holder ? !pidAlive(holder.pid) : age2 > 5e3);
+  if (stale) {
+    try {
+      if (fs30.readFileSync(file, "utf8") === raw)
+        fs30.rmSync(file, { force: true });
+    } catch {
+    }
+    return { state: "retry" };
+  }
+  return { state: "wait", ...holder ? { holder: holder.pid } : {} };
+}
+function releaseRepoLock(file, mine) {
+  try {
+    if (fs30.readFileSync(file, "utf8") === mine)
+      fs30.rmSync(file, { force: true, recursive: true, maxRetries: 5 });
+  } catch {
+  }
+}
+async function withRepoLock(common, fn) {
+  const file = path26.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);
+    if (took.state === "held") {
+      held = true;
+      break;
+    }
+    if (took.state === "wait")
+      await new Promise((r) => setTimeout(r, 50 + Math.random() * 50));
+  }
+  try {
+    await fn();
+  } finally {
+    if (held)
+      releaseRepoLock(file, mine);
+  }
+}
+function withRepoLockSync(cwd, fn) {
+  let common;
+  try {
+    common = execFileSync3("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return fn();
+  }
+  const file = path26.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;
+  const pause = new Int32Array(new SharedArrayBuffer(4));
+  let held = false;
+  while (Date.now() < deadline) {
+    const took = takeRepoLock(file, mine);
+    if (took.state === "held") {
+      held = true;
+      break;
+    }
+    if (took.state === "wait") {
+      if (took.holder === process.pid)
+        break;
+      Atomics.wait(pause, 0, 0, 50 + Math.random() * 50);
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    if (held)
+      releaseRepoLock(file, mine);
+  }
+}
+async function oneAtATime(cwd, fn) {
+  const common = await git2(cwd, "rev-parse", "--path-format=absolute", "--git-common-dir");
+  const key = realpath(common);
+  const run4 = (repoQueues.get(key) ?? Promise.resolve()).then(() => withRepoLock(common, () => fn(common)));
+  const tail = run4.catch(() => {
+  });
+  repoQueues.set(key, tail);
+  try {
+    await run4;
+  } finally {
+    if (repoQueues.get(key) === tail)
+      repoQueues.delete(key);
+  }
+}
+function fetchStamps(common) {
+  try {
+    return JSON.parse(fs30.readFileSync(path26.join(common, "lobstah-fetch.json"), "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function fetchShared(cwd, remote, ref) {
+  const asked = Date.now();
+  const key = `${remote} ${ref}`;
+  await oneAtATime(cwd, async (common) => {
+    if ((fetchStamps(common)[key] ?? -Infinity) >= asked)
+      return;
+    const started = Date.now();
+    await gitShared(cwd, "fetch", remote, ref);
+    const stamps = { ...fetchStamps(common), [key]: started };
+    fs30.writeFileSync(path26.join(common, "lobstah-fetch.json"), JSON.stringify(stamps, null, 2));
+  });
+}
 async function allocate(repo, id, fromRemoteBranch = repo.trunk) {
   const dir = worktreePath(id);
   if (fs30.existsSync(dir)) {
@@ -5642,8 +5808,10 @@ async function allocate(repo, id, fromRemoteBranch = repo.trunk) {
       throw new Error(`repo path ${repo.path} missing and no origin configured`);
     await run("git", ["clone", repo.origin, repo.path], { env: process.env });
   }
-  await gitShared(repo.path, "fetch", "origin", fromRemoteBranch);
-  await gitShared(repo.path, "worktree", "add", "--no-track", dir, "-b", `lobstah/${id}`, `origin/${fromRemoteBranch}`);
+  await fetchShared(repo.path, "origin", fromRemoteBranch);
+  await oneAtATime(repo.path, async () => {
+    await gitShared(repo.path, "worktree", "add", "--no-track", dir, "-b", `lobstah/${id}`, `origin/${fromRemoteBranch}`);
+  });
   await runSetup(repo, dir);
   return dir;
 }
@@ -5760,7 +5928,7 @@ async function chooseWorktree(input) {
   return { reuse: true, path: found.path, owner: found.owner, from: found.from };
 }
 async function prepareReuse(repo, dir) {
-  await gitShared(dir, "fetch", "origin", repo.trunk);
+  await fetchShared(dir, "origin", repo.trunk);
   if (!repo.setup?.length)
     return { setupRan: false };
   if (recordedSetupHash(dir) === setupHash(repo, dir))
@@ -5876,7 +6044,7 @@ async function removeIfSafe(dir, opts = {}) {
   }
   return { removed: true, primary, deletedBranches, keptBranches };
 }
-var run, shell, LOCK_CONTENTION, ATTEMPTS, LOCKFILES, short;
+var run, shell, LOCK_CONTENTION, ATTEMPTS, REPO_LOCK_WAIT_MS, repoQueues, BUSY, LOCKFILES, short;
 var init_dist3 = __esm({
   "packages/worktree/dist/index.js"() {
     "use strict";
@@ -5901,9 +6069,17 @@ var init_dist3 = __esm({
       // held by another process ("fetching ref <ref> failed: reference already
       // exists"). The files backend maps the lock's EEXIST to this reason; older
       // git printed "Unable to create '<ref>.lock': File exists" instead.
-      /reference already exists/
+      /reference already exists/,
+      // Windows: two fetches unpack the same loose object, and one cannot write
+      // the file the other holds open ("unable to write file
+      // .git/objects/<xx>/<rest>: Permission denied", then "unpack-objects
+      // failed"). Only an object path matches, not any denied write.
+      /unable to write file \S*objects[\\/][0-9a-f]{2}[\\/][0-9a-f]{38,}: Permission denied/
     ];
     ATTEMPTS = 6;
+    REPO_LOCK_WAIT_MS = 5 * 6e4;
+    repoQueues = /* @__PURE__ */ new Map();
+    BUSY = /* @__PURE__ */ new Set(["EPERM", "EACCES", "EBUSY"]);
     LOCKFILES = [
       "pnpm-lock.yaml",
       "package-lock.json",
@@ -6813,6 +6989,7 @@ var init_plan = __esm({
 function startWallClock(opts) {
   const now2 = opts.now ?? Date.now;
   const tickMs = Math.max(1, Math.min(opts.tickMs ?? 5e3, opts.limitMs));
+  const sleepGapMs = opts.sleepGapMs ?? Math.max(6e4, tickMs * 6);
   let elapsed = opts.initialElapsedMs ?? 0;
   const maxMs = Math.max(opts.limitMs, opts.maxMs ?? opts.limitMs);
   let windowMs = Math.min(maxMs, Math.max(opts.limitMs, opts.initialWindowMs ?? opts.limitMs));
@@ -6826,8 +7003,9 @@ function startWallClock(opts) {
     } catch {
       paused = false;
     }
+    const step = Math.max(0, t - last);
     if (!paused)
-      elapsed += t - last;
+      elapsed += step > sleepGapMs ? Math.min(step, tickMs) : step;
     last = t;
     if (!done && elapsed >= windowMs && elapsed < maxMs) {
       let advanced = false;
@@ -7067,8 +7245,18 @@ var init_remote = __esm({
 // packages/runner/dist/run.js
 import * as fs70 from "node:fs";
 import * as path57 from "node:path";
-import { execFileSync as execFileSync8 } from "node:child_process";
+import { execFileSync as execFileSync9 } from "node:child_process";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
+function livePrState(url) {
+  const ref = parsePrRef(url);
+  if (!ref)
+    return void 0;
+  try {
+    return ghPrView(ref).state;
+  } catch {
+    return void 0;
+  }
+}
 function within(p, ms, fallback) {
   let timer;
   const late = new Promise((resolve13) => timer = setTimeout(() => resolve13(fallback), ms));
@@ -7109,6 +7297,14 @@ async function main(activeDir, lane, seams = {}) {
     attempts
   };
   fs70.writeFileSync(path57.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") {
+      status("failed", `cancelled: ${descriptor.pr.url} is ${state.toLowerCase()}; nothing to repair`);
+      complete(id, lane);
+      return;
+    }
+  }
   const plan = planStart({
     id,
     lane,
@@ -7213,7 +7409,7 @@ async function main(activeDir, lane, seams = {}) {
   })();
   const head = () => {
     try {
-      return execFileSync8("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+      return execFileSync9("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
     } catch {
       return void 0;
     }
@@ -7393,7 +7589,8 @@ var init_run = __esm({
       chooseWorktree,
       prepareReuse,
       collectEvidence,
-      reap: async () => 0
+      reap: async () => 0,
+      prState: livePrState
     };
     DONE_WAIT_MS = 2e3;
     short3 = (s) => s.slice(0, 8);
@@ -7401,10 +7598,10 @@ var init_run = __esm({
 });
 
 // packages/runner/dist/reap.js
-import { execFileSync as execFileSync9 } from "node:child_process";
+import { execFileSync as execFileSync10 } from "node:child_process";
 function listProcesses() {
   if (process.platform === "win32") {
-    const out2 = execFileSync9("powershell.exe", [
+    const out2 = execFileSync10("powershell.exe", [
       "-NoProfile",
       "-NonInteractive",
       "-Command",
@@ -7412,7 +7609,7 @@ function listProcesses() {
     ], { encoding: "utf8", windowsHide: true, timeout: 3e4, stdio: ["ignore", "pipe", "ignore"] });
     return out2.split(/\r?\n/).map((l) => l.trim().split(/\s+/).map(Number)).filter(([pid, ppid]) => Number.isInteger(pid) && Number.isInteger(ppid)).map(([pid, ppid]) => ({ pid, ppid }));
   }
-  const out = execFileSync9("ps", ["-A", "-o", "pid=,ppid=,pgid="], {
+  const out = execFileSync10("ps", ["-A", "-o", "pid=,ppid=,pgid="], {
     encoding: "utf8",
     timeout: 3e4,
     stdio: ["ignore", "pipe", "ignore"]
@@ -7452,7 +7649,7 @@ async function stopPids(pids, graceMs = 2e3) {
   if (process.platform === "win32") {
     for (const pid of pids) {
       try {
-        execFileSync9("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true, timeout: 3e4 });
+        execFileSync10("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true, timeout: 3e4 });
       } catch {
       }
     }
@@ -7556,7 +7753,7 @@ import { fileURLToPath as fileURLToPath6 } from "node:url";
 
 // packages/supervisor/dist/liveness.js
 init_dist2();
-import { execFileSync as execFileSync3 } from "node:child_process";
+import { execFileSync as execFileSync4 } from "node:child_process";
 function classify(input) {
   const { hasRunner, alive: alive2, lastVerb, lastEventAt: lastEventAt2, startedAt, now: now2, wedgeThresholdMs } = input;
   if (lastVerb && TERMINAL_VERBS.includes(lastVerb))
@@ -7577,15 +7774,15 @@ function classify(input) {
 function processStartTime(pid) {
   try {
     if (process.platform === "win32") {
-      const out = execFileSync3("powershell.exe", ["-NoProfile", "-Command", `(Get-Process -Id ${pid}).StartTime.Ticks`], { encoding: "utf8" }).trim();
+      const out = execFileSync4("powershell.exe", ["-NoProfile", "-Command", `(Get-Process -Id ${pid}).StartTime.Ticks`], { encoding: "utf8" }).trim();
       return out || void 0;
     }
-    return execFileSync3("ps", ["-p", String(pid), "-o", "lstart="], { encoding: "utf8" }).trim() || void 0;
+    return execFileSync4("ps", ["-p", String(pid), "-o", "lstart="], { encoding: "utf8" }).trim() || void 0;
   } catch {
     return void 0;
   }
 }
-function pidAlive(pid, recordedStart) {
+function pidAlive2(pid, recordedStart) {
   try {
     process.kill(pid, 0);
   } catch {
@@ -7599,7 +7796,7 @@ function pidAlive(pid, recordedStart) {
 function killGroup(pid, signal = "SIGTERM") {
   if (process.platform === "win32") {
     try {
-      execFileSync3("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore" });
+      execFileSync4("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore" });
     } catch {
     }
     return;
@@ -7820,7 +8017,7 @@ function sessionOf(st) {
     return void 0;
   }
 }
-function reconcileOne(st, cfg, log, spawnHeadless = spawnRunner) {
+function reconcileOne(st, cfg, log, spawnHeadless = spawnRunner, resumeGrace = false) {
   const hasDescriptor = fs32.existsSync(path28.join(st.dir, "descriptor.json"));
   if (!hasDescriptor) {
     const age2 = Date.now() - fs32.statSync(st.dir).mtimeMs;
@@ -7830,7 +8027,7 @@ function reconcileOne(st, cfg, log, spawnHeadless = spawnRunner) {
   }
   const statusLog = readStatusLog(st.id, st.lane);
   const lastVerb = statusLog.at(-1)?.verb;
-  const alive2 = st.runner ? pidAlive(st.runner.pid, st.runner.processStartTime) : void 0;
+  const alive2 = st.runner ? pidAlive2(st.runner.pid, st.runner.processStartTime) : void 0;
   const sessionClaim = readSessionClaim(st.id, st.lane);
   if (sessionClaim) {
     if (lastVerb === "done" || lastVerb === "failed") {
@@ -7900,6 +8097,8 @@ function reconcileOne(st, cfg, log, spawnHeadless = spawnRunner) {
       break;
     }
     case "wedged": {
+      if (resumeGrace)
+        break;
       const attempts = (st.runner?.attempts ?? 0) + 1;
       if (st.runner)
         killGroup(st.runner.pid, "SIGKILL");
@@ -7933,7 +8132,7 @@ function wakeReason(id, lane, now2 = Date.now()) {
 }
 function wakeParked(lane, free, log, spawnHeadless = spawnRunner, now2 = Date.now()) {
   let woke = 0;
-  const parked = listActive(lane).filter((st) => st.runner && !isTrapCatch(st.id, lane) && isParked(st.id, lane) && !cancelRequested(st.id, lane) && !pidAlive(st.runner.pid, st.runner.processStartTime));
+  const parked = listActive(lane).filter((st) => st.runner && !isTrapCatch(st.id, lane) && isParked(st.id, lane) && !cancelRequested(st.id, lane) && !pidAlive2(st.runner.pid, st.runner.processStartTime));
   for (const st of parked) {
     if (woke >= free)
       break;
@@ -8068,10 +8267,12 @@ function tick(log = () => {
   ensureLayout();
   const now2 = hooks.now?.() ?? Date.now();
   const ttl = cfg.soak.ttlSecs * 1e3;
+  const wedgeMs = cfg.limits.wedgeThresholdSecs * 1e3;
   const home = lobstahHome();
   const timing = tickTimes.get(home);
-  const resumed = timing && now2 - timing.last > ttl ? now2 : timing?.resumed;
+  const resumed = timing && now2 - timing.last > Math.min(ttl, wedgeMs) ? now2 : timing?.resumed;
   tickTimes.set(home, { last: now2, resumed });
+  const wedgeGrace = resumed !== void 0 && now2 - resumed <= wedgeMs;
   writeHeartbeat(cfg);
   hooks.prWatches?.(hooks.now?.() ?? Date.now(), log);
   for (const action of resumed !== void 0 && now2 - resumed <= ttl ? [] : sweepGhostTraps(ttl, now2, cfg.soak.pausedTtlSecs * 1e3)) {
@@ -8086,7 +8287,7 @@ function tick(log = () => {
   const skipFor = (lane) => lane === "work" ? workSkip : choreSkip;
   for (const lane of ["chore", "work"]) {
     for (const st of listActive(lane))
-      reconcileOne(st, cfg, log, hooks.spawnRunner);
+      reconcileOne(st, cfg, log, hooks.spawnRunner, wedgeGrace);
   }
   retentionPass(cfg, hooks, log);
   const hasHeadlessSlot = (lane) => slotUsage(lane).headless < (lane === "work" ? cfg.limits.maxConcurrent : cfg.limits.choreConcurrent);
@@ -8115,7 +8316,7 @@ function tick(log = () => {
       inFlight++;
       const st = listActive(lane).find((s) => s.id === id);
       if (st)
-        reconcileOne(st, cfg, log, hooks.spawnRunner);
+        reconcileOne(st, cfg, log, hooks.spawnRunner, wedgeGrace);
     }
   }
   if (cfg.notifyCommand) {
@@ -8135,7 +8336,7 @@ function acquireDaemonLock() {
   const lockPath = path28.join(lobstahHome(), "daemon.lock");
   try {
     const prior = JSON.parse(fs32.readFileSync(lockPath, "utf8"));
-    if (pidAlive(prior.pid, prior.processStartTime)) {
+    if (pidAlive2(prior.pid, prior.processStartTime)) {
       throw new Error(`another daemon (pid ${prior.pid}) already supervises ${lobstahHome()} \u2014 run a second instance against its own LOBSTAH_HOME instead`);
     }
   } catch (err) {
@@ -8862,7 +9063,7 @@ import * as path32 from "node:path";
 init_dist2();
 import * as fs36 from "node:fs";
 import * as path31 from "node:path";
-import { execFileSync as execFileSync4 } from "node:child_process";
+import { execFileSync as execFileSync5 } from "node:child_process";
 function age(seconds) {
   if (seconds < 60)
     return `${seconds}s`;
@@ -8872,7 +9073,7 @@ function age(seconds) {
 }
 function git3(worktree, ...args) {
   try {
-    return execFileSync4("git", args, { cwd: worktree, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 }).trim();
+    return execFileSync5("git", args, { cwd: worktree, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 }).trim();
   } catch {
     return void 0;
   }
@@ -9973,7 +10174,7 @@ function worktreeView(id, lane) {
 init_dist2();
 import * as fs45 from "node:fs";
 import * as path39 from "node:path";
-import { execFileSync as execFileSync5 } from "node:child_process";
+import { execFileSync as execFileSync6 } from "node:child_process";
 var GIT_CACHE_MS = 6e4;
 var gitCache = /* @__PURE__ */ new Map();
 function headStamp(cwd) {
@@ -10001,7 +10202,7 @@ function git4(cwd, ...args) {
   if (hit && stamp !== "" && hit.stamp === stamp && now2 - hit.at < GIT_CACHE_MS) return hit.out;
   let out;
   try {
-    out = execFileSync5("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 }).trim();
+    out = execFileSync6("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 }).trim();
   } catch {
     out = void 0;
   }
@@ -10220,13 +10421,15 @@ function terminal2(id, lane) {
 function liveWorkers() {
   const out = [];
   for (const reg of listTraps()) {
-    if (!hasOpenCatch(reg)) continue;
+    const catchId = hasOpenCatch(reg) ? reg.claimed : void 0;
+    const lane = catchId ? laneOf(catchId) ?? "work" : "work";
     out.push({
       label: `wt:${reg.name ?? reg.trapId}`,
-      dispatchId: reg.claimed,
-      lane: laneOf(reg.claimed) ?? "work",
+      ...catchId ? { dispatchId: catchId } : {},
+      lane,
       worktree: reg.worktree,
-      repo: storedDescriptor(reg.claimed, laneOf(reg.claimed) ?? "work")?.repo ?? reg.repo
+      repo: (catchId ? storedDescriptor(catchId, lane)?.repo : void 0) ?? reg.repo,
+      trapId: reg.trapId
     });
   }
   for (const lane of ["work", "chore"]) {
@@ -10254,6 +10457,7 @@ function git5(cwd, args) {
   const res = spawnSync4("git", ["-C", cwd, ...args], { encoding: "utf8", timeout: 1e4 });
   return res.status === 0 && !res.error ? res.stdout.trim() : void 0;
 }
+var TRAP_MESSAGE_HOLD_MS = 24 * 36e5;
 var GIT_CACHE_MS2 = 6e4;
 var gitCache2 = /* @__PURE__ */ new Map();
 function gitFacts(worktree, branch, now2 = Date.now()) {
@@ -10271,7 +10475,7 @@ function gitFacts(worktree, branch, now2 = Date.now()) {
 function workerHold(worker) {
   const branches = /* @__PURE__ */ new Map();
   const prs = /* @__PURE__ */ new Map();
-  const evidence = readEvidence(worker.dispatchId, worker.lane);
+  const evidence = worker.dispatchId ? readEvidence(worker.dispatchId, worker.lane) : {};
   const origin = worker.repo ? loadConfig().repos[worker.repo]?.origin : void 0;
   let forgeRepo = origin ? githubRepoFromOrigin(origin) : void 0;
   if (worker.worktree && fs46.existsSync(worker.worktree)) {
@@ -10292,10 +10496,28 @@ function workerHold(worker) {
   }
   const named = evidence.prUrl ? parsePrRef(evidence.prUrl) : void 0;
   if (named) prs.set(named.key, "works on this PR");
-  const owned = chainPr(worker.dispatchId, worker.lane);
+  const owned = worker.dispatchId ? chainPr(worker.dispatchId, worker.lane) : void 0;
   const ownedRef = owned ? parsePrRef(owned.url) : void 0;
   if (ownedRef && !prs.has(ownedRef.key)) prs.set(ownedRef.key, "its chain owns this PR");
-  return { label: worker.label, dispatchId: worker.dispatchId, ...forgeRepo ? { forgeRepo } : {}, branches, prs };
+  const said = [
+    ...worker.dispatchId ? [storedDescriptor(worker.dispatchId, worker.lane)?.brief ?? "", ...messageTexts(worker.dispatchId, worker.lane)] : [],
+    ...worker.trapId ? trapMessageTexts(worker.trapId, Date.now() - TRAP_MESSAGE_HOLD_MS) : []
+  ].join("\n");
+  return {
+    label: worker.label,
+    ...worker.dispatchId ? { dispatchId: worker.dispatchId } : {},
+    ...worker.trapId ? { trapId: worker.trapId } : {},
+    ...forgeRepo ? { forgeRepo } : {},
+    branches,
+    prs,
+    said
+  };
+}
+function namesPr(text, pr, sameRepo) {
+  if (!pr.repo || pr.number === void 0 || !text) return false;
+  const repo = pr.repo.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const n = String(pr.number);
+  return new RegExp(`github\\.com/${repo}/pull/${n}(?![0-9])`, "i").test(text) || new RegExp(`(?<![\\w.-])${repo}#${n}(?![0-9])`, "i").test(text) || sameRepo && new RegExp(`(?<![\\w/#&])#${n}(?![0-9])`).test(text);
 }
 function readWorkerHolds() {
   return liveWorkers().map(workerHold);
@@ -10308,10 +10530,11 @@ function repairHold(pr, records, workers) {
   for (const target of targets) {
     for (const worker of workers) {
       if (worker.forgeRepo && worker.forgeRepo !== target.repo) continue;
-      const how = worker.prs.get(target.key) ?? (target.head ? worker.branches.get(target.head) : void 0);
+      const how = worker.prs.get(target.key) ?? (target.head ? worker.branches.get(target.head) : void 0) ?? (namesPr(worker.said, target, worker.forgeRepo === target.repo) ? "was told to work on this PR" : void 0);
       if (!how) continue;
       const where = target.below ? `; #${target.number} is below this PR` : "";
-      return { heldBy: worker.label, reason: `${worker.label} (dispatch ${worker.dispatchId.slice(0, 8)}) ${how}${where}` };
+      const dispatch = worker.dispatchId ? ` (dispatch ${worker.dispatchId.slice(0, 8)})` : "";
+      return { heldBy: worker.label, reason: `${worker.label}${dispatch} ${how}${where}` };
     }
   }
   return void 0;
@@ -10463,6 +10686,11 @@ function holdCancelledRepair(id, now2 = /* @__PURE__ */ new Date()) {
   }
   return held;
 }
+function trapAddressOf(id) {
+  const claim = readSessionClaim(id, "work");
+  const deliveredTo = readEvidence(id, "work").deliveredTo;
+  return claim?.by.startsWith("wt:") ? claim.by : deliveredTo?.startsWith("wt:") ? deliveredTo : void 0;
+}
 function deliverPrRepairs(log, cap = 3, opts = {}) {
   const config = loadConfig();
   const cfg = config.watch;
@@ -10565,7 +10793,12 @@ function deliverPrRepairs(log, cap = 3, opts = {}) {
         });
       };
       if (watch2.heldAt) return wait(watchHold(watch2));
-      const held = repairHold(pr, records ??= readPrs(), workers ??= (opts.workerHolds ?? readWorkerHolds)());
+      const ownerTrap = trapAddressOf(chainState(owner).latest);
+      const held = repairHold(
+        pr,
+        records ??= readPrs(),
+        (workers ??= (opts.workerHolds ?? readWorkerHolds)()).filter((w2) => !(w2.dispatchId === void 0 && w2.trapId !== void 0 && `wt:${w2.trapId}` === ownerTrap))
+      );
       if (held) return wait(held);
       const changed = Math.max(
         Date.parse(pr.headSince ?? pr.observedAt) || now2,
@@ -10592,9 +10825,7 @@ function deliverPrRepairs(log, cap = 3, opts = {}) {
       }
       const target = storedDescriptor(chain.latest, "work");
       if (!target) return;
-      const claim = readSessionClaim(chain.latest, "work");
-      const deliveredTo = readEvidence(chain.latest, "work").deliveredTo;
-      const address = claim?.by.startsWith("wt:") ? claim.by : deliveredTo?.startsWith("wt:") ? deliveredTo : void 0;
+      const address = trapAddressOf(chain.latest);
       const trap = address ? readTrap(address.slice(3)) : void 0;
       const liveTrap2 = trap && now2 - trapLastSeen(trap) <= config.soak.ttlSecs * 1e3 ? trap : void 0;
       const waitSecs = Math.max(0, Number.isFinite(cfg.repairTrapWaitSecs) ? cfg.repairTrapWaitSecs : 600);
@@ -11673,7 +11904,7 @@ function liveState(text) {
     return void 0;
   }
   if (!state || !Number.isInteger(state.pid) || state.pid <= 0 || !Number.isInteger(state.port)) return void 0;
-  return pidAlive2(state.pid) ? state : void 0;
+  return pidAlive3(state.pid) ? state : void 0;
 }
 function readGlassState() {
   return liveState(readStateText());
@@ -11701,7 +11932,7 @@ function writeGlassState(state) {
 function removeGlassState() {
   fs51.rmSync(stateFile(), { force: true });
 }
-function pidAlive2(pid) {
+function pidAlive3(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -11802,7 +12033,7 @@ async function terminate(pid, timeoutMs) {
   } catch {
   }
   const deadline = Date.now() + timeoutMs;
-  while (pidAlive2(pid)) {
+  while (pidAlive3(pid)) {
     if (Date.now() >= deadline) return false;
     await delay(50);
   }
@@ -11957,7 +12188,7 @@ ${help}`;
 init_dist2();
 import * as fs52 from "node:fs";
 import * as path45 from "node:path";
-import { execFileSync as execFileSync6 } from "node:child_process";
+import { execFileSync as execFileSync7 } from "node:child_process";
 var DAY = 864e5;
 function walkBytes(target) {
   const stat = fs52.lstatSync(target);
@@ -11976,7 +12207,7 @@ var sizing = {
   worktree(target, platform = process.platform) {
     if (platform !== "win32") {
       try {
-        const out = execFileSync6("du", ["-sk", target], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        const out = execFileSync7("du", ["-sk", target], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
         const kb = Number(out.trim().split(/\s+/)[0]);
         if (Number.isFinite(kb)) return kb * 1024;
       } catch {
@@ -12202,20 +12433,20 @@ function removeWorktree(id, dir) {
       const desc = JSON.parse(fs52.readFileSync(descFile, "utf8"));
       const repo = loadConfig().repos[desc.repo];
       if (repo) {
-        execFileSync6("git", ["worktree", "remove", "--force", dir], { cwd: repo.path, stdio: "ignore" });
+        execFileSync7("git", ["worktree", "remove", "--force", dir], { cwd: repo.path, stdio: "ignore" });
         return;
       }
     } catch {
     }
   }
   try {
-    const common = execFileSync6("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], {
+    const common = execFileSync7("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], {
       cwd: dir,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
     if (common) {
-      execFileSync6("git", ["--git-dir", common, "worktree", "remove", "--force", dir], { stdio: "ignore" });
+      execFileSync7("git", ["--git-dir", common, "worktree", "remove", "--force", dir], { stdio: "ignore" });
       return;
     }
   } catch {
@@ -12266,8 +12497,9 @@ function runCull(days, apply, freeBytes = statfsFreeBytes, now2 = Date.now()) {
 
 // apps/cli/src/release.ts
 init_dist2();
+init_dist3();
 import * as fs53 from "node:fs";
-import { execFileSync as execFileSync7 } from "node:child_process";
+import { execFileSync as execFileSync8 } from "node:child_process";
 var DAY2 = 864e5;
 function listIds(dir) {
   try {
@@ -12346,7 +12578,7 @@ function mergedPrs(all) {
 }
 function git7(cwd, ...args) {
   try {
-    return execFileSync7("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+    return execFileSync8("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
   } catch {
     return void 0;
   }
@@ -12356,7 +12588,7 @@ function unsafe(dir, fetched) {
   if (status === void 0) return "unpushed work: not a readable git checkout";
   if (status !== "") return "unpushed work: uncommitted changes";
   const common = git7(dir, "rev-parse", "--path-format=absolute", "--git-common-dir") ?? dir;
-  if (!fetched.has(common)) fetched.set(common, git7(dir, "fetch", "--quiet", "origin") !== void 0);
+  if (!fetched.has(common)) fetched.set(common, withRepoLockSync(dir, () => git7(dir, "fetch", "--quiet", "origin")) !== void 0);
   if (!fetched.get(common)) return "unpushed work: fetch failed, remote state unknown";
   const remote = git7(dir, "branch", "-r", "--contains", "HEAD");
   if (remote === void 0 || remote === "") return "unpushed work: HEAD is not on the remote";
@@ -12585,7 +12817,6 @@ function answerKey(key, req) {
     lane: q.lane,
     ...q.repo ? { repo: q.repo } : {},
     askedBy: "worker",
-    replace: false,
     maxBytes
   });
   try {
@@ -14115,7 +14346,7 @@ async function awaitHeartbeat(sinceMs, oldPid, timeoutMs = RESTART_WAIT_MS) {
   }
   return void 0;
 }
-function pidAlive3(pid) {
+function pidAlive4(pid) {
   try {
     process.kill(pid, 0);
     return true;
@@ -14128,7 +14359,7 @@ function daemonStatus(installed, now2 = Date.now()) {
   const hb = readHeartbeat();
   const ageSecs = hb ? Math.max(0, Math.round((now2 - (Date.parse(hb.heartbeat) || 0)) / 1e3)) : void 0;
   const fresh = ageSecs !== void 0 && ageSecs * 1e3 < HEARTBEAT_STALE_MS3;
-  const running = fresh && (hb?.pid === void 0 || pidAlive3(hb.pid));
+  const running = fresh && (hb?.pid === void 0 || pidAlive4(hb.pid));
   const parked = parkedDispatches(now2);
   const cfg = loadConfig();
   const work = slotUsage("work");
@@ -14362,6 +14593,7 @@ function observePr(ref, view, opts = {}) {
   if (id && lane) mergeEvidence(id, lane, { pr });
   const was = before?.state ?? legacyBefore?.state;
   const terminal3 = pr.state === "MERGED" || pr.state === "CLOSED";
+  if (terminal3) cancelQueuedRepairs(ref.key);
   const endedAt = Date.parse(view.mergedAt ?? view.closedAt ?? "");
   const recentEnd = Number.isFinite(endedAt) && now2.getTime() - endedAt <= FIRST_SIGHT_NOTICE_MS;
   if (terminal3 && (was === "OPEN" || was === void 0 && recentEnd)) {
@@ -14378,6 +14610,15 @@ function observePr(ref, view, opts = {}) {
   }
   return after;
 }
+function cancelQueuedRepairs(key) {
+  const cancelled = [];
+  for (const id of pendingIds("chore")) {
+    const d = queuedDescriptor(id, "chore");
+    if (!d?.systemRepair || !d.pr?.url || parsePrRef(d.pr.url)?.key !== key) continue;
+    if (cancelQueued(id, "chore")) cancelled.push(id);
+  }
+  return cancelled;
+}
 function rawConfig() {
   try {
     return parse(fs64.readFileSync(configPath(), "utf8"));
@@ -14849,6 +15090,7 @@ var COMMANDS = {
       "--option": { value: "<label>", repeatable: true },
       "--attach": { value: "<file>", repeatable: true },
       "--withdraw": { value: "<key>" },
+      "--replace": { value: "<key>" },
       "--grounds": { value: "<name>" },
       "--session": { value: "<id>" }
     },
@@ -14984,7 +15226,7 @@ work in flight requires a live watcher or the hook blocks with the arm command.
 --attach copies images the page names by bare filename; --title overrides its first # heading.
 The glass shows it on the deck; \`lobstah attention ack <key>\` acks it.`,
   "man:ask": `Put a decision to the human: a card in the glass (decisions/<rid>/) until
-answered or withdrawn. A newer ask on the same dispatch replaces it. The answer
+answered or withdrawn. Asks stand side by side; --replace <key> replaces one. The answer
 wakes man wait as decision-answer. Reserved for the claimed helm.`,
   "man:answer": `Answer a decision (or a raw question's <lane>:<id>) as the glass does.
 Stores the answer; the helm's man wait receives it as decision-answer.`,
@@ -15315,11 +15557,12 @@ lobstah man (orchestrator sessions \u2014 bare \`lobstah man\` prints the manual
   man file <file.md> [--attach <file> ...] [--title <text>]
                                   file the helm's own report under its
                                   grounds; the glass renders it on the deck.
-  man ask [<dispatch-id>] --title <q> [--detail <f.md>] [--option <label> ...] [--attach <file> ...]
+  man ask [<dispatch-id>] --title <q> [--detail <f.md>] [--option <label> ...] [--attach <file> ...] [--replace <key>]
                                   put a decision to the human: a card in the
                                   glass until answered or withdrawn
-                                  (--withdraw <key>). The answer wakes man
-                                  wait as a decision-answer event.
+                                  (--withdraw <key>). Asks stand side by side;
+                                  --replace <key> replaces one. The answer
+                                  wakes man wait as a decision-answer event.
   man answer <key> [--option <label>] [--text <text>] [--attach <file> ...]
                                   answer a decision from the terminal.
   man helm [--session <id>] [--grounds <name>] [--take] [--harness claude|codex]
@@ -15606,7 +15849,7 @@ function liveChainMember(member) {
   if (isParked(member.id, member.lane)) return true;
   try {
     const runner = JSON.parse(fs72.readFileSync(path59.join(dir, "runner.json"), "utf8"));
-    return pidAlive(runner.pid, runner.processStartTime);
+    return pidAlive2(runner.pid, runner.processStartTime);
   } catch {
     return false;
   }
@@ -16072,6 +16315,19 @@ ${text}`, from);
 ${usageFor("report")}`);
         }
       }
+      if (verb === "done") {
+        const unread = unhandled(id, lane);
+        if (unread.length > 0) {
+          for (const m of unread) {
+            console.log(`--- message ${m.file}`);
+            console.log(m.text);
+            acknowledge(id, lane, m.file);
+          }
+          throw new Error(
+            `not reported done: ${unread.length} unread message(s) for ${id} arrived while you worked. They are printed above and now marked read. Act on them, then report done again.`
+          );
+        }
+      }
       const reportFile = opt("--report");
       const attachFiles = values("--attach");
       if (reportFile !== void 0 && verb !== "done" && verb !== "failed")
@@ -16208,7 +16464,7 @@ ${usageFor("report")}`);
       const runnerFile = path59.join(activeDir, "runner.json");
       if (fs72.existsSync(runnerFile)) {
         const runner = JSON.parse(fs72.readFileSync(runnerFile, "utf8"));
-        if (pidAlive(runner.pid, runner.processStartTime)) killGroup(runner.pid, "SIGKILL");
+        if (pidAlive2(runner.pid, runner.processStartTime)) killGroup(runner.pid, "SIGKILL");
         fs72.unlinkSync(runnerFile);
       }
       appendStatus(id, lane, "working", `swapped to ${descriptor.harness ?? "default"} \u2014 awaiting respawn`);
@@ -16381,6 +16637,7 @@ ${usageFor("man:ask")}`);
           ...repo ? { repo } : {},
           ...grounds ? { grounds } : {},
           askedBy: "helm",
+          ...opt("--replace") !== void 0 ? { replace: opt("--replace") } : {},
           maxBytes: loadConfig().limits.attachmentMaxBytes
         });
       } catch (err) {

package/dist/runner.js

@@ -857,6 +857,26 @@ var GB = 1024 ** 3;
 // packages/core/dist/watch.js
 import * as fs3 from "node:fs";
 import * as path3 from "node:path";
+
+// packages/core/dist/gh-errors.js
+function firstMeaningfulLine(...outputs) {
+  for (const out of outputs) {
+    for (const raw of (out ?? "").split("\n")) {
+      let line = raw.trim();
+      if (!line || /^(warning:|hint:|\(node:|\{|\})/i.test(line))
+        continue;
+      const m = /^error:\s*(.*)$/.exec(line);
+      if (m)
+        line = m[1].replace(/^"(.*)"$/, "$1").trim();
+      line = line.replace(/^(gh|GraphQL):\s*/i, "");
+      if (line)
+        return line;
+    }
+  }
+  return void 0;
+}
+
+// packages/core/dist/watch.js
 function watchesDir() {
   return path3.join(lobstahHome(), "watches");
 }
@@ -1577,6 +1597,7 @@ var COMPILED_BINARY = (() => {
 })();
 
 // packages/core/dist/pr.js
+import { spawnSync } from "node:child_process";
 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)
@@ -1587,6 +1608,59 @@ function parsePrRef(s) {
 }
 var PR_VIEW_FIELDS = "title,state,isDraft,headRefOid,baseRefName,baseRefOid,headRefName,mergeStateStatus,reviewDecision,statusCheckRollup,mergedAt,closedAt,updatedAt,reviews";
 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) {
+  const view1 = (fields2) => spawnSync("gh", ["pr", "view", String(ref.number), "--repo", `${ref.owner}/${ref.repo}`, "--json", fields2], {
+    encoding: "utf8",
+    timeout: 6e4
+  });
+  const reason = (r) => firstMeaningfulLine(r.stderr) ?? `gh exited ${r.status}`;
+  const unknownBase = (r) => r.status !== 0 && /unknown json field.*baseRefOid/i.test(r.stderr ?? "");
+  const withoutBase = (fields2) => fields2.split(",").filter((f) => f !== "baseRefOid").join(",");
+  let fields = PR_VIEW_FIELDS;
+  let res = view1(fields);
+  if (unknownBase(res))
+    res = view1(fields = withoutBase(fields));
+  if (res.error)
+    throw new Error(`gh: ${res.error.message}`);
+  let checksError;
+  if (res.status !== 0 && FORBIDDEN.test(res.stderr ?? "")) {
+    checksError = reason(res);
+    const retry = view1(fields === PR_VIEW_FIELDS ? PR_VIEW_FIELDS_NO_CHECKS : withoutBase(PR_VIEW_FIELDS_NO_CHECKS));
+    if (retry.error)
+      throw new Error(`gh: ${retry.error.message}`);
+    if (retry.status !== 0) {
+      throw new Error(FORBIDDEN.test(retry.stderr ?? "") ? `${reason(retry)} (fails even without check results)` : reason(retry));
+    }
+    res = retry;
+  }
+  if (res.status !== 0)
+    throw new Error(reason(res));
+  const view = JSON.parse(res.stdout);
+  if (checksError)
+    view.checksError = checksError;
+  if (view.state === "OPEN") {
+    const threads = ghUnresolvedThreads(ref);
+    if (threads !== void 0)
+      view.unresolvedThreads = threads;
+  }
+  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}}}}}";
+function ghUnresolvedThreads(ref) {
+  const res = spawnSync("gh", ["api", "graphql", "-f", `query=${THREADS_QUERY}`, "-f", `owner=${ref.owner}`, "-f", `repo=${ref.repo}`, "-F", `n=${ref.number}`], { encoding: "utf8", timeout: 6e4 });
+  if (res.error || res.status !== 0)
+    return void 0;
+  return parseUnresolvedThreads(res.stdout);
+}
+function parseUnresolvedThreads(stdout) {
+  try {
+    const nodes = JSON.parse(stdout).data?.repository?.pullRequest?.reviewThreads?.nodes;
+    return Array.isArray(nodes) ? nodes.filter((t) => t.isResolved === false).length : void 0;
+  } catch {
+    return void 0;
+  }
+}
 
 // packages/core/dist/prs.js
 import * as fs14 from "node:fs";
@@ -1594,6 +1668,20 @@ import * as path11 from "node:path";
 function prsDir() {
   return path11.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`);
+}
+function readPr(key) {
+  try {
+    return JSON.parse(fs14.readFileSync(prRecordFile(key), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
 function readPrs() {
   let files;
   try {
@@ -1655,7 +1743,7 @@ function pushRule(branch, id = "<dispatch id>") {
 import * as fs15 from "node:fs";
 import * as os3 from "node:os";
 import * as path12 from "node:path";
-import { spawnSync } from "node:child_process";
+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) {
   const version = sessionId ? UUID.exec(sessionId)?.[1] : void 0;
@@ -1717,7 +1805,7 @@ function isUnresumable(error) {
 function worktreeProgress(worktree, trunk) {
   if (!worktree || !fs15.existsSync(worktree))
     return "No worktree progress recorded.";
-  const git2 = (...a) => spawnSync("git", a, { cwd: worktree, encoding: "utf8" }).stdout?.trim() ?? "";
+  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");
   const status = git2("status", "--short");
   return `Commits so far:
@@ -1827,7 +1915,7 @@ function isFinished(id, lane) {
 // packages/runner/src/run.ts
 import * as fs19 from "node:fs";
 import * as path16 from "node:path";
-import { execFileSync } from "node:child_process";
+import { execFileSync as execFileSync2 } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/adapters/dist/claude.js
@@ -2346,7 +2434,7 @@ function loadAdapter(name) {
 import * as fs17 from "node:fs";
 import * as path14 from "node:path";
 import { createHash } from "node:crypto";
-import { exec, execFile } from "node:child_process";
+import { exec, execFile, execFileSync } from "node:child_process";
 import { promisify } from "node:util";
 var run = promisify(execFile);
 var shell = promisify(exec);
@@ -2372,7 +2460,12 @@ var LOCK_CONTENTION = [
   // held by another process ("fetching ref <ref> failed: reference already
   // exists"). The files backend maps the lock's EEXIST to this reason; older
   // git printed "Unable to create '<ref>.lock': File exists" instead.
-  /reference already exists/
+  /reference already exists/,
+  // Windows: two fetches unpack the same loose object, and one cannot write
+  // the file the other holds open ("unable to write file
+  // .git/objects/<xx>/<rest>: Permission denied", then "unpack-objects
+  // failed"). Only an object path matches, not any denied write.
+  /unable to write file \S*objects[\\/][0-9a-f]{2}[\\/][0-9a-f]{38,}: Permission denied/
 ];
 function gitStderr(err) {
   const stderr = err.stderr;
@@ -2399,6 +2492,112 @@ ${gitStderr(err)}`, { cause: err });
     }
   }
 }
+var REPO_LOCK_WAIT_MS = 5 * 6e4;
+var repoQueues = /* @__PURE__ */ new Map();
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+var BUSY = /* @__PURE__ */ new Set(["EPERM", "EACCES", "EBUSY"]);
+function takeRepoLock(file, mine) {
+  try {
+    fs17.writeFileSync(file, mine, { flag: "wx" });
+    return { state: "held" };
+  } catch (err) {
+    const code = err.code ?? "";
+    if (code !== "EEXIST" && !BUSY.has(code))
+      throw err;
+  }
+  let raw = "";
+  let age = 0;
+  try {
+    raw = fs17.readFileSync(file, "utf8");
+    age = Date.now() - fs17.statSync(file).mtimeMs;
+  } catch {
+    return { state: "retry" };
+  }
+  let holder;
+  try {
+    holder = JSON.parse(raw);
+  } catch {
+    holder = void 0;
+  }
+  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 });
+    } catch {
+    }
+    return { state: "retry" };
+  }
+  return { state: "wait", ...holder ? { holder: holder.pid } : {} };
+}
+function releaseRepoLock(file, mine) {
+  try {
+    if (fs17.readFileSync(file, "utf8") === mine)
+      fs17.rmSync(file, { force: true, recursive: true, maxRetries: 5 });
+  } catch {
+  }
+}
+async function withRepoLock(common, fn) {
+  const file = path14.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);
+    if (took.state === "held") {
+      held = true;
+      break;
+    }
+    if (took.state === "wait")
+      await new Promise((r) => setTimeout(r, 50 + Math.random() * 50));
+  }
+  try {
+    await fn();
+  } finally {
+    if (held)
+      releaseRepoLock(file, 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(() => {
+  });
+  repoQueues.set(key, tail);
+  try {
+    await run2;
+  } finally {
+    if (repoQueues.get(key) === tail)
+      repoQueues.delete(key);
+  }
+}
+function fetchStamps(common) {
+  try {
+    return JSON.parse(fs17.readFileSync(path14.join(common, "lobstah-fetch.json"), "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function fetchShared(cwd, remote, ref) {
+  const asked = Date.now();
+  const key = `${remote} ${ref}`;
+  await oneAtATime(cwd, async (common) => {
+    if ((fetchStamps(common)[key] ?? -Infinity) >= asked)
+      return;
+    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));
+  });
+}
 async function allocate(repo, id, fromRemoteBranch = repo.trunk) {
   const dir = worktreePath(id);
   if (fs17.existsSync(dir)) {
@@ -2409,8 +2608,10 @@ async function allocate(repo, id, fromRemoteBranch = repo.trunk) {
       throw new Error(`repo path ${repo.path} missing and no origin configured`);
     await run("git", ["clone", repo.origin, repo.path], { env: process.env });
   }
-  await gitShared(repo.path, "fetch", "origin", fromRemoteBranch);
-  await gitShared(repo.path, "worktree", "add", "--no-track", dir, "-b", `lobstah/${id}`, `origin/${fromRemoteBranch}`);
+  await fetchShared(repo.path, "origin", fromRemoteBranch);
+  await oneAtATime(repo.path, async () => {
+    await gitShared(repo.path, "worktree", "add", "--no-track", dir, "-b", `lobstah/${id}`, `origin/${fromRemoteBranch}`);
+  });
   await runSetup(repo, dir);
   return dir;
 }
@@ -2544,7 +2745,7 @@ async function chooseWorktree(input) {
   return { reuse: true, path: found.path, owner: found.owner, from: found.from };
 }
 async function prepareReuse(repo, dir) {
-  await gitShared(dir, "fetch", "origin", repo.trunk);
+  await fetchShared(dir, "origin", repo.trunk);
   if (!repo.setup?.length)
     return { setupRan: false };
   if (recordedSetupHash(dir) === setupHash(repo, dir))
@@ -2874,6 +3075,7 @@ function planStart(input) {
 function startWallClock(opts) {
   const now2 = opts.now ?? Date.now;
   const tickMs = Math.max(1, Math.min(opts.tickMs ?? 5e3, opts.limitMs));
+  const sleepGapMs = opts.sleepGapMs ?? Math.max(6e4, tickMs * 6);
   let elapsed = opts.initialElapsedMs ?? 0;
   const maxMs = Math.max(opts.limitMs, opts.maxMs ?? opts.limitMs);
   let windowMs = Math.min(maxMs, Math.max(opts.limitMs, opts.initialWindowMs ?? opts.limitMs));
@@ -2887,7 +3089,8 @@ function startWallClock(opts) {
     } catch {
       paused = false;
     }
-    if (!paused) elapsed += t - last;
+    const step = Math.max(0, t - last);
+    if (!paused) elapsed += step > sleepGapMs ? Math.min(step, tickMs) : step;
     last = t;
     if (!done && elapsed >= windowMs && elapsed < maxMs) {
       let advanced = false;
@@ -3094,13 +3297,23 @@ function keepRemote(opts) {
 }
 
 // packages/runner/src/run.ts
+function livePrState(url) {
+  const ref = parsePrRef(url);
+  if (!ref) return void 0;
+  try {
+    return ghPrView(ref).state;
+  } catch {
+    return void 0;
+  }
+}
 var defaultDeps = {
   loadAdapter,
   allocate,
   chooseWorktree,
   prepareReuse,
   collectEvidence,
-  reap: async () => 0
+  reap: async () => 0,
+  prState: livePrState
 };
 var DONE_WAIT_MS = 2e3;
 function within(p, ms, fallback) {
@@ -3141,6 +3354,14 @@ async function main(activeDir, lane, seams = {}) {
     attempts
   };
   fs19.writeFileSync(path16.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") {
+      status("failed", `cancelled: ${descriptor.pr.url} is ${state.toLowerCase()}; nothing to repair`);
+      complete(id, lane);
+      return;
+    }
+  }
   const plan = planStart({
     id,
     lane,
@@ -3240,7 +3461,7 @@ async function main(activeDir, lane, seams = {}) {
   })();
   const head = () => {
     try {
-      return execFileSync("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+      return execFileSync2("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
     } catch {
       return void 0;
     }
@@ -3412,10 +3633,10 @@ async function main(activeDir, lane, seams = {}) {
 }
 
 // packages/runner/src/reap.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
+import { execFileSync as execFileSync3 } from "node:child_process";
 function listProcesses() {
   if (process.platform === "win32") {
-    const out2 = execFileSync2(
+    const out2 = execFileSync3(
       "powershell.exe",
       [
         "-NoProfile",
@@ -3427,7 +3648,7 @@ function listProcesses() {
     );
     return out2.split(/\r?\n/).map((l) => l.trim().split(/\s+/).map(Number)).filter(([pid, ppid]) => Number.isInteger(pid) && Number.isInteger(ppid)).map(([pid, ppid]) => ({ pid, ppid }));
   }
-  const out = execFileSync2("ps", ["-A", "-o", "pid=,ppid=,pgid="], {
+  const out = execFileSync3("ps", ["-A", "-o", "pid=,ppid=,pgid="], {
     encoding: "utf8",
     timeout: 3e4,
     stdio: ["ignore", "pipe", "ignore"]
@@ -3470,7 +3691,7 @@ async function stopPids(pids, graceMs = 2e3) {
   if (process.platform === "win32") {
     for (const pid of pids) {
       try {
-        execFileSync2("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true, timeout: 3e4 });
+        execFileSync3("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true, timeout: 3e4 });
       } catch {
       }
     }

package/docs/man.md

@@ -509,7 +509,9 @@ the same rule.
   `attachments/`. The claimed helm alone may ask.
 - **Standing.** A decision stands until it is answered or the helm withdraws
   it with `lobstah man ask --withdraw <key>`, which removes its directory. A
-  newer `man ask` on the same dispatch replaces the older decision.
+  newer `man ask` on the same dispatch keeps the older decisions: each shows
+  as its own card. `lobstah man ask ... --replace <key>` replaces that one
+  standing decision; a key that is not standing is refused.
 - **Attention.** A standing decision is attention of kind `decision`, in
   the default `attentionKinds`. It makes the verdict `needs-attention`. A
   worker's raw `needs-decision` or `blocked` stays a `question` until the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lobstah",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "Harness-agnostic, token-efficient supervision framework for coding agents",
   "license": "MIT",
   "author": "aequitas labs LLC",