lobstah 0.1.2 → 0.2.1

package/dist/main.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
 // apps/cli/src/main.ts
-import * as fs23 from "node:fs";
+import * as fs25 from "node:fs";
 import * as os6 from "node:os";
-import * as path17 from "node:path";
-import { randomUUID as randomUUID3 } from "node:crypto";
-import { spawnSync as spawnSync4 } from "node:child_process";
+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
@@ -38,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`);
@@ -936,32 +937,210 @@ function onPath(bin, pathVar = process.env.PATH) {
   }
   return false;
 }
-function resolvable(specifier) {
+function packagePresent(specifier, fromFile = import.meta.url) {
+  const require_2 = createRequire(fromFile);
   try {
-    createRequire(import.meta.url).resolve(specifier);
+    require_2.resolve(specifier);
     return true;
   } catch {
-    return false;
   }
+  for (const dir of require_2.resolve.paths(specifier) ?? []) {
+    if (fs9.existsSync(path5.join(dir, specifier, "package.json")))
+      return true;
+  }
+  return false;
 }
 function detectHarnesses() {
   const out = [];
-  if (onPath("claude") || resolvable("@anthropic-ai/claude-agent-sdk"))
+  if (onPath("claude") || packagePresent("@anthropic-ai/claude-agent-sdk"))
     out.push("claude");
-  if (onPath("codex") || resolvable("@openai/codex-sdk"))
+  if (onPath("codex") || packagePresent("@openai/codex-sdk"))
     out.push("codex");
   return out;
 }
 function codexInvocation(argv) {
   if (onPath("codex"))
     return { file: "codex", argv };
+  const require_2 = createRequire(import.meta.url);
   try {
-    const cli = createRequire(import.meta.url).resolve("@openai/codex/bin/codex.js");
+    const cli = require_2.resolve("@openai/codex/bin/codex.js");
     return { file: process.execPath, argv: [cli, ...argv] };
+  } catch {
+  }
+  for (const dir of require_2.resolve.paths("@openai/codex") ?? []) {
+    const cli = path5.join(dir, "@openai", "codex", "bin", "codex.js");
+    if (fs9.existsSync(cli))
+      return { file: process.execPath, argv: [cli, ...argv] };
+  }
+  return void 0;
+}
+
+// packages/core/dist/watch.js
+import * as fs10 from "node:fs";
+import * as 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";
@@ -1021,26 +1200,26 @@ function killGroup(pid, signal = "SIGTERM") {
 }
 
 // packages/supervisor/dist/daemon.js
-import * as fs11 from "node:fs";
+import * as fs12 from "node:fs";
 import * as os3 from "node:os";
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 import { createRequire as createRequire2 } from "node:module";
 import { fileURLToPath } from "node:url";
 
 // packages/supervisor/dist/notify.js
-import * as fs10 from "node:fs";
-import * as path6 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 path6.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(fs10.readFileSync(cursorPath(id, lane), "utf8")) || 0;
+    cursor = Number(fs11.readFileSync(cursorPath(id, lane), "utf8")) || 0;
   } catch {
     cursor = void 0;
   }
@@ -1050,13 +1229,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);
   }
-  fs10.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 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));
+  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 = () => {
 }) {
@@ -1086,11 +1265,11 @@ function captureWaitBaseline() {
   return lengths;
 }
 function attnCursorPath(id, lane) {
-  return path6.join(laneDirs(lane).state, `${id}.attn`);
+  return path7.join(laneDirs(lane).state, `${id}.attn`);
 }
 function readAttnCursor(file) {
   try {
-    const parsed = JSON.parse(fs10.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 };
@@ -1116,7 +1295,7 @@ function attentionNow(consume = true, remindMs = 15 * 6e4, now = Date.now()) {
         continue;
       out.push({ id, lane, entry });
       if (consume)
-        fs10.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;
@@ -1151,33 +1330,33 @@ function runnerEntry() {
 }
 function readRunnerInfo(dir) {
   try {
-    return JSON.parse(fs11.readFileSync(path7.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 fs11.readdirSync(dir).filter((f) => !f.startsWith(".")).map((id) => {
-    const d = path7.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 {
-    fs11.renameSync(st.dir, path7.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 = path7.join(st.dir, "handoff");
-  if (!nudge && fs11.existsSync(handoffFile)) {
-    nudge = fs11.readFileSync(handoffFile, "utf8");
-    fs11.unlinkSync(handoffFile);
+  const handoffFile = path8.join(st.dir, "handoff");
+  if (!nudge && fs12.existsSync(handoffFile)) {
+    nudge = fs12.readFileSync(handoffFile, "utf8");
+    fs12.unlinkSync(handoffFile);
   }
-  const logPath = path7.join(laneDirs(st.lane).state, `${st.id}.runner.log`);
-  const log = fs11.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],
@@ -1188,7 +1367,7 @@ function spawnRunner(st, opts) {
       ...nudge ? { LOBSTAH_NUDGE: nudge } : {}
     }
   });
-  fs11.closeSync(log);
+  fs12.closeSync(log);
   child.unref();
   const info = {
     pid: child.pid ?? -1,
@@ -1196,22 +1375,22 @@ function spawnRunner(st, opts) {
     processStartTime: child.pid ? processStartTime(child.pid) : void 0,
     attempts: opts.attempts
   };
-  fs11.writeFileSync(path7.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(fs11.readFileSync(path7.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 = fs11.existsSync(path7.join(st.dir, "descriptor.json"));
+  const hasDescriptor = fs12.existsSync(path8.join(st.dir, "descriptor.json"));
   if (!hasDescriptor) {
-    const age = Date.now() - fs11.statSync(st.dir).mtimeMs;
+    const age = Date.now() - fs12.statSync(st.dir).mtimeMs;
     if (age > 5 * 6e4)
-      fs11.rmSync(st.dir, { recursive: true, force: true });
+      fs12.rmSync(st.dir, { recursive: true, force: true });
     return;
   }
   const statusLog = readStatusLog(st.id, st.lane);
@@ -1295,16 +1474,16 @@ function writeHeartbeat(cfg) {
     heartbeat: (/* @__PURE__ */ new Date()).toISOString()
   };
   const tmp = `${executorPath()}.tmp`;
-  fs11.writeFileSync(tmp, JSON.stringify(payload, null, 2));
-  fs11.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 fs11.readdirSync(dir)) {
-    const p = path7.join(dir, id);
-    if (fs11.statSync(p).mtimeMs < cutoff)
-      fs11.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();
@@ -1344,9 +1523,9 @@ function tick(log = () => {
   pruneChores(loadConfig());
 }
 function acquireDaemonLock() {
-  const lockPath = path7.join(lobstahHome(), "daemon.lock");
+  const lockPath = path8.join(lobstahHome(), "daemon.lock");
   try {
-    const prior = JSON.parse(fs11.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`);
     }
@@ -1354,10 +1533,10 @@ function acquireDaemonLock() {
     if (err instanceof Error && err.message.includes("already supervises"))
       throw err;
   }
-  fs11.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 {
-      fs11.unlinkSync(lockPath);
+      fs12.unlinkSync(lockPath);
     } catch {
     }
   };
@@ -1369,17 +1548,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);
+      };
+    });
   }
 }
 
@@ -1387,7 +1591,7 @@ async function daemon(intervalMs = 5e3, log = console.log) {
 import { spawn as spawn3 } from "node:child_process";
 
 // apps/pick/dist/config.js
-import * as fs12 from "node:fs";
+import * as fs13 from "node:fs";
 import { execSync } from "node:child_process";
 import * as os4 from "node:os";
 
@@ -1429,7 +1633,7 @@ function resolveTokenSource(section, label) {
   }
   if (file) {
     return () => {
-      const token = fs12.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;
@@ -1447,7 +1651,7 @@ function resolveTokenSource(section, label) {
 }
 function loadPickupConfig() {
   const file = configPath();
-  const raw = fs12.existsSync(file) ? parse(fs12.readFileSync(file, "utf8")) : {};
+  const raw = fs13.existsSync(file) ? parse(fs13.readFileSync(file, "utf8")) : {};
   const p = raw.pickup ?? {};
   const out = {
     pollSecs: Number(p.pollSecs ?? 45),
@@ -1520,23 +1724,23 @@ function loadPickupConfig() {
 }
 
 // apps/pick/dist/state.js
-import * as fs13 from "node:fs";
-import * as path8 from "node:path";
+import * as fs14 from "node:fs";
+import * as path9 from "node:path";
 var PickupState = class {
   file;
   data;
-  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: {} };
+  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}`;
-    fs13.writeFileSync(tmp, JSON.stringify(this.data, null, 2));
-    fs13.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];
@@ -1920,12 +2124,12 @@ async function dispatchLoop(source, state, log = () => {
 }
 
 // apps/pick/dist/loops/report.js
-import * as fs14 from "node:fs";
-import * as path9 from "node:path";
+import * as fs15 from "node:fs";
+import * as path10 from "node:path";
 function dispatchLane(uuid) {
   for (const lane of ["work", "chore"]) {
     const d = laneDirs(lane);
-    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`))) {
+    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;
     }
   }
@@ -1966,12 +2170,12 @@ async function reportLoop(source, state, log = () => {
 }
 
 // apps/pick/dist/loops/reconcile.js
-import * as fs15 from "node:fs";
-import * as path10 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 (fs15.existsSync(path10.join(d.active, uuid)) || fs15.existsSync(path10.join(d.queue, `${uuid}.json`))) {
+    if (fs16.existsSync(path11.join(d.active, uuid)) || fs16.existsSync(path11.join(d.queue, `${uuid}.json`))) {
       return lane;
     }
   }
@@ -2011,28 +2215,28 @@ async function reconcileLoop(source, state, log = () => {
 
 // apps/pick/dist/loops/merge.js
 import { randomUUID as randomUUID2 } from "node:crypto";
-import * as fs17 from "node:fs";
-import * as path12 from "node:path";
+import * as fs18 from "node:fs";
+import * as path13 from "node:path";
 
 // apps/pick/dist/merge-view.js
-import * as fs16 from "node:fs";
-import * as path11 from "node:path";
+import * as fs17 from "node:fs";
+import * as path12 from "node:path";
 function viewPath() {
-  return path11.join(lobstahHome(), "pickup", "merge-view.json");
+  return path12.join(lobstahHome(), "pickup", "merge-view.json");
 }
 function readMergeView() {
   try {
-    return JSON.parse(fs16.readFileSync(viewPath(), "utf8"));
+    return JSON.parse(fs17.readFileSync(viewPath(), "utf8"));
   } catch {
     return void 0;
   }
 }
 function writeMergeView(view) {
   const file = viewPath();
-  fs16.mkdirSync(path11.dirname(file), { recursive: true });
+  fs17.mkdirSync(path12.dirname(file), { recursive: true });
   const tmp = `${file}.tmp-${process.pid}`;
-  fs16.writeFileSync(tmp, JSON.stringify(view, null, 2));
-  fs16.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()) {
@@ -2054,7 +2258,7 @@ async function recordMergeView(repo, open, disposition, now = /* @__PURE__ */ ne
 }
 function readPickupMap() {
   try {
-    const raw = JSON.parse(fs16.readFileSync(path11.join(lobstahHome(), "pickup", "state.json"), "utf8"));
+    const raw = JSON.parse(fs17.readFileSync(path12.join(lobstahHome(), "pickup", "state.json"), "utf8"));
     return raw.map ?? {};
   } catch {
     return {};
@@ -2088,7 +2292,7 @@ function rebaseBrief(pr) {
 }
 function choreVerdict(uuid) {
   const d = laneDirs("chore");
-  if (fs17.existsSync(path12.join(d.active, uuid)) || fs17.existsSync(path12.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";
@@ -2181,6 +2385,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)
@@ -2204,7 +2528,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);
@@ -2221,6 +2587,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();
@@ -2237,16 +2608,22 @@ async function runPickup(mode = "daemon") {
   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));
   }
 }
@@ -2265,21 +2642,21 @@ function mergeHaulHook(existing) {
 }
 
 // apps/cli/src/tend.ts
-import * as fs18 from "node:fs";
-import * as path13 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(fs18.readFileSync(file, "utf8"));
+    return JSON.parse(fs20.readFileSync(file, "utf8"));
   } catch {
     return void 0;
   }
 }
 function doneIds(lane) {
   try {
-    return fs18.readdirSync(laneDirs(lane).done).filter((f) => !f.startsWith("."));
+    return fs20.readdirSync(laneDirs(lane).done).filter((f) => !f.startsWith("."));
   } catch {
     return [];
   }
@@ -2298,16 +2675,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", 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"));
+  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 (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";
+  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()) {
@@ -2335,8 +2712,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 = fs18.statSync(path13.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;
@@ -2358,12 +2766,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 {
@@ -2372,6 +2781,7 @@ function buildTendReport(now = Date.now()) {
     counts: { queued: queued.length, active: active.length, choresActive, done24h, failed24h },
     attention,
     stories,
+    watches,
     merge
   };
 }
@@ -2407,9 +2817,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"]
+        ["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", "owner", "pending", "last", "error"]
       )
     );
   }
@@ -2430,13 +2857,13 @@ function renderTend(r) {
 }
 
 // apps/cli/src/cull.ts
-import * as fs19 from "node:fs";
-import * as path14 from "node:path";
+import * as fs21 from "node:fs";
+import * as path16 from "node:path";
 import { execFileSync as execFileSync2 } from "node:child_process";
 var DAY = 864e5;
 function idsIn(dir) {
   try {
-    return new Set(fs19.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();
   }
@@ -2451,39 +2878,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 = path14.join(d.done, id);
-      const m = fs19.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 = path14.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 = path14.join(wtRoot, id);
-    items.push({ kind: "worktree", id, target: p, ageDays: Math.floor((now - fs19.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 fs19.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 = fs19.statSync(path14.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: path14.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 = path14.join(laneDirs(lane).done, id, "descriptor.json");
+    const descFile = path16.join(laneDirs(lane).done, id, "descriptor.json");
     try {
-      const desc = JSON.parse(fs19.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" });
@@ -2492,15 +2919,15 @@ function removeWorktree(id, dir) {
     } catch {
     }
   }
-  fs19.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")) fs19.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 = path14.dirname(item.target);
-    for (const f of fs19.readdirSync(dir)) {
-      if (f.startsWith(`${item.id}.`)) fs19.rmSync(path14.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 });
     }
   }
 }
@@ -2526,6 +2953,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
@@ -2545,12 +2976,11 @@ 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";
+import * as fs22 from "node:fs";
+import { spawnSync as spawnSync2 } from "node:child_process";
 var HEARTBEAT_STALE_MS2 = 9e4;
 function git(repoPath, ...args) {
-  const res = spawnSync("git", ["-C", repoPath, ...args], { encoding: "utf8" });
+  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()) {
@@ -2562,25 +2992,20 @@ function runDoctor(now = Date.now()) {
   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 {
-  }
+  const codexSdk = packagePresent("@openai/codex-sdk");
   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)) {
+  if (!fs22.existsSync(cfgFile)) {
     push("config", "fail", `${cfgFile} missing \u2014 run \`lobstah init\``);
     return rows;
   }
   let parsed;
   try {
-    parsed = parse(fs20.readFileSync(cfgFile, "utf8"));
+    parsed = parse(fs22.readFileSync(cfgFile, "utf8"));
     push("config", "ok", cfgFile);
   } catch (err) {
     push("config", "fail", `${cfgFile}: ${err instanceof Error ? err.message : String(err)}`);
@@ -2591,7 +3016,7 @@ function runDoctor(now = Date.now()) {
   if (repoKeys.length === 0) push("repos", "warn", "none configured \u2014 add one with `lobstah repos add <path>`");
   for (const [key, repo] of Object.entries(cfg.repos)) {
     const label = `repo ${key}`;
-    if (!fs20.existsSync(repo.path)) {
+    if (!fs22.existsSync(repo.path)) {
       push(label, "fail", `path ${repo.path} does not exist`);
       continue;
     }
@@ -2619,11 +3044,11 @@ function runDoctor(now = Date.now()) {
     }
   }
   const hb = executorPath();
-  if (!fs20.existsSync(hb)) {
+  if (!fs22.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 payload = JSON.parse(fs22.readFileSync(hb, "utf8"));
       const age = now - new Date(payload.heartbeat ?? 0).getTime();
       push(
         "daemon",
@@ -2639,10 +3064,10 @@ function runDoctor(now = Date.now()) {
 }
 
 // apps/cli/src/service.ts
-import * as fs21 from "node:fs";
+import * as fs23 from "node:fs";
 import * as os5 from "node:os";
-import * as path15 from "node:path";
-import { spawnSync as spawnSync2 } from "node:child_process";
+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;");
 }
@@ -2665,8 +3090,8 @@ function renderLaunchdPlist(spec) {
   </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>
+  <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>
 `;
@@ -2681,8 +3106,8 @@ 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`)}
+StandardOutput=append:${path17.posix.join(spec.logDir, `${spec.kind}.log`)}
+StandardError=append:${path17.posix.join(spec.logDir, `${spec.kind}.err`)}
 
 [Install]
 WantedBy=default.target
@@ -2690,45 +3115,48 @@ WantedBy=default.target
 }
 function servicePathEnv(nodePath, home = os5.homedir()) {
   const dirs = [
-    path15.dirname(nodePath),
-    path15.join(home, ".local", "bin"),
+    path17.posix.dirname(nodePath),
+    path17.posix.join(home, ".local", "bin"),
     "/opt/homebrew/bin",
     "/usr/local/bin",
     "/usr/bin",
     "/bin"
   ];
-  return [...new Set(dirs)].join(path15.delimiter);
+  return [...new Set(dirs)].join(":");
 }
 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`);
+  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 = spawnSync2(cmd, args, { encoding: "utf8" });
+  const res = spawnSync3(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]);
+  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: path15.join(lobstahHome(), "logs")
+    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`);
   }
-  fs21.mkdirSync(spec.logDir, { recursive: true });
+  fs23.mkdirSync(spec.logDir, { recursive: true });
   const file = serviceFile(kind);
-  fs21.mkdirSync(path15.dirname(file), { recursive: true });
+  fs23.mkdirSync(path17.dirname(file), { recursive: true });
   if (process.platform === "darwin") {
-    if (fs21.existsSync(file)) run("launchctl", ["unload", file]);
-    fs21.writeFileSync(file, renderLaunchdPlist(spec));
+    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 };
   }
-  fs21.writeFileSync(file, renderSystemdUnit(spec));
+  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 };
@@ -2736,22 +3164,22 @@ function installService(kind) {
 function uninstallService(kind) {
   const file = serviceFile(kind);
   if (process.platform === "darwin") {
-    if (fs21.existsSync(file)) run("launchctl", ["unload", file]);
+    if (fs23.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);
+  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 fs22 from "node:fs";
-import * as path16 from "node:path";
-import { spawnSync as spawnSync3 } from "node:child_process";
+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 = spawnSync3("git", ["-C", dir, ...args], { encoding: "utf8" });
+  const res = spawnSync4("git", ["-C", dir, ...args], { encoding: "utf8" });
   return res.status === 0 ? res.stdout.trim() : void 0;
 }
 var LOCKFILE_SETUP = [
@@ -2764,37 +3192,41 @@ var LOCKFILE_SETUP = [
   ["poetry.lock", ["poetry install"]]
 ];
 function detectRepo(dir) {
-  const abs = path16.resolve(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");
-  if (!top || fs22.realpathSync(top) !== fs22.realpathSync(abs)) return void 0;
+  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]) => fs22.existsSync(path16.join(abs, f)))?.[1];
-  return { key: path16.basename(abs), path: abs, trunk, origin, setup };
+  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 = path16.resolve(root);
-    if (!fs22.existsSync(abs)) continue;
+    const abs = path18.resolve(root);
+    if (!fs24.existsSync(abs)) continue;
     const self = detectRepo(abs);
     if (self) {
       found.push(self);
       continue;
     }
-    for (const entry of fs22.readdirSync(abs, { withFileTypes: true })) {
+    for (const entry of fs24.readdirSync(abs, { withFileTypes: true })) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const child = detectRepo(path16.join(abs, entry.name));
+      const child = detectRepo(path18.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"));
+  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()) {
@@ -2802,10 +3234,18 @@ function appendRepoBlock(repo, opts = {}, file = configPath()) {
   if (repo.origin) lines.push(`origin = ${JSON.stringify(repo.origin)}`);
   if (repo.setup) lines.push(`setup  = [${repo.setup.map((s) => JSON.stringify(s)).join(", ")}]`);
   if (opts.pickup) lines.push(`pickup = true`);
-  fs22.appendFileSync(file, `${lines.join("\n")}
+  fs24.appendFileSync(file, `${lines.join("\n")}
 `);
 }
 
+// apps/cli/src/report-args.ts
+function parseReportArgs(rest) {
+  const prIndex = rest.indexOf("--pr");
+  const prUrl = prIndex >= 0 ? rest[prIndex + 1] : void 0;
+  const note = rest.filter((_, i) => prIndex < 0 || i !== prIndex && i !== prIndex + 1).join(" ") || void 0;
+  return { note, prUrl };
+}
+
 // apps/cli/src/main.ts
 var HELP = `lobstah \u2014 supervision framework for coding agents
 
@@ -2833,6 +3273,16 @@ 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:
   daemon [--interval <ms>]        the supervisor: claims, worktrees, liveness,
@@ -2850,10 +3300,12 @@ 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.
+                                  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,
@@ -2890,10 +3342,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 (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`))) {
+    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;
     }
   }
@@ -2901,7 +3369,7 @@ function findLane(id) {
 }
 function rowsFor(lane, bucket) {
   const dir = laneDirs(lane)[bucket];
-  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 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$/, "");
@@ -2927,9 +3395,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 ?? fs23.readFileSync(briefFile, "utf8"),
+        brief: briefText ?? fs25.readFileSync(briefFile, "utf8"),
         harness: arg(args, "--harness"),
         model: arg(args, "--model"),
         effort: arg(args, "--effort"),
@@ -2966,17 +3434,17 @@ async function mainCli() {
       if (!id) throw new Error("logs requires a dispatch id");
       const lane = findLane(id);
       const file = eventsPath(id, lane);
-      if (fs23.existsSync(file)) process.stdout.write(fs23.readFileSync(file, "utf8"));
+      if (fs25.existsSync(file)) process.stdout.write(fs25.readFileSync(file, "utf8"));
       if (args.includes("--follow")) {
-        let size = fs23.existsSync(file) ? fs23.statSync(file).size : 0;
+        let size = fs25.existsSync(file) ? fs25.statSync(file).size : 0;
         setInterval(() => {
-          if (!fs23.existsSync(file)) return;
-          const now = fs23.statSync(file).size;
+          if (!fs25.existsSync(file)) return;
+          const now = fs25.statSync(file).size;
           if (now > size) {
-            const fd = fs23.openSync(file, "r");
+            const fd = fs25.openSync(file, "r");
             const buf = Buffer.alloc(now - size);
-            fs23.readSync(fd, buf, 0, buf.length, size);
-            fs23.closeSync(fd);
+            fs25.readSync(fd, buf, 0, buf.length, size);
+            fs25.closeSync(fd);
             process.stdout.write(buf.toString("utf8"));
             size = now;
           }
@@ -2997,9 +3465,7 @@ async function mainCli() {
       const [id, verb, ...rest] = args;
       if (!id || !verb) throw new Error(`report requires an id and a verb (${VERBS.join("|")})`);
       const lane = findLane(id);
-      const prIndex = rest.indexOf("--pr");
-      const prUrl = prIndex >= 0 ? rest[prIndex + 1] : void 0;
-      const note = rest.filter((_, i) => i !== prIndex && i !== prIndex + 1).join(" ") || void 0;
+      const { note, prUrl } = parseReportArgs(rest);
       const entry = appendStatus(id, lane, verb, note);
       if (prUrl) mergeEvidence(id, lane, { prUrl });
       console.log(toonKV({ id, verb: entry.verb, at: entry.at, ...prUrl ? { prUrl } : {} }));
@@ -3032,23 +3498,23 @@ async function mainCli() {
         );
       }
       const dirs = laneDirs(lane);
-      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";
+      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(fs23.readFileSync(path17.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 = path17.join(lobstahHome(), "worktrees", id);
-      const cwd = fs23.existsSync(worktree) ? worktree : process.cwd();
+      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 = spawnSync4(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;
     }
@@ -3056,20 +3522,20 @@ async function mainCli() {
       const id = args[0];
       if (!id) throw new Error("swap requires a dispatch id");
       const lane = findLane(id);
-      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 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;
       }
-      fs23.writeFileSync(descFile, JSON.stringify(descriptor, null, 2));
-      const worktree = path17.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 (fs23.existsSync(worktree)) {
-        const git3 = (...a) => spawnSync4("git", a, { cwd: worktree, encoding: "utf8" }).stdout?.trim() ?? "";
+      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:
@@ -3078,17 +3544,17 @@ ${commits || "(none)"}
 Uncommitted changes:
 ${status || "(clean)"}`;
       }
-      fs23.writeFileSync(
-        path17.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 = path17.join(activeDir, "runner.json");
-      if (fs23.existsSync(runnerFile)) {
-        const runner = JSON.parse(fs23.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");
-        fs23.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 }));
@@ -3164,9 +3630,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();
@@ -3177,26 +3647,32 @@ ${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 = args.includes("--global") ? path17.join(os6.homedir(), ".claude", "settings.json") : path17.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(fs23.readFileSync(file, "utf8"));
+        existing = JSON.parse(fs25.readFileSync(file, "utf8"));
       } catch {
         existing = void 0;
       }
       const { settings, changed } = mergeHaulHook(existing);
       if (changed) {
-        fs23.mkdirSync(path17.dirname(file), { recursive: true });
-        fs23.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")) fs23.writeFileSync(".lobstah-man", "");
+      if (args.includes("--marker")) fs25.writeFileSync(".lobstah-man", "");
       console.log(
         toonKV({
           hook: "lobstah man haul",
@@ -3209,32 +3685,41 @@ ${progress}`
     }
     case "man:haul": {
       try {
-        if (process.env.LOBSTAH_MAN !== "1" && !fs23.existsSync(".lobstah-man")) break;
+        if (process.env.LOBSTAH_MAN !== "1" && !fs25.existsSync(".lobstah-man")) break;
         const anyActive = ["work", "chore"].some(
-          (l) => fs23.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 }));
@@ -3283,7 +3768,7 @@ ${progress}`
         path: r.path,
         trunk: r.trunk,
         pickup: r.pickup ?? false,
-        exists: fs23.existsSync(r.path)
+        exists: fs25.existsSync(r.path)
       }));
       console.log(toonTable("repos", rows, ["key", "path", "trunk", "pickup", "exists"]));
       break;
@@ -3292,8 +3777,43 @@ ${progress}`
       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 (!fs23.existsSync(configPath())) {
+      if (!fs25.existsSync(configPath())) {
         const exampleRepo = args.includes("--scan") ? "" : `[repos.example]
 path  = "~/src/example"
 trunk = "main"
@@ -3302,7 +3822,7 @@ trunk = "main"
 # pickup = true   # opt into [pickup.github] multi-repo tracker pickup
 
 `;
-        fs23.writeFileSync(
+        fs25.writeFileSync(
           configPath(),
           `# lobstah workspace definitions \u2014 the descriptor's repo key resolves here.
 # Top-level keys must come before any [section].
@@ -3340,12 +3860,12 @@ wallClockSecs      = 3600
       let reference = "https://github.com/aequitas-labs/lobstah/blob/main/docs/configuration.md";
       try {
         const local = fileURLToPath2(new URL("../docs/configuration.md", import.meta.url));
-        if (fs23.existsSync(local)) reference = local;
+        if (fs25.existsSync(local)) reference = local;
       } catch {
       }
       console.log(
         toonKV({
-          home: path17.dirname(configPath()),
+          home: path19.dirname(configPath()),
           config: configPath(),
           ...added.length > 0 ? { added: added.join(", ") } : {},
           ...unmarked.length > 0 ? { note: `none marked pickable \u2014 set pickup = true per [repos.*] (or rerun with --pickup)` } : {},