lobstah 0.3.2 → 0.5.5

package/dist/runner.js

@@ -1,6 +1,6 @@
 // packages/runner/src/index.ts
-import * as fs9 from "node:fs";
-import * as path7 from "node:path";
+import * as fs10 from "node:fs";
+import * as path8 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // packages/core/dist/types.js
@@ -36,19 +36,23 @@ function evidencePath(id, lane) {
   return path.join(laneDirs(lane).state, `${id}.evidence`);
 }
 
+// packages/core/dist/attachments.js
+function attachmentBlock(attachments) {
+  if (attachments.length === 0)
+    return "";
+  return [
+    "--- ATTACHMENTS ---",
+    ...attachments.map((a) => `${a.name} (${a.type}, ${a.bytes} bytes) at ${a.path}`),
+    "Images and PDFs can be read directly with your file tools."
+  ].join("\n");
+}
+
 // packages/core/dist/queue.js
-import * as fs from "node:fs";
+import * as fs2 from "node:fs";
 import * as path2 from "node:path";
-function complete(id, lane) {
-  const dirs = laneDirs(lane);
-  fs.renameSync(path2.join(dirs.active, id), path2.join(dirs.done, id));
-}
-function cancelRequested(id, lane) {
-  return fs.existsSync(path2.join(laneDirs(lane).active, id, "cancel"));
-}
 
 // packages/core/dist/status.js
-import * as fs2 from "node:fs";
+import * as fs from "node:fs";
 function isVerb(v) {
   return VERBS.includes(v);
 }
@@ -57,15 +61,15 @@ function appendStatus(id, lane, verb, note) {
     throw new Error(`invalid status verb "${verb}" \u2014 must be one of: ${VERBS.join(", ")}`);
   }
   const entry = { at: (/* @__PURE__ */ new Date()).toISOString(), verb, ...note ? { note } : {} };
-  fs2.appendFileSync(statusPath(id, lane), `${JSON.stringify(entry)}
+  fs.appendFileSync(statusPath(id, lane), `${JSON.stringify(entry)}
 `);
   return entry;
 }
 function readStatusLog(id, lane) {
   const file = statusPath(id, lane);
-  if (!fs2.existsSync(file))
+  if (!fs.existsSync(file))
     return [];
-  return fs2.readFileSync(file, "utf8").split("\n").filter(Boolean).flatMap((line) => {
+  return fs.readFileSync(file, "utf8").split("\n").filter(Boolean).flatMap((line) => {
     try {
       const parsed = JSON.parse(line);
       return isVerb(parsed.verb) ? [parsed] : [];
@@ -75,12 +79,30 @@ function readStatusLog(id, lane) {
   });
 }
 
+// packages/core/dist/queue.js
+function complete(id, lane) {
+  const dirs = laneDirs(lane);
+  fs2.renameSync(path2.join(dirs.active, id), path2.join(dirs.done, id));
+}
+function cancelRequested(id, lane) {
+  return fs2.existsSync(path2.join(laneDirs(lane).active, id, "cancel"));
+}
+
 // packages/core/dist/events.js
 import * as fs3 from "node:fs";
 function appendEvent(id, lane, ev) {
   fs3.appendFileSync(eventsPath(id, lane), `${JSON.stringify(ev)}
 `);
 }
+function touchEvents(id, lane, at = /* @__PURE__ */ new Date()) {
+  const file = eventsPath(id, lane);
+  try {
+    fs3.utimesSync(file, at, at);
+  } catch {
+    fs3.appendFileSync(file, "");
+    fs3.utimesSync(file, at, at);
+  }
+}
 
 // packages/core/dist/evidence.js
 import * as fs4 from "node:fs";
@@ -101,6 +123,7 @@ function mergeEvidence(id, lane, patch) {
 // packages/core/dist/inbox.js
 import * as fs5 from "node:fs";
 import * as path3 from "node:path";
+var metaName = (file) => file.replace(/\.msg$/, ".meta.json");
 function inboxDir(id, lane) {
   return path3.join(laneDirs(lane).inbox, id);
 }
@@ -114,6 +137,10 @@ function acknowledge(id, lane, file) {
   const dir = inboxDir(id, lane);
   fs5.mkdirSync(path3.join(dir, "handled"), { recursive: true });
   fs5.renameSync(path3.join(dir, file), path3.join(dir, "handled", file));
+  try {
+    fs5.renameSync(path3.join(dir, metaName(file)), path3.join(dir, "handled", metaName(file)));
+  } catch {
+  }
 }
 
 // packages/core/dist/config.js
@@ -767,17 +794,37 @@ function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
 }
 
 // packages/core/dist/config.js
+var ATTENTION_KINDS = ["question", "landed", "pr:draft", "pr:review", "pr:checks", "pr:ready"];
+var DEFAULT_ATTENTION_KINDS = ["question", "pr:draft", "pr:review", "pr:checks", "pr:ready"];
+function parseAttentionKinds(raw) {
+  if (raw === void 0)
+    return [...DEFAULT_ATTENTION_KINDS];
+  if (!Array.isArray(raw)) {
+    throw new Error(`attentionKinds must be an array of kinds (${ATTENTION_KINDS.join(", ")}) in ${configPath()}`);
+  }
+  for (const k of raw) {
+    if (!ATTENTION_KINDS.includes(k)) {
+      throw new Error(`attentionKinds: unknown kind "${String(k)}" in ${configPath()} \u2014 valid kinds: ${ATTENTION_KINDS.join(", ")}`);
+    }
+  }
+  return [...new Set(raw)];
+}
 var DEFAULT_SOAK = {
   deferSecs: 90,
   ttlSecs: 1800
 };
+var DEFAULT_HELM = {
+  ttlSecs: 1800,
+  reportSecs: 900
+};
 var DEFAULT_LIMITS = {
   maxConcurrent: 2,
   choreConcurrent: 1,
   wedgeThresholdSecs: 600,
   maxRestartAttempts: 2,
   wallClockSecs: 3600,
-  choreRetentionDays: 7
+  choreRetentionDays: 7,
+  attachmentMaxBytes: 25 * 1024 * 1024
 };
 function configPath() {
   return path4.join(lobstahHome(), "config.toml");
@@ -801,14 +848,22 @@ function loadConfig() {
       pickup: r.pickup === void 0 ? void 0 : Boolean(r.pickup)
     };
   }
+  const groundsRaw = raw.grounds ?? {};
+  const grounds = {};
+  for (const [key, g] of Object.entries(groundsRaw)) {
+    grounds[key] = { repos: Array.isArray(g.repos) ? g.repos.map(String) : [] };
+  }
   return {
     repos,
     harness: raw.harness ?? {},
     limits: { ...DEFAULT_LIMITS, ...raw.limits ?? {} },
     soak: { ...DEFAULT_SOAK, ...raw.soak ?? {} },
+    helm: { ...DEFAULT_HELM, ...raw.helm ?? {} },
+    grounds,
     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
+    remindSecs: raw.remindSecs !== void 0 ? Number(raw.remindSecs) : void 0,
+    attentionKinds: parseAttentionKinds(raw.attentionKinds)
   };
 }
 function resolveDispatch(d, cfg) {
@@ -830,6 +885,58 @@ function resolveDispatch(d, cfg) {
   };
 }
 
+// packages/core/dist/harness.js
+import * as fs7 from "node:fs";
+import * as path5 from "node:path";
+import { createRequire } from "node:module";
+function resolveOnPath(bin, pathVar = process.env.PATH) {
+  if (!pathVar)
+    return void 0;
+  const names = process.platform === "win32" ? [bin, `${bin}.exe`, `${bin}.cmd`, `${bin}.bat`] : [bin];
+  for (const dir of pathVar.split(path5.delimiter)) {
+    if (!dir)
+      continue;
+    for (const name of names) {
+      const candidate = path5.join(dir, name);
+      try {
+        fs7.accessSync(candidate, fs7.constants.X_OK);
+        if (fs7.statSync(candidate).isFile())
+          return candidate;
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function onPath(bin, pathVar = process.env.PATH) {
+  return resolveOnPath(bin, pathVar) !== void 0;
+}
+function codexInvocation(argv) {
+  if (onPath("codex"))
+    return { file: "codex", argv };
+  const require_ = createRequire(import.meta.url);
+  try {
+    const cli = require_.resolve("@openai/codex/bin/codex.js");
+    return { file: process.execPath, argv: [cli, ...argv] };
+  } catch {
+  }
+  for (const dir of require_.resolve.paths("@openai/codex") ?? []) {
+    const cli = path5.join(dir, "@openai", "codex", "bin", "codex.js");
+    if (fs7.existsSync(cli))
+      return { file: process.execPath, argv: [cli, ...argv] };
+  }
+  return void 0;
+}
+
+// packages/core/dist/compiled.js
+var COMPILED_BINARY = (() => {
+  const bun = globalThis.Bun;
+  return bun !== void 0 && String(bun.main ?? "").includes("$bunfs");
+})();
+
+// packages/adapters/dist/claude.js
+import { spawn } from "node:child_process";
+
 // packages/adapters/dist/types.js
 var AsyncQueue = class {
   buffer = [];
@@ -908,29 +1015,154 @@ function flagsToExtraArgs(flags) {
   }
   return extra;
 }
+function pumpClaudeMessage(msg, push, onSession) {
+  const at = now();
+  if (msg.type === "system" && msg.subtype === "init") {
+    if (msg.session_id)
+      onSession(msg.session_id);
+    push({ at, type: "session", data: { sessionId: msg.session_id } });
+  } else if (msg.type === "assistant") {
+    for (const block of msg.message?.content ?? []) {
+      if (block.type === "tool_use") {
+        push({ at, type: "tool-start", data: { name: block.name } });
+      } else if (block.type === "text" && block.text) {
+        push({ at, type: "text", data: { text: String(block.text).slice(0, 2e3) } });
+      }
+    }
+  } else if (msg.type === "user") {
+    const content = msg.message?.content;
+    if (Array.isArray(content)) {
+      for (const block of content) {
+        if (block.type === "tool_result")
+          push({ at, type: "tool-end", data: {} });
+      }
+    }
+  } else if (msg.type === "result") {
+    push({ at, type: "turn-end", data: { subtype: msg.subtype, costUsd: msg.total_cost_usd } });
+  }
+}
+var userMessage = (content) => ({
+  type: "user",
+  message: { role: "user", content },
+  parent_tool_use_id: null,
+  session_id: ""
+});
+function claudeCliArgs(opts) {
+  const args = [
+    "-p",
+    "--output-format",
+    "stream-json",
+    "--input-format",
+    "stream-json",
+    "--verbose",
+    "--permission-mode",
+    "bypassPermissions"
+  ];
+  if (opts.model)
+    args.push("--model", opts.model);
+  if (opts.limits.maxTurns)
+    args.push("--max-turns", String(opts.limits.maxTurns));
+  if (opts.resumeSession)
+    args.push("--resume", opts.resumeSession, "--fork-session");
+  args.push(...opts.flags);
+  return args;
+}
+function startClaudeCli(invocation, opts) {
+  const child = spawn(invocation.file, [...invocation.argvPrefix, ...claudeCliArgs(opts)], {
+    cwd: opts.cwd,
+    env: { ...process.env, ...opts.env },
+    stdio: ["pipe", "pipe", "pipe"],
+    shell: process.platform === "win32"
+    // .cmd shims need a shell to exec
+  });
+  const events = new AsyncQueue();
+  const input = new InputGate();
+  let sessionId;
+  let stderrTail = "";
+  child.stdin.on("error", () => {
+  });
+  child.stderr.on("data", (d) => {
+    stderrTail = (stderrTail + d.toString()).slice(-2e3);
+  });
+  child.stdin.write(`${JSON.stringify(userMessage(opts.prompt))}
+`);
+  void (async () => {
+    while (true) {
+      const text = await input.next();
+      if (text === void 0)
+        break;
+      child.stdin.write(`${JSON.stringify(userMessage(text))}
+`);
+    }
+    child.stdin.end();
+  })();
+  let buf = "";
+  child.stdout.on("data", (d) => {
+    buf += d.toString();
+    let i;
+    while ((i = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, i).trim();
+      buf = buf.slice(i + 1);
+      if (!line)
+        continue;
+      try {
+        pumpClaudeMessage(JSON.parse(line), (e) => events.push(e), (id) => sessionId = id);
+      } catch {
+      }
+    }
+  });
+  const done = new Promise((resolve2) => {
+    child.on("error", (err) => {
+      events.push({ at: now(), type: "error", data: { message: err.message } });
+      events.close();
+      resolve2({ sessionId, error: err.message });
+    });
+    child.on("exit", (code) => {
+      events.close();
+      if (code === 0)
+        resolve2({ sessionId });
+      else {
+        const detail = stderrTail.trim().split("\n").at(-1);
+        const error = `claude exited ${code}${detail ? ` \u2014 ${detail}` : ""}`;
+        resolve2({ sessionId, error });
+      }
+    });
+  });
+  return {
+    events,
+    send: (text) => input.send(text),
+    end: () => input.end(),
+    done,
+    kill: () => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      input.end();
+    }
+  };
+}
 function createClaudeAdapter() {
   return {
     name: "claude",
     async start(opts) {
-      const sdk = await import("@anthropic-ai/claude-agent-sdk");
+      let sdk;
+      try {
+        sdk = await import("@anthropic-ai/claude-agent-sdk");
+      } catch (err) {
+        if (onPath("claude"))
+          return startClaudeCli({ file: "claude", argvPrefix: [] }, opts);
+        const detail = err instanceof Error ? err.message : String(err);
+        throw new Error(`claude adapter: agent SDK unavailable (${detail}) and no \`claude\` CLI on PATH`);
+      }
       const input = new InputGate();
       async function* userMessages() {
-        yield {
-          type: "user",
-          message: { role: "user", content: opts.prompt },
-          parent_tool_use_id: null,
-          session_id: ""
-        };
+        yield userMessage(opts.prompt);
         while (true) {
           const text = await input.next();
           if (text === void 0)
             return;
-          yield {
-            type: "user",
-            message: { role: "user", content: text },
-            parent_tool_use_id: null,
-            session_id: ""
-          };
+          yield userMessage(text);
         }
       }
       const q = sdk.query({
@@ -951,29 +1183,7 @@ function createClaudeAdapter() {
       const done = (async () => {
         try {
           for await (const msg of q) {
-            const at = now();
-            if (msg.type === "system" && msg.subtype === "init") {
-              sessionId = msg.session_id;
-              events.push({ at, type: "session", data: { sessionId } });
-            } else if (msg.type === "assistant") {
-              for (const block of msg.message?.content ?? []) {
-                if (block.type === "tool_use") {
-                  events.push({ at, type: "tool-start", data: { name: block.name } });
-                } else if (block.type === "text" && block.text) {
-                  events.push({ at, type: "text", data: { text: String(block.text).slice(0, 2e3) } });
-                }
-              }
-            } else if (msg.type === "user") {
-              const content = msg.message?.content;
-              if (Array.isArray(content)) {
-                for (const block of content) {
-                  if (block.type === "tool_result")
-                    events.push({ at, type: "tool-end", data: {} });
-                }
-              }
-            } else if (msg.type === "result") {
-              events.push({ at, type: "turn-end", data: { subtype: msg.subtype, costUsd: msg.total_cost_usd } });
-            }
+            pumpClaudeMessage(msg, (e) => events.push(e), (id) => sessionId = id);
           }
           return { sessionId };
         } catch (err) {
@@ -1002,32 +1212,159 @@ function createClaudeAdapter() {
 }
 
 // packages/adapters/dist/codex.js
-import * as fs7 from "node:fs";
+import * as fs8 from "node:fs";
 import * as os3 from "node:os";
-import * as path5 from "node:path";
+import * as path6 from "node:path";
+import { spawn as spawn2 } from "node:child_process";
 function isolatedCodexHome() {
-  const dir = path5.join(lobstahHome(), "codex-home");
-  fs7.mkdirSync(dir, { recursive: true });
-  const auth = path5.join(dir, "auth.json");
-  const realAuth = path5.join(os3.homedir(), ".codex", "auth.json");
-  if (!fs7.existsSync(auth) && fs7.existsSync(realAuth)) {
+  const dir = path6.join(lobstahHome(), "codex-home");
+  fs8.mkdirSync(dir, { recursive: true });
+  const auth = path6.join(dir, "auth.json");
+  const realAuth = path6.join(os3.homedir(), ".codex", "auth.json");
+  if (!fs8.existsSync(auth) && fs8.existsSync(realAuth)) {
     try {
-      fs7.symlinkSync(realAuth, auth);
+      fs8.symlinkSync(realAuth, auth);
     } catch {
-      fs7.copyFileSync(realAuth, auth);
+      fs8.copyFileSync(realAuth, auth);
     }
   }
-  const cfg = path5.join(dir, "config.toml");
-  if (!fs7.existsSync(cfg)) {
-    fs7.writeFileSync(cfg, "# lobstah-managed: auth inherited from ~/.codex, interactive config not\n");
+  const cfg = path6.join(dir, "config.toml");
+  if (!fs8.existsSync(cfg)) {
+    fs8.writeFileSync(cfg, "# lobstah-managed: auth inherited from ~/.codex, interactive config not\n");
   }
   return dir;
 }
+function pumpCodexEvent(ev, push, onSession) {
+  const at = now();
+  if (ev.type === "thread.started") {
+    if (ev.thread_id)
+      onSession(ev.thread_id);
+    push({ at, type: "session", data: { sessionId: ev.thread_id } });
+  } else if (ev.type === "turn.started") {
+    push({ at, type: "turn-start", data: {} });
+  } else if (ev.type === "item.started") {
+    push({ at, type: "tool-start", data: { name: ev.item?.type } });
+  } else if (ev.type === "item.completed") {
+    if (ev.item?.type === "agent_message" && ev.item?.text) {
+      push({ at, type: "text", data: { text: String(ev.item.text).slice(0, 2e3) } });
+    } else {
+      push({ at, type: "tool-end", data: { name: ev.item?.type } });
+    }
+  } else if (ev.type === "turn.failed") {
+    const message = ev.error?.message ?? "turn failed";
+    push({ at, type: "error", data: { message } });
+    return message;
+  }
+  return void 0;
+}
+function codexExecArgs(opts, prompt, resumeThread) {
+  const args = ["exec"];
+  if (resumeThread)
+    args.push("resume", resumeThread);
+  args.push("--json", "--skip-git-repo-check", "--sandbox", "workspace-write", "--cd", opts.cwd);
+  if (opts.model)
+    args.push("-m", opts.model);
+  if (opts.effort)
+    args.push("-c", `model_reasoning_effort=${JSON.stringify(opts.effort)}`);
+  args.push(prompt);
+  return args;
+}
+function startCodexCli(invoke, opts) {
+  const input = new InputGate();
+  const events = new AsyncQueue();
+  let sessionId;
+  let current;
+  let killed = false;
+  function runTurn(prompt, resumeThread) {
+    return new Promise((resolve2) => {
+      const inv = invoke(codexExecArgs(opts, prompt, resumeThread));
+      const child = spawn2(inv.file, inv.argv, {
+        cwd: opts.cwd,
+        env: { ...process.env, ...opts.env, CODEX_HOME: isolatedCodexHome() },
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: process.platform === "win32" && inv.file !== process.execPath
+      });
+      current = child;
+      let turnError;
+      let stderrTail = "";
+      child.stderr?.on("data", (d) => {
+        stderrTail = (stderrTail + d.toString()).slice(-2e3);
+      });
+      let buf = "";
+      child.stdout?.on("data", (d) => {
+        buf += d.toString();
+        let i;
+        while ((i = buf.indexOf("\n")) >= 0) {
+          const line = buf.slice(0, i).trim();
+          buf = buf.slice(i + 1);
+          if (!line)
+            continue;
+          try {
+            const failed = pumpCodexEvent(JSON.parse(line), (e) => events.push(e), (id) => sessionId = id);
+            if (failed)
+              turnError = failed;
+          } catch {
+          }
+        }
+      });
+      child.on("error", (err) => resolve2(err.message));
+      child.on("exit", (code) => {
+        if (turnError)
+          return resolve2(turnError);
+        if (code === 0 || killed)
+          return resolve2(void 0);
+        const detail = stderrTail.trim().split("\n").at(-1);
+        resolve2(`codex exited ${code}${detail ? ` \u2014 ${detail}` : ""}`);
+      });
+    });
+  }
+  const done = (async () => {
+    try {
+      let next = opts.prompt;
+      let thread = opts.resumeSession;
+      while (next !== void 0 && !killed) {
+        const error = await runTurn(next, thread);
+        thread = sessionId ?? thread;
+        if (error) {
+          events.push({ at: now(), type: "error", data: { message: error } });
+          return { sessionId, error };
+        }
+        events.push({ at: now(), type: "turn-end", data: {} });
+        next = await input.next();
+      }
+      return { sessionId };
+    } finally {
+      events.close();
+    }
+  })();
+  return {
+    events,
+    send: (text) => input.send(text),
+    end: () => input.end(),
+    done,
+    kill: () => {
+      killed = true;
+      try {
+        current?.kill("SIGKILL");
+      } catch {
+      }
+      input.end();
+    }
+  };
+}
 function createCodexAdapter() {
   return {
     name: "codex",
     async start(opts) {
-      const mod = await import("@openai/codex-sdk");
+      let mod;
+      try {
+        mod = await import("@openai/codex-sdk");
+      } catch (err) {
+        if (codexInvocation([]))
+          return startCodexCli((argv) => codexInvocation(argv), opts);
+        const detail = err instanceof Error ? err.message : String(err);
+        throw new Error(`codex adapter: SDK unavailable (${detail}) and no codex CLI found (PATH or vendored)`);
+      }
       const codex = new mod.Codex({
         env: { ...process.env, ...opts.env, CODEX_HOME: isolatedCodexHome() }
       });
@@ -1050,24 +1387,9 @@ function createCodexAdapter() {
           while (next !== void 0) {
             const streamed = await thread.runStreamed(next);
             for await (const ev of streamed.events) {
-              const at = now();
-              if (ev.type === "thread.started") {
-                sessionId = ev.thread_id;
-                events.push({ at, type: "session", data: { sessionId } });
-              } else if (ev.type === "turn.started") {
-                events.push({ at, type: "turn-start", data: {} });
-              } else if (ev.type === "item.started") {
-                events.push({ at, type: "tool-start", data: { name: ev.item?.type } });
-              } else if (ev.type === "item.completed") {
-                if (ev.item?.type === "agent_message" && ev.item?.text) {
-                  events.push({ at, type: "text", data: { text: String(ev.item.text).slice(0, 2e3) } });
-                } else {
-                  events.push({ at, type: "tool-end", data: { name: ev.item?.type } });
-                }
-              } else if (ev.type === "turn.failed") {
-                lastTurnError = ev.error?.message ?? "turn failed";
-                events.push({ at, type: "error", data: { message: lastTurnError } });
-              }
+              const failed = pumpCodexEvent(ev, (e) => events.push(e), (id) => sessionId = id);
+              if (failed)
+                lastTurnError = failed;
             }
             events.push({ at: now(), type: "turn-end", data: {} });
             next = await input.next();
@@ -1105,14 +1427,14 @@ function loadAdapter(name) {
 }
 
 // packages/worktree/dist/index.js
-import * as fs8 from "node:fs";
-import * as path6 from "node:path";
+import * as fs9 from "node:fs";
+import * as path7 from "node:path";
 import { exec, execFile } from "node:child_process";
 import { promisify } from "node:util";
 var run = promisify(execFile);
 var shell = promisify(exec);
 function worktreePath(id) {
-  return path6.join(lobstahHome(), "worktrees", id);
+  return path7.join(lobstahHome(), "worktrees", id);
 }
 async function git(cwd, ...args) {
   const { stdout } = await run("git", args, { cwd, env: process.env });
@@ -1120,10 +1442,10 @@ async function git(cwd, ...args) {
 }
 async function allocate(repo, id) {
   const dir = worktreePath(id);
-  if (fs8.existsSync(dir)) {
+  if (fs9.existsSync(dir)) {
     throw new Error(`worktree for ${id} already exists at ${dir} \u2014 never allocate a second`);
   }
-  if (!fs8.existsSync(repo.path)) {
+  if (!fs9.existsSync(repo.path)) {
     if (!repo.origin)
       throw new Error(`repo path ${repo.path} missing and no origin configured`);
     await run("git", ["clone", repo.origin, repo.path], { env: process.env });
@@ -1154,10 +1476,77 @@ function buildPrompt(brief, opts) {
     `--- BRIEF ---`,
     brief
   ];
+  if (opts.attachments?.length) parts.push(attachmentBlock(opts.attachments));
   if (opts.nudge) parts.push(`--- SUPERVISOR NOTE ---`, opts.nudge);
   return parts.join("\n\n");
 }
 
+// packages/runner/src/drive.ts
+var WAITING_VERBS = ["needs-decision", "blocked", "paused"];
+var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+function deliver(run2, id, lane) {
+  const msgs = unhandled(id, lane);
+  for (const m of msgs) {
+    run2.send(m.text);
+    acknowledge(id, lane, m.file);
+  }
+  return msgs.length;
+}
+async function drive(run2, opts) {
+  const { id, lane, pollMs = 3e3, stopped = () => false } = opts;
+  let cancelled = false;
+  let finished = false;
+  void run2.done.then(() => finished = true);
+  const cancel = () => {
+    cancelled = true;
+    run2.kill();
+  };
+  const answered = (verb) => {
+    appendStatus(id, lane, "working", "operator message delivered");
+    appendEvent(id, lane, { at: (/* @__PURE__ */ new Date()).toISOString(), type: "runner", data: { resumed: verb } });
+  };
+  const awaitAnswer = async (verb) => {
+    appendEvent(id, lane, { at: (/* @__PURE__ */ new Date()).toISOString(), type: "runner", data: { waiting: verb } });
+    while (true) {
+      if (stopped() || finished) return;
+      if (cancelRequested(id, lane)) return cancel();
+      if (deliver(run2, id, lane) > 0) return answered(verb);
+      touchEvents(id, lane);
+      await sleep(pollMs);
+    }
+  };
+  for await (const ev of run2.events) {
+    appendEvent(id, lane, ev);
+    if (ev.type === "session" && ev.data?.sessionId) {
+      mergeEvidence(id, lane, { sessionId: String(ev.data.sessionId) });
+    }
+    if (ev.type !== "turn-end" || cancelled || stopped()) continue;
+    if (cancelRequested(id, lane)) {
+      cancel();
+      continue;
+    }
+    const lastVerb = readStatusLog(id, lane).at(-1)?.verb;
+    const waiting = lastVerb !== void 0 && WAITING_VERBS.includes(lastVerb);
+    if (deliver(run2, id, lane) > 0) {
+      if (waiting) answered(lastVerb);
+      continue;
+    }
+    if (waiting) {
+      await awaitAnswer(lastVerb);
+      continue;
+    }
+    run2.end();
+  }
+  return { cancelled };
+}
+function settle(id, lane, r) {
+  const lastVerb = readStatusLog(id, lane).at(-1)?.verb;
+  if (r.cancelled) appendStatus(id, lane, "failed", "cancelled by operator");
+  else if (r.wallClockHit) appendStatus(id, lane, "failed", "wall-clock limit exceeded");
+  else if (r.error) appendStatus(id, lane, "failed", r.error.slice(0, 500));
+  else if (!lastVerb || !TERMINAL_VERBS.includes(lastVerb)) appendStatus(id, lane, "done");
+}
+
 // packages/runner/src/index.ts
 function followUpSession(followUp) {
   for (const lane of ["work", "chore"]) {
@@ -1167,40 +1556,40 @@ function followUpSession(followUp) {
   return void 0;
 }
 async function main(activeDir, lane) {
-  const id = path7.basename(activeDir);
+  const id = path8.basename(activeDir);
   const status = (verb, note) => appendStatus(id, lane, verb, note);
   const cfg = loadConfig();
-  const descriptor = JSON.parse(fs9.readFileSync(path7.join(activeDir, "descriptor.json"), "utf8"));
+  const descriptor = JSON.parse(fs10.readFileSync(path8.join(activeDir, "descriptor.json"), "utf8"));
   const resolved = resolveDispatch(descriptor, cfg);
   const repo = cfg.repos[descriptor.repo];
-  const briefFile = path7.join(activeDir, "brief.md");
-  if (!fs9.existsSync(briefFile)) fs9.writeFileSync(briefFile, descriptor.brief);
-  const brief = fs9.readFileSync(briefFile, "utf8");
+  const briefFile = path8.join(activeDir, "brief.md");
+  if (!fs10.existsSync(briefFile)) fs10.writeFileSync(briefFile, descriptor.brief);
+  const brief = fs10.readFileSync(briefFile, "utf8");
   const attempts = Number(process.env.LOBSTAH_ATTEMPTS ?? "1");
   const runnerInfo = {
     pid: process.pid,
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     attempts
   };
-  fs9.writeFileSync(path7.join(activeDir, "runner.json"), JSON.stringify(runnerInfo, null, 2));
+  fs10.writeFileSync(path8.join(activeDir, "runner.json"), JSON.stringify(runnerInfo, null, 2));
   status("working", attempts > 1 ? `attempt ${attempts}` : void 0);
   appendEvent(id, lane, { at: (/* @__PURE__ */ new Date()).toISOString(), type: "runner", data: { pid: process.pid, attempts } });
-  const wtFile = path7.join(activeDir, "worktree.json");
+  const wtFile = path8.join(activeDir, "worktree.json");
   let cwd;
-  if (fs9.existsSync(wtFile)) {
-    cwd = JSON.parse(fs9.readFileSync(wtFile, "utf8")).path;
-    if (!fs9.existsSync(cwd)) throw new Error(`recorded worktree ${cwd} is gone`);
-  } else if (fs9.existsSync(worktreePath(id))) {
+  if (fs10.existsSync(wtFile)) {
+    cwd = JSON.parse(fs10.readFileSync(wtFile, "utf8")).path;
+    if (!fs10.existsSync(cwd)) throw new Error(`recorded worktree ${cwd} is gone`);
+  } else if (fs10.existsSync(worktreePath(id))) {
     throw new Error(`unrecorded worktree already exists for ${id} \u2014 refusing to proceed`);
   } else {
     cwd = await allocate(repo, id);
-    fs9.writeFileSync(wtFile, JSON.stringify({ path: cwd }, null, 2));
+    fs10.writeFileSync(wtFile, JSON.stringify({ path: cwd }, null, 2));
   }
   const resumeSession = process.env.LOBSTAH_RESUME ?? (descriptor.followUp ? followUpSession(descriptor.followUp) : void 0);
   const adapter = loadAdapter(resolved.harness);
-  const prompt = buildPrompt(brief, { id, nudge: process.env.LOBSTAH_NUDGE });
-  const binDir = path7.resolve(path7.dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "bin");
-  const workerPath = fs9.existsSync(path7.join(binDir, "lobstah")) ? `${binDir}${path7.delimiter}${process.env.PATH ?? ""}` : void 0;
+  const prompt = buildPrompt(brief, { id, nudge: process.env.LOBSTAH_NUDGE, attachments: descriptor.attachments });
+  const binDir = path8.resolve(path8.dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "bin");
+  const workerPath = fs10.existsSync(path8.join(binDir, "lobstah")) ? `${binDir}${path8.delimiter}${process.env.PATH ?? ""}` : void 0;
   const run2 = await adapter.start({
     id,
     cwd,
@@ -1221,29 +1610,7 @@ async function main(activeDir, lane) {
     wallClockHit = true;
     run2.kill();
   }, resolved.limits.wallClockSecs * 1e3) : void 0;
-  let cancelled = false;
-  for await (const ev of run2.events) {
-    appendEvent(id, lane, ev);
-    if (ev.type === "session" && ev.data?.sessionId) {
-      mergeEvidence(id, lane, { sessionId: String(ev.data.sessionId) });
-    }
-    if (ev.type === "turn-end") {
-      if (cancelRequested(id, lane)) {
-        cancelled = true;
-        run2.kill();
-        continue;
-      }
-      const msgs = unhandled(id, lane);
-      if (msgs.length > 0) {
-        for (const m of msgs) {
-          run2.send(m.text);
-          acknowledge(id, lane, m.file);
-        }
-      } else {
-        run2.end();
-      }
-    }
-  }
+  const { cancelled } = await drive(run2, { id, lane, stopped: () => wallClockHit });
   const result = await run2.done;
   if (wallTimer) clearTimeout(wallTimer);
   try {
@@ -1256,33 +1623,26 @@ async function main(activeDir, lane) {
       note: `evidence collection failed: ${err instanceof Error ? err.message : String(err)}`.slice(0, 300)
     });
   }
-  const lastVerb = readStatusLog(id, lane).at(-1)?.verb;
-  if (cancelled) {
-    status("failed", "cancelled by operator");
-  } else if (wallClockHit) {
-    status("failed", "wall-clock limit exceeded");
-  } else if (result.error) {
-    status("failed", result.error.slice(0, 500));
-  } else if (!lastVerb || !TERMINAL_VERBS.includes(lastVerb)) {
-    status("done");
-  }
+  settle(id, lane, { cancelled, wallClockHit, error: result.error });
   complete(id, lane);
 }
-var [activeDirArg, laneArg] = process.argv.slice(2);
-if (activeDirArg) {
-  const lane = laneArg === "chore" ? "chore" : "work";
-  main(activeDirArg, lane).catch((err) => {
-    const id = path7.basename(activeDirArg);
+function runRunner(activeDirArg2, laneArg2) {
+  const lane = laneArg2 === "chore" ? "chore" : "work";
+  main(activeDirArg2, lane).catch((err) => {
+    const id = path8.basename(activeDirArg2);
     try {
       appendStatus(id, lane, "failed", String(err instanceof Error ? err.message : err).slice(0, 500));
-      fs9.renameSync(activeDirArg, path7.join(laneDirs(lane).done, id));
+      fs10.renameSync(activeDirArg2, path8.join(laneDirs(lane).done, id));
     } catch {
     }
     process.exitCode = 1;
   });
 }
+var [activeDirArg, laneArg] = process.argv.slice(2);
+if (activeDirArg && activeDirArg !== "__runner") runRunner(activeDirArg, laneArg);
 export {
-  main
+  main,
+  runRunner
 };
 /*! Bundled license information: