lobstah 0.1.0

package/dist/main.js

@@ -0,0 +1,2688 @@
+#!/usr/bin/env node
+
+// apps/cli/src/main.ts
+import * as fs16 from "node:fs";
+import * as path12 from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { spawnSync } from "node:child_process";
+
+// packages/core/dist/types.js
+var VERBS = ["working", "needs-decision", "blocked", "paused", "done", "failed"];
+var TERMINAL_VERBS = ["done", "failed"];
+
+// packages/core/dist/paths.js
+import * as os from "node:os";
+import * as path from "node:path";
+import * as fs from "node:fs";
+function lobstahHome() {
+  return process.env.LOBSTAH_HOME ?? path.join(os.homedir(), ".lobstah");
+}
+function laneRoot(lane) {
+  return lane === "work" ? lobstahHome() : path.join(lobstahHome(), "chores");
+}
+function laneDirs(lane) {
+  const root = laneRoot(lane);
+  return {
+    queue: path.join(root, "queue"),
+    active: path.join(root, "active"),
+    done: path.join(root, "done"),
+    state: path.join(root, "state"),
+    inbox: path.join(root, "inbox")
+  };
+}
+function ensureLayout() {
+  for (const lane of ["work", "chore"]) {
+    for (const dir of Object.values(laneDirs(lane)))
+      fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.mkdirSync(path.join(lobstahHome(), "worktrees"), { recursive: true });
+}
+function statusPath(id, lane) {
+  return path.join(laneDirs(lane).state, `${id}.status`);
+}
+function eventsPath(id, lane) {
+  return path.join(laneDirs(lane).state, `${id}.events`);
+}
+function evidencePath(id, lane) {
+  return path.join(laneDirs(lane).state, `${id}.evidence`);
+}
+function executorPath() {
+  return path.join(lobstahHome(), "executor.json");
+}
+
+// packages/core/dist/queue.js
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+function atomicWrite(file, content) {
+  const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
+  fs2.writeFileSync(tmp, content);
+  fs2.renameSync(tmp, file);
+}
+function enqueue(d, lane = "work") {
+  if (!d.id || !d.repo || !d.brief) {
+    throw new Error("descriptor requires id, repo, and brief");
+  }
+  atomicWrite(path2.join(laneDirs(lane).queue, `${d.id}.json`), JSON.stringify(d, null, 2));
+}
+function pendingIds(lane) {
+  const dir = laneDirs(lane).queue;
+  return fs2.readdirSync(dir).filter((f) => f.endsWith(".json")).map((f) => ({ f, m: fs2.statSync(path2.join(dir, f)).mtimeMs })).sort((a, b) => a.m - b.m).map(({ f }) => f.slice(0, -".json".length));
+}
+function claimNext(lane) {
+  const dirs = laneDirs(lane);
+  for (const id of pendingIds(lane)) {
+    const activeDir = path2.join(dirs.active, id);
+    try {
+      fs2.mkdirSync(activeDir);
+    } catch {
+      continue;
+    }
+    try {
+      fs2.renameSync(path2.join(dirs.queue, `${id}.json`), path2.join(activeDir, "descriptor.json"));
+      return id;
+    } catch {
+      fs2.rmdirSync(activeDir, { recursive: true });
+      continue;
+    }
+  }
+  return null;
+}
+function activeIds(lane) {
+  return fs2.readdirSync(laneDirs(lane).active).filter((f) => !f.startsWith("."));
+}
+function requestCancel(id, lane) {
+  fs2.writeFileSync(path2.join(laneDirs(lane).active, id, "cancel"), (/* @__PURE__ */ new Date()).toISOString());
+}
+function cancelRequested(id, lane) {
+  return fs2.existsSync(path2.join(laneDirs(lane).active, id, "cancel"));
+}
+
+// packages/core/dist/status.js
+import * as fs3 from "node:fs";
+function isVerb(v) {
+  return VERBS.includes(v);
+}
+function appendStatus(id, lane, verb, note) {
+  if (!isVerb(verb)) {
+    throw new Error(`invalid status verb "${verb}" \u2014 must be one of: ${VERBS.join(", ")}`);
+  }
+  const entry = { at: (/* @__PURE__ */ new Date()).toISOString(), verb, ...note ? { note } : {} };
+  fs3.appendFileSync(statusPath(id, lane), `${JSON.stringify(entry)}
+`);
+  return entry;
+}
+function readStatusLog(id, lane) {
+  const file = statusPath(id, lane);
+  if (!fs3.existsSync(file))
+    return [];
+  return fs3.readFileSync(file, "utf8").split("\n").filter(Boolean).flatMap((line) => {
+    try {
+      const parsed = JSON.parse(line);
+      return isVerb(parsed.verb) ? [parsed] : [];
+    } catch {
+      return [];
+    }
+  });
+}
+function reconcile({ log, lastEventAt: lastEventAt2, now = Date.now(), busyThresholdMs = 12e4 }) {
+  const last = log[log.length - 1];
+  if (last && TERMINAL_VERBS.includes(last.verb))
+    return last.verb;
+  const busy = lastEventAt2 !== void 0 && now - lastEventAt2 < busyThresholdMs;
+  if (busy)
+    return last && last.verb !== "working" ? last.verb : "working";
+  if (last)
+    return last.verb;
+  return "unknown";
+}
+
+// packages/core/dist/events.js
+import * as fs4 from "node:fs";
+function lastEventAt(id, lane) {
+  try {
+    return fs4.statSync(eventsPath(id, lane)).mtimeMs;
+  } catch {
+    return void 0;
+  }
+}
+
+// packages/core/dist/evidence.js
+import * as fs5 from "node:fs";
+function readEvidence(id, lane) {
+  try {
+    return JSON.parse(fs5.readFileSync(evidencePath(id, lane), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function mergeEvidence(id, lane, patch) {
+  const file = evidencePath(id, lane);
+  const tmp = `${file}.tmp-${process.pid}`;
+  fs5.writeFileSync(tmp, JSON.stringify({ ...readEvidence(id, lane), ...patch }, null, 2));
+  fs5.renameSync(tmp, file);
+}
+
+// packages/core/dist/inbox.js
+import * as fs6 from "node:fs";
+import * as path3 from "node:path";
+function inboxDir(id, lane) {
+  return path3.join(laneDirs(lane).inbox, id);
+}
+function sendMessage(id, lane, text) {
+  const dir = inboxDir(id, lane);
+  fs6.mkdirSync(path3.join(dir, "handled"), { recursive: true });
+  const existing = fs6.readdirSync(dir).filter((f) => f.endsWith(".msg")).length;
+  const handled = fs6.readdirSync(path3.join(dir, "handled")).length;
+  const name = `${String(existing + handled + 1).padStart(3, "0")}.msg`;
+  const tmp = path3.join(dir, `.tmp-${process.pid}-${Date.now()}`);
+  fs6.writeFileSync(tmp, text);
+  fs6.renameSync(tmp, path3.join(dir, name));
+  return name;
+}
+function unhandled(id, lane) {
+  const dir = inboxDir(id, lane);
+  if (!fs6.existsSync(dir))
+    return [];
+  return fs6.readdirSync(dir).filter((f) => f.endsWith(".msg")).sort().map((f) => ({ file: f, text: fs6.readFileSync(path3.join(dir, f), "utf8") }));
+}
+function acknowledge(id, lane, file) {
+  const dir = inboxDir(id, lane);
+  fs6.mkdirSync(path3.join(dir, "handled"), { recursive: true });
+  fs6.renameSync(path3.join(dir, file), path3.join(dir, "handled", file));
+}
+
+// packages/core/dist/config.js
+import * as fs7 from "node:fs";
+import * as os2 from "node:os";
+import * as path4 from "node:path";
+
+// node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/date.js
+var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
+var TomlDate = class _TomlDate extends Date {
+  #hasDate = false;
+  #hasTime = false;
+  #offset = null;
+  constructor(date) {
+    let hasDate = true;
+    let hasTime = true;
+    let offset = "Z";
+    if (typeof date === "string") {
+      let match = date.match(DATE_TIME_RE);
+      if (match) {
+        if (!match[1]) {
+          hasDate = false;
+          date = `0000-01-01T${date}`;
+        }
+        hasTime = !!match[2];
+        hasTime && date[10] === " " && (date = date.replace(" ", "T"));
+        if (match[2] && +match[2] > 23) {
+          date = "";
+        } else {
+          offset = match[3] || null;
+          date = date.toUpperCase();
+          if (!offset && hasTime)
+            date += "Z";
+        }
+      } else {
+        date = "";
+      }
+    }
+    super(date);
+    if (!isNaN(this.getTime())) {
+      this.#hasDate = hasDate;
+      this.#hasTime = hasTime;
+      this.#offset = offset;
+    }
+  }
+  isDateTime() {
+    return this.#hasDate && this.#hasTime;
+  }
+  isLocal() {
+    return !this.#hasDate || !this.#hasTime || !this.#offset;
+  }
+  isDate() {
+    return this.#hasDate && !this.#hasTime;
+  }
+  isTime() {
+    return this.#hasTime && !this.#hasDate;
+  }
+  isValid() {
+    return this.#hasDate || this.#hasTime;
+  }
+  toISOString() {
+    let iso = super.toISOString();
+    if (this.isDate())
+      return iso.slice(0, 10);
+    if (this.isTime())
+      return iso.slice(11, 23);
+    if (this.#offset === null)
+      return iso.slice(0, -1);
+    if (this.#offset === "Z")
+      return iso;
+    let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+    offset = this.#offset[0] === "-" ? offset : -offset;
+    let offsetDate = new Date(this.getTime() - offset * 6e4);
+    return offsetDate.toISOString().slice(0, -1) + this.#offset;
+  }
+  static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+    let date = new _TomlDate(jsDate);
+    date.#offset = offset;
+    return date;
+  }
+  static wrapAsLocalDateTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalDate(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasTime = false;
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasDate = false;
+    date.#offset = null;
+    return date;
+  }
+};
+
+// node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/error.js
+function getLineColFromPtr(string, ptr) {
+  let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
+  return [lines.length, lines.pop().length + 1];
+}
+function makeCodeBlock(string, line, column) {
+  let lines = string.split(/\r\n|\n|\r/g);
+  let codeblock = "";
+  let numberLen = (Math.log10(line + 1) | 0) + 1;
+  for (let i = line - 1; i <= line + 1; i++) {
+    let l = lines[i - 1];
+    if (!l)
+      continue;
+    codeblock += i.toString().padEnd(numberLen, " ");
+    codeblock += ":  ";
+    codeblock += l;
+    codeblock += "\n";
+    if (i === line) {
+      codeblock += " ".repeat(numberLen + column + 2);
+      codeblock += "^\n";
+    }
+  }
+  return codeblock;
+}
+var TomlError = class extends Error {
+  line;
+  column;
+  codeblock;
+  constructor(message, options) {
+    const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+    const codeblock = makeCodeBlock(options.toml, line, column);
+    super(`Invalid TOML document: ${message}
+
+${codeblock}`, options);
+    this.line = line;
+    this.column = column;
+    this.codeblock = codeblock;
+  }
+};
+
+// node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/util.js
+function indexOfNewline(str, start = 0) {
+  let idx = str.indexOf("\n", start);
+  if (str.charCodeAt(idx - 1) === 13)
+    idx--;
+  return idx;
+}
+function skipComment(ctx) {
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    let c = ctx.s.charCodeAt(ctx.p);
+    if (c === 10)
+      break;
+    if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10) {
+      ctx.p++;
+      break;
+    }
+    if (c < 32 && c !== 9 || c === 127) {
+      throw new TomlError("control characters are not allowed in comments", {
+        toml: ctx.s,
+        ptr: ctx.p
+      });
+    }
+  }
+}
+function skipVoid(ctx, banNewLines, banComments) {
+  let c;
+  while (1) {
+    while ((c = ctx.s.charCodeAt(ctx.p)) === 32 || c === 9 || !banNewLines && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10))
+      ctx.p++;
+    if (banComments || c !== 35)
+      break;
+    skipComment(ctx);
+  }
+}
+function skipUntil(ctx, sep, end) {
+  let ptr = ctx.p;
+  if (!end) {
+    ptr = indexOfNewline(ctx.s, ptr);
+    ctx.p = ptr < 0 ? ctx.s.length : ptr;
+    return;
+  }
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    let c = ctx.s.charCodeAt(ctx.p);
+    if (c === 35) {
+      skipComment(ctx);
+    } else if (c === end || c === sep) {
+      return;
+    }
+  }
+  throw new TomlError("cannot find end of structure", {
+    toml: ctx.s,
+    ptr
+  });
+}
+
+// node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/primitive.js
+var INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
+var FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
+var LEADING_ZERO = /^[+-]?0[0-9_]/;
+function parseString(ctx) {
+  let start = ctx.p;
+  let c = ctx.s.charCodeAt(ctx.p++);
+  let first = c;
+  let isLiteral = c === 39;
+  let isMultiline = c === ctx.s.charCodeAt(ctx.p) && c === ctx.s.charCodeAt(ctx.p + 1);
+  if (isMultiline) {
+    if ((c = ctx.s.charCodeAt(ctx.p += 2)) === 10)
+      ctx.p++;
+    else if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)
+      ctx.p += 2;
+  }
+  let parsed = "";
+  let sliceStart = ctx.p;
+  let state = 0;
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    c = ctx.s.charCodeAt(ctx.p);
+    if (isMultiline && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)) {
+      state = state && 3;
+    } else if (c < 32 && c !== 9 || c === 127) {
+      throw new TomlError("control characters are not allowed in strings", {
+        toml: ctx.s,
+        ptr: ctx.p
+      });
+    } else if ((!state || state === 3) && c === first && (!isMultiline || ctx.s.charCodeAt(ctx.p + 1) === first && ctx.s.charCodeAt(ctx.p + 2) === first)) {
+      if (isMultiline) {
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
+      }
+      if (!state)
+        parsed += ctx.s.slice(sliceStart, ctx.p);
+      ctx.p += isMultiline ? 3 : 1;
+      return parsed;
+    } else if (!state) {
+      if (!isLiteral && c === 92) {
+        parsed += ctx.s.slice(sliceStart, sliceStart = ctx.p);
+        state = 1;
+      }
+    } else if (state === 1) {
+      if (c === 120 || c === 117 || c === 85) {
+        let value = 0;
+        let len = c === 120 ? 2 : c === 117 ? 4 : 8;
+        for (let j = 0; j < len; j++, ctx.p++) {
+          let hex = ctx.s.charCodeAt(ctx.p + 1);
+          let digit = (
+            /* 0-9 */
+            hex >= 48 && hex <= 57 ? hex - 48 : (
+              /* A-F */
+              hex >= 65 && hex <= 70 ? hex - 65 + 10 : (
+                /* a-f */
+                hex >= 97 && hex <= 102 ? hex - 97 + 10 : -1
+              )
+            )
+          );
+          if (digit < 0)
+            throw new TomlError("invalid non-hex character in unicode escape", { toml: ctx.s, ptr: ctx.p + 1 });
+          value = value << 4 | digit;
+        }
+        if (value < 0 || value > 1114111 || value >= 55296 && value <= 57343) {
+          throw new TomlError("invalid unicode escape", { toml: ctx.s, ptr: ctx.p });
+        }
+        parsed += String.fromCodePoint(value);
+        sliceStart = ctx.p + 1;
+        state = 0;
+      } else if (c === 32 || c === 9) {
+        state = 2;
+      } else {
+        if (c === 98)
+          parsed += "\b";
+        else if (c === 116)
+          parsed += "	";
+        else if (c === 110)
+          parsed += "\n";
+        else if (c === 102)
+          parsed += "\f";
+        else if (c === 114)
+          parsed += "\r";
+        else if (c === 101)
+          parsed += "\x1B";
+        else if (c === 34)
+          parsed += '"';
+        else if (c === 92)
+          parsed += "\\";
+        else
+          throw new TomlError("unrecognized escape sequence", { toml: ctx.s, ptr: ctx.p });
+        sliceStart = ctx.p + 1;
+        state = 0;
+      }
+    } else if (c !== 32 && c !== 9) {
+      if (state === 2) {
+        throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
+          toml: ctx.s,
+          ptr: sliceStart
+        });
+      }
+      state = !isLiteral && c === 92 ? 1 : 0;
+      sliceStart = ctx.p;
+    }
+  }
+  throw new TomlError("unfinished string", { toml: ctx.s, ptr: start });
+}
+function sliceAndTrimEndOf(ctx, start, end) {
+  let value = ctx.s.slice(start, end);
+  let commentIdx = value.indexOf("#");
+  if (commentIdx > 0) {
+    skipComment({ s: value, p: commentIdx, d: 0 });
+    value = value.slice(0, commentIdx);
+  }
+  return value.trimEnd();
+}
+function parseValue(ctx, integersAsBigInt, end) {
+  let ptr = ctx.p;
+  let err = { toml: ctx.s, ptr };
+  skipUntil(ctx, 44, end);
+  let value = sliceAndTrimEndOf(ctx, ptr, ctx.p);
+  if (!value)
+    throw new TomlError("incomplete declaration: value expected", err);
+  if (value === "-inf")
+    return -Infinity;
+  if (value === "inf" || value === "+inf")
+    return Infinity;
+  if (value === "nan" || value === "+nan" || value === "-nan")
+    return NaN;
+  if (value === "-0")
+    return integersAsBigInt ? 0n : 0;
+  let isInt = INT_REGEX.test(value);
+  if (isInt || FLOAT_REGEX.test(value)) {
+    if (LEADING_ZERO.test(value)) {
+      throw new TomlError("leading zeroes are not allowed", err);
+    }
+    value = value.replace(/_/g, "");
+    let numeric = +value;
+    if (isNaN(numeric)) {
+      throw new TomlError("invalid number", err);
+    }
+    if (isInt) {
+      if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
+        throw new TomlError("integer value cannot be represented losslessly", err);
+      }
+      if (isInt || integersAsBigInt === true)
+        numeric = BigInt(value);
+    }
+    return numeric;
+  }
+  const date = new TomlDate(value);
+  if (!date.isValid())
+    throw new TomlError("invalid value", err);
+  return date;
+}
+
+// node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/extract.js
+function extractValue(ctx, end, integersAsBigInt) {
+  let ptr = ctx.p;
+  let c = ctx.s.charCodeAt(ptr);
+  if (c === 91 || c === 123) {
+    if (!ctx.d--) {
+      throw new TomlError("document contains excessively nested structures. aborting.", {
+        toml: ctx.s,
+        ptr
+      });
+    }
+    let value = c === 91 ? parseArray(ctx, integersAsBigInt) : parseInlineTable(ctx, integersAsBigInt);
+    ctx.d++;
+    return value;
+  }
+  if (c === 34 || c === 39) {
+    return parseString(ctx);
+  }
+  if (c === 116) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 114 || ctx.s.charCodeAt(++ctx.p) !== 117 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      throw new TomlError("invalid value", { toml: ctx.s, ptr });
+    ctx.p++;
+    return true;
+  }
+  if (c === 102) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 108 || ctx.s.charCodeAt(++ctx.p) !== 115 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      throw new TomlError("invalid value", { toml: ctx.s, ptr });
+    ctx.p++;
+    return false;
+  }
+  return parseValue(ctx, integersAsBigInt, end);
+}
+
+// node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/struct.js
+var KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
+function parseKey(ctx, end = "=") {
+  let start = ctx.p;
+  let dot = start - 1;
+  let parsed = [];
+  let endPtr = ctx.s.indexOf(end, start);
+  if (endPtr < 0) {
+    throw new TomlError("incomplete key-value: cannot find end of key", {
+      toml: ctx.s,
+      ptr: start
+    });
+  }
+  do {
+    let c = ctx.s.charCodeAt(ctx.p = ++dot);
+    if (c !== 32 && c !== 9) {
+      if (c === 34 || c === 39) {
+        if (c === ctx.s.charCodeAt(ctx.p + 1) && c === ctx.s.charCodeAt(ctx.p + 2)) {
+          throw new TomlError("multiline strings are not allowed in keys", {
+            toml: ctx.s,
+            ptr: ctx.p
+          });
+        }
+        let part = parseString(ctx);
+        dot = ctx.s.indexOf(".", ctx.p);
+        let strEnd = ctx.s.slice(ctx.p, dot < 0 || dot > endPtr ? endPtr : dot);
+        let newLine = indexOfNewline(strEnd);
+        if (newLine > -1) {
+          throw new TomlError("newlines are not allowed in keys", {
+            toml: ctx.s,
+            ptr: newLine
+          });
+        }
+        if (strEnd.trimStart()) {
+          throw new TomlError("found extra tokens after the string part", {
+            toml: ctx.s,
+            ptr: ctx.p
+          });
+        }
+        if (endPtr < ctx.p) {
+          endPtr = ctx.s.indexOf(end, ctx.p);
+          if (endPtr < 0) {
+            throw new TomlError("incomplete key-value: cannot find end of key", {
+              toml: ctx.s,
+              ptr: start
+            });
+          }
+        }
+        parsed.push(part);
+      } else {
+        dot = ctx.s.indexOf(".", ctx.p);
+        let part = ctx.s.slice(ctx.p, dot < 0 || dot > endPtr ? endPtr : dot);
+        if (!KEY_PART_RE.test(part)) {
+          throw new TomlError("only letter, numbers, dashes and underscores are allowed in keys", {
+            toml: ctx.s,
+            ptr: ctx.p
+          });
+        }
+        parsed.push(part.trimEnd());
+      }
+    }
+  } while (dot + 1 && dot < endPtr);
+  ctx.p = endPtr + 1;
+  skipVoid(ctx, true, true);
+  return parsed;
+}
+function parseInlineTable(ctx, integersAsBigInt) {
+  let res = {};
+  let seen = /* @__PURE__ */ new Set();
+  let c;
+  ctx.p++;
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 125) {
+      ctx.p++;
+      return res;
+    }
+    let k;
+    let t = res;
+    let hasOwn = false;
+    let p = ctx.p;
+    let key = parseKey(ctx);
+    for (let i = 0; i < key.length; i++) {
+      if (i)
+        t = hasOwn ? t[k] : t[k] = {};
+      k = key[i];
+      if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
+        throw new TomlError("trying to redefine an already defined value", {
+          toml: ctx.s,
+          ptr: p
+        });
+      }
+      if (!hasOwn && k === "__proto__") {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+      }
+    }
+    if (hasOwn) {
+      throw new TomlError("trying to redefine an already defined value", {
+        toml: ctx.s,
+        ptr: ctx.p
+      });
+    }
+    let value = extractValue(ctx, 125, integersAsBigInt);
+    seen.add(t[k] = value);
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 125) {
+      return res;
+    }
+    if (c !== 44) {
+      throw new TomlError("expected comma or end of structure", { toml: ctx.s, ptr: ctx.p - 1 });
+    }
+  }
+  throw new TomlError("unfinished table encountered", {
+    toml: ctx.s,
+    ptr: ctx.p
+  });
+}
+function parseArray(ctx, integersAsBigInt) {
+  let res = [];
+  let c;
+  ctx.p++;
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 93) {
+      ctx.p++;
+      return res;
+    }
+    res.push(extractValue(ctx, 93, integersAsBigInt));
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 93) {
+      return res;
+    }
+    if (c !== 44) {
+      throw new TomlError("expected comma or end of structure", { toml: ctx.s, ptr: ctx.p - 1 });
+    }
+  }
+  throw new TomlError("unfinished array encountered", {
+    toml: ctx.s,
+    ptr: ctx.p
+  });
+}
+
+// node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/parse.js
+function peekTable(key, table, meta, type) {
+  let t = table;
+  let m = meta;
+  let k;
+  let hasOwn = false;
+  let state;
+  for (let i = 0; i < key.length; i++) {
+    if (i) {
+      t = hasOwn ? t[k] : t[k] = {};
+      m = (state = m[k]).c;
+      if (type === 0 && (state.t === 1 || state.t === 2)) {
+        return null;
+      }
+      if (state.t === 2) {
+        let l = t.length - 1;
+        t = t[l];
+        m = m[l].c;
+      }
+    }
+    k = key[i];
+    if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) {
+      return null;
+    }
+    if (!hasOwn) {
+      if (k === "__proto__") {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
+      }
+      m[k] = {
+        t: i < key.length - 1 && type === 2 ? 3 : type,
+        d: false,
+        i: 0,
+        c: {}
+      };
+    }
+  }
+  state = m[k];
+  if (state.t !== type && !(type === 1 && state.t === 3)) {
+    return null;
+  }
+  if (type === 2) {
+    if (!state.d) {
+      state.d = true;
+      t[k] = [];
+    }
+    t[k].push(t = {});
+    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: {} };
+  }
+  if (state.d) {
+    return null;
+  }
+  state.d = true;
+  if (type === 1) {
+    t = hasOwn ? t[k] : t[k] = {};
+  } else if (type === 0 && hasOwn) {
+    return null;
+  }
+  return [k, t, state.c];
+}
+function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
+  let ctx = { s: toml, p: 0, d: maxDepth };
+  let res = {};
+  let meta = {};
+  let tmp;
+  let tbl = res;
+  let m = meta;
+  skipVoid(ctx);
+  while (ctx.p < toml.length) {
+    if (toml.charCodeAt(ctx.p) === 91) {
+      let isTableArray = toml.charCodeAt(++ctx.p) === 91;
+      tmp = ctx.p += +isTableArray;
+      let k = parseKey(ctx, "]");
+      if (isTableArray) {
+        if (toml.charCodeAt(ctx.p - 1) !== 93) {
+          throw new TomlError("expected end of table declaration", {
+            toml,
+            ptr: ctx.p - 1
+          });
+        }
+        ctx.p++;
+      }
+      let p = peekTable(
+        k,
+        res,
+        meta,
+        isTableArray ? 2 : 1
+        /* Type.EXPLICIT */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr: tmp
+        });
+      }
+      m = p[2];
+      tbl = p[1];
+    } else {
+      tmp = ctx.p;
+      let k = parseKey(ctx);
+      let p = peekTable(
+        k,
+        tbl,
+        m,
+        0
+        /* Type.DOTTED */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr: tmp
+        });
+      }
+      p[1][p[0]] = extractValue(ctx, void 0, integersAsBigInt);
+    }
+    skipVoid(ctx, true);
+    if (ctx.p < toml.length && (tmp = toml.charCodeAt(ctx.p)) !== 10 && tmp !== 13) {
+      throw new TomlError("each key-value declaration must be followed by an end-of-line", {
+        toml,
+        ptr: ctx.p
+      });
+    }
+    skipVoid(ctx);
+  }
+  return res;
+}
+
+// packages/core/dist/config.js
+var DEFAULT_LIMITS = {
+  maxConcurrent: 2,
+  choreConcurrent: 1,
+  wedgeThresholdSecs: 600,
+  maxRestartAttempts: 2,
+  wallClockSecs: 3600,
+  choreRetentionDays: 7
+};
+function configPath() {
+  return path4.join(lobstahHome(), "config.toml");
+}
+function expandHome(p) {
+  return p.startsWith("~/") ? path4.join(os2.homedir(), p.slice(2)) : p;
+}
+function loadConfig() {
+  const file = configPath();
+  const raw = fs7.existsSync(file) ? parse(fs7.readFileSync(file, "utf8")) : {};
+  const reposRaw = raw.repos ?? {};
+  const repos = {};
+  for (const [key, r] of Object.entries(reposRaw)) {
+    repos[key] = {
+      path: expandHome(String(r.path ?? "")),
+      origin: r.origin ? String(r.origin) : void 0,
+      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
+    };
+  }
+  return {
+    repos,
+    harness: raw.harness ?? {},
+    limits: { ...DEFAULT_LIMITS, ...raw.limits ?? {} },
+    notifyCommand: raw.notifyCommand ? String(raw.notifyCommand) : void 0,
+    notifyVerbs: Array.isArray(raw.notifyVerbs) ? raw.notifyVerbs.map(String) : void 0,
+    remindSecs: raw.remindSecs !== void 0 ? Number(raw.remindSecs) : void 0
+  };
+}
+
+// packages/core/dist/toon.js
+function cell(v) {
+  if (v === void 0 || v === null)
+    return "";
+  const s = String(v);
+  return s.includes(",") || s.includes("\n") ? JSON.stringify(s) : s;
+}
+function toonKV(obj) {
+  return Object.entries(obj).filter(([, v]) => v !== void 0).map(([k, v]) => `${k}: ${cell(v)}`).join("\n");
+}
+function toonTable(name, rows, cols) {
+  const header = `${name}[${rows.length}]{${cols.join(",")}}:`;
+  if (rows.length === 0)
+    return header;
+  return [header, ...rows.map((r) => `  ${cols.map((c) => cell(r[c])).join(",")}`)].join("\n");
+}
+
+// packages/supervisor/dist/liveness.js
+import { execFileSync } from "node:child_process";
+function classify(input) {
+  const { hasRunner, alive, lastVerb, lastEventAt: lastEventAt2, startedAt, now, wedgeThresholdMs } = input;
+  if (lastVerb && TERMINAL_VERBS.includes(lastVerb))
+    return "terminal";
+  if (!hasRunner)
+    return "unclaimed";
+  if (alive === void 0)
+    return "unknown";
+  if (!alive)
+    return "dead";
+  const baseline = lastEventAt2 ?? startedAt;
+  if (baseline === void 0)
+    return "unknown";
+  return now - baseline > wedgeThresholdMs ? "wedged" : "busy";
+}
+function processStartTime(pid) {
+  try {
+    if (process.platform === "win32") {
+      const out = execFileSync("powershell.exe", ["-NoProfile", "-Command", `(Get-Process -Id ${pid}).StartTime.Ticks`], { encoding: "utf8" }).trim();
+      return out || void 0;
+    }
+    return execFileSync("ps", ["-p", String(pid), "-o", "lstart="], { encoding: "utf8" }).trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function pidAlive(pid, recordedStart) {
+  try {
+    process.kill(pid, 0);
+  } catch {
+    return false;
+  }
+  if (!recordedStart)
+    return true;
+  const current = processStartTime(pid);
+  return current !== void 0 && current === recordedStart;
+}
+function killGroup(pid, signal = "SIGTERM") {
+  if (process.platform === "win32") {
+    try {
+      execFileSync("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore" });
+    } catch {
+    }
+    return;
+  }
+  try {
+    process.kill(-pid, signal);
+  } catch {
+    try {
+      process.kill(pid, signal);
+    } catch {
+    }
+  }
+}
+
+// packages/supervisor/dist/daemon.js
+import * as fs9 from "node:fs";
+import * as os3 from "node:os";
+import * as path6 from "node:path";
+import { spawn as spawn2 } from "node:child_process";
+import { createRequire } 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 { 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`);
+}
+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;
+  } catch {
+    cursor = void 0;
+  }
+  if (log.length <= (cursor ?? 0))
+    return [];
+  let fresh = log.slice(cursor ?? 0);
+  if (cursor === void 0 && sinceMs > 0) {
+    fresh = fresh.filter((e) => Date.parse(e.at) >= sinceMs);
+  }
+  fs8.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));
+}
+function execNotify(command, ev, log = () => {
+}) {
+  const child = spawn(command, {
+    shell: true,
+    detached: true,
+    stdio: "ignore",
+    env: {
+      ...process.env,
+      LOBSTAH_ID: ev.id,
+      LOBSTAH_LANE: ev.lane,
+      LOBSTAH_VERB: ev.entry.verb,
+      LOBSTAH_NOTE: ev.entry.note ?? "",
+      LOBSTAH_AT: ev.entry.at
+    }
+  });
+  child.on("error", (err) => log(`notify: ${err.message}`));
+  child.unref();
+}
+function captureWaitBaseline() {
+  const lengths = {};
+  for (const lane of ["work", "chore"]) {
+    for (const id of notifiableIds(lane, Number.POSITIVE_INFINITY)) {
+      lengths[`${lane}:${id}`] = readStatusLog(id, lane).length;
+    }
+  }
+  return lengths;
+}
+function attnCursorPath(id, lane) {
+  return path5.join(laneDirs(lane).state, `${id}.attn`);
+}
+function readAttnCursor(file) {
+  try {
+    const parsed = JSON.parse(fs8.readFileSync(file, "utf8"));
+    return { seen: parsed.seen ?? 0, at: parsed.at ?? 0 };
+  } catch {
+    return { seen: 0, at: 0 };
+  }
+}
+function attentionNow(consume = true, remindMs = 15 * 6e4, now = Date.now()) {
+  const out = [];
+  for (const lane of ["work", "chore"]) {
+    for (const id of activeIds(lane)) {
+      const log = readStatusLog(id, lane);
+      const state = reconcile({ log, lastEventAt: lastEventAt(id, lane) });
+      if (state !== "needs-decision" && state !== "blocked")
+        continue;
+      const index = log.length - 1 - [...log].reverse().findIndex((e) => e.verb === state);
+      const entry = log[index];
+      if (!entry)
+        continue;
+      const file = attnCursorPath(id, lane);
+      const cursor = readAttnCursor(file);
+      const fresh = index >= cursor.seen;
+      const remind = !fresh && remindMs > 0 && now - cursor.at > remindMs;
+      if (!fresh && !remind)
+        continue;
+      out.push({ id, lane, entry });
+      if (consume)
+        fs8.writeFileSync(file, JSON.stringify({ seen: Math.max(cursor.seen, index + 1), at: now }));
+    }
+  }
+  return out;
+}
+function freshWakeEvents(baseline, verbs = DEFAULT_NOTIFY_VERBS) {
+  const out = [];
+  for (const lane of ["work", "chore"]) {
+    for (const id of notifiableIds(lane, Number.POSITIVE_INFINITY)) {
+      const key = `${lane}:${id}`;
+      const log = readStatusLog(id, lane);
+      const seen = baseline[key] ?? 0;
+      if (log.length > seen) {
+        baseline[key] = log.length;
+        for (const entry of log.slice(seen)) {
+          if (verbs.includes(entry.verb))
+            out.push({ id, lane, entry });
+        }
+      }
+    }
+  }
+  return out;
+}
+
+// packages/supervisor/dist/daemon.js
+var require_ = createRequire(import.meta.url);
+function runnerEntry() {
+  try {
+    return require_.resolve("@lobstah/runner");
+  } catch {
+    return fileURLToPath(new URL("./runner.js", import.meta.url));
+  }
+}
+function readRunnerInfo(dir) {
+  try {
+    return JSON.parse(fs9.readFileSync(path6.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 { id, lane, dir: d, runner: readRunnerInfo(d) };
+  });
+}
+function finalize(st) {
+  try {
+    fs9.renameSync(st.dir, path6.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 logPath = path6.join(laneDirs(st.lane).state, `${st.id}.runner.log`);
+  const log = fs9.openSync(logPath, "a");
+  const child = spawn2(process.execPath, [runnerEntry(), st.dir, st.lane], {
+    detached: true,
+    stdio: ["ignore", log, log],
+    env: {
+      ...process.env,
+      LOBSTAH_ATTEMPTS: String(opts.attempts),
+      ...opts.resume ? { LOBSTAH_RESUME: opts.resume } : {},
+      ...nudge ? { LOBSTAH_NUDGE: nudge } : {}
+    }
+  });
+  fs9.closeSync(log);
+  child.unref();
+  const info = {
+    pid: child.pid ?? -1,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    processStartTime: child.pid ? processStartTime(child.pid) : void 0,
+    attempts: opts.attempts
+  };
+  fs9.writeFileSync(path6.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"));
+    return ev.sessionId;
+  } catch {
+    return void 0;
+  }
+}
+function reconcileOne(st, cfg, log) {
+  const hasDescriptor = fs9.existsSync(path6.join(st.dir, "descriptor.json"));
+  if (!hasDescriptor) {
+    const age = Date.now() - fs9.statSync(st.dir).mtimeMs;
+    if (age > 5 * 6e4)
+      fs9.rmSync(st.dir, { recursive: true, force: true });
+    return;
+  }
+  const statusLog = readStatusLog(st.id, st.lane);
+  const lastVerb = statusLog.at(-1)?.verb;
+  const alive = st.runner ? pidAlive(st.runner.pid, st.runner.processStartTime) : void 0;
+  if (cancelRequested(st.id, st.lane) && st.runner && alive) {
+    log(`${st.id}: cancel requested, killing group ${st.runner.pid}`);
+    killGroup(st.runner.pid);
+    return;
+  }
+  const cls = classify({
+    hasRunner: st.runner !== void 0,
+    alive,
+    lastVerb,
+    lastEventAt: lastEventAt(st.id, st.lane),
+    startedAt: st.runner ? Date.parse(st.runner.startedAt) : void 0,
+    now: Date.now(),
+    wedgeThresholdMs: cfg.limits.wedgeThresholdSecs * 1e3
+  });
+  switch (cls) {
+    case "unclaimed":
+      spawnRunner(st, { attempts: 1 });
+      log(`${st.id}: spawned runner`);
+      break;
+    case "terminal":
+      if (!alive)
+        finalize(st);
+      break;
+    case "busy":
+      break;
+    case "dead": {
+      const attempts = (st.runner?.attempts ?? 0) + 1;
+      if (attempts <= cfg.limits.maxRestartAttempts + 1) {
+        log(`${st.id}: runner died, respawning (attempt ${attempts})`);
+        spawnRunner(st, { attempts, resume: sessionOf(st) });
+      } else {
+        appendStatus(st.id, st.lane, "failed", "runner died repeatedly; work preserved");
+        finalize(st);
+        log(`${st.id}: failed after ${attempts - 1} restarts`);
+      }
+      break;
+    }
+    case "wedged": {
+      const attempts = (st.runner?.attempts ?? 0) + 1;
+      if (st.runner)
+        killGroup(st.runner.pid, "SIGKILL");
+      if (attempts <= cfg.limits.maxRestartAttempts + 1) {
+        log(`${st.id}: wedged (no activity), forking session with a nudge (attempt ${attempts})`);
+        spawnRunner(st, {
+          attempts,
+          resume: sessionOf(st),
+          nudge: "The previous attempt stalled with no tool activity. Review git log and git status in this worktree, then continue the brief from where it stopped."
+        });
+      } else {
+        appendStatus(st.id, st.lane, "failed", "wedged repeatedly; work preserved");
+        finalize(st);
+        log(`${st.id}: failed after repeated wedges`);
+      }
+      break;
+    }
+    case "unknown":
+      log(`${st.id}: state unknown \u2014 leaving untouched`);
+      break;
+  }
+}
+function writeHeartbeat(cfg) {
+  const payload = {
+    machineId: os3.hostname(),
+    repos: Object.keys(cfg.repos),
+    harnesses: ["claude", "codex"],
+    maxConcurrent: cfg.limits.maxConcurrent,
+    version: "0.1.0",
+    heartbeat: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const tmp = `${executorPath()}.tmp`;
+  fs9.writeFileSync(tmp, JSON.stringify(payload, null, 2));
+  fs9.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 });
+  }
+}
+var daemonStartedAt = Date.now();
+function tick(log = () => {
+}) {
+  const cfg = loadConfig();
+  ensureLayout();
+  writeHeartbeat(cfg);
+  for (const lane of ["chore", "work"]) {
+    const active = listActive(lane);
+    for (const st of active)
+      reconcileOne(st, cfg, log);
+    const ceiling = lane === "work" ? cfg.limits.maxConcurrent : cfg.limits.choreConcurrent;
+    let inFlight = listActive(lane).length;
+    while (inFlight < ceiling) {
+      const id = claimNext(lane);
+      if (!id)
+        break;
+      log(`${id}: claimed (${lane})`);
+      inFlight++;
+      const st = listActive(lane).find((s) => s.id === id);
+      if (st)
+        reconcileOne(st, cfg, log);
+    }
+  }
+  if (cfg.notifyCommand) {
+    const verbs = cfg.notifyVerbs ?? DEFAULT_NOTIFY_VERBS;
+    for (const lane of ["work", "chore"]) {
+      for (const id of notifiableIds(lane)) {
+        for (const ev of pendingNotifications(id, lane, verbs, daemonStartedAt)) {
+          execNotify(cfg.notifyCommand, ev, log);
+          log(`${id}: notified ${ev.entry.verb}`);
+        }
+      }
+    }
+  }
+  pruneChores(loadConfig());
+}
+function acquireDaemonLock() {
+  const lockPath = path6.join(lobstahHome(), "daemon.lock");
+  try {
+    const prior = JSON.parse(fs9.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`);
+    }
+  } catch (err) {
+    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));
+  const release = () => {
+    try {
+      fs9.unlinkSync(lockPath);
+    } catch {
+    }
+  };
+  process.on("exit", release);
+  for (const sig of ["SIGINT", "SIGTERM"]) {
+    process.on(sig, () => {
+      release();
+      process.exit(0);
+    });
+  }
+}
+async function daemon(intervalMs = 5e3, log = console.log) {
+  ensureLayout();
+  acquireDaemonLock();
+  log(`lobstah daemon: watching ${laneDirs("work").queue} every ${intervalMs}ms`);
+  while (true) {
+    try {
+      tick(log);
+    } catch (err) {
+      log(`tick error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+}
+
+// apps/pick/dist/run.js
+import { spawn as spawn3 } from "node:child_process";
+
+// apps/pick/dist/config.js
+import * as fs10 from "node:fs";
+import { execSync } from "node:child_process";
+import * as os4 from "node:os";
+
+// apps/pick/dist/types.js
+var DEFAULT_MERGE_POLICY = {
+  enabled: false,
+  method: "squash",
+  approvers: [],
+  assigneeApproves: true,
+  restrictedLabels: [],
+  scope: "own"
+};
+var MARKER = /\[lobstah:([0-9a-f-]{36})\]/;
+function marker(uuid) {
+  return `[lobstah:${uuid}]`;
+}
+
+// apps/pick/dist/config.js
+function resolveTokenSource(section, label) {
+  const command = section.tokenCommand ? String(section.tokenCommand) : void 0;
+  const file = section.tokenFile ? String(section.tokenFile) : void 0;
+  const envName = section.tokenEnv ? String(section.tokenEnv) : void 0;
+  if (command) {
+    let cached;
+    return () => {
+      if (cached && Date.now() - cached.at < 5 * 6e4)
+        return cached.token;
+      const token = execSync(command, { encoding: "utf8" }).trim();
+      if (!token)
+        throw new Error(`${label}: tokenCommand produced no output`);
+      cached = { token, at: Date.now() };
+      return token;
+    };
+  }
+  if (file) {
+    return () => {
+      const token = fs10.readFileSync(file.startsWith("~/") ? `${os4.homedir()}/${file.slice(2)}` : file, "utf8").trim();
+      if (!token)
+        throw new Error(`${label}: tokenFile ${file} is empty`);
+      return token;
+    };
+  }
+  if (envName) {
+    return () => {
+      const token = process.env[envName];
+      if (!token)
+        throw new Error(`${label}: no token in $${envName}`);
+      return token;
+    };
+  }
+  throw new Error(`${label}: configure one of tokenCommand, tokenFile, tokenEnv`);
+}
+function loadPickupConfig() {
+  const file = configPath();
+  const raw = fs10.existsSync(file) ? parse(fs10.readFileSync(file, "utf8")) : {};
+  const p = raw.pickup ?? {};
+  const out = {
+    pollSecs: Number(p.pollSecs ?? 45),
+    notifyCommand: p.notifyCommand ? String(p.notifyCommand) : void 0
+  };
+  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 ?? ""),
+      token,
+      startLabel: String(gh.startLabel ?? "lobstah"),
+      claimedLabel: String(gh.claimedLabel ?? "lobstah:claimed"),
+      merge: { ...DEFAULT_MERGE_POLICY, ...gh.merge ?? {} }
+    };
+    if (!out.github.repo || !out.github.key || !out.github.identity) {
+      throw new Error("pickup.github requires repo, key, and identity");
+    }
+  }
+  const ln = p.linear;
+  if (ln) {
+    const token = resolveTokenSource({ tokenEnv: "LINEAR_TOKEN", ...ln }, "pickup.linear");
+    token();
+    out.linear = {
+      token,
+      startState: String(ln.startState ?? "Todo"),
+      claimedState: String(ln.claimedState ?? "In Progress"),
+      doneState: String(ln.doneState ?? "In Review"),
+      route: ln.route ?? {}
+    };
+  }
+  return out;
+}
+
+// apps/pick/dist/state.js
+import * as fs11 from "node:fs";
+import * as path7 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: {} };
+    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);
+  }
+  get(key) {
+    return this.data.map[key];
+  }
+  entries() {
+    return Object.entries(this.data.map);
+  }
+  set(key, entry) {
+    this.data.map[key] = entry;
+    this.save();
+  }
+  update(key, patch) {
+    const cur = this.data.map[key];
+    if (!cur)
+      return;
+    this.data.map[key] = { ...cur, ...patch };
+    this.save();
+  }
+  approvalConsumed(dedupKey) {
+    return dedupKey in this.data.consumedApprovals;
+  }
+  consumeApproval(dedupKey) {
+    this.data.consumedApprovals[dedupKey] = (/* @__PURE__ */ new Date()).toISOString();
+    this.save();
+  }
+  rebase(prKey) {
+    return this.data.rebases[prKey];
+  }
+  setRebase(prKey, uuid) {
+    this.data.rebases[prKey] = { uuid };
+    this.save();
+  }
+  failRebase(prKey) {
+    const cur = this.data.rebases[prKey];
+    if (cur) {
+      cur.failed = true;
+      this.save();
+    }
+  }
+  clearRebase(prKey) {
+    delete this.data.rebases[prKey];
+    this.save();
+  }
+};
+
+// apps/pick/dist/sources/github.js
+var API = "https://api.github.com";
+var GithubSource = class {
+  cfg;
+  name;
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.name = `gh:${cfg.repo}`;
+  }
+  async api(method, url, body) {
+    const res = await fetch(`${API}${url}`, {
+      method,
+      headers: {
+        authorization: `Bearer ${this.cfg.token()}`,
+        accept: "application/vnd.github+json",
+        "user-agent": "lobstah-pick",
+        ...body ? { "content-type": "application/json" } : {}
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok)
+      throw new Error(`github ${method} ${url}: ${res.status} ${await res.text()}`);
+    return res.status === 204 ? void 0 : await res.json();
+  }
+  issueKey(n) {
+    return `gh:${this.cfg.repo}#${n}`;
+  }
+  numberOf(key) {
+    return Number(key.split("#").pop());
+  }
+  async poll() {
+    const items = [];
+    const issues = await this.api("GET", `/repos/${this.cfg.repo}/issues?labels=${encodeURIComponent(this.cfg.startLabel)}&assignee=${this.cfg.identity}&state=open&per_page=50`);
+    for (const issue of issues) {
+      if (issue.pull_request)
+        continue;
+      items.push({
+        key: this.issueKey(issue.number),
+        kind: "issue",
+        repoKey: this.cfg.key,
+        title: issue.title,
+        brief: `${issue.title}
+
+${issue.body ?? ""}
+
+When the change is complete, commit it, push the branch, and open a PR against ${this.cfg.repo} referencing #${issue.number}.`
+      });
+    }
+    const pulls = await this.api("GET", `/repos/${this.cfg.repo}/pulls?state=open&per_page=50`);
+    for (const pr of pulls) {
+      const m = /^lobstah\/([0-9a-f-]{36})$/.exec(pr.head.ref);
+      if (!m)
+        continue;
+      const reviews = await this.latestReviews(pr.number);
+      const changes = reviews.find((r) => r.state === "CHANGES_REQUESTED" && r.commit_id === pr.head.sha);
+      if (!changes)
+        continue;
+      items.push({
+        key: `gh:${this.cfg.repo}#pr${pr.number}@${pr.head.sha}`,
+        kind: "review",
+        repoKey: this.cfg.key,
+        title: pr.title,
+        followUp: m[1],
+        brief: `Address the review feedback on ${pr.html_url} (branch ${pr.head.ref}). Check out that branch in this worktree, read the review comments with \`gh pr view ${pr.number} --comments\`, implement the requested changes, and push. Reply to review threads where a reply is warranted.`
+      });
+    }
+    return items;
+  }
+  async claim(item) {
+    if (item.kind === "review")
+      return true;
+    const n = this.numberOf(item.key);
+    const issue = await this.api("GET", `/repos/${this.cfg.repo}/issues/${n}`);
+    if (issue.labels.some((l) => l.name === this.cfg.claimedLabel))
+      return false;
+    await this.api("POST", `/repos/${this.cfg.repo}/issues/${n}/labels`, { labels: [this.cfg.claimedLabel] });
+    await this.api("DELETE", `/repos/${this.cfg.repo}/issues/${n}/labels/${encodeURIComponent(this.cfg.startLabel)}`).catch(() => {
+    });
+    return true;
+  }
+  async report(key, verb, evidence) {
+    const n = this.numberOf(key.replace(/@.*$/, "").replace("#pr", "#"));
+    const lines = [`${marker(evidence.uuid)} **${verb}**`];
+    if (evidence.prUrl)
+      lines.push(`PR: ${evidence.prUrl}`);
+    if (evidence.branch)
+      lines.push(`branch: \`${evidence.branch}\``);
+    if (evidence.note)
+      lines.push(evidence.note);
+    await this.api("POST", `/repos/${this.cfg.repo}/issues/${n}/comments`, { body: lines.join("\n") });
+  }
+  async inbound(key, since) {
+    if (key.includes("#pr"))
+      return [];
+    const n = this.numberOf(key);
+    const url = `/repos/${this.cfg.repo}/issues/${n}/comments${since ? `?since=${encodeURIComponent(since)}` : ""}`;
+    const comments = await this.api("GET", url);
+    return comments.filter((c) => c.user.login !== this.cfg.identity && !MARKER.test(c.body)).map((c) => c.body);
+  }
+  async inProgress() {
+    const issues = await this.api("GET", `/repos/${this.cfg.repo}/issues?labels=${encodeURIComponent(this.cfg.claimedLabel)}&state=all&per_page=100`);
+    return issues.filter((i) => !i.pull_request).map((i) => ({ key: this.issueKey(i.number), open: i.state === "open" }));
+  }
+  async recoverUuid(key) {
+    const n = this.numberOf(key);
+    const comments = await this.api("GET", `/repos/${this.cfg.repo}/issues/${n}/comments?per_page=100`);
+    for (const c of comments.reverse()) {
+      const m = MARKER.exec(c.body);
+      if (m)
+        return m[1];
+    }
+    return void 0;
+  }
+  async reset(key, note) {
+    const n = this.numberOf(key);
+    await this.api("POST", `/repos/${this.cfg.repo}/issues/${n}/comments`, { body: note });
+    await this.api("POST", `/repos/${this.cfg.repo}/issues/${n}/labels`, { labels: [this.cfg.startLabel] });
+    await this.api("DELETE", `/repos/${this.cfg.repo}/issues/${n}/labels/${encodeURIComponent(this.cfg.claimedLabel)}`).catch(() => {
+    });
+  }
+  // ── MergeSource ──────────────────────────────────────────────────────────
+  async latestReviews(n) {
+    const all = await this.api("GET", `/repos/${this.cfg.repo}/pulls/${n}/reviews?per_page=100`);
+    const latest = /* @__PURE__ */ new Map();
+    for (const r of all) {
+      if (r.state !== "APPROVED" && r.state !== "CHANGES_REQUESTED")
+        continue;
+      latest.set(r.user.login, r);
+    }
+    return [...latest.values()];
+  }
+  async toCandidate(pr) {
+    const reviews = await this.latestReviews(pr.number);
+    return {
+      number: pr.number,
+      url: pr.html_url,
+      author: pr.user.login,
+      headSha: pr.head.sha,
+      headRef: pr.head.ref,
+      labels: pr.labels.map((l) => l.name),
+      assignees: pr.assignees.map((a) => a.login),
+      reviews: reviews.map((r) => ({ id: r.id, author: r.user.login, state: r.state, sha: r.commit_id })),
+      mergeableState: pr.draft ? "draft" : pr.mergeable_state ?? "unknown"
+    };
+  }
+  async mergeCandidates() {
+    const pulls = await this.api("GET", `/repos/${this.cfg.repo}/pulls?state=open&per_page=50`);
+    const own = pulls.filter((p) => p.user.login === this.cfg.identity || p.head.ref.startsWith("lobstah/"));
+    return Promise.all(own.map((p) => this.toCandidate(p)));
+  }
+  async refresh(n) {
+    const pr = await this.api("GET", `/repos/${this.cfg.repo}/pulls/${n}`);
+    return pr.state === "open" ? this.toCandidate(pr) : void 0;
+  }
+  async updateBranch(n) {
+    await this.api("PUT", `/repos/${this.cfg.repo}/pulls/${n}/update-branch`, {});
+  }
+  async merge(n, method) {
+    await this.api("PUT", `/repos/${this.cfg.repo}/pulls/${n}/merge`, { merge_method: method });
+  }
+  async comment(n, text) {
+    await this.api("POST", `/repos/${this.cfg.repo}/issues/${n}/comments`, { body: text });
+  }
+  async addLabel(n, label) {
+    await this.api("POST", `/repos/${this.cfg.repo}/issues/${n}/labels`, { labels: [label] });
+  }
+  repoKey() {
+    return this.cfg.key;
+  }
+};
+
+// apps/pick/dist/sources/linear.js
+var API2 = "https://api.linear.app/graphql";
+function stateFor(cfg, verb) {
+  if (verb === "done")
+    return cfg.doneState;
+  if (verb === "failed")
+    return cfg.startState;
+  return void 0;
+}
+var LinearSource = class {
+  cfg;
+  name = "linear";
+  stateIds = /* @__PURE__ */ new Map();
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  async gql(query, variables = {}) {
+    const res = await fetch(API2, {
+      method: "POST",
+      headers: { authorization: this.cfg.token(), "content-type": "application/json" },
+      body: JSON.stringify({ query, variables })
+    });
+    const json = await res.json();
+    if (!res.ok || json.errors?.length) {
+      throw new Error(`linear: ${json.errors?.map((e) => e.message).join("; ") ?? res.status}`);
+    }
+    return json.data;
+  }
+  async assigned(stateName) {
+    const data = await this.gql(`query($state: String!) {
+        issues(filter: { assignee: { isMe: { eq: true } }, state: { name: { eq: $state } } }, first: 50) {
+          nodes { id identifier title description state { name } team { key id } }
+        }
+      }`, { state: stateName });
+    return data.issues.nodes;
+  }
+  async stateId(teamId, name) {
+    const cacheKey = `${teamId}:${name}`;
+    const cached = this.stateIds.get(cacheKey);
+    if (cached)
+      return cached;
+    const data = await this.gql(`query($team: String!) { team(id: $team) { states { nodes { id name } } } }`, { team: teamId });
+    for (const s of data.team.states.nodes)
+      this.stateIds.set(`${teamId}:${s.name}`, s.id);
+    const id = this.stateIds.get(cacheKey);
+    if (!id)
+      throw new Error(`linear: team has no state named "${name}"`);
+    return id;
+  }
+  async issueByKey(key) {
+    const identifier = key.replace(/^linear:/, "");
+    const data = await this.gql(`query($id: String!) { issue(id: $id) { id identifier title description state { name } team { key id } } }`, { id: identifier });
+    return data.issue;
+  }
+  async moveTo(issue, stateName) {
+    const stateId = await this.stateId(issue.team.id, stateName);
+    await this.gql(`mutation($id: String!, $state: String!) { issueUpdate(id: $id, input: { stateId: $state }) { success } }`, { id: issue.id, state: stateId });
+  }
+  async commentOn(issue, body) {
+    await this.gql(`mutation($id: String!, $body: String!) { commentCreate(input: { issueId: $id, body: $body }) { success } }`, { id: issue.id, body });
+  }
+  async poll() {
+    const issues = await this.assigned(this.cfg.startState);
+    return issues.flatMap((issue) => {
+      const repoKey = this.cfg.route[issue.team.key];
+      if (!repoKey)
+        return [];
+      return [
+        {
+          key: `linear:${issue.identifier}`,
+          kind: "issue",
+          repoKey,
+          title: issue.title,
+          brief: `${issue.identifier}: ${issue.title}
+
+${issue.description ?? ""}
+
+When the change is complete, commit it, push the branch, and open a PR whose description includes "Fixes ${issue.identifier}".`
+        }
+      ];
+    });
+  }
+  async claim(item) {
+    const issue = await this.issueByKey(item.key);
+    if (issue.state.name !== this.cfg.startState)
+      return false;
+    await this.moveTo(issue, this.cfg.claimedState);
+    return true;
+  }
+  async report(key, verb, evidence) {
+    const issue = await this.issueByKey(key);
+    const lines = [`${marker(evidence.uuid)} **${verb}**`];
+    if (evidence.prUrl)
+      lines.push(`PR: ${evidence.prUrl}`);
+    if (evidence.branch)
+      lines.push(`branch: \`${evidence.branch}\``);
+    if (evidence.note)
+      lines.push(evidence.note);
+    await this.commentOn(issue, lines.join("\n"));
+    const target = stateFor(this.cfg, verb);
+    if (target)
+      await this.moveTo(issue, target);
+  }
+  async inbound(key, since) {
+    const identifier = key.replace(/^linear:/, "");
+    const data = await this.gql(`query($id: String!) { issue(id: $id) { comments(first: 50) { nodes { body createdAt user { isMe } } } } }`, { id: identifier });
+    return data.issue.comments.nodes.filter((c) => !c.user?.isMe && !MARKER.test(c.body)).filter((c) => !since || c.createdAt > since).map((c) => c.body);
+  }
+  async inProgress() {
+    const issues = await this.assigned(this.cfg.claimedState);
+    return issues.map((i) => ({ key: `linear:${i.identifier}`, open: true }));
+  }
+  async recoverUuid(key) {
+    const identifier = key.replace(/^linear:/, "");
+    const data = await this.gql(`query($id: String!) { issue(id: $id) { comments(first: 100) { nodes { body } } } }`, { id: identifier });
+    for (const c of [...data.issue.comments.nodes].reverse()) {
+      const m = MARKER.exec(c.body);
+      if (m)
+        return m[1];
+    }
+    return void 0;
+  }
+  async reset(key, note) {
+    const issue = await this.issueByKey(key);
+    await this.commentOn(issue, note);
+    await this.moveTo(issue, this.cfg.startState);
+  }
+};
+
+// apps/pick/dist/loops/dispatch.js
+import { randomUUID } from "node:crypto";
+async function dispatchLoop(source, state, log = () => {
+}) {
+  const items = await source.poll();
+  for (const item of items) {
+    if (state.get(item.key))
+      continue;
+    if (!await source.claim(item)) {
+      log(`${item.key}: claim lost \u2014 another machine has it`);
+      continue;
+    }
+    const id = randomUUID();
+    enqueue({
+      id,
+      repo: item.repoKey,
+      brief: item.brief,
+      // A review dispatch forks the implementation session; issues start cold.
+      ...item.kind === "review" && item.followUp ? { followUp: item.followUp } : {}
+    }, "work");
+    state.set(item.key, { uuid: id, kind: item.kind, createdAt: (/* @__PURE__ */ new Date()).toISOString() });
+    log(`${item.key}: dispatched as ${id}`);
+  }
+}
+
+// apps/pick/dist/loops/report.js
+import * as fs12 from "node:fs";
+import * as path8 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`))) {
+      return lane;
+    }
+  }
+  return void 0;
+}
+async function reportLoop(source, state, log = () => {
+}, notify = () => {
+}) {
+  for (const [key, entry] of state.entries()) {
+    const lane = dispatchLane(entry.uuid);
+    if (!lane)
+      continue;
+    const verb = reconcile({
+      log: readStatusLog(entry.uuid, lane),
+      lastEventAt: lastEventAt(entry.uuid, lane)
+    });
+    if (verb !== "unknown" && verb !== entry.lastReported) {
+      const evidence = readEvidence(entry.uuid, lane);
+      await source.report(key, verb, { ...evidence, uuid: entry.uuid });
+      state.update(key, { lastReported: verb });
+      log(`${key}: reported ${verb}`);
+      notify({
+        key,
+        uuid: entry.uuid,
+        verb,
+        note: readStatusLog(entry.uuid, lane).at(-1)?.note,
+        prUrl: evidence.prUrl
+      });
+    }
+    const msgs = await source.inbound(key, entry.lastInboundAt);
+    if (msgs.length > 0) {
+      for (const m of msgs)
+        sendMessage(entry.uuid, lane, m);
+      state.update(key, { lastInboundAt: (/* @__PURE__ */ new Date()).toISOString() });
+      log(`${key}: forwarded ${msgs.length} comment(s) to inbox`);
+    }
+  }
+}
+
+// apps/pick/dist/loops/reconcile.js
+import * as fs13 from "node:fs";
+import * as path9 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`))) {
+      return lane;
+    }
+  }
+  return void 0;
+}
+async function reconcileLoop(source, state, log = () => {
+}) {
+  for (const { key, open } of await source.inProgress()) {
+    let entry = state.get(key);
+    if (!entry) {
+      const recovered = await source.recoverUuid(key);
+      if (recovered) {
+        state.set(key, { uuid: recovered, kind: "issue", createdAt: (/* @__PURE__ */ new Date()).toISOString(), recovered: true });
+        entry = state.get(key);
+        log(`${key}: rebuilt mapping to ${recovered} from the tracker trail`);
+      }
+    }
+    if (!entry) {
+      if (open) {
+        await source.reset(key, "no dispatch backs this item \u2014 resetting to the start state");
+        log(`${key}: orphaned item, reset`);
+      }
+      continue;
+    }
+    if (!open) {
+      const lane = dispatchActive(entry.uuid);
+      if (lane && !cancelRequested(entry.uuid, lane)) {
+        try {
+          requestCancel(entry.uuid, lane);
+          log(`${key}: item closed, cancelled orphaned dispatch ${entry.uuid}`);
+        } catch {
+        }
+      }
+    }
+  }
+}
+
+// apps/pick/dist/loops/merge.js
+import { randomUUID as randomUUID2 } from "node:crypto";
+import * as fs14 from "node:fs";
+import * as path10 from "node:path";
+function qualifyingSet(policy, pr) {
+  const restricted = pr.labels.some((l) => policy.restrictedLabels.includes(l));
+  if (restricted || !policy.assigneeApproves)
+    return [...policy.approvers];
+  return [.../* @__PURE__ */ new Set([...policy.approvers, ...pr.assignees])];
+}
+function qualifiedApproval(policy, pr) {
+  const outstanding = pr.reviews.some((r) => r.state === "CHANGES_REQUESTED");
+  if (outstanding)
+    return void 0;
+  const set = qualifyingSet(policy, pr);
+  return pr.reviews.find((r) => r.state === "APPROVED" && r.sha === pr.headSha && set.includes(r.author));
+}
+function approvalDedupKey(pr, review) {
+  return `${pr.number}#${review.id}@${pr.headSha}`;
+}
+function rebaseBrief(pr) {
+  return [
+    `Rebase the branch ${pr.headRef} of ${pr.url} onto its base branch, resolving any conflicts`,
+    `in a way that preserves the intent of both sides. Then push the rebased branch with`,
+    `\`git push --force-with-lease\`. Do not merge the PR. Do not change anything beyond conflict`,
+    `resolution. When pushed, report status done.`
+  ].join(" ");
+}
+function choreVerdict(uuid) {
+  const d = laneDirs("chore");
+  if (fs14.existsSync(path10.join(d.active, uuid)) || fs14.existsSync(path10.join(d.queue, `${uuid}.json`)))
+    return "active";
+  const last = readStatusLog(uuid, "chore").at(-1)?.verb;
+  return last === "done" ? "done" : "failed";
+}
+async function mergeLoop(ms, policy, state, log = () => {
+}) {
+  if (!policy.enabled)
+    return;
+  for (const candidate of await ms.mergeCandidates()) {
+    const prKey = `${ms.name}#${candidate.number}`;
+    const rebase = state.rebase(prKey);
+    if (rebase) {
+      if (rebase.failed)
+        continue;
+      const verdict = choreVerdict(rebase.uuid);
+      if (verdict === "active")
+        continue;
+      if (verdict === "failed") {
+        await ms.comment(candidate.number, `Automated rebase failed (dispatch ${rebase.uuid}) \u2014 needs a human.`);
+        await ms.addLabel(candidate.number, "needs-human");
+        state.failRebase(prKey);
+        log(`${prKey}: rebase chore failed, flagged for a human`);
+        continue;
+      }
+      state.clearRebase(prKey);
+    }
+    const provisional = qualifiedApproval(policy, candidate);
+    if (!provisional)
+      continue;
+    if (state.approvalConsumed(approvalDedupKey(candidate, provisional)))
+      continue;
+    const pr = await ms.refresh(candidate.number);
+    if (!pr)
+      continue;
+    const approval = qualifiedApproval(policy, pr);
+    if (!approval) {
+      log(`${prKey}: gate no longer holds on fresh fetch \u2014 skipping`);
+      continue;
+    }
+    const dedupKey = approvalDedupKey(pr, approval);
+    if (state.approvalConsumed(dedupKey))
+      continue;
+    switch (pr.mergeableState) {
+      case "blocked":
+      case "draft":
+        log(`${prKey}: ${pr.mergeableState} \u2014 not merging`);
+        break;
+      case "behind":
+        await ms.updateBranch(pr.number);
+        log(`${prKey}: behind base, updated branch \u2014 gate re-enters next tick`);
+        break;
+      case "dirty": {
+        const uuid = randomUUID2();
+        enqueue({ id: uuid, repo: ms.repoKey(), brief: rebaseBrief(pr) }, "chore");
+        state.setRebase(prKey, uuid);
+        log(`${prKey}: real conflict \u2014 wrote rebase chore ${uuid}`);
+        break;
+      }
+      default: {
+        await ms.merge(pr.number, policy.method);
+        state.consumeApproval(dedupKey);
+        log(`${prKey}: merged (${policy.method}) on approval by ${approval.author}`);
+      }
+    }
+  }
+}
+
+// apps/pick/dist/run.js
+function makeNotifier(command, log) {
+  if (!command)
+    return () => {
+    };
+  return (n) => {
+    const child = spawn3(command, {
+      shell: true,
+      env: {
+        ...process.env,
+        LOBSTAH_KEY: n.key,
+        LOBSTAH_UUID: n.uuid,
+        LOBSTAH_VERB: n.verb,
+        LOBSTAH_NOTE: n.note ?? "",
+        LOBSTAH_PR_URL: n.prUrl ?? ""
+      },
+      stdio: "ignore",
+      detached: true
+    });
+    child.on("error", (err) => log(`notify: ${err.message}`));
+    child.unref();
+  };
+}
+async function cycle(sources, merges, state, log, notify) {
+  for (const source of sources) {
+    try {
+      await dispatchLoop(source, state, log);
+      await reportLoop(source, state, log, notify);
+      await reconcileLoop(source, state, log);
+    } catch (err) {
+      log(`${source.name}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  for (const { source, policy } of merges) {
+    try {
+      await mergeLoop(source, policy, state, log);
+    } catch (err) {
+      log(`${source.name} merge: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+}
+async function runPickup(mode = "daemon") {
+  ensureLayout();
+  const cfg = loadPickupConfig();
+  const state = new PickupState();
+  const log = (m) => console.log(`[pickup] ${m}`);
+  const sources = [];
+  const merges = [];
+  if (cfg.github) {
+    const gh = new GithubSource(cfg.github);
+    sources.push(gh);
+    merges.push({ source: gh, policy: cfg.github.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");
+  }
+  const notify = makeNotifier(cfg.notifyCommand, log);
+  if (mode === "once") {
+    await cycle(sources, merges, state, log, notify);
+    return;
+  }
+  log(`polling every ${cfg.pollSecs}s \u2014 no webhooks, no inbound surface`);
+  while (true) {
+    await cycle(sources, merges, state, log, notify);
+    await new Promise((r) => setTimeout(r, cfg.pollSecs * 1e3));
+  }
+}
+
+// apps/cli/src/hooks.ts
+var HAUL_HOOK = { type: "command", command: "lobstah man haul", timeout: 14400 };
+function mergeHaulHook(existing) {
+  const settings = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
+  settings.hooks = settings.hooks && typeof settings.hooks === "object" ? settings.hooks : {};
+  const stop = Array.isArray(settings.hooks.Stop) ? settings.hooks.Stop : [];
+  const present = stop.some((m) => (m.hooks ?? []).some((h) => h.command?.includes("lobstah man haul")));
+  if (present) return { settings, changed: false };
+  stop.push({ hooks: [{ ...HAUL_HOOK }] });
+  settings.hooks.Stop = stop;
+  return { settings, changed: true };
+}
+
+// apps/cli/src/cull.ts
+import * as fs15 from "node:fs";
+import * as path11 from "node:path";
+import { execFileSync as execFileSync2 } from "node:child_process";
+var DAY = 864e5;
+function idsIn(dir) {
+  try {
+    return new Set(fs15.readdirSync(dir).filter((f) => !f.startsWith(".")).map((f) => f.replace(/\.json$/, "")));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function planCull(olderThanDays, now = Date.now()) {
+  const cutoff = now - olderThanDays * DAY;
+  const items = [];
+  const live = /* @__PURE__ */ new Set();
+  const doneMtimes = /* @__PURE__ */ new Map();
+  for (const lane of ["work", "chore"]) {
+    const d = laneDirs(lane);
+    for (const id of idsIn(d.queue)) live.add(id);
+    for (const id of idsIn(d.active)) live.add(id);
+    for (const id of idsIn(d.done)) {
+      const p = path11.join(d.done, id);
+      const m = fs15.statSync(p).mtimeMs;
+      doneMtimes.set(id, m);
+      if (m < cutoff) items.push({ kind: "done", id, target: p, ageDays: Math.floor((now - m) / DAY) });
+    }
+  }
+  const wtRoot = path11.join(lobstahHome(), "worktrees");
+  for (const id of idsIn(wtRoot)) {
+    if (live.has(id)) continue;
+    const doneAt = doneMtimes.get(id);
+    if (doneAt !== void 0 && doneAt >= cutoff) continue;
+    const p = path11.join(wtRoot, id);
+    items.push({ kind: "worktree", id, target: p, ageDays: Math.floor((now - fs15.statSync(p).mtimeMs) / DAY) });
+  }
+  for (const lane of ["work", "chore"]) {
+    const d = laneDirs(lane);
+    const seen = /* @__PURE__ */ new Set();
+    for (const f of fs15.readdirSync(d.state)) {
+      const id = f.replace(/\.(status|events|evidence|attn|notified|runner\.log)$/, "");
+      if (id === f || seen.has(id) || live.has(id) || doneMtimes.has(id)) continue;
+      const m = fs15.statSync(path11.join(d.state, f)).mtimeMs;
+      if (m >= cutoff) continue;
+      seen.add(id);
+      items.push({ kind: "state", id, target: path11.join(d.state, `${id}.*`), ageDays: Math.floor((now - m) / DAY) });
+    }
+  }
+  return items;
+}
+function removeWorktree(id, dir) {
+  for (const lane of ["work", "chore"]) {
+    const descFile = path11.join(laneDirs(lane).done, id, "descriptor.json");
+    try {
+      const desc = JSON.parse(fs15.readFileSync(descFile, "utf8"));
+      const repo = loadConfig().repos[desc.repo];
+      if (repo) {
+        execFileSync2("git", ["worktree", "remove", "--force", dir], { cwd: repo.path, stdio: "ignore" });
+        return;
+      }
+    } catch {
+    }
+  }
+  fs15.rmSync(dir, { recursive: true, force: true });
+}
+function applyCull(items) {
+  for (const item of items.filter((i) => i.kind === "worktree")) removeWorktree(item.id, item.target);
+  for (const item of items.filter((i) => i.kind === "done")) fs15.rmSync(item.target, { recursive: true, force: true });
+  for (const item of items.filter((i) => i.kind === "state")) {
+    const dir = path11.dirname(item.target);
+    for (const f of fs15.readdirSync(dir)) {
+      if (f.startsWith(`${item.id}.`)) fs15.rmSync(path11.join(dir, f), { force: true });
+    }
+  }
+}
+
+// apps/cli/src/manual.ts
+var MANUAL = `the lobsterman's manual
+
+You are the lobsterman: one interactive session that sets traps (dispatches),
+reads buoys (status), and hauls when something needs you. The boat (daemon)
+does the supervision \u2014 you never watch a trap work.
+
+your working set:
+  lobstah set --repo <key> --bait <brief.md>    set a trap (alias of dispatch)
+  lobstah buoys                                 scan the water (alias of ls)
+  lobstah buoy <id>                             check one buoy (alias of status)
+  lobstah logs <id> --follow                    listen on one line
+  lobstah send <id> "<instruction>"             more bait, delivered between turns
+  lobstah attach <id>                           bring one trap alongside
+  lobstah swap <id> --harness codex             re-rig on the same spot
+  lobstah catch <id>                            land the catch (evidence)
+  lobstah cancel <id>                           cut one away
+  lobstah cull [--apply]                        sweep aged catch and lost gear
+
+getting woken instead of asking:
+  lobstah man wait          block until a dispatch needs attention (arm it as a
+                            background task; re-arm after each wake)
+  lobstah man init          install the Stop-hook park, then launch the
+                            designated session with: LOBSTAH_MAN=1 claude
+  lobstah man wait --peek   at session start \u2014 resurface anything standing
+
+paste into your liaison instructions:
+  For any task that should run in the background, dispatch it with the lobstah
+  CLI instead of doing it inline. Write briefs that stand alone \u2014 the worker
+  has no other context. Check progress when asked, not on a loop. A dispatch
+  reporting needs-decision is waiting on the human: surface its question
+  immediately, then \`lobstah send\` the answer. done means brief fulfilled \u2014
+  report the catch (\`lobstah catch <id>\`) and never merge anything yourself.
+
+full pattern and trade-offs: docs/lobsterman.md \xB7 config: docs/configuration.md`;
+
+// apps/cli/src/main.ts
+var HELP = `lobstah \u2014 supervisor for local coding agents
+
+work (humans and agents):
+  dispatch --repo <key> (--brief <file> | --brief-text <text>)   (alias: set --bait)
+           [--harness claude|codex] [--model <m>] [--effort <e>]
+           [--follow-up <uuid>] [--chore] [--id <uuid>]
+                                  queue a supervised dispatch; prints the id
+  ls [--all]                      queue, active, recent done      (alias: buoys)
+  status [<uuid>]                 reconciled state                (alias: buoy)
+  logs <uuid> [--follow]          the normalized event stream
+  send <uuid> <message>           deliver an instruction between agent turns
+  inbox <uuid>                    read and acknowledge pending messages
+                                  (workers: check at natural checkpoints)
+  attach <uuid> [--print] [--force]
+                                  open the dispatch's own harness session in
+                                  its worktree (claude --resume / codex resume)
+  swap <uuid> [--harness claude|codex] [--model <m>] [--effort <e>]
+                                  hand an active dispatch to a fresh session \u2014
+                                  same worktree and brief plus a git progress
+                                  note; conversations don't cross harnesses
+  catch <uuid>                    the evidence: branch, commits, PR, session
+  cull [--older-than <days>] [--apply]
+                                  sweep aged catch and lost gear \u2014 old done/
+                                  entries, orphaned worktrees, stale state.
+                                  Dry run by default (14 days).
+  cancel <uuid>                   request cancellation
+
+host processes (run under launchd/systemd/pm2):
+  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
+
+lobsterman (orchestrator sessions \u2014 bare \`lobstah man\` prints the manual):
+  man wait [--timeout <secs>] [--peek]
+                                  block until a dispatch needs attention, then
+                                  print the event and what to do next; exit 2
+                                  on timeout. Unanswered questions re-fire
+                                  every remindSecs until answered.
+  man init [--shared] [--marker]  install the haul Stop hook into this
+                                  project's .claude/settings.local.json
+                                  (--shared: settings.json); --marker touches
+                                  .lobstah-man. Idempotent.
+  man 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:
+                                  LOBSTAH_MAN=1 or a .lobstah-man file.
+
+workers (dispatched agents; injected into every brief):
+  report <uuid> <verb> [note] [--pr <url>]
+                                  the validated status write path
+                                  (${VERBS.join(" | ")})
+
+setup:
+  init                            create ~/.lobstah + example config
+
+Everything except daemon and pick works with both stopped: writes are files,
+reads are files. Output is TOON; agents can drive this CLI directly.
+Home: $LOBSTAH_HOME (default ~/.lobstah) \u2014 one daemon per home, enforced.`;
+function arg(args, flag) {
+  const i = args.indexOf(flag);
+  return i >= 0 ? args[i + 1] : void 0;
+}
+function findLane(id) {
+  for (const lane of ["work", "chore"]) {
+    const d = laneDirs(lane);
+    if (fs16.existsSync(path12.join(d.active, id)) || fs16.existsSync(path12.join(d.queue, `${id}.json`)) || fs16.existsSync(path12.join(d.done, id)) || fs16.existsSync(path12.join(d.state, `${id}.status`))) {
+      return lane;
+    }
+  }
+  throw new Error(`unknown dispatch ${id}`);
+}
+function rowsFor(lane, bucket) {
+  const dir = laneDirs(lane)[bucket];
+  const entries = fs16.readdirSync(dir).filter((f) => !f.startsWith(".")).map((f) => ({ f, m: fs16.statSync(path12.join(dir, f)).mtimeMs })).sort((a, b) => b.m - a.m);
+  const sliced = bucket === "done" ? entries.slice(0, 10) : entries;
+  return sliced.map(({ f, m }) => {
+    const id = f.replace(/\.json$/, "");
+    const state = reconcile({ log: readStatusLog(id, lane), lastEventAt: lastEventAt(id, lane) });
+    return { id, lane, bucket, state, updated: new Date(m).toISOString() };
+  });
+}
+async function mainCli() {
+  let [cmd, ...args] = process.argv.slice(2);
+  const ALIASES = { set: "dispatch", buoys: "ls", buoy: "status" };
+  cmd = cmd !== void 0 ? ALIASES[cmd] ?? cmd : cmd;
+  if (cmd === "man") {
+    cmd = args.length > 0 ? `man:${args[0]}` : "man:manual";
+    args = args.slice(1);
+  }
+  ensureLayout();
+  switch (cmd) {
+    case "dispatch": {
+      const repo = arg(args, "--repo");
+      const briefFile = arg(args, "--brief") ?? arg(args, "--bait");
+      const briefText = arg(args, "--brief-text");
+      if (!repo || !briefFile && !briefText) {
+        throw new Error("dispatch requires --repo and --brief <file> (or --brief-text)");
+      }
+      const d = {
+        id: arg(args, "--id") ?? randomUUID3(),
+        repo,
+        brief: briefText ?? fs16.readFileSync(briefFile, "utf8"),
+        harness: arg(args, "--harness"),
+        model: arg(args, "--model"),
+        effort: arg(args, "--effort"),
+        followUp: arg(args, "--follow-up")
+      };
+      const lane = args.includes("--chore") ? "chore" : "work";
+      enqueue(d, lane);
+      console.log(toonKV({ id: d.id, repo, lane, queued: (/* @__PURE__ */ new Date()).toISOString() }));
+      break;
+    }
+    case "ls": {
+      const lanes = args.includes("--all") ? ["work", "chore"] : ["work"];
+      const rows = lanes.flatMap(
+        (lane) => ["queue", "active", "done"].flatMap((b) => rowsFor(lane, b))
+      );
+      console.log(toonTable("dispatches", rows, ["id", "lane", "bucket", "state", "updated"]));
+      break;
+    }
+    case "status": {
+      const id = args[0];
+      if (!id) {
+        const rows = ["work", "chore"].flatMap((lane2) => rowsFor(lane2, "active"));
+        console.log(toonTable("active", rows, ["id", "lane", "state", "updated"]));
+        break;
+      }
+      const lane = findLane(id);
+      const log = readStatusLog(id, lane);
+      const state = reconcile({ log, lastEventAt: lastEventAt(id, lane) });
+      console.log(toonKV({ id, lane, state, lastNote: log.at(-1)?.note, entries: log.length }));
+      break;
+    }
+    case "logs": {
+      const id = args[0];
+      if (!id) throw new Error("logs requires a dispatch id");
+      const lane = findLane(id);
+      const file = eventsPath(id, lane);
+      if (fs16.existsSync(file)) process.stdout.write(fs16.readFileSync(file, "utf8"));
+      if (args.includes("--follow")) {
+        let size = fs16.existsSync(file) ? fs16.statSync(file).size : 0;
+        setInterval(() => {
+          if (!fs16.existsSync(file)) return;
+          const now = fs16.statSync(file).size;
+          if (now > size) {
+            const fd = fs16.openSync(file, "r");
+            const buf = Buffer.alloc(now - size);
+            fs16.readSync(fd, buf, 0, buf.length, size);
+            fs16.closeSync(fd);
+            process.stdout.write(buf.toString("utf8"));
+            size = now;
+          }
+        }, 1e3);
+        await new Promise(() => {
+        });
+      }
+      break;
+    }
+    case "send": {
+      const [id, ...rest] = args;
+      if (!id || rest.length === 0) throw new Error("send requires an id and a message");
+      const name = sendMessage(id, findLane(id), rest.join(" "));
+      console.log(toonKV({ id, queued: name }));
+      break;
+    }
+    case "report": {
+      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 entry = appendStatus(id, lane, verb, note);
+      if (prUrl) mergeEvidence(id, lane, { prUrl });
+      console.log(toonKV({ id, verb: entry.verb, at: entry.at, ...prUrl ? { prUrl } : {} }));
+      break;
+    }
+    case "inbox": {
+      const id = args[0];
+      if (!id) throw new Error("inbox requires a dispatch id");
+      const lane = findLane(id);
+      const msgs = unhandled(id, lane);
+      if (msgs.length === 0) {
+        console.log(toonKV({ id, inbox: "empty" }));
+        break;
+      }
+      for (const m of msgs) {
+        console.log(`--- message ${m.file}`);
+        console.log(m.text);
+        acknowledge(id, lane, m.file);
+      }
+      break;
+    }
+    case "attach": {
+      const id = args[0];
+      if (!id) throw new Error("attach requires a dispatch id");
+      const lane = findLane(id);
+      const state = reconcile({ log: readStatusLog(id, lane), lastEventAt: lastEventAt(id, lane) });
+      if (state === "working" && !args.includes("--force")) {
+        throw new Error(
+          `${id} is still working \u2014 attaching would put two writers on one session. Follow it with \`lobstah logs ${id} --follow\`, steer it with \`lobstah send\`, or pass --force after cancelling.`
+        );
+      }
+      const dirs = laneDirs(lane);
+      const descriptorFile = ["active", "done"].map((b) => path12.join(dirs[b], id, "descriptor.json")).find((f) => fs16.existsSync(f));
+      const harness = descriptorFile ? JSON.parse(fs16.readFileSync(descriptorFile, "utf8")).harness ?? "claude" : "claude";
+      let sessionId;
+      try {
+        sessionId = JSON.parse(fs16.readFileSync(path12.join(dirs.state, `${id}.evidence`), "utf8")).sessionId;
+      } catch {
+      }
+      if (!sessionId) throw new Error(`${id} has no recorded harness session to attach to`);
+      const worktree = path12.join(lobstahHome(), "worktrees", id);
+      const cwd = fs16.existsSync(worktree) ? worktree : process.cwd();
+      const invocation = harness === "codex" ? { file: "codex", argv: ["resume", sessionId] } : { file: "claude", argv: ["--resume", sessionId] };
+      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" });
+      if (res.error) throw new Error(`could not launch ${invocation.file}: ${res.error.message}`);
+      break;
+    }
+    case "swap": {
+      const id = args[0];
+      if (!id) throw new Error("swap requires a dispatch id");
+      const lane = findLane(id);
+      const activeDir = path12.join(laneDirs(lane).active, id);
+      if (!fs16.existsSync(activeDir)) throw new Error(`${id} is not active \u2014 swap only applies to in-flight dispatches`);
+      const descFile = path12.join(activeDir, "descriptor.json");
+      const descriptor = JSON.parse(fs16.readFileSync(descFile, "utf8"));
+      const fromHarness = descriptor.harness ?? "default";
+      for (const key of ["harness", "model", "effort"]) {
+        const v = arg(args, `--${key}`);
+        if (v) descriptor[key] = v;
+      }
+      fs16.writeFileSync(descFile, JSON.stringify(descriptor, null, 2));
+      const worktree = path12.join(lobstahHome(), "worktrees", id);
+      let progress = "No worktree progress recorded.";
+      if (fs16.existsSync(worktree)) {
+        const git = (...a) => spawnSync("git", a, { cwd: worktree, encoding: "utf8" }).stdout?.trim() ?? "";
+        const commits = git("log", "--oneline", "-15");
+        const status = git("status", "--short");
+        progress = `Commits so far:
+${commits || "(none)"}
+
+Uncommitted changes:
+${status || "(clean)"}`;
+      }
+      fs16.writeFileSync(
+        path12.join(activeDir, "handoff"),
+        `You are taking over this dispatch from a previous agent session (harness: ${fromHarness}). Its conversation is not available \u2014 the worktree state below is the ground truth. Review it, then continue the brief from where it stops.
+
+${progress}`
+      );
+      const runnerFile = path12.join(activeDir, "runner.json");
+      if (fs16.existsSync(runnerFile)) {
+        const runner = JSON.parse(fs16.readFileSync(runnerFile, "utf8"));
+        if (pidAlive(runner.pid, runner.processStartTime)) killGroup(runner.pid, "SIGKILL");
+        fs16.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 }));
+      break;
+    }
+    case "catch": {
+      const id = args[0];
+      if (!id) throw new Error("catch requires a dispatch id");
+      const lane = findLane(id);
+      const log = readStatusLog(id, lane);
+      const ev = readEvidence(id, lane);
+      console.log(
+        toonKV({
+          id,
+          state: reconcile({ log, lastEventAt: lastEventAt(id, lane) }),
+          branch: ev.branch,
+          prUrl: ev.prUrl,
+          sessionId: ev.sessionId,
+          note: log.at(-1)?.note
+        })
+      );
+      if (ev.commits?.length) {
+        console.log(`commits[${ev.commits.length}]:`);
+        for (const c of ev.commits) console.log(`  ${c}`);
+      }
+      break;
+    }
+    case "cull": {
+      const days = Number(arg(args, "--older-than") ?? "14");
+      const plan = planCull(days);
+      console.log(
+        toonTable(
+          "cull",
+          plan.map((i) => ({ kind: i.kind, id: i.id, ageDays: i.ageDays })),
+          ["kind", "id", "ageDays"]
+        )
+      );
+      if (plan.length === 0) break;
+      if (args.includes("--apply")) {
+        applyCull(plan);
+        console.log(`applied: ${plan.length} removed`);
+      } else {
+        console.log("dry run \u2014 pass --apply to remove");
+      }
+      break;
+    }
+    case "man:manual": {
+      console.log(MANUAL);
+      break;
+    }
+    case "cancel": {
+      const id = args[0];
+      if (!id) throw new Error("cancel requires a dispatch id");
+      requestCancel(id, findLane(id));
+      console.log(toonKV({ id, cancel: "requested" }));
+      break;
+    }
+    case "man:wait": {
+      const timeoutSecs = Number(arg(args, "--timeout") ?? "0");
+      const deadline = timeoutSecs > 0 ? Date.now() + timeoutSecs * 1e3 : Number.POSITIVE_INFINITY;
+      const emit = (evs) => {
+        for (const e of evs) {
+          console.log(toonKV({ id: e.id, lane: e.lane, verb: e.entry.verb, note: e.entry.note, at: e.entry.at }));
+        }
+        const ev = evs[0];
+        console.log(
+          `next: run \`lobstah status ${ev.id}\` for full state` + (ev.entry.verb === "needs-decision" || ev.entry.verb === "blocked" ? `, answer with \`lobstah send ${ev.id} "<answer>"\`` : ", collect the evidence and report the outcome") + ", then re-arm a background `lobstah man wait`."
+        );
+      };
+      const remindMs = (loadConfig().remindSecs ?? 900) * 1e3;
+      const standing = attentionNow(!args.includes("--peek"), remindMs);
+      if (standing.length > 0) {
+        emit(standing);
+        break;
+      }
+      const baseline = captureWaitBaseline();
+      while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 1500));
+        const fresh = freshWakeEvents(baseline);
+        if (fresh.length > 0) {
+          emit(fresh);
+          return;
+        }
+      }
+      console.log(toonKV({ timeout: true, waitedSecs: timeoutSecs }));
+      process.exitCode = 2;
+      break;
+    }
+    case "man:init": {
+      const file = path12.join(".claude", args.includes("--shared") ? "settings.json" : "settings.local.json");
+      let existing;
+      try {
+        existing = JSON.parse(fs16.readFileSync(file, "utf8"));
+      } catch {
+        existing = void 0;
+      }
+      const { settings, changed } = mergeHaulHook(existing);
+      if (changed) {
+        fs16.mkdirSync(".claude", { recursive: true });
+        fs16.writeFileSync(file, `${JSON.stringify(settings, null, 2)}
+`);
+      }
+      if (args.includes("--marker")) fs16.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"
+        })
+      );
+      break;
+    }
+    case "man:haul": {
+      try {
+        if (process.env.LOBSTAH_MAN !== "1" && !fs16.existsSync(".lobstah-man")) break;
+        const anyActive = ["work", "chore"].some(
+          (l) => fs16.readdirSync(laneDirs(l).active).some((f) => !f.startsWith("."))
+        );
+        if (!anyActive) break;
+        const timeoutSecs = Number(arg(args, "--timeout") ?? "14000");
+        const deadline = Date.now() + timeoutSecs * 1e3;
+        const remindMs = (loadConfig().remindSecs ?? 900) * 1e3;
+        let evs = attentionNow(true, remindMs);
+        if (evs.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;
+          }
+        }
+        if (evs.length === 0) break;
+        const lines = evs.map(
+          (ev) => `- ${ev.entry.verb} ${ev.id}${ev.entry.note ? ` \u2014 ${ev.entry.note}` : ""}`
+        );
+        const reason = [
+          "A lobstah dispatch needs attention:",
+          ...lines,
+          'Check with `lobstah status <id>`; answer a needs-decision with `lobstah send <id> "<answer>"`.',
+          "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 }));
+      } catch {
+      }
+      break;
+    }
+    case "daemon": {
+      const interval = Number(arg(args, "--interval") ?? "5000");
+      await daemon(interval);
+      break;
+    }
+    case "pick": {
+      await runPickup(args[0] === "once" ? "once" : "daemon");
+      break;
+    }
+    case "init": {
+      if (!fs16.existsSync(configPath())) {
+        fs16.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]
+default = "claude"
+
+[limits]
+maxConcurrent      = 2
+choreConcurrent    = 1
+wedgeThresholdSecs = 600
+maxRestartAttempts = 2
+wallClockSecs      = 3600
+`
+        );
+      }
+      console.log(
+        toonKV({
+          home: path12.dirname(configPath()),
+          config: configPath(),
+          reference: "docs/configuration.md",
+          initialized: true
+        })
+      );
+      break;
+    }
+    case void 0:
+    case "--help":
+    case "help":
+      console.log(HELP);
+      break;
+    default:
+      throw new Error(`unknown command "${cmd}" \u2014 run lobstah help`);
+  }
+}
+mainCli().catch((err) => {
+  console.error(`error: ${err instanceof Error ? err.message : String(err)}`);
+  process.exit(1);
+});
+/*! Bundled license information:
+
+smol-toml/dist/date.js:
+smol-toml/dist/error.js:
+smol-toml/dist/util.js:
+smol-toml/dist/primitive.js:
+smol-toml/dist/extract.js:
+smol-toml/dist/struct.js:
+smol-toml/dist/parse.js:
+smol-toml/dist/stringify.js:
+smol-toml/dist/index.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+*/