lobstah 0.2.1 → 0.3.1

package/dist/main.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
 // apps/cli/src/main.ts
-import * as fs25 from "node:fs";
+import * as fs28 from "node:fs";
 import * as os6 from "node:os";
-import * as path19 from "node:path";
+import * as path22 from "node:path";
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { spawnSync as spawnSync5 } from "node:child_process";
+import { spawnSync as spawnSync6 } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/core/dist/types.js
@@ -39,6 +39,10 @@ function ensureLayout() {
   }
   fs.mkdirSync(path.join(lobstahHome(), "worktrees"), { recursive: true });
   fs.mkdirSync(path.join(lobstahHome(), "watches"), { recursive: true });
+  fs.mkdirSync(path.join(lobstahHome(), "soaking"), { recursive: true });
+}
+function soakingDir() {
+  return path.join(lobstahHome(), "soaking");
 }
 function statusPath(id, lane) {
   return path.join(laneDirs(lane).state, `${id}.status`);
@@ -71,9 +75,21 @@ function pendingIds(lane) {
   const dir = laneDirs(lane).queue;
   return fs2.readdirSync(dir).filter((f) => f.endsWith(".json")).map((f) => ({ f, m: fs2.statSync(path2.join(dir, f)).mtimeMs })).sort((a, b) => a.m - b.m).map(({ f }) => f.slice(0, -".json".length));
 }
-function claimNext(lane) {
+function queuedDescriptor(id, lane) {
+  try {
+    return JSON.parse(fs2.readFileSync(path2.join(laneDirs(lane).queue, `${id}.json`), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function claimNext(lane, skip) {
   const dirs = laneDirs(lane);
   for (const id of pendingIds(lane)) {
+    if (skip) {
+      const d = queuedDescriptor(id, lane);
+      if (!d || skip(d))
+        continue;
+    }
     const activeDir = path2.join(dirs.active, id);
     try {
       fs2.mkdirSync(activeDir);
@@ -90,9 +106,19 @@ function claimNext(lane) {
   }
   return null;
 }
+function requeue(id, lane) {
+  const dirs = laneDirs(lane);
+  const activeDir = path2.join(dirs.active, id);
+  fs2.renameSync(path2.join(activeDir, "descriptor.json"), path2.join(dirs.queue, `${id}.json`));
+  fs2.rmSync(activeDir, { recursive: true, force: true });
+}
 function activeIds(lane) {
   return fs2.readdirSync(laneDirs(lane).active).filter((f) => !f.startsWith("."));
 }
+function complete(id, lane) {
+  const dirs = laneDirs(lane);
+  fs2.renameSync(path2.join(dirs.active, id), path2.join(dirs.done, id));
+}
 function requestCancel(id, lane) {
   fs2.writeFileSync(path2.join(laneDirs(lane).active, id, "cancel"), (/* @__PURE__ */ new Date()).toISOString());
 }
@@ -845,6 +871,10 @@ function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
 }
 
 // packages/core/dist/config.js
+var DEFAULT_SOAK = {
+  deferSecs: 90,
+  ttlSecs: 1800
+};
 var DEFAULT_LIMITS = {
   maxConcurrent: 2,
   choreConcurrent: 1,
@@ -879,6 +909,7 @@ function loadConfig() {
     repos,
     harness: raw.harness ?? {},
     limits: { ...DEFAULT_LIMITS, ...raw.limits ?? {} },
+    soak: { ...DEFAULT_SOAK, ...raw.soak ?? {} },
     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
@@ -901,6 +932,9 @@ function toonTable(name, rows, cols) {
     return header;
   return [header, ...rows.map((r) => `  ${cols.map((c) => cell(r[c])).join(",")}`)].join("\n");
 }
+function toonHelp(lines) {
+  return [`help[${lines.length}]:`, ...lines.map((l) => `  ${l}`)].join("\n");
+}
 
 // packages/core/dist/version.js
 import * as fs8 from "node:fs";
@@ -1142,6 +1176,158 @@ function markFollowUp(key, followUpId, deliveredThrough) {
     writeWatch(w);
 }
 
+// packages/core/dist/soak.js
+import * as fs11 from "node:fs";
+import * as path7 from "node:path";
+function regPath(sessionId) {
+  return path7.join(soakingDir(), `${sessionId}.json`);
+}
+function atomicWrite2(file, content) {
+  const tmp = `${file}.tmp-${process.pid}`;
+  fs11.writeFileSync(tmp, content);
+  fs11.renameSync(tmp, file);
+}
+function signOnSoak(reg) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const prior = readSoak(reg.sessionId);
+  const full = {
+    ...reg,
+    signedOnAt: prior?.signedOnAt ?? now,
+    heartbeatAt: now,
+    claimed: prior?.claimed
+  };
+  atomicWrite2(regPath(reg.sessionId), JSON.stringify(full, null, 2));
+  return full;
+}
+function readSoak(sessionId) {
+  try {
+    return JSON.parse(fs11.readFileSync(regPath(sessionId), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function listSoaking() {
+  try {
+    return fs11.readdirSync(soakingDir()).filter((f) => f.endsWith(".json")).map((f) => JSON.parse(fs11.readFileSync(path7.join(soakingDir(), f), "utf8")));
+  } catch {
+    return [];
+  }
+}
+function stowSoak(sessionId) {
+  const reg = readSoak(sessionId);
+  if (!reg)
+    return void 0;
+  fs11.rmSync(regPath(sessionId), { force: true });
+  return reg;
+}
+function heartbeatSoak(sessionId, patch = {}) {
+  const reg = readSoak(sessionId);
+  if (!reg)
+    return void 0;
+  const next = { ...reg, ...patch, heartbeatAt: (/* @__PURE__ */ new Date()).toISOString() };
+  atomicWrite2(regPath(sessionId), JSON.stringify(next, null, 2));
+  return next;
+}
+function claimPath(id, lane) {
+  return path7.join(laneDirs(lane).active, id, "claim.json");
+}
+function readSessionClaim(id, lane) {
+  try {
+    return JSON.parse(fs11.readFileSync(claimPath(id, lane), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function addressedSession(d) {
+  return d.for?.startsWith("session:") ? d.for.slice("session:".length) : void 0;
+}
+function hasOpenCatch(reg) {
+  if (!reg.claimed)
+    return false;
+  if (!fs11.existsSync(path7.join(laneDirs("work").active, reg.claimed)))
+    return false;
+  const last = readStatusLog(reg.claimed, "work").at(-1)?.verb;
+  return last === void 0 || !TERMINAL_VERBS.includes(last);
+}
+function releaseCatch(reg) {
+  if (!hasOpenCatch(reg))
+    return {};
+  const id = reg.claimed;
+  fs11.rmSync(path7.join(laneDirs("work").active, id, "claim.json"), { force: true });
+  if (cancelRequested(id, "work")) {
+    appendStatus(id, "work", "failed", "cancelled by request; claimant gone, work preserved");
+    complete(id, "work");
+    return { finalized: id };
+  }
+  requeue(id, "work");
+  return { requeued: id };
+}
+function claimBait(reg) {
+  if (hasOpenCatch(reg))
+    return null;
+  const mine = `session:${reg.sessionId}`;
+  const takeable = (d) => {
+    if (d.for === mine)
+      return true;
+    if (d.for !== void 0)
+      return false;
+    return reg.repo !== void 0 && d.repo === reg.repo;
+  };
+  for (const pass of [(d) => d.for === mine, takeable]) {
+    const id = claimNext("work", (d) => !pass(d));
+    if (!id)
+      continue;
+    const descriptor = JSON.parse(fs11.readFileSync(path7.join(laneDirs("work").active, id, "descriptor.json"), "utf8"));
+    const claim = { by: mine, harness: reg.harness, worktree: reg.worktree, at: (/* @__PURE__ */ new Date()).toISOString() };
+    atomicWrite2(claimPath(id, "work"), JSON.stringify(claim, null, 2));
+    mergeEvidence(id, "work", { sessionId: reg.sessionId });
+    heartbeatSoak(reg.sessionId, { claimed: id });
+    return { id, descriptor };
+  }
+  return null;
+}
+var msOf = (iso) => Date.parse(iso) || 0;
+function soakReady(reg, deferMs, now = Date.now()) {
+  return now - msOf(reg.heartbeatAt) <= deferMs && !hasOpenCatch(reg);
+}
+function soakSkip(soaking, deferMs, now = Date.now()) {
+  return (d) => {
+    const to = addressedSession(d);
+    if (to !== void 0)
+      return soaking.some((r) => r.sessionId === to);
+    return soaking.some((r) => r.repo === d.repo && soakReady(r, deferMs, now));
+  };
+}
+function sweepGhostTraps(ttlMs, now = Date.now()) {
+  const actions = [];
+  for (const reg of listSoaking()) {
+    if (now - msOf(reg.heartbeatAt) <= ttlMs)
+      continue;
+    if (hasOpenCatch(reg)) {
+      const lastReport = readStatusLog(reg.claimed, "work").at(-1)?.at;
+      if (lastReport && now - msOf(lastReport) <= ttlMs)
+        continue;
+      const released = releaseCatch(reg);
+      actions.push({ sessionId: reg.sessionId, requeued: released.requeued ?? released.finalized });
+    } else {
+      actions.push({ sessionId: reg.sessionId });
+    }
+    fs11.rmSync(regPath(reg.sessionId), { force: true });
+  }
+  return actions;
+}
+function baitBrief(id, d) {
+  return [
+    `You are a soaking trap and caught bait: dispatch ${id}.`,
+    "",
+    "Work it 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\`).`,
+    "The brief:",
+    "",
+    d.brief
+  ].join("\n");
+}
+
 // packages/supervisor/dist/liveness.js
 import { execFileSync } from "node:child_process";
 function classify(input) {
@@ -1200,26 +1386,26 @@ function killGroup(pid, signal = "SIGTERM") {
 }
 
 // packages/supervisor/dist/daemon.js
-import * as fs12 from "node:fs";
+import * as fs13 from "node:fs";
 import * as os3 from "node:os";
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 import { createRequire as createRequire2 } from "node:module";
 import { fileURLToPath } from "node:url";
 
 // packages/supervisor/dist/notify.js
-import * as fs11 from "node:fs";
-import * as path7 from "node:path";
+import * as fs12 from "node:fs";
+import * as path8 from "node:path";
 import { spawn } from "node:child_process";
 var DEFAULT_NOTIFY_VERBS = ["needs-decision", "blocked", "done", "failed"];
 function cursorPath(id, lane) {
-  return path7.join(laneDirs(lane).state, `${id}.notified`);
+  return path8.join(laneDirs(lane).state, `${id}.notified`);
 }
 function pendingNotifications(id, lane, verbs = DEFAULT_NOTIFY_VERBS, sinceMs = 0) {
   const log = readStatusLog(id, lane);
   let cursor;
   try {
-    cursor = Number(fs11.readFileSync(cursorPath(id, lane), "utf8")) || 0;
+    cursor = Number(fs12.readFileSync(cursorPath(id, lane), "utf8")) || 0;
   } catch {
     cursor = void 0;
   }
@@ -1229,13 +1415,13 @@ function pendingNotifications(id, lane, verbs = DEFAULT_NOTIFY_VERBS, sinceMs =
   if (cursor === void 0 && sinceMs > 0) {
     fresh = fresh.filter((e) => Date.parse(e.at) >= sinceMs);
   }
-  fs11.writeFileSync(cursorPath(id, lane), String(log.length));
+  fs12.writeFileSync(cursorPath(id, lane), String(log.length));
   return fresh.filter((e) => verbs.includes(e.verb)).map((entry) => ({ id, lane, entry }));
 }
 function notifiableIds(lane, maxAgeMs = 48 * 36e5) {
   const dir = laneDirs(lane).state;
   const cutoff = Date.now() - maxAgeMs;
-  return fs11.readdirSync(dir).filter((f) => f.endsWith(".status")).filter((f) => fs11.statSync(path7.join(dir, f)).mtimeMs > cutoff).map((f) => f.slice(0, -".status".length));
+  return fs12.readdirSync(dir).filter((f) => f.endsWith(".status")).filter((f) => fs12.statSync(path8.join(dir, f)).mtimeMs > cutoff).map((f) => f.slice(0, -".status".length));
 }
 function execNotify(command, ev, log = () => {
 }) {
@@ -1265,11 +1451,11 @@ function captureWaitBaseline() {
   return lengths;
 }
 function attnCursorPath(id, lane) {
-  return path7.join(laneDirs(lane).state, `${id}.attn`);
+  return path8.join(laneDirs(lane).state, `${id}.attn`);
 }
 function readAttnCursor(file) {
   try {
-    const parsed = JSON.parse(fs11.readFileSync(file, "utf8"));
+    const parsed = JSON.parse(fs12.readFileSync(file, "utf8"));
     return { seen: parsed.seen ?? 0, at: parsed.at ?? 0 };
   } catch {
     return { seen: 0, at: 0 };
@@ -1295,7 +1481,7 @@ function attentionNow(consume = true, remindMs = 15 * 6e4, now = Date.now()) {
         continue;
       out.push({ id, lane, entry });
       if (consume)
-        fs11.writeFileSync(file, JSON.stringify({ seen: Math.max(cursor.seen, index + 1), at: now }));
+        fs12.writeFileSync(file, JSON.stringify({ seen: Math.max(cursor.seen, index + 1), at: now }));
     }
   }
   return out;
@@ -1330,33 +1516,33 @@ function runnerEntry() {
 }
 function readRunnerInfo(dir) {
   try {
-    return JSON.parse(fs12.readFileSync(path8.join(dir, "runner.json"), "utf8"));
+    return JSON.parse(fs13.readFileSync(path9.join(dir, "runner.json"), "utf8"));
   } catch {
     return void 0;
   }
 }
 function listActive(lane) {
   const dir = laneDirs(lane).active;
-  return fs12.readdirSync(dir).filter((f) => !f.startsWith(".")).map((id) => {
-    const d = path8.join(dir, id);
+  return fs13.readdirSync(dir).filter((f) => !f.startsWith(".")).map((id) => {
+    const d = path9.join(dir, id);
     return { id, lane, dir: d, runner: readRunnerInfo(d) };
   });
 }
 function finalize(st) {
   try {
-    fs12.renameSync(st.dir, path8.join(laneDirs(st.lane).done, st.id));
+    fs13.renameSync(st.dir, path9.join(laneDirs(st.lane).done, st.id));
   } catch {
   }
 }
 function spawnRunner(st, opts) {
   let nudge = opts.nudge;
-  const handoffFile = path8.join(st.dir, "handoff");
-  if (!nudge && fs12.existsSync(handoffFile)) {
-    nudge = fs12.readFileSync(handoffFile, "utf8");
-    fs12.unlinkSync(handoffFile);
+  const handoffFile = path9.join(st.dir, "handoff");
+  if (!nudge && fs13.existsSync(handoffFile)) {
+    nudge = fs13.readFileSync(handoffFile, "utf8");
+    fs13.unlinkSync(handoffFile);
   }
-  const logPath = path8.join(laneDirs(st.lane).state, `${st.id}.runner.log`);
-  const log = fs12.openSync(logPath, "a");
+  const logPath = path9.join(laneDirs(st.lane).state, `${st.id}.runner.log`);
+  const log = fs13.openSync(logPath, "a");
   const child = spawn2(process.execPath, [runnerEntry(), st.dir, st.lane], {
     detached: true,
     stdio: ["ignore", log, log],
@@ -1367,7 +1553,7 @@ function spawnRunner(st, opts) {
       ...nudge ? { LOBSTAH_NUDGE: nudge } : {}
     }
   });
-  fs12.closeSync(log);
+  fs13.closeSync(log);
   child.unref();
   const info = {
     pid: child.pid ?? -1,
@@ -1375,27 +1561,35 @@ function spawnRunner(st, opts) {
     processStartTime: child.pid ? processStartTime(child.pid) : void 0,
     attempts: opts.attempts
   };
-  fs12.writeFileSync(path8.join(st.dir, "runner.json"), JSON.stringify(info, null, 2));
+  fs13.writeFileSync(path9.join(st.dir, "runner.json"), JSON.stringify(info, null, 2));
 }
 function sessionOf(st) {
   try {
-    const ev = JSON.parse(fs12.readFileSync(path8.join(laneDirs(st.lane).state, `${st.id}.evidence`), "utf8"));
+    const ev = JSON.parse(fs13.readFileSync(path9.join(laneDirs(st.lane).state, `${st.id}.evidence`), "utf8"));
     return ev.sessionId;
   } catch {
     return void 0;
   }
 }
 function reconcileOne(st, cfg, log) {
-  const hasDescriptor = fs12.existsSync(path8.join(st.dir, "descriptor.json"));
+  const hasDescriptor = fs13.existsSync(path9.join(st.dir, "descriptor.json"));
   if (!hasDescriptor) {
-    const age = Date.now() - fs12.statSync(st.dir).mtimeMs;
+    const age = Date.now() - fs13.statSync(st.dir).mtimeMs;
     if (age > 5 * 6e4)
-      fs12.rmSync(st.dir, { recursive: true, force: true });
+      fs13.rmSync(st.dir, { recursive: true, force: true });
     return;
   }
   const statusLog = readStatusLog(st.id, st.lane);
   const lastVerb = statusLog.at(-1)?.verb;
   const alive = st.runner ? pidAlive(st.runner.pid, st.runner.processStartTime) : void 0;
+  const sessionClaim = readSessionClaim(st.id, st.lane);
+  if (sessionClaim) {
+    if (lastVerb === "done" || lastVerb === "failed") {
+      finalize(st);
+      log(`${st.id}: ${lastVerb} (claimed by ${sessionClaim.by}), finalized`);
+    }
+    return;
+  }
   if (cancelRequested(st.id, st.lane)) {
     if (st.runner && alive) {
       log(`${st.id}: cancel requested, killing group ${st.runner.pid}`);
@@ -1474,16 +1668,16 @@ function writeHeartbeat(cfg) {
     heartbeat: (/* @__PURE__ */ new Date()).toISOString()
   };
   const tmp = `${executorPath()}.tmp`;
-  fs12.writeFileSync(tmp, JSON.stringify(payload, null, 2));
-  fs12.renameSync(tmp, executorPath());
+  fs13.writeFileSync(tmp, JSON.stringify(payload, null, 2));
+  fs13.renameSync(tmp, executorPath());
 }
 function pruneChores(cfg) {
   const dir = laneDirs("chore").done;
   const cutoff = Date.now() - cfg.limits.choreRetentionDays * 864e5;
-  for (const id of fs12.readdirSync(dir)) {
-    const p = path8.join(dir, id);
-    if (fs12.statSync(p).mtimeMs < cutoff)
-      fs12.rmSync(p, { recursive: true, force: true });
+  for (const id of fs13.readdirSync(dir)) {
+    const p = path9.join(dir, id);
+    if (fs13.statSync(p).mtimeMs < cutoff)
+      fs13.rmSync(p, { recursive: true, force: true });
   }
 }
 var daemonStartedAt = Date.now();
@@ -1492,6 +1686,10 @@ function tick(log = () => {
   const cfg = loadConfig();
   ensureLayout();
   writeHeartbeat(cfg);
+  for (const action of sweepGhostTraps(cfg.soak.ttlSecs * 1e3)) {
+    log(`ghost trap ${action.sessionId.slice(0, 8)} swept` + (action.requeued ? ` \u2014 bait ${action.requeued} back in the queue` : ""));
+  }
+  const workSkip = soakSkip(listSoaking(), cfg.soak.deferSecs * 1e3);
   for (const lane of ["chore", "work"]) {
     const active = listActive(lane);
     for (const st of active)
@@ -1499,7 +1697,7 @@ function tick(log = () => {
     const ceiling = lane === "work" ? cfg.limits.maxConcurrent : cfg.limits.choreConcurrent;
     let inFlight = listActive(lane).length;
     while (inFlight < ceiling) {
-      const id = claimNext(lane);
+      const id = claimNext(lane, lane === "work" ? workSkip : void 0);
       if (!id)
         break;
       log(`${id}: claimed (${lane})`);
@@ -1523,9 +1721,9 @@ function tick(log = () => {
   pruneChores(loadConfig());
 }
 function acquireDaemonLock() {
-  const lockPath = path8.join(lobstahHome(), "daemon.lock");
+  const lockPath = path9.join(lobstahHome(), "daemon.lock");
   try {
-    const prior = JSON.parse(fs12.readFileSync(lockPath, "utf8"));
+    const prior = JSON.parse(fs13.readFileSync(lockPath, "utf8"));
     if (pidAlive(prior.pid, prior.processStartTime)) {
       throw new Error(`another daemon (pid ${prior.pid}) already supervises ${lobstahHome()} \u2014 run a second instance against its own LOBSTAH_HOME instead`);
     }
@@ -1533,10 +1731,10 @@ function acquireDaemonLock() {
     if (err instanceof Error && err.message.includes("already supervises"))
       throw err;
   }
-  fs12.writeFileSync(lockPath, JSON.stringify({ pid: process.pid, processStartTime: processStartTime(process.pid), startedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
+  fs13.writeFileSync(lockPath, JSON.stringify({ pid: process.pid, processStartTime: processStartTime(process.pid), startedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
   const release = () => {
     try {
-      fs12.unlinkSync(lockPath);
+      fs13.unlinkSync(lockPath);
     } catch {
     }
   };
@@ -1552,7 +1750,7 @@ function watchQueues(onChange) {
   const watchers = [];
   for (const lane of ["work", "chore"]) {
     try {
-      watchers.push(fs12.watch(laneDirs(lane).queue, onChange));
+      watchers.push(fs13.watch(laneDirs(lane).queue, onChange));
     } catch {
     }
   }
@@ -1573,15 +1771,15 @@ async function daemon(intervalMs = 5e3, log = console.log) {
     } catch (err) {
       log(`tick error: ${err instanceof Error ? err.message : String(err)}`);
     }
-    await new Promise((resolve2) => {
+    await new Promise((resolve3) => {
       const timer = setTimeout(() => {
         wake = void 0;
-        resolve2();
+        resolve3();
       }, intervalMs);
       wake = () => {
         wake = void 0;
         clearTimeout(timer);
-        setTimeout(resolve2, 50);
+        setTimeout(resolve3, 50);
       };
     });
   }
@@ -1591,7 +1789,7 @@ async function daemon(intervalMs = 5e3, log = console.log) {
 import { spawn as spawn3 } from "node:child_process";
 
 // apps/pick/dist/config.js
-import * as fs13 from "node:fs";
+import * as fs14 from "node:fs";
 import { execSync } from "node:child_process";
 import * as os4 from "node:os";
 
@@ -1633,7 +1831,7 @@ function resolveTokenSource(section, label) {
   }
   if (file) {
     return () => {
-      const token = fs13.readFileSync(file.startsWith("~/") ? `${os4.homedir()}/${file.slice(2)}` : file, "utf8").trim();
+      const token = fs14.readFileSync(file.startsWith("~/") ? `${os4.homedir()}/${file.slice(2)}` : file, "utf8").trim();
       if (!token)
         throw new Error(`${label}: tokenFile ${file} is empty`);
       return token;
@@ -1651,7 +1849,7 @@ function resolveTokenSource(section, label) {
 }
 function loadPickupConfig() {
   const file = configPath();
-  const raw = fs13.existsSync(file) ? parse(fs13.readFileSync(file, "utf8")) : {};
+  const raw = fs14.existsSync(file) ? parse(fs14.readFileSync(file, "utf8")) : {};
   const p = raw.pickup ?? {};
   const out = {
     pollSecs: Number(p.pollSecs ?? 45),
@@ -1724,23 +1922,23 @@ function loadPickupConfig() {
 }
 
 // apps/pick/dist/state.js
-import * as fs14 from "node:fs";
-import * as path9 from "node:path";
+import * as fs15 from "node:fs";
+import * as path10 from "node:path";
 var PickupState = class {
   file;
   data;
-  constructor(dir = path9.join(lobstahHome(), "pickup")) {
-    fs14.mkdirSync(dir, { recursive: true });
-    this.file = path9.join(dir, "state.json");
-    this.data = fs14.existsSync(this.file) ? JSON.parse(fs14.readFileSync(this.file, "utf8")) : { map: {}, consumedApprovals: {}, rebases: {} };
+  constructor(dir = path10.join(lobstahHome(), "pickup")) {
+    fs15.mkdirSync(dir, { recursive: true });
+    this.file = path10.join(dir, "state.json");
+    this.data = fs15.existsSync(this.file) ? JSON.parse(fs15.readFileSync(this.file, "utf8")) : { map: {}, consumedApprovals: {}, rebases: {} };
     this.data.map ??= {};
     this.data.consumedApprovals ??= {};
     this.data.rebases ??= {};
   }
   save() {
     const tmp = `${this.file}.tmp-${process.pid}`;
-    fs14.writeFileSync(tmp, JSON.stringify(this.data, null, 2));
-    fs14.renameSync(tmp, this.file);
+    fs15.writeFileSync(tmp, JSON.stringify(this.data, null, 2));
+    fs15.renameSync(tmp, this.file);
   }
   get(key) {
     return this.data.map[key];
@@ -1786,6 +1984,38 @@ var PickupState = class {
   }
 };
 
+// apps/pick/dist/pr-evidence.js
+import * as fs16 from "node:fs";
+import * as path11 from "node:path";
+function prUrlKey(url) {
+  return url.replace(/\/+$/, "");
+}
+function prEvidenceIndex() {
+  const byUrl = /* @__PURE__ */ new Map();
+  const stateDir = laneDirs("work").state;
+  let files;
+  try {
+    files = fs16.readdirSync(stateDir).filter((f) => f.endsWith(".evidence"));
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+  for (const f of files) {
+    const file = path11.join(stateDir, f);
+    try {
+      const prUrl = JSON.parse(fs16.readFileSync(file, "utf8")).prUrl;
+      if (!prUrl)
+        continue;
+      const key = prUrlKey(prUrl);
+      const mtime = fs16.statSync(file).mtimeMs;
+      const cur = byUrl.get(key);
+      if (!cur || mtime > cur.mtime)
+        byUrl.set(key, { uuid: f.slice(0, -".evidence".length), mtime });
+    } catch {
+    }
+  }
+  return new Map([...byUrl].map(([url, v]) => [url, v.uuid]));
+}
+
 // apps/pick/dist/sources/github.js
 var API = "https://api.github.com";
 var GithubSource = class {
@@ -1834,26 +2064,70 @@ ${issue.body ?? ""}
 When the change is complete, commit it, push the branch, and open a PR against ${this.cfg.repo} referencing #${issue.number}.`
       });
     }
+    const evidence = prEvidenceIndex();
     const pulls = await this.api("GET", `/repos/${this.cfg.repo}/pulls?state=open&per_page=50`);
     for (const pr of pulls) {
       const m = /^lobstah\/([0-9a-f-]{36})$/.exec(pr.head.ref);
-      if (!m)
+      const uuid = m?.[1] ?? evidence.get(prUrlKey(pr.html_url));
+      if (!uuid)
         continue;
-      const reviews = await this.latestReviews(pr.number);
-      const changes = reviews.find((r) => r.state === "CHANGES_REQUESTED" && r.commit_id === pr.head.sha);
-      if (!changes)
+      const feedback = await this.latestFeedback(pr.number);
+      if (!feedback)
         continue;
+      const subject = `gh:${this.cfg.repo}#pr${pr.number}`;
       items.push({
-        key: `gh:${this.cfg.repo}#pr${pr.number}@${pr.head.sha}`,
+        key: `${subject}@${feedback}`,
+        subject,
         kind: "review",
         repoKey: this.cfg.key,
         title: pr.title,
-        followUp: m[1],
-        brief: `Address the review feedback on ${pr.html_url} (branch ${pr.head.ref}). Check out that branch in this worktree, read the review comments with \`gh pr view ${pr.number} --comments\`, implement the requested changes, and push. Reply to review threads where a reply is warranted.`
+        followUp: uuid,
+        brief: `Address the review feedback on ${pr.html_url} (branch ${pr.head.ref}). Check out that branch in this worktree, read the full review discussion with \`gh pr view ${pr.number} --comments\`, implement what the feedback asks, and push. Reply to review threads where a reply is warranted. When the feedback is addressed, report status done.`
       });
     }
     return items;
   }
+  /**
+   * The newest human feedback event on a PR, as an opaque round tag —
+   * `rv<id>` for a submitted review, `rc<id>` for an inline review-thread
+   * comment, `ic<id>` for a conversation comment. Feedback means: a
+   * CHANGES_REQUESTED review on any sha (a review of a slightly stale head
+   * still asks for changes), a COMMENTED review with a body, or any comment
+   * — always by someone other than the configured identity, and never a
+   * marker comment. APPROVED reviews are the merge loop's signal, not
+   * feedback. Returns undefined when no human has spoken.
+   */
+  async latestFeedback(n) {
+    const events = [];
+    const human = (login) => login !== this.cfg.identity;
+    const reviews = await this.paged(`/repos/${this.cfg.repo}/pulls/${n}/reviews`);
+    for (const r of reviews) {
+      if (!human(r.user.login))
+        continue;
+      const actionable = r.state === "CHANGES_REQUESTED" || r.state === "COMMENTED" && (r.body ?? "").trim() !== "";
+      if (actionable)
+        events.push({ at: r.submitted_at, tag: `rv${r.id}` });
+    }
+    for (const c of await this.paged(`/repos/${this.cfg.repo}/pulls/${n}/comments`)) {
+      if (human(c.user.login))
+        events.push({ at: c.created_at, tag: `rc${c.id}` });
+    }
+    for (const c of await this.paged(`/repos/${this.cfg.repo}/issues/${n}/comments`)) {
+      if (human(c.user.login) && !MARKER.test(c.body))
+        events.push({ at: c.created_at, tag: `ic${c.id}` });
+    }
+    events.sort((a, b) => a.at === b.at ? a.tag.localeCompare(b.tag) : a.at.localeCompare(b.at));
+    return events.at(-1)?.tag;
+  }
+  async paged(url) {
+    const all = [];
+    for (let page = 1; ; page++) {
+      const batch = await this.api("GET", `${url}?per_page=100&page=${page}`);
+      all.push(...batch);
+      if (batch.length < 100)
+        return all;
+    }
+  }
   async claim(item) {
     if (item.kind === "review")
       return true;
@@ -2100,36 +2374,14 @@ When the change is complete, commit it, push the branch, and open a PR whose des
 
 // apps/pick/dist/loops/dispatch.js
 import { randomUUID } from "node:crypto";
-async function dispatchLoop(source, state, log = () => {
-}) {
-  const items = await source.poll();
-  for (const item of items) {
-    if (state.get(item.key))
-      continue;
-    if (!await source.claim(item)) {
-      log(`${item.key}: claim lost \u2014 another machine has it`);
-      continue;
-    }
-    const id = randomUUID();
-    enqueue({
-      id,
-      repo: item.repoKey,
-      brief: item.brief,
-      // A review dispatch forks the implementation session; issues start cold.
-      ...item.kind === "review" && item.followUp ? { followUp: item.followUp } : {}
-    }, "work");
-    state.set(item.key, { uuid: id, kind: item.kind, createdAt: (/* @__PURE__ */ new Date()).toISOString() });
-    log(`${item.key}: dispatched as ${id}`);
-  }
-}
 
 // apps/pick/dist/loops/report.js
-import * as fs15 from "node:fs";
-import * as path10 from "node:path";
+import * as fs17 from "node:fs";
+import * as path12 from "node:path";
 function dispatchLane(uuid) {
   for (const lane of ["work", "chore"]) {
     const d = laneDirs(lane);
-    if (fs15.existsSync(path10.join(d.active, uuid)) || fs15.existsSync(path10.join(d.queue, `${uuid}.json`)) || fs15.existsSync(path10.join(d.done, uuid)) || fs15.existsSync(path10.join(d.state, `${uuid}.status`))) {
+    if (fs17.existsSync(path12.join(d.active, uuid)) || fs17.existsSync(path12.join(d.queue, `${uuid}.json`)) || fs17.existsSync(path12.join(d.done, uuid)) || fs17.existsSync(path12.join(d.state, `${uuid}.status`))) {
       return lane;
     }
   }
@@ -2169,13 +2421,58 @@ async function reportLoop(source, state, log = () => {
   }
 }
 
+// apps/pick/dist/loops/dispatch.js
+function terminal(uuid) {
+  const lane = dispatchLane(uuid);
+  if (!lane)
+    return true;
+  const verb = reconcile({ log: readStatusLog(uuid, lane), lastEventAt: lastEventAt(uuid, lane) });
+  return verb === "done" || verb === "failed";
+}
+function roundPlan(item, state) {
+  const rounds = item.subject ? state.entries().filter(([k]) => k.startsWith(`${item.subject}@`)).map(([, e]) => e) : [];
+  const chain = [...rounds.map((e) => e.uuid), ...item.followUp ? [item.followUp] : []];
+  if (chain.some((uuid) => !terminal(uuid)))
+    return { hold: true };
+  const forkable = rounds.filter((e) => dispatchLane(e.uuid)).sort((a, b) => a.createdAt.localeCompare(b.createdAt)).at(-1)?.uuid;
+  const target = forkable ?? item.followUp;
+  return { hold: false, followUp: target && dispatchLane(target) ? target : void 0 };
+}
+async function dispatchLoop(source, state, log = () => {
+}) {
+  const items = await source.poll();
+  for (const item of items) {
+    if (state.get(item.key))
+      continue;
+    const plan = item.kind === "review" ? roundPlan(item, state) : { hold: false, followUp: void 0 };
+    if (plan.hold) {
+      log(`${item.key}: a prior round is still in flight \u2014 holding`);
+      continue;
+    }
+    if (!await source.claim(item)) {
+      log(`${item.key}: claim lost \u2014 another machine has it`);
+      continue;
+    }
+    const id = randomUUID();
+    enqueue({
+      id,
+      repo: item.repoKey,
+      brief: item.brief,
+      // A review dispatch forks the latest session in its chain; issues start cold.
+      ...plan.followUp ? { followUp: plan.followUp } : {}
+    }, "work");
+    state.set(item.key, { uuid: id, kind: item.kind, createdAt: (/* @__PURE__ */ new Date()).toISOString() });
+    log(`${item.key}: dispatched as ${id}`);
+  }
+}
+
 // apps/pick/dist/loops/reconcile.js
-import * as fs16 from "node:fs";
-import * as path11 from "node:path";
+import * as fs18 from "node:fs";
+import * as path13 from "node:path";
 function dispatchActive(uuid) {
   for (const lane of ["work", "chore"]) {
     const d = laneDirs(lane);
-    if (fs16.existsSync(path11.join(d.active, uuid)) || fs16.existsSync(path11.join(d.queue, `${uuid}.json`))) {
+    if (fs18.existsSync(path13.join(d.active, uuid)) || fs18.existsSync(path13.join(d.queue, `${uuid}.json`))) {
       return lane;
     }
   }
@@ -2215,28 +2512,28 @@ async function reconcileLoop(source, state, log = () => {
 
 // apps/pick/dist/loops/merge.js
 import { randomUUID as randomUUID2 } from "node:crypto";
-import * as fs18 from "node:fs";
-import * as path13 from "node:path";
+import * as fs20 from "node:fs";
+import * as path15 from "node:path";
 
 // apps/pick/dist/merge-view.js
-import * as fs17 from "node:fs";
-import * as path12 from "node:path";
+import * as fs19 from "node:fs";
+import * as path14 from "node:path";
 function viewPath() {
-  return path12.join(lobstahHome(), "pickup", "merge-view.json");
+  return path14.join(lobstahHome(), "pickup", "merge-view.json");
 }
 function readMergeView() {
   try {
-    return JSON.parse(fs17.readFileSync(viewPath(), "utf8"));
+    return JSON.parse(fs19.readFileSync(viewPath(), "utf8"));
   } catch {
     return void 0;
   }
 }
 function writeMergeView(view) {
   const file = viewPath();
-  fs17.mkdirSync(path12.dirname(file), { recursive: true });
+  fs19.mkdirSync(path14.dirname(file), { recursive: true });
   const tmp = `${file}.tmp-${process.pid}`;
-  fs17.writeFileSync(tmp, JSON.stringify(view, null, 2));
-  fs17.renameSync(tmp, file);
+  fs19.writeFileSync(tmp, JSON.stringify(view, null, 2));
+  fs19.renameSync(tmp, file);
 }
 var RECENT_RETENTION_MS = 48 * 36e5;
 async function recordMergeView(repo, open, disposition, now = /* @__PURE__ */ new Date()) {
@@ -2258,7 +2555,7 @@ async function recordMergeView(repo, open, disposition, now = /* @__PURE__ */ ne
 }
 function readPickupMap() {
   try {
-    const raw = JSON.parse(fs17.readFileSync(path12.join(lobstahHome(), "pickup", "state.json"), "utf8"));
+    const raw = JSON.parse(fs19.readFileSync(path14.join(lobstahHome(), "pickup", "state.json"), "utf8"));
     return raw.map ?? {};
   } catch {
     return {};
@@ -2292,7 +2589,7 @@ function rebaseBrief(pr) {
 }
 function choreVerdict(uuid) {
   const d = laneDirs("chore");
-  if (fs18.existsSync(path13.join(d.active, uuid)) || fs18.existsSync(path13.join(d.queue, `${uuid}.json`)))
+  if (fs20.existsSync(path15.join(d.active, uuid)) || fs20.existsSync(path15.join(d.queue, `${uuid}.json`)))
     return "active";
   const last = readStatusLog(uuid, "chore").at(-1)?.verb;
   return last === "done" ? "done" : "failed";
@@ -2386,8 +2683,8 @@ async function mergeLoop(ms, policy, state, log = () => {
 }
 
 // apps/pick/dist/loops/watch.js
-import * as fs19 from "node:fs";
-import * as path14 from "node:path";
+import * as fs21 from "node:fs";
+import * as path16 from "node:path";
 import { randomUUID as randomUUID3 } from "node:crypto";
 var DEFAULT_BRIEF = `You are resuming earlier work. The watched source {key} produced new events:
 
@@ -2397,7 +2694,7 @@ Read them, act on what they ask, and report the outcome.`;
 function laneOf(id) {
   for (const lane of ["work", "chore"]) {
     const d = laneDirs(lane);
-    if (fs19.existsSync(path14.join(d.active, id)) || fs19.existsSync(path14.join(d.queue, `${id}.json`)) || fs19.existsSync(path14.join(d.done, id)) || fs19.existsSync(path14.join(d.state, `${id}.status`))) {
+    if (fs21.existsSync(path16.join(d.active, id)) || fs21.existsSync(path16.join(d.queue, `${id}.json`)) || fs21.existsSync(path16.join(d.done, id)) || fs21.existsSync(path16.join(d.state, `${id}.status`))) {
       return lane;
     }
   }
@@ -2406,13 +2703,13 @@ function laneOf(id) {
 function descriptorOf(id, lane) {
   const d = laneDirs(lane);
   for (const bucket of ["active", "done"]) {
-    const f = path14.join(d[bucket], id, "descriptor.json");
-    if (fs19.existsSync(f))
-      return JSON.parse(fs19.readFileSync(f, "utf8"));
+    const f = path16.join(d[bucket], id, "descriptor.json");
+    if (fs21.existsSync(f))
+      return JSON.parse(fs21.readFileSync(f, "utf8"));
   }
-  const q = path14.join(d.queue, `${id}.json`);
-  if (fs19.existsSync(q))
-    return JSON.parse(fs19.readFileSync(q, "utf8"));
+  const q = path16.join(d.queue, `${id}.json`);
+  if (fs21.existsSync(q))
+    return JSON.parse(fs21.readFileSync(q, "utf8"));
   return void 0;
 }
 function isTerminal(id) {
@@ -2439,9 +2736,12 @@ function spawnContinuation(w, pending, log) {
   }
   const id = randomUUID3();
   const brief = (w.brief ?? DEFAULT_BRIEF).replaceAll("{key}", w.key).replaceAll("{events}", JSON.stringify(pending, null, 2));
-  enqueue({ id, repo: descriptor.repo, brief, followUp: target }, "work");
+  const claim = readSessionClaim(target, targetLane);
+  const claimant = claim?.by.startsWith("session:") ? claim.by.slice("session:".length) : void 0;
+  const live = claimant !== void 0 && readSoak(claimant) !== void 0;
+  enqueue({ id, repo: descriptor.repo, brief, followUp: target, ...live ? { for: claim.by } : {} }, "work");
   markFollowUp(w.key, id, readWatchEvents(w.key).length);
-  log(`watch ${w.key}: ${pending.length} event(s) \u2192 continuation ${id} (forks ${target})`);
+  log(`watch ${w.key}: ${pending.length} event(s) \u2192 continuation ${id} ` + (live ? `(addressed to soaking ${claimant.slice(0, 8)})` : `(forks ${target})`));
 }
 function notifyMan(watch2, fresh, notify) {
   if (fresh.length === 0 || watch2.owner !== "man")
@@ -2642,21 +2942,21 @@ function mergeHaulHook(existing) {
 }
 
 // apps/cli/src/tend.ts
-import * as fs20 from "node:fs";
-import * as path15 from "node:path";
+import * as fs22 from "node:fs";
+import * as path17 from "node:path";
 var HEARTBEAT_STALE_MS = 9e4;
 var CLAIM_STALE_MS = 12e4;
 var DAY_MS = 24 * 36e5;
 function readJson(file) {
   try {
-    return JSON.parse(fs20.readFileSync(file, "utf8"));
+    return JSON.parse(fs22.readFileSync(file, "utf8"));
   } catch {
     return void 0;
   }
 }
 function doneIds(lane) {
   try {
-    return fs20.readdirSync(laneDirs(lane).done).filter((f) => !f.startsWith("."));
+    return fs22.readdirSync(laneDirs(lane).done).filter((f) => !f.startsWith("."));
   } catch {
     return [];
   }
@@ -2675,16 +2975,16 @@ function followUps(uuid) {
     const desc = readJson(file);
     if (desc?.followUp === uuid) out.push({ id, bucket });
   };
-  for (const id of pendingIds("work")) scan(id, "queued", path15.join(d.queue, `${id}.json`));
-  for (const id of activeIds("work")) scan(id, "active", path15.join(d.active, id, "descriptor.json"));
-  for (const id of doneIds("work")) scan(id, "done", path15.join(d.done, id, "descriptor.json"));
+  for (const id of pendingIds("work")) scan(id, "queued", path17.join(d.queue, `${id}.json`));
+  for (const id of activeIds("work")) scan(id, "active", path17.join(d.active, id, "descriptor.json"));
+  for (const id of doneIds("work")) scan(id, "done", path17.join(d.done, id, "descriptor.json"));
   return out;
 }
 function bucketOf(uuid) {
   const d = laneDirs("work");
-  if (fs20.existsSync(path15.join(d.active, uuid))) return "active";
-  if (fs20.existsSync(path15.join(d.done, uuid))) return "done";
-  if (fs20.existsSync(path15.join(d.queue, `${uuid}.json`))) return "queued";
+  if (fs22.existsSync(path17.join(d.active, uuid))) return "active";
+  if (fs22.existsSync(path17.join(d.done, uuid))) return "done";
+  if (fs22.existsSync(path17.join(d.queue, `${uuid}.json`))) return "queued";
   return void 0;
 }
 function buildTendReport(now = Date.now()) {
@@ -2744,7 +3044,7 @@ function buildTendReport(now = Date.now()) {
     }
   }
   const oldestQueuedAge = queued.reduce((max, id) => {
-    const st = fs20.statSync(path15.join(laneDirs("work").queue, `${id}.json`), { throwIfNoEntry: false });
+    const st = fs22.statSync(path17.join(laneDirs("work").queue, `${id}.json`), { throwIfNoEntry: false });
     return st ? Math.max(max, now - st.mtimeMs) : max;
   }, 0);
   const stalled = daemonUp && queued.length > 0 && active.length < cfg.limits.maxConcurrent && oldestQueuedAge > CLAIM_STALE_MS;
@@ -2775,6 +3075,13 @@ function buildTendReport(now = Date.now()) {
     stories.push({ key: "(direct)", dispatches: [d], prUrl: d.prUrl, gate: gateFor(id, d.prUrl), watch: watchByDispatch.get(id) });
   }
   const verdict = !daemonUp ? "daemon-down" : stalled ? "stalled" : attention.length > 0 ? "needs-attention" : active.length + queued.length > 0 ? "working" : "idle";
+  const soaking = listSoaking().map((r) => ({
+    session: r.sessionId.slice(0, 8),
+    repo: r.repo ?? "(addressed only)",
+    worktree: r.worktree,
+    claimed: r.claimed,
+    heartbeatAgeSecs: Math.max(0, Math.round((now - (Date.parse(r.heartbeatAt) || 0)) / 1e3))
+  }));
   return {
     verdict,
     daemon: { up: daemonUp, lastHeartbeat: heartbeat },
@@ -2782,6 +3089,7 @@ function buildTendReport(now = Date.now()) {
     attention,
     stories,
     watches,
+    soaking,
     merge
   };
 }
@@ -2840,6 +3148,22 @@ function renderTend(r) {
       )
     );
   }
+  if (r.soaking.length > 0) {
+    lines.push("");
+    lines.push(
+      toonTable(
+        "soaking",
+        r.soaking.map((s) => ({
+          session: s.session,
+          repo: s.repo,
+          claimed: s.claimed ? s.claimed.slice(0, 8) : "",
+          heartbeat: `${s.heartbeatAgeSecs}s ago`,
+          worktree: s.worktree
+        })),
+        ["session", "repo", "claimed", "heartbeat", "worktree"]
+      )
+    );
+  }
   if (r.merge && (r.merge.open.length > 0 || r.merge.recent.length > 0)) {
     lines.push("");
     lines.push(
@@ -2857,13 +3181,13 @@ function renderTend(r) {
 }
 
 // apps/cli/src/cull.ts
-import * as fs21 from "node:fs";
-import * as path16 from "node:path";
+import * as fs23 from "node:fs";
+import * as path18 from "node:path";
 import { execFileSync as execFileSync2 } from "node:child_process";
 var DAY = 864e5;
 function idsIn(dir) {
   try {
-    return new Set(fs21.readdirSync(dir).filter((f) => !f.startsWith(".")).map((f) => f.replace(/\.json$/, "")));
+    return new Set(fs23.readdirSync(dir).filter((f) => !f.startsWith(".")).map((f) => f.replace(/\.json$/, "")));
   } catch {
     return /* @__PURE__ */ new Set();
   }
@@ -2878,39 +3202,39 @@ function planCull(olderThanDays, now = Date.now()) {
     for (const id of idsIn(d.queue)) live.add(id);
     for (const id of idsIn(d.active)) live.add(id);
     for (const id of idsIn(d.done)) {
-      const p = path16.join(d.done, id);
-      const m = fs21.statSync(p).mtimeMs;
+      const p = path18.join(d.done, id);
+      const m = fs23.statSync(p).mtimeMs;
       doneMtimes.set(id, m);
       if (m < cutoff) items.push({ kind: "done", id, target: p, ageDays: Math.floor((now - m) / DAY) });
     }
   }
-  const wtRoot = path16.join(lobstahHome(), "worktrees");
+  const wtRoot = path18.join(lobstahHome(), "worktrees");
   for (const id of idsIn(wtRoot)) {
     if (live.has(id)) continue;
     const doneAt = doneMtimes.get(id);
     if (doneAt !== void 0 && doneAt >= cutoff) continue;
-    const p = path16.join(wtRoot, id);
-    items.push({ kind: "worktree", id, target: p, ageDays: Math.floor((now - fs21.statSync(p).mtimeMs) / DAY) });
+    const p = path18.join(wtRoot, id);
+    items.push({ kind: "worktree", id, target: p, ageDays: Math.floor((now - fs23.statSync(p).mtimeMs) / DAY) });
   }
   for (const lane of ["work", "chore"]) {
     const d = laneDirs(lane);
     const seen = /* @__PURE__ */ new Set();
-    for (const f of fs21.readdirSync(d.state)) {
+    for (const f of fs23.readdirSync(d.state)) {
       const id = f.replace(/\.(status|events|evidence|attn|notified|runner\.log)$/, "");
       if (id === f || seen.has(id) || live.has(id) || doneMtimes.has(id)) continue;
-      const m = fs21.statSync(path16.join(d.state, f)).mtimeMs;
+      const m = fs23.statSync(path18.join(d.state, f)).mtimeMs;
       if (m >= cutoff) continue;
       seen.add(id);
-      items.push({ kind: "state", id, target: path16.join(d.state, `${id}.*`), ageDays: Math.floor((now - m) / DAY) });
+      items.push({ kind: "state", id, target: path18.join(d.state, `${id}.*`), ageDays: Math.floor((now - m) / DAY) });
     }
   }
   return items;
 }
 function removeWorktree(id, dir) {
   for (const lane of ["work", "chore"]) {
-    const descFile = path16.join(laneDirs(lane).done, id, "descriptor.json");
+    const descFile = path18.join(laneDirs(lane).done, id, "descriptor.json");
     try {
-      const desc = JSON.parse(fs21.readFileSync(descFile, "utf8"));
+      const desc = JSON.parse(fs23.readFileSync(descFile, "utf8"));
       const repo = loadConfig().repos[desc.repo];
       if (repo) {
         execFileSync2("git", ["worktree", "remove", "--force", dir], { cwd: repo.path, stdio: "ignore" });
@@ -2919,15 +3243,15 @@ function removeWorktree(id, dir) {
     } catch {
     }
   }
-  fs21.rmSync(dir, { recursive: true, force: true });
+  fs23.rmSync(dir, { recursive: true, force: true });
 }
 function applyCull(items) {
   for (const item of items.filter((i) => i.kind === "worktree")) removeWorktree(item.id, item.target);
-  for (const item of items.filter((i) => i.kind === "done")) fs21.rmSync(item.target, { recursive: true, force: true });
+  for (const item of items.filter((i) => i.kind === "done")) fs23.rmSync(item.target, { recursive: true, force: true });
   for (const item of items.filter((i) => i.kind === "state")) {
-    const dir = path16.dirname(item.target);
-    for (const f of fs21.readdirSync(dir)) {
-      if (f.startsWith(`${item.id}.`)) fs21.rmSync(path16.join(dir, f), { force: true });
+    const dir = path18.dirname(item.target);
+    for (const f of fs23.readdirSync(dir)) {
+      if (f.startsWith(`${item.id}.`)) fs23.rmSync(path18.join(dir, f), { force: true });
     }
   }
 }
@@ -2957,6 +3281,11 @@ your working set:
                                                 external (a review session, a
                                                 CI run) \u2014 its events wake you
                                                 like any dispatch would
+  lobstah set ... --for session:<id>            drop bait into a soaking trap:
+                                                a live session that volunteered
+                                                (\`lobstah soak\`) works it in
+                                                its own worktree instead of a
+                                                fresh headless spawn
 
 getting woken instead of asking:
   lobstah man wait          block until a dispatch needs attention (arm it as a
@@ -2976,7 +3305,7 @@ paste into your liaison instructions:
 full pattern and trade-offs: docs/lobsterman.md \xB7 config: docs/configuration.md`;
 
 // apps/cli/src/doctor.ts
-import * as fs22 from "node:fs";
+import * as fs24 from "node:fs";
 import { spawnSync as spawnSync2 } from "node:child_process";
 var HEARTBEAT_STALE_MS2 = 9e4;
 function git(repoPath, ...args) {
@@ -2999,13 +3328,13 @@ function runDoctor(now = Date.now()) {
     codexPath ? "on PATH" : codexSdk ? "vendored SDK (attach uses it too)" : "neither codex nor the SDK \u2014 codex dispatches will fail"
   );
   const cfgFile = configPath();
-  if (!fs22.existsSync(cfgFile)) {
+  if (!fs24.existsSync(cfgFile)) {
     push("config", "fail", `${cfgFile} missing \u2014 run \`lobstah init\``);
     return rows;
   }
   let parsed;
   try {
-    parsed = parse(fs22.readFileSync(cfgFile, "utf8"));
+    parsed = parse(fs24.readFileSync(cfgFile, "utf8"));
     push("config", "ok", cfgFile);
   } catch (err) {
     push("config", "fail", `${cfgFile}: ${err instanceof Error ? err.message : String(err)}`);
@@ -3016,7 +3345,7 @@ function runDoctor(now = Date.now()) {
   if (repoKeys.length === 0) push("repos", "warn", "none configured \u2014 add one with `lobstah repos add <path>`");
   for (const [key, repo] of Object.entries(cfg.repos)) {
     const label = `repo ${key}`;
-    if (!fs22.existsSync(repo.path)) {
+    if (!fs24.existsSync(repo.path)) {
       push(label, "fail", `path ${repo.path} does not exist`);
       continue;
     }
@@ -3044,11 +3373,11 @@ function runDoctor(now = Date.now()) {
     }
   }
   const hb = executorPath();
-  if (!fs22.existsSync(hb)) {
+  if (!fs24.existsSync(hb)) {
     push("daemon", "warn", "no heartbeat \u2014 daemon not running (`lobstah daemon install`)");
   } else {
     try {
-      const payload = JSON.parse(fs22.readFileSync(hb, "utf8"));
+      const payload = JSON.parse(fs24.readFileSync(hb, "utf8"));
       const age = now - new Date(payload.heartbeat ?? 0).getTime();
       push(
         "daemon",
@@ -3064,9 +3393,9 @@ function runDoctor(now = Date.now()) {
 }
 
 // apps/cli/src/service.ts
-import * as fs23 from "node:fs";
+import * as fs25 from "node:fs";
 import * as os5 from "node:os";
-import * as path17 from "node:path";
+import * as path19 from "node:path";
 import { spawnSync as spawnSync3 } from "node:child_process";
 function xml(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -3090,8 +3419,8 @@ function renderLaunchdPlist(spec) {
   </dict>
   <key>RunAtLoad</key><true/>
   <key>KeepAlive</key><true/>
-  <key>StandardOutPath</key><string>${xml(path17.posix.join(spec.logDir, `${spec.kind}.log`))}</string>
-  <key>StandardErrorPath</key><string>${xml(path17.posix.join(spec.logDir, `${spec.kind}.err`))}</string>
+  <key>StandardOutPath</key><string>${xml(path19.posix.join(spec.logDir, `${spec.kind}.log`))}</string>
+  <key>StandardErrorPath</key><string>${xml(path19.posix.join(spec.logDir, `${spec.kind}.err`))}</string>
 </dict>
 </plist>
 `;
@@ -3106,8 +3435,8 @@ Restart=always
 RestartSec=5
 Environment=PATH=${spec.pathEnv}
 Environment=LOBSTAH_HOME=${spec.home}
-StandardOutput=append:${path17.posix.join(spec.logDir, `${spec.kind}.log`)}
-StandardError=append:${path17.posix.join(spec.logDir, `${spec.kind}.err`)}
+StandardOutput=append:${path19.posix.join(spec.logDir, `${spec.kind}.log`)}
+StandardError=append:${path19.posix.join(spec.logDir, `${spec.kind}.err`)}
 
 [Install]
 WantedBy=default.target
@@ -3115,8 +3444,8 @@ WantedBy=default.target
 }
 function servicePathEnv(nodePath, home = os5.homedir()) {
   const dirs = [
-    path17.posix.dirname(nodePath),
-    path17.posix.join(home, ".local", "bin"),
+    path19.posix.dirname(nodePath),
+    path19.posix.join(home, ".local", "bin"),
     "/opt/homebrew/bin",
     "/usr/local/bin",
     "/usr/bin",
@@ -3125,7 +3454,7 @@ function servicePathEnv(nodePath, home = os5.homedir()) {
   return [...new Set(dirs)].join(":");
 }
 function serviceFile(kind) {
-  return process.platform === "darwin" ? path17.join(os5.homedir(), "Library", "LaunchAgents", `lobstah.${kind}.plist`) : path17.join(os5.homedir(), ".config", "systemd", "user", `lobstah-${kind}.service`);
+  return process.platform === "darwin" ? path19.join(os5.homedir(), "Library", "LaunchAgents", `lobstah.${kind}.plist`) : path19.join(os5.homedir(), ".config", "systemd", "user", `lobstah-${kind}.service`);
 }
 function run(cmd, args) {
   const res = spawnSync3(cmd, args, { encoding: "utf8" });
@@ -3135,28 +3464,28 @@ function installService(kind) {
   if (process.platform === "win32") {
     throw new Error(`no service manager support on Windows \u2014 run \`lobstah ${kind}\` under your process manager of choice`);
   }
-  const entry = fs23.realpathSync(process.argv[1]);
+  const entry = fs25.realpathSync(process.argv[1]);
   const spec = {
     kind,
     nodePath: process.execPath,
     entry,
     pathEnv: servicePathEnv(process.execPath),
     home: lobstahHome(),
-    logDir: path17.join(lobstahHome(), "logs")
+    logDir: path19.join(lobstahHome(), "logs")
   };
   if (!onPath("git", spec.pathEnv)) {
     throw new Error(`git is not reachable on the service PATH (${spec.pathEnv}) \u2014 the daemon cannot allocate worktrees`);
   }
-  fs23.mkdirSync(spec.logDir, { recursive: true });
+  fs25.mkdirSync(spec.logDir, { recursive: true });
   const file = serviceFile(kind);
-  fs23.mkdirSync(path17.dirname(file), { recursive: true });
+  fs25.mkdirSync(path19.dirname(file), { recursive: true });
   if (process.platform === "darwin") {
-    if (fs23.existsSync(file)) run("launchctl", ["unload", file]);
-    fs23.writeFileSync(file, renderLaunchdPlist(spec));
+    if (fs25.existsSync(file)) run("launchctl", ["unload", file]);
+    fs25.writeFileSync(file, renderLaunchdPlist(spec));
     const load = run("launchctl", ["load", file]);
     return { file, loaded: load.ok, detail: load.ok ? `label lobstah.${kind}` : load.out };
   }
-  fs23.writeFileSync(file, renderSystemdUnit(spec));
+  fs25.writeFileSync(file, renderSystemdUnit(spec));
   run("systemctl", ["--user", "daemon-reload"]);
   const enable = run("systemctl", ["--user", "enable", "--now", `lobstah-${kind}.service`]);
   return { file, loaded: enable.ok, detail: enable.ok ? `unit lobstah-${kind}.service` : enable.out };
@@ -3164,19 +3493,19 @@ function installService(kind) {
 function uninstallService(kind) {
   const file = serviceFile(kind);
   if (process.platform === "darwin") {
-    if (fs23.existsSync(file)) run("launchctl", ["unload", file]);
+    if (fs25.existsSync(file)) run("launchctl", ["unload", file]);
   } else {
     run("systemctl", ["--user", "disable", "--now", `lobstah-${kind}.service`]);
   }
-  const removed = fs23.existsSync(file);
-  if (removed) fs23.unlinkSync(file);
+  const removed = fs25.existsSync(file);
+  if (removed) fs25.unlinkSync(file);
   if (process.platform !== "darwin") run("systemctl", ["--user", "daemon-reload"]);
   return { file, removed };
 }
 
 // apps/cli/src/repos.ts
-import * as fs24 from "node:fs";
-import * as path18 from "node:path";
+import * as fs26 from "node:fs";
+import * as path20 from "node:path";
 import { spawnSync as spawnSync4 } from "node:child_process";
 function git2(dir, ...args) {
   const res = spawnSync4("git", ["-C", dir, ...args], { encoding: "utf8" });
@@ -3192,41 +3521,41 @@ var LOCKFILE_SETUP = [
   ["poetry.lock", ["poetry install"]]
 ];
 function detectRepo(dir) {
-  const abs = path18.resolve(dir);
+  const abs = path20.resolve(dir);
   if (git2(abs, "rev-parse", "--is-inside-work-tree") !== "true") return void 0;
   const top = git2(abs, "rev-parse", "--show-toplevel");
-  const canon = (p) => {
-    const real = path18.resolve(fs24.realpathSync.native(p));
+  const canon2 = (p) => {
+    const real = path20.resolve(fs26.realpathSync.native(p));
     return process.platform === "win32" ? real.toLowerCase() : real;
   };
-  if (!top || canon(top) !== canon(abs)) return void 0;
+  if (!top || canon2(top) !== canon2(abs)) return void 0;
   const origin = git2(abs, "remote", "get-url", "origin");
   const headRef = git2(abs, "symbolic-ref", "--short", "refs/remotes/origin/HEAD");
   const trunk = headRef?.replace(/^origin\//, "") ?? git2(abs, "branch", "--show-current") ?? "main";
-  const setup = LOCKFILE_SETUP.find(([f]) => fs24.existsSync(path18.join(abs, f)))?.[1];
-  return { key: path18.basename(abs), path: abs, trunk, origin, setup };
+  const setup = LOCKFILE_SETUP.find(([f]) => fs26.existsSync(path20.join(abs, f)))?.[1];
+  return { key: path20.basename(abs), path: abs, trunk, origin, setup };
 }
 function scanForRepos(roots) {
   const found = [];
   for (const root of roots) {
-    const abs = path18.resolve(root);
-    if (!fs24.existsSync(abs)) continue;
+    const abs = path20.resolve(root);
+    if (!fs26.existsSync(abs)) continue;
     const self = detectRepo(abs);
     if (self) {
       found.push(self);
       continue;
     }
-    for (const entry of fs24.readdirSync(abs, { withFileTypes: true })) {
+    for (const entry of fs26.readdirSync(abs, { withFileTypes: true })) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const child = detectRepo(path18.join(abs, entry.name));
+      const child = detectRepo(path20.join(abs, entry.name));
       if (child) found.push(child);
     }
   }
   return found;
 }
 function configuredRepoKeys(file = configPath()) {
-  if (!fs24.existsSync(file)) return /* @__PURE__ */ new Set();
-  const raw = parse(fs24.readFileSync(file, "utf8"));
+  if (!fs26.existsSync(file)) return /* @__PURE__ */ new Set();
+  const raw = parse(fs26.readFileSync(file, "utf8"));
   return new Set(Object.keys(raw.repos ?? {}));
 }
 function appendRepoBlock(repo, opts = {}, file = configPath()) {
@@ -3234,7 +3563,7 @@ function appendRepoBlock(repo, opts = {}, file = configPath()) {
   if (repo.origin) lines.push(`origin = ${JSON.stringify(repo.origin)}`);
   if (repo.setup) lines.push(`setup  = [${repo.setup.map((s) => JSON.stringify(s)).join(", ")}]`);
   if (opts.pickup) lines.push(`pickup = true`);
-  fs24.appendFileSync(file, `${lines.join("\n")}
+  fs26.appendFileSync(file, `${lines.join("\n")}
 `);
 }
 
@@ -3246,17 +3575,220 @@ function parseReportArgs(rest) {
   return { note, prUrl };
 }
 
+// apps/cli/src/soak-site.ts
+import * as fs27 from "node:fs";
+import * as path21 from "node:path";
+import { spawnSync as spawnSync5 } from "node:child_process";
+function git3(dir, ...args) {
+  const res = spawnSync5("git", ["-C", dir, ...args], { encoding: "utf8" });
+  return res.status === 0 ? res.stdout.trim() : void 0;
+}
+function canon(p) {
+  try {
+    const real = path21.resolve(fs27.realpathSync.native(p));
+    return process.platform === "win32" ? real.toLowerCase() : real;
+  } catch {
+    return path21.resolve(p);
+  }
+}
+function inspectSoakSite(cwd, repos) {
+  const top = git3(cwd, "rev-parse", "--show-toplevel");
+  if (!top) return void 0;
+  const gitDir = git3(cwd, "rev-parse", "--git-dir");
+  const commonDir = git3(cwd, "rev-parse", "--git-common-dir");
+  if (!gitDir || !commonDir) return void 0;
+  const abs = (p) => path21.isAbsolute(p) ? p : path21.join(cwd, p);
+  const primary = canon(abs(gitDir)) === canon(abs(commonDir));
+  const primaryRoot = canon(path21.dirname(abs(commonDir)));
+  const repoKey = Object.entries(repos).find(([, r]) => canon(r.path) === primaryRoot)?.[0];
+  return { worktree: canon(top), primary, repoKey };
+}
+function readHookStdin() {
+  if (process.stdin.isTTY) return void 0;
+  try {
+    const raw = fs27.readFileSync(0, "utf8");
+    if (!raw.trim()) return void 0;
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// apps/cli/src/usage.ts
+var HARNESS = "claude|codex";
+var COMMANDS = {
+  dispatch: {
+    flags: {
+      "--repo": { value: "<key>", required: true },
+      "--brief": { value: "<file>" },
+      "--bait": { value: "<file>" },
+      "--brief-text": { value: "<text>" },
+      "--harness": { value: HARNESS },
+      "--model": { value: "<m>" },
+      "--effort": { value: "<e>" },
+      "--follow-up": { value: "<uuid>" },
+      "--for": { value: "session:<id>" },
+      "--chore": {},
+      "--id": { value: "<uuid>" }
+    }
+  },
+  ls: { flags: { "--all": {} } },
+  status: { flags: {}, positionals: "[<uuid>]" },
+  logs: { flags: { "--follow": {}, "--full": {} }, positionals: "<uuid>" },
+  send: { flags: {}, positionals: "<uuid> <message...>", tailAfter: 1 },
+  inbox: { flags: {}, positionals: "<uuid>" },
+  attach: { flags: { "--print": {}, "--force": {} }, positionals: "<uuid>" },
+  swap: {
+    flags: { "--harness": { value: HARNESS }, "--model": { value: "<m>" }, "--effort": { value: "<e>" } },
+    positionals: "<uuid>"
+  },
+  catch: { flags: {}, positionals: "<uuid>" },
+  cull: { flags: { "--older-than": { value: "<days>" }, "--apply": {} } },
+  cancel: { flags: {}, positionals: "<uuid>" },
+  report: { flags: {}, positionals: "<uuid> <verb> [note...] [--pr <url>]", tailAfter: 2 },
+  watch: {
+    subverbs: ["add", "rm", "ls"],
+    flags: {
+      "--check": { value: "<cmd>" },
+      "--for": { value: "<uuid>" },
+      "--cursor": { value: "<c>" },
+      "--every": { value: "<s>" },
+      "--brief": { value: "<template>" },
+      "--stream": { value: "<cmd>" }
+    },
+    positionals: "[<key>]"
+  },
+  soak: { flags: { "--session": { value: "<id>", required: true }, "--one": {}, "--harness": { value: HARNESS } } },
+  stow: { flags: { "--session": { value: "<id>" }, "--quiet": {} } },
+  daemon: { subverbs: ["install", "uninstall"], flags: { "--interval": { value: "<ms>" } } },
+  pick: { subverbs: ["once", "install", "uninstall"], flags: {} },
+  doctor: { flags: {} },
+  repos: { subverbs: ["add"], flags: { "--pickup": {}, "--key": { value: "<k>" } }, positionals: "[<path>]" },
+  init: { flags: { "--scan": {}, "--pickup": {} }, positionals: "[<dir>...]" },
+  version: { flags: {} },
+  "man:manual": { flags: {} },
+  "man:tend": { flags: { "--json": {} } },
+  "man:wait": { flags: { "--timeout": { value: "<secs>" }, "--peek": {} } },
+  "man:init": { flags: { "--shared": {}, "--global": {}, "--marker": {} } },
+  "man:haul": { flags: { "--timeout": { value: "<secs>" } } },
+  "man:brief": { flags: {} }
+};
+var PROSE = {
+  dispatch: `Queue a supervised dispatch; prints the id. --for addresses the bait to a
+soaking session instead of a fresh headless worker. Alias: set --bait.`,
+  ls: `Queue, active, and recent done dispatches (--all includes chores). Alias: buoys.`,
+  status: `Reconciled state for one dispatch, or all active without an id. Alias: buoy.`,
+  logs: `The dispatch's normalized event stream \u2014 last 50 events by default,
+--full for everything, --follow to tail.`,
+  send: `Deliver an instruction to a running dispatch between its turns.`,
+  inbox: `Read and acknowledge pending messages (workers: check at natural checkpoints).`,
+  attach: `Open the dispatch's own harness session in its worktree. Refused while
+working unless --force; --print shows the command instead of running it.`,
+  swap: `Hand an active dispatch to a fresh session \u2014 same worktree and brief plus a
+git progress note.`,
+  catch: `The evidence: branch, commits, PR, session.`,
+  cull: `Sweep aged done entries, orphaned worktrees, and stale state. Dry run
+without --apply (default 14 days).`,
+  cancel: `Request cancellation; the daemon (or the claiming session) winds it down.`,
+  report: `The validated status write path: working | needs-decision | blocked |
+paused | done | failed.`,
+  watch: `Stand watch on something external; bare \`watch\` (or \`watch ls\`) lists.
+The check command answers "anything since {cursor}?" in JSON.`,
+  soak: `Volunteer this session as a worker: it parks at turn end and takes matching
+bait. Refused from a primary checkout \u2014 soak from a worktree. --one stows
+after the first catch.`,
+  stow: `Sign a soaking session off; an open catch goes back to the queue.`,
+  daemon: `The supervisor process (claims, worktrees, liveness, restarts). install
+writes + loads a launchd agent / systemd user unit.`,
+  pick: `Tracker loops: poll Linear/GitHub, dispatch assigned work, report back,
+reconcile, merge.`,
+  doctor: `Check binaries, config, repos, harnesses, and the daemon heartbeat; exit 1
+on failures.`,
+  repos: `List configured repos, or detect one and append its [repos.*] block.`,
+  init: `Create ~/.lobstah + config; --scan appends a [repos.*] block per repo found
+under the given directories.`,
+  version: `The installed lobstah version.`,
+  "man:manual": `The lobsterman's manual.`,
+  "man:tend": `The whole-fleet pass: verdict, unanswered questions, each work item's chain,
+PR, and merge gate. Pure disk read.`,
+  "man:wait": `Block until a dispatch or watched source needs attention; exit 3 on timeout.
+--peek surfaces standing events without consuming them.`,
+  "man:init": `Install the haul Stop hook into Claude settings; --marker touches
+.lobstah-man to arm this directory.`,
+  "man:haul": `Stop-hook entry point: park the session while work is in flight (lobsterman
+or soaking worker); prints hook-decision JSON on an event.`,
+  "man:brief": `SessionStart-hook entry point: announce the session id and fleet state into
+the conversation.`
+};
+function synopsis(cmd) {
+  const spec = COMMANDS[cmd];
+  if (!spec) return `lobstah ${cmd.replace(":", " ")}`;
+  const parts = [`lobstah ${cmd.replace(":", " ")}`];
+  if (spec.subverbs) parts.push(`[${spec.subverbs.join("|")}]`);
+  if (spec.positionals) parts.push(spec.positionals);
+  for (const [flag, f] of Object.entries(spec.flags)) {
+    const body = f.value ? `${flag} ${f.value}` : flag;
+    parts.push(f.required ? body : `[${body}]`);
+  }
+  const lines = [];
+  let line = "";
+  for (const part of parts) {
+    const candidate = line === "" ? part : `${line} ${part}`;
+    if (candidate.length > 78 && line !== "") {
+      lines.push(line);
+      line = `  ${part}`;
+    } else {
+      line = candidate;
+    }
+  }
+  lines.push(line);
+  return lines.join("\n");
+}
+function usageFor(cmd) {
+  if (!COMMANDS[cmd]) return void 0;
+  const prose = PROSE[cmd];
+  return prose ? `${synopsis(cmd)}
+${prose}` : synopsis(cmd);
+}
+var UsageError = class extends Error {
+};
+function validateArgs(cmd, args) {
+  const spec = COMMANDS[cmd];
+  if (!spec) return void 0;
+  let positionals = 0;
+  for (let i = 0; i < args.length; i++) {
+    const tok = args[i];
+    if (spec.tailAfter !== void 0 && positionals >= spec.tailAfter) break;
+    if (!tok.startsWith("--")) {
+      if (positionals === 0 && spec.subverbs && !spec.subverbs.includes(tok)) {
+        return { error: `unknown ${cmd} subcommand "${tok}" (expected ${spec.subverbs.join(" | ")})` };
+      }
+      positionals++;
+      continue;
+    }
+    if (tok === "--help") return { help: true };
+    const f = spec.flags[tok];
+    if (!f) return { error: `unknown flag ${tok} for ${cmd.replace(":", " ")}` };
+    if (f.value) i++;
+  }
+  return {};
+}
+
 // apps/cli/src/main.ts
 var HELP = `lobstah \u2014 supervision framework for coding agents
 
 work (humans and agents):
   dispatch --repo <key> (--brief <file> | --brief-text <text>)   (alias: set --bait)
            [--harness claude|codex] [--model <m>] [--effort <e>]
-           [--follow-up <uuid>] [--chore] [--id <uuid>]
-                                  queue a supervised dispatch; prints the id
+           [--follow-up <uuid>] [--for session:<id>] [--chore] [--id <uuid>]
+                                  queue a supervised dispatch; prints the id.
+                                  --for addresses the bait to a soaking
+                                  session instead of a fresh headless worker
   ls [--all]                      queue, active, recent done      (alias: buoys)
   status [<uuid>]                 reconciled state                (alias: buoy)
-  logs <uuid> [--follow]          the normalized event stream
+  logs <uuid> [--follow|--full]   the normalized event stream (last 50 events
+                                  by default; --full for everything)
   send <uuid> <message>           deliver an instruction between agent turns
   inbox <uuid>                    read and acknowledge pending messages
                                   (workers: check at natural checkpoints)
@@ -3302,7 +3834,7 @@ lobsterman (orchestrator sessions \u2014 bare \`lobstah man\` prints the manual)
   man wait [--timeout <secs>] [--peek]
                                   block until a dispatch or watched source
                                   needs attention, then print the event and
-                                  what to do next; exit 2 on timeout. Runs due
+                                  what to do next; exit 3 on timeout. Runs due
                                   watch checks itself when no pick process is.
                                   Unanswered questions re-fire every
                                   remindSecs until answered.
@@ -3323,6 +3855,19 @@ workers (dispatched agents; injected into every brief):
                                   the validated status write path
                                   (${VERBS.join(" | ")})
 
+soaking (interactive sessions volunteering as workers):
+  soak --session <id> [--one] [--harness claude|codex]
+                                  put this session in the water: it parks at
+                                  turn end and takes matching bait from the
+                                  work queue. Refused from a primary checkout
+                                  \u2014 soak from a worktree. --one stows after
+                                  the first catch. The session id comes from
+                                  the plugin's session-start brief.
+  stow [--session <id>] [--quiet] take the trap out: sign the session off; an
+                                  open catch goes back to the queue. A stale
+                                  registration (ghost trap) is swept
+                                  automatically after [soak].ttlSecs.
+
 setup:
   init [--scan <dir>... [--pickup]]
                                   create ~/.lobstah + example config; --scan
@@ -3343,6 +3888,40 @@ function arg(args, flag) {
   return i >= 0 ? args[i + 1] : void 0;
 }
 var WATCH_EVERY_SECS = 45;
+async function soakPark(sessionId, args) {
+  const timeoutSecs = Number(arg(args, "--timeout") ?? "14000");
+  const deadline = Date.now() + timeoutSecs * 1e3;
+  const block = (reason) => console.log(JSON.stringify({ decision: "block", reason }));
+  while (true) {
+    const reg = heartbeatSoak(sessionId);
+    if (!reg) return;
+    if (hasOpenCatch(reg)) {
+      const id = reg.claimed;
+      if (cancelRequested(id, "work")) {
+        block(
+          `Your catch ${id} was cancelled. Stop working it, leave the worktree as it is, and run \`lobstah report ${id} failed "cancelled by request"\`.`
+        );
+        return;
+      }
+      if (unhandled(id, "work").length > 0) {
+        block(`New instruction for your catch ${id} \u2014 read it with \`lobstah inbox ${id}\`, act on it, and keep reporting.`);
+        return;
+      }
+    } else {
+      if (reg.one && reg.claimed) {
+        stowSoak(sessionId);
+        return;
+      }
+      const caught = claimBait(reg);
+      if (caught) {
+        block(baitBrief(caught.id, caught.descriptor));
+        return;
+      }
+    }
+    if (Date.now() >= deadline) return;
+    await new Promise((r) => setTimeout(r, 1500));
+  }
+}
 function runDueManWatches() {
   for (const w of listWatches()) {
     if (w.owner === "man" && watchDue(w, WATCH_EVERY_SECS)) runWatchCheck(w);
@@ -3361,7 +3940,7 @@ function emitWatchAttention(attns) {
 function findLane(id) {
   for (const lane of ["work", "chore"]) {
     const d = laneDirs(lane);
-    if (fs25.existsSync(path19.join(d.active, id)) || fs25.existsSync(path19.join(d.queue, `${id}.json`)) || fs25.existsSync(path19.join(d.done, id)) || fs25.existsSync(path19.join(d.state, `${id}.status`))) {
+    if (fs28.existsSync(path22.join(d.active, id)) || fs28.existsSync(path22.join(d.queue, `${id}.json`)) || fs28.existsSync(path22.join(d.done, id)) || fs28.existsSync(path22.join(d.state, `${id}.status`))) {
       return lane;
     }
   }
@@ -3369,7 +3948,7 @@ function findLane(id) {
 }
 function rowsFor(lane, bucket) {
   const dir = laneDirs(lane)[bucket];
-  const entries = fs25.readdirSync(dir).filter((f) => !f.startsWith(".")).map((f) => ({ f, m: fs25.statSync(path19.join(dir, f)).mtimeMs })).sort((a, b) => b.m - a.m);
+  const entries = fs28.readdirSync(dir).filter((f) => !f.startsWith(".")).map((f) => ({ f, m: fs28.statSync(path22.join(dir, f)).mtimeMs })).sort((a, b) => b.m - a.m);
   const sliced = bucket === "done" ? entries.slice(0, 10) : entries;
   return sliced.map(({ f, m }) => {
     const id = f.replace(/\.json$/, "");
@@ -3382,10 +3961,20 @@ async function mainCli() {
   const ALIASES = { set: "dispatch", buoys: "ls", buoy: "status" };
   cmd = cmd !== void 0 ? ALIASES[cmd] ?? cmd : cmd;
   if (cmd === "man") {
-    cmd = args.length > 0 ? `man:${args[0]}` : "man:manual";
+    cmd = args.length > 0 && args[0] !== "--help" ? `man:${args[0]}` : "man:manual";
     args = args.slice(1);
   }
   ensureLayout();
+  if (cmd !== void 0) {
+    const v = validateArgs(cmd, args);
+    if (v?.help) {
+      console.log(usageFor(cmd));
+      return;
+    }
+    if (v?.error) throw new UsageError(`${v.error}
+
+${usageFor(cmd)}`);
+  }
   switch (cmd) {
     case "dispatch": {
       const repo = arg(args, "--repo");
@@ -3394,18 +3983,30 @@ async function mainCli() {
       if (!repo || !briefFile && !briefText) {
         throw new Error("dispatch requires --repo and --brief <file> (or --brief-text)");
       }
+      const address = arg(args, "--for");
+      if (address && !address.startsWith("session:")) {
+        throw new Error("dispatch --for takes a session address: --for session:<id>");
+      }
       const d = {
         id: arg(args, "--id") ?? randomUUID4(),
         repo,
-        brief: briefText ?? fs25.readFileSync(briefFile, "utf8"),
+        brief: briefText ?? fs28.readFileSync(briefFile, "utf8"),
         harness: arg(args, "--harness"),
         model: arg(args, "--model"),
         effort: arg(args, "--effort"),
-        followUp: arg(args, "--follow-up")
+        followUp: arg(args, "--follow-up"),
+        for: address
       };
       const lane = args.includes("--chore") ? "chore" : "work";
       enqueue(d, lane);
       console.log(toonKV({ id: d.id, repo, lane, queued: (/* @__PURE__ */ new Date()).toISOString() }));
+      console.log(
+        toonHelp([
+          `lobstah status ${d.id}`,
+          `lobstah send ${d.id} "<instruction>"`,
+          "lobstah man wait   (block until something needs you)"
+        ])
+      );
       break;
     }
     case "ls": {
@@ -3414,6 +4015,7 @@ async function mainCli() {
         (lane) => ["queue", "active", "done"].flatMap((b) => rowsFor(lane, b))
       );
       console.log(toonTable("dispatches", rows, ["id", "lane", "bucket", "state", "updated"]));
+      console.log(toonHelp(["lobstah status <id>", "lobstah man tend   (verdict + stories + gates)"]));
       break;
     }
     case "status": {
@@ -3427,6 +4029,11 @@ async function mainCli() {
       const log = readStatusLog(id, lane);
       const state = reconcile({ log, lastEventAt: lastEventAt(id, lane) });
       console.log(toonKV({ id, lane, state, lastNote: log.at(-1)?.note, entries: log.length }));
+      console.log(
+        toonHelp(
+          state === "needs-decision" || state === "blocked" ? [`lobstah send ${id} "<answer>"`, `lobstah logs ${id} --follow`] : state === "done" || state === "failed" ? [`lobstah catch ${id}   (branch, commits, PR)`] : [`lobstah logs ${id} --follow`, `lobstah send ${id} "<instruction>"`]
+        )
+      );
       break;
     }
     case "logs": {
@@ -3434,17 +4041,29 @@ async function mainCli() {
       if (!id) throw new Error("logs requires a dispatch id");
       const lane = findLane(id);
       const file = eventsPath(id, lane);
-      if (fs25.existsSync(file)) process.stdout.write(fs25.readFileSync(file, "utf8"));
+      if (fs28.existsSync(file)) {
+        const raw = fs28.readFileSync(file, "utf8");
+        const lines = raw.split("\n").filter((l) => l.length > 0);
+        const LIMIT = 50;
+        if (!args.includes("--full") && lines.length > LIMIT) {
+          console.log(
+            `(truncated: last ${LIMIT} of ${lines.length} events \u2014 \`lobstah logs ${id} --full\` for all)`
+          );
+          for (const l of lines.slice(-LIMIT)) console.log(l);
+        } else {
+          process.stdout.write(raw);
+        }
+      }
       if (args.includes("--follow")) {
-        let size = fs25.existsSync(file) ? fs25.statSync(file).size : 0;
+        let size = fs28.existsSync(file) ? fs28.statSync(file).size : 0;
         setInterval(() => {
-          if (!fs25.existsSync(file)) return;
-          const now = fs25.statSync(file).size;
+          if (!fs28.existsSync(file)) return;
+          const now = fs28.statSync(file).size;
           if (now > size) {
-            const fd = fs25.openSync(file, "r");
+            const fd = fs28.openSync(file, "r");
             const buf = Buffer.alloc(now - size);
-            fs25.readSync(fd, buf, 0, buf.length, size);
-            fs25.closeSync(fd);
+            fs28.readSync(fd, buf, 0, buf.length, size);
+            fs28.closeSync(fd);
             process.stdout.write(buf.toString("utf8"));
             size = now;
           }
@@ -3498,23 +4117,23 @@ async function mainCli() {
         );
       }
       const dirs = laneDirs(lane);
-      const descriptorFile = ["active", "done"].map((b) => path19.join(dirs[b], id, "descriptor.json")).find((f) => fs25.existsSync(f));
-      const harness = descriptorFile ? JSON.parse(fs25.readFileSync(descriptorFile, "utf8")).harness ?? "claude" : "claude";
+      const descriptorFile = ["active", "done"].map((b) => path22.join(dirs[b], id, "descriptor.json")).find((f) => fs28.existsSync(f));
+      const harness = descriptorFile ? JSON.parse(fs28.readFileSync(descriptorFile, "utf8")).harness ?? "claude" : "claude";
       let sessionId;
       try {
-        sessionId = JSON.parse(fs25.readFileSync(path19.join(dirs.state, `${id}.evidence`), "utf8")).sessionId;
+        sessionId = JSON.parse(fs28.readFileSync(path22.join(dirs.state, `${id}.evidence`), "utf8")).sessionId;
       } catch {
       }
       if (!sessionId) throw new Error(`${id} has no recorded harness session to attach to`);
-      const worktree = path19.join(lobstahHome(), "worktrees", id);
-      const cwd = fs25.existsSync(worktree) ? worktree : process.cwd();
+      const worktree = path22.join(lobstahHome(), "worktrees", id);
+      const cwd = fs28.existsSync(worktree) ? worktree : process.cwd();
       const invocation = harness === "codex" ? codexInvocation(["resume", sessionId]) : { file: "claude", argv: ["--resume", sessionId] };
       if (!invocation) throw new Error("no codex CLI found \u2014 neither on PATH nor vendored by @openai/codex-sdk");
       if (args.includes("--print")) {
         console.log(toonKV({ id, harness, sessionId, cwd, command: `${invocation.file} ${invocation.argv.join(" ")}` }));
         break;
       }
-      const res = spawnSync5(invocation.file, invocation.argv, { cwd, stdio: "inherit" });
+      const res = spawnSync6(invocation.file, invocation.argv, { cwd, stdio: "inherit" });
       if (res.error) throw new Error(`could not launch ${invocation.file}: ${res.error.message}`);
       break;
     }
@@ -3522,39 +4141,39 @@ async function mainCli() {
       const id = args[0];
       if (!id) throw new Error("swap requires a dispatch id");
       const lane = findLane(id);
-      const activeDir = path19.join(laneDirs(lane).active, id);
-      if (!fs25.existsSync(activeDir)) throw new Error(`${id} is not active \u2014 swap only applies to in-flight dispatches`);
-      const descFile = path19.join(activeDir, "descriptor.json");
-      const descriptor = JSON.parse(fs25.readFileSync(descFile, "utf8"));
+      const activeDir = path22.join(laneDirs(lane).active, id);
+      if (!fs28.existsSync(activeDir)) throw new Error(`${id} is not active \u2014 swap only applies to in-flight dispatches`);
+      const descFile = path22.join(activeDir, "descriptor.json");
+      const descriptor = JSON.parse(fs28.readFileSync(descFile, "utf8"));
       const fromHarness = descriptor.harness ?? "default";
       for (const key of ["harness", "model", "effort"]) {
         const v = arg(args, `--${key}`);
         if (v) descriptor[key] = v;
       }
-      fs25.writeFileSync(descFile, JSON.stringify(descriptor, null, 2));
-      const worktree = path19.join(lobstahHome(), "worktrees", id);
+      fs28.writeFileSync(descFile, JSON.stringify(descriptor, null, 2));
+      const worktree = path22.join(lobstahHome(), "worktrees", id);
       let progress = "No worktree progress recorded.";
-      if (fs25.existsSync(worktree)) {
-        const git3 = (...a) => spawnSync5("git", a, { cwd: worktree, encoding: "utf8" }).stdout?.trim() ?? "";
-        const commits = git3("log", "--oneline", "-15");
-        const status = git3("status", "--short");
+      if (fs28.existsSync(worktree)) {
+        const git4 = (...a) => spawnSync6("git", a, { cwd: worktree, encoding: "utf8" }).stdout?.trim() ?? "";
+        const commits = git4("log", "--oneline", "-15");
+        const status = git4("status", "--short");
         progress = `Commits so far:
 ${commits || "(none)"}
 
 Uncommitted changes:
 ${status || "(clean)"}`;
       }
-      fs25.writeFileSync(
-        path19.join(activeDir, "handoff"),
+      fs28.writeFileSync(
+        path22.join(activeDir, "handoff"),
         `You are taking over this dispatch from a previous agent session (harness: ${fromHarness}). Its conversation is not available \u2014 the worktree state below is the ground truth. Review it, then continue the brief from where it stops.
 
 ${progress}`
       );
-      const runnerFile = path19.join(activeDir, "runner.json");
-      if (fs25.existsSync(runnerFile)) {
-        const runner = JSON.parse(fs25.readFileSync(runnerFile, "utf8"));
+      const runnerFile = path22.join(activeDir, "runner.json");
+      if (fs28.existsSync(runnerFile)) {
+        const runner = JSON.parse(fs28.readFileSync(runnerFile, "utf8"));
         if (pidAlive(runner.pid, runner.processStartTime)) killGroup(runner.pid, "SIGKILL");
-        fs25.unlinkSync(runnerFile);
+        fs28.unlinkSync(runnerFile);
       }
       appendStatus(id, lane, "working", `swapped to ${descriptor.harness ?? "default"} \u2014 awaiting respawn`);
       console.log(toonKV({ id, harness: descriptor.harness ?? "default", model: descriptor.model, swapped: true }));
@@ -3655,24 +4274,24 @@ ${progress}`
         }
       }
       console.log(toonKV({ timeout: true, waitedSecs: timeoutSecs }));
-      process.exitCode = 2;
+      process.exitCode = 3;
       break;
     }
     case "man:init": {
-      const file = args.includes("--global") ? path19.join(os6.homedir(), ".claude", "settings.json") : path19.join(".claude", args.includes("--shared") ? "settings.json" : "settings.local.json");
+      const file = args.includes("--global") ? path22.join(os6.homedir(), ".claude", "settings.json") : path22.join(".claude", args.includes("--shared") ? "settings.json" : "settings.local.json");
       let existing;
       try {
-        existing = JSON.parse(fs25.readFileSync(file, "utf8"));
+        existing = JSON.parse(fs28.readFileSync(file, "utf8"));
       } catch {
         existing = void 0;
       }
       const { settings, changed } = mergeHaulHook(existing);
       if (changed) {
-        fs25.mkdirSync(path19.dirname(file), { recursive: true });
-        fs25.writeFileSync(file, `${JSON.stringify(settings, null, 2)}
+        fs28.mkdirSync(path22.dirname(file), { recursive: true });
+        fs28.writeFileSync(file, `${JSON.stringify(settings, null, 2)}
 `);
       }
-      if (args.includes("--marker")) fs25.writeFileSync(".lobstah-man", "");
+      if (args.includes("--marker")) fs28.writeFileSync(".lobstah-man", "");
       console.log(
         toonKV({
           hook: "lobstah man haul",
@@ -3685,9 +4304,15 @@ ${progress}`
     }
     case "man:haul": {
       try {
-        if (process.env.LOBSTAH_MAN !== "1" && !fs25.existsSync(".lobstah-man")) break;
+        const hook = readHookStdin();
+        const soakReg = hook?.session_id ? readSoak(hook.session_id) : void 0;
+        if (soakReg) {
+          await soakPark(soakReg.sessionId, args);
+          break;
+        }
+        if (process.env.LOBSTAH_MAN !== "1" && !fs28.existsSync(".lobstah-man")) break;
         const anyActive = ["work", "chore"].some(
-          (l) => fs25.readdirSync(laneDirs(l).active).some((f) => !f.startsWith("."))
+          (l) => fs28.readdirSync(laneDirs(l).active).some((f) => !f.startsWith("."))
         );
         const anyWatch = listWatches().some((w) => w.owner === "man");
         if (!anyActive && !anyWatch) break;
@@ -3727,6 +4352,87 @@ ${progress}`
       }
       break;
     }
+    case "man:brief": {
+      const hook = readHookStdin();
+      if (!hook?.session_id) break;
+      let fleet = "";
+      try {
+        const r = buildTendReport();
+        fleet = ` Fleet: ${r.verdict} (${r.counts.queued} queued, ${r.counts.active} active` + (r.attention.length > 0 ? `, ${r.attention.length} awaiting a human` : "") + ") \u2014 `lobstah` for the live view.";
+      } catch {
+      }
+      const soaking = readSoak(hook.session_id) !== void 0;
+      const context = soaking ? `lobstah: session id ${hook.session_id} \u2014 this session is soaking (a volunteered worker); \`lobstah stow --session ${hook.session_id}\` signs it off.${fleet}` : `lobstah: session id ${hook.session_id} (for \`lobstah soak|stow --session <id>\`).${fleet}`;
+      console.log(
+        JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: context } })
+      );
+      break;
+    }
+    case "soak": {
+      const sessionId = arg(args, "--session");
+      if (!sessionId) {
+        throw new Error(
+          "soak requires --session <id> \u2014 the harness session id, announced at session start by the lobstah plugin (`lobstah man brief`)"
+        );
+      }
+      const cfg = loadConfig();
+      const site = inspectSoakSite(process.cwd(), cfg.repos);
+      if (!site) throw new Error("soak must run inside a git checkout \u2014 the trap is the worktree");
+      if (site.primary) {
+        throw new Error(
+          "this is the repo's primary checkout \u2014 never claimable. Create a worktree (`git worktree add ../<name> -b <branch>`) and soak from there."
+        );
+      }
+      const rival = listSoaking().find((r) => r.sessionId !== sessionId && r.worktree === site.worktree);
+      if (rival) {
+        throw new Error(
+          `session ${rival.sessionId.slice(0, 8)} already soaks this worktree \u2014 one trap per worktree. Stow it first (\`lobstah stow --session ${rival.sessionId}\`) or soak from another worktree.`
+        );
+      }
+      const reg = signOnSoak({
+        sessionId,
+        harness: arg(args, "--harness") ?? "claude",
+        repo: site.repoKey,
+        worktree: site.worktree,
+        cwd: process.cwd(),
+        one: args.includes("--one") || void 0
+      });
+      console.log(
+        toonKV({
+          soaking: sessionId,
+          repo: reg.repo ?? "(none configured \u2014 addressed bait only)",
+          worktree: reg.worktree,
+          ...reg.one ? { one: true } : {},
+          note: "parks at turn end via the Stop hook (lobstah plugin or `man init --global`); bait arrives as a wake"
+        })
+      );
+      console.log(toonHelp([`lobstah stow --session ${sessionId}   (sign off)`]));
+      break;
+    }
+    case "stow": {
+      const sessionId = arg(args, "--session") ?? readHookStdin()?.session_id;
+      const quiet = args.includes("--quiet");
+      if (!sessionId) {
+        if (quiet) break;
+        throw new Error("stow requires --session <id> (or hook input on stdin)");
+      }
+      const reg = stowSoak(sessionId);
+      if (!reg) {
+        if (!quiet) console.log(toonKV({ session: sessionId, soaking: false }));
+        break;
+      }
+      const released = releaseCatch(reg);
+      if (!quiet) {
+        console.log(
+          toonKV({
+            stowed: sessionId,
+            ...released.requeued ? { requeued: released.requeued } : {},
+            ...released.finalized ? { finalized: released.finalized } : {}
+          })
+        );
+      }
+      break;
+    }
     case "daemon":
     case "pick": {
       const kind = cmd;
@@ -3768,7 +4474,7 @@ ${progress}`
         path: r.path,
         trunk: r.trunk,
         pickup: r.pickup ?? false,
-        exists: fs25.existsSync(r.path)
+        exists: fs28.existsSync(r.path)
       }));
       console.log(toonTable("repos", rows, ["key", "path", "trunk", "pickup", "exists"]));
       break;
@@ -3793,6 +4499,11 @@ ${progress}`
           stream: arg(args, "--stream")
         });
         console.log(toonKV({ key: w.key, owner: w.owner, cursor: w.cursor, registered: true }));
+        console.log(
+          toonHelp(
+            w.owner === "man" ? ["lobstah man wait   (its events wake you)", "lobstah watch   (list watches)"] : ["lobstah watch   (list watches; events fork the owning chain)"]
+          )
+        );
         break;
       }
       if (sub === "rm") {
@@ -3813,7 +4524,7 @@ ${progress}`
       break;
     }
     case "init": {
-      if (!fs25.existsSync(configPath())) {
+      if (!fs28.existsSync(configPath())) {
         const exampleRepo = args.includes("--scan") ? "" : `[repos.example]
 path  = "~/src/example"
 trunk = "main"
@@ -3822,7 +4533,7 @@ trunk = "main"
 # pickup = true   # opt into [pickup.github] multi-repo tracker pickup
 
 `;
-        fs25.writeFileSync(
+        fs28.writeFileSync(
           configPath(),
           `# lobstah workspace definitions \u2014 the descriptor's repo key resolves here.
 # Top-level keys must come before any [section].
@@ -3860,12 +4571,12 @@ wallClockSecs      = 3600
       let reference = "https://github.com/aequitas-labs/lobstah/blob/main/docs/configuration.md";
       try {
         const local = fileURLToPath2(new URL("../docs/configuration.md", import.meta.url));
-        if (fs25.existsSync(local)) reference = local;
+        if (fs28.existsSync(local)) reference = local;
       } catch {
       }
       console.log(
         toonKV({
-          home: path19.dirname(configPath()),
+          home: path22.dirname(configPath()),
           config: configPath(),
           ...added.length > 0 ? { added: added.join(", ") } : {},
           ...unmarked.length > 0 ? { note: `none marked pickable \u2014 set pickup = true per [repos.*] (or rerun with --pickup)` } : {},
@@ -3879,18 +4590,35 @@ wallClockSecs      = 3600
     case "-v":
       console.log(lobstahVersion());
       break;
-    case void 0:
+    case void 0: {
+      console.log(`lobstah ${lobstahVersion()} \u2014 supervision for coding agents (home: ${lobstahHome()})`);
+      console.log("");
+      console.log(renderTend(buildTendReport()));
+      console.log("");
+      console.log(
+        toonHelp([
+          'lobstah dispatch --repo <key> --brief-text "<brief>"   queue work',
+          "lobstah status <id>                                    one dispatch",
+          "lobstah man tend                                       full fleet pass",
+          "lobstah help                                           every command"
+        ])
+      );
+      break;
+    }
     case "--help":
     case "help":
       console.log(HELP);
       break;
     default:
-      throw new Error(`unknown command "${cmd}" \u2014 run lobstah help`);
+      throw new UsageError(`unknown command "${cmd}" \u2014 run \`lobstah help\``);
   }
 }
 mainCli().catch((err) => {
-  console.error(`error: ${err instanceof Error ? err.message : String(err)}`);
-  process.exit(1);
+  const msg = err instanceof Error ? err.message : String(err);
+  const [first, ...rest] = msg.split("\n");
+  console.log(toonKV({ error: first }));
+  if (rest.length > 0) console.log(rest.join("\n").trimStart());
+  process.exit(err instanceof UsageError ? 2 : 1);
 });
 /*! Bundled license information: