lobstah 0.5.0 → 0.5.7

package/dist/runner.js

@@ -1,7 +1,6 @@
 // packages/runner/src/index.ts
-import * as fs10 from "node:fs";
-import * as path8 from "node:path";
-import { fileURLToPath } from "node:url";
+import * as fs13 from "node:fs";
+import * as path11 from "node:path";
 
 // packages/core/dist/types.js
 var VERBS = ["working", "needs-decision", "blocked", "paused", "done", "failed"];
@@ -26,6 +25,9 @@ function laneDirs(lane) {
     inbox: path.join(root, "inbox")
   };
 }
+function soakingDir() {
+  return path.join(lobstahHome(), "soaking");
+}
 function statusPath(id, lane) {
   return path.join(laneDirs(lane).state, `${id}.status`);
 }
@@ -36,6 +38,17 @@ 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 fs2 from "node:fs";
 import * as path2 from "node:path";
@@ -69,6 +82,20 @@ function readStatusLog(id, lane) {
 }
 
 // packages/core/dist/queue.js
+function storedDescriptor(id, lane) {
+  const dirs = laneDirs(lane);
+  for (const file of [
+    path2.join(dirs.queue, `${id}.json`),
+    path2.join(dirs.active, id, "descriptor.json"),
+    path2.join(dirs.done, id, "descriptor.json")
+  ]) {
+    try {
+      return JSON.parse(fs2.readFileSync(file, "utf8"));
+    } catch {
+    }
+  }
+  return void 0;
+}
 function complete(id, lane) {
   const dirs = laneDirs(lane);
   fs2.renameSync(path2.join(dirs.active, id), path2.join(dirs.done, id));
@@ -83,6 +110,15 @@ 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";
@@ -103,6 +139,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);
 }
@@ -116,6 +153,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
@@ -769,6 +810,21 @@ function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
 }
 
 // packages/core/dist/config.js
+var ATTENTION_KINDS = ["question", "landed", "pr:draft", "pr:review", "pr:checks", "pr:conflict", "pr:ready"];
+var DEFAULT_ATTENTION_KINDS = ["question", "pr:draft", "pr:review", "pr:checks", "pr:conflict", "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
@@ -783,7 +839,8 @@ var DEFAULT_LIMITS = {
   wedgeThresholdSecs: 600,
   maxRestartAttempts: 2,
   wallClockSecs: 3600,
-  choreRetentionDays: 7
+  choreRetentionDays: 7,
+  attachmentMaxBytes: 25 * 1024 * 1024
 };
 function configPath() {
   return path4.join(lobstahHome(), "config.toml");
@@ -821,7 +878,8 @@ function loadConfig() {
     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) {
@@ -886,12 +944,127 @@ function codexInvocation(argv) {
   return void 0;
 }
 
+// packages/core/dist/soak.js
+import * as fs8 from "node:fs";
+import * as path6 from "node:path";
+function regPath(trapId) {
+  return path6.join(soakingDir(), `${trapId}.json`);
+}
+function readTrap(trapId) {
+  try {
+    return JSON.parse(fs8.readFileSync(regPath(trapId), "utf8"));
+  } catch {
+    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/core/dist/resume.js
+import * as fs9 from "node:fs";
+import * as path7 from "node:path";
+import { spawnSync } from "node:child_process";
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-([0-9a-f])[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function harnessFromSessionId(sessionId) {
+  const version = sessionId ? UUID.exec(sessionId)?.[1] : void 0;
+  return version === "7" ? "codex" : version === "4" ? "claude" : void 0;
+}
+function claimOf(id, lane) {
+  const dirs = laneDirs(lane);
+  for (const dir of [dirs.active, dirs.done]) {
+    try {
+      return JSON.parse(fs9.readFileSync(path7.join(dir, id, "claim.json"), "utf8"));
+    } catch {
+    }
+  }
+  return void 0;
+}
+function laneOf(id) {
+  for (const lane of ["work", "chore"]) {
+    if (storedDescriptor(id, lane) || readEvidence(id, lane).sessionId)
+      return lane;
+  }
+  return void 0;
+}
+function resolveSessionHarness(id, cfg, laneHint) {
+  const lane = laneHint ?? laneOf(id);
+  if (!lane)
+    return {};
+  const ev = readEvidence(id, lane);
+  const sessionId = ev.sessionId;
+  const out = (harness, source) => ({
+    sessionId,
+    harness,
+    source,
+    lane
+  });
+  if (ev.harness)
+    return out(ev.harness, "evidence");
+  const claim = claimOf(id, lane);
+  if (claim?.harness)
+    return out(claim.harness, "trap");
+  if (ev.deliveredTo?.startsWith("wt:")) {
+    const reg = readTrap(ev.deliveredTo.slice("wt:".length));
+    if (reg?.harness)
+      return out(reg.harness, "trap");
+  }
+  const byId = harnessFromSessionId(sessionId);
+  if (byId)
+    return out(byId, "session-id");
+  const d = storedDescriptor(id, lane);
+  const repo = d && cfg?.repos[d.repo];
+  const fromDescriptor = d?.harness ?? repo?.harness?.default ?? cfg?.harness.default;
+  if (fromDescriptor)
+    return out(fromDescriptor, "descriptor");
+  return { sessionId, lane };
+}
+var UNRESUMABLE = /no conversation found|no rollout found|(session|thread|conversation)( id)?[^.\n]{0,80}\b(not found|does not exist|unknown|invalid)|(could not|cannot|failed to|unable to) (find|load|resume)[^.\n]{0,40}\b(session|thread|conversation)/i;
+function isUnresumable(error) {
+  return error !== void 0 && UNRESUMABLE.test(error);
+}
+function worktreeProgress(worktree, trunk) {
+  if (!worktree || !fs9.existsSync(worktree))
+    return "No worktree progress recorded.";
+  const git2 = (...a) => spawnSync("git", a, { cwd: worktree, encoding: "utf8" }).stdout?.trim() ?? "";
+  const commits = trunk ? git2("log", "--oneline", `origin/${trunk}..HEAD`) : git2("log", "--oneline", "-15");
+  const status = git2("status", "--short");
+  return `Commits so far:
+${commits || "(none)"}
+
+Uncommitted changes:
+${status || "(clean)"}`;
+}
+function originProgress(originId, lane) {
+  const ev = readEvidence(originId, lane);
+  const last = readStatusLog(originId, lane).at(-1);
+  const lines = [`The earlier dispatch ${originId} left:`];
+  if (ev.branch)
+    lines.push(`- branch: ${ev.branch}`);
+  if (ev.prUrl)
+    lines.push(`- PR: ${ev.prUrl}`);
+  if (last)
+    lines.push(`- last status: ${last.verb}${last.note ? ` \u2014 ${last.note}` : ""}`);
+  if (ev.commits?.length)
+    lines.push("- commits:", ...ev.commits.map((c) => `    ${c}`));
+  if (lines.length === 1)
+    lines.push("- (no recorded branch, PR, or commits)");
+  return lines.join("\n");
+}
+function handoffNote(fromHarness, progress, why) {
+  return `You are taking over this dispatch from a previous agent session (harness: ${fromHarness}). Its conversation is not available${why ? ` (${why})` : ""} \u2014 the state below is the ground truth. Review it, then continue the brief from where it stops.
+
+${progress}`;
+}
+
+// packages/runner/src/run.ts
+import * as fs12 from "node:fs";
+import * as path10 from "node:path";
+import { fileURLToPath } from "node:url";
+
 // packages/adapters/dist/claude.js
 import { spawn } from "node:child_process";
 
@@ -1170,25 +1343,25 @@ function createClaudeAdapter() {
 }
 
 // packages/adapters/dist/codex.js
-import * as fs8 from "node:fs";
+import * as fs10 from "node:fs";
 import * as os3 from "node:os";
-import * as path6 from "node:path";
+import * as path8 from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 function isolatedCodexHome() {
-  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)) {
+  const dir = path8.join(lobstahHome(), "codex-home");
+  fs10.mkdirSync(dir, { recursive: true });
+  const auth = path8.join(dir, "auth.json");
+  const realAuth = path8.join(os3.homedir(), ".codex", "auth.json");
+  if (!fs10.existsSync(auth) && fs10.existsSync(realAuth)) {
     try {
-      fs8.symlinkSync(realAuth, auth);
+      fs10.symlinkSync(realAuth, auth);
     } catch {
-      fs8.copyFileSync(realAuth, auth);
+      fs10.copyFileSync(realAuth, auth);
     }
   }
-  const cfg = path6.join(dir, "config.toml");
-  if (!fs8.existsSync(cfg)) {
-    fs8.writeFileSync(cfg, "# lobstah-managed: auth inherited from ~/.codex, interactive config not\n");
+  const cfg = path8.join(dir, "config.toml");
+  if (!fs10.existsSync(cfg)) {
+    fs10.writeFileSync(cfg, "# lobstah-managed: auth inherited from ~/.codex, interactive config not\n");
   }
   return dir;
 }
@@ -1385,14 +1558,14 @@ function loadAdapter(name) {
 }
 
 // packages/worktree/dist/index.js
-import * as fs9 from "node:fs";
-import * as path7 from "node:path";
+import * as fs11 from "node:fs";
+import * as path9 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 path7.join(lobstahHome(), "worktrees", id);
+  return path9.join(lobstahHome(), "worktrees", id);
 }
 async function git(cwd, ...args) {
   const { stdout } = await run("git", args, { cwd, env: process.env });
@@ -1400,10 +1573,10 @@ async function git(cwd, ...args) {
 }
 async function allocate(repo, id) {
   const dir = worktreePath(id);
-  if (fs9.existsSync(dir)) {
+  if (fs11.existsSync(dir)) {
     throw new Error(`worktree for ${id} already exists at ${dir} \u2014 never allocate a second`);
   }
-  if (!fs9.existsSync(repo.path)) {
+  if (!fs11.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 });
@@ -1434,100 +1607,247 @@ 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/index.ts
-function followUpSession(followUp) {
-  for (const lane of ["work", "chore"]) {
-    const ev = readEvidence(followUp, lane);
-    if (ev.sessionId) return ev.sessionId;
+// 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 void 0;
+  return msgs.length;
+}
+async function drive(run2, opts) {
+  const { id, lane, pollMs = 3e3, stopped = () => false } = opts;
+  let cancelled = false;
+  let activity = 0;
+  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 === "tool-start" || ev.type === "text") activity++;
+    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, activity };
+}
+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/plan.ts
+var short = (s) => s.slice(0, 8);
+function askedHarness(id, lane, cfg) {
+  const d = storedDescriptor(id, lane);
+  return d?.harness ?? (d ? cfg.repos[d.repo]?.harness?.default : void 0) ?? cfg.harness.default ?? "claude";
+}
+function planStart(input) {
+  const { id, lane, descriptor, cfg, resolvedHarness, envResume } = input;
+  if (envResume) {
+    const own = resolveSessionHarness(id, cfg, lane);
+    const harness = (own.sessionId === envResume ? own.harness : harnessFromSessionId(envResume)) ?? resolvedHarness;
+    return {
+      harness,
+      resume: { sessionId: envResume, own: true },
+      note: harness !== resolvedHarness ? `resuming own ${harness} session ${short(envResume)}` : void 0
+    };
+  }
+  const prior = readEvidence(id, lane).sessionId;
+  if (prior) {
+    const from = resolveSessionHarness(id, cfg, lane).harness;
+    return {
+      harness: resolvedHarness,
+      cold: { why: `session ${short(prior)} is not resumed on a respawn`, fromHarness: from },
+      note: `respawn: starting cold on ${resolvedHarness}${from ? ` (previous session: ${from})` : ""}`
+    };
+  }
+  if (!descriptor.followUp) return { harness: resolvedHarness };
+  const originId = descriptor.followUp;
+  const origin = resolveSessionHarness(originId, cfg);
+  const originLane = origin.lane ?? lane;
+  const originRef = { id: originId, lane: originLane };
+  if (!origin.sessionId) {
+    return {
+      harness: resolvedHarness,
+      cold: { why: `follow-up origin ${short(originId)} has no recorded session`, origin: originRef },
+      note: `follow-up of ${short(originId)}: no session recorded \u2014 starting cold on ${resolvedHarness} with a progress note`
+    };
+  }
+  if (!origin.harness) {
+    return {
+      harness: resolvedHarness,
+      resume: { sessionId: origin.sessionId, own: false, origin: originRef },
+      note: `follow-up of ${short(originId)}: resuming session ${short(origin.sessionId)} on ${resolvedHarness} (origin harness unknown)`
+    };
+  }
+  const requested = descriptor.harness;
+  const swap = requested !== void 0 && requested !== origin.harness && requested !== askedHarness(originId, originLane, cfg);
+  if (swap) {
+    return {
+      harness: requested,
+      cold: { why: `swap from ${origin.harness} to ${requested}`, fromHarness: origin.harness, origin: originRef },
+      note: `follow-up of ${short(originId)}: swap \u2014 origin session is ${origin.harness}, ${requested} requested; starting cold on ${requested} with a progress note`
+    };
+  }
+  const ignored = requested !== void 0 && requested !== origin.harness ? ` (--harness ${requested} ignored for the resume)` : "";
+  return {
+    harness: origin.harness,
+    resume: { sessionId: origin.sessionId, own: false, origin: originRef },
+    note: `follow-up of ${short(originId)}: resuming ${origin.harness} session ${short(origin.sessionId)} (harness from ${origin.source})${ignored}`
+  };
+}
+
+// packages/runner/src/run.ts
+var defaultDeps = { loadAdapter, allocate, collectEvidence };
+function coldNote(cold, cwd, trunk) {
+  const parts = [worktreeProgress(cwd, trunk)];
+  if (cold.origin) parts.push(originProgress(cold.origin.id, cold.origin.lane));
+  return handoffNote(cold.fromHarness ?? "unknown", parts.join("\n\n"), cold.why);
 }
-async function main(activeDir, lane) {
-  const id = path8.basename(activeDir);
+async function main(activeDir, lane, deps = defaultDeps) {
+  const id = path10.basename(activeDir);
   const status = (verb, note) => appendStatus(id, lane, verb, note);
   const cfg = loadConfig();
-  const descriptor = JSON.parse(fs10.readFileSync(path8.join(activeDir, "descriptor.json"), "utf8"));
+  const descriptor = JSON.parse(fs12.readFileSync(path10.join(activeDir, "descriptor.json"), "utf8"));
   const resolved = resolveDispatch(descriptor, cfg);
   const repo = cfg.repos[descriptor.repo];
-  const briefFile = path8.join(activeDir, "brief.md");
-  if (!fs10.existsSync(briefFile)) fs10.writeFileSync(briefFile, descriptor.brief);
-  const brief = fs10.readFileSync(briefFile, "utf8");
+  const briefFile = path10.join(activeDir, "brief.md");
+  if (!fs12.existsSync(briefFile)) fs12.writeFileSync(briefFile, descriptor.brief);
+  const brief = fs12.readFileSync(briefFile, "utf8");
   const attempts = Number(process.env.LOBSTAH_ATTEMPTS ?? "1");
   const runnerInfo = {
     pid: process.pid,
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     attempts
   };
-  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 = path8.join(activeDir, "worktree.json");
+  fs12.writeFileSync(path10.join(activeDir, "runner.json"), JSON.stringify(runnerInfo, null, 2));
+  const plan = planStart({
+    id,
+    lane,
+    descriptor,
+    cfg,
+    resolvedHarness: resolved.harness,
+    envResume: process.env.LOBSTAH_RESUME
+  });
+  const firstNote = [attempts > 1 ? `attempt ${attempts}` : void 0, plan.note].filter(Boolean).join("; ");
+  status("working", firstNote || void 0);
+  appendEvent(id, lane, {
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    type: "runner",
+    data: { pid: process.pid, attempts, harness: plan.harness, ...plan.resume ? { resume: plan.resume.sessionId } : {} }
+  });
+  const own = readEvidence(id, lane).sessionId;
+  mergeEvidence(id, lane, { harness: plan.harness, sessionId: plan.resume?.own ? own : void 0 });
+  const wtFile = path10.join(activeDir, "worktree.json");
   let cwd;
-  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))) {
+  if (fs12.existsSync(wtFile)) {
+    cwd = JSON.parse(fs12.readFileSync(wtFile, "utf8")).path;
+    if (!fs12.existsSync(cwd)) throw new Error(`recorded worktree ${cwd} is gone`);
+  } else if (fs12.existsSync(worktreePath(id))) {
     throw new Error(`unrecorded worktree already exists for ${id} \u2014 refusing to proceed`);
   } else {
-    cwd = await allocate(repo, id);
-    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 = 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,
-    prompt,
-    model: resolved.model,
-    effort: resolved.effort,
-    limits: resolved.limits,
-    env: {
-      ...resolved.env,
-      LOBSTAH_HOME: lobstahHome(),
-      ...workerPath ? { PATH: workerPath } : {}
-    },
-    flags: resolved.flags,
-    resumeSession
-  });
+    cwd = await deps.allocate(repo, id);
+    fs12.writeFileSync(wtFile, JSON.stringify({ path: cwd }, null, 2));
+  }
+  const adapter = deps.loadAdapter(plan.harness);
+  const envNudge = process.env.LOBSTAH_NUDGE;
+  const planNudge = plan.cold && !envNudge ? coldNote(plan.cold, cwd, repo.trunk) : void 0;
+  const promptWith = (nudge) => buildPrompt(brief, { id, nudge, attachments: descriptor.attachments });
+  const binDir = path10.resolve(path10.dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "bin");
+  const workerPath = fs12.existsSync(path10.join(binDir, "lobstah")) ? `${binDir}${path10.delimiter}${process.env.PATH ?? ""}` : void 0;
   let wallClockHit = false;
+  let current;
   const wallTimer = resolved.limits.wallClockSecs ? setTimeout(() => {
     wallClockHit = true;
-    run2.kill();
+    current?.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 runOnce = async (prompt, resumeSession) => {
+    const run2 = await adapter.start({
+      id,
+      cwd,
+      prompt,
+      model: resolved.model,
+      effort: resolved.effort,
+      limits: resolved.limits,
+      env: {
+        ...resolved.env,
+        LOBSTAH_HOME: lobstahHome(),
+        ...workerPath ? { PATH: workerPath } : {}
+      },
+      flags: resolved.flags,
+      resumeSession
+    });
+    current = run2;
+    const { cancelled: cancelled2, activity } = await drive(run2, { id, lane, stopped: () => wallClockHit });
+    const result2 = await run2.done;
+    return { cancelled: cancelled2, activity, result: result2 };
+  };
+  let outcome = await runOnce(promptWith(envNudge ?? planNudge), plan.resume?.sessionId);
+  if (plan.resume && !outcome.cancelled && !wallClockHit && outcome.activity === 0 && isUnresumable(outcome.result.error)) {
+    const reason = outcome.result.error.replace(/\s+/g, " ").slice(0, 200);
+    status("working", `resume-fallback: ${reason} \u2014 starting cold on ${plan.harness} with a progress note`);
+    appendEvent(id, lane, { at: (/* @__PURE__ */ new Date()).toISOString(), type: "runner", data: { resumeFallback: reason } });
+    mergeEvidence(id, lane, { resumeFallback: reason, sessionId: void 0 });
+    const note = coldNote(
+      {
+        why: `resume of session ${plan.resume.sessionId} failed`,
+        fromHarness: plan.harness,
+        ...plan.resume.origin ? { origin: plan.resume.origin } : {}
+      },
+      cwd,
+      repo.trunk
+    );
+    outcome = await runOnce(promptWith([envNudge, note].filter(Boolean).join("\n\n")), void 0);
   }
-  const result = await run2.done;
   if (wallTimer) clearTimeout(wallTimer);
+  const { cancelled, result } = outcome;
   try {
-    const gitEvidence = await collectEvidence(repo, id);
+    const gitEvidence = await deps.collectEvidence(repo, id);
     console.log(`[runner] git evidence: ${JSON.stringify(gitEvidence)}`);
     mergeEvidence(id, lane, { ...gitEvidence, sessionId: result.sessionId ?? readEvidence(id, lane).sessionId });
     console.log(`[runner] evidence after merge: ${JSON.stringify(readEvidence(id, lane))}`);
@@ -1536,25 +1856,18 @@ 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);
 }
+
+// packages/runner/src/index.ts
 function runRunner(activeDirArg2, laneArg2) {
   const lane = laneArg2 === "chore" ? "chore" : "work";
   main(activeDirArg2, lane).catch((err) => {
-    const id = path8.basename(activeDirArg2);
+    const id = path11.basename(activeDirArg2);
     try {
       appendStatus(id, lane, "failed", String(err instanceof Error ? err.message : err).slice(0, 500));
-      fs10.renameSync(activeDirArg2, path8.join(laneDirs(lane).done, id));
+      fs13.renameSync(activeDirArg2, path11.join(laneDirs(lane).done, id));
     } catch {
     }
     process.exitCode = 1;
@@ -1564,6 +1877,7 @@ var [activeDirArg, laneArg] = process.argv.slice(2);
 if (activeDirArg && activeDirArg !== "__runner") runRunner(activeDirArg, laneArg);
 export {
   main,
+  planStart,
   runRunner
 };
 /*! Bundled license information: