lobstah 0.5.11 → 0.5.13

package/dist/runner.js

@@ -1,10 +1,12 @@
 // packages/runner/src/index.ts
-import * as fs13 from "node:fs";
-import * as path11 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"];
 var TERMINAL_VERBS = ["done", "failed"];
+var WAITING_ON = ["review", "pr", "deploy", "person", "external"];
+var WAITING_ON_VERBS = ["paused", "needs-decision", "blocked"];
 
 // packages/core/dist/paths.js
 import * as os from "node:os";
@@ -34,6 +36,9 @@ function statusPath(id, lane) {
 function eventsPath(id, lane) {
   return path.join(laneDirs(lane).state, `${id}.events`);
 }
+function activityPath(id, lane) {
+  return path.join(laneDirs(lane).state, `${id}.activity`);
+}
 function evidencePath(id, lane) {
   return path.join(laneDirs(lane).state, `${id}.evidence`);
 }
@@ -50,28 +55,281 @@ function attachmentBlock(attachments) {
 }
 
 // packages/core/dist/queue.js
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+
+// packages/core/dist/status.js
 import * as fs2 from "node:fs";
+
+// packages/core/dist/activity.js
+import * as fs from "node:fs";
 import * as path2 from "node:path";
+var ACTIVITY_KINDS = ["tool", "message", "thinking", "waiting"];
+var ACTIVITY_SUMMARY_MAX = 80;
+var SECRET_PATTERNS = [
+  /\b(?:sk|pk|rk)[-_][A-Za-z0-9_-]{8,}/i,
+  /\b(?:gh[posur]_|github_pat_|glpat-|xox[abprs]-|npm_|hf_)[A-Za-z0-9_-]{16,}/,
+  /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/,
+  /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{4,}/,
+  /\bbearer\b/i,
+  /(?:token|secret|passw(?:or)?d|pwd|api[-_]?key|auth|credential|private[-_]?key)[^\s]*[=:]/i
+];
+function looksSecret(word) {
+  if (SECRET_PATTERNS.some((re) => re.test(word)))
+    return true;
+  for (const run2 of word.match(/[A-Za-z0-9+/_=-]{24,}/g) ?? []) {
+    if (/[0-9]/.test(run2) && /[A-Za-z]/.test(run2))
+      return true;
+  }
+  return false;
+}
+function redactSummary(s, max = ACTIVITY_SUMMARY_MAX) {
+  const clean = s.replace(/[\r\n\t]+/g, " ").split(" ").filter(Boolean).map((w) => looksSecret(w) ? "[redacted]" : w).join(" ");
+  return clean.length > max ? `${clean.slice(0, max - 1)}\u2026` : clean;
+}
+var SHELLS = /* @__PURE__ */ new Set(["bash", "sh", "zsh", "dash", "fish", "pwsh", "powershell", "cmd"]);
+function commandWord(command) {
+  let words = command.trim().split(/\s+/).filter(Boolean);
+  while (words.length > 0 && /^[A-Za-z_][A-Za-z0-9_]*=/.test(words[0]))
+    words = words.slice(1);
+  if (words[0] === "env") {
+    words = words.slice(1);
+    while (words.length > 0 && (/^[A-Za-z_][A-Za-z0-9_]*=/.test(words[0]) || words[0].startsWith("-")))
+      words = words.slice(1);
+  }
+  const first = words[0];
+  if (!first)
+    return void 0;
+  const name = baseName(first.replace(/^["']|["']$/g, "")).replace(/\.(exe|cmd|bat)$/i, "");
+  if (SHELLS.has(name.toLowerCase()) && words[1] && /^(-\w*c|\/c|-command)$/i.test(words[1])) {
+    return commandWord(words.slice(2).join(" ").replace(/^["']/, "")) ?? name;
+  }
+  return name || void 0;
+}
+function baseName(p) {
+  const parts = p.split(/[\\/]/).filter(Boolean);
+  return parts.at(-1) ?? p;
+}
+function isWindowsPath(p) {
+  return /^[A-Za-z]:[\\/]/.test(p) || p.startsWith("\\\\");
+}
+function relativeTarget(p, root) {
+  if (!root)
+    return baseName(p);
+  const win = isWindowsPath(p) || isWindowsPath(root);
+  const lib = win ? path2.win32 : path2.posix;
+  if (!lib.isAbsolute(p))
+    return p.replace(/\\/g, "/");
+  const rel = lib.relative(win ? root : root.replace(/\\/g, "/"), p);
+  if (!rel || rel.startsWith("..") || lib.isAbsolute(rel))
+    return `\u2026/${baseName(p)}`;
+  return rel.replace(/\\/g, "/");
+}
+function urlHost(u) {
+  try {
+    return new URL(u).host || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function toolTarget(input) {
+  if (!input || typeof input !== "object")
+    return void 0;
+  const i = input;
+  const str = (k) => typeof i[k] === "string" && i[k].length > 0 ? i[k] : void 0;
+  const file = str("file_path") ?? str("notebook_path") ?? str("path");
+  if (file)
+    return file;
+  const command = str("command") ?? (Array.isArray(i.command) ? i.command.map(String).join(" ") : void 0);
+  if (command)
+    return commandWord(command);
+  const url = str("url");
+  if (url)
+    return urlHost(url);
+  const changes = i.changes;
+  if (Array.isArray(changes) && changes.length > 0) {
+    const first = changes[0];
+    if (typeof first?.path === "string")
+      return first.path;
+  }
+  return str("subagent_type") ?? str("skill");
+}
+function toolSummary(name, target, root) {
+  const looksPath = target !== void 0 && (/[\\/]/.test(target) || isWindowsPath(target));
+  const shown = target === void 0 ? "" : looksPath ? relativeTarget(target, root) : target;
+  return redactSummary(shown ? `${name} ${shown}` : name);
+}
+function activityFromEvent(ev, root) {
+  const data = ev.data ?? {};
+  switch (ev.type) {
+    case "tool-start": {
+      const name = typeof data.name === "string" && data.name ? data.name : "tool";
+      const target = typeof data.target === "string" ? data.target : void 0;
+      return { kind: "tool", summary: toolSummary(name, target, root) };
+    }
+    case "text":
+      return { kind: "message", summary: "writing a message" };
+    case "thinking":
+      return { kind: "thinking", summary: "thinking" };
+    case "runner": {
+      if (typeof data.on === "string")
+        return { kind: "waiting", summary: redactSummary(`waiting on ${data.on}`) };
+      if (typeof data.waiting === "string")
+        return { kind: "waiting", summary: redactSummary(`waiting for an answer (${data.waiting})`) };
+      if (data.holding === "background")
+        return { kind: "waiting", summary: "waiting on background work" };
+      return void 0;
+    }
+    default:
+      return void 0;
+  }
+}
+function atomicWrite(file, content) {
+  const tmp = `${file}.tmp-${process.pid}`;
+  fs.writeFileSync(tmp, content);
+  fs.renameSync(tmp, file);
+}
+function writeActivity(id, lane, a) {
+  const safe = { at: a.at, kind: a.kind, summary: redactSummary(a.summary) };
+  atomicWrite(activityPath(id, lane), JSON.stringify(safe));
+}
+function readActivity(id, lane) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(activityPath(id, lane), "utf8"));
+    if (typeof parsed.at !== "string" || typeof parsed.summary !== "string")
+      return void 0;
+    if (!ACTIVITY_KINDS.includes(parsed.kind))
+      return void 0;
+    return { ...parsed, summary: redactSummary(parsed.summary) };
+  } catch {
+    return void 0;
+  }
+}
+var ActivityTracker = class {
+  write;
+  opts;
+  lastWriteAt = -Infinity;
+  lastKind;
+  pending;
+  timer;
+  throttleMs;
+  now;
+  constructor(write, opts = {}) {
+    this.write = write;
+    this.opts = opts;
+    this.throttleMs = opts.throttleMs ?? 1e4;
+    this.now = opts.now ?? Date.now;
+  }
+  observe(ev) {
+    const derived = activityFromEvent(ev, this.opts.root);
+    if (derived)
+      this.offer({ at: new Date(this.now()).toISOString(), ...derived });
+  }
+  offer(a) {
+    const t = this.now();
+    if (a.kind !== this.lastKind || t - this.lastWriteAt >= this.throttleMs) {
+      this.emit(a, t);
+      return;
+    }
+    this.pending = a;
+    if (!this.timer) {
+      this.timer = setTimeout(() => {
+        this.timer = void 0;
+        this.flush();
+      }, Math.max(0, this.throttleMs - (t - this.lastWriteAt)));
+      this.timer.unref?.();
+    }
+  }
+  /** Write a held record now. */
+  flush() {
+    if (!this.pending)
+      return;
+    const a = this.pending;
+    this.emit(a, this.now());
+  }
+  stop() {
+    if (this.timer)
+      clearTimeout(this.timer);
+    this.timer = void 0;
+    this.pending = void 0;
+  }
+  emit(a, t) {
+    this.pending = void 0;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    this.lastWriteAt = t;
+    this.lastKind = a.kind;
+    try {
+      this.write(a);
+    } catch {
+    }
+  }
+};
 
 // packages/core/dist/status.js
-import * as fs from "node:fs";
 function isVerb(v) {
   return VERBS.includes(v);
 }
-function appendStatus(id, lane, verb, note, at) {
+function isWaitingOn(v) {
+  return WAITING_ON.includes(v);
+}
+var DURATION = /^(\d+(?:\.\d+)?)\s*(s|m|h|d)$/i;
+var UNIT_MS = { s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
+function parseUntil(v, now2 = Date.now()) {
+  const d = DURATION.exec(v.trim());
+  if (d)
+    return new Date(now2 + Number(d[1]) * UNIT_MS[d[2].toLowerCase()]).toISOString();
+  const t = Date.parse(v);
+  if (Number.isNaN(t))
+    throw new Error(`invalid --until "${v}" \u2014 an ISO time (2026-10-01T09:00Z) or a duration (30m, 4h, 2d)`);
+  return new Date(t).toISOString();
+}
+function waitingFields(verb, w, now2 = Date.now()) {
+  const out = {};
+  if ((w.waitingOn !== void 0 || w.link !== void 0) && !WAITING_ON_VERBS.includes(verb)) {
+    throw new Error(`--waiting-on and --link are valid only with ${WAITING_ON_VERBS.join(", ")} \u2014 not ${verb}`);
+  }
+  if (w.until !== void 0 && verb !== "paused")
+    throw new Error(`--until is valid only with paused \u2014 not ${verb}`);
+  if (w.waitingOn !== void 0) {
+    if (!isWaitingOn(w.waitingOn)) {
+      throw new Error(`invalid --waiting-on "${w.waitingOn}" \u2014 must be one of: ${WAITING_ON.join(", ")}`);
+    }
+    out.waitingOn = w.waitingOn;
+  }
+  if (w.link !== void 0) {
+    let url;
+    try {
+      url = new URL(w.link);
+    } catch {
+      url = void 0;
+    }
+    if (!url || url.protocol !== "http:" && url.protocol !== "https:") {
+      throw new Error(`invalid --link "${w.link}" \u2014 must be an http or https URL`);
+    }
+    out.link = url.href;
+  }
+  if (w.until !== void 0)
+    out.until = parseUntil(w.until, now2);
+  return out;
+}
+function appendStatus(id, lane, verb, note, at, waiting) {
   if (!isVerb(verb)) {
     throw new Error(`invalid status verb "${verb}" \u2014 must be one of: ${VERBS.join(", ")}`);
   }
-  const entry = { at: at ?? (/* @__PURE__ */ new Date()).toISOString(), verb, ...note ? { note } : {} };
-  fs.appendFileSync(statusPath(id, lane), `${JSON.stringify(entry)}
+  const extra = waiting ? waitingFields(verb, waiting) : {};
+  const entry = { at: at ?? (/* @__PURE__ */ new Date()).toISOString(), verb, ...note ? { note } : {}, ...extra };
+  fs2.appendFileSync(statusPath(id, lane), `${JSON.stringify(entry)}
 `);
   return entry;
 }
 function readStatusLog(id, lane) {
   const file = statusPath(id, lane);
-  if (!fs.existsSync(file))
+  if (!fs2.existsSync(file))
     return [];
-  return fs.readFileSync(file, "utf8").split("\n").filter(Boolean).flatMap((line) => {
+  return fs2.readFileSync(file, "utf8").split("\n").filter(Boolean).flatMap((line) => {
     try {
       const parsed = JSON.parse(line);
       return isVerb(parsed.verb) ? [parsed] : [];
@@ -80,51 +338,57 @@ function readStatusLog(id, lane) {
     }
   });
 }
+function pausedWaiting(entry) {
+  return entry?.verb === "paused" && entry.waitingOn !== void 0;
+}
 
 // packages/core/dist/queue.js
 function storedDescriptor(id, lane) {
   const dirs = laneDirs(lane);
   for (const file of [
-    path2.join(dirs.queue, `${id}.json`),
-    path2.join(dirs.active, id, "descriptor.json"),
-    path2.join(dirs.done, id, "descriptor.json")
+    path3.join(dirs.queue, `${id}.json`),
+    path3.join(dirs.active, id, "descriptor.json"),
+    path3.join(dirs.done, id, "descriptor.json")
   ]) {
     try {
-      return JSON.parse(fs2.readFileSync(file, "utf8"));
+      return JSON.parse(fs3.readFileSync(file, "utf8"));
     } catch {
     }
   }
   return void 0;
 }
+function activeIds(lane) {
+  return fs3.readdirSync(laneDirs(lane).active).filter((f) => !f.startsWith("."));
+}
 function complete(id, lane) {
   const dirs = laneDirs(lane);
-  fs2.renameSync(path2.join(dirs.active, id), path2.join(dirs.done, id));
+  fs3.renameSync(path3.join(dirs.active, id), path3.join(dirs.done, id));
 }
 function cancelRequested(id, lane) {
-  return fs2.existsSync(path2.join(laneDirs(lane).active, id, "cancel"));
+  return fs3.existsSync(path3.join(laneDirs(lane).active, id, "cancel"));
 }
 
 // packages/core/dist/events.js
-import * as fs3 from "node:fs";
+import * as fs4 from "node:fs";
 function appendEvent(id, lane, ev) {
-  fs3.appendFileSync(eventsPath(id, lane), `${JSON.stringify(ev)}
+  fs4.appendFileSync(eventsPath(id, lane), `${JSON.stringify(ev)}
 `);
 }
 function touchEvents(id, lane, at = /* @__PURE__ */ new Date()) {
   const file = eventsPath(id, lane);
   try {
-    fs3.utimesSync(file, at, at);
+    fs4.utimesSync(file, at, at);
   } catch {
-    fs3.appendFileSync(file, "");
-    fs3.utimesSync(file, at, at);
+    fs4.appendFileSync(file, "");
+    fs4.utimesSync(file, at, at);
   }
 }
 
 // packages/core/dist/evidence.js
-import * as fs4 from "node:fs";
+import * as fs5 from "node:fs";
 function readEvidence(id, lane) {
   try {
-    return JSON.parse(fs4.readFileSync(evidencePath(id, lane), "utf8"));
+    return JSON.parse(fs5.readFileSync(evidencePath(id, lane), "utf8"));
   } catch {
     return {};
   }
@@ -132,37 +396,70 @@ function readEvidence(id, lane) {
 function mergeEvidence(id, lane, patch) {
   const file = evidencePath(id, lane);
   const tmp = `${file}.tmp-${process.pid}`;
-  fs4.writeFileSync(tmp, JSON.stringify({ ...readEvidence(id, lane), ...patch }, null, 2));
-  fs4.renameSync(tmp, file);
+  fs5.writeFileSync(tmp, JSON.stringify({ ...readEvidence(id, lane), ...patch }, null, 2));
+  fs5.renameSync(tmp, file);
+}
+
+// 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
-import * as fs5 from "node:fs";
-import * as path3 from "node:path";
 var metaName = (file) => file.replace(/\.msg$/, ".meta.json");
 function inboxDir(id, lane) {
-  return path3.join(laneDirs(lane).inbox, id);
+  return path5.join(laneDirs(lane).inbox, id);
 }
 function unhandled(id, lane) {
   const dir = inboxDir(id, lane);
-  if (!fs5.existsSync(dir))
+  if (!fs7.existsSync(dir))
     return [];
-  return fs5.readdirSync(dir).filter((f) => f.endsWith(".msg")).sort().map((f) => ({ file: f, text: fs5.readFileSync(path3.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);
-  fs5.mkdirSync(path3.join(dir, "handled"), { recursive: true });
-  fs5.renameSync(path3.join(dir, file), path3.join(dir, "handled", file));
+  fs7.mkdirSync(path5.join(dir, "handled"), { recursive: true });
+  fs7.renameSync(path5.join(dir, file), path5.join(dir, "handled", file));
   try {
-    fs5.renameSync(path3.join(dir, metaName(file)), path3.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 fs6 from "node:fs";
+import * as fs8 from "node:fs";
 import * as os2 from "node:os";
-import * as path4 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;
@@ -811,7 +1108,7 @@ function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
 
 // packages/core/dist/config.js
 var ATTENTION_KINDS = ["question", "landed", "pr:draft", "pr:review", "pr:checks", "pr:conflict", "pr:ready"];
-var DEFAULT_ATTENTION_KINDS = ["question", "pr:draft", "pr:review", "pr:checks", "pr:conflict", "pr:ready"];
+var DEFAULT_ATTENTION_KINDS = ["question", "pr:ready", "pr:review", "pr:conflict", "pr:checks"];
 function parseAttentionKinds(raw) {
   if (raw === void 0)
     return [...DEFAULT_ATTENTION_KINDS];
@@ -827,7 +1124,9 @@ function parseAttentionKinds(raw) {
 }
 var DEFAULT_SOAK = {
   deferSecs: 90,
-  ttlSecs: 1800
+  ttlSecs: 1800,
+  beat: true,
+  pausedTtlSecs: 86400
 };
 var DEFAULT_HELM = {
   ttlSecs: 1800,
@@ -835,28 +1134,33 @@ var DEFAULT_HELM = {
   armGraceSecs: 5
 };
 var DEFAULT_GLASS = { port: 4949 };
-var DEFAULT_WATCH = { maxForksPerCycle: 3 };
+var DEFAULT_WATCH = { maxForksPerCycle: 3, autoRepair: true, conflicts: true, checks: true, maxRepairsPerPr: 2 };
 var DEFAULT_LIMITS = {
   maxConcurrent: 2,
   choreConcurrent: 1,
   wedgeThresholdSecs: 600,
   maxRestartAttempts: 2,
   wallClockSecs: 3600,
+  pushEarly: true,
+  draftPr: true,
+  checkpointOnStop: true,
   backgroundWaitSecs: 1800,
   choreRetentionDays: 7,
   attachmentMaxBytes: 25 * 1024 * 1024,
   retentionDays: 0,
-  minFreeGB: 0
+  minFreeGB: 0,
+  reuseWorktree: true,
+  releaseOnMerge: false
 };
 function configPath() {
-  return path4.join(lobstahHome(), "config.toml");
+  return path6.join(lobstahHome(), "config.toml");
 }
 function expandHome(p) {
-  return p.startsWith("~/") ? path4.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 = fs6.existsSync(file) ? parse(fs6.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)) {
@@ -867,7 +1171,11 @@ function loadConfig() {
       setup: Array.isArray(r.setup) ? r.setup.map(String) : void 0,
       env: r.env ?? void 0,
       harness: r.harness ?? void 0,
-      pickup: r.pickup === void 0 ? void 0 : Boolean(r.pickup)
+      pickup: r.pickup === void 0 ? void 0 : Boolean(r.pickup),
+      scratch: Array.isArray(r.scratch) ? r.scratch.map(String) : void 0,
+      pushEarly: r.pushEarly === void 0 ? void 0 : Boolean(r.pushEarly),
+      draftPr: r.draftPr === void 0 ? void 0 : Boolean(r.draftPr),
+      checkpointOnStop: r.checkpointOnStop === void 0 ? void 0 : Boolean(r.checkpointOnStop)
     };
   }
   const groundsRaw = raw.grounds ?? {};
@@ -910,21 +1218,21 @@ function resolveDispatch(d, cfg) {
 }
 
 // packages/core/dist/harness.js
-import * as fs7 from "node:fs";
-import * as path5 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(path5.delimiter)) {
+  for (const dir of pathVar.split(path7.delimiter)) {
     if (!dir)
       continue;
     for (const name of names) {
-      const candidate = path5.join(dir, name);
+      const candidate = path7.join(dir, name);
       try {
-        fs7.accessSync(candidate, fs7.constants.X_OK);
-        if (fs7.statSync(candidate).isFile())
+        fs9.accessSync(candidate, fs9.constants.X_OK);
+        if (fs9.statSync(candidate).isFile())
           return candidate;
       } catch {
       }
@@ -945,22 +1253,28 @@ function codexInvocation(argv) {
   } catch {
   }
   for (const dir of require_.resolve.paths("@openai/codex") ?? []) {
-    const cli = path5.join(dir, "@openai", "codex", "bin", "codex.js");
-    if (fs7.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 fs8 from "node:fs";
-import * as path6 from "node:path";
-function regPath(trapId) {
-  return path6.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) {
+function slug(key) {
+  return key.replace(/[^A-Za-z0-9._-]+/g, "-");
+}
+function watchPath(key) {
+  return path8.join(watchesDir(), `${slug(key)}.json`);
+}
+function readWatch(key) {
   try {
-    return JSON.parse(fs8.readFileSync(regPath(trapId), "utf8"));
+    return JSON.parse(fs10.readFileSync(watchPath(key), "utf8"));
   } catch {
     return void 0;
   }
@@ -976,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 fs9 from "node:fs";
+import * as fs12 from "node:fs";
 import * as os3 from "node:os";
-import * as path7 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) {
@@ -993,7 +1364,7 @@ function claimOf(id, lane) {
   const dirs = laneDirs(lane);
   for (const dir of [dirs.active, dirs.done]) {
     try {
-      return JSON.parse(fs9.readFileSync(path7.join(dir, id, "claim.json"), "utf8"));
+      return JSON.parse(fs12.readFileSync(path10.join(dir, id, "claim.json"), "utf8"));
     } catch {
     }
   }
@@ -1043,7 +1414,7 @@ function isUnresumable(error) {
   return error !== void 0 && UNRESUMABLE.test(error);
 }
 function worktreeProgress(worktree, trunk) {
-  if (!worktree || !fs9.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");
@@ -1076,31 +1447,31 @@ function handoffNote(fromHarness, progress, why) {
 ${progress}`;
 }
 function codexHome(env = process.env) {
-  return env.CODEX_HOME ?? path7.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 = fs9.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 path7.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(path7.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(path7.join(home, "sessions"), 3) ?? walk(path7.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);
@@ -1108,12 +1479,12 @@ function codexDesktopThread(threadId, home = codexHome()) {
     return void 0;
   let head = "";
   try {
-    const fd = fs9.openSync(file, "r");
+    const fd = fs12.openSync(file, "r");
     try {
       const buf = Buffer.alloc(4096);
-      head = buf.subarray(0, fs9.readSync(fd, buf, 0, buf.length, 0)).toString("utf8");
+      head = buf.subarray(0, fs12.readSync(fd, buf, 0, buf.length, 0)).toString("utf8");
     } finally {
-      fs9.closeSync(fd);
+      fs12.closeSync(fd);
     }
   } catch {
     return void 0;
@@ -1143,10 +1514,164 @@ function droppedModelNote(harness, dropped) {
   return `model ${dropped.model} is a ${dropped.owner} model \u2014 dropped, using ${harness}'s default`;
 }
 
+// packages/core/dist/worktrees.js
+import * as fs13 from "node:fs";
+import * as path11 from "node:path";
+var LANES = ["work", "chore"];
+function worktreePath(id) {
+  return path11.join(lobstahHome(), "worktrees", id);
+}
+function readRecord(file) {
+  try {
+    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 = path11.relative(path11.join(lobstahHome(), "worktrees"), p);
+  if (!rel || rel.startsWith("..") || path11.isAbsolute(rel))
+    return void 0;
+  return rel.split(/[\\/]/)[0];
+}
+function dispatchWorktree(id, lane) {
+  for (const l of lane ? [lane] : LANES) {
+    const ev = readEvidence(id, l);
+    if (ev.worktree) {
+      const owner = ev.worktreeOf ?? ownerOfPath(ev.worktree) ?? id;
+      return { path: ev.worktree, owner, reused: owner !== id };
+    }
+    const dirs = laneDirs(l);
+    for (const dir of [dirs.active, dirs.done]) {
+      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 };
+      }
+    }
+  }
+  return { path: worktreePath(id), owner: id, reused: false };
+}
+function laneOf2(id) {
+  for (const l of LANES) {
+    const d = laneDirs(l);
+    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;
+    }
+  }
+  return void 0;
+}
+function followUpAncestors(id, lane) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set([id]);
+  let cur = storedDescriptor(id, lane ?? laneOf2(id) ?? "work")?.followUp;
+  while (cur && !seen.has(cur)) {
+    out.push(cur);
+    seen.add(cur);
+    cur = storedDescriptor(cur, laneOf2(cur) ?? lane ?? "work")?.followUp;
+  }
+  return out;
+}
+function chainWorktree(followUp) {
+  for (const id of [followUp, ...followUpAncestors(followUp)]) {
+    const wt = dispatchWorktree(id, laneOf2(id));
+    if (fs13.existsSync(wt.path))
+      return { ...wt, from: id };
+  }
+  return void 0;
+}
+function worktreeGitDir(wt) {
+  const dotGit = path11.join(wt, ".git");
+  try {
+    const st = fs13.statSync(dotGit);
+    if (st.isDirectory())
+      return dotGit;
+    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 ? path11.join(gitDir, "lobstah.lock") : void 0;
+}
+function readWorktreeLock(wt) {
+  const file = worktreeLockFile(wt);
+  if (!file)
+    return void 0;
+  try {
+    return JSON.parse(fs13.readFileSync(file, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function lockIsLive(lock) {
+  return fs13.existsSync(path11.join(laneDirs(lock.lane).active, lock.id));
+}
+function worktreeHolder(wt) {
+  const lock = readWorktreeLock(wt);
+  return lock && lockIsLive(lock) ? lock : void 0;
+}
+function acquireWorktreeLock(wt, id, lane) {
+  const file = worktreeLockFile(wt);
+  const mine = { id, lane, pid: process.pid, at: (/* @__PURE__ */ new Date()).toISOString() };
+  if (!file)
+    return { id: "(no git dir)", lane, pid: 0, at: mine.at };
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      fs13.writeFileSync(file, JSON.stringify(mine, null, 2), { flag: "wx" });
+      return void 0;
+    } catch (err) {
+      if (err.code !== "EEXIST")
+        throw err;
+    }
+    let raw;
+    try {
+      raw = fs13.readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    let held2;
+    try {
+      held2 = JSON.parse(raw);
+    } catch {
+      held2 = void 0;
+    }
+    if (held2?.id === id) {
+      fs13.writeFileSync(file, JSON.stringify(mine, null, 2));
+      return void 0;
+    }
+    if (held2 && lockIsLive(held2))
+      return held2;
+    try {
+      if (fs13.readFileSync(file, "utf8") === raw)
+        fs13.rmSync(file, { force: true });
+    } catch {
+    }
+  }
+  const held = readWorktreeLock(wt);
+  return held ?? { id: "(contended)", lane, pid: 0, at: mine.at };
+}
+function releaseWorktreeLock(wt, id) {
+  const file = worktreeLockFile(wt);
+  if (!file)
+    return;
+  if (readWorktreeLock(wt)?.id === id)
+    fs13.rmSync(file, { force: true });
+}
+
+// packages/core/dist/slots.js
+function isTrapCatch(id, lane) {
+  return readSessionClaim(id, lane)?.by.startsWith("wt:") ?? false;
+}
+
 // packages/runner/src/run.ts
-import * as fs12 from "node:fs";
-import * as path10 from "node:path";
-import { fileURLToPath } from "node:url";
+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";
 
 // packages/adapters/dist/claude.js
 import { spawn } from "node:child_process";
@@ -1178,7 +1703,7 @@ var AsyncQueue = class {
           return Promise.resolve({ value: item, done: false });
         if (this.closed)
           return Promise.resolve({ value: void 0, done: true });
-        return new Promise((resolve2) => this.waiters.push(resolve2));
+        return new Promise((resolve6) => this.waiters.push(resolve6));
       }
     };
   }
@@ -1203,7 +1728,7 @@ var InputGate = class {
         return msg;
       if (this.ended)
         return void 0;
-      await new Promise((resolve2) => this.waiter = resolve2);
+      await new Promise((resolve6) => this.waiter = resolve6);
       this.waiter = null;
     }
   }
@@ -1241,7 +1766,10 @@ function pumpClaudeMessage(msg, push, onSession) {
   } else if (msg.type === "assistant") {
     for (const block of msg.message?.content ?? []) {
       if (block.type === "tool_use") {
-        push({ at, type: "tool-start", data: { name: block.name } });
+        const target = toolTarget(block.input);
+        push({ at, type: "tool-start", data: { name: block.name, ...target ? { target } : {} } });
+      } else if (block.type === "thinking" || block.type === "redacted_thinking") {
+        push({ at, type: "thinking", data: {} });
       } else if (block.type === "text" && block.text) {
         push({ at, type: "text", data: { text: String(block.text).slice(0, 2e3) } });
       }
@@ -1343,20 +1871,20 @@ function startClaudeCli(invocation, opts) {
       }
     }
   });
-  const done = new Promise((resolve2) => {
+  const done = new Promise((resolve6) => {
     child.on("error", (err) => {
       events.push({ at: now(), type: "error", data: { message: err.message } });
       events.close();
-      resolve2({ sessionId, error: err.message });
+      resolve6({ sessionId, error: err.message });
     });
     child.on("exit", (code) => {
       events.close();
       if (code === 0)
-        resolve2({ sessionId });
+        resolve6({ sessionId });
       else {
         const detail = stderrTail.trim().split("\n").at(-1);
         const error = `claude exited ${code}${detail ? ` \u2014 ${detail}` : ""}`;
-        resolve2({ sessionId, error });
+        resolve6({ sessionId, error });
       }
     });
   });
@@ -1435,25 +1963,25 @@ function createClaudeAdapter() {
 }
 
 // packages/adapters/dist/codex.js
-import * as fs10 from "node:fs";
+import * as fs14 from "node:fs";
 import * as os4 from "node:os";
-import * as path8 from "node:path";
+import * as path12 from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 function isolatedCodexHome() {
-  const dir = path8.join(lobstahHome(), "codex-home");
-  fs10.mkdirSync(dir, { recursive: true });
-  const auth = path8.join(dir, "auth.json");
-  const realAuth = path8.join(os4.homedir(), ".codex", "auth.json");
-  if (!fs10.existsSync(auth) && fs10.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 {
-      fs10.symlinkSync(realAuth, auth);
+      fs14.symlinkSync(realAuth, auth);
     } catch {
-      fs10.copyFileSync(realAuth, auth);
+      fs14.copyFileSync(realAuth, auth);
     }
   }
-  const cfg = path8.join(dir, "config.toml");
-  if (!fs10.existsSync(cfg)) {
-    fs10.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;
 }
@@ -1465,8 +1993,12 @@ function pumpCodexEvent(ev, push, onSession) {
     push({ at, type: "session", data: { sessionId: ev.thread_id } });
   } else if (ev.type === "turn.started") {
     push({ at, type: "turn-start", data: {} });
+  } else if (ev.type === "item.started" && ev.item?.type === "reasoning") {
+    push({ at, type: "thinking", data: {} });
   } else if (ev.type === "item.started") {
-    push({ at, type: "tool-start", data: { name: ev.item?.type } });
+    const item = ev.item ?? {};
+    const target = toolTarget(item) ?? (typeof item.tool === "string" ? typeof item.server === "string" ? `${item.server}.${item.tool}` : item.tool : void 0);
+    push({ at, type: "tool-start", data: { name: item.type, ...target ? { target } : {} } });
   } else if (ev.type === "item.completed") {
     if (ev.item?.type === "agent_message" && ev.item?.text) {
       push({ at, type: "text", data: { text: String(ev.item.text).slice(0, 2e3) } });
@@ -1499,7 +2031,7 @@ function startCodexCli(invoke, opts) {
   let current;
   let killed = false;
   function runTurn(prompt, resumeThread) {
-    return new Promise((resolve2) => {
+    return new Promise((resolve6) => {
       const inv = invoke(codexExecArgs(opts, prompt, resumeThread));
       const child = spawn2(inv.file, inv.argv, {
         cwd: opts.cwd,
@@ -1530,14 +2062,14 @@ function startCodexCli(invoke, opts) {
           }
         }
       });
-      child.on("error", (err) => resolve2(err.message));
+      child.on("error", (err) => resolve6(err.message));
       child.on("exit", (code) => {
         if (turnError)
-          return resolve2(turnError);
+          return resolve6(turnError);
         if (code === 0 || killed)
-          return resolve2(void 0);
+          return resolve6(void 0);
         const detail = stderrTail.trim().split("\n").at(-1);
-        resolve2(`codex exited ${code}${detail ? ` \u2014 ${detail}` : ""}`);
+        resolve6(`codex exited ${code}${detail ? ` \u2014 ${detail}` : ""}`);
       });
     });
   }
@@ -1650,15 +2182,13 @@ function loadAdapter(name) {
 }
 
 // packages/worktree/dist/index.js
-import * as fs11 from "node:fs";
-import * as path9 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";
 var run = promisify(execFile);
 var shell = promisify(exec);
-function worktreePath(id) {
-  return path9.join(lobstahHome(), "worktrees", id);
-}
 async function git(cwd, ...args) {
   const { stdout } = await run("git", args, { cwd, env: process.env });
   return stdout.trim();
@@ -1710,23 +2240,158 @@ ${gitStderr(err)}`, { cause: err });
 }
 async function allocate(repo, id) {
   const dir = worktreePath(id);
-  if (fs11.existsSync(dir)) {
+  if (fs15.existsSync(dir)) {
     throw new Error(`worktree for ${id} already exists at ${dir} \u2014 never allocate a second`);
   }
-  if (!fs11.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 });
   }
   await gitShared(repo.path, "fetch", "origin", repo.trunk);
   await gitShared(repo.path, "worktree", "add", "--no-track", dir, "-b", `lobstah/${id}`, `origin/${repo.trunk}`);
+  await runSetup(repo, dir);
+  return dir;
+}
+async function runSetup(repo, dir) {
   for (const cmd of repo.setup ?? []) {
     await shell(cmd, { cwd: dir, env: { ...process.env, ...repo.env ?? {} } });
   }
-  return dir;
+  recordSetup(repo, dir);
+}
+var LOCKFILES = [
+  "pnpm-lock.yaml",
+  "package-lock.json",
+  "npm-shrinkwrap.json",
+  "yarn.lock",
+  "bun.lock",
+  "bun.lockb",
+  "Cargo.lock",
+  "go.sum",
+  "poetry.lock",
+  "uv.lock",
+  "Pipfile.lock",
+  "Gemfile.lock",
+  "composer.lock",
+  "Package.resolved"
+];
+function setupHash(repo, dir) {
+  const h = createHash("sha256");
+  h.update(JSON.stringify(repo.setup ?? []));
+  for (const name of LOCKFILES) {
+    const file = path13.join(dir, name);
+    if (!fs15.existsSync(file))
+      continue;
+    h.update(`\0${name}\0`);
+    h.update(fs15.readFileSync(file));
+  }
+  return h.digest("hex");
 }
-async function collectEvidence(repo, id) {
-  const dir = worktreePath(id);
+function setupRecordFile(dir) {
+  const gitDir = worktreeGitDir(dir);
+  return gitDir ? path13.join(gitDir, "lobstah-setup.json") : void 0;
+}
+function recordSetup(repo, dir) {
+  const file = setupRecordFile(dir);
+  if (file)
+    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(fs15.readFileSync(file, "utf8")).hash : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var short = (s) => s.slice(0, 8);
+function realpath(p) {
+  let r;
+  try {
+    r = fs15.realpathSync.native(p);
+  } catch {
+    r = path13.resolve(p);
+  }
+  return process.platform === "win32" ? r.toLowerCase() : r;
+}
+function norm(p) {
+  return p.replace(/^"(.*)"$/, "$1").replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+}
+function onlyScratch(porcelain, scratch) {
+  const lines = porcelain.split("\n").filter((l) => l.trim() !== "");
+  if (lines.length === 0)
+    return true;
+  const roots = (scratch ?? []).map(norm).filter(Boolean);
+  if (roots.length === 0)
+    return false;
+  return lines.every((line) => {
+    if (!line.startsWith("?? "))
+      return false;
+    const p = norm(line.slice(3));
+    return roots.some((r) => p === r || p.startsWith(`${r}/`));
+  });
+}
+async function chooseWorktree(input) {
+  const { id, lane, repoKey, repo, followUp } = input;
+  const found = chainWorktree(followUp);
+  if (!found)
+    return { reuse: false, reason: "origin worktree is gone" };
+  const ownerRepo = storedDescriptor(found.owner, laneOf2(found.owner) ?? lane)?.repo ?? storedDescriptor(found.from, laneOf2(found.from) ?? lane)?.repo;
+  if (ownerRepo !== void 0 && ownerRepo !== repoKey) {
+    return { reuse: false, reason: `origin worktree belongs to repo ${ownerRepo}` };
+  }
+  try {
+    const common = await git(found.path, "rev-parse", "--path-format=absolute", "--git-common-dir");
+    const mine = await git(repo.path, "rev-parse", "--path-format=absolute", "--git-common-dir");
+    if (realpath(common) !== realpath(mine))
+      return { reuse: false, reason: "origin worktree belongs to another repo" };
+  } catch {
+    return { reuse: false, reason: "origin worktree is not a readable git checkout" };
+  }
+  const here = realpath(found.path);
+  for (const t of listTraps()) {
+    if (typeof t.worktree !== "string")
+      continue;
+    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"]) {
+    for (const other of activeIds(l)) {
+      if (other === id)
+        continue;
+      if (realpath(dispatchWorktree(other, l).path) === here) {
+        return { reuse: false, reason: `origin worktree is in use by ${short(other)}` };
+      }
+    }
+  }
+  const holder = worktreeHolder(found.path);
+  if (holder && holder.id !== id)
+    return { reuse: false, reason: `origin worktree is in use by ${short(holder.id)}` };
+  let porcelain;
+  try {
+    porcelain = await git(found.path, "status", "--porcelain");
+  } catch {
+    return { reuse: false, reason: "origin worktree is not a readable git checkout" };
+  }
+  if (!onlyScratch(porcelain, repo.scratch)) {
+    return { reuse: false, reason: "origin worktree has uncommitted changes; allocated a fresh one" };
+  }
+  const held = acquireWorktreeLock(found.path, id, lane);
+  if (held)
+    return { reuse: false, reason: `origin worktree is in use by ${short(held.id)}` };
+  return { reuse: true, path: found.path, owner: found.owner, from: found.from };
+}
+async function prepareReuse(repo, dir) {
+  await gitShared(dir, "fetch", "origin", repo.trunk);
+  if (!repo.setup?.length)
+    return { setupRan: false };
+  if (recordedSetupHash(dir) === setupHash(repo, dir))
+    return { setupRan: false };
+  await runSetup(repo, dir);
+  return { setupRan: true };
+}
+async function collectEvidence(repo, dir) {
   const branch = await git(dir, "rev-parse", "--abbrev-ref", "HEAD");
   const log = await git(dir, "log", "--oneline", `origin/${repo.trunk}..HEAD`);
   return { branch, commits: log ? log.split("\n") : [] };
@@ -1740,9 +2405,12 @@ function buildPrompt(brief, opts) {
     `Work only inside the current directory \u2014 it is an isolated git worktree allocated for this dispatch.`,
     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.`,
-    `Commit your work with clear messages. Do not merge anything.`,
+    `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.`,
+    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);
@@ -1754,7 +2422,7 @@ var WAITING_VERBS = ["needs-decision", "blocked", "paused"];
 function unreportedNudge(id) {
   return `Your turn ended without a status report, so this dispatch is not finished. If the work is complete, run \`lobstah report ${id} done "<what you did>"\`, adding \`--pr <url>\` if you opened a PR. If no change was needed, report \`done\` with a note saying why. If a human has to answer a question, or you are blocked, report \`needs-decision\` or \`blocked\` with it. If you are waiting on something, run it in the background: you are woken when it finishes.`;
 }
-var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+var sleep = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms));
 function deliver(run2, id, lane) {
   const msgs = unhandled(id, lane);
   for (const m of msgs) {
@@ -1772,6 +2440,14 @@ async function drive(run2, opts) {
     backgroundWaitMs = 30 * 6e4,
     settleGraceMs = 12e4
   } = opts;
+  const tracker = new ActivityTracker((a) => writeActivity(id, lane, a), {
+    root: opts.cwd,
+    throttleMs: opts.activityThrottleMs
+  });
+  const record = (ev) => {
+    appendEvent(id, lane, ev);
+    tracker.observe(ev);
+  };
   let cancelled = false;
   let activity = 0;
   let finished = false;
@@ -1785,7 +2461,8 @@ async function drive(run2, opts) {
     appendEvent(id, lane, { at: (/* @__PURE__ */ new Date()).toISOString(), type: "runner", data: { resumed: verb } });
   };
   const awaitAnswer = async (verb) => {
-    appendEvent(id, lane, { at: (/* @__PURE__ */ new Date()).toISOString(), type: "runner", data: { waiting: verb } });
+    const on = readStatusLog(id, lane).at(-1)?.waitingOn;
+    record({ at: (/* @__PURE__ */ new Date()).toISOString(), type: "runner", data: { waiting: verb, ...on ? { on } : {} } });
     while (true) {
       if (stopped() || finished) return;
       if (cancelRequested(id, lane)) return cancel();
@@ -1797,7 +2474,7 @@ async function drive(run2, opts) {
   let liveBackground = 0;
   let nudged = false;
   let hold;
-  const runnerEvent = (data) => appendEvent(id, lane, { at: (/* @__PURE__ */ new Date()).toISOString(), type: "runner", data });
+  const runnerEvent = (data) => record({ at: (/* @__PURE__ */ new Date()).toISOString(), type: "runner", data });
   const releaseHold = () => {
     if (!hold) return;
     clearInterval(hold.heartbeat);
@@ -1832,7 +2509,7 @@ async function drive(run2, opts) {
     hold = { heartbeat, expiry };
   };
   for await (const ev of run2.events) {
-    appendEvent(id, lane, ev);
+    record(ev);
     if (ev.type === "background") {
       liveBackground = Number(ev.data?.live ?? 0);
       if (hold && liveBackground === 0) holdOpen(settleGraceMs);
@@ -1875,18 +2552,20 @@ async function drive(run2, opts) {
     unreported();
   }
   releaseHold();
+  tracker.flush();
+  tracker.stop();
   return { cancelled, activity };
 }
 function settle(id, lane, r) {
   const lastVerb = readStatusLog(id, lane).at(-1)?.verb;
   if (r.cancelled) appendStatus(id, lane, "failed", "cancelled by operator");
-  else if (r.wallClockHit) appendStatus(id, lane, "failed", "wall-clock limit exceeded");
+  else if (r.wallClockHit) appendStatus(id, lane, "failed", `budget: out of time${r.budgetNote ? `; ${r.budgetNote}` : ""}; send continue to resume`);
   else if (r.error) appendStatus(id, lane, "failed", r.error.slice(0, 500));
   else if (!lastVerb || !TERMINAL_VERBS.includes(lastVerb)) appendStatus(id, lane, "failed", "stopped without reporting a result");
 }
 
 // packages/runner/src/plan.ts
-var short = (s) => s.slice(0, 8);
+var short2 = (s) => s.slice(0, 8);
 function askedHarness(id, lane, cfg) {
   const d = storedDescriptor(id, lane);
   return d?.harness ?? (d ? cfg.repos[d.repo]?.harness?.default : void 0) ?? cfg.harness.default ?? "claude";
@@ -1900,13 +2579,13 @@ function planStart(input) {
       return {
         harness: resolvedHarness,
         cold: { why: CODEX_DESKTOP_THREAD, fromHarness: harness },
-        note: `restart: ${CODEX_DESKTOP_THREAD} (${short(envResume)}), starting cold on ${resolvedHarness}`
+        note: `restart: ${CODEX_DESKTOP_THREAD} (${short2(envResume)}), starting cold on ${resolvedHarness}`
       };
     }
     return {
       harness,
       resume: { sessionId: envResume, own: true },
-      note: harness !== resolvedHarness ? `resuming own ${harness} session ${short(envResume)}` : void 0
+      note: harness !== resolvedHarness ? `resuming own ${harness} session ${short2(envResume)}` : void 0
     };
   }
   const prior = readEvidence(id, lane).sessionId;
@@ -1914,7 +2593,7 @@ function planStart(input) {
     const from = resolveSessionHarness(id, cfg, lane).harness;
     return {
       harness: resolvedHarness,
-      cold: { why: `session ${short(prior)} is not resumed on a respawn`, fromHarness: from },
+      cold: { why: `session ${short2(prior)} is not resumed on a respawn`, fromHarness: from },
       note: `respawn: starting cold on ${resolvedHarness}${from ? ` (previous session: ${from})` : ""}`
     };
   }
@@ -1926,15 +2605,15 @@ function planStart(input) {
   if (!origin.sessionId) {
     return {
       harness: resolvedHarness,
-      cold: { why: `follow-up origin ${short(originId)} has no recorded session`, origin: originRef },
-      note: `follow-up of ${short(originId)}: no session recorded \u2014 starting cold on ${resolvedHarness} with a progress note`
+      cold: { why: `follow-up origin ${short2(originId)} has no recorded session`, origin: originRef },
+      note: `follow-up of ${short2(originId)}: no session recorded \u2014 starting cold on ${resolvedHarness} with a progress note`
     };
   }
   if (!origin.harness) {
     return {
       harness: resolvedHarness,
       resume: { sessionId: origin.sessionId, own: false, origin: originRef },
-      note: `follow-up of ${short(originId)}: resuming session ${short(origin.sessionId)} on ${resolvedHarness} (origin harness unknown)`
+      note: `follow-up of ${short2(originId)}: resuming session ${short2(origin.sessionId)} on ${resolvedHarness} (origin harness unknown)`
     };
   }
   const requested = descriptor.harness;
@@ -1943,48 +2622,273 @@ function planStart(input) {
     return {
       harness: requested,
       cold: { why: `swap from ${origin.harness} to ${requested}`, fromHarness: origin.harness, origin: originRef },
-      note: `follow-up of ${short(originId)}: swap \u2014 origin session is ${origin.harness}, ${requested} requested; starting cold on ${requested} with a progress note`
+      note: `follow-up of ${short2(originId)}: swap \u2014 origin session is ${origin.harness}, ${requested} requested; starting cold on ${requested} with a progress note`
     };
   }
   if (origin.harness === "codex" && codexDesktopThread(origin.sessionId)) {
     return {
       harness: resolvedHarness,
       cold: { why: CODEX_DESKTOP_THREAD, fromHarness: origin.harness, origin: originRef },
-      note: `follow-up of ${short(originId)}: ${CODEX_DESKTOP_THREAD} (${short(origin.sessionId)}), starting cold on ${resolvedHarness} with a progress note`
+      note: `follow-up of ${short2(originId)}: ${CODEX_DESKTOP_THREAD} (${short2(origin.sessionId)}), starting cold on ${resolvedHarness} with a progress note`
     };
   }
   const ignored = requested !== void 0 && requested !== origin.harness ? ` (--harness ${requested} ignored for the resume)` : "";
   return {
     harness: origin.harness,
     resume: { sessionId: origin.sessionId, own: false, origin: originRef },
-    note: `follow-up of ${short(originId)}: resuming ${origin.harness} session ${short(origin.sessionId)} (harness from ${origin.source})${ignored}`
+    note: `follow-up of ${short2(originId)}: resuming ${origin.harness} session ${short2(origin.sessionId)} (harness from ${origin.source})${ignored}`
+  };
+}
+
+// packages/runner/src/wallclock.ts
+function startWallClock(opts) {
+  const now2 = opts.now ?? Date.now;
+  const tickMs = Math.max(1, Math.min(opts.tickMs ?? 5e3, opts.limitMs));
+  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));
+  let last = now2();
+  let done = false;
+  const check = () => {
+    const t = now2();
+    let paused = false;
+    try {
+      paused = opts.paused();
+    } catch {
+      paused = false;
+    }
+    if (!paused) elapsed += t - last;
+    last = t;
+    if (!done && elapsed >= windowMs && elapsed < maxMs) {
+      let advanced = false;
+      try {
+        advanced = opts.progress?.() ?? false;
+      } catch {
+      }
+      if (advanced) windowMs = Math.min(maxMs, windowMs + opts.limitMs);
+    }
+    opts.onTick?.(elapsed, windowMs);
+    if (!done && elapsed >= windowMs) {
+      done = true;
+      clearInterval(timer);
+      opts.onExpire();
+    }
+  };
+  const timer = setInterval(check, tickMs);
+  timer.unref?.();
+  return {
+    stop: () => {
+      done = true;
+      clearInterval(timer);
+    },
+    elapsed: () => elapsed,
+    window: () => windowMs
+  };
+}
+
+// packages/runner/src/remote.ts
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+import { fileURLToPath } from "node:url";
+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() : "";
+  return (stderr || (err instanceof Error ? err.message : String(err))).replace(/\s+/g, " ").slice(0, 240);
+}
+function checkpointAllowed(file) {
+  const parts = file.toLowerCase().split("/");
+  const base = parts.at(-1) ?? "";
+  if (parts.some((p) => [".git", "node_modules", "dist", "build", "coverage", ".next", ".turbo"].includes(p))) return false;
+  if (base === ".env" || base.startsWith(".env.") || base.endsWith(".pem") || base.endsWith(".key") || base.endsWith(".p12")) return false;
+  if (/^(credentials?|secrets?|id_rsa|id_ed25519)(\.|$)/.test(base)) return false;
+  return true;
+}
+function keepRemote(opts) {
+  const { id, lane, cwd, trunk, policy, existingPrUrl } = opts;
+  const command = async (bin, args, timeout = 12e4) => {
+    const file = bin === "gh" || bin === "lobstah" ? resolveOnPath(bin) ?? bin : bin;
+    return (await exec2(file, args, {
+      cwd,
+      encoding: "utf8",
+      timeout,
+      maxBuffer: 4 * 1024 * 1024,
+      shell: process.platform === "win32" && /\.(?:cmd|bat)$/i.test(file)
+    })).stdout.trim();
+  };
+  const git2 = (...args) => command("git", args);
+  const note = (message) => mergeEvidence(id, lane, { note: message.slice(0, 300) });
+  if (existingPrUrl) mergeEvidence(id, lane, { prUrl: existingPrUrl });
+  const registerWatch = async (url) => {
+    const root = 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;
+  let stopped = false;
+  let opened = false;
+  let opening;
+  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;
+    return branch;
+  };
+  const draft = async (branch) => {
+    if (!policy.draftPr || opened || readEvidence(id, lane).prUrl) return;
+    let url = "";
+    try {
+      url = await command("gh", ["pr", "view", branch, "--json", "url", "--jq", ".url"]);
+    } catch {
+    }
+    if (!url) {
+      try {
+        url = await command("gh", [
+          "pr",
+          "create",
+          "--draft",
+          "--base",
+          trunk,
+          "--head",
+          branch,
+          "--title",
+          opts.title.slice(0, 120),
+          "--body",
+          `Work in progress for lobstah dispatch ${id}.`
+        ]);
+      } catch (err) {
+        draftProblem = `draft PR unavailable: ${firstLine(err)}`;
+        note(draftProblem);
+        return;
+      }
+    }
+    const match = url.match(/https:\/\/github\.com\/[^\s]+\/pull\/\d+/);
+    if (!match) return;
+    opened = true;
+    draftProblem = void 0;
+    mergeEvidence(id, lane, { prUrl: match[0] });
+    await registerWatch(match[0]).catch(() => {
+    });
+  };
+  const check = async () => {
+    if (!policy.pushEarly || trapClaimed() || existingPrUrl) return;
+    const branch = await branchName();
+    if (!branch) return;
+    const head = await git2("rev-parse", "HEAD");
+    const ahead = await git2("rev-list", "--count", `origin/${trunk}..HEAD`).catch(() => "1");
+    if (ahead === "0") return;
+    if (head === lastSeenHead) return;
+    lastSeenHead = head;
+    if (head === pushedHead) return;
+    try {
+      await git2("push", "-u", "origin", branch);
+      pushedHead = head;
+      pushProblem = void 0;
+      mergeEvidence(id, lane, { branch });
+      note(`remote saved: ${branch}@${head.slice(0, 12)}`);
+      if (!opening) opening = draft(branch).finally(() => {
+        opening = void 0;
+      });
+    } catch (err) {
+      pushProblem = `push rejected for ${branch}@${head.slice(0, 12)}: ${firstLine(err)}; retry after HEAD moves`;
+      note(pushProblem);
+    }
+  };
+  const poll = () => {
+    if (busy || stopped) return;
+    busy = check().catch((err) => note(`remote check unavailable: ${firstLine(err)}`)).finally(() => {
+      busy = void 0;
+    });
+  };
+  if (policy.pushEarly) poll();
+  const timer = setInterval(poll, Math.min(1e4, Math.max(1e3, opts.intervalMs ?? 1e4)));
+  timer.unref?.();
+  return {
+    stop: async () => {
+      stopped = true;
+      clearInterval(timer);
+      await busy;
+      await check().catch((err) => note(`final push unavailable: ${firstLine(err)}`));
+      await opening;
+      await watching;
+    },
+    saveBeforeStop: async () => {
+      stopped = true;
+      clearInterval(timer);
+      await busy;
+      if (trapClaimed()) return "checkpoint skipped: trap-claimed dispatch";
+      const branch = await branchName();
+      if (!branch) {
+        const message2 = "checkpoint skipped: detached or trunk; files left in place";
+        note(message2);
+        return message2;
+      }
+      let saved = "no working-tree changes";
+      if (policy.checkpointOnStop) {
+        try {
+          const paths = (await git2("ls-files", "-m", "-o", "-d", "--exclude-standard", "-z")).split("\0").filter(Boolean).filter(checkpointAllowed);
+          if (paths.length) {
+            await git2("add", "-A", "--", ...paths);
+            const staged = await git2("diff", "--cached", "--name-only", "--", ...paths);
+            if (staged) {
+              await git2("commit", "--only", "-m", "Checkpoint before runner stop", "--", ...paths);
+              saved = `checkpoint committed (${staged.split("\n").length} files)`;
+            }
+          }
+        } catch (err) {
+          saved = `checkpoint unavailable: ${firstLine(err)}`;
+        }
+      }
+      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 ? `; ${existingPrUrl ? "existing" : "draft"} PR ${pr}` : ""}${pushProblem ? `; ${pushProblem}` : ""}${draftProblem ? `; ${draftProblem}` : ""}`;
+      note(message);
+      return message;
+    }
   };
 }
 
 // packages/runner/src/run.ts
-var defaultDeps = { loadAdapter, allocate, collectEvidence };
+var defaultDeps = { loadAdapter, allocate, chooseWorktree, prepareReuse, collectEvidence };
+var short3 = (s) => s.slice(0, 8);
 function coldNote(cold, cwd, trunk) {
   const parts = [worktreeProgress(cwd, trunk)];
   if (cold.origin) parts.push(originProgress(cold.origin.id, cold.origin.lane));
   return handoffNote(cold.fromHarness ?? "unknown", parts.join("\n\n"), cold.why);
 }
-async function main(activeDir, lane, deps = defaultDeps) {
-  const id = path10.basename(activeDir);
+async function main(activeDir, lane, seams = {}) {
+  const deps = { ...defaultDeps, ...seams };
+  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(fs12.readFileSync(path10.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 = path10.join(activeDir, "brief.md");
-  if (!fs12.existsSync(briefFile)) fs12.writeFileSync(briefFile, descriptor.brief);
-  const brief = fs12.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
   };
-  fs12.writeFileSync(path10.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,
@@ -1993,11 +2897,24 @@ async function main(activeDir, lane, deps = defaultDeps) {
     resolvedHarness: resolved.harness,
     envResume: process.env.LOBSTAH_RESUME
   });
+  const wtFile = path15.join(activeDir, "worktree.json");
+  let recorded;
+  let choice;
+  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 });
+  }
+  const worktreeNote = choice ? choice.reuse ? `reusing worktree of ${short3(choice.from)}` : `fresh worktree (${choice.reason})` : void 0;
   const firstModel = modelForHarness(plan.harness, resolved.model);
   const firstNote = [
     attempts > 1 ? `attempt ${attempts}` : void 0,
     plan.note,
-    firstModel.dropped ? droppedModelNote(plan.harness, firstModel.dropped) : void 0
+    firstModel.dropped ? droppedModelNote(plan.harness, firstModel.dropped) : void 0,
+    worktreeNote
   ].filter(Boolean).join("; ");
   status("working", firstNote || void 0);
   appendEvent(id, lane, {
@@ -2007,28 +2924,112 @@ async function main(activeDir, lane, deps = defaultDeps) {
   });
   const own = readEvidence(id, lane).sessionId;
   mergeEvidence(id, lane, { harness: plan.harness, sessionId: plan.resume?.own ? own : void 0 });
-  const wtFile = path10.join(activeDir, "worktree.json");
   let cwd;
-  if (fs12.existsSync(wtFile)) {
-    cwd = JSON.parse(fs12.readFileSync(wtFile, "utf8")).path;
-    if (!fs12.existsSync(cwd)) throw new Error(`recorded worktree ${cwd} is gone`);
-  } else if (fs12.existsSync(worktreePath(id))) {
-    throw new Error(`unrecorded worktree already exists for ${id} \u2014 refusing to proceed`);
+  if (recorded) {
+    cwd = recorded;
+    acquireWorktreeLock(cwd, id, lane);
+  } else if (choice?.reuse) {
+    cwd = choice.path;
+    const { setupRan } = await deps.prepareReuse(repo, cwd);
+    if (setupRan) console.log(`[runner] lockfile changed since setup last ran in ${cwd}: setup re-run`);
+    appendEvent(id, lane, {
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "runner",
+      data: { worktree: cwd, worktreeOf: choice.owner, setupRan }
+    });
+    fs17.writeFileSync(wtFile, JSON.stringify({ path: cwd, of: choice.owner }, null, 2));
   } else {
     cwd = await deps.allocate(repo, id);
-    fs12.writeFileSync(wtFile, JSON.stringify({ path: cwd }, null, 2));
-  }
+    acquireWorktreeLock(cwd, id, lane);
+    fs17.writeFileSync(wtFile, JSON.stringify({ path: cwd }, null, 2));
+  }
+  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,
+    checkpointOnStop: repo.checkpointOnStop ?? cfg.limits.checkpointOnStop
+  };
+  const remoteEnabled = Object.values(remotePolicy).some(Boolean);
+  const remote = keepRemote({
+    id,
+    lane,
+    cwd,
+    trunk: repo.trunk,
+    title: descriptor.brief.split("\n")[0]?.trim() || `Lobstah dispatch ${short3(id)}`,
+    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 = path10.resolve(path10.dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "bin");
-  const workerPath = fs12.existsSync(path10.join(binDir, "lobstah")) ? `${binDir}${path10.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 wallTimer = resolved.limits.wallClockSecs ? setTimeout(() => {
-    wallClockHit = true;
-    current?.kill();
-  }, resolved.limits.wallClockSecs * 1e3) : void 0;
+  const wallFile = path15.join(activeDir, "wallclock.json");
+  const wallState = (() => {
+    try {
+      return JSON.parse(fs17.readFileSync(wallFile, "utf8"));
+    } catch {
+      return { elapsedMs: 0, windowMs: resolved.limits.wallClockSecs * 1e3 };
+    }
+  })();
+  const head = () => {
+    try {
+      return execFileSync("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    } catch {
+      return void 0;
+    }
+  };
+  wallState.lastHead ??= head();
+  const maxWallMs = Math.max(
+    resolved.limits.wallClockSecs ?? 0,
+    cfg.limits.maxWallClockSecs ?? (resolved.limits.wallClockSecs ?? 0) * 4
+  ) * 1e3;
+  const persistWall = (elapsedMs, windowMs) => {
+    const tmp = `${wallFile}.tmp-${process.pid}`;
+    fs17.writeFileSync(tmp, JSON.stringify({ ...wallState, elapsedMs, windowMs }));
+    fs17.renameSync(tmp, wallFile);
+  };
+  const madeProgress = () => {
+    const activity = readActivity(id, lane);
+    const recent = activity && Date.now() - Date.parse(activity.at) <= cfg.limits.wedgeThresholdSecs * 1e3;
+    if (recent && activity.at !== wallState.lastProgressAt) {
+      wallState.lastProgressAt = activity.at;
+      wallState.lastHead = head();
+      return true;
+    }
+    const currentHead = head();
+    if (currentHead && currentHead !== wallState.lastHead) {
+      wallState.lastHead = currentHead;
+      return true;
+    }
+    return false;
+  };
+  const wallTimer = resolved.limits.wallClockSecs ? startWallClock({
+    limitMs: resolved.limits.wallClockSecs * 1e3,
+    maxMs: maxWallMs,
+    initialElapsedMs: wallState.elapsedMs,
+    initialWindowMs: wallState.windowMs,
+    paused: () => pausedWaiting(readStatusLog(id, lane).at(-1)),
+    progress: madeProgress,
+    onTick: persistWall,
+    onExpire: () => {
+      wallClockHit = true;
+      current?.kill();
+    }
+  }) : void 0;
+  if (wallTimer && wallState.elapsedMs >= maxWallMs) {
+    wallTimer.stop();
+    const saved = remoteEnabled ? await remote.saveBeforeStop() : void 0;
+    settle(id, lane, { cancelled: false, wallClockHit: true, budgetNote: saved });
+    releaseWorktreeLock(cwd, id);
+    complete(id, lane);
+    return;
+  }
   const runOnce = async (harness, prompt, resumeSession) => {
     const run2 = await deps.loadAdapter(harness).start({
       id,
@@ -2049,6 +3050,7 @@ async function main(activeDir, lane, deps = defaultDeps) {
     const { cancelled: cancelled2, activity } = await drive(run2, {
       id,
       lane,
+      cwd,
       stopped: () => wallClockHit,
       backgroundWaitMs: cfg.limits.backgroundWaitSecs * 1e3
     });
@@ -2081,10 +3083,18 @@ async function main(activeDir, lane, deps = defaultDeps) {
     );
     outcome = await runOnce(coldHarness, promptWith([envNudge, note].filter(Boolean).join("\n\n")), void 0);
   }
-  if (wallTimer) clearTimeout(wallTimer);
+  wallTimer?.stop();
   const { cancelled, result } = outcome;
+  const terminal = ["done", "failed"].includes(readStatusLog(id, lane).at(-1)?.verb ?? "");
+  let savedNote;
+  if (remoteEnabled && (wallClockHit || cancelled || !!result.error || !terminal)) {
+    savedNote = await remote.saveBeforeStop();
+    status("working", `work saved before stop: ${savedNote}`);
+  } else {
+    await remote.stop();
+  }
   try {
-    const gitEvidence = await deps.collectEvidence(repo, id);
+    const gitEvidence = await deps.collectEvidence(repo, cwd);
     console.log(`[runner] git evidence: ${JSON.stringify(gitEvidence)}`);
     mergeEvidence(id, lane, { ...gitEvidence, sessionId: result.sessionId ?? readEvidence(id, lane).sessionId });
     console.log(`[runner] evidence after merge: ${JSON.stringify(readEvidence(id, lane))}`);
@@ -2093,7 +3103,8 @@ async function main(activeDir, lane, deps = defaultDeps) {
       note: `evidence collection failed: ${err instanceof Error ? err.message : String(err)}`.slice(0, 300)
     });
   }
-  settle(id, lane, { cancelled, wallClockHit, error: result.error });
+  settle(id, lane, { cancelled, wallClockHit, error: result.error, budgetNote: savedNote });
+  releaseWorktreeLock(cwd, id);
   complete(id, lane);
 }
 
@@ -2101,10 +3112,10 @@ async function main(activeDir, lane, deps = defaultDeps) {
 function runRunner(activeDirArg2, laneArg2) {
   const lane = laneArg2 === "chore" ? "chore" : "work";
   main(activeDirArg2, lane).catch((err) => {
-    const id = path11.basename(activeDirArg2);
+    const id = path16.basename(activeDirArg2);
     try {
       appendStatus(id, lane, "failed", String(err instanceof Error ? err.message : err).slice(0, 500));
-      fs13.renameSync(activeDirArg2, path11.join(laneDirs(lane).done, id));
+      fs18.renameSync(activeDirArg2, path16.join(laneDirs(lane).done, id));
     } catch {
     }
     process.exitCode = 1;