lobstah 0.1.1 → 0.2.0

package/dist/main.js

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
 
 // apps/cli/src/main.ts
-import * as fs18 from "node:fs";
-import * as path14 from "node:path";
-import { randomUUID as randomUUID3 } from "node:crypto";
-import { spawnSync } from "node:child_process";
+import * as fs25 from "node:fs";
+import * as os6 from "node:os";
+import * as path19 from "node:path";
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { spawnSync as spawnSync5 } 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"];
@@ -36,6 +38,7 @@ function ensureLayout() {
       fs.mkdirSync(dir, { recursive: true });
   }
   fs.mkdirSync(path.join(lobstahHome(), "worktrees"), { recursive: true });
+  fs.mkdirSync(path.join(lobstahHome(), "watches"), { recursive: true });
 }
 function statusPath(id, lane) {
   return path.join(laneDirs(lane).state, `${id}.status`);
@@ -868,7 +871,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 +902,235 @@ 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/core/dist/watch.js
+import * as fs10 from "node:fs";
+import * as path6 from "node:path";
+import { spawnSync } from "node:child_process";
+function watchesDir() {
+  return path6.join(lobstahHome(), "watches");
+}
+function slug(key) {
+  return key.replace(/[^A-Za-z0-9._-]+/g, "-");
+}
+function watchPath(key) {
+  return path6.join(watchesDir(), `${slug(key)}.json`);
+}
+function eventsPath2(key) {
+  return path6.join(watchesDir(), `${slug(key)}.events`);
+}
+function writeWatch(w) {
+  fs10.mkdirSync(watchesDir(), { recursive: true });
+  const file = watchPath(w.key);
+  const tmp = `${file}.tmp`;
+  fs10.writeFileSync(tmp, JSON.stringify(w, null, 2));
+  fs10.renameSync(tmp, file);
+}
+function readWatch(key) {
+  try {
+    return JSON.parse(fs10.readFileSync(watchPath(key), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function listWatches() {
+  if (!fs10.existsSync(watchesDir()))
+    return [];
+  return fs10.readdirSync(watchesDir()).filter((f) => f.endsWith(".json")).map((f) => {
+    try {
+      return JSON.parse(fs10.readFileSync(path6.join(watchesDir(), f), "utf8"));
+    } catch {
+      return void 0;
+    }
+  }).filter((w) => w !== void 0);
+}
+function addWatch(key, check, opts = {}) {
+  if (!key || !check)
+    throw new Error("watch add requires a key and a --check command");
+  const existing = readWatch(key);
+  const w = {
+    key,
+    owner: opts.owner ?? existing?.owner ?? "man",
+    check,
+    stream: opts.stream ?? existing?.stream,
+    cursor: existing?.cursor ?? opts.cursor ?? "0",
+    everySecs: opts.everySecs ?? existing?.everySecs,
+    brief: opts.brief ?? existing?.brief,
+    createdAt: existing?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    lastCheckedAt: existing?.lastCheckedAt,
+    seen: existing?.seen ?? 0,
+    seenAt: existing?.seenAt ?? 0,
+    lastFollowUpId: existing?.lastFollowUpId
+  };
+  writeWatch(w);
+  return w;
+}
+function removeWatch(key) {
+  const existed = fs10.existsSync(watchPath(key));
+  fs10.rmSync(watchPath(key), { force: true });
+  fs10.rmSync(eventsPath2(key), { force: true });
+  return existed;
+}
+function readWatchEvents(key) {
+  try {
+    return fs10.readFileSync(eventsPath2(key), "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l));
+  } catch {
+    return [];
+  }
+}
+function appendWatchEvents(key, events) {
+  const seen = new Set(readWatchEvents(key).map((e) => String(e.seq)));
+  const fresh = events.filter((e) => !seen.has(String(e.seq)));
+  if (fresh.length > 0) {
+    fs10.appendFileSync(eventsPath2(key), fresh.map((e) => JSON.stringify(e)).join("\n") + "\n");
+  }
+  return fresh;
+}
+function setWatchCursor(key, cursor) {
+  const w = readWatch(key);
+  if (!w || w.cursor === cursor)
+    return;
+  w.cursor = cursor;
+  writeWatch(w);
+}
+function watchDue(w, defaultEverySecs, now = Date.now()) {
+  const every = (w.everySecs ?? defaultEverySecs) * 1e3;
+  const last = w.lastCheckedAt ? Date.parse(w.lastCheckedAt) : 0;
+  return now - last >= every;
+}
+var CHECK_TIMEOUT_MS = 9e4;
+function runWatchCheck(w, now = /* @__PURE__ */ new Date()) {
+  w.lastCheckedAt = now.toISOString();
+  writeWatch(w);
+  const cmd = w.check.replaceAll("{cursor}", w.cursor);
+  const res = spawnSync(cmd, { shell: true, encoding: "utf8", timeout: CHECK_TIMEOUT_MS, maxBuffer: 8 * 1024 * 1024 });
+  if (res.status !== 0 || res.error) {
+    w.lastError = (res.error?.message || res.stderr?.trim() || `exit ${res.status}`).slice(0, 500);
+    writeWatch(w);
+    return { watch: w, fresh: [] };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(res.stdout);
+  } catch {
+    w.lastError = `unparseable check output: ${res.stdout.slice(0, 200).trim()}`;
+    writeWatch(w);
+    return { watch: w, fresh: [] };
+  }
+  w.lastError = void 0;
+  const events = Array.isArray(parsed.events) ? parsed.events.map((e) => ({
+    seq: e.seq ?? w.cursor,
+    summary: e.summary !== void 0 ? String(e.summary) : void 0,
+    ...e,
+    at: now.toISOString()
+  })) : [];
+  const fresh = appendWatchEvents(w.key, events);
+  if (parsed.cursor !== void 0)
+    w.cursor = String(parsed.cursor);
+  if (parsed.done === true)
+    w.done = true;
+  writeWatch(w);
+  return { watch: w, fresh };
+}
+function pendingWatchEvents(consume, owner = "man", now = Date.now()) {
+  const out = [];
+  for (const w of listWatches()) {
+    const isMan = w.owner === "man";
+    if (owner === "man" !== isMan)
+      continue;
+    const events = readWatchEvents(w.key);
+    const fresh = events.slice(w.seen);
+    if (fresh.length === 0) {
+      if (w.done && consume)
+        removeWatch(w.key);
+      continue;
+    }
+    out.push({ watch: w, events: fresh });
+    if (consume) {
+      w.seen = events.length;
+      w.seenAt = now;
+      if (w.done)
+        removeWatch(w.key);
+      else
+        writeWatch(w);
+    }
+  }
+  return out;
+}
+function markFollowUp(key, followUpId, deliveredThrough) {
+  const w = readWatch(key);
+  if (!w)
+    return;
+  w.lastFollowUpId = followUpId;
+  w.seen = deliveredThrough;
+  w.seenAt = Date.now();
+  if (w.done)
+    removeWatch(w.key);
+  else
+    writeWatch(w);
+}
+
 // packages/supervisor/dist/liveness.js
 import { execFileSync } from "node:child_process";
 function classify(input) {
@@ -956,26 +1189,26 @@ function killGroup(pid, signal = "SIGTERM") {
 }
 
 // packages/supervisor/dist/daemon.js
-import * as fs9 from "node:fs";
+import * as fs12 from "node:fs";
 import * as os3 from "node:os";
-import * as path6 from "node:path";
+import * as path8 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 fs11 from "node:fs";
+import * as path7 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 path7.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(fs11.readFileSync(cursorPath(id, lane), "utf8")) || 0;
   } catch {
     cursor = void 0;
   }
@@ -985,13 +1218,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));
+  fs11.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 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));
 }
 function execNotify(command, ev, log = () => {
 }) {
@@ -1021,11 +1254,11 @@ function captureWaitBaseline() {
   return lengths;
 }
 function attnCursorPath(id, lane) {
-  return path5.join(laneDirs(lane).state, `${id}.attn`);
+  return path7.join(laneDirs(lane).state, `${id}.attn`);
 }
 function readAttnCursor(file) {
   try {
-    const parsed = JSON.parse(fs8.readFileSync(file, "utf8"));
+    const parsed = JSON.parse(fs11.readFileSync(file, "utf8"));
     return { seen: parsed.seen ?? 0, at: parsed.at ?? 0 };
   } catch {
     return { seen: 0, at: 0 };
@@ -1051,7 +1284,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 }));
+        fs11.writeFileSync(file, JSON.stringify({ seen: Math.max(cursor.seen, index + 1), at: now }));
     }
   }
   return out;
@@ -1076,7 +1309,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 +1319,33 @@ function runnerEntry() {
 }
 function readRunnerInfo(dir) {
   try {
-    return JSON.parse(fs9.readFileSync(path6.join(dir, "runner.json"), "utf8"));
+    return JSON.parse(fs12.readFileSync(path8.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 fs12.readdirSync(dir).filter((f) => !f.startsWith(".")).map((id) => {
+    const d = path8.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));
+    fs12.renameSync(st.dir, path8.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 = path8.join(st.dir, "handoff");
+  if (!nudge && fs12.existsSync(handoffFile)) {
+    nudge = fs12.readFileSync(handoffFile, "utf8");
+    fs12.unlinkSync(handoffFile);
   }
-  const logPath = path6.join(laneDirs(st.lane).state, `${st.id}.runner.log`);
-  const log = fs9.openSync(logPath, "a");
+  const logPath = path8.join(laneDirs(st.lane).state, `${st.id}.runner.log`);
+  const log = fs12.openSync(logPath, "a");
   const child = spawn2(process.execPath, [runnerEntry(), st.dir, st.lane], {
     detached: true,
     stdio: ["ignore", log, log],
@@ -1123,7 +1356,7 @@ function spawnRunner(st, opts) {
       ...nudge ? { LOBSTAH_NUDGE: nudge } : {}
     }
   });
-  fs9.closeSync(log);
+  fs12.closeSync(log);
   child.unref();
   const info = {
     pid: child.pid ?? -1,
@@ -1131,22 +1364,22 @@ 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));
+  fs12.writeFileSync(path8.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(fs12.readFileSync(path8.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 = fs12.existsSync(path8.join(st.dir, "descriptor.json"));
   if (!hasDescriptor) {
-    const age = Date.now() - fs9.statSync(st.dir).mtimeMs;
+    const age = Date.now() - fs12.statSync(st.dir).mtimeMs;
     if (age > 5 * 6e4)
-      fs9.rmSync(st.dir, { recursive: true, force: true });
+      fs12.rmSync(st.dir, { recursive: true, force: true });
     return;
   }
   const statusLog = readStatusLog(st.id, st.lane);
@@ -1224,22 +1457,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());
+  fs12.writeFileSync(tmp, JSON.stringify(payload, null, 2));
+  fs12.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 fs12.readdirSync(dir)) {
+    const p = path8.join(dir, id);
+    if (fs12.statSync(p).mtimeMs < cutoff)
+      fs12.rmSync(p, { recursive: true, force: true });
   }
 }
 var daemonStartedAt = Date.now();
@@ -1279,9 +1512,9 @@ function tick(log = () => {
   pruneChores(loadConfig());
 }
 function acquireDaemonLock() {
-  const lockPath = path6.join(lobstahHome(), "daemon.lock");
+  const lockPath = path8.join(lobstahHome(), "daemon.lock");
   try {
-    const prior = JSON.parse(fs9.readFileSync(lockPath, "utf8"));
+    const prior = JSON.parse(fs12.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`);
     }
@@ -1289,10 +1522,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));
+  fs12.writeFileSync(lockPath, JSON.stringify({ pid: process.pid, processStartTime: processStartTime(process.pid), startedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
   const release = () => {
     try {
-      fs9.unlinkSync(lockPath);
+      fs12.unlinkSync(lockPath);
     } catch {
     }
   };
@@ -1304,17 +1537,42 @@ function acquireDaemonLock() {
     });
   }
 }
+function watchQueues(onChange) {
+  const watchers = [];
+  for (const lane of ["work", "chore"]) {
+    try {
+      watchers.push(fs12.watch(laneDirs(lane).queue, onChange));
+    } catch {
+    }
+  }
+  return () => {
+    for (const w of watchers)
+      w.close();
+  };
+}
 async function daemon(intervalMs = 5e3, log = console.log) {
   ensureLayout();
   acquireDaemonLock();
   log(`lobstah daemon: watching ${laneDirs("work").queue} every ${intervalMs}ms`);
+  let wake;
+  watchQueues(() => wake?.());
   while (true) {
     try {
       tick(log);
     } catch (err) {
       log(`tick error: ${err instanceof Error ? err.message : String(err)}`);
     }
-    await new Promise((r) => setTimeout(r, intervalMs));
+    await new Promise((resolve2) => {
+      const timer = setTimeout(() => {
+        wake = void 0;
+        resolve2();
+      }, intervalMs);
+      wake = () => {
+        wake = void 0;
+        clearTimeout(timer);
+        setTimeout(resolve2, 50);
+      };
+    });
   }
 }
 
@@ -1322,7 +1580,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 fs13 from "node:fs";
 import { execSync } from "node:child_process";
 import * as os4 from "node:os";
 
@@ -1341,6 +1599,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;
@@ -1359,7 +1622,7 @@ function resolveTokenSource(section, label) {
   }
   if (file) {
     return () => {
-      const token = fs10.readFileSync(file.startsWith("~/") ? `${os4.homedir()}/${file.slice(2)}` : file, "utf8").trim();
+      const token = fs13.readFileSync(file.startsWith("~/") ? `${os4.homedir()}/${file.slice(2)}` : file, "utf8").trim();
       if (!token)
         throw new Error(`${label}: tokenFile ${file} is empty`);
       return token;
@@ -1377,27 +1640,55 @@ function resolveTokenSource(section, label) {
 }
 function loadPickupConfig() {
   const file = configPath();
-  const raw = fs10.existsSync(file) ? parse(fs10.readFileSync(file, "utf8")) : {};
+  const raw = fs13.existsSync(file) ? parse(fs13.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;
@@ -1422,23 +1713,23 @@ function loadPickupConfig() {
 }
 
 // apps/pick/dist/state.js
-import * as fs11 from "node:fs";
-import * as path7 from "node:path";
+import * as fs14 from "node:fs";
+import * as path9 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 = 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: {} };
     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);
+    fs14.writeFileSync(tmp, JSON.stringify(this.data, null, 2));
+    fs14.renameSync(tmp, this.file);
   }
   get(key) {
     return this.data.map[key];
@@ -1822,12 +2113,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 fs15 from "node:fs";
+import * as path10 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 (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`))) {
       return lane;
     }
   }
@@ -1868,12 +2159,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 fs16 from "node:fs";
+import * as path11 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 (fs16.existsSync(path11.join(d.active, uuid)) || fs16.existsSync(path11.join(d.queue, `${uuid}.json`))) {
       return lane;
     }
   }
@@ -1913,28 +2204,28 @@ async function reconcileLoop(source, state, log = () => {
 
 // apps/pick/dist/loops/merge.js
 import { randomUUID as randomUUID2 } from "node:crypto";
-import * as fs15 from "node:fs";
-import * as path11 from "node:path";
+import * as fs18 from "node:fs";
+import * as path13 from "node:path";
 
 // apps/pick/dist/merge-view.js
-import * as fs14 from "node:fs";
-import * as path10 from "node:path";
+import * as fs17 from "node:fs";
+import * as path12 from "node:path";
 function viewPath() {
-  return path10.join(lobstahHome(), "pickup", "merge-view.json");
+  return path12.join(lobstahHome(), "pickup", "merge-view.json");
 }
 function readMergeView() {
   try {
-    return JSON.parse(fs14.readFileSync(viewPath(), "utf8"));
+    return JSON.parse(fs17.readFileSync(viewPath(), "utf8"));
   } catch {
     return void 0;
   }
 }
 function writeMergeView(view) {
   const file = viewPath();
-  fs14.mkdirSync(path10.dirname(file), { recursive: true });
+  fs17.mkdirSync(path12.dirname(file), { recursive: true });
   const tmp = `${file}.tmp-${process.pid}`;
-  fs14.writeFileSync(tmp, JSON.stringify(view, null, 2));
-  fs14.renameSync(tmp, file);
+  fs17.writeFileSync(tmp, JSON.stringify(view, null, 2));
+  fs17.renameSync(tmp, file);
 }
 var RECENT_RETENTION_MS = 48 * 36e5;
 async function recordMergeView(repo, open, disposition, now = /* @__PURE__ */ new Date()) {
@@ -1956,7 +2247,7 @@ async function recordMergeView(repo, open, disposition, now = /* @__PURE__ */ ne
 }
 function readPickupMap() {
   try {
-    const raw = JSON.parse(fs14.readFileSync(path10.join(lobstahHome(), "pickup", "state.json"), "utf8"));
+    const raw = JSON.parse(fs17.readFileSync(path12.join(lobstahHome(), "pickup", "state.json"), "utf8"));
     return raw.map ?? {};
   } catch {
     return {};
@@ -1990,7 +2281,7 @@ function rebaseBrief(pr) {
 }
 function choreVerdict(uuid) {
   const d = laneDirs("chore");
-  if (fs15.existsSync(path11.join(d.active, uuid)) || fs15.existsSync(path11.join(d.queue, `${uuid}.json`)))
+  if (fs18.existsSync(path13.join(d.active, uuid)) || fs18.existsSync(path13.join(d.queue, `${uuid}.json`)))
     return "active";
   const last = readStatusLog(uuid, "chore").at(-1)?.verb;
   return last === "done" ? "done" : "failed";
@@ -2083,6 +2374,126 @@ async function mergeLoop(ms, policy, state, log = () => {
   await recordMergeView(ms.forgeRepo(), observed, (n) => ms.disposition(n));
 }
 
+// apps/pick/dist/loops/watch.js
+import * as fs19 from "node:fs";
+import * as path14 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:
+
+{events}
+
+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`))) {
+      return lane;
+    }
+  }
+  return void 0;
+}
+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 q = path14.join(d.queue, `${id}.json`);
+  if (fs19.existsSync(q))
+    return JSON.parse(fs19.readFileSync(q, "utf8"));
+  return void 0;
+}
+function isTerminal(id) {
+  const lane = laneOf(id);
+  if (!lane)
+    return true;
+  const state = reconcile({ log: readStatusLog(id, lane), lastEventAt: lastEventAt(id, lane) });
+  return state === "done" || state === "failed";
+}
+function spawnContinuation(w, pending, log) {
+  const owner = w.owner.slice("dispatch:".length);
+  const target = w.lastFollowUpId && !laneOf(w.lastFollowUpId) ? owner : w.lastFollowUpId ?? owner;
+  const targetLane = laneOf(target);
+  if (!targetLane) {
+    log(`watch ${w.key}: owner dispatch ${target} is gone \u2014 dropping watch`);
+    removeWatch(w.key);
+    return;
+  }
+  const descriptor = descriptorOf(target, targetLane);
+  if (!descriptor) {
+    log(`watch ${w.key}: no descriptor for ${target} \u2014 dropping watch`);
+    removeWatch(w.key);
+    return;
+  }
+  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");
+  markFollowUp(w.key, id, readWatchEvents(w.key).length);
+  log(`watch ${w.key}: ${pending.length} event(s) \u2192 continuation ${id} (forks ${target})`);
+}
+function notifyMan(watch2, fresh, notify) {
+  if (fresh.length === 0 || watch2.owner !== "man")
+    return;
+  notify({
+    key: watch2.key,
+    uuid: "watch",
+    verb: "watch",
+    note: fresh[0]?.summary ?? `${fresh.length} new event(s)`
+  });
+}
+function deliverDispatchOwned(log) {
+  for (const { watch: watch2, events } of pendingWatchEvents(false, "dispatch")) {
+    if (watch2.lastFollowUpId && !isTerminal(watch2.lastFollowUpId))
+      continue;
+    spawnContinuation(watch2, events, log);
+  }
+  for (const w of listWatches()) {
+    if (w.done && w.owner !== "man" && readWatchEvents(w.key).length <= w.seen)
+      removeWatch(w.key);
+  }
+}
+async function watchLoop(defaultEverySecs, log, notify = () => {
+}) {
+  for (const w of listWatches()) {
+    if (watchDue(w, defaultEverySecs)) {
+      const { watch: watch2, fresh } = runWatchCheck(w);
+      if (watch2.lastError)
+        log(`watch ${w.key}: check failed \u2014 ${watch2.lastError}`);
+      notifyMan(watch2, fresh, notify);
+    }
+  }
+  deliverDispatchOwned(log);
+}
+function handleStreamLine(key, line, log, notify) {
+  const watch2 = readWatch(key);
+  if (!watch2)
+    return;
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    log(`watch ${key}: unparseable stream line \u2014 ${line.slice(0, 120)}`);
+    return;
+  }
+  if (parsed.seq === void 0) {
+    if (parsed.cursor !== void 0)
+      setWatchCursor(key, String(parsed.cursor));
+    return;
+  }
+  const event = {
+    seq: parsed.seq,
+    summary: parsed.summary !== void 0 ? String(parsed.summary) : void 0,
+    ...parsed,
+    at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const fresh = appendWatchEvents(key, event.seq !== void 0 ? [event] : []);
+  setWatchCursor(key, String(parsed.cursor ?? event.seq));
+  notifyMan(watch2, fresh, notify);
+  if (fresh.length > 0)
+    deliverDispatchOwned(log);
+}
+
 // apps/pick/dist/run.js
 function makeNotifier(command, log) {
   if (!command)
@@ -2106,7 +2517,49 @@ function makeNotifier(command, log) {
     child.unref();
   };
 }
-async function cycle(sources, merges, state, log, notify) {
+var SingleFlight = class {
+  chain = Promise.resolve();
+  run(job) {
+    const next = this.chain.then(job, job);
+    this.chain = next.then(() => {
+    }, () => {
+    });
+    return next;
+  }
+};
+function syncStreams(children, flight, log, notify) {
+  for (const w of listWatches()) {
+    if (!w.stream || children.has(w.key))
+      continue;
+    const cmd = w.stream.replaceAll("{cursor}", w.cursor);
+    const child = spawn3(cmd, { shell: true, stdio: ["ignore", "pipe", "ignore"] });
+    children.set(w.key, child);
+    log(`watch ${w.key}: stream attached`);
+    let buffer = "";
+    child.stdout.on("data", (chunk) => {
+      buffer += chunk.toString("utf8");
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.trim())
+          continue;
+        void flight.run(() => handleStreamLine(w.key, line, log, notify));
+      }
+    });
+    child.on("exit", () => {
+      children.delete(w.key);
+      log(`watch ${w.key}: stream ended \u2014 cadence covers until resync`);
+    });
+    child.on("error", () => children.delete(w.key));
+  }
+  for (const [key, child] of children) {
+    if (!readWatch(key)?.stream) {
+      child.kill();
+      children.delete(key);
+    }
+  }
+}
+async function cycle(sources, merges, state, pollSecs, log, notify) {
   for (const source of sources) {
     try {
       await dispatchLoop(source, state, log);
@@ -2123,6 +2576,11 @@ async function cycle(sources, merges, state, log, notify) {
       log(`${source.name} merge: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
+  try {
+    await watchLoop(pollSecs, log, notify);
+  } catch (err) {
+    log(`watches: ${err instanceof Error ? err.message : String(err)}`);
+  }
 }
 async function runPickup(mode = "daemon") {
   ensureLayout();
@@ -2131,24 +2589,30 @@ 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));
   if (sources.length === 0) {
-    throw new Error("no [pickup.github] or [pickup.linear] configured \u2014 nothing to poll");
+    if (listWatches().length === 0) {
+      throw new Error("no [pickup.github], [pickup.linear], or registered watches \u2014 nothing to poll");
+    }
+    log("no tracker sources configured \u2014 watch-only mode");
   }
   const notify = makeNotifier(cfg.notifyCommand, log);
   if (mode === "once") {
-    await cycle(sources, merges, state, log, notify);
+    await cycle(sources, merges, state, cfg.pollSecs, log, notify);
     return;
   }
   log(`polling every ${cfg.pollSecs}s \u2014 no webhooks, no inbound surface`);
+  const flight = new SingleFlight();
+  const streamChildren = /* @__PURE__ */ new Map();
   while (true) {
-    await cycle(sources, merges, state, log, notify);
+    await flight.run(() => cycle(sources, merges, state, cfg.pollSecs, log, notify));
+    syncStreams(streamChildren, flight, log, notify);
     await new Promise((r) => setTimeout(r, cfg.pollSecs * 1e3));
   }
 }
@@ -2167,21 +2631,21 @@ function mergeHaulHook(existing) {
 }
 
 // apps/cli/src/tend.ts
-import * as fs16 from "node:fs";
-import * as path12 from "node:path";
+import * as fs20 from "node:fs";
+import * as path15 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(fs16.readFileSync(file, "utf8"));
+    return JSON.parse(fs20.readFileSync(file, "utf8"));
   } catch {
     return void 0;
   }
 }
 function doneIds(lane) {
   try {
-    return fs16.readdirSync(laneDirs(lane).done).filter((f) => !f.startsWith("."));
+    return fs20.readdirSync(laneDirs(lane).done).filter((f) => !f.startsWith("."));
   } catch {
     return [];
   }
@@ -2200,16 +2664,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", path12.join(d.queue, `${id}.json`));
-  for (const id of activeIds("work")) scan(id, "active", path12.join(d.active, id, "descriptor.json"));
-  for (const id of doneIds("work")) scan(id, "done", path12.join(d.done, id, "descriptor.json"));
+  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"));
   return out;
 }
 function bucketOf(uuid) {
   const d = laneDirs("work");
-  if (fs16.existsSync(path12.join(d.active, uuid))) return "active";
-  if (fs16.existsSync(path12.join(d.done, uuid))) return "done";
-  if (fs16.existsSync(path12.join(d.queue, `${uuid}.json`))) return "queued";
+  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";
   return void 0;
 }
 function buildTendReport(now = Date.now()) {
@@ -2237,8 +2701,39 @@ function buildTendReport(now = Date.now()) {
     ageSecs: Math.max(0, Math.round((now - Date.parse(ev.entry.at)) / 1e3)),
     note: ev.entry.note
   }));
+  const watches = [];
+  const watchByDispatch = /* @__PURE__ */ new Map();
+  for (const w of listWatches()) {
+    const events = readWatchEvents(w.key);
+    const pending = events.slice(w.seen);
+    const last = events.at(-1);
+    watches.push({
+      key: w.key,
+      owner: w.owner,
+      cursor: w.cursor,
+      pendingEvents: pending.length,
+      lastSummary: last?.summary,
+      lastAt: last?.at,
+      error: w.lastError
+    });
+    if (w.owner.startsWith("dispatch:")) {
+      const label = `${w.key}${pending.length > 0 ? ` (${pending.length} pending)` : ""}`;
+      watchByDispatch.set(w.owner.slice("dispatch:".length), label);
+      if (w.lastFollowUpId) watchByDispatch.set(w.lastFollowUpId, label);
+    }
+    if (w.owner === "man" && pending.length > 0) {
+      const oldest = pending[0];
+      attention.push({
+        id: w.key,
+        lane: "work",
+        verb: "watch",
+        ageSecs: oldest?.at ? Math.max(0, Math.round((now - Date.parse(oldest.at)) / 1e3)) : 0,
+        note: pending.at(-1)?.summary
+      });
+    }
+  }
   const oldestQueuedAge = queued.reduce((max, id) => {
-    const st = fs16.statSync(path12.join(laneDirs("work").queue, `${id}.json`), { throwIfNoEntry: false });
+    const st = fs20.statSync(path15.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;
@@ -2260,12 +2755,13 @@ function buildTendReport(now = Date.now()) {
     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) });
+    const watch2 = chain.map((d) => watchByDispatch.get(d.id)).find((w) => w !== void 0);
+    stories.push({ key, dispatches: chain, prUrl, gate: gateFor(entry.uuid, prUrl), watch: watch2 });
   }
   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) });
+    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";
   return {
@@ -2274,6 +2770,7 @@ function buildTendReport(now = Date.now()) {
     counts: { queued: queued.length, active: active.length, choresActive, done24h, failed24h },
     attention,
     stories,
+    watches,
     merge
   };
 }
@@ -2309,9 +2806,26 @@ function renderTend(r) {
           key: s.key,
           dispatches: s.dispatches.map((d) => `${d.id.slice(0, 8)}:${d.state}`).join(" \u2192 "),
           pr: s.prUrl ?? "",
-          gate: s.gate ?? ""
+          gate: s.gate ?? "",
+          watch: s.watch ?? ""
+        })),
+        ["key", "dispatches", "pr", "gate", "watch"]
+      )
+    );
+  }
+  if (r.watches.length > 0) {
+    lines.push("");
+    lines.push(
+      toonTable(
+        "watches",
+        r.watches.map((w) => ({
+          key: w.key,
+          owner: w.owner,
+          pending: w.pendingEvents,
+          last: w.lastSummary ?? "",
+          error: w.error ?? ""
         })),
-        ["key", "dispatches", "pr", "gate"]
+        ["key", "owner", "pending", "last", "error"]
       )
     );
   }
@@ -2332,13 +2846,13 @@ function renderTend(r) {
 }
 
 // apps/cli/src/cull.ts
-import * as fs17 from "node:fs";
-import * as path13 from "node:path";
+import * as fs21 from "node:fs";
+import * as path16 from "node:path";
 import { execFileSync as execFileSync2 } from "node:child_process";
 var DAY = 864e5;
 function idsIn(dir) {
   try {
-    return new Set(fs17.readdirSync(dir).filter((f) => !f.startsWith(".")).map((f) => f.replace(/\.json$/, "")));
+    return new Set(fs21.readdirSync(dir).filter((f) => !f.startsWith(".")).map((f) => f.replace(/\.json$/, "")));
   } catch {
     return /* @__PURE__ */ new Set();
   }
@@ -2353,39 +2867,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 = path13.join(d.done, id);
-      const m = fs17.statSync(p).mtimeMs;
+      const p = path16.join(d.done, id);
+      const m = fs21.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 = path13.join(lobstahHome(), "worktrees");
+  const wtRoot = path16.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 = path13.join(wtRoot, id);
-    items.push({ kind: "worktree", id, target: p, ageDays: Math.floor((now - fs17.statSync(p).mtimeMs) / DAY) });
+    const p = path16.join(wtRoot, id);
+    items.push({ kind: "worktree", id, target: p, ageDays: Math.floor((now - fs21.statSync(p).mtimeMs) / DAY) });
   }
   for (const lane of ["work", "chore"]) {
     const d = laneDirs(lane);
     const seen = /* @__PURE__ */ new Set();
-    for (const f of fs17.readdirSync(d.state)) {
+    for (const f of fs21.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 = fs17.statSync(path13.join(d.state, f)).mtimeMs;
+      const m = fs21.statSync(path16.join(d.state, f)).mtimeMs;
       if (m >= cutoff) continue;
       seen.add(id);
-      items.push({ kind: "state", id, target: path13.join(d.state, `${id}.*`), ageDays: Math.floor((now - m) / DAY) });
+      items.push({ kind: "state", id, target: path16.join(d.state, `${id}.*`), ageDays: Math.floor((now - m) / DAY) });
     }
   }
   return items;
 }
 function removeWorktree(id, dir) {
   for (const lane of ["work", "chore"]) {
-    const descFile = path13.join(laneDirs(lane).done, id, "descriptor.json");
+    const descFile = path16.join(laneDirs(lane).done, id, "descriptor.json");
     try {
-      const desc = JSON.parse(fs17.readFileSync(descFile, "utf8"));
+      const desc = JSON.parse(fs21.readFileSync(descFile, "utf8"));
       const repo = loadConfig().repos[desc.repo];
       if (repo) {
         execFileSync2("git", ["worktree", "remove", "--force", dir], { cwd: repo.path, stdio: "ignore" });
@@ -2394,15 +2908,15 @@ function removeWorktree(id, dir) {
     } catch {
     }
   }
-  fs17.rmSync(dir, { recursive: true, force: true });
+  fs21.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")) fs17.rmSync(item.target, { recursive: true, force: true });
+  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 === "state")) {
-    const dir = path13.dirname(item.target);
-    for (const f of fs17.readdirSync(dir)) {
-      if (f.startsWith(`${item.id}.`)) fs17.rmSync(path13.join(dir, f), { force: true });
+    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 });
     }
   }
 }
@@ -2428,6 +2942,10 @@ your working set:
   lobstah man tend [--json]                     tend the string: fleet verdict,
                                                 unanswered questions, each work
                                                 item's chain + PR + merge gate
+  lobstah watch add <key> --check <cmd>         stand watch on something
+                                                external (a review session, a
+                                                CI run) \u2014 its events wake you
+                                                like any dispatch would
 
 getting woken instead of asking:
   lobstah man wait          block until a dispatch needs attention (arm it as a
@@ -2446,6 +2964,275 @@ 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 { createRequire as createRequire3 } from "node:module";
+import { spawnSync as spawnSync2 } from "node:child_process";
+var HEARTBEAT_STALE_MS2 = 9e4;
+function git(repoPath, ...args) {
+  const res = spawnSync2("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 (!fs22.existsSync(cfgFile)) {
+    push("config", "fail", `${cfgFile} missing \u2014 run \`lobstah init\``);
+    return rows;
+  }
+  let parsed;
+  try {
+    parsed = parse(fs22.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 (!fs22.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 (!fs22.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 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 fs23 from "node:fs";
+import * as os5 from "node:os";
+import * as path17 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;");
+}
+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(path17.posix.join(spec.logDir, `${spec.kind}.log`))}</string>
+  <key>StandardErrorPath</key><string>${xml(path17.posix.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:${path17.posix.join(spec.logDir, `${spec.kind}.log`)}
+StandardError=append:${path17.posix.join(spec.logDir, `${spec.kind}.err`)}
+
+[Install]
+WantedBy=default.target
+`;
+}
+function servicePathEnv(nodePath, home = os5.homedir()) {
+  const dirs = [
+    path17.posix.dirname(nodePath),
+    path17.posix.join(home, ".local", "bin"),
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    "/usr/bin",
+    "/bin"
+  ];
+  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`);
+}
+function run(cmd, args) {
+  const res = spawnSync3(cmd, args, { encoding: "utf8" });
+  return { ok: res.status === 0, out: `${res.stdout ?? ""}${res.stderr ?? ""}`.trim() };
+}
+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 spec = {
+    kind,
+    nodePath: process.execPath,
+    entry,
+    pathEnv: servicePathEnv(process.execPath),
+    home: lobstahHome(),
+    logDir: path17.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 });
+  const file = serviceFile(kind);
+  fs23.mkdirSync(path17.dirname(file), { recursive: true });
+  if (process.platform === "darwin") {
+    if (fs23.existsSync(file)) run("launchctl", ["unload", file]);
+    fs23.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));
+  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 (fs23.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);
+  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 { spawnSync as spawnSync4 } from "node:child_process";
+function git2(dir, ...args) {
+  const res = spawnSync4("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 = path18.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));
+    return process.platform === "win32" ? real.toLowerCase() : real;
+  };
+  if (!top || canon(top) !== canon(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 };
+}
+function scanForRepos(roots) {
+  const found = [];
+  for (const root of roots) {
+    const abs = path18.resolve(root);
+    if (!fs24.existsSync(abs)) continue;
+    const self = detectRepo(abs);
+    if (self) {
+      found.push(self);
+      continue;
+    }
+    for (const entry of fs24.readdirSync(abs, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+      const child = detectRepo(path18.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"));
+  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`);
+  fs24.appendFileSync(file, `${lines.join("\n")}
+`);
+}
+
 // apps/cli/src/main.ts
 var HELP = `lobstah \u2014 supervision framework for coding agents
 
@@ -2473,12 +3260,25 @@ work (humans and agents):
                                   entries, orphaned worktrees, stale state.
                                   Dry run by default (14 days).
   cancel <uuid>                   request cancellation
+  watch [add <key> --check <cmd> [--for <uuid>] [--cursor <c>] [--every <s>]
+        [--brief <template>] [--stream <cmd>] | rm <key>]
+                                  stand watch on something external: the check
+                                  command answers "anything since {cursor}?"
+                                  in JSON. Events wake man wait/haul (default)
+                                  or fork a continuation of --for's dispatch
+                                  chain. --stream holds a long-lived NDJSON
+                                  child under pick for ms-latency delivery
+                                  (the check stays the guarantee). Bare
+                                  \`watch\` lists.
 
-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
@@ -2487,14 +3287,19 @@ lobsterman (orchestrator sessions \u2014 bare \`lobstah man\` prints the manual)
                                   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.
+                                  block until a dispatch or watched source
+                                  needs attention, then print the event and
+                                  what to do next; exit 2 on timeout. Runs due
+                                  watch checks itself when no pick process is.
+                                  Unanswered questions re-fire every
+                                  remindSecs until answered.
+  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:
@@ -2506,7 +3311,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.
@@ -2515,10 +3329,26 @@ function arg(args, flag) {
   const i = args.indexOf(flag);
   return i >= 0 ? args[i + 1] : void 0;
 }
+var WATCH_EVERY_SECS = 45;
+function runDueManWatches() {
+  for (const w of listWatches()) {
+    if (w.owner === "man" && watchDue(w, WATCH_EVERY_SECS)) runWatchCheck(w);
+  }
+}
+function emitWatchAttention(attns) {
+  for (const a of attns) {
+    for (const e of a.events) {
+      console.log(toonKV({ watch: a.watch.key, seq: e.seq, summary: e.summary }));
+    }
+  }
+  console.log(
+    "next: handle the watched update now (a review round, a finished run \u2014 `lobstah watch ls` for context), then re-arm a background `lobstah man wait`."
+  );
+}
 function findLane(id) {
   for (const lane of ["work", "chore"]) {
     const d = laneDirs(lane);
-    if (fs18.existsSync(path14.join(d.active, id)) || fs18.existsSync(path14.join(d.queue, `${id}.json`)) || fs18.existsSync(path14.join(d.done, id)) || fs18.existsSync(path14.join(d.state, `${id}.status`))) {
+    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`))) {
       return lane;
     }
   }
@@ -2526,7 +3356,7 @@ function findLane(id) {
 }
 function rowsFor(lane, bucket) {
   const dir = laneDirs(lane)[bucket];
-  const entries = fs18.readdirSync(dir).filter((f) => !f.startsWith(".")).map((f) => ({ f, m: fs18.statSync(path14.join(dir, f)).mtimeMs })).sort((a, b) => b.m - a.m);
+  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 sliced = bucket === "done" ? entries.slice(0, 10) : entries;
   return sliced.map(({ f, m }) => {
     const id = f.replace(/\.json$/, "");
@@ -2552,9 +3382,9 @@ async function mainCli() {
         throw new Error("dispatch requires --repo and --brief <file> (or --brief-text)");
       }
       const d = {
-        id: arg(args, "--id") ?? randomUUID3(),
+        id: arg(args, "--id") ?? randomUUID4(),
         repo,
-        brief: briefText ?? fs18.readFileSync(briefFile, "utf8"),
+        brief: briefText ?? fs25.readFileSync(briefFile, "utf8"),
         harness: arg(args, "--harness"),
         model: arg(args, "--model"),
         effort: arg(args, "--effort"),
@@ -2591,17 +3421,17 @@ async function mainCli() {
       if (!id) throw new Error("logs requires a dispatch id");
       const lane = findLane(id);
       const file = eventsPath(id, lane);
-      if (fs18.existsSync(file)) process.stdout.write(fs18.readFileSync(file, "utf8"));
+      if (fs25.existsSync(file)) process.stdout.write(fs25.readFileSync(file, "utf8"));
       if (args.includes("--follow")) {
-        let size = fs18.existsSync(file) ? fs18.statSync(file).size : 0;
+        let size = fs25.existsSync(file) ? fs25.statSync(file).size : 0;
         setInterval(() => {
-          if (!fs18.existsSync(file)) return;
-          const now = fs18.statSync(file).size;
+          if (!fs25.existsSync(file)) return;
+          const now = fs25.statSync(file).size;
           if (now > size) {
-            const fd = fs18.openSync(file, "r");
+            const fd = fs25.openSync(file, "r");
             const buf = Buffer.alloc(now - size);
-            fs18.readSync(fd, buf, 0, buf.length, size);
-            fs18.closeSync(fd);
+            fs25.readSync(fd, buf, 0, buf.length, size);
+            fs25.closeSync(fd);
             process.stdout.write(buf.toString("utf8"));
             size = now;
           }
@@ -2657,22 +3487,23 @@ async function mainCli() {
         );
       }
       const dirs = laneDirs(lane);
-      const descriptorFile = ["active", "done"].map((b) => path14.join(dirs[b], id, "descriptor.json")).find((f) => fs18.existsSync(f));
-      const harness = descriptorFile ? JSON.parse(fs18.readFileSync(descriptorFile, "utf8")).harness ?? "claude" : "claude";
+      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";
       let sessionId;
       try {
-        sessionId = JSON.parse(fs18.readFileSync(path14.join(dirs.state, `${id}.evidence`), "utf8")).sessionId;
+        sessionId = JSON.parse(fs25.readFileSync(path19.join(dirs.state, `${id}.evidence`), "utf8")).sessionId;
       } catch {
       }
       if (!sessionId) throw new Error(`${id} has no recorded harness session to attach to`);
-      const worktree = path14.join(lobstahHome(), "worktrees", id);
-      const cwd = fs18.existsSync(worktree) ? worktree : process.cwd();
-      const invocation = harness === "codex" ? { file: "codex", argv: ["resume", sessionId] } : { file: "claude", argv: ["--resume", sessionId] };
+      const worktree = path19.join(lobstahHome(), "worktrees", id);
+      const cwd = fs25.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 = spawnSync5(invocation.file, invocation.argv, { cwd, stdio: "inherit" });
       if (res.error) throw new Error(`could not launch ${invocation.file}: ${res.error.message}`);
       break;
     }
@@ -2680,39 +3511,39 @@ async function mainCli() {
       const id = args[0];
       if (!id) throw new Error("swap requires a dispatch id");
       const lane = findLane(id);
-      const activeDir = path14.join(laneDirs(lane).active, id);
-      if (!fs18.existsSync(activeDir)) throw new Error(`${id} is not active \u2014 swap only applies to in-flight dispatches`);
-      const descFile = path14.join(activeDir, "descriptor.json");
-      const descriptor = JSON.parse(fs18.readFileSync(descFile, "utf8"));
+      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 fromHarness = descriptor.harness ?? "default";
       for (const key of ["harness", "model", "effort"]) {
         const v = arg(args, `--${key}`);
         if (v) descriptor[key] = v;
       }
-      fs18.writeFileSync(descFile, JSON.stringify(descriptor, null, 2));
-      const worktree = path14.join(lobstahHome(), "worktrees", id);
+      fs25.writeFileSync(descFile, JSON.stringify(descriptor, null, 2));
+      const worktree = path19.join(lobstahHome(), "worktrees", id);
       let progress = "No worktree progress recorded.";
-      if (fs18.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 (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");
         progress = `Commits so far:
 ${commits || "(none)"}
 
 Uncommitted changes:
 ${status || "(clean)"}`;
       }
-      fs18.writeFileSync(
-        path14.join(activeDir, "handoff"),
+      fs25.writeFileSync(
+        path19.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 = path14.join(activeDir, "runner.json");
-      if (fs18.existsSync(runnerFile)) {
-        const runner = JSON.parse(fs18.readFileSync(runnerFile, "utf8"));
+      const runnerFile = path19.join(activeDir, "runner.json");
+      if (fs25.existsSync(runnerFile)) {
+        const runner = JSON.parse(fs25.readFileSync(runnerFile, "utf8"));
         if (pidAlive(runner.pid, runner.processStartTime)) killGroup(runner.pid, "SIGKILL");
-        fs18.unlinkSync(runnerFile);
+        fs25.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 }));
@@ -2788,9 +3619,13 @@ ${progress}`
         );
       };
       const remindMs = (loadConfig().remindSecs ?? 900) * 1e3;
-      const standing = attentionNow(!args.includes("--peek"), remindMs);
-      if (standing.length > 0) {
-        emit(standing);
+      const consume = !args.includes("--peek");
+      runDueManWatches();
+      const standing = attentionNow(consume, remindMs);
+      const standingWatches = pendingWatchEvents(consume);
+      if (standing.length > 0 || standingWatches.length > 0) {
+        if (standing.length > 0) emit(standing);
+        if (standingWatches.length > 0) emitWatchAttention(standingWatches);
         break;
       }
       const baseline = captureWaitBaseline();
@@ -2801,64 +3636,79 @@ ${progress}`
           emit(fresh);
           return;
         }
+        runDueManWatches();
+        const watched = pendingWatchEvents(true);
+        if (watched.length > 0) {
+          emitWatchAttention(watched);
+          return;
+        }
       }
       console.log(toonKV({ timeout: true, waitedSecs: timeoutSecs }));
       process.exitCode = 2;
       break;
     }
     case "man:init": {
-      const file = path14.join(".claude", args.includes("--shared") ? "settings.json" : "settings.local.json");
+      const file = args.includes("--global") ? path19.join(os6.homedir(), ".claude", "settings.json") : path19.join(".claude", args.includes("--shared") ? "settings.json" : "settings.local.json");
       let existing;
       try {
-        existing = JSON.parse(fs18.readFileSync(file, "utf8"));
+        existing = JSON.parse(fs25.readFileSync(file, "utf8"));
       } catch {
         existing = void 0;
       }
       const { settings, changed } = mergeHaulHook(existing);
       if (changed) {
-        fs18.mkdirSync(".claude", { recursive: true });
-        fs18.writeFileSync(file, `${JSON.stringify(settings, null, 2)}
+        fs25.mkdirSync(path19.dirname(file), { recursive: true });
+        fs25.writeFileSync(file, `${JSON.stringify(settings, null, 2)}
 `);
       }
-      if (args.includes("--marker")) fs18.writeFileSync(".lobstah-man", "");
+      if (args.includes("--marker")) fs25.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" && !fs18.existsSync(".lobstah-man")) break;
+        if (process.env.LOBSTAH_MAN !== "1" && !fs25.existsSync(".lobstah-man")) break;
         const anyActive = ["work", "chore"].some(
-          (l) => fs18.readdirSync(laneDirs(l).active).some((f) => !f.startsWith("."))
+          (l) => fs25.readdirSync(laneDirs(l).active).some((f) => !f.startsWith("."))
         );
-        if (!anyActive) break;
+        const anyWatch = listWatches().some((w) => w.owner === "man");
+        if (!anyActive && !anyWatch) break;
         const timeoutSecs = Number(arg(args, "--timeout") ?? "14000");
         const deadline = Date.now() + timeoutSecs * 1e3;
         const remindMs = (loadConfig().remindSecs ?? 900) * 1e3;
+        runDueManWatches();
         let evs = attentionNow(true, remindMs);
-        if (evs.length === 0) {
+        let watched = pendingWatchEvents(true);
+        if (evs.length === 0 && watched.length === 0) {
           const baseline = captureWaitBaseline();
           while (Date.now() < deadline) {
             await new Promise((r) => setTimeout(r, 1500));
             evs = freshWakeEvents(baseline);
             if (evs.length === 0) evs = attentionNow(true, remindMs);
-            if (evs.length > 0) break;
+            runDueManWatches();
+            watched = pendingWatchEvents(true);
+            if (evs.length > 0 || watched.length > 0) break;
           }
         }
-        if (evs.length === 0) break;
-        const lines = evs.map(
-          (ev) => `- ${ev.entry.verb} ${ev.id}${ev.entry.note ? ` \u2014 ${ev.entry.note}` : ""}`
-        );
+        if (evs.length === 0 && watched.length === 0) break;
+        const lines = [
+          ...evs.map((ev) => `- ${ev.entry.verb} ${ev.id}${ev.entry.note ? ` \u2014 ${ev.entry.note}` : ""}`),
+          ...watched.flatMap(
+            (a) => a.events.map((e) => `- watch ${a.watch.key}${e.summary ? ` \u2014 ${e.summary}` : ` (seq ${e.seq})`}`)
+          )
+        ];
         const reason = [
-          "A lobstah dispatch needs attention:",
+          "A lobstah dispatch or watched source needs attention:",
           ...lines,
-          'Check with `lobstah status <id>`; answer a needs-decision with `lobstah send <id> "<answer>"`.',
+          'Check a dispatch with `lobstah status <id>`; answer a needs-decision with `lobstah send <id> "<answer>"`.',
+          "A watch line means an external source updated (e.g. a review round) \u2014 handle it directly.",
           "Handle it now. This session re-parks automatically at turn end \u2014 do not arm any watcher."
         ].join("\n");
         console.log(JSON.stringify({ decision: "block", reason }));
@@ -2866,31 +3716,109 @@ ${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: fs25.existsSync(r.path)
+      }));
+      console.log(toonTable("repos", rows, ["key", "path", "trunk", "pickup", "exists"]));
+      break;
+    }
+    case "version": {
+      console.log(lobstahVersion());
+      break;
+    }
+    case "watch": {
+      const sub = args[0];
+      if (sub === "add") {
+        const key = args[1];
+        const check = arg(args, "--check");
+        if (!key || key.startsWith("--") || !check) throw new Error("watch add requires a key and --check <command>");
+        const forId = arg(args, "--for");
+        const every = arg(args, "--every");
+        const w = addWatch(key, check, {
+          owner: forId ? `dispatch:${forId}` : "man",
+          cursor: arg(args, "--cursor"),
+          everySecs: every ? Number(every) : void 0,
+          brief: arg(args, "--brief"),
+          stream: arg(args, "--stream")
+        });
+        console.log(toonKV({ key: w.key, owner: w.owner, cursor: w.cursor, registered: true }));
+        break;
+      }
+      if (sub === "rm") {
+        const key = args[1];
+        if (!key) throw new Error("watch rm requires a key");
+        console.log(toonKV({ key, removed: removeWatch(key) }));
+        break;
+      }
+      const rows = listWatches().map((w) => ({
+        key: w.key,
+        owner: w.owner,
+        cursor: w.cursor,
+        pending: readWatchEvents(w.key).length - w.seen,
+        lastChecked: w.lastCheckedAt ?? "-",
+        error: w.lastError ?? ""
+      }));
+      console.log(toonTable("watches", rows, ["key", "owner", "cursor", "pending", "lastChecked", "error"]));
       break;
     }
     case "init": {
-      if (!fs18.existsSync(configPath())) {
-        fs18.writeFileSync(
+      if (!fs25.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
+
+`;
+        fs25.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]
@@ -2902,16 +3830,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 (fs25.existsSync(local)) reference = local;
+      } catch {
+      }
       console.log(
         toonKV({
-          home: path14.dirname(configPath()),
+          home: path19.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":