lobstah 0.1.0 → 0.1.2

package/dist/main.js

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
 
 // apps/cli/src/main.ts
-import * as fs16 from "node:fs";
-import * as path12 from "node:path";
+import * as fs23 from "node:fs";
+import * as os6 from "node:os";
+import * as path17 from "node:path";
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { spawnSync } from "node:child_process";
+import { spawnSync as spawnSync4 } from "node:child_process";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/core/dist/types.js
 var VERBS = ["working", "needs-decision", "blocked", "paused", "done", "failed"];
@@ -868,7 +870,8 @@ function loadConfig() {
       trunk: String(r.trunk ?? "main"),
       setup: Array.isArray(r.setup) ? r.setup.map(String) : void 0,
       env: r.env ?? void 0,
-      harness: r.harness ?? void 0
+      harness: r.harness ?? void 0,
+      pickup: r.pickup === void 0 ? void 0 : Boolean(r.pickup)
     };
   }
   return {
@@ -898,6 +901,68 @@ function toonTable(name, rows, cols) {
   return [header, ...rows.map((r) => `  ${cols.map((c) => cell(r[c])).join(",")}`)].join("\n");
 }
 
+// packages/core/dist/version.js
+import * as fs8 from "node:fs";
+function lobstahVersion() {
+  try {
+    const pkg = JSON.parse(fs8.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    if (pkg.name === "lobstah" && typeof pkg.version === "string")
+      return pkg.version;
+  } catch {
+  }
+  return "0.0.0-dev";
+}
+
+// packages/core/dist/harness.js
+import * as fs9 from "node:fs";
+import * as path5 from "node:path";
+import { createRequire } from "node:module";
+function onPath(bin, pathVar = process.env.PATH) {
+  if (!pathVar)
+    return false;
+  const names = process.platform === "win32" ? [bin, `${bin}.exe`, `${bin}.cmd`, `${bin}.bat`] : [bin];
+  for (const dir of pathVar.split(path5.delimiter)) {
+    if (!dir)
+      continue;
+    for (const name of names) {
+      const candidate = path5.join(dir, name);
+      try {
+        fs9.accessSync(candidate, fs9.constants.X_OK);
+        if (fs9.statSync(candidate).isFile())
+          return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+function resolvable(specifier) {
+  try {
+    createRequire(import.meta.url).resolve(specifier);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectHarnesses() {
+  const out = [];
+  if (onPath("claude") || resolvable("@anthropic-ai/claude-agent-sdk"))
+    out.push("claude");
+  if (onPath("codex") || resolvable("@openai/codex-sdk"))
+    out.push("codex");
+  return out;
+}
+function codexInvocation(argv) {
+  if (onPath("codex"))
+    return { file: "codex", argv };
+  try {
+    const cli = createRequire(import.meta.url).resolve("@openai/codex/bin/codex.js");
+    return { file: process.execPath, argv: [cli, ...argv] };
+  } catch {
+    return void 0;
+  }
+}
+
 // packages/supervisor/dist/liveness.js
 import { execFileSync } from "node:child_process";
 function classify(input) {
@@ -956,26 +1021,26 @@ function killGroup(pid, signal = "SIGTERM") {
 }
 
 // packages/supervisor/dist/daemon.js
-import * as fs9 from "node:fs";
+import * as fs11 from "node:fs";
 import * as os3 from "node:os";
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 import { spawn as spawn2 } from "node:child_process";
-import { createRequire } from "node:module";
+import { createRequire as createRequire2 } from "node:module";
 import { fileURLToPath } from "node:url";
 
 // packages/supervisor/dist/notify.js
-import * as fs8 from "node:fs";
-import * as path5 from "node:path";
+import * as fs10 from "node:fs";
+import * as path6 from "node:path";
 import { spawn } from "node:child_process";
 var DEFAULT_NOTIFY_VERBS = ["needs-decision", "blocked", "done", "failed"];
 function cursorPath(id, lane) {
-  return path5.join(laneDirs(lane).state, `${id}.notified`);
+  return path6.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(fs8.readFileSync(cursorPath(id, lane), "utf8")) || 0;
+    cursor = Number(fs10.readFileSync(cursorPath(id, lane), "utf8")) || 0;
   } catch {
     cursor = void 0;
   }
@@ -985,13 +1050,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);
   }
-  fs8.writeFileSync(cursorPath(id, lane), String(log.length));
+  fs10.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 fs8.readdirSync(dir).filter((f) => f.endsWith(".status")).filter((f) => fs8.statSync(path5.join(dir, f)).mtimeMs > cutoff).map((f) => f.slice(0, -".status".length));
+  return fs10.readdirSync(dir).filter((f) => f.endsWith(".status")).filter((f) => fs10.statSync(path6.join(dir, f)).mtimeMs > cutoff).map((f) => f.slice(0, -".status".length));
 }
 function execNotify(command, ev, log = () => {
 }) {
@@ -1021,11 +1086,11 @@ function captureWaitBaseline() {
   return lengths;
 }
 function attnCursorPath(id, lane) {
-  return path5.join(laneDirs(lane).state, `${id}.attn`);
+  return path6.join(laneDirs(lane).state, `${id}.attn`);
 }
 function readAttnCursor(file) {
   try {
-    const parsed = JSON.parse(fs8.readFileSync(file, "utf8"));
+    const parsed = JSON.parse(fs10.readFileSync(file, "utf8"));
     return { seen: parsed.seen ?? 0, at: parsed.at ?? 0 };
   } catch {
     return { seen: 0, at: 0 };
@@ -1051,7 +1116,7 @@ function attentionNow(consume = true, remindMs = 15 * 6e4, now = Date.now()) {
         continue;
       out.push({ id, lane, entry });
       if (consume)
-        fs8.writeFileSync(file, JSON.stringify({ seen: Math.max(cursor.seen, index + 1), at: now }));
+        fs10.writeFileSync(file, JSON.stringify({ seen: Math.max(cursor.seen, index + 1), at: now }));
     }
   }
   return out;
@@ -1076,7 +1141,7 @@ function freshWakeEvents(baseline, verbs = DEFAULT_NOTIFY_VERBS) {
 }
 
 // packages/supervisor/dist/daemon.js
-var require_ = createRequire(import.meta.url);
+var require_ = createRequire2(import.meta.url);
 function runnerEntry() {
   try {
     return require_.resolve("@lobstah/runner");
@@ -1086,33 +1151,33 @@ function runnerEntry() {
 }
 function readRunnerInfo(dir) {
   try {
-    return JSON.parse(fs9.readFileSync(path6.join(dir, "runner.json"), "utf8"));
+    return JSON.parse(fs11.readFileSync(path7.join(dir, "runner.json"), "utf8"));
   } catch {
     return void 0;
   }
 }
 function listActive(lane) {
   const dir = laneDirs(lane).active;
-  return fs9.readdirSync(dir).filter((f) => !f.startsWith(".")).map((id) => {
-    const d = path6.join(dir, id);
+  return fs11.readdirSync(dir).filter((f) => !f.startsWith(".")).map((id) => {
+    const d = path7.join(dir, id);
     return { id, lane, dir: d, runner: readRunnerInfo(d) };
   });
 }
 function finalize(st) {
   try {
-    fs9.renameSync(st.dir, path6.join(laneDirs(st.lane).done, st.id));
+    fs11.renameSync(st.dir, path7.join(laneDirs(st.lane).done, st.id));
   } catch {
   }
 }
 function spawnRunner(st, opts) {
   let nudge = opts.nudge;
-  const handoffFile = path6.join(st.dir, "handoff");
-  if (!nudge && fs9.existsSync(handoffFile)) {
-    nudge = fs9.readFileSync(handoffFile, "utf8");
-    fs9.unlinkSync(handoffFile);
+  const handoffFile = path7.join(st.dir, "handoff");
+  if (!nudge && fs11.existsSync(handoffFile)) {
+    nudge = fs11.readFileSync(handoffFile, "utf8");
+    fs11.unlinkSync(handoffFile);
   }
-  const logPath = path6.join(laneDirs(st.lane).state, `${st.id}.runner.log`);
-  const log = fs9.openSync(logPath, "a");
+  const logPath = path7.join(laneDirs(st.lane).state, `${st.id}.runner.log`);
+  const log = fs11.openSync(logPath, "a");
   const child = spawn2(process.execPath, [runnerEntry(), st.dir, st.lane], {
     detached: true,
     stdio: ["ignore", log, log],
@@ -1123,7 +1188,7 @@ function spawnRunner(st, opts) {
       ...nudge ? { LOBSTAH_NUDGE: nudge } : {}
     }
   });
-  fs9.closeSync(log);
+  fs11.closeSync(log);
   child.unref();
   const info = {
     pid: child.pid ?? -1,
@@ -1131,30 +1196,38 @@ function spawnRunner(st, opts) {
     processStartTime: child.pid ? processStartTime(child.pid) : void 0,
     attempts: opts.attempts
   };
-  fs9.writeFileSync(path6.join(st.dir, "runner.json"), JSON.stringify(info, null, 2));
+  fs11.writeFileSync(path7.join(st.dir, "runner.json"), JSON.stringify(info, null, 2));
 }
 function sessionOf(st) {
   try {
-    const ev = JSON.parse(fs9.readFileSync(path6.join(laneDirs(st.lane).state, `${st.id}.evidence`), "utf8"));
+    const ev = JSON.parse(fs11.readFileSync(path7.join(laneDirs(st.lane).state, `${st.id}.evidence`), "utf8"));
     return ev.sessionId;
   } catch {
     return void 0;
   }
 }
 function reconcileOne(st, cfg, log) {
-  const hasDescriptor = fs9.existsSync(path6.join(st.dir, "descriptor.json"));
+  const hasDescriptor = fs11.existsSync(path7.join(st.dir, "descriptor.json"));
   if (!hasDescriptor) {
-    const age = Date.now() - fs9.statSync(st.dir).mtimeMs;
+    const age = Date.now() - fs11.statSync(st.dir).mtimeMs;
     if (age > 5 * 6e4)
-      fs9.rmSync(st.dir, { recursive: true, force: true });
+      fs11.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;
-  if (cancelRequested(st.id, st.lane) && st.runner && alive) {
-    log(`${st.id}: cancel requested, killing group ${st.runner.pid}`);
-    killGroup(st.runner.pid);
+  if (cancelRequested(st.id, st.lane)) {
+    if (st.runner && alive) {
+      log(`${st.id}: cancel requested, killing group ${st.runner.pid}`);
+      killGroup(st.runner.pid);
+      return;
+    }
+    if (lastVerb !== "done" && lastVerb !== "failed") {
+      appendStatus(st.id, st.lane, "failed", "cancelled by request; work preserved");
+    }
+    finalize(st);
+    log(`${st.id}: cancelled, finalized`);
     return;
   }
   const cls = classify({
@@ -1216,22 +1289,22 @@ function writeHeartbeat(cfg) {
   const payload = {
     machineId: os3.hostname(),
     repos: Object.keys(cfg.repos),
-    harnesses: ["claude", "codex"],
+    harnesses: detectHarnesses(),
     maxConcurrent: cfg.limits.maxConcurrent,
-    version: "0.1.0",
+    version: lobstahVersion(),
     heartbeat: (/* @__PURE__ */ new Date()).toISOString()
   };
   const tmp = `${executorPath()}.tmp`;
-  fs9.writeFileSync(tmp, JSON.stringify(payload, null, 2));
-  fs9.renameSync(tmp, executorPath());
+  fs11.writeFileSync(tmp, JSON.stringify(payload, null, 2));
+  fs11.renameSync(tmp, executorPath());
 }
 function pruneChores(cfg) {
   const dir = laneDirs("chore").done;
   const cutoff = Date.now() - cfg.limits.choreRetentionDays * 864e5;
-  for (const id of fs9.readdirSync(dir)) {
-    const p = path6.join(dir, id);
-    if (fs9.statSync(p).mtimeMs < cutoff)
-      fs9.rmSync(p, { recursive: true, force: true });
+  for (const id of fs11.readdirSync(dir)) {
+    const p = path7.join(dir, id);
+    if (fs11.statSync(p).mtimeMs < cutoff)
+      fs11.rmSync(p, { recursive: true, force: true });
   }
 }
 var daemonStartedAt = Date.now();
@@ -1271,9 +1344,9 @@ function tick(log = () => {
   pruneChores(loadConfig());
 }
 function acquireDaemonLock() {
-  const lockPath = path6.join(lobstahHome(), "daemon.lock");
+  const lockPath = path7.join(lobstahHome(), "daemon.lock");
   try {
-    const prior = JSON.parse(fs9.readFileSync(lockPath, "utf8"));
+    const prior = JSON.parse(fs11.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`);
     }
@@ -1281,10 +1354,10 @@ function acquireDaemonLock() {
     if (err instanceof Error && err.message.includes("already supervises"))
       throw err;
   }
-  fs9.writeFileSync(lockPath, JSON.stringify({ pid: process.pid, processStartTime: processStartTime(process.pid), startedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
+  fs11.writeFileSync(lockPath, JSON.stringify({ pid: process.pid, processStartTime: processStartTime(process.pid), startedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
   const release = () => {
     try {
-      fs9.unlinkSync(lockPath);
+      fs11.unlinkSync(lockPath);
     } catch {
     }
   };
@@ -1314,7 +1387,7 @@ async function daemon(intervalMs = 5e3, log = console.log) {
 import { spawn as spawn3 } from "node:child_process";
 
 // apps/pick/dist/config.js
-import * as fs10 from "node:fs";
+import * as fs12 from "node:fs";
 import { execSync } from "node:child_process";
 import * as os4 from "node:os";
 
@@ -1333,6 +1406,11 @@ function marker(uuid) {
 }
 
 // apps/pick/dist/config.js
+function githubRepoFromOrigin(origin) {
+  const m = /^git@github\.com:(.+?)(?:\.git)?$/.exec(origin) ?? /^ssh:\/\/git@github\.com\/(.+?)(?:\.git)?$/.exec(origin) ?? /^https:\/\/github\.com\/(.+?)(?:\.git)?\/?$/.exec(origin);
+  const repo = m?.[1];
+  return repo && repo.split("/").length === 2 ? repo : void 0;
+}
 function resolveTokenSource(section, label) {
   const command = section.tokenCommand ? String(section.tokenCommand) : void 0;
   const file = section.tokenFile ? String(section.tokenFile) : void 0;
@@ -1351,7 +1429,7 @@ function resolveTokenSource(section, label) {
   }
   if (file) {
     return () => {
-      const token = fs10.readFileSync(file.startsWith("~/") ? `${os4.homedir()}/${file.slice(2)}` : file, "utf8").trim();
+      const token = fs12.readFileSync(file.startsWith("~/") ? `${os4.homedir()}/${file.slice(2)}` : file, "utf8").trim();
       if (!token)
         throw new Error(`${label}: tokenFile ${file} is empty`);
       return token;
@@ -1369,36 +1447,70 @@ function resolveTokenSource(section, label) {
 }
 function loadPickupConfig() {
   const file = configPath();
-  const raw = fs10.existsSync(file) ? parse(fs10.readFileSync(file, "utf8")) : {};
+  const raw = fs12.existsSync(file) ? parse(fs12.readFileSync(file, "utf8")) : {};
   const p = raw.pickup ?? {};
   const out = {
     pollSecs: Number(p.pollSecs ?? 45),
-    notifyCommand: p.notifyCommand ? String(p.notifyCommand) : void 0
+    notifyCommand: p.notifyCommand ? String(p.notifyCommand) : void 0,
+    github: []
   };
   const gh = p.github;
   if (gh) {
     const token = resolveTokenSource({ tokenEnv: "GITHUB_TOKEN", ...gh }, "pickup.github");
     token();
-    out.github = {
-      repo: String(gh.repo ?? ""),
-      key: String(gh.key ?? ""),
-      identity: String(gh.identity ?? ""),
+    const identity = String(gh.identity ?? "");
+    if (!identity)
+      throw new Error("pickup.github requires identity");
+    const shared = {
+      identity,
       token,
       startLabel: String(gh.startLabel ?? "lobstah"),
-      claimedLabel: String(gh.claimedLabel ?? "lobstah:claimed"),
-      merge: { ...DEFAULT_MERGE_POLICY, ...gh.merge ?? {} }
+      claimedLabel: String(gh.claimedLabel ?? "lobstah:claimed")
     };
-    if (!out.github.repo || !out.github.key || !out.github.identity) {
-      throw new Error("pickup.github requires repo, key, and identity");
+    const mergeBase = { ...DEFAULT_MERGE_POLICY, ...gh.merge ?? {} };
+    const overrides = gh.overrides ?? {};
+    if (gh.repo || gh.key) {
+      const single = { ...shared, repo: String(gh.repo ?? ""), key: String(gh.key ?? ""), merge: mergeBase };
+      if (!single.repo || !single.key)
+        throw new Error("pickup.github requires repo, key, and identity");
+      out.github.push(single);
+    } else {
+      for (const [key, repo] of Object.entries(loadConfig().repos)) {
+        if (!repo.pickup)
+          continue;
+        if (!repo.origin)
+          throw new Error(`repos.${key} has pickup = true but no origin to derive the GitHub repo from`);
+        const forgeRepo = githubRepoFromOrigin(repo.origin);
+        if (!forgeRepo)
+          throw new Error(`repos.${key} has pickup = true but origin "${repo.origin}" is not a GitHub URL`);
+        const o = overrides[key] ?? {};
+        out.github.push({
+          ...shared,
+          repo: forgeRepo,
+          key,
+          startLabel: o.startLabel ? String(o.startLabel) : shared.startLabel,
+          claimedLabel: o.claimedLabel ? String(o.claimedLabel) : shared.claimedLabel,
+          merge: { ...mergeBase, ...o.merge ?? {} }
+        });
+      }
+      if (out.github.length === 0) {
+        throw new Error("pickup.github has no repo \u2014 multi-repo mode needs at least one [repos.<key>] with pickup = true and a GitHub origin");
+      }
     }
   }
   const ln = p.linear;
   if (ln) {
     const token = resolveTokenSource({ tokenEnv: "LINEAR_TOKEN", ...ln }, "pickup.linear");
     token();
+    const assignField = ln.assignField ? String(ln.assignField) : "assignee";
+    if (assignField !== "assignee" && assignField !== "delegate") {
+      throw new Error(`pickup.linear.assignField must be "assignee" or "delegate", got "${assignField}"`);
+    }
     out.linear = {
       token,
+      assignField,
       startState: String(ln.startState ?? "Todo"),
+      startStateTypes: Array.isArray(ln.startStateTypes) ? ln.startStateTypes.map(String) : void 0,
       claimedState: String(ln.claimedState ?? "In Progress"),
       doneState: String(ln.doneState ?? "In Review"),
       route: ln.route ?? {}
@@ -1408,23 +1520,23 @@ function loadPickupConfig() {
 }
 
 // apps/pick/dist/state.js
-import * as fs11 from "node:fs";
-import * as path7 from "node:path";
+import * as fs13 from "node:fs";
+import * as path8 from "node:path";
 var PickupState = class {
   file;
   data;
-  constructor(dir = path7.join(lobstahHome(), "pickup")) {
-    fs11.mkdirSync(dir, { recursive: true });
-    this.file = path7.join(dir, "state.json");
-    this.data = fs11.existsSync(this.file) ? JSON.parse(fs11.readFileSync(this.file, "utf8")) : { map: {}, consumedApprovals: {}, rebases: {} };
+  constructor(dir = path8.join(lobstahHome(), "pickup")) {
+    fs13.mkdirSync(dir, { recursive: true });
+    this.file = path8.join(dir, "state.json");
+    this.data = fs13.existsSync(this.file) ? JSON.parse(fs13.readFileSync(this.file, "utf8")) : { map: {}, consumedApprovals: {}, rebases: {} };
     this.data.map ??= {};
     this.data.consumedApprovals ??= {};
     this.data.rebases ??= {};
   }
   save() {
     const tmp = `${this.file}.tmp-${process.pid}`;
-    fs11.writeFileSync(tmp, JSON.stringify(this.data, null, 2));
-    fs11.renameSync(tmp, this.file);
+    fs13.writeFileSync(tmp, JSON.stringify(this.data, null, 2));
+    fs13.renameSync(tmp, this.file);
   }
   get(key) {
     return this.data.map[key];
@@ -1624,6 +1736,15 @@ When the change is complete, commit it, push the branch, and open a PR against $
     const pr = await this.api("GET", `/repos/${this.cfg.repo}/pulls/${n}`);
     return pr.state === "open" ? this.toCandidate(pr) : void 0;
   }
+  async disposition(n) {
+    const pr = await this.api("GET", `/repos/${this.cfg.repo}/pulls/${n}`);
+    if (pr.state === "open")
+      return "open";
+    return pr.merged_at ? "merged" : "closed";
+  }
+  forgeRepo() {
+    return this.cfg.repo;
+  }
   async updateBranch(n) {
     await this.api("PUT", `/repos/${this.cfg.repo}/pulls/${n}/update-branch`, {});
   }
@@ -1669,12 +1790,14 @@ var LinearSource = class {
     }
     return json.data;
   }
-  async assigned(stateName) {
-    const data = await this.gql(`query($state: String!) {
-        issues(filter: { assignee: { isMe: { eq: true } }, state: { name: { eq: $state } } }, first: 50) {
-          nodes { id identifier title description state { name } team { key id } }
+  async assigned(stateName, byTypes) {
+    const field = this.cfg.assignField ?? "assignee";
+    const stateFilter = byTypes?.length ? { type: { in: byTypes } } : { name: { eq: stateName } };
+    const data = await this.gql(`query($filter: IssueFilter!) {
+        issues(filter: $filter, first: 50) {
+          nodes { id identifier title description state { name type } team { key id } }
         }
-      }`, { state: stateName });
+      }`, { filter: { [field]: { isMe: { eq: true } }, state: stateFilter } });
     return data.issues.nodes;
   }
   async stateId(teamId, name) {
@@ -1692,7 +1815,7 @@ var LinearSource = class {
   }
   async issueByKey(key) {
     const identifier = key.replace(/^linear:/, "");
-    const data = await this.gql(`query($id: String!) { issue(id: $id) { id identifier title description state { name } team { key id } } }`, { id: identifier });
+    const data = await this.gql(`query($id: String!) { issue(id: $id) { id identifier title description state { name type } team { key id } } }`, { id: identifier });
     return data.issue;
   }
   async moveTo(issue, stateName) {
@@ -1703,7 +1826,7 @@ var LinearSource = class {
     await this.gql(`mutation($id: String!, $body: String!) { commentCreate(input: { issueId: $id, body: $body }) { success } }`, { id: issue.id, body });
   }
   async poll() {
-    const issues = await this.assigned(this.cfg.startState);
+    const issues = await this.assigned(this.cfg.startState, this.cfg.startStateTypes);
     return issues.flatMap((issue) => {
       const repoKey = this.cfg.route[issue.team.key];
       if (!repoKey)
@@ -1725,7 +1848,8 @@ When the change is complete, commit it, push the branch, and open a PR whose des
   }
   async claim(item) {
     const issue = await this.issueByKey(item.key);
-    if (issue.state.name !== this.cfg.startState)
+    const stillWaiting = this.cfg.startStateTypes?.length ? this.cfg.startStateTypes.includes(issue.state.type) : issue.state.name === this.cfg.startState;
+    if (!stillWaiting)
       return false;
     await this.moveTo(issue, this.cfg.claimedState);
     return true;
@@ -1796,12 +1920,12 @@ async function dispatchLoop(source, state, log = () => {
 }
 
 // apps/pick/dist/loops/report.js
-import * as fs12 from "node:fs";
-import * as path8 from "node:path";
+import * as fs14 from "node:fs";
+import * as path9 from "node:path";
 function dispatchLane(uuid) {
   for (const lane of ["work", "chore"]) {
     const d = laneDirs(lane);
-    if (fs12.existsSync(path8.join(d.active, uuid)) || fs12.existsSync(path8.join(d.queue, `${uuid}.json`)) || fs12.existsSync(path8.join(d.done, uuid)) || fs12.existsSync(path8.join(d.state, `${uuid}.status`))) {
+    if (fs14.existsSync(path9.join(d.active, uuid)) || fs14.existsSync(path9.join(d.queue, `${uuid}.json`)) || fs14.existsSync(path9.join(d.done, uuid)) || fs14.existsSync(path9.join(d.state, `${uuid}.status`))) {
       return lane;
     }
   }
@@ -1842,12 +1966,12 @@ async function reportLoop(source, state, log = () => {
 }
 
 // apps/pick/dist/loops/reconcile.js
-import * as fs13 from "node:fs";
-import * as path9 from "node:path";
+import * as fs15 from "node:fs";
+import * as path10 from "node:path";
 function dispatchActive(uuid) {
   for (const lane of ["work", "chore"]) {
     const d = laneDirs(lane);
-    if (fs13.existsSync(path9.join(d.active, uuid)) || fs13.existsSync(path9.join(d.queue, `${uuid}.json`))) {
+    if (fs15.existsSync(path10.join(d.active, uuid)) || fs15.existsSync(path10.join(d.queue, `${uuid}.json`))) {
       return lane;
     }
   }
@@ -1887,8 +2011,57 @@ async function reconcileLoop(source, state, log = () => {
 
 // apps/pick/dist/loops/merge.js
 import { randomUUID as randomUUID2 } from "node:crypto";
-import * as fs14 from "node:fs";
-import * as path10 from "node:path";
+import * as fs17 from "node:fs";
+import * as path12 from "node:path";
+
+// apps/pick/dist/merge-view.js
+import * as fs16 from "node:fs";
+import * as path11 from "node:path";
+function viewPath() {
+  return path11.join(lobstahHome(), "pickup", "merge-view.json");
+}
+function readMergeView() {
+  try {
+    return JSON.parse(fs16.readFileSync(viewPath(), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function writeMergeView(view) {
+  const file = viewPath();
+  fs16.mkdirSync(path11.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}`;
+  fs16.writeFileSync(tmp, JSON.stringify(view, null, 2));
+  fs16.renameSync(tmp, file);
+}
+var RECENT_RETENTION_MS = 48 * 36e5;
+async function recordMergeView(repo, open, disposition, now = /* @__PURE__ */ new Date()) {
+  const prev = readMergeView();
+  const recent = (prev?.recent ?? []).filter((r) => now.getTime() - Date.parse(r.at) < RECENT_RETENTION_MS);
+  const stillOpen = new Set(open.map((p) => p.number));
+  for (const was of prev?.open ?? []) {
+    if (stillOpen.has(was.number))
+      continue;
+    try {
+      const d = await disposition(was.number);
+      if (d === "open")
+        continue;
+      recent.push({ number: was.number, url: was.url, disposition: d, at: now.toISOString() });
+    } catch {
+    }
+  }
+  writeMergeView({ updatedAt: now.toISOString(), repo, open, recent });
+}
+function readPickupMap() {
+  try {
+    const raw = JSON.parse(fs16.readFileSync(path11.join(lobstahHome(), "pickup", "state.json"), "utf8"));
+    return raw.map ?? {};
+  } catch {
+    return {};
+  }
+}
+
+// apps/pick/dist/loops/merge.js
 function qualifyingSet(policy, pr) {
   const restricted = pr.labels.some((l) => policy.restrictedLabels.includes(l));
   if (restricted || !policy.assigneeApproves)
@@ -1915,7 +2088,7 @@ function rebaseBrief(pr) {
 }
 function choreVerdict(uuid) {
   const d = laneDirs("chore");
-  if (fs14.existsSync(path10.join(d.active, uuid)) || fs14.existsSync(path10.join(d.queue, `${uuid}.json`)))
+  if (fs17.existsSync(path12.join(d.active, uuid)) || fs17.existsSync(path12.join(d.queue, `${uuid}.json`)))
     return "active";
   const last = readStatusLog(uuid, "chore").at(-1)?.verb;
   return last === "done" ? "done" : "failed";
@@ -1924,54 +2097,78 @@ async function mergeLoop(ms, policy, state, log = () => {
 }) {
   if (!policy.enabled)
     return;
+  const observed = [];
+  const observe = (pr, gate) => {
+    const m = /^lobstah\/([0-9a-f-]{36})$/.exec(pr.headRef);
+    observed.push({
+      number: pr.number,
+      url: pr.url,
+      headRef: pr.headRef,
+      headSha: pr.headSha,
+      mergeableState: pr.mergeableState,
+      gate,
+      uuid: m?.[1]
+    });
+  };
   for (const candidate of await ms.mergeCandidates()) {
     const prKey = `${ms.name}#${candidate.number}`;
     const rebase = state.rebase(prKey);
     if (rebase) {
-      if (rebase.failed)
+      if (rebase.failed) {
+        observe(candidate, "rebase-failed");
         continue;
+      }
       const verdict = choreVerdict(rebase.uuid);
-      if (verdict === "active")
+      if (verdict === "active") {
+        observe(candidate, `conflict-chore:${rebase.uuid}`);
         continue;
+      }
       if (verdict === "failed") {
         await ms.comment(candidate.number, `Automated rebase failed (dispatch ${rebase.uuid}) \u2014 needs a human.`);
         await ms.addLabel(candidate.number, "needs-human");
         state.failRebase(prKey);
         log(`${prKey}: rebase chore failed, flagged for a human`);
+        observe(candidate, "rebase-failed");
         continue;
       }
       state.clearRebase(prKey);
     }
     const provisional = qualifiedApproval(policy, candidate);
-    if (!provisional)
-      continue;
-    if (state.approvalConsumed(approvalDedupKey(candidate, provisional)))
+    if (!provisional || state.approvalConsumed(approvalDedupKey(candidate, provisional))) {
+      observe(candidate, "waiting-approval");
       continue;
+    }
     const pr = await ms.refresh(candidate.number);
     if (!pr)
       continue;
     const approval = qualifiedApproval(policy, pr);
     if (!approval) {
       log(`${prKey}: gate no longer holds on fresh fetch \u2014 skipping`);
+      observe(pr, "waiting-approval");
       continue;
     }
     const dedupKey = approvalDedupKey(pr, approval);
-    if (state.approvalConsumed(dedupKey))
+    if (state.approvalConsumed(dedupKey)) {
+      observe(pr, "waiting-approval");
       continue;
+    }
     switch (pr.mergeableState) {
       case "blocked":
       case "draft":
         log(`${prKey}: ${pr.mergeableState} \u2014 not merging`);
+        observe(pr, pr.mergeableState);
         break;
       case "behind":
         await ms.updateBranch(pr.number);
         log(`${prKey}: behind base, updated branch \u2014 gate re-enters next tick`);
+        observe(pr, "behind-updated");
         break;
       case "dirty": {
         const uuid = randomUUID2();
         enqueue({ id: uuid, repo: ms.repoKey(), brief: rebaseBrief(pr) }, "chore");
         state.setRebase(prKey, uuid);
         log(`${prKey}: real conflict \u2014 wrote rebase chore ${uuid}`);
+        observe(pr, `conflict-chore:${uuid}`);
         break;
       }
       default: {
@@ -1981,6 +2178,7 @@ async function mergeLoop(ms, policy, state, log = () => {
       }
     }
   }
+  await recordMergeView(ms.forgeRepo(), observed, (n) => ms.disposition(n));
 }
 
 // apps/pick/dist/run.js
@@ -2031,10 +2229,10 @@ async function runPickup(mode = "daemon") {
   const log = (m) => console.log(`[pickup] ${m}`);
   const sources = [];
   const merges = [];
-  if (cfg.github) {
-    const gh = new GithubSource(cfg.github);
+  for (const ghCfg of cfg.github) {
+    const gh = new GithubSource(ghCfg);
     sources.push(gh);
-    merges.push({ source: gh, policy: cfg.github.merge });
+    merges.push({ source: gh, policy: ghCfg.merge });
   }
   if (cfg.linear)
     sources.push(new LinearSource(cfg.linear));
@@ -2066,14 +2264,179 @@ function mergeHaulHook(existing) {
   return { settings, changed: true };
 }
 
+// apps/cli/src/tend.ts
+import * as fs18 from "node:fs";
+import * as path13 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(fs18.readFileSync(file, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function doneIds(lane) {
+  try {
+    return fs18.readdirSync(laneDirs(lane).done).filter((f) => !f.startsWith("."));
+  } catch {
+    return [];
+  }
+}
+function describeDispatch(id, lane, bucket) {
+  const log = readStatusLog(id, lane);
+  const last = log.at(-1);
+  const state = bucket === "queued" ? "queued" : reconcile({ log, lastEventAt: lastEventAt(id, lane) });
+  const evidence = readEvidence(id, lane);
+  return { id, lane, bucket, state, note: last?.note, at: last?.at, prUrl: evidence.prUrl };
+}
+function followUps(uuid) {
+  const out = [];
+  const d = laneDirs("work");
+  const scan = (id, bucket, file) => {
+    const desc = readJson(file);
+    if (desc?.followUp === uuid) out.push({ id, bucket });
+  };
+  for (const id of pendingIds("work")) scan(id, "queued", path13.join(d.queue, `${id}.json`));
+  for (const id of activeIds("work")) scan(id, "active", path13.join(d.active, id, "descriptor.json"));
+  for (const id of doneIds("work")) scan(id, "done", path13.join(d.done, id, "descriptor.json"));
+  return out;
+}
+function bucketOf(uuid) {
+  const d = laneDirs("work");
+  if (fs18.existsSync(path13.join(d.active, uuid))) return "active";
+  if (fs18.existsSync(path13.join(d.done, uuid))) return "done";
+  if (fs18.existsSync(path13.join(d.queue, `${uuid}.json`))) return "queued";
+  return void 0;
+}
+function buildTendReport(now = Date.now()) {
+  const cfg = loadConfig();
+  const heartbeat = readJson(executorPath())?.heartbeat;
+  const daemonUp = heartbeat !== void 0 && now - Date.parse(heartbeat) < HEARTBEAT_STALE_MS;
+  const queued = pendingIds("work");
+  const active = activeIds("work");
+  const choresActive = activeIds("chore").length + pendingIds("chore").length;
+  let done24h = 0;
+  let failed24h = 0;
+  for (const lane of ["work", "chore"]) {
+    for (const id of doneIds(lane)) {
+      const last = readStatusLog(id, lane).at(-1);
+      if (!last || now - Date.parse(last.at) > DAY_MS) continue;
+      if (last.verb === "failed") failed24h += 1;
+      else if (last.verb === "done") done24h += 1;
+    }
+  }
+  const remindMs = (cfg.remindSecs ?? 900) * 1e3;
+  const attention = attentionNow(false, remindMs, now).map((ev) => ({
+    id: ev.id,
+    lane: ev.lane,
+    verb: ev.entry.verb,
+    ageSecs: Math.max(0, Math.round((now - Date.parse(ev.entry.at)) / 1e3)),
+    note: ev.entry.note
+  }));
+  const oldestQueuedAge = queued.reduce((max, id) => {
+    const st = fs18.statSync(path13.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;
+  const merge = readMergeView();
+  const gateFor = (uuid, prUrl) => {
+    const open = merge?.open.find((p) => p.uuid === uuid || prUrl !== void 0 && p.url === prUrl);
+    if (open) return open.gate;
+    const recent = merge?.recent.find((r) => prUrl !== void 0 && r.url === prUrl);
+    return recent?.disposition;
+  };
+  const storied = /* @__PURE__ */ new Set();
+  const stories = [];
+  for (const [key, entry] of Object.entries(readPickupMap())) {
+    const bucket = bucketOf(entry.uuid);
+    if (!bucket) continue;
+    const chain = [describeDispatch(entry.uuid, "work", bucket)];
+    for (const f of followUps(entry.uuid)) chain.push(describeDispatch(f.id, "work", f.bucket));
+    for (const d of chain) storied.add(d.id);
+    const fresh = chain.some((d) => d.bucket !== "done" || d.at !== void 0 && now - Date.parse(d.at) < DAY_MS);
+    if (!fresh) continue;
+    const prUrl = chain.map((d) => d.prUrl).find((u) => u !== void 0);
+    stories.push({ key, dispatches: chain, prUrl, gate: gateFor(entry.uuid, prUrl) });
+  }
+  for (const id of [...active, ...queued]) {
+    if (storied.has(id)) continue;
+    const d = describeDispatch(id, "work", bucketOf(id) ?? "active");
+    stories.push({ key: "(direct)", dispatches: [d], prUrl: d.prUrl, gate: gateFor(id, d.prUrl) });
+  }
+  const verdict = !daemonUp ? "daemon-down" : stalled ? "stalled" : attention.length > 0 ? "needs-attention" : active.length + queued.length > 0 ? "working" : "idle";
+  return {
+    verdict,
+    daemon: { up: daemonUp, lastHeartbeat: heartbeat },
+    counts: { queued: queued.length, active: active.length, choresActive, done24h, failed24h },
+    attention,
+    stories,
+    merge
+  };
+}
+function renderTend(r) {
+  const lines = [];
+  lines.push(
+    toonKV({
+      verdict: r.verdict,
+      daemon: r.daemon.up ? "up" : `down (last heartbeat ${r.daemon.lastHeartbeat ?? "never"})`,
+      queued: r.counts.queued,
+      active: r.counts.active,
+      chores: r.counts.choresActive,
+      done24h: r.counts.done24h,
+      failed24h: r.counts.failed24h
+    })
+  );
+  if (r.attention.length > 0) {
+    lines.push("");
+    lines.push(
+      toonTable(
+        "attention",
+        r.attention.map((a) => ({ id: a.id, verb: a.verb, waitingMins: Math.round(a.ageSecs / 60), note: a.note ?? "" })),
+        ["id", "verb", "waitingMins", "note"]
+      )
+    );
+  }
+  if (r.stories.length > 0) {
+    lines.push("");
+    lines.push(
+      toonTable(
+        "work",
+        r.stories.map((s) => ({
+          key: s.key,
+          dispatches: s.dispatches.map((d) => `${d.id.slice(0, 8)}:${d.state}`).join(" \u2192 "),
+          pr: s.prUrl ?? "",
+          gate: s.gate ?? ""
+        })),
+        ["key", "dispatches", "pr", "gate"]
+      )
+    );
+  }
+  if (r.merge && (r.merge.open.length > 0 || r.merge.recent.length > 0)) {
+    lines.push("");
+    lines.push(
+      toonTable(
+        `prs (${r.merge.repo}, observed ${r.merge.updatedAt})`,
+        [
+          ...r.merge.open.map((p) => ({ pr: `#${p.number}`, state: p.mergeableState, gate: p.gate, url: p.url })),
+          ...r.merge.recent.map((p) => ({ pr: `#${p.number}`, state: p.disposition, gate: "", url: p.url }))
+        ],
+        ["pr", "state", "gate", "url"]
+      )
+    );
+  }
+  return lines.join("\n");
+}
+
 // apps/cli/src/cull.ts
-import * as fs15 from "node:fs";
-import * as path11 from "node:path";
+import * as fs19 from "node:fs";
+import * as path14 from "node:path";
 import { execFileSync as execFileSync2 } from "node:child_process";
 var DAY = 864e5;
 function idsIn(dir) {
   try {
-    return new Set(fs15.readdirSync(dir).filter((f) => !f.startsWith(".")).map((f) => f.replace(/\.json$/, "")));
+    return new Set(fs19.readdirSync(dir).filter((f) => !f.startsWith(".")).map((f) => f.replace(/\.json$/, "")));
   } catch {
     return /* @__PURE__ */ new Set();
   }
@@ -2088,39 +2451,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 = path11.join(d.done, id);
-      const m = fs15.statSync(p).mtimeMs;
+      const p = path14.join(d.done, id);
+      const m = fs19.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 = path11.join(lobstahHome(), "worktrees");
+  const wtRoot = path14.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 = path11.join(wtRoot, id);
-    items.push({ kind: "worktree", id, target: p, ageDays: Math.floor((now - fs15.statSync(p).mtimeMs) / DAY) });
+    const p = path14.join(wtRoot, id);
+    items.push({ kind: "worktree", id, target: p, ageDays: Math.floor((now - fs19.statSync(p).mtimeMs) / DAY) });
   }
   for (const lane of ["work", "chore"]) {
     const d = laneDirs(lane);
     const seen = /* @__PURE__ */ new Set();
-    for (const f of fs15.readdirSync(d.state)) {
+    for (const f of fs19.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 = fs15.statSync(path11.join(d.state, f)).mtimeMs;
+      const m = fs19.statSync(path14.join(d.state, f)).mtimeMs;
       if (m >= cutoff) continue;
       seen.add(id);
-      items.push({ kind: "state", id, target: path11.join(d.state, `${id}.*`), ageDays: Math.floor((now - m) / DAY) });
+      items.push({ kind: "state", id, target: path14.join(d.state, `${id}.*`), ageDays: Math.floor((now - m) / DAY) });
     }
   }
   return items;
 }
 function removeWorktree(id, dir) {
   for (const lane of ["work", "chore"]) {
-    const descFile = path11.join(laneDirs(lane).done, id, "descriptor.json");
+    const descFile = path14.join(laneDirs(lane).done, id, "descriptor.json");
     try {
-      const desc = JSON.parse(fs15.readFileSync(descFile, "utf8"));
+      const desc = JSON.parse(fs19.readFileSync(descFile, "utf8"));
       const repo = loadConfig().repos[desc.repo];
       if (repo) {
         execFileSync2("git", ["worktree", "remove", "--force", dir], { cwd: repo.path, stdio: "ignore" });
@@ -2129,15 +2492,15 @@ function removeWorktree(id, dir) {
     } catch {
     }
   }
-  fs15.rmSync(dir, { recursive: true, force: true });
+  fs19.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")) fs15.rmSync(item.target, { recursive: true, force: true });
+  for (const item of items.filter((i) => i.kind === "done")) fs19.rmSync(item.target, { recursive: true, force: true });
   for (const item of items.filter((i) => i.kind === "state")) {
-    const dir = path11.dirname(item.target);
-    for (const f of fs15.readdirSync(dir)) {
-      if (f.startsWith(`${item.id}.`)) fs15.rmSync(path11.join(dir, f), { force: true });
+    const dir = path14.dirname(item.target);
+    for (const f of fs19.readdirSync(dir)) {
+      if (f.startsWith(`${item.id}.`)) fs19.rmSync(path14.join(dir, f), { force: true });
     }
   }
 }
@@ -2160,6 +2523,9 @@ your working set:
   lobstah catch <id>                            land the catch (evidence)
   lobstah cancel <id>                           cut one away
   lobstah cull [--apply]                        sweep aged catch and lost gear
+  lobstah man tend [--json]                     tend the string: fleet verdict,
+                                                unanswered questions, each work
+                                                item's chain + PR + merge gate
 
 getting woken instead of asking:
   lobstah man wait          block until a dispatch needs attention (arm it as a
@@ -2178,8 +2544,270 @@ 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 fs20 from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
+import { spawnSync } from "node:child_process";
+var HEARTBEAT_STALE_MS2 = 9e4;
+function git(repoPath, ...args) {
+  const res = spawnSync("git", ["-C", repoPath, ...args], { encoding: "utf8" });
+  return { ok: res.status === 0, out: (res.stdout ?? "").trim() || (res.stderr ?? "").trim() };
+}
+function runDoctor(now = Date.now()) {
+  const rows = [];
+  const push = (check, status, detail) => rows.push({ check, status, detail });
+  const major = Number(process.versions.node.split(".")[0]);
+  push("node", major >= 20 ? "ok" : "fail", `v${process.versions.node}${major >= 20 ? "" : " \u2014 lobstah needs >=20"}`);
+  push("git", onPath("git") ? "ok" : "fail", onPath("git") ? "on PATH" : "not on PATH");
+  const claude = onPath("claude");
+  push("harness claude", claude ? "ok" : "warn", claude ? "on PATH" : "claude not on PATH \u2014 claude dispatches will fail");
+  const codexPath = onPath("codex");
+  let codexSdk = false;
+  try {
+    createRequire3(import.meta.url).resolve("@openai/codex-sdk");
+    codexSdk = true;
+  } catch {
+  }
+  push(
+    "harness codex",
+    codexPath || codexSdk ? "ok" : "warn",
+    codexPath ? "on PATH" : codexSdk ? "vendored SDK (attach uses it too)" : "neither codex nor the SDK \u2014 codex dispatches will fail"
+  );
+  const cfgFile = configPath();
+  if (!fs20.existsSync(cfgFile)) {
+    push("config", "fail", `${cfgFile} missing \u2014 run \`lobstah init\``);
+    return rows;
+  }
+  let parsed;
+  try {
+    parsed = parse(fs20.readFileSync(cfgFile, "utf8"));
+    push("config", "ok", cfgFile);
+  } catch (err) {
+    push("config", "fail", `${cfgFile}: ${err instanceof Error ? err.message : String(err)}`);
+    return rows;
+  }
+  const cfg = loadConfig();
+  const repoKeys = Object.keys(cfg.repos);
+  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 (!fs20.existsSync(repo.path)) {
+      push(label, "fail", `path ${repo.path} does not exist`);
+      continue;
+    }
+    if (!git(repo.path, "rev-parse", "--is-inside-work-tree").ok) {
+      push(label, "fail", `${repo.path} is not a git repository`);
+      continue;
+    }
+    const trunk = git(repo.path, "rev-parse", "--verify", "--quiet", `origin/${repo.trunk}`);
+    push(
+      label,
+      trunk.ok ? "ok" : "warn",
+      trunk.ok ? `${repo.path} (trunk origin/${repo.trunk})` : `origin/${repo.trunk} not found \u2014 check trunk or \`git fetch\``
+    );
+  }
+  if (parsed.pickup) {
+    try {
+      const pk = loadPickupConfig();
+      const sources = [
+        ...pk.github.map((g) => `gh:${g.repo}\u2192${g.key}`),
+        ...pk.linear ? ["linear"] : []
+      ];
+      push("pickup", sources.length > 0 ? "ok" : "warn", sources.join(", ") || "section present but no sources");
+    } catch (err) {
+      push("pickup", "fail", err instanceof Error ? err.message : String(err));
+    }
+  }
+  const hb = executorPath();
+  if (!fs20.existsSync(hb)) {
+    push("daemon", "warn", "no heartbeat \u2014 daemon not running (`lobstah daemon install`)");
+  } else {
+    try {
+      const payload = JSON.parse(fs20.readFileSync(hb, "utf8"));
+      const age = now - new Date(payload.heartbeat ?? 0).getTime();
+      push(
+        "daemon",
+        age < HEARTBEAT_STALE_MS2 ? "ok" : "warn",
+        age < HEARTBEAT_STALE_MS2 ? `heartbeat ${Math.round(age / 1e3)}s ago (v${payload.version ?? "?"})` : `heartbeat stale (${Math.round(age / 1e3)}s) \u2014 daemon down or wedged`
+      );
+    } catch {
+      push("daemon", "warn", "heartbeat unreadable");
+    }
+  }
+  push("lobstah", "ok", `v${lobstahVersion()} at ${process.argv[1] ?? "?"}`);
+  return rows;
+}
+
+// apps/cli/src/service.ts
+import * as fs21 from "node:fs";
+import * as os5 from "node:os";
+import * as path15 from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+function xml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function renderLaunchdPlist(spec) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>lobstah.${spec.kind}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${xml(spec.nodePath)}</string>
+    <string>${xml(spec.entry)}</string>
+    <string>${spec.kind}</string>
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key><string>${xml(spec.pathEnv)}</string>
+    <key>LOBSTAH_HOME</key><string>${xml(spec.home)}</string>
+  </dict>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${xml(path15.join(spec.logDir, `${spec.kind}.log`))}</string>
+  <key>StandardErrorPath</key><string>${xml(path15.join(spec.logDir, `${spec.kind}.err`))}</string>
+</dict>
+</plist>
+`;
+}
+function renderSystemdUnit(spec) {
+  return `[Unit]
+Description=lobstah ${spec.kind}
+
+[Service]
+ExecStart=${spec.nodePath} ${spec.entry} ${spec.kind}
+Restart=always
+RestartSec=5
+Environment=PATH=${spec.pathEnv}
+Environment=LOBSTAH_HOME=${spec.home}
+StandardOutput=append:${path15.join(spec.logDir, `${spec.kind}.log`)}
+StandardError=append:${path15.join(spec.logDir, `${spec.kind}.err`)}
+
+[Install]
+WantedBy=default.target
+`;
+}
+function servicePathEnv(nodePath, home = os5.homedir()) {
+  const dirs = [
+    path15.dirname(nodePath),
+    path15.join(home, ".local", "bin"),
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    "/usr/bin",
+    "/bin"
+  ];
+  return [...new Set(dirs)].join(path15.delimiter);
+}
+function serviceFile(kind) {
+  return process.platform === "darwin" ? path15.join(os5.homedir(), "Library", "LaunchAgents", `lobstah.${kind}.plist`) : path15.join(os5.homedir(), ".config", "systemd", "user", `lobstah-${kind}.service`);
+}
+function run(cmd, args) {
+  const res = spawnSync2(cmd, args, { encoding: "utf8" });
+  return { ok: res.status === 0, out: `${res.stdout ?? ""}${res.stderr ?? ""}`.trim() };
+}
+function installService(kind) {
+  const entry = fs21.realpathSync(process.argv[1]);
+  const spec = {
+    kind,
+    nodePath: process.execPath,
+    entry,
+    pathEnv: servicePathEnv(process.execPath),
+    home: lobstahHome(),
+    logDir: path15.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`);
+  }
+  fs21.mkdirSync(spec.logDir, { recursive: true });
+  const file = serviceFile(kind);
+  fs21.mkdirSync(path15.dirname(file), { recursive: true });
+  if (process.platform === "darwin") {
+    if (fs21.existsSync(file)) run("launchctl", ["unload", file]);
+    fs21.writeFileSync(file, renderLaunchdPlist(spec));
+    const load = run("launchctl", ["load", file]);
+    return { file, loaded: load.ok, detail: load.ok ? `label lobstah.${kind}` : load.out };
+  }
+  fs21.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 };
+}
+function uninstallService(kind) {
+  const file = serviceFile(kind);
+  if (process.platform === "darwin") {
+    if (fs21.existsSync(file)) run("launchctl", ["unload", file]);
+  } else {
+    run("systemctl", ["--user", "disable", "--now", `lobstah-${kind}.service`]);
+  }
+  const removed = fs21.existsSync(file);
+  if (removed) fs21.unlinkSync(file);
+  if (process.platform !== "darwin") run("systemctl", ["--user", "daemon-reload"]);
+  return { file, removed };
+}
+
+// apps/cli/src/repos.ts
+import * as fs22 from "node:fs";
+import * as path16 from "node:path";
+import { spawnSync as spawnSync3 } from "node:child_process";
+function git2(dir, ...args) {
+  const res = spawnSync3("git", ["-C", dir, ...args], { encoding: "utf8" });
+  return res.status === 0 ? res.stdout.trim() : void 0;
+}
+var LOCKFILE_SETUP = [
+  ["pnpm-lock.yaml", ["pnpm install"]],
+  ["package-lock.json", ["npm install"]],
+  ["yarn.lock", ["yarn install"]],
+  ["bun.lockb", ["bun install"]],
+  ["bun.lock", ["bun install"]],
+  ["uv.lock", ["uv sync"]],
+  ["poetry.lock", ["poetry install"]]
+];
+function detectRepo(dir) {
+  const abs = path16.resolve(dir);
+  if (git2(abs, "rev-parse", "--is-inside-work-tree") !== "true") return void 0;
+  const top = git2(abs, "rev-parse", "--show-toplevel");
+  if (!top || fs22.realpathSync(top) !== fs22.realpathSync(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]) => fs22.existsSync(path16.join(abs, f)))?.[1];
+  return { key: path16.basename(abs), path: abs, trunk, origin, setup };
+}
+function scanForRepos(roots) {
+  const found = [];
+  for (const root of roots) {
+    const abs = path16.resolve(root);
+    if (!fs22.existsSync(abs)) continue;
+    const self = detectRepo(abs);
+    if (self) {
+      found.push(self);
+      continue;
+    }
+    for (const entry of fs22.readdirSync(abs, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+      const child = detectRepo(path16.join(abs, entry.name));
+      if (child) found.push(child);
+    }
+  }
+  return found;
+}
+function configuredRepoKeys(file = configPath()) {
+  if (!fs22.existsSync(file)) return /* @__PURE__ */ new Set();
+  const raw = parse(fs22.readFileSync(file, "utf8"));
+  return new Set(Object.keys(raw.repos ?? {}));
+}
+function appendRepoBlock(repo, opts = {}, file = configPath()) {
+  const lines = [``, `[repos.${repo.key}]`, `path  = ${JSON.stringify(repo.path)}`, `trunk = ${JSON.stringify(repo.trunk)}`];
+  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`);
+  fs22.appendFileSync(file, `${lines.join("\n")}
+`);
+}
+
 // apps/cli/src/main.ts
-var HELP = `lobstah \u2014 supervisor for local coding agents
+var HELP = `lobstah \u2014 supervision framework for coding agents
 
 work (humans and agents):
   dispatch --repo <key> (--brief <file> | --brief-text <text>)   (alias: set --bait)
@@ -2206,22 +2834,33 @@ work (humans and agents):
                                   Dry run by default (14 days).
   cancel <uuid>                   request cancellation
 
-host processes (run under launchd/systemd/pm2):
+host processes:
   daemon [--interval <ms>]        the supervisor: claims, worktrees, liveness,
                                   restart ladder, notifyCommand. One per home.
   pick [once]                     tracker loops: poll Linear/GitHub, dispatch
                                   assigned work, report back, reconcile, merge
+  daemon install|uninstall        write + load the launchd agent / systemd user
+  pick install|uninstall          unit for this host, with resolved node and
+                                  lobstah paths (launchd gets no shell env)
 
 lobsterman (orchestrator sessions \u2014 bare \`lobstah man\` prints the manual):
+  man tend [--json]               tend the whole string: fleet verdict (daemon
+                                  up, stalled vs idle), unanswered questions
+                                  with ages, each work item's dispatch chain,
+                                  PR, and merge-gate status from pick's last
+                                  observation. Pure disk read \u2014 no forge calls.
   man wait [--timeout <secs>] [--peek]
                                   block until a dispatch needs attention, then
                                   print the event and what to do next; exit 2
                                   on timeout. Unanswered questions re-fire
                                   every remindSecs until answered.
-  man init [--shared] [--marker]  install the haul Stop hook into this
-                                  project's .claude/settings.local.json
-                                  (--shared: settings.json); --marker touches
-                                  .lobstah-man. Idempotent.
+  man init [--shared|--global] [--marker]
+                                  install the haul Stop hook: this project's
+                                  .claude/settings.local.json by default,
+                                  settings.json with --shared, or once into
+                                  ~/.claude/settings.json with --global (any
+                                  directory with a .lobstah-man file then
+                                  parks); --marker touches .lobstah-man.
   man haul [--timeout <secs>]     Stop-hook entry point: park the session while
                                   work is in flight; prints hook-decision JSON
                                   on an event, silent exit 0 otherwise. Gate:
@@ -2233,7 +2872,16 @@ workers (dispatched agents; injected into every brief):
                                   (${VERBS.join(" | ")})
 
 setup:
-  init                            create ~/.lobstah + example config
+  init [--scan <dir>... [--pickup]]
+                                  create ~/.lobstah + example config; --scan
+                                  detects git repos under the given roots and
+                                  appends a [repos.*] block per repo (--pickup
+                                  marks them pickable by [pickup.github])
+  repos [add <path> [--pickup] [--key <k>]]
+                                  list configured repos, or detect + append one
+  doctor                          check binaries, config, repos, harnesses, and
+                                  the daemon heartbeat; exit 1 on failures
+  version | --version             the installed lobstah version
 
 Everything except daemon and pick works with both stopped: writes are files,
 reads are files. Output is TOON; agents can drive this CLI directly.
@@ -2245,7 +2893,7 @@ function arg(args, flag) {
 function findLane(id) {
   for (const lane of ["work", "chore"]) {
     const d = laneDirs(lane);
-    if (fs16.existsSync(path12.join(d.active, id)) || fs16.existsSync(path12.join(d.queue, `${id}.json`)) || fs16.existsSync(path12.join(d.done, id)) || fs16.existsSync(path12.join(d.state, `${id}.status`))) {
+    if (fs23.existsSync(path17.join(d.active, id)) || fs23.existsSync(path17.join(d.queue, `${id}.json`)) || fs23.existsSync(path17.join(d.done, id)) || fs23.existsSync(path17.join(d.state, `${id}.status`))) {
       return lane;
     }
   }
@@ -2253,7 +2901,7 @@ function findLane(id) {
 }
 function rowsFor(lane, bucket) {
   const dir = laneDirs(lane)[bucket];
-  const entries = fs16.readdirSync(dir).filter((f) => !f.startsWith(".")).map((f) => ({ f, m: fs16.statSync(path12.join(dir, f)).mtimeMs })).sort((a, b) => b.m - a.m);
+  const entries = fs23.readdirSync(dir).filter((f) => !f.startsWith(".")).map((f) => ({ f, m: fs23.statSync(path17.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$/, "");
@@ -2281,7 +2929,7 @@ async function mainCli() {
       const d = {
         id: arg(args, "--id") ?? randomUUID3(),
         repo,
-        brief: briefText ?? fs16.readFileSync(briefFile, "utf8"),
+        brief: briefText ?? fs23.readFileSync(briefFile, "utf8"),
         harness: arg(args, "--harness"),
         model: arg(args, "--model"),
         effort: arg(args, "--effort"),
@@ -2318,17 +2966,17 @@ async function mainCli() {
       if (!id) throw new Error("logs requires a dispatch id");
       const lane = findLane(id);
       const file = eventsPath(id, lane);
-      if (fs16.existsSync(file)) process.stdout.write(fs16.readFileSync(file, "utf8"));
+      if (fs23.existsSync(file)) process.stdout.write(fs23.readFileSync(file, "utf8"));
       if (args.includes("--follow")) {
-        let size = fs16.existsSync(file) ? fs16.statSync(file).size : 0;
+        let size = fs23.existsSync(file) ? fs23.statSync(file).size : 0;
         setInterval(() => {
-          if (!fs16.existsSync(file)) return;
-          const now = fs16.statSync(file).size;
+          if (!fs23.existsSync(file)) return;
+          const now = fs23.statSync(file).size;
           if (now > size) {
-            const fd = fs16.openSync(file, "r");
+            const fd = fs23.openSync(file, "r");
             const buf = Buffer.alloc(now - size);
-            fs16.readSync(fd, buf, 0, buf.length, size);
-            fs16.closeSync(fd);
+            fs23.readSync(fd, buf, 0, buf.length, size);
+            fs23.closeSync(fd);
             process.stdout.write(buf.toString("utf8"));
             size = now;
           }
@@ -2384,22 +3032,23 @@ async function mainCli() {
         );
       }
       const dirs = laneDirs(lane);
-      const descriptorFile = ["active", "done"].map((b) => path12.join(dirs[b], id, "descriptor.json")).find((f) => fs16.existsSync(f));
-      const harness = descriptorFile ? JSON.parse(fs16.readFileSync(descriptorFile, "utf8")).harness ?? "claude" : "claude";
+      const descriptorFile = ["active", "done"].map((b) => path17.join(dirs[b], id, "descriptor.json")).find((f) => fs23.existsSync(f));
+      const harness = descriptorFile ? JSON.parse(fs23.readFileSync(descriptorFile, "utf8")).harness ?? "claude" : "claude";
       let sessionId;
       try {
-        sessionId = JSON.parse(fs16.readFileSync(path12.join(dirs.state, `${id}.evidence`), "utf8")).sessionId;
+        sessionId = JSON.parse(fs23.readFileSync(path17.join(dirs.state, `${id}.evidence`), "utf8")).sessionId;
       } catch {
       }
       if (!sessionId) throw new Error(`${id} has no recorded harness session to attach to`);
-      const worktree = path12.join(lobstahHome(), "worktrees", id);
-      const cwd = fs16.existsSync(worktree) ? worktree : process.cwd();
-      const invocation = harness === "codex" ? { file: "codex", argv: ["resume", sessionId] } : { file: "claude", argv: ["--resume", sessionId] };
+      const worktree = path17.join(lobstahHome(), "worktrees", id);
+      const cwd = fs23.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 = spawnSync(invocation.file, invocation.argv, { cwd, stdio: "inherit" });
+      const res = spawnSync4(invocation.file, invocation.argv, { cwd, stdio: "inherit" });
       if (res.error) throw new Error(`could not launch ${invocation.file}: ${res.error.message}`);
       break;
     }
@@ -2407,39 +3056,39 @@ async function mainCli() {
       const id = args[0];
       if (!id) throw new Error("swap requires a dispatch id");
       const lane = findLane(id);
-      const activeDir = path12.join(laneDirs(lane).active, id);
-      if (!fs16.existsSync(activeDir)) throw new Error(`${id} is not active \u2014 swap only applies to in-flight dispatches`);
-      const descFile = path12.join(activeDir, "descriptor.json");
-      const descriptor = JSON.parse(fs16.readFileSync(descFile, "utf8"));
+      const activeDir = path17.join(laneDirs(lane).active, id);
+      if (!fs23.existsSync(activeDir)) throw new Error(`${id} is not active \u2014 swap only applies to in-flight dispatches`);
+      const descFile = path17.join(activeDir, "descriptor.json");
+      const descriptor = JSON.parse(fs23.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;
       }
-      fs16.writeFileSync(descFile, JSON.stringify(descriptor, null, 2));
-      const worktree = path12.join(lobstahHome(), "worktrees", id);
+      fs23.writeFileSync(descFile, JSON.stringify(descriptor, null, 2));
+      const worktree = path17.join(lobstahHome(), "worktrees", id);
       let progress = "No worktree progress recorded.";
-      if (fs16.existsSync(worktree)) {
-        const git = (...a) => spawnSync("git", a, { cwd: worktree, encoding: "utf8" }).stdout?.trim() ?? "";
-        const commits = git("log", "--oneline", "-15");
-        const status = git("status", "--short");
+      if (fs23.existsSync(worktree)) {
+        const git3 = (...a) => spawnSync4("git", a, { cwd: worktree, encoding: "utf8" }).stdout?.trim() ?? "";
+        const commits = git3("log", "--oneline", "-15");
+        const status = git3("status", "--short");
         progress = `Commits so far:
 ${commits || "(none)"}
 
 Uncommitted changes:
 ${status || "(clean)"}`;
       }
-      fs16.writeFileSync(
-        path12.join(activeDir, "handoff"),
+      fs23.writeFileSync(
+        path17.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 = path12.join(activeDir, "runner.json");
-      if (fs16.existsSync(runnerFile)) {
-        const runner = JSON.parse(fs16.readFileSync(runnerFile, "utf8"));
+      const runnerFile = path17.join(activeDir, "runner.json");
+      if (fs23.existsSync(runnerFile)) {
+        const runner = JSON.parse(fs23.readFileSync(runnerFile, "utf8"));
         if (pidAlive(runner.pid, runner.processStartTime)) killGroup(runner.pid, "SIGKILL");
-        fs16.unlinkSync(runnerFile);
+        fs23.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 }));
@@ -2490,6 +3139,11 @@ ${progress}`
       console.log(MANUAL);
       break;
     }
+    case "man:tend": {
+      const report = buildTendReport();
+      console.log(args.includes("--json") ? JSON.stringify(report, null, 2) : renderTend(report));
+      break;
+    }
     case "cancel": {
       const id = args[0];
       if (!id) throw new Error("cancel requires a dispatch id");
@@ -2529,35 +3183,35 @@ ${progress}`
       break;
     }
     case "man:init": {
-      const file = path12.join(".claude", args.includes("--shared") ? "settings.json" : "settings.local.json");
+      const file = args.includes("--global") ? path17.join(os6.homedir(), ".claude", "settings.json") : path17.join(".claude", args.includes("--shared") ? "settings.json" : "settings.local.json");
       let existing;
       try {
-        existing = JSON.parse(fs16.readFileSync(file, "utf8"));
+        existing = JSON.parse(fs23.readFileSync(file, "utf8"));
       } catch {
         existing = void 0;
       }
       const { settings, changed } = mergeHaulHook(existing);
       if (changed) {
-        fs16.mkdirSync(".claude", { recursive: true });
-        fs16.writeFileSync(file, `${JSON.stringify(settings, null, 2)}
+        fs23.mkdirSync(path17.dirname(file), { recursive: true });
+        fs23.writeFileSync(file, `${JSON.stringify(settings, null, 2)}
 `);
       }
-      if (args.includes("--marker")) fs16.writeFileSync(".lobstah-man", "");
+      if (args.includes("--marker")) fs23.writeFileSync(".lobstah-man", "");
       console.log(
         toonKV({
           hook: "lobstah man haul",
           file,
           installed: changed || "already present",
-          gate: args.includes("--marker") ? ".lobstah-man (this directory)" : "launch with LOBSTAH_MAN=1 claude"
+          gate: args.includes("--marker") ? ".lobstah-man (this directory)" : args.includes("--global") ? "touch .lobstah-man in a project (or LOBSTAH_MAN=1) to arm it there" : "launch with LOBSTAH_MAN=1 claude"
         })
       );
       break;
     }
     case "man:haul": {
       try {
-        if (process.env.LOBSTAH_MAN !== "1" && !fs16.existsSync(".lobstah-man")) break;
+        if (process.env.LOBSTAH_MAN !== "1" && !fs23.existsSync(".lobstah-man")) break;
         const anyActive = ["work", "chore"].some(
-          (l) => fs16.readdirSync(laneDirs(l).active).some((f) => !f.startsWith("."))
+          (l) => fs23.readdirSync(laneDirs(l).active).some((f) => !f.startsWith("."))
         );
         if (!anyActive) break;
         const timeoutSecs = Number(arg(args, "--timeout") ?? "14000");
@@ -2588,31 +3242,74 @@ ${progress}`
       }
       break;
     }
-    case "daemon": {
-      const interval = Number(arg(args, "--interval") ?? "5000");
-      await daemon(interval);
+    case "daemon":
+    case "pick": {
+      const kind = cmd;
+      if (args[0] === "install") {
+        const res = installService(kind);
+        console.log(toonKV({ service: kind, file: res.file, loaded: res.loaded, detail: res.detail }));
+        break;
+      }
+      if (args[0] === "uninstall") {
+        const res = uninstallService(kind);
+        console.log(toonKV({ service: kind, file: res.file, removed: res.removed }));
+        break;
+      }
+      if (kind === "daemon") await daemon(Number(arg(args, "--interval") ?? "5000"));
+      else await runPickup(args[0] === "once" ? "once" : "daemon");
+      break;
+    }
+    case "doctor": {
+      const rows = runDoctor();
+      console.log(toonTable("doctor", rows, ["check", "status", "detail"]));
+      if (rows.some((r) => r.status === "fail")) process.exitCode = 1;
       break;
     }
-    case "pick": {
-      await runPickup(args[0] === "once" ? "once" : "daemon");
+    case "repos": {
+      if (args[0] === "add") {
+        const target = args[1];
+        if (!target) throw new Error("repos add requires a path");
+        const detected = detectRepo(target);
+        if (!detected) throw new Error(`${target} is not the root of a git repository`);
+        const key = arg(args, "--key") ?? detected.key;
+        if (configuredRepoKeys().has(key)) throw new Error(`repos.${key} already configured \u2014 edit ${configPath()} directly`);
+        appendRepoBlock({ ...detected, key }, { pickup: args.includes("--pickup") });
+        console.log(toonKV({ key, path: detected.path, trunk: detected.trunk, origin: detected.origin, pickup: args.includes("--pickup") }));
+        break;
+      }
+      const repos = loadConfig().repos;
+      const rows = Object.entries(repos).map(([key, r]) => ({
+        key,
+        path: r.path,
+        trunk: r.trunk,
+        pickup: r.pickup ?? false,
+        exists: fs23.existsSync(r.path)
+      }));
+      console.log(toonTable("repos", rows, ["key", "path", "trunk", "pickup", "exists"]));
+      break;
+    }
+    case "version": {
+      console.log(lobstahVersion());
       break;
     }
     case "init": {
-      if (!fs16.existsSync(configPath())) {
-        fs16.writeFileSync(
+      if (!fs23.existsSync(configPath())) {
+        const exampleRepo = args.includes("--scan") ? "" : `[repos.example]
+path  = "~/src/example"
+trunk = "main"
+# origin = "git@github.com:you/example.git"
+# setup  = ["pnpm install"]
+# pickup = true   # opt into [pickup.github] multi-repo tracker pickup
+
+`;
+        fs23.writeFileSync(
           configPath(),
           `# lobstah workspace definitions \u2014 the descriptor's repo key resolves here.
 # Top-level keys must come before any [section].
 # notifyCommand = "ntfy pub my-topic "$LOBSTAH_VERB $LOBSTAH_ID: $LOBSTAH_NOTE""
 # notifyVerbs   = ["needs-decision", "blocked", "done", "failed"]   # the default
 
-[repos.example]
-path  = "~/src/example"
-trunk = "main"
-# origin = "git@github.com:you/example.git"
-# setup  = ["pnpm install"]
-
-[harness]
+${exampleRepo}[harness]
 default = "claude"
 
 [limits]
@@ -2624,16 +3321,44 @@ wallClockSecs      = 3600
 `
         );
       }
+      const scanIdx = args.indexOf("--scan");
+      const added = [];
+      const unmarked = [];
+      if (scanIdx >= 0) {
+        const roots = args.slice(scanIdx + 1).filter((a) => !a.startsWith("--"));
+        if (roots.length === 0) throw new Error("--scan requires at least one directory");
+        const known = configuredRepoKeys();
+        const pickup = args.includes("--pickup");
+        for (const repo of scanForRepos(roots)) {
+          if (known.has(repo.key)) continue;
+          known.add(repo.key);
+          appendRepoBlock(repo, { pickup });
+          added.push(repo.key);
+          if (!pickup) unmarked.push(repo.key);
+        }
+      }
+      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 (fs23.existsSync(local)) reference = local;
+      } catch {
+      }
       console.log(
         toonKV({
-          home: path12.dirname(configPath()),
+          home: path17.dirname(configPath()),
           config: configPath(),
-          reference: "docs/configuration.md",
+          ...added.length > 0 ? { added: added.join(", ") } : {},
+          ...unmarked.length > 0 ? { note: `none marked pickable \u2014 set pickup = true per [repos.*] (or rerun with --pickup)` } : {},
+          reference,
           initialized: true
         })
       );
       break;
     }
+    case "--version":
+    case "-v":
+      console.log(lobstahVersion());
+      break;
     case void 0:
     case "--help":
     case "help":