lobstah 0.5.13 → 0.6.0

package/dist/runner.js

@@ -1,6 +1,6 @@
 // packages/runner/src/index.ts
-import * as fs18 from "node:fs";
-import * as path16 from "node:path";
+import * as fs20 from "node:fs";
+import * as path17 from "node:path";
 
 // packages/core/dist/types.js
 var VERBS = ["working", "needs-decision", "blocked", "paused", "done", "failed"];
@@ -11,6 +11,17 @@ var WAITING_ON_VERBS = ["paused", "needs-decision", "blocked"];
 // packages/core/dist/paths.js
 import * as os from "node:os";
 import * as path from "node:path";
+import * as fs from "node:fs";
+function readDirIfPresent(dir) {
+  try {
+    return fs.readdirSync(dir);
+  } catch (e) {
+    const code = e.code;
+    if (code === "ENOENT" || code === "ENOTDIR")
+      return [];
+    throw e;
+  }
+}
 function lobstahHome() {
   return process.env.LOBSTAH_HOME ?? path.join(os.homedir(), ".lobstah");
 }
@@ -54,615 +65,236 @@ function attachmentBlock(attachments) {
   ].join("\n");
 }
 
-// packages/core/dist/queue.js
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
+// packages/core/dist/decisions.js
+var DECISION_DETAIL_MAX = 64 * 1024;
+var ANSWER_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".csv": "text/csv",
+  ".json": "application/json",
+  ".log": "text/plain",
+  ".diff": "text/plain",
+  ".patch": "text/plain",
+  ".yaml": "text/plain",
+  ".yml": "text/plain",
+  ".toml": "text/plain",
+  ".zip": "application/zip"
+};
+var ANSWER_EXTENSIONS = Object.keys(ANSWER_TYPES);
 
-// packages/core/dist/status.js
+// packages/core/dist/config.js
 import * as fs2 from "node:fs";
-
-// packages/core/dist/activity.js
-import * as fs from "node:fs";
+import * as os2 from "node:os";
 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;
+
+// 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;
+var TomlDate = class _TomlDate extends Date {
+  #hasDate = false;
+  #hasTime = false;
+  #offset = null;
+  constructor(date) {
+    let hasDate = true;
+    let hasTime = true;
+    let offset = "Z";
+    if (typeof date === "string") {
+      let match = date.match(DATE_TIME_RE);
+      if (match) {
+        if (!match[1]) {
+          hasDate = false;
+          date = `0000-01-01T${date}`;
+        }
+        hasTime = !!match[2];
+        hasTime && date[10] === " " && (date = date.replace(" ", "T"));
+        if (match[2] && +match[2] > 23) {
+          date = "";
+        } else {
+          offset = match[3] || null;
+          date = date.toUpperCase();
+          if (!offset && hasTime)
+            date += "Z";
+        }
+      } else {
+        date = "";
+      }
+    }
+    super(date);
+    if (!isNaN(this.getTime())) {
+      this.#hasDate = hasDate;
+      this.#hasTime = hasTime;
+      this.#offset = offset;
+    }
   }
-  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;
+  isDateTime() {
+    return this.#hasDate && this.#hasTime;
   }
-}
-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;
+  isLocal() {
+    return !this.#hasDate || !this.#hasTime || !this.#offset;
   }
-  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;
+  isDate() {
+    return this.#hasDate && !this.#hasTime;
   }
-}
-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;
+  isTime() {
+    return this.#hasTime && !this.#hasDate;
   }
-}
-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;
+  isValid() {
+    return this.#hasDate || this.#hasTime;
   }
-  observe(ev) {
-    const derived = activityFromEvent(ev, this.opts.root);
-    if (derived)
-      this.offer({ at: new Date(this.now()).toISOString(), ...derived });
+  toISOString() {
+    let iso = super.toISOString();
+    if (this.isDate())
+      return iso.slice(0, 10);
+    if (this.isTime())
+      return iso.slice(11, 23);
+    if (this.#offset === null)
+      return iso.slice(0, -1);
+    if (this.#offset === "Z")
+      return iso;
+    let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+    offset = this.#offset[0] === "-" ? offset : -offset;
+    let offsetDate = new Date(this.getTime() - offset * 6e4);
+    return offsetDate.toISOString().slice(0, -1) + this.#offset;
   }
-  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?.();
-    }
+  static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+    let date = new _TomlDate(jsDate);
+    date.#offset = offset;
+    return date;
   }
-  /** Write a held record now. */
-  flush() {
-    if (!this.pending)
-      return;
-    const a = this.pending;
-    this.emit(a, this.now());
+  static wrapAsLocalDateTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#offset = null;
+    return date;
   }
-  stop() {
-    if (this.timer)
-      clearTimeout(this.timer);
-    this.timer = void 0;
-    this.pending = void 0;
+  static wrapAsLocalDate(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasTime = false;
+    date.#offset = null;
+    return date;
   }
-  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 {
-    }
+  static wrapAsLocalTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasDate = false;
+    date.#offset = null;
+    return date;
   }
 };
 
-// packages/core/dist/status.js
-function isVerb(v) {
-  return VERBS.includes(v);
-}
-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();
+// node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/error.js
+function getLineColFromPtr(string, ptr) {
+  let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
+  return [lines.length, lines.pop().length + 1];
 }
-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`);
+function makeCodeBlock(string, line, column) {
+  let lines = string.split(/\r\n|\n|\r/g);
+  let codeblock = "";
+  let numberLen = (Math.log10(line + 1) | 0) + 1;
+  for (let i = line - 1; i <= line + 1; i++) {
+    let l = lines[i - 1];
+    if (!l)
+      continue;
+    codeblock += i.toString().padEnd(numberLen, " ");
+    codeblock += ":  ";
+    codeblock += l;
+    codeblock += "\n";
+    if (i === line) {
+      codeblock += " ".repeat(numberLen + column + 2);
+      codeblock += "^\n";
     }
-    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 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 (!fs2.existsSync(file))
-    return [];
-  return fs2.readFileSync(file, "utf8").split("\n").filter(Boolean).flatMap((line) => {
-    try {
-      const parsed = JSON.parse(line);
-      return isVerb(parsed.verb) ? [parsed] : [];
-    } catch {
-      return [];
-    }
-  });
-}
-function pausedWaiting(entry) {
-  return entry?.verb === "paused" && entry.waitingOn !== void 0;
+  return codeblock;
 }
+var TomlError = class extends Error {
+  line;
+  column;
+  codeblock;
+  constructor(message, options) {
+    const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+    const codeblock = makeCodeBlock(options.toml, line, column);
+    super(`Invalid TOML document: ${message}
 
-// packages/core/dist/queue.js
-function storedDescriptor(id, lane) {
-  const dirs = laneDirs(lane);
-  for (const file of [
-    path3.join(dirs.queue, `${id}.json`),
-    path3.join(dirs.active, id, "descriptor.json"),
-    path3.join(dirs.done, id, "descriptor.json")
-  ]) {
-    try {
-      return JSON.parse(fs3.readFileSync(file, "utf8"));
-    } catch {
-    }
+${codeblock}`, options);
+    this.line = line;
+    this.column = column;
+    this.codeblock = codeblock;
   }
-  return void 0;
-}
-function activeIds(lane) {
-  return fs3.readdirSync(laneDirs(lane).active).filter((f) => !f.startsWith("."));
-}
-function complete(id, lane) {
-  const dirs = laneDirs(lane);
-  fs3.renameSync(path3.join(dirs.active, id), path3.join(dirs.done, id));
-}
-function cancelRequested(id, lane) {
-  return fs3.existsSync(path3.join(laneDirs(lane).active, id, "cancel"));
-}
+};
 
-// packages/core/dist/events.js
-import * as fs4 from "node:fs";
-function appendEvent(id, lane, ev) {
-  fs4.appendFileSync(eventsPath(id, lane), `${JSON.stringify(ev)}
-`);
-}
-function touchEvents(id, lane, at = /* @__PURE__ */ new Date()) {
-  const file = eventsPath(id, lane);
-  try {
-    fs4.utimesSync(file, at, at);
-  } catch {
-    fs4.appendFileSync(file, "");
-    fs4.utimesSync(file, at, at);
-  }
+// node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/util.js
+function indexOfNewline(str, start = 0) {
+  let idx = str.indexOf("\n", start);
+  if (str.charCodeAt(idx - 1) === 13)
+    idx--;
+  return idx;
 }
-
-// packages/core/dist/evidence.js
-import * as fs5 from "node:fs";
-function readEvidence(id, lane) {
-  try {
-    return JSON.parse(fs5.readFileSync(evidencePath(id, lane), "utf8"));
-  } catch {
-    return {};
+function skipComment(ctx) {
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    let c = ctx.s.charCodeAt(ctx.p);
+    if (c === 10)
+      break;
+    if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10) {
+      ctx.p++;
+      break;
+    }
+    if (c < 32 && c !== 9 || c === 127) {
+      throw new TomlError("control characters are not allowed in comments", {
+        toml: ctx.s,
+        ptr: ctx.p
+      });
+    }
   }
 }
-function mergeEvidence(id, lane, patch) {
-  const file = evidencePath(id, lane);
-  const tmp = `${file}.tmp-${process.pid}`;
-  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 skipVoid(ctx, banNewLines, banComments) {
+  let c;
+  while (1) {
+    while ((c = ctx.s.charCodeAt(ctx.p)) === 32 || c === 9 || !banNewLines && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10))
+      ctx.p++;
+    if (banComments || c !== 35)
+      break;
+    skipComment(ctx);
   }
 }
-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 skipUntil(ctx, sep, end) {
+  let ptr = ctx.p;
+  if (!end) {
+    ptr = indexOfNewline(ctx.s, ptr);
+    ctx.p = ptr < 0 ? ctx.s.length : ptr;
+    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;
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    let c = ctx.s.charCodeAt(ctx.p);
+    if (c === 35) {
+      skipComment(ctx);
+    } else if (c === end || c === sep) {
+      return;
+    }
   }
+  throw new TomlError("cannot find end of structure", {
+    toml: ctx.s,
+    ptr
+  });
 }
 
-// packages/core/dist/inbox.js
-var metaName = (file) => file.replace(/\.msg$/, ".meta.json");
-function inboxDir(id, lane) {
-  return path5.join(laneDirs(lane).inbox, id);
-}
-function unhandled(id, lane) {
-  const dir = inboxDir(id, lane);
-  if (!fs7.existsSync(dir))
-    return [];
-  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);
-  fs7.mkdirSync(path5.join(dir, "handled"), { recursive: true });
-  fs7.renameSync(path5.join(dir, file), path5.join(dir, "handled", file));
-  try {
-    fs7.renameSync(path5.join(dir, metaName(file)), path5.join(dir, "handled", metaName(file)));
-  } catch {
-  }
-}
-
-// packages/core/dist/config.js
-import * as fs8 from "node:fs";
-import * as os2 from "node:os";
-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;
-var TomlDate = class _TomlDate extends Date {
-  #hasDate = false;
-  #hasTime = false;
-  #offset = null;
-  constructor(date) {
-    let hasDate = true;
-    let hasTime = true;
-    let offset = "Z";
-    if (typeof date === "string") {
-      let match = date.match(DATE_TIME_RE);
-      if (match) {
-        if (!match[1]) {
-          hasDate = false;
-          date = `0000-01-01T${date}`;
-        }
-        hasTime = !!match[2];
-        hasTime && date[10] === " " && (date = date.replace(" ", "T"));
-        if (match[2] && +match[2] > 23) {
-          date = "";
-        } else {
-          offset = match[3] || null;
-          date = date.toUpperCase();
-          if (!offset && hasTime)
-            date += "Z";
-        }
-      } else {
-        date = "";
-      }
-    }
-    super(date);
-    if (!isNaN(this.getTime())) {
-      this.#hasDate = hasDate;
-      this.#hasTime = hasTime;
-      this.#offset = offset;
-    }
-  }
-  isDateTime() {
-    return this.#hasDate && this.#hasTime;
-  }
-  isLocal() {
-    return !this.#hasDate || !this.#hasTime || !this.#offset;
-  }
-  isDate() {
-    return this.#hasDate && !this.#hasTime;
-  }
-  isTime() {
-    return this.#hasTime && !this.#hasDate;
-  }
-  isValid() {
-    return this.#hasDate || this.#hasTime;
-  }
-  toISOString() {
-    let iso = super.toISOString();
-    if (this.isDate())
-      return iso.slice(0, 10);
-    if (this.isTime())
-      return iso.slice(11, 23);
-    if (this.#offset === null)
-      return iso.slice(0, -1);
-    if (this.#offset === "Z")
-      return iso;
-    let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
-    offset = this.#offset[0] === "-" ? offset : -offset;
-    let offsetDate = new Date(this.getTime() - offset * 6e4);
-    return offsetDate.toISOString().slice(0, -1) + this.#offset;
-  }
-  static wrapAsOffsetDateTime(jsDate, offset = "Z") {
-    let date = new _TomlDate(jsDate);
-    date.#offset = offset;
-    return date;
-  }
-  static wrapAsLocalDateTime(jsDate) {
-    let date = new _TomlDate(jsDate);
-    date.#offset = null;
-    return date;
-  }
-  static wrapAsLocalDate(jsDate) {
-    let date = new _TomlDate(jsDate);
-    date.#hasTime = false;
-    date.#offset = null;
-    return date;
-  }
-  static wrapAsLocalTime(jsDate) {
-    let date = new _TomlDate(jsDate);
-    date.#hasDate = false;
-    date.#offset = null;
-    return date;
-  }
-};
-
-// node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/error.js
-function getLineColFromPtr(string, ptr) {
-  let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
-  return [lines.length, lines.pop().length + 1];
-}
-function makeCodeBlock(string, line, column) {
-  let lines = string.split(/\r\n|\n|\r/g);
-  let codeblock = "";
-  let numberLen = (Math.log10(line + 1) | 0) + 1;
-  for (let i = line - 1; i <= line + 1; i++) {
-    let l = lines[i - 1];
-    if (!l)
-      continue;
-    codeblock += i.toString().padEnd(numberLen, " ");
-    codeblock += ":  ";
-    codeblock += l;
-    codeblock += "\n";
-    if (i === line) {
-      codeblock += " ".repeat(numberLen + column + 2);
-      codeblock += "^\n";
-    }
-  }
-  return codeblock;
-}
-var TomlError = class extends Error {
-  line;
-  column;
-  codeblock;
-  constructor(message, options) {
-    const [line, column] = getLineColFromPtr(options.toml, options.ptr);
-    const codeblock = makeCodeBlock(options.toml, line, column);
-    super(`Invalid TOML document: ${message}
-
-${codeblock}`, options);
-    this.line = line;
-    this.column = column;
-    this.codeblock = codeblock;
-  }
-};
-
-// node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/util.js
-function indexOfNewline(str, start = 0) {
-  let idx = str.indexOf("\n", start);
-  if (str.charCodeAt(idx - 1) === 13)
-    idx--;
-  return idx;
-}
-function skipComment(ctx) {
-  for (; ctx.p < ctx.s.length; ctx.p++) {
-    let c = ctx.s.charCodeAt(ctx.p);
-    if (c === 10)
-      break;
-    if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10) {
-      ctx.p++;
-      break;
-    }
-    if (c < 32 && c !== 9 || c === 127) {
-      throw new TomlError("control characters are not allowed in comments", {
-        toml: ctx.s,
-        ptr: ctx.p
-      });
-    }
-  }
-}
-function skipVoid(ctx, banNewLines, banComments) {
-  let c;
-  while (1) {
-    while ((c = ctx.s.charCodeAt(ctx.p)) === 32 || c === 9 || !banNewLines && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10))
-      ctx.p++;
-    if (banComments || c !== 35)
-      break;
-    skipComment(ctx);
-  }
-}
-function skipUntil(ctx, sep, end) {
-  let ptr = ctx.p;
-  if (!end) {
-    ptr = indexOfNewline(ctx.s, ptr);
-    ctx.p = ptr < 0 ? ctx.s.length : ptr;
-    return;
-  }
-  for (; ctx.p < ctx.s.length; ctx.p++) {
-    let c = ctx.s.charCodeAt(ctx.p);
-    if (c === 35) {
-      skipComment(ctx);
-    } else if (c === end || c === sep) {
-      return;
-    }
-  }
-  throw new TomlError("cannot find end of structure", {
-    toml: ctx.s,
-    ptr
-  });
-}
-
-// node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/primitive.js
-var INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
-var FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
-var LEADING_ZERO = /^[+-]?0[0-9_]/;
-function parseString(ctx) {
-  let start = ctx.p;
-  let c = ctx.s.charCodeAt(ctx.p++);
-  let first = c;
-  let isLiteral = c === 39;
-  let isMultiline = c === ctx.s.charCodeAt(ctx.p) && c === ctx.s.charCodeAt(ctx.p + 1);
-  if (isMultiline) {
-    if ((c = ctx.s.charCodeAt(ctx.p += 2)) === 10)
-      ctx.p++;
-    else if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)
-      ctx.p += 2;
+// node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/primitive.js
+var INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
+var FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
+var LEADING_ZERO = /^[+-]?0[0-9_]/;
+function parseString(ctx) {
+  let start = ctx.p;
+  let c = ctx.s.charCodeAt(ctx.p++);
+  let first = c;
+  let isLiteral = c === 39;
+  let isMultiline = c === ctx.s.charCodeAt(ctx.p) && c === ctx.s.charCodeAt(ctx.p + 1);
+  if (isMultiline) {
+    if ((c = ctx.s.charCodeAt(ctx.p += 2)) === 10)
+      ctx.p++;
+    else if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)
+      ctx.p += 2;
   }
   let parsed = "";
   let sliceStart = ctx.p;
@@ -1025,214 +657,892 @@ function peekTable(key, table, meta, type) {
       state.d = true;
       t[k] = [];
     }
-    t[k].push(t = {});
-    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: {} };
-  }
-  if (state.d) {
-    return null;
-  }
-  state.d = true;
-  if (type === 1) {
-    t = hasOwn ? t[k] : t[k] = {};
-  } else if (type === 0 && hasOwn) {
-    return null;
-  }
-  return [k, t, state.c];
-}
-function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
-  let ctx = { s: toml, p: 0, d: maxDepth };
-  let res = {};
-  let meta = {};
-  let tmp;
-  let tbl = res;
-  let m = meta;
-  skipVoid(ctx);
-  while (ctx.p < toml.length) {
-    if (toml.charCodeAt(ctx.p) === 91) {
-      let isTableArray = toml.charCodeAt(++ctx.p) === 91;
-      tmp = ctx.p += +isTableArray;
-      let k = parseKey(ctx, "]");
-      if (isTableArray) {
-        if (toml.charCodeAt(ctx.p - 1) !== 93) {
-          throw new TomlError("expected end of table declaration", {
-            toml,
-            ptr: ctx.p - 1
-          });
-        }
-        ctx.p++;
-      }
-      let p = peekTable(
-        k,
-        res,
-        meta,
-        isTableArray ? 2 : 1
-        /* Type.EXPLICIT */
-      );
-      if (!p) {
-        throw new TomlError("trying to redefine an already defined table or value", {
-          toml,
-          ptr: tmp
-        });
-      }
-      m = p[2];
-      tbl = p[1];
-    } else {
-      tmp = ctx.p;
-      let k = parseKey(ctx);
-      let p = peekTable(
-        k,
-        tbl,
-        m,
-        0
-        /* Type.DOTTED */
-      );
-      if (!p) {
-        throw new TomlError("trying to redefine an already defined table or value", {
-          toml,
-          ptr: tmp
-        });
-      }
-      p[1][p[0]] = extractValue(ctx, void 0, integersAsBigInt);
+    t[k].push(t = {});
+    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: {} };
+  }
+  if (state.d) {
+    return null;
+  }
+  state.d = true;
+  if (type === 1) {
+    t = hasOwn ? t[k] : t[k] = {};
+  } else if (type === 0 && hasOwn) {
+    return null;
+  }
+  return [k, t, state.c];
+}
+function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
+  let ctx = { s: toml, p: 0, d: maxDepth };
+  let res = {};
+  let meta = {};
+  let tmp;
+  let tbl = res;
+  let m = meta;
+  skipVoid(ctx);
+  while (ctx.p < toml.length) {
+    if (toml.charCodeAt(ctx.p) === 91) {
+      let isTableArray = toml.charCodeAt(++ctx.p) === 91;
+      tmp = ctx.p += +isTableArray;
+      let k = parseKey(ctx, "]");
+      if (isTableArray) {
+        if (toml.charCodeAt(ctx.p - 1) !== 93) {
+          throw new TomlError("expected end of table declaration", {
+            toml,
+            ptr: ctx.p - 1
+          });
+        }
+        ctx.p++;
+      }
+      let p = peekTable(
+        k,
+        res,
+        meta,
+        isTableArray ? 2 : 1
+        /* Type.EXPLICIT */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr: tmp
+        });
+      }
+      m = p[2];
+      tbl = p[1];
+    } else {
+      tmp = ctx.p;
+      let k = parseKey(ctx);
+      let p = peekTable(
+        k,
+        tbl,
+        m,
+        0
+        /* Type.DOTTED */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr: tmp
+        });
+      }
+      p[1][p[0]] = extractValue(ctx, void 0, integersAsBigInt);
+    }
+    skipVoid(ctx, true);
+    if (ctx.p < toml.length && (tmp = toml.charCodeAt(ctx.p)) !== 10 && tmp !== 13) {
+      throw new TomlError("each key-value declaration must be followed by an end-of-line", {
+        toml,
+        ptr: ctx.p
+      });
+    }
+    skipVoid(ctx);
+  }
+  return res;
+}
+
+// packages/core/dist/config.js
+var ATTENTION_KINDS = ["question", "decision", "landed", "pr:draft", "pr:review", "pr:checks", "pr:conflict", "pr:ready", "report"];
+var DEFAULT_ATTENTION_KINDS = ["question", "decision", "pr:ready", "pr:review", "pr:conflict", "pr:checks"];
+function parseAttentionKinds(raw) {
+  if (raw === void 0)
+    return [...DEFAULT_ATTENTION_KINDS];
+  if (!Array.isArray(raw)) {
+    throw new Error(`attentionKinds must be an array of kinds (${ATTENTION_KINDS.join(", ")}) in ${configPath()}`);
+  }
+  for (const k of raw) {
+    if (!ATTENTION_KINDS.includes(k)) {
+      throw new Error(`attentionKinds: unknown kind "${String(k)}" in ${configPath()} \u2014 valid kinds: ${ATTENTION_KINDS.join(", ")}`);
+    }
+  }
+  return [...new Set(raw)];
+}
+var DEFAULT_SOAK = {
+  deferSecs: 90,
+  ttlSecs: 1800,
+  beat: true,
+  pausedTtlSecs: 86400
+};
+var DEFAULT_HELM = {
+  ttlSecs: 1800,
+  reportSecs: 900,
+  armGraceSecs: 5
+};
+var DEFAULT_GLASS = { port: 4949 };
+var DEFAULT_WATCH = { maxForksPerCycle: 3, autoRepair: true, conflicts: true, checks: true, maxRepairsPerPr: 2, repairSettleSecs: 600, repairTrapWaitSecs: 600 };
+var DEFAULT_LIMITS = {
+  maxConcurrent: 2,
+  choreConcurrent: 1,
+  wedgeThresholdSecs: 600,
+  maxRestartAttempts: 2,
+  wallClockSecs: 3600,
+  pushEarly: true,
+  draftPr: true,
+  checkpointOnStop: true,
+  backgroundWaitSecs: 1800,
+  exitGraceSecs: 30,
+  choreRetentionDays: 7,
+  attachmentMaxBytes: 25 * 1024 * 1024,
+  retentionDays: 0,
+  minFreeGB: 0,
+  reuseWorktree: true,
+  releaseOnMerge: false
+};
+function configPath() {
+  return path2.join(lobstahHome(), "config.toml");
+}
+function expandHome(p) {
+  return p.startsWith("~/") ? path2.join(os2.homedir(), p.slice(2)) : p;
+}
+function loadConfig() {
+  const file = configPath();
+  const raw = fs2.existsSync(file) ? parse(fs2.readFileSync(file, "utf8")) : {};
+  const reposRaw = raw.repos ?? {};
+  const repos = {};
+  for (const [key, r] of Object.entries(reposRaw)) {
+    repos[key] = {
+      path: expandHome(String(r.path ?? "")),
+      origin: r.origin ? String(r.origin) : void 0,
+      trunk: String(r.trunk ?? "main"),
+      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),
+      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),
+      humanGateChecks: Array.isArray(r.humanGateChecks) ? r.humanGateChecks.map(String).filter(Boolean) : void 0
+    };
+  }
+  const groundsRaw = raw.grounds ?? {};
+  const grounds = {};
+  for (const [key, g] of Object.entries(groundsRaw)) {
+    grounds[key] = { repos: Array.isArray(g.repos) ? g.repos.map(String) : [] };
+  }
+  return {
+    repos,
+    harness: raw.harness ?? {},
+    limits: { ...DEFAULT_LIMITS, ...raw.limits ?? {} },
+    soak: { ...DEFAULT_SOAK, ...raw.soak ?? {} },
+    helm: { ...DEFAULT_HELM, ...raw.helm ?? {} },
+    glass: { ...DEFAULT_GLASS, ...raw.glass ?? {} },
+    watch: { ...DEFAULT_WATCH, ...raw.watch ?? {} },
+    grounds,
+    notifyCommand: raw.notifyCommand ? String(raw.notifyCommand) : void 0,
+    notifyVerbs: Array.isArray(raw.notifyVerbs) ? raw.notifyVerbs.map(String) : void 0,
+    remindSecs: raw.remindSecs !== void 0 ? Number(raw.remindSecs) : void 0,
+    attentionKinds: parseAttentionKinds(raw.attentionKinds)
+  };
+}
+function resolveDispatch(d, cfg) {
+  const repo = cfg.repos[d.repo];
+  if (!repo)
+    throw new Error(`unknown repo key "${d.repo}" \u2014 add it to ${configPath()}`);
+  const rh = repo.harness ?? {};
+  const gh = cfg.harness;
+  return {
+    harness: d.harness ?? rh.default ?? gh.default ?? "claude",
+    model: d.model ?? rh.model ?? gh.model,
+    effort: d.effort ?? rh.effort ?? gh.effort,
+    limits: {
+      wallClockSecs: cfg.limits.wallClockSecs,
+      ...d.limits ?? {}
+    },
+    env: { ...repo.env ?? {}, ...d.env ?? {} },
+    flags: d.flags ?? []
+  };
+}
+
+// packages/core/dist/disk.js
+var GB = 1024 ** 3;
+
+// packages/core/dist/watch.js
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+function watchesDir() {
+  return path3.join(lobstahHome(), "watches");
+}
+function slug(key) {
+  return key.replace(/[^A-Za-z0-9._-]+/g, "-");
+}
+function watchPath(key) {
+  return path3.join(watchesDir(), `${slug(key)}.json`);
+}
+function readWatch(key) {
+  try {
+    return JSON.parse(fs3.readFileSync(watchPath(key), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+
+// packages/core/dist/inbox.js
+import * as fs11 from "node:fs";
+import * as path9 from "node:path";
+
+// packages/core/dist/soak.js
+import * as fs10 from "node:fs";
+import * as path8 from "node:path";
+
+// packages/core/dist/queue.js
+import * as fs6 from "node:fs";
+import * as path5 from "node:path";
+
+// packages/core/dist/status.js
+import * as fs5 from "node:fs";
+
+// packages/core/dist/activity.js
+import * as fs4 from "node:fs";
+import * as path4 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 words2 = command.trim().split(/\s+/).filter(Boolean);
+  while (words2.length > 0 && /^[A-Za-z_][A-Za-z0-9_]*=/.test(words2[0]))
+    words2 = words2.slice(1);
+  if (words2[0] === "env") {
+    words2 = words2.slice(1);
+    while (words2.length > 0 && (/^[A-Za-z_][A-Za-z0-9_]*=/.test(words2[0]) || words2[0].startsWith("-")))
+      words2 = words2.slice(1);
+  }
+  const first = words2[0];
+  if (!first)
+    return void 0;
+  const name = baseName(first.replace(/^["']|["']$/g, "")).replace(/\.(exe|cmd|bat)$/i, "");
+  if (SHELLS.has(name.toLowerCase()) && words2[1] && /^(-\w*c|\/c|-command)$/i.test(words2[1])) {
+    return commandWord(words2.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 ? path4.win32 : path4.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}`;
+  fs4.writeFileSync(tmp, content);
+  fs4.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(fs4.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
+function isVerb(v) {
+  return VERBS.includes(v);
+}
+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, reported = false) {
+  if (!isVerb(verb)) {
+    throw new Error(`invalid status verb "${verb}" \u2014 must be one of: ${VERBS.join(", ")}`);
+  }
+  const extra = waiting ? waitingFields(verb, waiting) : {};
+  const entry = {
+    at: at ?? (/* @__PURE__ */ new Date()).toISOString(),
+    verb,
+    ...note ? { note } : {},
+    ...extra,
+    ...reported ? { reported: true } : {}
+  };
+  fs5.appendFileSync(statusPath(id, lane), `${JSON.stringify(entry)}
+`);
+  return entry;
+}
+function readStatusLog(id, lane) {
+  const file = statusPath(id, lane);
+  if (!fs5.existsSync(file))
+    return [];
+  return fs5.readFileSync(file, "utf8").split("\n").filter(Boolean).flatMap((line) => {
+    try {
+      const parsed = JSON.parse(line);
+      return isVerb(parsed.verb) ? [parsed] : [];
+    } catch {
+      return [];
+    }
+  });
+}
+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 [
+    path5.join(dirs.queue, `${id}.json`),
+    path5.join(dirs.active, id, "descriptor.json"),
+    path5.join(dirs.done, id, "descriptor.json")
+  ]) {
+    try {
+      return JSON.parse(fs6.readFileSync(file, "utf8"));
+    } catch {
+    }
+  }
+  return void 0;
+}
+function activeIds(lane) {
+  return readDirIfPresent(laneDirs(lane).active).filter((f) => !f.startsWith("."));
+}
+function complete(id, lane) {
+  const dirs = laneDirs(lane);
+  fs6.renameSync(path5.join(dirs.active, id), path5.join(dirs.done, id));
+}
+function cancelRequested(id, lane) {
+  return fs6.existsSync(path5.join(laneDirs(lane).active, id, "cancel"));
+}
+
+// packages/core/dist/evidence.js
+import * as fs7 from "node:fs";
+function readEvidence(id, lane) {
+  try {
+    return JSON.parse(fs7.readFileSync(evidencePath(id, lane), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function mergeEvidence(id, lane, patch) {
+  const file = evidencePath(id, lane);
+  const tmp = `${file}.tmp-${process.pid}`;
+  fs7.writeFileSync(tmp, JSON.stringify({ ...readEvidence(id, lane), ...patch }, null, 2));
+  fs7.renameSync(tmp, file);
+}
+
+// packages/core/dist/pushes.js
+import * as fs8 from "node:fs";
+import * as path6 from "node:path";
+var MAX_PUSHES = 20;
+var PUSH_HEAD = "HEAD";
+var VALUE_OPTIONS = /* @__PURE__ */ new Set(["-o", "--push-option", "--repo", "--receive-pack", "--exec"]);
+function words(segment) {
+  const out = [];
+  const re = /"((?:[^"\\]|\\.)*)"|'([^']*)'|(\S+)/g;
+  for (let m = re.exec(segment); m; m = re.exec(segment))
+    out.push(m[1] ?? m[2] ?? m[3] ?? "");
+  return out;
+}
+function branchOf(ref) {
+  const name = ref.replace(/^\+/, "").replace(/^refs\/heads\//, "");
+  return name === "@" || name === "" ? PUSH_HEAD : name;
+}
+function gitPushTargets(command) {
+  if (command === void 0)
+    return void 0;
+  const text = typeof command === "string" ? command : command.join(" ");
+  if (!/\bgit\b[^\n]*\bpush\b/.test(text))
+    return void 0;
+  const targets = [];
+  let found = false;
+  for (const segment of text.split(/&&|\|\||[;|\n]/)) {
+    const w = words(segment);
+    let i = w.findIndex((x) => x === "git" || /[\\/]git(?:\.exe)?$/.test(x));
+    if (i < 0)
+      continue;
+    for (i++; i < w.length && w[i].startsWith("-"); i++)
+      if (w[i] === "-C" || w[i] === "-c")
+        i++;
+    if (w[i] !== "push")
+      continue;
+    found = true;
+    const positional = [];
+    for (let j = i + 1; j < w.length; j++) {
+      const arg = w[j];
+      if (arg === "--")
+        continue;
+      if (arg.startsWith("-")) {
+        if (VALUE_OPTIONS.has(arg))
+          j++;
+        continue;
+      }
+      positional.push(arg);
+    }
+    const refspecs = positional.slice(1);
+    if (refspecs.length === 0)
+      targets.push(PUSH_HEAD);
+    for (const spec of refspecs)
+      targets.push(branchOf(spec.includes(":") ? spec.slice(spec.indexOf(":") + 1) : spec));
+  }
+  return found ? [...new Set(targets)] : void 0;
+}
+function gitDirAt(dir) {
+  let at = path6.resolve(dir);
+  for (; ; ) {
+    const dotGit = path6.join(at, ".git");
+    try {
+      const stat = fs8.statSync(dotGit);
+      if (stat.isDirectory())
+        return dotGit;
+      const m = /^gitdir:\s*(.+)$/m.exec(fs8.readFileSync(dotGit, "utf8"));
+      return m ? path6.resolve(at, m[1].trim()) : void 0;
+    } catch {
+    }
+    const up = path6.dirname(at);
+    if (up === at)
+      return void 0;
+    at = up;
+  }
+}
+function currentBranchAt(dir) {
+  const gitDir = gitDirAt(dir);
+  if (!gitDir)
+    return void 0;
+  try {
+    const m = /^ref:\s*refs\/heads\/(.+)$/m.exec(fs8.readFileSync(path6.join(gitDir, "HEAD"), "utf8"));
+    return m ? m[1].trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolvePushTargets(targets, cwd) {
+  const head = cwd ? currentBranchAt(cwd) : void 0;
+  return [...new Set(targets.flatMap((t) => t === PUSH_HEAD ? head ? [head] : [] : [t]))];
+}
+function recordPush(id, lane, branches, at = (/* @__PURE__ */ new Date()).toISOString()) {
+  if (branches.length === 0)
+    return;
+  const kept = (readEvidence(id, lane).pushes ?? []).filter((p) => !branches.includes(p.branch));
+  const pushes = [...kept, ...branches.map((branch) => ({ branch, at }))].slice(-MAX_PUSHES);
+  mergeEvidence(id, lane, { pushes });
+}
+
+// packages/core/dist/worktrees.js
+import * as fs9 from "node:fs";
+import * as path7 from "node:path";
+var LANES = ["work", "chore"];
+function worktreePath(id) {
+  return path7.join(lobstahHome(), "worktrees", id);
+}
+function readRecord(file) {
+  try {
+    const r = JSON.parse(fs9.readFileSync(file, "utf8"));
+    return typeof r.path === "string" ? r : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function ownerOfPath(p) {
+  const rel = path7.relative(path7.join(lobstahHome(), "worktrees"), p);
+  if (!rel || rel.startsWith("..") || path7.isAbsolute(rel))
+    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(path7.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 laneOf(id) {
+  for (const l of LANES) {
+    const d = laneDirs(l);
+    if (fs9.existsSync(path7.join(d.queue, `${id}.json`)) || fs9.existsSync(path7.join(d.active, id)) || fs9.existsSync(path7.join(d.done, id))) {
+      return l;
+    }
+  }
+  return void 0;
+}
+function followUpAncestors(id, lane) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set([id]);
+  let cur = storedDescriptor(id, lane ?? laneOf(id) ?? "work")?.followUp;
+  while (cur && !seen.has(cur)) {
+    out.push(cur);
+    seen.add(cur);
+    cur = storedDescriptor(cur, laneOf(cur) ?? lane ?? "work")?.followUp;
+  }
+  return out;
+}
+function chainWorktree(followUp) {
+  for (const id of [followUp, ...followUpAncestors(followUp)]) {
+    const wt = dispatchWorktree(id, laneOf(id));
+    if (fs9.existsSync(wt.path))
+      return { ...wt, from: id };
+  }
+  return void 0;
+}
+function worktreeGitDir(wt) {
+  const dotGit = path7.join(wt, ".git");
+  try {
+    const st = fs9.statSync(dotGit);
+    if (st.isDirectory())
+      return dotGit;
+    const m = /^gitdir:\s*(.+?)\s*$/m.exec(fs9.readFileSync(dotGit, "utf8"));
+    return m ? path7.resolve(wt, m[1]) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function worktreeLockFile(wt) {
+  const gitDir = worktreeGitDir(wt);
+  return gitDir ? path7.join(gitDir, "lobstah.lock") : void 0;
+}
+function readWorktreeLock(wt) {
+  const file = worktreeLockFile(wt);
+  if (!file)
+    return void 0;
+  try {
+    return JSON.parse(fs9.readFileSync(file, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function lockIsLive(lock) {
+  return fs9.existsSync(path7.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 {
+      fs9.writeFileSync(file, JSON.stringify(mine, null, 2), { flag: "wx" });
+      return void 0;
+    } catch (err) {
+      if (err.code !== "EEXIST")
+        throw err;
+    }
+    let raw;
+    try {
+      raw = fs9.readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    let held2;
+    try {
+      held2 = JSON.parse(raw);
+    } catch {
+      held2 = void 0;
+    }
+    if (held2?.id === id) {
+      fs9.writeFileSync(file, JSON.stringify(mine, null, 2));
+      return void 0;
     }
-    skipVoid(ctx, true);
-    if (ctx.p < toml.length && (tmp = toml.charCodeAt(ctx.p)) !== 10 && tmp !== 13) {
-      throw new TomlError("each key-value declaration must be followed by an end-of-line", {
-        toml,
-        ptr: ctx.p
-      });
+    if (held2 && lockIsLive(held2))
+      return held2;
+    try {
+      if (fs9.readFileSync(file, "utf8") === raw)
+        fs9.rmSync(file, { force: true });
+    } catch {
     }
-    skipVoid(ctx);
   }
-  return res;
+  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)
+    fs9.rmSync(file, { force: true });
 }
 
-// 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:ready", "pr:review", "pr:conflict", "pr:checks"];
-function parseAttentionKinds(raw) {
-  if (raw === void 0)
-    return [...DEFAULT_ATTENTION_KINDS];
-  if (!Array.isArray(raw)) {
-    throw new Error(`attentionKinds must be an array of kinds (${ATTENTION_KINDS.join(", ")}) in ${configPath()}`);
-  }
-  for (const k of raw) {
-    if (!ATTENTION_KINDS.includes(k)) {
-      throw new Error(`attentionKinds: unknown kind "${String(k)}" in ${configPath()} \u2014 valid kinds: ${ATTENTION_KINDS.join(", ")}`);
-    }
+// packages/core/dist/soak.js
+function regPath(trapId) {
+  return path8.join(soakingDir(), `${trapId}.json`);
+}
+function readTrap(trapId) {
+  try {
+    return JSON.parse(fs10.readFileSync(regPath(trapId), "utf8"));
+  } catch {
+    return void 0;
   }
-  return [...new Set(raw)];
 }
-var DEFAULT_SOAK = {
-  deferSecs: 90,
-  ttlSecs: 1800,
-  beat: true,
-  pausedTtlSecs: 86400
-};
-var DEFAULT_HELM = {
-  ttlSecs: 1800,
-  reportSecs: 900,
-  armGraceSecs: 5
-};
-var DEFAULT_GLASS = { port: 4949 };
-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,
-  reuseWorktree: true,
-  releaseOnMerge: false
-};
-function configPath() {
-  return path6.join(lobstahHome(), "config.toml");
+function listTraps() {
+  try {
+    return fs10.readdirSync(soakingDir()).filter((f) => f.endsWith(".json")).map((f) => JSON.parse(fs10.readFileSync(path8.join(soakingDir(), f), "utf8"))).filter((r) => typeof r.trapId === "string");
+  } catch {
+    return [];
+  }
 }
-function expandHome(p) {
-  return p.startsWith("~/") ? path6.join(os2.homedir(), p.slice(2)) : p;
+function claimPath(id, lane) {
+  return path8.join(laneDirs(lane).active, id, "claim.json");
 }
-function loadConfig() {
-  const file = configPath();
-  const raw = fs8.existsSync(file) ? parse(fs8.readFileSync(file, "utf8")) : {};
-  const reposRaw = raw.repos ?? {};
-  const repos = {};
-  for (const [key, r] of Object.entries(reposRaw)) {
-    repos[key] = {
-      path: expandHome(String(r.path ?? "")),
-      origin: r.origin ? String(r.origin) : void 0,
-      trunk: String(r.trunk ?? "main"),
-      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),
-      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)
-    };
+function readSessionClaim(id, lane) {
+  try {
+    return JSON.parse(fs10.readFileSync(claimPath(id, lane), "utf8"));
+  } catch {
+    return void 0;
   }
-  const groundsRaw = raw.grounds ?? {};
-  const grounds = {};
-  for (const [key, g] of Object.entries(groundsRaw)) {
-    grounds[key] = { repos: Array.isArray(g.repos) ? g.repos.map(String) : [] };
+}
+
+// packages/core/dist/inbox.js
+var metaName = (file) => file.replace(/\.msg$/, ".meta.json");
+function inboxDir(id, lane) {
+  return path9.join(laneDirs(lane).inbox, id);
+}
+function unhandled(id, lane) {
+  const dir = inboxDir(id, lane);
+  return readDirIfPresent(dir).filter((f) => f.endsWith(".msg")).sort().map((f) => ({ file: f, text: fs11.readFileSync(path9.join(dir, f), "utf8") }));
+}
+function acknowledge(id, lane, file) {
+  const dir = inboxDir(id, lane);
+  fs11.mkdirSync(path9.join(dir, "handled"), { recursive: true });
+  fs11.renameSync(path9.join(dir, file), path9.join(dir, "handled", file));
+  try {
+    fs11.renameSync(path9.join(dir, metaName(file)), path9.join(dir, "handled", metaName(file)));
+  } catch {
   }
-  return {
-    repos,
-    harness: raw.harness ?? {},
-    limits: { ...DEFAULT_LIMITS, ...raw.limits ?? {} },
-    soak: { ...DEFAULT_SOAK, ...raw.soak ?? {} },
-    helm: { ...DEFAULT_HELM, ...raw.helm ?? {} },
-    glass: { ...DEFAULT_GLASS, ...raw.glass ?? {} },
-    watch: { ...DEFAULT_WATCH, ...raw.watch ?? {} },
-    grounds,
-    notifyCommand: raw.notifyCommand ? String(raw.notifyCommand) : void 0,
-    notifyVerbs: Array.isArray(raw.notifyVerbs) ? raw.notifyVerbs.map(String) : void 0,
-    remindSecs: raw.remindSecs !== void 0 ? Number(raw.remindSecs) : void 0,
-    attentionKinds: parseAttentionKinds(raw.attentionKinds)
-  };
 }
-function resolveDispatch(d, cfg) {
-  const repo = cfg.repos[d.repo];
-  if (!repo)
-    throw new Error(`unknown repo key "${d.repo}" \u2014 add it to ${configPath()}`);
-  const rh = repo.harness ?? {};
-  const gh = cfg.harness;
-  return {
-    harness: d.harness ?? rh.default ?? gh.default ?? "claude",
-    model: d.model ?? rh.model ?? gh.model,
-    effort: d.effort ?? rh.effort ?? gh.effort,
-    limits: {
-      wallClockSecs: cfg.limits.wallClockSecs,
-      ...d.limits ?? {}
-    },
-    env: { ...repo.env ?? {}, ...d.env ?? {} },
-    flags: d.flags ?? []
-  };
+
+// packages/core/dist/events.js
+import * as fs12 from "node:fs";
+function appendEvent(id, lane, ev) {
+  fs12.appendFileSync(eventsPath(id, lane), `${JSON.stringify(ev)}
+`);
+}
+function touchEvents(id, lane, at = /* @__PURE__ */ new Date()) {
+  const file = eventsPath(id, lane);
+  try {
+    fs12.utimesSync(file, at, at);
+  } catch {
+    fs12.appendFileSync(file, "");
+    fs12.utimesSync(file, at, at);
+  }
 }
 
 // packages/core/dist/harness.js
-import * as fs9 from "node:fs";
-import * as path7 from "node:path";
+import * as fs13 from "node:fs";
+import * as path10 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(path7.delimiter)) {
+  for (const dir of pathVar.split(path10.delimiter)) {
     if (!dir)
       continue;
     for (const name of names) {
-      const candidate = path7.join(dir, name);
+      const candidate = path10.join(dir, name);
       try {
-        fs9.accessSync(candidate, fs9.constants.X_OK);
-        if (fs9.statSync(candidate).isFile())
+        fs13.accessSync(candidate, fs13.constants.X_OK);
+        if (fs13.statSync(candidate).isFile())
           return candidate;
       } catch {
       }
@@ -1241,48 +1551,25 @@ function resolveOnPath(bin, pathVar = process.env.PATH) {
   return void 0;
 }
 function onPath(bin, pathVar = process.env.PATH) {
-  return resolveOnPath(bin, pathVar) !== void 0;
-}
-function codexInvocation(argv) {
-  if (onPath("codex"))
-    return { file: "codex", argv };
-  const require_ = createRequire(import.meta.url);
-  try {
-    const cli = require_.resolve("@openai/codex/bin/codex.js");
-    return { file: process.execPath, argv: [cli, ...argv] };
-  } catch {
-  }
-  for (const dir of require_.resolve.paths("@openai/codex") ?? []) {
-    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/watch.js
-import * as fs10 from "node:fs";
-import * as path8 from "node:path";
-function watchesDir() {
-  return path8.join(lobstahHome(), "watches");
-}
-function slug(key) {
-  return key.replace(/[^A-Za-z0-9._-]+/g, "-");
-}
-function watchPath(key) {
-  return path8.join(watchesDir(), `${slug(key)}.json`);
+  return resolveOnPath(bin, pathVar) !== void 0;
 }
-function readWatch(key) {
+function codexInvocation(argv) {
+  if (onPath("codex"))
+    return { file: "codex", argv };
+  const require_ = createRequire(import.meta.url);
   try {
-    return JSON.parse(fs10.readFileSync(watchPath(key), "utf8"));
+    const cli = require_.resolve("@openai/codex/bin/codex.js");
+    return { file: process.execPath, argv: [cli, ...argv] };
   } catch {
-    return void 0;
   }
+  for (const dir of require_.resolve.paths("@openai/codex") ?? []) {
+    const cli = path10.join(dir, "@openai", "codex", "bin", "codex.js");
+    if (fs13.existsSync(cli))
+      return { file: process.execPath, argv: [cli, ...argv] };
+  }
+  return void 0;
 }
 
-// packages/core/dist/disk.js
-var GB = 1024 ** 3;
-
 // packages/core/dist/compiled.js
 var COMPILED_BINARY = (() => {
   const bun = globalThis.Bun;
@@ -1298,25 +1585,25 @@ function parsePrRef(s) {
   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 = "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(",");
 
 // packages/core/dist/prs.js
-import * as fs11 from "node:fs";
-import * as path9 from "node:path";
+import * as fs14 from "node:fs";
+import * as path11 from "node:path";
 function prsDir() {
-  return path9.join(lobstahHome(), "prs");
+  return path11.join(lobstahHome(), "prs");
 }
 function readPrs() {
   let files;
   try {
-    files = fs11.readdirSync(prsDir()).filter((f) => f.endsWith(".json"));
+    files = fs14.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"));
+      const r = JSON.parse(fs14.readFileSync(path11.join(prsDir(), f), "utf8"));
       return typeof r.key === "string" && typeof r.url === "string" ? [r] : [];
     } catch {
       return [];
@@ -1332,11 +1619,11 @@ function chainPr(id, lane) {
   while (at && !seen.has(at)) {
     ancestry.push(at);
     seen.add(at);
-    at = storedDescriptor(at, lane)?.followUp;
+    at = storedDescriptor(at, laneOf(at) ?? lane)?.followUp;
   }
   const records = readPrs();
   for (const member of ancestry.reverse()) {
-    const evidence = readEvidence(member, lane);
+    const evidence = readEvidence(member, laneOf(member) ?? lane);
     const url = evidence.prUrl ?? evidence.pr?.url;
     const ref = url && parsePrRef(url);
     if (ref) {
@@ -1350,10 +1637,24 @@ function chainPr(id, lane) {
   return void 0;
 }
 
+// packages/core/dist/pr-repair.js
+var PUSH_RETRIES = 3;
+var PUSH_REJECTED = "push rejected:";
+function pushRule(branch, id = "<dispatch id>") {
+  const b = branch ?? "the PR's head branch";
+  return [
+    `Push only to the existing branch ${b}.`,
+    `If the push is rejected as non-fast-forward because ${b} moved, fetch ${b}, rebase your commits onto the moved head again, and push with \`--force-with-lease=${b}:<the head you just fetched>\`. Retry at most ${PUSH_RETRIES} times.`,
+    "If a push hook fails with a real test or type error, do not retry the push: fix the error, commit, and push again.",
+    `If you still cannot push, report \`lobstah report ${id} failed "${PUSH_REJECTED} <rejection text>; moved head <full sha of the head you fetched>"\` and leave the PR as it was.`,
+    "Never push to another branch. Never open a new PR."
+  ].join(" ");
+}
+
 // packages/core/dist/resume.js
-import * as fs12 from "node:fs";
+import * as fs15 from "node:fs";
 import * as os3 from "node:os";
-import * as path10 from "node:path";
+import * as path12 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) {
@@ -1364,13 +1665,13 @@ function claimOf(id, lane) {
   const dirs = laneDirs(lane);
   for (const dir of [dirs.active, dirs.done]) {
     try {
-      return JSON.parse(fs12.readFileSync(path10.join(dir, id, "claim.json"), "utf8"));
+      return JSON.parse(fs15.readFileSync(path12.join(dir, id, "claim.json"), "utf8"));
     } catch {
     }
   }
   return void 0;
 }
-function laneOf(id) {
+function laneOf2(id) {
   for (const lane of ["work", "chore"]) {
     if (storedDescriptor(id, lane) || readEvidence(id, lane).sessionId)
       return lane;
@@ -1378,7 +1679,7 @@ function laneOf(id) {
   return void 0;
 }
 function resolveSessionHarness(id, cfg, laneHint) {
-  const lane = laneHint ?? laneOf(id);
+  const lane = laneHint ?? laneOf2(id);
   if (!lane)
     return {};
   const ev = readEvidence(id, lane);
@@ -1414,7 +1715,7 @@ function isUnresumable(error) {
   return error !== void 0 && UNRESUMABLE.test(error);
 }
 function worktreeProgress(worktree, trunk) {
-  if (!worktree || !fs12.existsSync(worktree))
+  if (!worktree || !fs15.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");
@@ -1447,31 +1748,31 @@ function handoffNote(fromHarness, progress, why) {
 ${progress}`;
 }
 function codexHome(env = process.env) {
-  return env.CODEX_HOME ?? path10.join(os3.homedir(), ".codex");
+  return env.CODEX_HOME ?? path12.join(os3.homedir(), ".codex");
 }
 function codexRolloutFile(threadId, home = codexHome()) {
   const suffix = `-${threadId}.jsonl`;
   const walk = (dir, depth) => {
     let entries;
     try {
-      entries = fs12.readdirSync(dir, { withFileTypes: true });
+      entries = fs15.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 path10.join(dir, e.name);
+        return path12.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(path10.join(dir, e.name), depth - 1);
+      const hit = walk(path12.join(dir, e.name), depth - 1);
       if (hit)
         return hit;
     }
     return void 0;
   };
-  return walk(path10.join(home, "sessions"), 3) ?? walk(path10.join(home, "archived_sessions"), 0);
+  return walk(path12.join(home, "sessions"), 3) ?? walk(path12.join(home, "archived_sessions"), 0);
 }
 function codexDesktopThread(threadId, home = codexHome()) {
   const file = codexRolloutFile(threadId, home);
@@ -1479,12 +1780,12 @@ function codexDesktopThread(threadId, home = codexHome()) {
     return void 0;
   let head = "";
   try {
-    const fd = fs12.openSync(file, "r");
+    const fd = fs15.openSync(file, "r");
     try {
       const buf = Buffer.alloc(4096);
-      head = buf.subarray(0, fs12.readSync(fd, buf, 0, buf.length, 0)).toString("utf8");
+      head = buf.subarray(0, fs15.readSync(fd, buf, 0, buf.length, 0)).toString("utf8");
     } finally {
-      fs12.closeSync(fd);
+      fs15.closeSync(fd);
     }
   } catch {
     return void 0;
@@ -1514,162 +1815,18 @@ 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;
 }
+function isFinished(id, lane) {
+  const verb = readStatusLog(id, lane).at(-1)?.verb;
+  return verb !== void 0 && TERMINAL_VERBS.includes(verb);
+}
 
 // packages/runner/src/run.ts
-import * as fs17 from "node:fs";
-import * as path15 from "node:path";
+import * as fs19 from "node:fs";
+import * as path16 from "node:path";
 import { execFileSync } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
@@ -1703,7 +1860,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((resolve6) => this.waiters.push(resolve6));
+        return new Promise((resolve7) => this.waiters.push(resolve7));
       }
     };
   }
@@ -1728,7 +1885,7 @@ var InputGate = class {
         return msg;
       if (this.ended)
         return void 0;
-      await new Promise((resolve6) => this.waiter = resolve6);
+      await new Promise((resolve7) => this.waiter = resolve7);
       this.waiter = null;
     }
   }
@@ -1767,7 +1924,9 @@ function pumpClaudeMessage(msg, push, onSession) {
     for (const block of msg.message?.content ?? []) {
       if (block.type === "tool_use") {
         const target = toolTarget(block.input);
-        push({ at, type: "tool-start", data: { name: block.name, ...target ? { target } : {} } });
+        const command = block.input?.command;
+        const pushes = typeof command === "string" ? gitPushTargets(command) : void 0;
+        push({ at, type: "tool-start", data: { name: block.name, ...target ? { target } : {}, ...pushes ? { pushes } : {} } });
       } else if (block.type === "thinking" || block.type === "redacted_thinking") {
         push({ at, type: "thinking", data: {} });
       } else if (block.type === "text" && block.text) {
@@ -1871,20 +2030,20 @@ function startClaudeCli(invocation, opts) {
       }
     }
   });
-  const done = new Promise((resolve6) => {
+  const done = new Promise((resolve7) => {
     child.on("error", (err) => {
       events.push({ at: now(), type: "error", data: { message: err.message } });
       events.close();
-      resolve6({ sessionId, error: err.message });
+      resolve7({ sessionId, error: err.message });
     });
     child.on("exit", (code) => {
       events.close();
       if (code === 0)
-        resolve6({ sessionId });
+        resolve7({ sessionId });
       else {
         const detail = stderrTail.trim().split("\n").at(-1);
         const error = `claude exited ${code}${detail ? ` \u2014 ${detail}` : ""}`;
-        resolve6({ sessionId, error });
+        resolve7({ sessionId, error });
       }
     });
   });
@@ -1963,25 +2122,25 @@ function createClaudeAdapter() {
 }
 
 // packages/adapters/dist/codex.js
-import * as fs14 from "node:fs";
+import * as fs16 from "node:fs";
 import * as os4 from "node:os";
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 function isolatedCodexHome() {
-  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)) {
+  const dir = path13.join(lobstahHome(), "codex-home");
+  fs16.mkdirSync(dir, { recursive: true });
+  const auth = path13.join(dir, "auth.json");
+  const realAuth = path13.join(os4.homedir(), ".codex", "auth.json");
+  if (!fs16.existsSync(auth) && fs16.existsSync(realAuth)) {
     try {
-      fs14.symlinkSync(realAuth, auth);
+      fs16.symlinkSync(realAuth, auth);
     } catch {
-      fs14.copyFileSync(realAuth, auth);
+      fs16.copyFileSync(realAuth, auth);
     }
   }
-  const cfg = path12.join(dir, "config.toml");
-  if (!fs14.existsSync(cfg)) {
-    fs14.writeFileSync(cfg, "# lobstah-managed: auth inherited from ~/.codex, interactive config not\n");
+  const cfg = path13.join(dir, "config.toml");
+  if (!fs16.existsSync(cfg)) {
+    fs16.writeFileSync(cfg, "# lobstah-managed: auth inherited from ~/.codex, interactive config not\n");
   }
   return dir;
 }
@@ -1998,7 +2157,9 @@ function pumpCodexEvent(ev, push, onSession) {
   } else if (ev.type === "item.started") {
     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 } : {} } });
+    const command = item.command;
+    const pushes = typeof command === "string" || Array.isArray(command) && command.every((c) => typeof c === "string") ? gitPushTargets(command) : void 0;
+    push({ at, type: "tool-start", data: { name: item.type, ...target ? { target } : {}, ...pushes ? { pushes } : {} } });
   } 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) } });
@@ -2031,7 +2192,7 @@ function startCodexCli(invoke, opts) {
   let current;
   let killed = false;
   function runTurn(prompt, resumeThread) {
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       const inv = invoke(codexExecArgs(opts, prompt, resumeThread));
       const child = spawn2(inv.file, inv.argv, {
         cwd: opts.cwd,
@@ -2062,14 +2223,14 @@ function startCodexCli(invoke, opts) {
           }
         }
       });
-      child.on("error", (err) => resolve6(err.message));
+      child.on("error", (err) => resolve7(err.message));
       child.on("exit", (code) => {
         if (turnError)
-          return resolve6(turnError);
+          return resolve7(turnError);
         if (code === 0 || killed)
-          return resolve6(void 0);
+          return resolve7(void 0);
         const detail = stderrTail.trim().split("\n").at(-1);
-        resolve6(`codex exited ${code}${detail ? ` \u2014 ${detail}` : ""}`);
+        resolve7(`codex exited ${code}${detail ? ` \u2014 ${detail}` : ""}`);
       });
     });
   }
@@ -2182,8 +2343,8 @@ function loadAdapter(name) {
 }
 
 // packages/worktree/dist/index.js
-import * as fs15 from "node:fs";
-import * as path13 from "node:path";
+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 { promisify } from "node:util";
@@ -2238,18 +2399,18 @@ ${gitStderr(err)}`, { cause: err });
     }
   }
 }
-async function allocate(repo, id) {
+async function allocate(repo, id, fromRemoteBranch = repo.trunk) {
   const dir = worktreePath(id);
-  if (fs15.existsSync(dir)) {
+  if (fs17.existsSync(dir)) {
     throw new Error(`worktree for ${id} already exists at ${dir} \u2014 never allocate a second`);
   }
-  if (!fs15.existsSync(repo.path)) {
+  if (!fs17.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 gitShared(repo.path, "fetch", "origin", fromRemoteBranch);
+  await gitShared(repo.path, "worktree", "add", "--no-track", dir, "-b", `lobstah/${id}`, `origin/${fromRemoteBranch}`);
   await runSetup(repo, dir);
   return dir;
 }
@@ -2279,27 +2440,27 @@ 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))
+    const file = path14.join(dir, name);
+    if (!fs17.existsSync(file))
       continue;
     h.update(`\0${name}\0`);
-    h.update(fs15.readFileSync(file));
+    h.update(fs17.readFileSync(file));
   }
   return h.digest("hex");
 }
 function setupRecordFile(dir) {
   const gitDir = worktreeGitDir(dir);
-  return gitDir ? path13.join(gitDir, "lobstah-setup.json") : void 0;
+  return gitDir ? path14.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));
+    fs17.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;
+    return file ? JSON.parse(fs17.readFileSync(file, "utf8")).hash : void 0;
   } catch {
     return void 0;
   }
@@ -2308,9 +2469,9 @@ var short = (s) => s.slice(0, 8);
 function realpath(p) {
   let r;
   try {
-    r = fs15.realpathSync.native(p);
+    r = fs17.realpathSync.native(p);
   } catch {
-    r = path13.resolve(p);
+    r = path14.resolve(p);
   }
   return process.platform === "win32" ? r.toLowerCase() : r;
 }
@@ -2336,7 +2497,7 @@ async function chooseWorktree(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;
+  const ownerRepo = storedDescriptor(found.owner, laneOf(found.owner) ?? lane)?.repo ?? storedDescriptor(found.from, laneOf(found.from) ?? lane)?.repo;
   if (ownerRepo !== void 0 && ownerRepo !== repoKey) {
     return { reuse: false, reason: `origin worktree belongs to repo ${ownerRepo}` };
   }
@@ -2352,8 +2513,8 @@ async function chooseWorktree(input) {
   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))
+    const rel = path14.relative(here, realpath(t.worktree));
+    if (!rel.startsWith("..") && !path14.isAbsolute(rel))
       return { reuse: false, reason: "origin worktree is a trap\u2019s" };
   }
   for (const l of ["work", "chore"]) {
@@ -2399,14 +2560,14 @@ async function collectEvidence(repo, dir) {
 
 // packages/runner/src/contract.ts
 function buildPrompt(brief, opts) {
-  const reporting = `Report status by running \`lobstah report ${opts.id} <verb> [note]\` (verbs: ${VERBS.join(", ")}). Attach a PR URL to your final report with \`--pr <url>\`. Only your report finishes this dispatch: ending a turn without \`done\` or \`failed\` does not. If you start background work and end your turn to wait for it, you are woken when it finishes. At natural checkpoints, check for operator messages with \`lobstah inbox ${opts.id}\` \u2014 messages also arrive automatically between your turns.`;
+  const reporting = `Report status by running \`lobstah report ${opts.id} <verb> [note]\` (verbs: ${VERBS.join(", ")}). Attach a PR URL to your final report with \`--pr <url>\`. If your output is findings rather than code, end with \`done "<one-line note>" --report <file.md>\` and add its images with \`--attach <file>\`. Only your report finishes this dispatch: ending a turn without \`done\` or \`failed\` does not. If you start background work and end your turn to wait for it, you are woken when it finishes. At natural checkpoints, check for operator messages with \`lobstah inbox ${opts.id}\` \u2014 messages also arrive automatically between your turns.`;
   const parts = [
     `You are a dispatched coding agent supervised by lobstah. Dispatch id: ${opts.id}.`,
     `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.`,
-    `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.`,
+    `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. A turn that ends on \`paused\` ends your session and stops its background work. The same session resumes when an operator message arrives, the \`--until\` time passes, or the PR you wait on ends; a merged PR finishes the dispatch as done.`,
+    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. ${pushRule(opts.existingPr.headRefName, opts.id)} 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 ---`,
     opts.existingPr ? `${brief}
 
@@ -2422,7 +2583,20 @@ 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((resolve6) => setTimeout(resolve6, ms));
+async function* until(source, stop) {
+  const it = source[Symbol.asyncIterator]();
+  const stopped = stop.then(() => ({ done: true, value: void 0 }));
+  while (true) {
+    const next = await Promise.race([it.next(), stopped]);
+    if (next.done) {
+      void it.return?.()?.catch?.(() => {
+      });
+      return;
+    }
+    yield next.value;
+  }
+}
+var sleep = (ms) => new Promise((resolve7) => setTimeout(resolve7, ms));
 function deliver(run2, id, lane) {
   const msgs = unhandled(id, lane);
   for (const m of msgs) {
@@ -2438,7 +2612,8 @@ async function drive(run2, opts) {
     pollMs = 3e3,
     stopped = () => false,
     backgroundWaitMs = 30 * 6e4,
-    settleGraceMs = 12e4
+    settleGraceMs = 12e4,
+    exitGraceMs = 3e4
   } = opts;
   const tracker = new ActivityTracker((a) => writeActivity(id, lane, a), {
     root: opts.cwd,
@@ -2452,9 +2627,55 @@ async function drive(run2, opts) {
   let activity = 0;
   let finished = false;
   void run2.done.then(() => finished = true);
+  let killed = false;
+  const kill = () => {
+    if (killed) return;
+    killed = true;
+    run2.kill();
+  };
   const cancel = () => {
     cancelled = true;
-    run2.kill();
+    kill();
+  };
+  let final = false;
+  let stoppedHarness;
+  let finalAt = 0;
+  let exit;
+  let abandon;
+  const abandoned = new Promise((resolve7) => abandon = resolve7);
+  const clearExit = () => {
+    if (!exit) return;
+    clearInterval(exit.poll);
+    clearTimeout(exit.expiry);
+    exit = void 0;
+  };
+  const stopHarness = (reason) => {
+    clearExit();
+    const afterMs = Date.now() - finalAt;
+    stoppedHarness = { reason, afterMs };
+    record({ at: (/* @__PURE__ */ new Date()).toISOString(), type: "runner", data: { stopped: reason, afterSecs: Math.round(afterMs / 1e3) } });
+    kill();
+    abandon();
+  };
+  let parked = false;
+  const finish = (park = false) => {
+    if (final || parked) return;
+    if (park) {
+      parked = true;
+      const on = readStatusLog(id, lane).at(-1)?.waitingOn;
+      record({ at: (/* @__PURE__ */ new Date()).toISOString(), type: "runner", data: { parked: "paused", ...on ? { on } : {} } });
+      opts.onPark?.();
+    } else {
+      final = true;
+      opts.onFinal?.();
+    }
+    finalAt = Date.now();
+    run2.end();
+    const poll = setInterval(() => {
+      if (cancelRequested(id, lane)) stopHarness("cancel");
+    }, Math.min(pollMs, exitGraceMs));
+    const expiry = setTimeout(() => stopHarness("exit-grace"), exitGraceMs);
+    exit = { poll, expiry };
   };
   const answered = (verb) => {
     appendStatus(id, lane, "working", "operator message delivered");
@@ -2508,7 +2729,7 @@ async function drive(run2, opts) {
     }, ms);
     hold = { heartbeat, expiry };
   };
-  for await (const ev of run2.events) {
+  for await (const ev of until(run2.events, abandoned)) {
     record(ev);
     if (ev.type === "background") {
       liveBackground = Number(ev.data?.live ?? 0);
@@ -2517,26 +2738,33 @@ async function drive(run2, opts) {
     }
     releaseHold();
     if (ev.type === "tool-start" || ev.type === "text") activity++;
+    if (ev.type === "tool-start" && Array.isArray(ev.data?.pushes)) {
+      recordPush(id, lane, resolvePushTargets(ev.data.pushes.map(String), opts.cwd), ev.at);
+    }
     if (ev.type === "session" && ev.data?.sessionId) {
       mergeEvidence(id, lane, { sessionId: String(ev.data.sessionId) });
     }
-    if (ev.type !== "turn-end" || cancelled || stopped()) continue;
+    if (ev.type !== "turn-end" || cancelled || stopped() || final || parked) continue;
+    const lastVerb = readStatusLog(id, lane).at(-1)?.verb;
+    if (lastVerb !== void 0 && TERMINAL_VERBS.includes(lastVerb)) {
+      finish();
+      continue;
+    }
     if (cancelRequested(id, lane)) {
       cancel();
       continue;
     }
-    const lastVerb = readStatusLog(id, lane).at(-1)?.verb;
     const waiting = lastVerb !== void 0 && WAITING_VERBS.includes(lastVerb);
     if (deliver(run2, id, lane) > 0) {
       if (waiting) answered(lastVerb);
       continue;
     }
-    if (waiting) {
-      await awaitAnswer(lastVerb);
+    if (lastVerb === "paused") {
+      finish(true);
       continue;
     }
-    if (lastVerb !== void 0 && TERMINAL_VERBS.includes(lastVerb)) {
-      run2.end();
+    if (waiting) {
+      await awaitAnswer(lastVerb);
       continue;
     }
     const subtype = ev.data?.subtype;
@@ -2552,16 +2780,18 @@ async function drive(run2, opts) {
     unreported();
   }
   releaseHold();
+  clearExit();
   tracker.flush();
   tracker.stop();
-  return { cancelled, activity };
+  return { cancelled, activity, final, ...parked ? { parked } : {}, ...stoppedHarness ? { stopped: stoppedHarness } : {} };
 }
 function settle(id, lane, r) {
   const lastVerb = readStatusLog(id, lane).at(-1)?.verb;
+  if (lastVerb !== void 0 && TERMINAL_VERBS.includes(lastVerb)) return;
   if (r.cancelled) appendStatus(id, lane, "failed", "cancelled by operator");
   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");
+  else appendStatus(id, lane, "failed", "stopped without reporting a result");
 }
 
 // packages/runner/src/plan.ts
@@ -2690,8 +2920,8 @@ function startWallClock(opts) {
 import { execFile as execFile2 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
 import { fileURLToPath } from "node:url";
-import * as fs16 from "node:fs";
-import * as path14 from "node:path";
+import * as fs18 from "node:fs";
+import * as path15 from "node:path";
 var exec2 = promisify2(execFile2);
 function firstLine(err) {
   const stderr = err && typeof err === "object" && "stderr" in err ? String(err.stderr).trim() : "";
@@ -2721,10 +2951,10 @@ function keepRemote(opts) {
   const note = (message) => mergeEvidence(id, lane, { note: message.slice(0, 300) });
   if (existingPrUrl) mergeEvidence(id, lane, { prUrl: existingPrUrl });
   const registerWatch = async (url) => {
-    const root = path14.resolve(path14.dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
-    const localCli = path14.join(root, "apps", "cli", "dist", "main.js");
+    const root = path15.resolve(path15.dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+    const localCli = path15.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);
+    if (fs18.existsSync(localCli)) await command(process.execPath, [localCli, ...args], 15e3);
     else await command("lobstah", args, 15e3);
   };
   let lastSeenHead;
@@ -2796,6 +3026,7 @@ function keepRemote(opts) {
       pushedHead = head;
       pushProblem = void 0;
       mergeEvidence(id, lane, { branch });
+      recordPush(id, lane, [branch]);
       note(`remote saved: ${branch}@${head.slice(0, 12)}`);
       if (!opening) opening = draft(branch).finally(() => {
         opening = void 0;
@@ -2863,8 +3094,28 @@ function keepRemote(opts) {
 }
 
 // packages/runner/src/run.ts
-var defaultDeps = { loadAdapter, allocate, chooseWorktree, prepareReuse, collectEvidence };
+var defaultDeps = {
+  loadAdapter,
+  allocate,
+  chooseWorktree,
+  prepareReuse,
+  collectEvidence,
+  reap: async () => 0
+};
+var DONE_WAIT_MS = 2e3;
+function within(p, ms, fallback) {
+  let timer;
+  const late = new Promise((resolve7) => timer = setTimeout(() => resolve7(fallback), ms));
+  return Promise.race([p, late]).finally(() => clearTimeout(timer));
+}
 var short3 = (s) => s.slice(0, 8);
+function boundPr(descriptor, lane) {
+  if (descriptor.pr?.url) {
+    const chain = descriptor.followUp ? chainPr(descriptor.followUp, lane) : void 0;
+    return { url: descriptor.pr.url, headRefName: descriptor.pr.headRefName ?? (chain?.url === descriptor.pr.url ? chain.headRefName : void 0) };
+  }
+  return descriptor.followUp ? chainPr(descriptor.followUp, lane) : void 0;
+}
 function coldNote(cold, cwd, trunk) {
   const parts = [worktreeProgress(cwd, trunk)];
   if (cold.origin) parts.push(originProgress(cold.origin.id, cold.origin.lane));
@@ -2872,23 +3123,24 @@ function coldNote(cold, cwd, trunk) {
 }
 async function main(activeDir, lane, seams = {}) {
   const deps = { ...defaultDeps, ...seams };
-  const id = path15.basename(activeDir);
+  const id = path16.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(fs17.readFileSync(path15.join(activeDir, "descriptor.json"), "utf8"));
+  const descriptor = JSON.parse(fs19.readFileSync(path16.join(activeDir, "descriptor.json"), "utf8"));
   const resolved = resolveDispatch(descriptor, cfg);
   const repo = cfg.repos[descriptor.repo];
-  const briefFile = path15.join(activeDir, "brief.md");
-  if (!fs17.existsSync(briefFile)) fs17.writeFileSync(briefFile, descriptor.brief);
-  const brief = fs17.readFileSync(briefFile, "utf8");
+  const briefFile = path16.join(activeDir, "brief.md");
+  if (!fs19.existsSync(briefFile)) fs19.writeFileSync(briefFile, descriptor.brief);
+  const brief = fs19.readFileSync(briefFile, "utf8");
   const attempts = Number(process.env.LOBSTAH_ATTEMPTS ?? "1");
+  const wake = process.env.LOBSTAH_WAKE;
   const runnerInfo = {
     pid: process.pid,
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     attempts
   };
-  fs17.writeFileSync(path15.join(activeDir, "runner.json"), JSON.stringify(runnerInfo, null, 2));
+  fs19.writeFileSync(path16.join(activeDir, "runner.json"), JSON.stringify(runnerInfo, null, 2));
   const plan = planStart({
     id,
     lane,
@@ -2897,13 +3149,13 @@ async function main(activeDir, lane, seams = {}) {
     resolvedHarness: resolved.harness,
     envResume: process.env.LOBSTAH_RESUME
   });
-  const wtFile = path15.join(activeDir, "worktree.json");
+  const wtFile = path16.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))) {
+  if (fs19.existsSync(wtFile)) {
+    recorded = JSON.parse(fs19.readFileSync(wtFile, "utf8")).path;
+    if (!fs19.existsSync(recorded)) throw new Error(`recorded worktree ${recorded} is gone`);
+  } else if (fs19.existsSync(worktreePath(id))) {
     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 });
@@ -2911,7 +3163,7 @@ async function main(activeDir, lane, seams = {}) {
   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,
+    wake ? `woke from pause: ${wake}` : attempts > 1 ? `attempt ${attempts}` : void 0,
     plan.note,
     firstModel.dropped ? droppedModelNote(plan.harness, firstModel.dropped) : void 0,
     worktreeNote
@@ -2937,15 +3189,15 @@ async function main(activeDir, lane, seams = {}) {
       type: "runner",
       data: { worktree: cwd, worktreeOf: choice.owner, setupRan }
     });
-    fs17.writeFileSync(wtFile, JSON.stringify({ path: cwd, of: choice.owner }, null, 2));
+    fs19.writeFileSync(wtFile, JSON.stringify({ path: cwd, of: choice.owner }, null, 2));
   } else {
-    cwd = await deps.allocate(repo, id);
+    cwd = await deps.allocate(repo, id, descriptor.systemRepair ? descriptor.pr?.headRefName : void 0);
     acquireWorktreeLock(cwd, id, lane);
-    fs17.writeFileSync(wtFile, JSON.stringify({ path: cwd }, null, 2));
+    fs19.writeFileSync(wtFile, JSON.stringify({ path: cwd }, null, 2));
   }
-  const worktreeOf = JSON.parse(fs17.readFileSync(wtFile, "utf8")).of;
+  const worktreeOf = JSON.parse(fs19.readFileSync(wtFile, "utf8")).of;
   mergeEvidence(id, lane, { worktree: cwd, worktreeOf });
-  const existingPr = descriptor.followUp ? chainPr(descriptor.followUp, lane) : void 0;
+  const existingPr = boundPr(descriptor, lane);
   if (existingPr) mergeEvidence(id, lane, { prUrl: existingPr.url });
   const remotePolicy = {
     pushEarly: repo.pushEarly ?? cfg.limits.pushEarly,
@@ -2962,17 +3214,26 @@ async function main(activeDir, lane, seams = {}) {
     policy: remotePolicy,
     existingPrUrl: existingPr?.url
   });
-  const envNudge = process.env.LOBSTAH_NUDGE;
+  const wakeNote = () => {
+    if (!wake) return void 0;
+    const msgs = unhandled(id, lane);
+    for (const m of msgs) acknowledge(id, lane, m.file);
+    return [
+      `You were paused and this dispatch was parked. The wait ended: ${wake}. Continue the work, and report as before.`,
+      ...msgs.map((m) => m.text)
+    ].join("\n\n");
+  };
+  const envNudge = [process.env.LOBSTAH_NUDGE, wakeNote()].filter(Boolean).join("\n\n") || void 0;
   const planNudge = plan.cold && !envNudge ? coldNote(plan.cold, cwd, repo.trunk) : void 0;
   const promptWith = (nudge) => buildPrompt(brief, { id, nudge, attachments: descriptor.attachments, existingPr });
-  const binDir = 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;
+  const binDir = path16.resolve(path16.dirname(fileURLToPath2(import.meta.url)), "..", "..", "..", "bin");
+  const workerPath = fs19.existsSync(path16.join(binDir, "lobstah")) ? `${binDir}${path16.delimiter}${process.env.PATH ?? ""}` : void 0;
   let wallClockHit = false;
   let current;
-  const wallFile = path15.join(activeDir, "wallclock.json");
+  const wallFile = path16.join(activeDir, "wallclock.json");
   const wallState = (() => {
     try {
-      return JSON.parse(fs17.readFileSync(wallFile, "utf8"));
+      return JSON.parse(fs19.readFileSync(wallFile, "utf8"));
     } catch {
       return { elapsedMs: 0, windowMs: resolved.limits.wallClockSecs * 1e3 };
     }
@@ -2991,8 +3252,8 @@ async function main(activeDir, lane, seams = {}) {
   ) * 1e3;
   const persistWall = (elapsedMs, windowMs) => {
     const tmp = `${wallFile}.tmp-${process.pid}`;
-    fs17.writeFileSync(tmp, JSON.stringify({ ...wallState, elapsedMs, windowMs }));
-    fs17.renameSync(tmp, wallFile);
+    fs19.writeFileSync(tmp, JSON.stringify({ ...wallState, elapsedMs, windowMs }));
+    fs19.renameSync(tmp, wallFile);
   };
   const madeProgress = () => {
     const activity = readActivity(id, lane);
@@ -3014,10 +3275,16 @@ async function main(activeDir, lane, seams = {}) {
     maxMs: maxWallMs,
     initialElapsedMs: wallState.elapsedMs,
     initialWindowMs: wallState.windowMs,
-    paused: () => pausedWaiting(readStatusLog(id, lane).at(-1)),
+    // A finished dispatch spends no time: the worker's final report
+    // stops the clock, even before the turn ends.
+    paused: () => {
+      const last = readStatusLog(id, lane).at(-1);
+      return pausedWaiting(last) || isFinished(id, lane);
+    },
     progress: madeProgress,
     onTick: persistWall,
     onExpire: () => {
+      if (isFinished(id, lane)) return;
       wallClockHit = true;
       current?.kill();
     }
@@ -3047,86 +3314,219 @@ async function main(activeDir, lane, seams = {}) {
       resumeSession
     });
     current = run2;
-    const { cancelled: cancelled2, activity } = await drive(run2, {
+    const driven = await drive(run2, {
       id,
       lane,
       cwd,
       stopped: () => wallClockHit,
-      backgroundWaitMs: cfg.limits.backgroundWaitSecs * 1e3
+      backgroundWaitMs: cfg.limits.backgroundWaitSecs * 1e3,
+      exitGraceMs: (cfg.limits.exitGraceSecs ?? 30) * 1e3,
+      onFinal: () => wallTimer?.stop(),
+      onPark: () => wallTimer?.stop()
     });
-    const result2 = await run2.done;
-    return { cancelled: cancelled2, activity, result: result2 };
+    const { cancelled, activity, parked } = driven;
+    if (driven.stopped) {
+      const reaped = await deps.reap();
+      console.log(`[runner] harness stopped (${driven.stopped.reason}) ${Math.round(driven.stopped.afterMs / 1e3)}s after the final report; ${reaped} process(es) stopped`);
+      mergeEvidence(id, lane, {
+        harnessStopped: {
+          reason: driven.stopped.reason,
+          afterSecs: Math.round(driven.stopped.afterMs / 1e3),
+          at: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+    }
+    const result = driven.final || parked ? await within(run2.done, DONE_WAIT_MS, {}) : await run2.done;
+    return { cancelled, activity, parked: parked === true, result };
   };
-  let outcome = await runOnce(plan.harness, promptWith(envNudge ?? planNudge), plan.resume?.sessionId);
-  if (plan.resume && !outcome.cancelled && !wallClockHit && outcome.activity === 0 && isUnresumable(outcome.result.error)) {
-    const reason = outcome.result.error.replace(/\s+/g, " ").slice(0, 200).trim();
-    const coldHarness = resolved.harness;
-    const coldModel = modelForHarness(coldHarness, resolved.model);
-    status(
-      "working",
-      `resume-fallback: ${reason} \u2014 starting cold on ${coldHarness}` + (coldModel.dropped ? `; ${droppedModelNote(coldHarness, coldModel.dropped)}` : "")
-    );
-    appendEvent(id, lane, {
-      at: (/* @__PURE__ */ new Date()).toISOString(),
-      type: "runner",
-      data: { resumeFallback: reason, harness: coldHarness }
-    });
-    mergeEvidence(id, lane, { resumeFallback: reason, sessionId: void 0, harness: coldHarness });
-    const note = coldNote(
-      {
-        why: `resume of session ${plan.resume.sessionId} failed`,
-        fromHarness: plan.harness,
-        ...plan.resume.origin ? { origin: plan.resume.origin } : {}
-      },
-      cwd,
-      repo.trunk
+  let finalReport = false;
+  let parkedExit = false;
+  try {
+    let outcome = await runOnce(plan.harness, promptWith(envNudge ?? planNudge), plan.resume?.sessionId);
+    if (plan.resume && !outcome.cancelled && !wallClockHit && outcome.activity === 0 && isUnresumable(outcome.result.error)) {
+      const reason = outcome.result.error.replace(/\s+/g, " ").slice(0, 200).trim();
+      const coldHarness = resolved.harness;
+      const coldModel = modelForHarness(coldHarness, resolved.model);
+      status(
+        "working",
+        `resume-fallback: ${reason} \u2014 starting cold on ${coldHarness}` + (coldModel.dropped ? `; ${droppedModelNote(coldHarness, coldModel.dropped)}` : "")
+      );
+      appendEvent(id, lane, {
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "runner",
+        data: { resumeFallback: reason, harness: coldHarness }
+      });
+      mergeEvidence(id, lane, { resumeFallback: reason, sessionId: void 0, harness: coldHarness });
+      const note = coldNote(
+        {
+          why: `resume of session ${plan.resume.sessionId} failed`,
+          fromHarness: plan.harness,
+          ...plan.resume.origin ? { origin: plan.resume.origin } : {}
+        },
+        cwd,
+        repo.trunk
+      );
+      outcome = await runOnce(coldHarness, promptWith([envNudge, note].filter(Boolean).join("\n\n")), void 0);
+    }
+    wallTimer?.stop();
+    const { cancelled, result } = outcome;
+    if (outcome.parked && !cancelled && !wallClockHit && readStatusLog(id, lane).at(-1)?.verb === "paused") {
+      parkedExit = true;
+      await remote.stop();
+      const gitEvidence = await deps.collectEvidence(repo, cwd).catch(() => ({}));
+      mergeEvidence(id, lane, { ...gitEvidence, sessionId: result.sessionId ?? readEvidence(id, lane).sessionId });
+      console.log("[runner] worker paused: session ended, dispatch parked");
+      return;
+    }
+    const terminal = isFinished(id, lane);
+    finalReport = terminal;
+    let savedNote;
+    if (remoteEnabled && !terminal) {
+      savedNote = await remote.saveBeforeStop();
+      status("working", `work saved before stop: ${savedNote}`);
+    } else {
+      await remote.stop();
+    }
+    try {
+      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))}`);
+    } catch (err) {
+      mergeEvidence(id, lane, {
+        note: `evidence collection failed: ${err instanceof Error ? err.message : String(err)}`.slice(0, 300)
+      });
+    }
+    settle(id, lane, { cancelled, wallClockHit, error: result.error, budgetNote: savedNote });
+  } finally {
+    wallTimer?.stop();
+    if (finalReport || parkedExit) {
+      const reaped = await deps.reap().catch(() => 0);
+      if (reaped > 0) console.log(`[runner] ${reaped} leftover process(es) stopped`);
+    }
+    if (!parkedExit) {
+      releaseWorktreeLock(cwd, id);
+      complete(id, lane);
+    }
+  }
+}
+
+// packages/runner/src/reap.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+function listProcesses() {
+  if (process.platform === "win32") {
+    const out2 = execFileSync2(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        'Get-CimInstance Win32_Process | ForEach-Object { "$($_.ProcessId) $($_.ParentProcessId)" }'
+      ],
+      { encoding: "utf8", windowsHide: true, timeout: 3e4, stdio: ["ignore", "pipe", "ignore"] }
     );
-    outcome = await runOnce(coldHarness, promptWith([envNudge, note].filter(Boolean).join("\n\n")), void 0);
-  }
-  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();
+    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="], {
+    encoding: "utf8",
+    timeout: 3e4,
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  return out.split("\n").map((l) => l.trim().split(/\s+/).map(Number)).filter(([pid, ppid, pgid]) => Number.isInteger(pid) && Number.isInteger(ppid) && Number.isInteger(pgid)).map(([pid, ppid, pgid]) => ({ pid, ppid, pgid }));
+}
+function startedBy(root, rows) {
+  const children = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    if (r.pid === r.ppid) continue;
+    const list = children.get(r.ppid) ?? [];
+    list.push(r.pid);
+    children.set(r.ppid, list);
+  }
+  const found = /* @__PURE__ */ new Set();
+  const stack = [root];
+  while (stack.length > 0) {
+    for (const child of children.get(stack.pop()) ?? []) {
+      if (child === root || found.has(child)) continue;
+      found.add(child);
+      stack.push(child);
+    }
   }
+  const leads = rows.find((r) => r.pid === root)?.pgid === root;
+  if (leads) {
+    for (const r of rows) if (r.pgid === root && r.pid !== root) found.add(r.pid);
+  }
+  return [...found];
+}
+var alive = (pid) => {
   try {
-    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))}`);
+    process.kill(pid, 0);
+    return true;
   } catch (err) {
-    mergeEvidence(id, lane, {
-      note: `evidence collection failed: ${err instanceof Error ? err.message : String(err)}`.slice(0, 300)
-    });
+    return err.code === "EPERM";
   }
-  settle(id, lane, { cancelled, wallClockHit, error: result.error, budgetNote: savedNote });
-  releaseWorktreeLock(cwd, id);
-  complete(id, lane);
+};
+async function stopPids(pids, graceMs = 2e3) {
+  if (pids.length === 0) return;
+  if (process.platform === "win32") {
+    for (const pid of pids) {
+      try {
+        execFileSync2("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true, timeout: 3e4 });
+      } catch {
+      }
+    }
+    return;
+  }
+  const signal = (pid, sig) => {
+    try {
+      process.kill(pid, sig);
+    } catch {
+    }
+  };
+  for (const pid of pids) signal(pid, "SIGTERM");
+  const deadline = Date.now() + graceMs;
+  while (pids.some(alive) && Date.now() < deadline) await new Promise((r) => setTimeout(r, 100));
+  for (const pid of pids.filter(alive)) signal(pid, "SIGKILL");
+}
+async function reapStarted(root = process.pid, graceMs) {
+  let rows;
+  try {
+    rows = listProcesses();
+  } catch {
+    return 0;
+  }
+  const pids = startedBy(root, rows);
+  await stopPids(pids, graceMs);
+  return pids.length;
 }
 
 // packages/runner/src/index.ts
+var EXIT_LINGER_MS = 5e3;
 function runRunner(activeDirArg2, laneArg2) {
   const lane = laneArg2 === "chore" ? "chore" : "work";
-  main(activeDirArg2, lane).catch((err) => {
-    const id = path16.basename(activeDirArg2);
+  const id = path17.basename(activeDirArg2);
+  main(activeDirArg2, lane, { reap: () => reapStarted(process.pid) }).catch((err) => {
     try {
-      appendStatus(id, lane, "failed", String(err instanceof Error ? err.message : err).slice(0, 500));
-      fs18.renameSync(activeDirArg2, path16.join(laneDirs(lane).done, id));
+      if (!isFinished(id, lane)) {
+        appendStatus(id, lane, "failed", String(err instanceof Error ? err.message : err).slice(0, 500));
+      }
+      fs20.renameSync(activeDirArg2, path17.join(laneDirs(lane).done, id));
     } catch {
     }
     process.exitCode = 1;
+  }).finally(() => {
+    setTimeout(() => process.exit(), EXIT_LINGER_MS).unref();
   });
 }
 var [activeDirArg, laneArg] = process.argv.slice(2);
 if (activeDirArg && activeDirArg !== "__runner") runRunner(activeDirArg, laneArg);
 export {
+  listProcesses,
   main,
   planStart,
-  runRunner
+  reapStarted,
+  runRunner,
+  startedBy,
+  stopPids
 };
 /*! Bundled license information: