lobstah 0.5.5 → 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`);
 }
@@ -80,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));
@@ -794,8 +810,8 @@ 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"];
+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];
@@ -928,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";
 
@@ -1212,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;
 }
@@ -1427,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 });
@@ -1442,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 });
@@ -1495,6 +1626,7 @@ function deliver(run2, id, lane) {
 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 = () => {
@@ -1517,6 +1649,7 @@ async function drive(run2, opts) {
   };
   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) });
     }
@@ -1537,7 +1670,7 @@ async function drive(run2, opts) {
     }
     run2.end();
   }
-  return { cancelled };
+  return { cancelled, activity };
 }
 function settle(id, lane, r) {
   const lastVerb = readStatusLog(id, lane).at(-1)?.verb;
@@ -1547,74 +1680,174 @@ function settle(id, lane, r) {
   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"]) {
-    const ev = readEvidence(followUp, lane);
-    if (ev.sessionId) return ev.sessionId;
+// 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
+    };
   }
-  return 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}`
+  };
 }
-async function main(activeDir, lane) {
-  const id = path8.basename(activeDir);
+
+// 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, 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, 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,
-    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;
-  const { cancelled } = await drive(run2, { id, lane, stopped: () => wallClockHit });
-  const result = await run2.done;
+  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);
+  }
   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))}`);
@@ -1626,13 +1859,15 @@ async function main(activeDir, lane) {
   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;
@@ -1642,6 +1877,7 @@ var [activeDirArg, laneArg] = process.argv.slice(2);
 if (activeDirArg && activeDirArg !== "__runner") runRunner(activeDirArg, laneArg);
 export {
   main,
+  planStart,
   runRunner
 };
 /*! Bundled license information:

package/docs/configuration.md

@@ -14,7 +14,7 @@ keys of that section.
 |---|---|---|
 | `notifyCommand` | — | Exec'd by the daemon on wake-worthy status transitions with `LOBSTAH_ID`, `LOBSTAH_LANE`, `LOBSTAH_VERB`, `LOBSTAH_NOTE`, `LOBSTAH_AT` in the environment. Fire-and-forget; point it at ntfy, a Slack helper, anything. |
 | `notifyVerbs` | `["needs-decision", "blocked", "done", "failed"]` | Which verbs fire `notifyCommand`. |
-| `attentionKinds` | `["question", "pr:draft", "pr:review", "pr:checks", "pr:ready"]` | Which attention kinds `man tend` lists — and so what the desktop pet and the glass walk across the screen. Valid kinds: `question`, `landed` (opt-in), `pr:draft`, `pr:review`, `pr:checks`, `pr:ready`; an unknown kind is a config error naming the valid set. Notify is edge-triggered and fires once per transition; attention is level-triggered and stands until its clear condition ([vocabulary.md](vocabulary.md#attention-contract)). |
+| `attentionKinds` | `["question", "pr:draft", "pr:review", "pr:checks", "pr:conflict", "pr:ready"]` | Which attention kinds `man tend` lists — and so what the desktop pet and the glass walk across the screen. Valid kinds: `question`, `landed` (opt-in), `pr:draft`, `pr:review`, `pr:checks`, `pr:conflict`, `pr:ready`; an unknown kind is a config error naming the valid set. Notify is edge-triggered and fires once per transition; attention is level-triggered and stands until its clear condition ([vocabulary.md](vocabulary.md#attention-contract)). |
 | `remindSecs` | `900` | An unanswered `needs-decision`/`blocked` re-fires to `man wait`/`man haul` on this interval until answered. `0` = report once only. |
 
 ## `[repos.<key>]` — workspace definitions

package/docs/design.md

@@ -452,6 +452,20 @@ event stream each poll so the wedge detector sees a live wait, delivers the
 answer into the next turn, and stamps `working`. Only a turn ending on `working`
 (or no report) with an empty inbox ends the session and is stamped `done`.
 
+**The session's own harness resumes it.** A session only resumes under the
+harness that wrote it: a Codex thread id handed to Claude Code is "No
+conversation found". The descriptor's `harness` records what was asked, not
+what ran (a trap claims unaddressed work with whatever harness it is), so every
+run stamps `harness` into evidence beside `sessionId` (the adapter's for a
+headless run, the trap's for a claim), and one resolver reads it back for a
+follow-up's fork, a daemon restart, `lobstah swap`, and `attach`. It falls back
+to the claiming trap, then the session id's UUID version, then the descriptor.
+A follow-up whose `--harness` names something the chain never asked for is a
+swap: cold on that harness with the brief plus a progress note. A resume the
+harness refuses before doing any work falls back the same way and records
+`resume-fallback: <reason>` in the status note and evidence. It never fails
+the dispatch. The first status note says which of these happened.
+
 ```ts
 // inside the runner
 const thread = await adapter.start({