lobstah 0.6.8 → 0.6.10

package/dist/main.js

@@ -1875,6 +1875,10 @@ function expandHome(p) {
 function loadConfig() {
   const file = configPath();
   const raw = fs8.existsSync(file) ? parse(fs8.readFileSync(file, "utf8")) : {};
+  const readySettleSecs = raw.readySettleSecs ?? 600;
+  if (typeof readySettleSecs !== "number" || !Number.isFinite(readySettleSecs) || readySettleSecs < 0) {
+    throw new Error(`readySettleSecs must be a non-negative number in ${configPath()}`);
+  }
   const reposRaw = raw.repos ?? {};
   const repos = {};
   for (const [key, r] of Object.entries(reposRaw)) {
@@ -1911,6 +1915,7 @@ function loadConfig() {
     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,
+    readySettleSecs,
     attentionKinds: parseAttentionKinds(raw.attentionKinds)
   };
 }
@@ -1943,6 +1948,7 @@ var init_config = __esm({
     DEFAULT_ATTENTION_KINDS = ["question", "decision", "pr:ready", "pr:review", "pr:conflict", "pr:checks"];
     DEFAULT_SOAK = {
       deferSecs: 90,
+      claimIdleNoticeSecs: 180,
       ttlSecs: 1800,
       beat: true,
       pausedTtlSecs: 86400,
@@ -2387,253 +2393,9 @@ var init_watch = __esm({
   }
 });
 
-// packages/core/dist/helm.js
+// packages/core/dist/activity.js
 import * as fs11 from "node:fs";
 import * as path11 from "node:path";
-function helmDir() {
-  return path11.join(lobstahHome(), "helm");
-}
-function relievedDir() {
-  return path11.join(helmDir(), ".relieved");
-}
-function helmPath(grounds) {
-  return path11.join(helmDir(), `${grounds}.json`);
-}
-function atomicWrite(file, content) {
-  fs11.mkdirSync(path11.dirname(file), { recursive: true });
-  const tmp = `${file}.tmp-${process.pid}`;
-  fs11.writeFileSync(tmp, content);
-  fs11.renameSync(tmp, file);
-}
-function readHelm(grounds) {
-  try {
-    return JSON.parse(fs11.readFileSync(helmPath(grounds), "utf8"));
-  } catch {
-    return void 0;
-  }
-}
-function listHelms() {
-  try {
-    return fs11.readdirSync(helmDir()).filter((f) => f.endsWith(".json")).map((f) => JSON.parse(fs11.readFileSync(path11.join(helmDir(), f), "utf8")));
-  } catch {
-    return [];
-  }
-}
-function helmOf(sessionId) {
-  return listHelms().find((h) => h.sessionId === sessionId);
-}
-function liveHelms(ttlMs, now2 = Date.now()) {
-  return listHelms().filter((h) => now2 - (Date.parse(h.heartbeatAt) || 0) <= ttlMs);
-}
-function helmGate(live, sessionId, grounds) {
-  if (grounds !== void 0) {
-    const holder = live.find((h) => h.grounds === grounds);
-    if (holder && holder.sessionId !== sessionId) {
-      return `grounds "${grounds}" is helmed by session ${holder.sessionId.slice(0, 8)} \u2014 its verbs are that session's alone. Run this from that session (--session), or take its helm (\`lobstah man helm --take\`).`;
-    }
-    if (holder)
-      return void 0;
-  }
-  if (live.length === 0)
-    return void 0;
-  if (sessionId !== void 0 && live.some((h) => h.sessionId === sessionId))
-    return void 0;
-  const holders = live.map((h) => `${h.grounds}=${h.sessionId.slice(0, 8)}`).join(", ");
-  return `the helm is claimed (${holders}) \u2014 this verb is reserved for the helm session. Run it there with --session <helm-session-id>, or take the helm (\`lobstah man helm --take\`).`;
-}
-function helmLabel(h) {
-  if (h.label)
-    return h.label;
-  const where = h.cwd ? path11.basename(h.cwd) : void 0;
-  if (!h.harness && !where)
-    return `session ${h.sessionId.slice(0, 8)}`;
-  return `${h.harness ?? "session"}${where ? ` @ ${where}` : ""}`;
-}
-function takeHelm(opts) {
-  const now2 = opts.now ?? Date.now();
-  const existing = readHelm(opts.grounds.name);
-  if (existing && existing.sessionId !== opts.sessionId) {
-    const fresh = now2 - (Date.parse(existing.heartbeatAt) || 0) <= opts.ttlMs;
-    if (fresh && !opts.take)
-      return { held: existing };
-    atomicWrite(path11.join(relievedDir(), `${existing.sessionId}.json`), JSON.stringify({
-      sessionId: existing.sessionId,
-      grounds: opts.grounds.name,
-      by: opts.sessionId,
-      at: new Date(now2).toISOString()
-    }, null, 2));
-  }
-  const iso = new Date(now2).toISOString();
-  const same = existing?.sessionId === opts.sessionId;
-  const live = existing !== void 0 && now2 - (Date.parse(existing.heartbeatAt) || 0) <= opts.ttlMs;
-  const reg = {
-    sessionId: opts.sessionId,
-    grounds: opts.grounds.name,
-    repos: opts.grounds.repos,
-    signedOnAt: same ? existing.signedOnAt : iso,
-    heartbeatAt: iso,
-    // A new helm on empty grounds starts its cursor now: a notice delivered
-    // to nobody while no helm was signed on is not news. A take from a live
-    // helm, or the same session signing on again, keeps the cursor, so
-    // nothing in flight is dropped.
-    wakesFrom: same || live ? existing.wakesFrom : iso,
-    // Identity refreshes on every sign-on; a re-sign without one keeps what
-    // the registration already knows.
-    harness: opts.identity?.harness ?? (same ? existing.harness : void 0),
-    cwd: opts.identity?.cwd ?? (same ? existing.cwd : void 0),
-    host: opts.identity?.host ?? (same ? existing.host : void 0),
-    label: opts.identity?.label ?? (same ? existing.label : void 0),
-    window: opts.identity?.window ?? (same ? existing.window : void 0),
-    tookFrom: existing && existing.sessionId !== opts.sessionId ? { sessionId: existing.sessionId, at: iso } : existing?.tookFrom
-  };
-  atomicWrite(helmPath(opts.grounds.name), JSON.stringify(reg, null, 2));
-  return { ok: reg };
-}
-function wakeFloorMs(h) {
-  return h?.wakesFrom ? Date.parse(h.wakesFrom) || 0 : 0;
-}
-function noticeStands(n) {
-  switch (n.kind) {
-    case "disk-held":
-      return readHold() !== void 0;
-    case "watch-failing":
-    case "watch-held":
-      return listWatches().some((w) => (w.key === n.refId || w.owner === `dispatch:${n.refId}`) && (n.kind === "watch-failing" ? w.failingNoticed === true : true));
-    case "trap-request":
-      return n.refId !== void 0 && isOpenRequest(n.refId);
-    default:
-      return false;
-  }
-}
-function noticeWakes(h) {
-  const floor = wakeFloorMs(h);
-  if (floor === 0)
-    return void 0;
-  return (n) => (Date.parse(n.at) || 0) >= floor || noticeStands(n);
-}
-function relieveHelm(sessionId) {
-  const relieved = [];
-  for (const h of listHelms()) {
-    if (h.sessionId !== sessionId)
-      continue;
-    fs11.rmSync(helmPath(h.grounds), { force: true });
-    relieved.push(h.grounds);
-  }
-  fs11.rmSync(path11.join(relievedDir(), `${sessionId}.json`), { force: true });
-  return relieved;
-}
-function heartbeatHelm(sessionId, opts = {}) {
-  const reg = helmOf(sessionId);
-  if (!reg)
-    return void 0;
-  const now2 = (/* @__PURE__ */ new Date()).toISOString();
-  const next = { ...reg, heartbeatAt: now2, ...opts.parked ? { parkedAt: now2 } : {} };
-  atomicWrite(helmPath(reg.grounds), JSON.stringify(next, null, 2));
-  return next;
-}
-function consumeRelievedNotice(sessionId) {
-  const file = path11.join(relievedDir(), `${sessionId}.json`);
-  try {
-    const notice = JSON.parse(fs11.readFileSync(file, "utf8"));
-    fs11.rmSync(file, { force: true });
-    return notice;
-  } catch {
-    return void 0;
-  }
-}
-function groundsList(cfg) {
-  const entries = Object.entries(cfg.grounds);
-  if (entries.length === 0)
-    return [{ name: "fleet", repos: Object.keys(cfg.repos) }];
-  return entries.map(([name, g]) => ({ name, repos: g.repos }));
-}
-function groundsErrors(cfg) {
-  const errors = [];
-  const seen = /* @__PURE__ */ new Map();
-  for (const [name, g] of Object.entries(cfg.grounds)) {
-    for (const repo of g.repos) {
-      if (cfg.repos[repo] === void 0)
-        errors.push(`grounds.${name} names unknown repo "${repo}"`);
-      const other = seen.get(repo);
-      if (other !== void 0)
-        errors.push(`repo "${repo}" is in both grounds.${other} and grounds.${name} \u2014 a repo belongs to at most one grounds`);
-      else
-        seen.set(repo, name);
-    }
-  }
-  return errors;
-}
-function resolveGrounds(cfg, name) {
-  const all = groundsList(cfg);
-  if (name === void 0) {
-    if (all.length === 1)
-      return all[0];
-    throw new Error(`multiple grounds configured \u2014 pass --grounds <${all.map((g) => g.name).join("|")}>`);
-  }
-  const found = all.find((g) => g.name === name);
-  if (!found)
-    throw new Error(`unknown grounds "${name}" (configured: ${all.map((g) => g.name).join(", ")})`);
-  return found;
-}
-var isOpenRequest;
-var init_helm = __esm({
-  "packages/core/dist/helm.js"() {
-    "use strict";
-    init_disk();
-    init_paths();
-    init_watch();
-    init_requests();
-    isOpenRequest = (id) => {
-      const r = readRequest(id);
-      return r !== void 0 && r.closedAt === void 0;
-    };
-  }
-});
-
-// packages/core/dist/session-link.js
-function validSessionLink(value) {
-  if (typeof value !== "string")
-    return false;
-  if (/[\x00-\x1f\x7f]/.test(value))
-    return false;
-  return /^claude:\/\/claude\.ai\/[A-Za-z0-9_/-]+$/.test(value) || /^vscode:\/\/anthropic\.claude-code\/open\?session=[A-Za-z0-9_-]+$/.test(value) || /^codex:\/\/threads\/[A-Za-z0-9-]+$/.test(value);
-}
-function linkMismatch(link, win) {
-  if (!win)
-    return void 0;
-  const ep = win.entrypoint;
-  const bundle = win.bundleId;
-  if (link.startsWith("vscode://")) {
-    if (ep !== void 0)
-      return ep === "claude-vscode" ? void 0 : `a vscode:// link needs the VS Code extension; this session's entrypoint is ${ep}`;
-    return bundle === void 0 || VSCODE_BUNDLE_RE.test(bundle) ? void 0 : `a vscode:// link needs the VS Code extension; this session runs in ${bundle}`;
-  }
-  if (link.startsWith("claude://")) {
-    if (ep !== void 0) {
-      return ep === "cli" || ep === "claude-vscode" || ep.startsWith("sdk-") ? `a claude:// link needs the Claude desktop app's Code tab; this session's entrypoint is ${ep}` : void 0;
-    }
-    if (bundle !== void 0 && bundle !== CLAUDE_DESKTOP_BUNDLE)
-      return `a claude:// link needs the Claude desktop app; this session runs in ${bundle}`;
-    return win.termProgram === "claude-desktop" ? "a claude:// link needs the Code tab; this session runs in the Claude desktop app's terminal" : void 0;
-  }
-  if (link.startsWith("codex://")) {
-    return bundle === void 0 || bundle === CODEX_BUNDLE ? void 0 : `a codex:// link needs the Codex app; this session runs in ${bundle}`;
-  }
-  return void 0;
-}
-var VSCODE_BUNDLE_RE, CLAUDE_DESKTOP_BUNDLE, CODEX_BUNDLE;
-var init_session_link = __esm({
-  "packages/core/dist/session-link.js"() {
-    "use strict";
-    VSCODE_BUNDLE_RE = /(?:VSCode|Cursor|windsurf)/;
-    CLAUDE_DESKTOP_BUNDLE = "com.anthropic.claudefordesktop";
-    CODEX_BUNDLE = "com.openai.codex";
-  }
-});
-
-// packages/core/dist/activity.js
-import * as fs12 from "node:fs";
-import * as path12 from "node:path";
 function looksSecret(word) {
   if (SECRET_PATTERNS.some((re) => re.test(word)))
     return true;
@@ -2676,7 +2438,7 @@ function relativeTarget(p, root) {
   if (!root)
     return baseName(p);
   const win = isWindowsPath(p) || isWindowsPath(root);
-  const lib = win ? path12.win32 : path12.posix;
+  const lib = win ? path11.win32 : path11.posix;
   if (!lib.isAbsolute(p))
     return p.replace(/\\/g, "/");
   const rel = lib.relative(win ? root : root.replace(/\\/g, "/"), p);
@@ -2743,18 +2505,18 @@ function activityFromEvent(ev, root) {
       return void 0;
   }
 }
-function atomicWrite2(file, content) {
+function atomicWrite(file, content) {
   const tmp = `${file}.tmp-${process.pid}`;
-  fs12.writeFileSync(tmp, content);
-  fs12.renameSync(tmp, file);
+  fs11.writeFileSync(tmp, content);
+  fs11.renameSync(tmp, file);
 }
 function writeActivity(id, lane, a) {
   const safe = { at: a.at, kind: a.kind, summary: redactSummary(a.summary) };
-  atomicWrite2(activityPath(id, lane), JSON.stringify(safe));
+  atomicWrite(activityPath(id, lane), JSON.stringify(safe));
 }
 function readActivity(id, lane) {
   try {
-    const parsed = JSON.parse(fs12.readFileSync(activityPath(id, lane), "utf8"));
+    const parsed = JSON.parse(fs11.readFileSync(activityPath(id, lane), "utf8"));
     if (typeof parsed.at !== "string" || typeof parsed.summary !== "string")
       return void 0;
     if (!ACTIVITY_KINDS.includes(parsed.kind))
@@ -2865,7 +2627,7 @@ var init_activity = __esm({
 });
 
 // packages/core/dist/status.js
-import * as fs13 from "node:fs";
+import * as fs12 from "node:fs";
 function isVerb(v) {
   return VERBS.includes(v);
 }
@@ -2922,7 +2684,7 @@ function appendStatus(id, lane, verb, note, at, waiting, reported = false) {
     ...extra,
     ...reported ? { reported: true } : {}
   };
-  fs13.appendFileSync(statusPath(id, lane), `${JSON.stringify(entry)}
+  fs12.appendFileSync(statusPath(id, lane), `${JSON.stringify(entry)}
 `);
   if (verb === "done") {
     try {
@@ -2934,9 +2696,9 @@ function appendStatus(id, lane, verb, note, at, waiting, reported = false) {
 }
 function readStatusLog(id, lane) {
   const file = statusPath(id, lane);
-  if (!fs13.existsSync(file))
+  if (!fs12.existsSync(file))
     return [];
-  return fs13.readFileSync(file, "utf8").split("\n").filter(Boolean).flatMap((line) => {
+  return fs12.readFileSync(file, "utf8").split("\n").filter(Boolean).flatMap((line) => {
     try {
       const parsed = JSON.parse(line);
       return isVerb(parsed.verb) ? [parsed] : [];
@@ -2994,12 +2756,12 @@ var init_status = __esm({
 });
 
 // packages/core/dist/queue.js
-import * as fs14 from "node:fs";
-import * as path13 from "node:path";
-function atomicWrite3(file, content) {
+import * as fs13 from "node:fs";
+import * as path12 from "node:path";
+function atomicWrite2(file, content) {
   const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
-  fs14.writeFileSync(tmp, content);
-  fs14.renameSync(tmp, file);
+  fs13.writeFileSync(tmp, content);
+  fs13.renameSync(tmp, file);
 }
 function enqueue(d, lane = "work") {
   if (!d.id || !d.repo || !d.brief) {
@@ -3011,11 +2773,11 @@ function enqueue(d, lane = "work") {
     ...inherited?.length ? { attachments: inherited } : {},
     queuedAt: d.queuedAt ?? (/* @__PURE__ */ new Date()).toISOString()
   };
-  atomicWrite3(path13.join(laneDirs(lane).queue, `${d.id}.json`), JSON.stringify(descriptor, null, 2));
+  atomicWrite2(path12.join(laneDirs(lane).queue, `${d.id}.json`), JSON.stringify(descriptor, null, 2));
 }
 function mtimeIfPresent(file) {
   try {
-    return fs14.statSync(file).mtimeMs;
+    return fs13.statSync(file).mtimeMs;
   } catch (e) {
     if (e.code === "ENOENT")
       return void 0;
@@ -3025,22 +2787,22 @@ function mtimeIfPresent(file) {
 function pendingIds(lane) {
   const dir = laneDirs(lane).queue;
   return readDirIfPresent(dir).filter((f) => f.endsWith(".json")).flatMap((f) => {
-    const m = mtimeIfPresent(path13.join(dir, f));
+    const m = mtimeIfPresent(path12.join(dir, f));
     return m === void 0 ? [] : [{ f, m }];
   }).sort((a, b) => a.m - b.m).map(({ f }) => f.slice(0, -".json".length));
 }
 function queuedDescriptor(id, lane) {
   try {
-    return JSON.parse(fs14.readFileSync(path13.join(laneDirs(lane).queue, `${id}.json`), "utf8"));
+    return JSON.parse(fs13.readFileSync(path12.join(laneDirs(lane).queue, `${id}.json`), "utf8"));
   } catch {
     return void 0;
   }
 }
 function queuedAt(id, lane) {
-  const file = path13.join(laneDirs(lane).queue, `${id}.json`);
+  const file = path12.join(laneDirs(lane).queue, `${id}.json`);
   let stat;
   try {
-    stat = fs14.statSync(file);
+    stat = fs13.statSync(file);
   } catch {
     return void 0;
   }
@@ -3055,17 +2817,17 @@ function claimNext(lane, skip) {
       if (!d || skip(d))
         continue;
     }
-    const activeDir = path13.join(dirs.active, id);
+    const activeDir = path12.join(dirs.active, id);
     try {
-      fs14.mkdirSync(activeDir);
+      fs13.mkdirSync(activeDir);
     } catch {
       continue;
     }
     try {
-      fs14.renameSync(path13.join(dirs.queue, `${id}.json`), path13.join(activeDir, "descriptor.json"));
+      fs13.renameSync(path12.join(dirs.queue, `${id}.json`), path12.join(activeDir, "descriptor.json"));
       return id;
     } catch {
-      fs14.rmdirSync(activeDir, { recursive: true });
+      fs13.rmdirSync(activeDir, { recursive: true });
       continue;
     }
   }
@@ -3073,19 +2835,19 @@ function claimNext(lane, skip) {
 }
 function requeue(id, lane) {
   const dirs = laneDirs(lane);
-  const activeDir = path13.join(dirs.active, id);
-  fs14.renameSync(path13.join(activeDir, "descriptor.json"), path13.join(dirs.queue, `${id}.json`));
-  fs14.rmSync(activeDir, { recursive: true, force: true });
+  const activeDir = path12.join(dirs.active, id);
+  fs13.renameSync(path12.join(activeDir, "descriptor.json"), path12.join(dirs.queue, `${id}.json`));
+  fs13.rmSync(activeDir, { recursive: true, force: true });
 }
 function storedDescriptor(id, lane) {
   const dirs = laneDirs(lane);
   for (const file of [
-    path13.join(dirs.queue, `${id}.json`),
-    path13.join(dirs.active, id, "descriptor.json"),
-    path13.join(dirs.done, id, "descriptor.json")
+    path12.join(dirs.queue, `${id}.json`),
+    path12.join(dirs.active, id, "descriptor.json"),
+    path12.join(dirs.done, id, "descriptor.json")
   ]) {
     try {
-      return JSON.parse(fs14.readFileSync(file, "utf8"));
+      return JSON.parse(fs13.readFileSync(file, "utf8"));
     } catch {
     }
   }
@@ -3096,30 +2858,30 @@ function activeIds(lane) {
 }
 function complete(id, lane) {
   const dirs = laneDirs(lane);
-  fs14.renameSync(path13.join(dirs.active, id), path13.join(dirs.done, id));
+  fs13.renameSync(path12.join(dirs.active, id), path12.join(dirs.done, id));
 }
 function requestCancel(id, lane) {
-  fs14.writeFileSync(path13.join(laneDirs(lane).active, id, "cancel"), (/* @__PURE__ */ new Date()).toISOString());
+  fs13.writeFileSync(path12.join(laneDirs(lane).active, id, "cancel"), (/* @__PURE__ */ new Date()).toISOString());
 }
 function cancelQueued(id, lane) {
   const dirs = laneDirs(lane);
-  const doneDir = path13.join(dirs.done, id);
+  const doneDir = path12.join(dirs.done, id);
   try {
-    fs14.mkdirSync(doneDir);
+    fs13.mkdirSync(doneDir);
   } catch {
     return false;
   }
   try {
-    fs14.renameSync(path13.join(dirs.queue, `${id}.json`), path13.join(doneDir, "descriptor.json"));
+    fs13.renameSync(path12.join(dirs.queue, `${id}.json`), path12.join(doneDir, "descriptor.json"));
   } catch {
-    fs14.rmdirSync(doneDir, { recursive: true });
+    fs13.rmdirSync(doneDir, { recursive: true });
     return false;
   }
   appendStatus(id, lane, "failed", "cancelled before claim");
   return true;
 }
 function cancelRequested(id, lane) {
-  return fs14.existsSync(path13.join(laneDirs(lane).active, id, "cancel"));
+  return fs13.existsSync(path12.join(laneDirs(lane).active, id, "cancel"));
 }
 var init_queue = __esm({
   "packages/core/dist/queue.js"() {
@@ -3129,11 +2891,52 @@ var init_queue = __esm({
   }
 });
 
+// packages/core/dist/session-link.js
+function validSessionLink(value) {
+  if (typeof value !== "string")
+    return false;
+  if (/[\x00-\x1f\x7f]/.test(value))
+    return false;
+  return /^claude:\/\/claude\.ai\/[A-Za-z0-9_/-]+$/.test(value) || /^vscode:\/\/anthropic\.claude-code\/open\?session=[A-Za-z0-9_-]+$/.test(value) || /^codex:\/\/threads\/[A-Za-z0-9-]+$/.test(value);
+}
+function linkMismatch(link, win) {
+  if (!win)
+    return void 0;
+  const ep = win.entrypoint;
+  const bundle = win.bundleId;
+  if (link.startsWith("vscode://")) {
+    if (ep !== void 0)
+      return ep === "claude-vscode" ? void 0 : `a vscode:// link needs the VS Code extension; this session's entrypoint is ${ep}`;
+    return bundle === void 0 || VSCODE_BUNDLE_RE.test(bundle) ? void 0 : `a vscode:// link needs the VS Code extension; this session runs in ${bundle}`;
+  }
+  if (link.startsWith("claude://")) {
+    if (ep !== void 0) {
+      return ep === "cli" || ep === "claude-vscode" || ep.startsWith("sdk-") ? `a claude:// link needs the Claude desktop app's Code tab; this session's entrypoint is ${ep}` : void 0;
+    }
+    if (bundle !== void 0 && bundle !== CLAUDE_DESKTOP_BUNDLE)
+      return `a claude:// link needs the Claude desktop app; this session runs in ${bundle}`;
+    return win.termProgram === "claude-desktop" ? "a claude:// link needs the Code tab; this session runs in the Claude desktop app's terminal" : void 0;
+  }
+  if (link.startsWith("codex://")) {
+    return bundle === void 0 || bundle === CODEX_BUNDLE ? void 0 : `a codex:// link needs the Codex app; this session runs in ${bundle}`;
+  }
+  return void 0;
+}
+var VSCODE_BUNDLE_RE, CLAUDE_DESKTOP_BUNDLE, CODEX_BUNDLE;
+var init_session_link = __esm({
+  "packages/core/dist/session-link.js"() {
+    "use strict";
+    VSCODE_BUNDLE_RE = /(?:VSCode|Cursor|windsurf)/;
+    CLAUDE_DESKTOP_BUNDLE = "com.anthropic.claudefordesktop";
+    CODEX_BUNDLE = "com.openai.codex";
+  }
+});
+
 // packages/core/dist/evidence.js
-import * as fs15 from "node:fs";
+import * as fs14 from "node:fs";
 function readEvidence(id, lane) {
   try {
-    return JSON.parse(fs15.readFileSync(evidencePath(id, lane), "utf8"));
+    return JSON.parse(fs14.readFileSync(evidencePath(id, lane), "utf8"));
   } catch {
     return {};
   }
@@ -3141,8 +2944,8 @@ function readEvidence(id, lane) {
 function mergeEvidence(id, lane, patch) {
   const file = evidencePath(id, lane);
   const tmp = `${file}.tmp-${process.pid}`;
-  fs15.writeFileSync(tmp, JSON.stringify({ ...readEvidence(id, lane), ...patch }, null, 2));
-  fs15.renameSync(tmp, file);
+  fs14.writeFileSync(tmp, JSON.stringify({ ...readEvidence(id, lane), ...patch }, null, 2));
+  fs14.renameSync(tmp, file);
 }
 var init_evidence = __esm({
   "packages/core/dist/evidence.js"() {
@@ -3152,8 +2955,8 @@ var init_evidence = __esm({
 });
 
 // packages/core/dist/pushes.js
-import * as fs16 from "node:fs";
-import * as path14 from "node:path";
+import * as fs15 from "node:fs";
+import * as path13 from "node:path";
 function words(segment) {
   const out = [];
   const re = /"((?:[^"\\]|\\.)*)"|'([^']*)'|(\S+)/g;
@@ -3205,18 +3008,18 @@ function gitPushTargets(command) {
   return found ? [...new Set(targets)] : void 0;
 }
 function gitDirAt(dir) {
-  let at = path14.resolve(dir);
+  let at = path13.resolve(dir);
   for (; ; ) {
-    const dotGit = path14.join(at, ".git");
+    const dotGit = path13.join(at, ".git");
     try {
-      const stat = fs16.statSync(dotGit);
+      const stat = fs15.statSync(dotGit);
       if (stat.isDirectory())
         return dotGit;
-      const m = /^gitdir:\s*(.+)$/m.exec(fs16.readFileSync(dotGit, "utf8"));
-      return m ? path14.resolve(at, m[1].trim()) : void 0;
+      const m = /^gitdir:\s*(.+)$/m.exec(fs15.readFileSync(dotGit, "utf8"));
+      return m ? path13.resolve(at, m[1].trim()) : void 0;
     } catch {
     }
-    const up = path14.dirname(at);
+    const up = path13.dirname(at);
     if (up === at)
       return void 0;
     at = up;
@@ -3227,7 +3030,7 @@ function currentBranchAt(dir) {
   if (!gitDir)
     return void 0;
   try {
-    const m = /^ref:\s*refs\/heads\/(.+)$/m.exec(fs16.readFileSync(path14.join(gitDir, "HEAD"), "utf8"));
+    const m = /^ref:\s*refs\/heads\/(.+)$/m.exec(fs15.readFileSync(path13.join(gitDir, "HEAD"), "utf8"));
     return m ? m[1].trim() : void 0;
   } catch {
     return void 0;
@@ -3256,18 +3059,18 @@ var init_pushes = __esm({
 });
 
 // packages/core/dist/trap-names.js
-import * as fs17 from "node:fs";
-import * as path15 from "node:path";
+import * as fs16 from "node:fs";
+import * as path14 from "node:path";
 import { randomInt } from "node:crypto";
 function namesDir() {
-  return path15.join(lobstahHome(), "trap-names");
+  return path14.join(lobstahHome(), "trap-names");
 }
 function nameFile(name) {
-  return path15.join(namesDir(), `${name}.json`);
+  return path14.join(namesDir(), `${name}.json`);
 }
 function knownTrapNames() {
   try {
-    return fs17.readdirSync(namesDir()).filter((file) => file.endsWith(".json")).map((file) => file.slice(0, -5)).filter((name) => TRAP_NAME_RE.test(name)).sort();
+    return fs16.readdirSync(namesDir()).filter((file) => file.endsWith(".json")).map((file) => file.slice(0, -5)).filter((name) => TRAP_NAME_RE.test(name)).sort();
   } catch {
     return [];
   }
@@ -3276,7 +3079,7 @@ function trapIdForName(name) {
   if (!TRAP_NAME_RE.test(name))
     return void 0;
   try {
-    const id = JSON.parse(fs17.readFileSync(nameFile(name), "utf8")).trapId;
+    const id = JSON.parse(fs16.readFileSync(nameFile(name), "utf8")).trapId;
     return typeof id === "string" ? id : void 0;
   } catch {
     return void 0;
@@ -3286,7 +3089,7 @@ function trapNameForId(trapId) {
   return knownTrapNames().find((name) => trapIdForName(name) === trapId);
 }
 function reserveTrapName(trapId, requested, start = randomInt(TRAP_FIRST_WORDS.length * TRAP_LAST_WORDS.length)) {
-  fs17.mkdirSync(namesDir(), { recursive: true });
+  fs16.mkdirSync(namesDir(), { recursive: true });
   const old = knownTrapNames().find((name) => trapIdForName(name) === trapId);
   if (requested !== void 0 && !TRAP_NAME_RE.test(requested)) {
     throw new Error(`invalid trap name "${requested}" \u2014 use two lowercase words of 2\u20138 letters joined by one hyphen`);
@@ -3302,9 +3105,9 @@ function reserveTrapName(trapId, requested, start = randomInt(TRAP_FIRST_WORDS.l
     if (name === old)
       return name;
     try {
-      fs17.writeFileSync(nameFile(name), JSON.stringify({ trapId }), { flag: "wx" });
+      fs16.writeFileSync(nameFile(name), JSON.stringify({ trapId }), { flag: "wx" });
       if (old)
-        fs17.rmSync(nameFile(old), { force: true });
+        fs16.rmSync(nameFile(old), { force: true });
       return name;
     } catch (err) {
       if (err.code !== "EEXIST")
@@ -3459,22 +3262,22 @@ var init_trap_names = __esm({
 });
 
 // packages/core/dist/worktrees.js
-import * as fs18 from "node:fs";
-import * as path16 from "node:path";
+import * as fs17 from "node:fs";
+import * as path15 from "node:path";
 function worktreePath(id) {
-  return path16.join(lobstahHome(), "worktrees", id);
+  return path15.join(lobstahHome(), "worktrees", id);
 }
 function readRecord(file) {
   try {
-    const r = JSON.parse(fs18.readFileSync(file, "utf8"));
+    const r = JSON.parse(fs17.readFileSync(file, "utf8"));
     return typeof r.path === "string" ? r : void 0;
   } catch {
     return void 0;
   }
 }
 function ownerOfPath(p) {
-  const rel = path16.relative(path16.join(lobstahHome(), "worktrees"), p);
-  if (!rel || rel.startsWith("..") || path16.isAbsolute(rel))
+  const rel = path15.relative(path15.join(lobstahHome(), "worktrees"), p);
+  if (!rel || rel.startsWith("..") || path15.isAbsolute(rel))
     return void 0;
   return rel.split(/[\\/]/)[0];
 }
@@ -3487,7 +3290,7 @@ function dispatchWorktree(id, lane) {
     }
     const dirs = laneDirs(l);
     for (const dir of [dirs.active, dirs.done]) {
-      const rec = readRecord(path16.join(dir, id, "worktree.json"));
+      const rec = readRecord(path15.join(dir, id, "worktree.json"));
       if (rec) {
         const owner = rec.of ?? ownerOfPath(rec.path) ?? id;
         return { path: rec.path, owner, reused: owner !== id };
@@ -3499,7 +3302,7 @@ function dispatchWorktree(id, lane) {
 function laneOf(id) {
   for (const l of LANES) {
     const d = laneDirs(l);
-    if (fs18.existsSync(path16.join(d.queue, `${id}.json`)) || fs18.existsSync(path16.join(d.active, id)) || fs18.existsSync(path16.join(d.done, id))) {
+    if (fs17.existsSync(path15.join(d.queue, `${id}.json`)) || fs17.existsSync(path15.join(d.active, id)) || fs17.existsSync(path15.join(d.done, id))) {
       return l;
     }
   }
@@ -3519,39 +3322,39 @@ function followUpAncestors(id, lane) {
 function chainWorktree(followUp) {
   for (const id of [followUp, ...followUpAncestors(followUp)]) {
     const wt = dispatchWorktree(id, laneOf(id));
-    if (fs18.existsSync(wt.path))
+    if (fs17.existsSync(wt.path))
       return { ...wt, from: id };
   }
   return void 0;
 }
 function worktreeGitDir(wt) {
-  const dotGit = path16.join(wt, ".git");
+  const dotGit = path15.join(wt, ".git");
   try {
-    const st = fs18.statSync(dotGit);
+    const st = fs17.statSync(dotGit);
     if (st.isDirectory())
       return dotGit;
-    const m = /^gitdir:\s*(.+?)\s*$/m.exec(fs18.readFileSync(dotGit, "utf8"));
-    return m ? path16.resolve(wt, m[1]) : void 0;
+    const m = /^gitdir:\s*(.+?)\s*$/m.exec(fs17.readFileSync(dotGit, "utf8"));
+    return m ? path15.resolve(wt, m[1]) : void 0;
   } catch {
     return void 0;
   }
 }
 function worktreeLockFile(wt) {
   const gitDir = worktreeGitDir(wt);
-  return gitDir ? path16.join(gitDir, "lobstah.lock") : void 0;
+  return gitDir ? path15.join(gitDir, "lobstah.lock") : void 0;
 }
 function readWorktreeLock(wt) {
   const file = worktreeLockFile(wt);
   if (!file)
     return void 0;
   try {
-    return JSON.parse(fs18.readFileSync(file, "utf8"));
+    return JSON.parse(fs17.readFileSync(file, "utf8"));
   } catch {
     return void 0;
   }
 }
 function lockIsLive(lock) {
-  return fs18.existsSync(path16.join(laneDirs(lock.lane).active, lock.id));
+  return fs17.existsSync(path15.join(laneDirs(lock.lane).active, lock.id));
 }
 function worktreeHolder(wt) {
   const lock = readWorktreeLock(wt);
@@ -3564,7 +3367,7 @@ function acquireWorktreeLock(wt, id, lane) {
     return { id: "(no git dir)", lane, pid: 0, at: mine.at };
   for (let attempt = 0; attempt < 3; attempt++) {
     try {
-      fs18.writeFileSync(file, JSON.stringify(mine, null, 2), { flag: "wx" });
+      fs17.writeFileSync(file, JSON.stringify(mine, null, 2), { flag: "wx" });
       return void 0;
     } catch (err) {
       if (err.code !== "EEXIST")
@@ -3572,7 +3375,7 @@ function acquireWorktreeLock(wt, id, lane) {
     }
     let raw;
     try {
-      raw = fs18.readFileSync(file, "utf8");
+      raw = fs17.readFileSync(file, "utf8");
     } catch {
       continue;
     }
@@ -3583,14 +3386,14 @@ function acquireWorktreeLock(wt, id, lane) {
       held2 = void 0;
     }
     if (held2?.id === id) {
-      fs18.writeFileSync(file, JSON.stringify(mine, null, 2));
+      fs17.writeFileSync(file, JSON.stringify(mine, null, 2));
       return void 0;
     }
     if (held2 && lockIsLive(held2))
       return held2;
     try {
-      if (fs18.readFileSync(file, "utf8") === raw)
-        fs18.rmSync(file, { force: true });
+      if (fs17.readFileSync(file, "utf8") === raw)
+        fs17.rmSync(file, { force: true });
     } catch {
     }
   }
@@ -3602,20 +3405,20 @@ function releaseWorktreeLock(wt, id) {
   if (!file)
     return;
   if (readWorktreeLock(wt)?.id === id)
-    fs18.rmSync(file, { force: true });
+    fs17.rmSync(file, { force: true });
 }
 function releaseDispatchLock(dispatchDir, id) {
-  const rec = readRecord(path16.join(dispatchDir, "worktree.json"));
+  const rec = readRecord(path15.join(dispatchDir, "worktree.json"));
   if (rec)
     releaseWorktreeLock(rec.path, id);
 }
 function keptWorktreesPath() {
-  return path16.join(lobstahHome(), "release-kept.json");
+  return path15.join(lobstahHome(), "release-kept.json");
 }
 function readKeptWorktrees() {
   try {
-    const list2 = JSON.parse(fs18.readFileSync(keptWorktreesPath(), "utf8"));
-    return Array.isArray(list2) ? list2.filter((k) => fs18.existsSync(worktreePath(k.id))) : [];
+    const list2 = JSON.parse(fs17.readFileSync(keptWorktreesPath(), "utf8"));
+    return Array.isArray(list2) ? list2.filter((k) => fs17.existsSync(worktreePath(k.id))) : [];
   } catch {
     return [];
   }
@@ -3623,12 +3426,12 @@ function readKeptWorktrees() {
 function writeKeptWorktrees(list2) {
   const file = keptWorktreesPath();
   if (list2.length === 0) {
-    fs18.rmSync(file, { force: true });
+    fs17.rmSync(file, { force: true });
     return;
   }
   const tmp = `${file}.tmp-${process.pid}`;
-  fs18.writeFileSync(tmp, JSON.stringify(list2, null, 2));
-  fs18.renameSync(tmp, file);
+  fs17.writeFileSync(tmp, JSON.stringify(list2, null, 2));
+  fs17.renameSync(tmp, file);
 }
 var LANES;
 var init_worktrees = __esm({
@@ -3642,8 +3445,8 @@ var init_worktrees = __esm({
 });
 
 // packages/core/dist/worktree-safety.js
-import * as fs19 from "node:fs";
-import * as path17 from "node:path";
+import * as fs18 from "node:fs";
+import * as path16 from "node:path";
 import { execFileSync } from "node:child_process";
 function git(dir, ...args) {
   return execFileSync("git", args, { cwd: dir, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 1e4 });
@@ -3687,22 +3490,22 @@ function removeGhostWorktree(dir) {
   const safety = inspectTrapWorktree(dir);
   if (safety.reason)
     return { ...safety, removed: false };
-  const anchor = path17.join(dir, ".lobstah-trap");
+  const anchor = path16.join(dir, ".lobstah-trap");
   let saved;
   try {
     const common = git(dir, "rev-parse", "--path-format=absolute", "--git-common-dir").trim();
     const own = git(dir, "rev-parse", "--path-format=absolute", "--git-dir").trim();
     if (common === own)
       return { ...safety, removed: false, reason: "not a linked worktree" };
-    if (fs19.existsSync(anchor)) {
-      saved = fs19.readFileSync(anchor);
-      fs19.unlinkSync(anchor);
+    if (fs18.existsSync(anchor)) {
+      saved = fs18.readFileSync(anchor);
+      fs18.unlinkSync(anchor);
     }
-    git(path17.dirname(common), "--git-dir", common, "worktree", "remove", dir);
+    git(path16.dirname(common), "--git-dir", common, "worktree", "remove", dir);
     return { ...safety, removed: true };
   } catch {
-    if (saved && fs19.existsSync(dir))
-      fs19.writeFileSync(anchor, saved);
+    if (saved && fs18.existsSync(dir))
+      fs18.writeFileSync(anchor, saved);
     return { ...safety, removed: false, reason: "git worktree remove refused" };
   }
 }
@@ -3713,20 +3516,20 @@ var init_worktree_safety = __esm({
 });
 
 // packages/core/dist/trap-start.js
-import * as fs20 from "node:fs";
-import * as path18 from "node:path";
+import * as fs19 from "node:fs";
+import * as path17 from "node:path";
 import { createHash as createHash3, randomBytes as randomBytes3, timingSafeEqual } from "node:crypto";
 function startPath(trapId) {
-  return path18.join(soakingDir(), `${trapId}.starting`);
+  return path17.join(soakingDir(), `${trapId}.starting`);
 }
 function ticketPath(trapId) {
-  return path18.join(soakingDir(), `${trapId}.ticket`);
+  return path17.join(soakingDir(), `${trapId}.ticket`);
 }
 function readReservationTicket(trapId) {
   if (!/^[0-9a-f]{8}$/.test(trapId))
     return void 0;
   try {
-    const ticket = fs20.readFileSync(ticketPath(trapId), "utf8").trim();
+    const ticket = fs19.readFileSync(ticketPath(trapId), "utf8").trim();
     return TRAP_TICKET_RE.exec(ticket)?.[1] === trapId ? ticket : void 0;
   } catch {
     return void 0;
@@ -3744,17 +3547,17 @@ function trapStartCommands(repoPath, ticket, harness) {
   return harness === "claude" || harness === "codex" ? all.filter((c) => c.harness === harness) : all;
 }
 function writeReservation(r) {
-  fs20.mkdirSync(soakingDir(), { recursive: true });
+  fs19.mkdirSync(soakingDir(), { recursive: true });
   const file = startPath(r.trapId);
   const tmp = `${file}.tmp-${process.pid}`;
-  fs20.writeFileSync(tmp, JSON.stringify(r, null, 2));
-  fs20.renameSync(tmp, file);
+  fs19.writeFileSync(tmp, JSON.stringify(r, null, 2));
+  fs19.renameSync(tmp, file);
 }
 function readReservation(trapId) {
   if (!/^[0-9a-f]{8}$/.test(trapId))
     return void 0;
   try {
-    const parsed = JSON.parse(fs20.readFileSync(startPath(trapId), "utf8"));
+    const parsed = JSON.parse(fs19.readFileSync(startPath(trapId), "utf8"));
     return typeof parsed.trapId === "string" && parsed.trapId === trapId ? parsed : void 0;
   } catch {
     return void 0;
@@ -3763,7 +3566,7 @@ function readReservation(trapId) {
 function listReservations() {
   let files;
   try {
-    files = fs20.readdirSync(soakingDir()).filter((f) => f.endsWith(".starting"));
+    files = fs19.readdirSync(soakingDir()).filter((f) => f.endsWith(".starting"));
   } catch {
     return [];
   }
@@ -3794,7 +3597,7 @@ function reserveTrap(opts) {
     ...opts.request ? { request: opts.request } : {}
   };
   writeReservation(reservation);
-  fs20.writeFileSync(ticketPath(trapId), ticket, { mode: 384 });
+  fs19.writeFileSync(ticketPath(trapId), ticket, { mode: 384 });
   postNotice({
     kind: "trap-starting",
     text: `trap ${trapLabel(reservation)} reserved for repo ${opts.repo} \u2014 starting, sign-on due by ${reservation.deadline}; address work with \`--for ${name}\``,
@@ -3818,8 +3621,8 @@ function reservationForTicket(ticket) {
 function dropReservation(trapId) {
   const r = readReservation(trapId);
   if (r)
-    fs20.rmSync(startPath(trapId), { force: true });
-  fs20.rmSync(ticketPath(trapId), { force: true });
+    fs19.rmSync(startPath(trapId), { force: true });
+  fs19.rmSync(ticketPath(trapId), { force: true });
   return r;
 }
 function withdrawReservation(trapId, by) {
@@ -3875,27 +3678,27 @@ var init_trap_start = __esm({
 });
 
 // packages/core/dist/soak.js
-import * as fs21 from "node:fs";
-import * as path19 from "node:path";
+import * as fs20 from "node:fs";
+import * as path18 from "node:path";
 import { randomBytes as randomBytes4 } from "node:crypto";
 function regPath(trapId) {
-  return path19.join(soakingDir(), `${trapId}.json`);
+  return path18.join(soakingDir(), `${trapId}.json`);
 }
-function atomicWrite4(file, content) {
+function atomicWrite3(file, content) {
   const tmp = `${file}.tmp-${process.pid}`;
-  fs21.writeFileSync(tmp, content);
-  fs21.renameSync(tmp, file);
+  fs20.writeFileSync(tmp, content);
+  fs20.renameSync(tmp, file);
 }
 function readTrapAnchor(worktree) {
   try {
-    const parsed = JSON.parse(fs21.readFileSync(path19.join(worktree, TRAP_FILE), "utf8"));
+    const parsed = JSON.parse(fs20.readFileSync(path18.join(worktree, TRAP_FILE), "utf8"));
     return typeof parsed.trapId === "string" ? parsed : void 0;
   } catch {
     return void 0;
   }
 }
 function writeTrapAnchor(worktree, anchor) {
-  atomicWrite4(path19.join(worktree, TRAP_FILE), `${JSON.stringify(anchor, null, 2)}
+  atomicWrite3(path18.join(worktree, TRAP_FILE), `${JSON.stringify(anchor, null, 2)}
 `);
 }
 function trapIdAt(worktree) {
@@ -3915,12 +3718,12 @@ function newTrapId() {
 function findAnchored(root, match) {
   let names;
   try {
-    names = fs21.readdirSync(root);
+    names = fs20.readdirSync(root);
   } catch {
     return void 0;
   }
   for (const name of names.sort()) {
-    const dir = path19.join(root, name);
+    const dir = path18.join(root, name);
     const anchor = readTrapAnchor(dir);
     if (anchor && match(anchor))
       return dir;
@@ -3935,7 +3738,7 @@ function anchoredWorktree(root, trapId) {
 }
 function readTrap(trapId) {
   try {
-    return JSON.parse(fs21.readFileSync(regPath(trapId), "utf8"));
+    return JSON.parse(fs20.readFileSync(regPath(trapId), "utf8"));
   } catch {
     return void 0;
   }
@@ -3976,7 +3779,7 @@ function unknownTrapMessage(address) {
 }
 function listTraps() {
   try {
-    return fs21.readdirSync(soakingDir()).filter((f) => f.endsWith(".json")).map((f) => JSON.parse(fs21.readFileSync(path19.join(soakingDir(), f), "utf8"))).filter((r) => typeof r.trapId === "string");
+    return fs20.readdirSync(soakingDir()).filter((f) => f.endsWith(".json")).map((f) => JSON.parse(fs20.readFileSync(path18.join(soakingDir(), f), "utf8"))).filter((r) => typeof r.trapId === "string");
   } catch {
     return [];
   }
@@ -4031,12 +3834,12 @@ function signOnTrap(opts) {
     ...sameSession && prior.titleSet ? { titleSet: prior.titleSet, titleSetAt: prior.titleSetAt } : {},
     ...sameSession && prior.titlePending ? { titlePending: prior.titlePending } : {}
   };
-  atomicWrite4(regPath(trapId), JSON.stringify(reg, null, 2));
+  atomicWrite3(regPath(trapId), JSON.stringify(reg, null, 2));
   releaseSignedOff(trapId);
   if (!prior) {
     postNotice({
       kind: "trap-signed-on",
-      text: `trap ${trapLabel(reg)} signed on (${opts.harness}, ${opts.repo ?? "no repo"}, ${path19.basename(opts.worktree)}) \u2014 address work with \`--for ${name}\``,
+      text: `trap ${trapLabel(reg)} signed on (${opts.harness}, ${opts.repo ?? "no repo"}, ${path18.basename(opts.worktree)}) \u2014 address work with \`--for ${name}\``,
       refId: trapId,
       repo: opts.repo,
       by: opts.sessionId
@@ -4046,14 +3849,14 @@ function signOnTrap(opts) {
 }
 function readSignedOff(trapId) {
   try {
-    return JSON.parse(fs21.readFileSync(signedOffPath(trapId), "utf8"));
+    return JSON.parse(fs20.readFileSync(signedOffPath(trapId), "utf8"));
   } catch {
     return void 0;
   }
 }
 function listSignedOff() {
   try {
-    return fs21.readdirSync(signedOffDir()).filter((f) => f.endsWith(".json")).flatMap((f) => {
+    return fs20.readdirSync(signedOffDir()).filter((f) => f.endsWith(".json")).flatMap((f) => {
       const s = readSignedOff(f.slice(0, -".json".length));
       return s ? [s] : [];
     });
@@ -4062,7 +3865,7 @@ function listSignedOff() {
   }
 }
 function releaseSignedOff(trapId) {
-  fs21.rmSync(signedOffPath(trapId), { force: true });
+  fs20.rmSync(signedOffPath(trapId), { force: true });
 }
 function recentlySignedOff(trapId, graceMs, now2 = Date.now()) {
   const s = readSignedOff(trapId);
@@ -4072,14 +3875,14 @@ function stowTrap(trapId, reason = "signed off", by) {
   const reg = readTrap(trapId);
   if (!reg)
     return void 0;
-  fs21.mkdirSync(signedOffDir(), { recursive: true });
-  atomicWrite4(signedOffPath(trapId), JSON.stringify({ trapId, name: reg.name, worktree: reg.worktree, at: (/* @__PURE__ */ new Date()).toISOString() }));
-  fs21.rmSync(regPath(trapId), { force: true });
-  fs21.rmSync(beatPath(trapId), { force: true });
-  fs21.rmSync(prProbePath(trapId), { force: true });
+  fs20.mkdirSync(signedOffDir(), { recursive: true });
+  atomicWrite3(signedOffPath(trapId), JSON.stringify({ trapId, name: reg.name, worktree: reg.worktree, at: (/* @__PURE__ */ new Date()).toISOString() }));
+  fs20.rmSync(regPath(trapId), { force: true });
+  fs20.rmSync(beatPath(trapId), { force: true });
+  fs20.rmSync(prProbePath(trapId), { force: true });
   postNotice({
     kind: "trap-stowed",
-    text: `trap ${trapLabel(reg)} ${reason} (${path19.basename(reg.worktree)}) \u2014 re-soaking that worktree restores the address`,
+    text: `trap ${trapLabel(reg)} ${reason} (${path18.basename(reg.worktree)}) \u2014 re-soaking that worktree restores the address`,
     refId: trapId,
     repo: reg.repo,
     by
@@ -4095,7 +3898,7 @@ function askTrapTitle(trapId, title) {
     delete next.titlePending;
   else
     next.titlePending = title;
-  atomicWrite4(regPath(trapId), JSON.stringify(next, null, 2));
+  atomicWrite3(regPath(trapId), JSON.stringify(next, null, 2));
   return next;
 }
 function countTitleReminder(trapId) {
@@ -4103,7 +3906,7 @@ function countTitleReminder(trapId) {
   if (!reg?.titlePending)
     return void 0;
   const n = (reg.titleReminders ?? 0) + 1;
-  atomicWrite4(regPath(trapId), JSON.stringify({ ...reg, titleReminders: n }, null, 2));
+  atomicWrite3(regPath(trapId), JSON.stringify({ ...reg, titleReminders: n }, null, 2));
   return n;
 }
 function confirmTrapTitle(trapId, now2 = Date.now()) {
@@ -4112,7 +3915,7 @@ function confirmTrapTitle(trapId, now2 = Date.now()) {
     return void 0;
   const { titlePending, titleReminders: _reminders, ...rest } = reg;
   const next = { ...rest, titleSet: titlePending ?? reg.titleSet ?? reg.name, titleSetAt: new Date(now2).toISOString() };
-  atomicWrite4(regPath(trapId), JSON.stringify(next, null, 2));
+  atomicWrite3(regPath(trapId), JSON.stringify(next, null, 2));
   return next;
 }
 function heartbeatTrap(trapId, opts = {}) {
@@ -4127,7 +3930,7 @@ function heartbeatTrap(trapId, opts = {}) {
     ...opts.parked ? { parkedAt: (/* @__PURE__ */ new Date()).toISOString() } : {},
     claimed: opts.claimed === null ? void 0 : opts.claimed ?? reg.claimed
   };
-  atomicWrite4(regPath(trapId), JSON.stringify(next, null, 2));
+  atomicWrite3(regPath(trapId), JSON.stringify(next, null, 2));
   if (firstPark) {
     postNotice({
       kind: "trap-listening",
@@ -4140,11 +3943,11 @@ function heartbeatTrap(trapId, opts = {}) {
   return next;
 }
 function claimPath(id, lane) {
-  return path19.join(laneDirs(lane).active, id, "claim.json");
+  return path18.join(laneDirs(lane).active, id, "claim.json");
 }
 function readSessionClaim(id, lane) {
   try {
-    return JSON.parse(fs21.readFileSync(claimPath(id, lane), "utf8"));
+    return JSON.parse(fs20.readFileSync(claimPath(id, lane), "utf8"));
   } catch {
     return void 0;
   }
@@ -4156,24 +3959,66 @@ function hasOpenCatch(reg) {
   if (!reg.claimed)
     return false;
   const lane = laneOf(reg.claimed);
-  if (!lane || !fs21.existsSync(path19.join(laneDirs(lane).active, reg.claimed)))
+  if (!lane || !fs20.existsSync(path18.join(laneDirs(lane).active, reg.claimed)))
     return false;
   const last = readStatusLog(reg.claimed, lane).at(-1)?.verb;
   return last === void 0 || !TERMINAL_VERBS.includes(last);
 }
+function unreportedTrapBait(reg) {
+  if (!hasOpenCatch(reg))
+    return void 0;
+  const id = reg.claimed;
+  const lane = laneOf(id);
+  const claim = readSessionClaim(id, lane);
+  if (!claim || claim.by !== `wt:${reg.trapId}`)
+    return void 0;
+  const log = readStatusLog(id, lane);
+  let receipt = -1;
+  for (let i = 0; i < log.length; i++) {
+    const s = log[i];
+    if (s.at === claim.at && s.note === `claimed by ${claim.by}` && !s.reported)
+      receipt = i;
+  }
+  const reports = receipt >= 0 ? log.slice(receipt + 1) : log.filter((s) => Date.parse(s.at) >= Date.parse(claim.at));
+  if (reports.some((s) => s.reported))
+    return void 0;
+  try {
+    const descriptor = JSON.parse(fs20.readFileSync(path18.join(laneDirs(lane).active, id, "descriptor.json"), "utf8"));
+    return { id, lane, descriptor, claim };
+  } catch {
+    return void 0;
+  }
+}
+function noticeIdleTrapClaims(now2 = Date.now(), graceMs = DEFAULT_SOAK.claimIdleNoticeSecs * 1e3) {
+  for (const reg of listTraps()) {
+    const bait = unreportedTrapBait(reg);
+    if (!bait || cancelRequested(bait.id, bait.lane))
+      continue;
+    const age2 = now2 - Date.parse(bait.claim.at);
+    if (!Number.isFinite(age2) || age2 < graceMs)
+      continue;
+    postNotice({
+      kind: "trap-claim-idle",
+      refId: bait.id,
+      repo: bait.descriptor.repo,
+      text: `${trapLabel(reg)} claimed ${bait.id} ${Math.floor(age2 / 1e3)}s ago but has not reported. The brief will be re-delivered at its next park; check that the session is awake.`,
+      dedupeKey: `trap-claim-idle-${bait.id}-${bait.claim.at}`
+    });
+  }
+}
 function releaseCatch(reg) {
   const id = reg.claimed;
   if (!id)
     return {};
   const lane = laneOf(id);
-  if (!lane || !fs21.existsSync(path19.join(laneDirs(lane).active, id)))
+  if (!lane || !fs20.existsSync(path18.join(laneDirs(lane).active, id)))
     return {};
   const last = readStatusLog(id, lane).at(-1)?.verb;
   if (last && TERMINAL_VERBS.includes(last)) {
     complete(id, lane);
     return { finalized: id };
   }
-  fs21.rmSync(path19.join(laneDirs(lane).active, id, "claim.json"), { force: true });
+  fs20.rmSync(path18.join(laneDirs(lane).active, id, "claim.json"), { force: true });
   if (cancelRequested(id, lane)) {
     appendStatus(id, lane, "failed", "cancelled by request; claimant gone, work preserved");
     complete(id, lane);
@@ -4195,7 +4040,7 @@ function claimBait(reg) {
     const id = claimNext(lane, (d) => !pass(d));
     if (!id)
       continue;
-    const descriptor = JSON.parse(fs21.readFileSync(path19.join(laneDirs(lane).active, id, "descriptor.json"), "utf8"));
+    const descriptor = JSON.parse(fs20.readFileSync(path18.join(laneDirs(lane).active, id, "descriptor.json"), "utf8"));
     const claim = {
       by: mine,
       sessionId: reg.sessionId,
@@ -4203,7 +4048,7 @@ function claimBait(reg) {
       worktree: reg.worktree,
       at: (/* @__PURE__ */ new Date()).toISOString()
     };
-    atomicWrite4(claimPath(id, lane), JSON.stringify(claim, null, 2));
+    atomicWrite3(claimPath(id, lane), JSON.stringify(claim, null, 2));
     appendStatus(id, lane, "working", `claimed by ${mine}`, claim.at);
     mergeEvidence(id, lane, { sessionId: reg.sessionId, harness: reg.harness, deliveredTo: mine, deliveredAt: claim.at });
     heartbeatTrap(reg.trapId, { claimed: id, parked: true });
@@ -4258,13 +4103,13 @@ function sweepGhostTraps(ttlMs, now2 = Date.now(), pausedTtlMs = 864e5) {
       }
     }
     const released = releaseCatch(reg);
-    const removal = reg.createdWorktree && fs21.existsSync(reg.worktree) ? removeGhostWorktree(reg.worktree) : void 0;
+    const removal = reg.createdWorktree && fs20.existsSync(reg.worktree) ? removeGhostWorktree(reg.worktree) : void 0;
     const catchNote = released.requeued ? ", catch requeued" : released.finalized ? ", catch finalized" : "";
     const worktreeNote = removal ? `; worktree ${removal.removed ? "removed" : "kept"}: ${reg.worktree}; branch ${removal.branch}; modified files ${removal.modifiedFiles ?? "unknown"}; unpushed commits ${removal.unpushedCommits ?? "unknown"}${removal.reason ? ` (${removal.reason})` : ""}` : "; worktree kept; re-soaking restores the same address";
     actions.push({ trapId: reg.trapId, ...released, ...pauseExpired ? { pauseExpired } : {}, ...removal ? { worktree: removal.removed ? "removed" : "kept" } : {} });
-    fs21.rmSync(regPath(reg.trapId), { force: true });
-    fs21.rmSync(beatPath(reg.trapId), { force: true });
-    fs21.rmSync(prProbePath(reg.trapId), { force: true });
+    fs20.rmSync(regPath(reg.trapId), { force: true });
+    fs20.rmSync(beatPath(reg.trapId), { force: true });
+    fs20.rmSync(prProbePath(reg.trapId), { force: true });
     postNotice({
       kind: "trap-ghosted",
       text: (pauseExpired ? `trap ${trapLabel(reg)} ghosted: its pause expired (paused on ${reg.claimed.slice(0, 8)} past --until or [soak].pausedTtlSecs, and quiet since)` : `trap ${trapLabel(reg)} ghosted (went quiet mid-watch)`) + ` \u2014 registration removed${catchNote}${worktreeNote}`,
@@ -4299,7 +4144,7 @@ function baitBrief(id, d) {
     `You are a lobstah worker session and have been assigned dispatch ${id}.`,
     "",
     "Do the work in THIS worktree on a fresh branch (branch first, never on the checked-out state directly).",
-    `Report progress with \`lobstah report ${id} working "<note>"\` at milestones, check \`lobstah inbox ${id}\` at natural checkpoints, and finish with \`lobstah report ${id} done "<note>" [--pr <url>]\` (or \`failed\`).`,
+    `Acknowledge this assignment now with \`lobstah report ${id} working "<note>"\`, then report at milestones, check \`lobstah inbox ${id}\` at natural checkpoints, and finish with \`lobstah report ${id} done "<note>" [--pr <url>]\` (or \`failed\`).`,
     "A needs-decision or blocked report queues your question to the human; the answer arrives in this dispatch's inbox.",
     `Before you wait on something outside lobstah (a human review, a PR review, a deploy), report \`lobstah report ${id} paused "<note>" --waiting-on review|pr|deploy|person|external --link <url>\`.`,
     "After EVERY report, run `lobstah soak --wait` again \u2014 it delivers inbox answers and your next assignment. Never end your turn without it unless you are signing off (`lobstah stow`).",
@@ -4311,40 +4156,40 @@ function baitBrief(id, d) {
   ].join("\n");
 }
 function beatPath(trapId) {
-  return path19.join(soakingDir(), `${trapId}.beat`);
+  return path18.join(soakingDir(), `${trapId}.beat`);
 }
 function readBeat(trapId) {
   try {
-    const parsed = JSON.parse(fs21.readFileSync(beatPath(trapId), "utf8"));
+    const parsed = JSON.parse(fs20.readFileSync(beatPath(trapId), "utf8"));
     return typeof parsed.at === "string" ? parsed : void 0;
   } catch {
     return void 0;
   }
 }
 function prProbePath(trapId) {
-  return path19.join(soakingDir(), `${trapId}.prprobe`);
+  return path18.join(soakingDir(), `${trapId}.prprobe`);
 }
 function readTrapPrProbe(trapId) {
   try {
-    const parsed = JSON.parse(fs21.readFileSync(prProbePath(trapId), "utf8"));
+    const parsed = JSON.parse(fs20.readFileSync(prProbePath(trapId), "utf8"));
     return typeof parsed.dispatch === "string" && typeof parsed.checkedAt === "string" ? parsed : void 0;
   } catch {
     return void 0;
   }
 }
 function writeTrapPrProbe(trapId, probe) {
-  atomicWrite4(prProbePath(trapId), JSON.stringify(probe));
+  atomicWrite3(prProbePath(trapId), JSON.stringify(probe));
 }
 function trapLastSeen(reg) {
   return Math.max(msOf(reg.heartbeatAt), msOf(readBeat(reg.trapId)?.at ?? ""));
 }
 function trapIdAbove(dir) {
-  let at = path19.resolve(dir);
+  let at = path18.resolve(dir);
   for (; ; ) {
     const id = trapIdAt(at);
     if (id !== void 0)
       return id;
-    const up = path19.dirname(at);
+    const up = path18.dirname(at);
     if (up === at)
       return void 0;
     at = up;
@@ -4366,7 +4211,7 @@ function beatTrap(input) {
   if (now2 - last < (input.throttleMs ?? 3e4))
     return { beat: false, reason: "throttled" };
   const at = new Date(now2).toISOString();
-  atomicWrite4(beatPath(trapId), JSON.stringify({ at, sessionId: reg.sessionId }));
+  atomicWrite3(beatPath(trapId), JSON.stringify({ at, sessionId: reg.sessionId }));
   if (!hasOpenCatch(reg))
     return { beat: true, trapId };
   const name = input.toolName || "tool";
@@ -4391,16 +4236,229 @@ var init_soak = __esm({
     init_worktrees();
     init_worktree_safety();
     init_trap_start();
+    init_config();
     TRAP_FILE = ".lobstah-trap";
     TRAP_ANCHOR_FILE = TRAP_FILE;
     TRAP_ADDRESS_RE = /\bwt:([a-z0-9][a-z0-9-]*)/g;
-    signedOffDir = () => path19.join(path19.dirname(soakingDir()), "signed-off");
-    signedOffPath = (trapId) => path19.join(signedOffDir(), `${trapId}.json`);
+    signedOffDir = () => path18.join(path18.dirname(soakingDir()), "signed-off");
+    signedOffPath = (trapId) => path18.join(signedOffDir(), `${trapId}.json`);
     TITLE_REMINDERS = 3;
     msOf = (iso) => Date.parse(iso) || 0;
   }
 });
 
+// packages/core/dist/helm.js
+import * as fs21 from "node:fs";
+import * as path19 from "node:path";
+function helmDir() {
+  return path19.join(lobstahHome(), "helm");
+}
+function relievedDir() {
+  return path19.join(helmDir(), ".relieved");
+}
+function helmPath(grounds) {
+  return path19.join(helmDir(), `${grounds}.json`);
+}
+function atomicWrite4(file, content) {
+  fs21.mkdirSync(path19.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}`;
+  fs21.writeFileSync(tmp, content);
+  fs21.renameSync(tmp, file);
+}
+function readHelm(grounds) {
+  try {
+    return JSON.parse(fs21.readFileSync(helmPath(grounds), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function listHelms() {
+  try {
+    return fs21.readdirSync(helmDir()).filter((f) => f.endsWith(".json")).map((f) => JSON.parse(fs21.readFileSync(path19.join(helmDir(), f), "utf8")));
+  } catch {
+    return [];
+  }
+}
+function helmOf(sessionId) {
+  return listHelms().find((h) => h.sessionId === sessionId);
+}
+function liveHelms(ttlMs, now2 = Date.now()) {
+  return listHelms().filter((h) => now2 - (Date.parse(h.heartbeatAt) || 0) <= ttlMs);
+}
+function helmGate(live, sessionId, grounds) {
+  if (grounds !== void 0) {
+    const holder = live.find((h) => h.grounds === grounds);
+    if (holder && holder.sessionId !== sessionId) {
+      return `grounds "${grounds}" is helmed by session ${holder.sessionId.slice(0, 8)} \u2014 its verbs are that session's alone. Run this from that session (--session), or take its helm (\`lobstah man helm --take\`).`;
+    }
+    if (holder)
+      return void 0;
+  }
+  if (live.length === 0)
+    return void 0;
+  if (sessionId !== void 0 && live.some((h) => h.sessionId === sessionId))
+    return void 0;
+  const holders = live.map((h) => `${h.grounds}=${h.sessionId.slice(0, 8)}`).join(", ");
+  return `the helm is claimed (${holders}) \u2014 this verb is reserved for the helm session. Run it there with --session <helm-session-id>, or take the helm (\`lobstah man helm --take\`).`;
+}
+function helmLabel(h) {
+  if (h.label)
+    return h.label;
+  const where = h.cwd ? path19.basename(h.cwd) : void 0;
+  if (!h.harness && !where)
+    return `session ${h.sessionId.slice(0, 8)}`;
+  return `${h.harness ?? "session"}${where ? ` @ ${where}` : ""}`;
+}
+function takeHelm(opts) {
+  const now2 = opts.now ?? Date.now();
+  const existing = readHelm(opts.grounds.name);
+  if (existing && existing.sessionId !== opts.sessionId) {
+    const fresh = now2 - (Date.parse(existing.heartbeatAt) || 0) <= opts.ttlMs;
+    if (fresh && !opts.take)
+      return { held: existing };
+    atomicWrite4(path19.join(relievedDir(), `${existing.sessionId}.json`), JSON.stringify({
+      sessionId: existing.sessionId,
+      grounds: opts.grounds.name,
+      by: opts.sessionId,
+      at: new Date(now2).toISOString()
+    }, null, 2));
+  }
+  const iso = new Date(now2).toISOString();
+  const same = existing?.sessionId === opts.sessionId;
+  const live = existing !== void 0 && now2 - (Date.parse(existing.heartbeatAt) || 0) <= opts.ttlMs;
+  const reg = {
+    sessionId: opts.sessionId,
+    grounds: opts.grounds.name,
+    repos: opts.grounds.repos,
+    signedOnAt: same ? existing.signedOnAt : iso,
+    heartbeatAt: iso,
+    // A new helm on empty grounds starts its cursor now: a notice delivered
+    // to nobody while no helm was signed on is not news. A take from a live
+    // helm, or the same session signing on again, keeps the cursor, so
+    // nothing in flight is dropped.
+    wakesFrom: same || live ? existing.wakesFrom : iso,
+    // Identity refreshes on every sign-on; a re-sign without one keeps what
+    // the registration already knows.
+    harness: opts.identity?.harness ?? (same ? existing.harness : void 0),
+    cwd: opts.identity?.cwd ?? (same ? existing.cwd : void 0),
+    host: opts.identity?.host ?? (same ? existing.host : void 0),
+    label: opts.identity?.label ?? (same ? existing.label : void 0),
+    window: opts.identity?.window ?? (same ? existing.window : void 0),
+    tookFrom: existing && existing.sessionId !== opts.sessionId ? { sessionId: existing.sessionId, at: iso } : existing?.tookFrom
+  };
+  atomicWrite4(helmPath(opts.grounds.name), JSON.stringify(reg, null, 2));
+  return { ok: reg };
+}
+function wakeFloorMs(h) {
+  return h?.wakesFrom ? Date.parse(h.wakesFrom) || 0 : 0;
+}
+function noticeStands(n) {
+  switch (n.kind) {
+    case "disk-held":
+      return readHold() !== void 0;
+    case "watch-failing":
+    case "watch-held":
+      return listWatches().some((w) => (w.key === n.refId || w.owner === `dispatch:${n.refId}`) && (n.kind === "watch-failing" ? w.failingNoticed === true : true));
+    case "trap-request":
+      return n.refId !== void 0 && isOpenRequest(n.refId);
+    case "trap-claim-idle":
+      return listTraps().some((reg) => {
+        if (reg.claimed !== n.refId)
+          return false;
+        const bait = unreportedTrapBait(reg);
+        return bait !== void 0 && !cancelRequested(bait.id, bait.lane) && Date.parse(bait.claim.at) <= Date.parse(n.at);
+      });
+    default:
+      return false;
+  }
+}
+function noticeWakes(h) {
+  const floor = wakeFloorMs(h);
+  if (floor === 0)
+    return void 0;
+  return (n) => (Date.parse(n.at) || 0) >= floor || noticeStands(n);
+}
+function relieveHelm(sessionId) {
+  const relieved = [];
+  for (const h of listHelms()) {
+    if (h.sessionId !== sessionId)
+      continue;
+    fs21.rmSync(helmPath(h.grounds), { force: true });
+    relieved.push(h.grounds);
+  }
+  fs21.rmSync(path19.join(relievedDir(), `${sessionId}.json`), { force: true });
+  return relieved;
+}
+function heartbeatHelm(sessionId, opts = {}) {
+  const reg = helmOf(sessionId);
+  if (!reg)
+    return void 0;
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const next = { ...reg, heartbeatAt: now2, ...opts.parked ? { parkedAt: now2 } : {} };
+  atomicWrite4(helmPath(reg.grounds), JSON.stringify(next, null, 2));
+  return next;
+}
+function consumeRelievedNotice(sessionId) {
+  const file = path19.join(relievedDir(), `${sessionId}.json`);
+  try {
+    const notice = JSON.parse(fs21.readFileSync(file, "utf8"));
+    fs21.rmSync(file, { force: true });
+    return notice;
+  } catch {
+    return void 0;
+  }
+}
+function groundsList(cfg) {
+  const entries = Object.entries(cfg.grounds);
+  if (entries.length === 0)
+    return [{ name: "fleet", repos: Object.keys(cfg.repos) }];
+  return entries.map(([name, g]) => ({ name, repos: g.repos }));
+}
+function groundsErrors(cfg) {
+  const errors = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (const [name, g] of Object.entries(cfg.grounds)) {
+    for (const repo of g.repos) {
+      if (cfg.repos[repo] === void 0)
+        errors.push(`grounds.${name} names unknown repo "${repo}"`);
+      const other = seen.get(repo);
+      if (other !== void 0)
+        errors.push(`repo "${repo}" is in both grounds.${other} and grounds.${name} \u2014 a repo belongs to at most one grounds`);
+      else
+        seen.set(repo, name);
+    }
+  }
+  return errors;
+}
+function resolveGrounds(cfg, name) {
+  const all = groundsList(cfg);
+  if (name === void 0) {
+    if (all.length === 1)
+      return all[0];
+    throw new Error(`multiple grounds configured \u2014 pass --grounds <${all.map((g) => g.name).join("|")}>`);
+  }
+  const found = all.find((g) => g.name === name);
+  if (!found)
+    throw new Error(`unknown grounds "${name}" (configured: ${all.map((g) => g.name).join(", ")})`);
+  return found;
+}
+var isOpenRequest;
+var init_helm = __esm({
+  "packages/core/dist/helm.js"() {
+    "use strict";
+    init_disk();
+    init_paths();
+    init_watch();
+    init_requests();
+    init_queue();
+    init_soak();
+    isOpenRequest = (id) => {
+      const r = readRequest(id);
+      return r !== void 0 && r.closedAt === void 0;
+    };
+  }
+});
+
 // packages/core/dist/inbox.js
 import * as fs22 from "node:fs";
 import * as path20 from "node:path";
@@ -5067,7 +5125,7 @@ function normalizeChecks(rollup) {
   }
   return [...latest.values()].map((v) => v.check).sort((a, b) => a.name.localeCompare(b.name));
 }
-function prStandingKinds(pr) {
+function prStandingKinds(pr, settle2) {
   if (pr.state !== "OPEN")
     return [];
   const out = [];
@@ -5081,8 +5139,11 @@ function prStandingKinds(pr) {
     out.push("pr:checks");
   if (isConflicting(pr.mergeStateStatus))
     out.push("pr:conflict");
-  if (!pr.checks.unknown && !pr.draft && !review && isMergeable(pr.mergeStateStatus) && failed === 0 && pending === 0 && (pr.reviewDecision === "APPROVED" || total > 0))
-    out.push("pr:ready");
+  if (!pr.checks.unknown && !pr.draft && !review && isMergeable(pr.mergeStateStatus) && failed === 0 && pending === 0 && (pr.reviewDecision === "APPROVED" || total > 0)) {
+    const since = Date.parse(pr.standingSince?.["pr:ready"] ?? pr.observedAt);
+    if (!settle2 || settle2.readySettleSecs === 0 || settle2.now >= since + settle2.readySettleSecs * 1e3)
+      out.push("pr:ready");
+  }
   return out;
 }
 function prReview(view) {
@@ -5438,7 +5499,7 @@ function upsertPr(pr, dispatchId) {
     const merged = { ...before ?? {}, ...pr, failingChecks: pr.failingChecks };
     const standingSince = {};
     for (const kind of prStandingKinds(merged)) {
-      standingSince[kind] = before?.standingSince?.[kind] ?? pr.observedAt;
+      standingSince[kind] = kind === "pr:ready" && before?.headSha !== pr.headSha ? pr.observedAt : before?.standingSince?.[kind] ?? pr.observedAt;
     }
     const after = {
       ...merged,
@@ -6185,6 +6246,21 @@ async function allocate(repo, id, fromRemoteBranch = repo.trunk) {
   await runSetup(repo, dir);
   return dir;
 }
+async function recoverWorktree(repo, id) {
+  const dir = worktreePath(id);
+  try {
+    if (fs31.statSync(path27.join(dir, ".git")).isFile()) {
+      const branch = await git2(dir, "symbolic-ref", "--quiet", "HEAD");
+      const root = await git2(dir, "rev-parse", "--show-toplevel");
+      const common = await git2(dir, "rev-parse", "--path-format=absolute", "--git-common-dir");
+      const mine = await git2(repo.path, "rev-parse", "--path-format=absolute", "--git-common-dir");
+      if (branch === `refs/heads/lobstah/${id}` && realpath(root) === realpath(dir) && realpath(common) === realpath(mine))
+        return dir;
+    }
+  } catch {
+  }
+  throw new Error(`unrecorded worktree at ${dir} for ${id} \u2014 ownership not proven (expected lobstah/${id} in ${repo.path}); inspect and preserve it, then relocate the conflicting checkout before retrying`);
+}
 async function runSetup(repo, dir) {
   for (const cmd of repo.setup ?? []) {
     await shell(cmd, { cwd: dir, env: { ...process.env, ...repo.env ?? {} } });
@@ -7723,17 +7799,19 @@ async function main(activeDir, lane, seams = {}) {
   });
   const wtFile = path64.join(activeDir, "worktree.json");
   let recorded;
+  let recovered = false;
   let choice;
   if (fs77.existsSync(wtFile)) {
     recorded = JSON.parse(fs77.readFileSync(wtFile, "utf8")).path;
     if (!fs77.existsSync(recorded))
       throw new Error(`recorded worktree ${recorded} is gone`);
   } else if (fs77.existsSync(worktreePath(id))) {
-    throw new Error(`unrecorded worktree already exists for ${id} \u2014 refusing to proceed`);
+    recorded = await recoverWorktree(repo, id);
+    recovered = true;
   } else if (descriptor.followUp && cfg.limits.reuseWorktree !== false) {
     choice = await deps.chooseWorktree({ id, lane, repoKey: descriptor.repo, repo, followUp: descriptor.followUp });
   }
-  const worktreeNote = choice ? choice.reuse ? `reusing worktree of ${short3(choice.from)}` : `fresh worktree (${choice.reason})` : void 0;
+  const worktreeNote = choice ? choice.reuse ? `reusing worktree of ${short3(choice.from)}` : `fresh worktree (${choice.reason})` : recovered ? "recovered own unrecorded worktree" : void 0;
   const firstModel = modelForHarness(plan.harness, resolved.model);
   const firstNote = [
     wake ? `woke from pause: ${wake}` : attempts > 1 ? `attempt ${attempts}` : void 0,
@@ -7752,7 +7830,13 @@ async function main(activeDir, lane, seams = {}) {
   let cwd;
   if (recorded) {
     cwd = recorded;
-    acquireWorktreeLock(cwd, id, lane);
+    const held = acquireWorktreeLock(cwd, id, lane);
+    if (held)
+      throw new Error(`worktree at ${cwd} is in use by ${held.id} \u2014 wait for that dispatch to release it before retrying`);
+    if (recovered) {
+      await deps.prepareReuse(repo, cwd);
+      fs77.writeFileSync(wtFile, JSON.stringify({ path: cwd }, null, 2));
+    }
   } else if (choice?.reuse) {
     cwd = choice.path;
     const { setupRan } = await deps.prepareReuse(repo, cwd);
@@ -8693,6 +8777,7 @@ function tick(log = () => {
   for (const t of bounceExpiredSignOffs(signOffGraceMs))
     log(`trap wt:${t} did not re-soak within the sign-off grace \u2014 its messages bounced to the helm`);
   noticeOrphanedBait(Date.now(), signOffGraceMs);
+  noticeIdleTrapClaims(now2, cfg.soak.claimIdleNoticeSecs * 1e3);
   const workSkip = daemonSkip(listTraps(), cfg.soak.deferSecs * 1e3);
   const choreSkip = (d) => d.for !== void 0 && (!d.systemRepair?.trapWaitUntil || Date.now() < Date.parse(d.systemRepair.trapWaitUntil));
   const skipFor = (lane) => lane === "work" ? workSkip : choreSkip;
@@ -10379,8 +10464,7 @@ function removeAck(key) {
 }
 var sha2 = (v) => createHash7("sha1").update(JSON.stringify(v)).digest("hex").slice(0, 16);
 function prStateHash(pr) {
-  const readySince = pr.standingSince?.["pr:ready"];
-  if (readySince) return sha2({ "pr:ready": readySince });
+  if (prStandingKinds(pr).includes("pr:ready")) return prReadyStateHash(pr.headSha);
   return sha2({
     headSha: pr.headSha,
     state: pr.state,
@@ -10393,15 +10477,18 @@ function prStateHash(pr) {
     repair: pr.repair ? { headSha: pr.repair.headSha, kind: pr.repair.kind, status: pr.repair.status, reason: pr.repair.reason } : void 0
   });
 }
+var prReadyStateHash = (headSha) => sha2({ "pr:ready": headSha });
 function currentAck(key, stateHash) {
   const a = readAck(key);
   return a && a.stateHash === stateHash ? a : void 0;
 }
 function pruneStaleAcks(standing) {
-  const hashes = new Map(standing.map((s) => [s.key, s.stateHash]));
+  const items = new Map(standing.map((s) => [s.key, s]));
   const pruned = [];
   for (const a of listAcks()) {
-    const h = hashes.get(a.key);
+    const item = items.get(a.key);
+    if (a.kind === "pr:ready" && item?.headSha && a.stateHash === prReadyStateHash(item.headSha)) continue;
+    const h = item?.stateHash;
     if (h !== void 0 && h !== a.stateHash && removeAck(a.key)) pruned.push(a.key);
   }
   return pruned;
@@ -11578,7 +11665,7 @@ function prAttention(now2, observed = observedPrs(), cfg = loadConfig()) {
   );
   const out = [];
   for (const { id, lane, pr, dispatch } of observed) {
-    const kinds = prKinds(pr).filter(
+    const kinds = prKinds(pr, { readySettleSecs: cfg.readySettleSecs, now: now2 }).filter(
       (kind) => kind !== "pr:ready" || !readyBlockedByStack(
         pr,
         observed.map((x) => x.pr)
@@ -11594,7 +11681,8 @@ function prAttention(now2, observed = observedPrs(), cfg = loadConfig()) {
       if (!human.show) continue;
       const repairCannotAct = human.reason !== void 0 && !["auto-repair is off", "not owned by lobstah", "no active PR watch"].includes(human.reason);
       if (!repairCannotAct && onTheHook(kind, chain, { reviewRounds, watchFollowUp })) continue;
-      const standingSince = pr.standingSince?.[kind] ?? pr.observedAt;
+      const conditionSince = pr.standingSince?.[kind] ?? pr.observedAt;
+      const standingSince = kind === "pr:ready" ? new Date(Date.parse(conditionSince) + cfg.readySettleSecs * 1e3).toISOString() : conditionSince;
       out.push({
         kind,
         key: ref?.key ?? pr.url,
@@ -12325,6 +12413,7 @@ function renderDigest(d) {
 }
 
 // apps/cli/src/charter.ts
+var HELM_REMINDER = "Helm reminder: any question or choice for the human goes on a card with lobstah man ask, not only in chat.";
 function charter(g) {
   const repos = g.repos.length > 0 ? g.repos.join(", ") : "(no repos configured)";
   return `the helm charter \u2014 grounds "${g.name}" (${repos})
@@ -12335,6 +12424,7 @@ Role:
 - Triage incoming work. Dispatch it. Review each catch. Decide requeue or cancel.
 - Do not do the work yourself. Write a self-contained brief and dispatch it.
 - Answer a worker's question when you can decide. Send the answer. Ask the human with \`lobstah man ask\` when the choice is theirs.
+- ${HELM_REMINDER}
 
 Fences:
 - The daemon claims, spawns, and restarts workers. Do not supervise a running catch.
@@ -16612,7 +16702,7 @@ var COMMANDS = {
   "man:init": { flags: { "--shared": {}, "--global": {}, "--marker": {} } },
   "man:haul": { flags: { "--timeout": { value: "<secs>" }, "--park": {} } },
   "man:brief": { flags: {} },
-  hook: { flags: {}, subverbs: ["session-start", "stop", "post-tool-use", "session-end"], maxPositionals: 1 },
+  hook: { flags: {}, subverbs: ["session-start", "user-prompt-submit", "stop", "post-tool-use", "session-end"], maxPositionals: 1 },
   "man:file": {
     flags: { "--attach": { value: "<file>", repeatable: true }, "--title": { value: "<text>" }, "--grounds": { value: "<name>" }, "--session": { value: "<id>" } },
     positionals: "<file.md>"
@@ -16770,7 +16860,8 @@ Stores the answer; the helm's man wait receives it as decision-answer.`,
   "man:brief": `SessionStart-hook entry point: announce the session id and fleet state into
 the conversation.`,
   hook: `The plugin hook entry points. Each detects the session's role (helm, trap, or
-neither): session-start runs man brief, stop runs man haul (--park, --timeout),
+neither): session-start runs man brief, user-prompt-submit adds a helm card reminder,
+stop runs man haul (--park, --timeout),
 post-tool-use runs soak beat, session-end runs stow --quiet. The older commands
 stay as aliases.`,
   __runner: `Internal: run one dispatch inside the compiled binary (the daemon re-execs
@@ -17008,7 +17099,7 @@ lobstah man (orchestrator sessions \u2014 bare \`lobstah man\` prints the manual
                                   ~/.claude/settings.json with --global (any
                                   directory with a .lobstah-man file then
                                   parks); --marker touches .lobstah-man.
-  hook session-start|stop|post-tool-use|session-end
+  hook session-start|user-prompt-submit|stop|post-tool-use|session-end
                                   the plugin hook entry points: each
                                   detects the session's role (helm, trap,
                                   or neither). session-start = man brief,
@@ -17156,8 +17247,10 @@ async function soakPark(trapId, timeout, plain = false) {
         );
         return "woke";
       }
-      if (unhandled(id, lane).length > 0) {
-        block(`New instruction for your dispatch ${id} \u2014 read it with \`lobstah inbox ${id}\`, act on it, and keep reporting.`);
+      const pending = unreportedTrapBait(reg);
+      const instruction = unhandled(id, lane).length > 0 ? `New instruction for your dispatch ${id} \u2014 read it with \`lobstah inbox ${id}\`, act on it, and keep reporting.` : void 0;
+      if (pending || instruction) {
+        block([instruction, pending ? baitBrief(id, pending.descriptor) : void 0].filter(Boolean).join("\n\n"));
         return "woke";
       }
     } else {
@@ -17354,6 +17447,16 @@ var HOOK_COMMANDS = {
 };
 async function mainCli() {
   let [cmd, ...args] = process.argv.slice(2);
+  if (cmd === "hook" && args[0] === "user-prompt-submit") {
+    try {
+      const hook = readHookStdin();
+      if (hook?.session_id && !trapBySession(hook.session_id) && helmOf(hook.session_id)) {
+        console.log(JSON.stringify({ hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: HELM_REMINDER } }));
+      }
+    } catch {
+    }
+    return;
+  }
   if (cmd === "soak" && args[0] === "beat" || cmd === "hook" && args[0] === "post-tool-use") {
     runBeat();
     return;