lobstah 0.5.9 → 0.5.10

package/dist/main.js

@@ -1395,6 +1395,7 @@ var init_config = __esm({
       wedgeThresholdSecs: 600,
       maxRestartAttempts: 2,
       wallClockSecs: 3600,
+      backgroundWaitSecs: 1800,
       choreRetentionDays: 7,
       attachmentMaxBytes: 25 * 1024 * 1024
     };
@@ -2809,6 +2810,9 @@ function pumpClaudeMessage(msg, push, onSession) {
     if (msg.session_id)
       onSession(msg.session_id);
     push({ at, type: "session", data: { sessionId: msg.session_id } });
+  } else if (msg.type === "system" && msg.subtype === "background_tasks_changed") {
+    const live = (msg.tasks ?? []).filter((t) => !t.ambient).length;
+    push({ at, type: "background", data: { live } });
   } else if (msg.type === "assistant") {
     for (const block of msg.message?.content ?? []) {
       if (block.type === "tool_use") {
@@ -2829,6 +2833,19 @@ function pumpClaudeMessage(msg, push, onSession) {
     push({ at, type: "turn-end", data: { subtype: msg.subtype, costUsd: msg.total_cost_usd } });
   }
 }
+function claudeSdkOptions(opts) {
+  return {
+    cwd: opts.cwd,
+    model: opts.model,
+    ...opts.effort ? { effort: opts.effort } : {},
+    maxTurns: opts.limits.maxTurns,
+    resume: opts.resumeSession,
+    forkSession: opts.resumeSession ? true : void 0,
+    permissionMode: "bypassPermissions",
+    env: { ...process.env, ...opts.env },
+    extraArgs: flagsToExtraArgs(opts.flags)
+  };
+}
 function claudeCliArgs(opts) {
   const args = [
     "-p",
@@ -2842,6 +2859,8 @@ function claudeCliArgs(opts) {
   ];
   if (opts.model)
     args.push("--model", opts.model);
+  if (opts.effort)
+    args.push("--effort", opts.effort);
   if (opts.limits.maxTurns)
     args.push("--max-turns", String(opts.limits.maxTurns));
   if (opts.resumeSession)
@@ -2949,16 +2968,7 @@ function createClaudeAdapter() {
       }
       const q = sdk.query({
         prompt: userMessages(),
-        options: {
-          cwd: opts.cwd,
-          model: opts.model,
-          maxTurns: opts.limits.maxTurns,
-          resume: opts.resumeSession,
-          forkSession: opts.resumeSession ? true : void 0,
-          permissionMode: "bypassPermissions",
-          env: { ...process.env, ...opts.env },
-          extraArgs: flagsToExtraArgs(opts.flags)
-        }
+        options: claudeSdkOptions(opts)
       });
       const events = new AsyncQueue();
       let sessionId;
@@ -3251,6 +3261,22 @@ async function git4(cwd, ...args) {
   const { stdout } = await run3("git", args, { cwd, env: process.env });
   return stdout.trim();
 }
+function isLockContention(err) {
+  const text = `${err.stderr ?? ""}
+${err instanceof Error ? err.message : ""}`;
+  return LOCK_CONTENTION.some((re) => re.test(text));
+}
+async function gitShared(cwd, ...args) {
+  for (let attempt = 1; ; attempt++) {
+    try {
+      return await git4(cwd, ...args);
+    } catch (err) {
+      if (attempt >= 6 || !isLockContention(err))
+        throw err;
+      await new Promise((r) => setTimeout(r, 100 * 2 ** (attempt - 1) * (0.5 + Math.random())));
+    }
+  }
+}
 async function allocate(repo, id) {
   const dir = worktreePath(id);
   if (fs43.existsSync(dir)) {
@@ -3261,8 +3287,8 @@ async function allocate(repo, id) {
       throw new Error(`repo path ${repo.path} missing and no origin configured`);
     await run3("git", ["clone", repo.origin, repo.path], { env: process.env });
   }
-  await git4(repo.path, "fetch", "origin", repo.trunk);
-  await git4(repo.path, "worktree", "add", dir, "-b", `lobstah/${id}`, `origin/${repo.trunk}`);
+  await gitShared(repo.path, "fetch", "origin", repo.trunk);
+  await gitShared(repo.path, "worktree", "add", "--no-track", dir, "-b", `lobstah/${id}`, `origin/${repo.trunk}`);
   for (const cmd of repo.setup ?? []) {
     await shell(cmd, { cwd: dir, env: { ...process.env, ...repo.env ?? {} } });
   }
@@ -3274,19 +3300,20 @@ async function collectEvidence(repo, id) {
   const log = await git4(dir, "log", "--oneline", `origin/${repo.trunk}..HEAD`);
   return { branch, commits: log ? log.split("\n") : [] };
 }
-var run3, shell;
+var run3, shell, LOCK_CONTENTION;
 var init_dist4 = __esm({
   "packages/worktree/dist/index.js"() {
     "use strict";
     init_dist2();
     run3 = promisify(execFile);
     shell = promisify(exec);
+    LOCK_CONTENTION = [/cannot lock ref/, /unable to update local ref/, /Unable to create '[^']*\.lock': File exists/];
   }
 });
 
 // packages/runner/dist/contract.js
 function buildPrompt(brief, opts) {
-  const reporting = `Report status by running \`lobstah report ${opts.id} <verb> [note]\` (verbs: ${VERBS.join(", ")}). Attach a PR URL to your final report with \`--pr <url>\`. At natural checkpoints, check for operator messages with \`lobstah inbox ${opts.id}\` \u2014 messages also arrive automatically between your turns.`;
+  const reporting = `Report status by running \`lobstah report ${opts.id} <verb> [note]\` (verbs: ${VERBS.join(", ")}). Attach a PR URL to your final report with \`--pr <url>\`. Only your report finishes this dispatch: ending a turn without \`done\` or \`failed\` does not. If you start background work and end your turn to wait for it, you are woken when it finishes. At natural checkpoints, check for operator messages with \`lobstah inbox ${opts.id}\` \u2014 messages also arrive automatically between your turns.`;
   const parts = [
     `You are a dispatched coding agent supervised by lobstah. Dispatch id: ${opts.id}.`,
     `Work only inside the current directory \u2014 it is an isolated git worktree allocated for this dispatch.`,
@@ -3310,6 +3337,9 @@ var init_contract = __esm({
 });
 
 // packages/runner/dist/drive.js
+function unreportedNudge(id) {
+  return `Your turn ended without a status report, so this dispatch is not finished. If the work is complete, run \`lobstah report ${id} done "<what you did>"\`, adding \`--pr <url>\` if you opened a PR. If no change was needed, report \`done\` with a note saying why. If a human has to answer a question, or you are blocked, report \`needs-decision\` or \`blocked\` with it. If you are waiting on something, run it in the background: you are woken when it finishes.`;
+}
 function deliver(run4, id, lane) {
   const msgs = unhandled(id, lane);
   for (const m of msgs) {
@@ -3319,7 +3349,7 @@ function deliver(run4, id, lane) {
   return msgs.length;
 }
 async function drive(run4, opts) {
-  const { id, lane, pollMs = 3e3, stopped = () => false } = opts;
+  const { id, lane, pollMs = 3e3, stopped = () => false, backgroundWaitMs = 30 * 6e4, settleGraceMs = 12e4 } = opts;
   let cancelled = false;
   let activity = 0;
   let finished = false;
@@ -3345,8 +3375,53 @@ async function drive(run4, opts) {
       await sleep(pollMs);
     }
   };
+  let liveBackground = 0;
+  let nudged = false;
+  let hold;
+  const runnerEvent = (data) => appendEvent(id, lane, { at: (/* @__PURE__ */ new Date()).toISOString(), type: "runner", data });
+  const releaseHold = () => {
+    if (!hold)
+      return;
+    clearInterval(hold.heartbeat);
+    clearTimeout(hold.expiry);
+    hold = void 0;
+  };
+  const unreported = () => {
+    if (!nudged) {
+      nudged = true;
+      runnerEvent({ nudged: "unreported" });
+      run4.send(unreportedNudge(id));
+      return;
+    }
+    appendStatus(id, lane, "failed", "ended without reporting a result, after being asked to");
+    run4.end();
+  };
+  const holdOpen = (ms) => {
+    releaseHold();
+    const heartbeat = setInterval(() => {
+      if (cancelRequested(id, lane)) {
+        releaseHold();
+        cancel();
+        return;
+      }
+      touchEvents(id, lane);
+    }, pollMs);
+    const expiry = setTimeout(() => {
+      releaseHold();
+      runnerEvent({ backgroundWait: "expired", live: liveBackground });
+      unreported();
+    }, ms);
+    hold = { heartbeat, expiry };
+  };
   for await (const ev of run4.events) {
     appendEvent(id, lane, ev);
+    if (ev.type === "background") {
+      liveBackground = Number(ev.data?.live ?? 0);
+      if (hold && liveBackground === 0)
+        holdOpen(settleGraceMs);
+      continue;
+    }
+    releaseHold();
     if (ev.type === "tool-start" || ev.type === "text")
       activity++;
     if (ev.type === "session" && ev.data?.sessionId) {
@@ -3369,8 +3444,23 @@ async function drive(run4, opts) {
       await awaitAnswer(lastVerb);
       continue;
     }
-    run4.end();
+    if (lastVerb !== void 0 && TERMINAL_VERBS.includes(lastVerb)) {
+      run4.end();
+      continue;
+    }
+    const subtype = ev.data?.subtype;
+    if (subtype !== void 0 && subtype !== "success") {
+      run4.end();
+      continue;
+    }
+    if (liveBackground > 0) {
+      runnerEvent({ holding: "background", live: liveBackground, forSecs: Math.round(backgroundWaitMs / 1e3) });
+      holdOpen(backgroundWaitMs);
+      continue;
+    }
+    unreported();
   }
+  releaseHold();
   return { cancelled, activity };
 }
 function settle(id, lane, r) {
@@ -3382,7 +3472,7 @@ function settle(id, lane, r) {
   else if (r.error)
     appendStatus(id, lane, "failed", r.error.slice(0, 500));
   else if (!lastVerb || !TERMINAL_VERBS.includes(lastVerb))
-    appendStatus(id, lane, "done");
+    appendStatus(id, lane, "failed", "stopped without reporting a result");
 }
 var WAITING_VERBS, sleep;
 var init_drive = __esm({
@@ -3568,7 +3658,12 @@ async function main(activeDir, lane, deps = defaultDeps) {
       resumeSession
     });
     current = run4;
-    const { cancelled: cancelled2, activity } = await drive(run4, { id, lane, stopped: () => wallClockHit });
+    const { cancelled: cancelled2, activity } = await drive(run4, {
+      id,
+      lane,
+      stopped: () => wallClockHit,
+      backgroundWaitMs: cfg.limits.backgroundWaitSecs * 1e3
+    });
     const result2 = await run4.done;
     return { cancelled: cancelled2, activity, result: result2 };
   };
@@ -4387,6 +4482,9 @@ var GithubSource = class {
     this.cfg = cfg;
     this.name = `gh:${cfg.repo}`;
   }
+  owns(key) {
+    return key.startsWith(`${this.name}#`);
+  }
   async api(method, url, body) {
     const res = await fetch(`${API}${url}`, {
       method,
@@ -4619,6 +4717,9 @@ var LinearSource = class {
   constructor(cfg) {
     this.cfg = cfg;
   }
+  owns(key) {
+    return key.startsWith("linear:");
+  }
   async gql(query, variables = {}) {
     const res = await fetch(API2, {
       method: "POST",
@@ -4766,42 +4867,51 @@ function dispatchLane(uuid) {
 async function reportLoop(source, state, log = () => {
 }, notify = () => {
 }) {
+  const failures = [];
   for (const [key, entry] of state.entries()) {
-    if (entry.released)
+    if (!source.owns(key))
       continue;
-    const lane = dispatchLane(entry.uuid);
-    if (!lane)
+    if (entry.released)
       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
+    try {
+      const lane = dispatchLane(entry.uuid);
+      if (!lane)
+        continue;
+      const verb = reconcile({
+        log: readStatusLog(entry.uuid, lane),
+        lastEventAt: lastEventAt(entry.uuid, lane)
       });
-    }
-    if (entry.kind === "issue" && verb === "failed" && fs22.existsSync(path17.join(laneDirs(lane).done, entry.uuid))) {
-      state.releaseIssue(key);
-      log(`${key}: finalized failure released for a bounded retry`);
-      continue;
-    }
-    const msgs = await source.inbound(key, entry.lastInboundAt);
-    if (msgs.length > 0) {
-      for (const m of msgs)
-        sendMessage(entry.uuid, lane, m, `tracker:${source.name.startsWith("gh:") ? "github" : source.name}`);
-      state.update(key, { lastInboundAt: (/* @__PURE__ */ new Date()).toISOString() });
-      log(`${key}: forwarded ${msgs.length} comment(s) to inbox`);
+      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
+        });
+      }
+      if (entry.kind === "issue" && verb === "failed" && fs22.existsSync(path17.join(laneDirs(lane).done, entry.uuid))) {
+        state.releaseIssue(key);
+        log(`${key}: finalized failure released for a bounded retry`);
+        continue;
+      }
+      const msgs = await source.inbound(key, entry.lastInboundAt);
+      if (msgs.length > 0) {
+        for (const m of msgs)
+          sendMessage(entry.uuid, lane, m, `tracker:${source.name.startsWith("gh:") ? "github" : source.name}`);
+        state.update(key, { lastInboundAt: (/* @__PURE__ */ new Date()).toISOString() });
+        log(`${key}: forwarded ${msgs.length} comment(s) to inbox`);
+      }
+    } catch (err) {
+      failures.push(`${key}: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
+  if (failures.length > 0)
+    throw new Error(failures.join("; "));
 }
 
 // apps/pick/dist/loops/dispatch.js
@@ -5273,12 +5383,16 @@ function syncStreams(children, flight, log, notify) {
 }
 async function cycle(sources, merges, state, pollSecs2, 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 loop of [
+      () => dispatchLoop(source, state, log),
+      () => reportLoop(source, state, log, notify),
+      () => reconcileLoop(source, state, log)
+    ]) {
+      try {
+        await loop();
+      } catch (err) {
+        log(`${source.name}: ${err instanceof Error ? err.message : String(err)}`);
+      }
     }
   }
   for (const { source, policy } of merges) {

package/dist/runner.js

@@ -841,6 +841,7 @@ var DEFAULT_LIMITS = {
   wedgeThresholdSecs: 600,
   maxRestartAttempts: 2,
   wallClockSecs: 3600,
+  backgroundWaitSecs: 1800,
   choreRetentionDays: 7,
   attachmentMaxBytes: 25 * 1024 * 1024
 };
@@ -1223,6 +1224,9 @@ function pumpClaudeMessage(msg, push, onSession) {
     if (msg.session_id)
       onSession(msg.session_id);
     push({ at, type: "session", data: { sessionId: msg.session_id } });
+  } else if (msg.type === "system" && msg.subtype === "background_tasks_changed") {
+    const live = (msg.tasks ?? []).filter((t) => !t.ambient).length;
+    push({ at, type: "background", data: { live } });
   } else if (msg.type === "assistant") {
     for (const block of msg.message?.content ?? []) {
       if (block.type === "tool_use") {
@@ -1249,6 +1253,19 @@ var userMessage = (content) => ({
   parent_tool_use_id: null,
   session_id: ""
 });
+function claudeSdkOptions(opts) {
+  return {
+    cwd: opts.cwd,
+    model: opts.model,
+    ...opts.effort ? { effort: opts.effort } : {},
+    maxTurns: opts.limits.maxTurns,
+    resume: opts.resumeSession,
+    forkSession: opts.resumeSession ? true : void 0,
+    permissionMode: "bypassPermissions",
+    env: { ...process.env, ...opts.env },
+    extraArgs: flagsToExtraArgs(opts.flags)
+  };
+}
 function claudeCliArgs(opts) {
   const args = [
     "-p",
@@ -1262,6 +1279,8 @@ function claudeCliArgs(opts) {
   ];
   if (opts.model)
     args.push("--model", opts.model);
+  if (opts.effort)
+    args.push("--effort", opts.effort);
   if (opts.limits.maxTurns)
     args.push("--max-turns", String(opts.limits.maxTurns));
   if (opts.resumeSession)
@@ -1369,16 +1388,7 @@ function createClaudeAdapter() {
       }
       const q = sdk.query({
         prompt: userMessages(),
-        options: {
-          cwd: opts.cwd,
-          model: opts.model,
-          maxTurns: opts.limits.maxTurns,
-          resume: opts.resumeSession,
-          forkSession: opts.resumeSession ? true : void 0,
-          permissionMode: "bypassPermissions",
-          env: { ...process.env, ...opts.env },
-          extraArgs: flagsToExtraArgs(opts.flags)
-        }
+        options: claudeSdkOptions(opts)
       });
       const events = new AsyncQueue();
       let sessionId;
@@ -1642,6 +1652,23 @@ async function git(cwd, ...args) {
   const { stdout } = await run("git", args, { cwd, env: process.env });
   return stdout.trim();
 }
+var LOCK_CONTENTION = [/cannot lock ref/, /unable to update local ref/, /Unable to create '[^']*\.lock': File exists/];
+function isLockContention(err) {
+  const text = `${err.stderr ?? ""}
+${err instanceof Error ? err.message : ""}`;
+  return LOCK_CONTENTION.some((re) => re.test(text));
+}
+async function gitShared(cwd, ...args) {
+  for (let attempt = 1; ; attempt++) {
+    try {
+      return await git(cwd, ...args);
+    } catch (err) {
+      if (attempt >= 6 || !isLockContention(err))
+        throw err;
+      await new Promise((r) => setTimeout(r, 100 * 2 ** (attempt - 1) * (0.5 + Math.random())));
+    }
+  }
+}
 async function allocate(repo, id) {
   const dir = worktreePath(id);
   if (fs11.existsSync(dir)) {
@@ -1652,8 +1679,8 @@ async function allocate(repo, id) {
       throw new Error(`repo path ${repo.path} missing and no origin configured`);
     await run("git", ["clone", repo.origin, repo.path], { env: process.env });
   }
-  await git(repo.path, "fetch", "origin", repo.trunk);
-  await git(repo.path, "worktree", "add", dir, "-b", `lobstah/${id}`, `origin/${repo.trunk}`);
+  await gitShared(repo.path, "fetch", "origin", repo.trunk);
+  await gitShared(repo.path, "worktree", "add", "--no-track", dir, "-b", `lobstah/${id}`, `origin/${repo.trunk}`);
   for (const cmd of repo.setup ?? []) {
     await shell(cmd, { cwd: dir, env: { ...process.env, ...repo.env ?? {} } });
   }
@@ -1668,7 +1695,7 @@ async function collectEvidence(repo, id) {
 
 // packages/runner/src/contract.ts
 function buildPrompt(brief, opts) {
-  const reporting = `Report status by running \`lobstah report ${opts.id} <verb> [note]\` (verbs: ${VERBS.join(", ")}). Attach a PR URL to your final report with \`--pr <url>\`. At natural checkpoints, check for operator messages with \`lobstah inbox ${opts.id}\` \u2014 messages also arrive automatically between your turns.`;
+  const reporting = `Report status by running \`lobstah report ${opts.id} <verb> [note]\` (verbs: ${VERBS.join(", ")}). Attach a PR URL to your final report with \`--pr <url>\`. Only your report finishes this dispatch: ending a turn without \`done\` or \`failed\` does not. If you start background work and end your turn to wait for it, you are woken when it finishes. At natural checkpoints, check for operator messages with \`lobstah inbox ${opts.id}\` \u2014 messages also arrive automatically between your turns.`;
   const parts = [
     `You are a dispatched coding agent supervised by lobstah. Dispatch id: ${opts.id}.`,
     `Work only inside the current directory \u2014 it is an isolated git worktree allocated for this dispatch.`,
@@ -1685,6 +1712,9 @@ function buildPrompt(brief, opts) {
 
 // packages/runner/src/drive.ts
 var WAITING_VERBS = ["needs-decision", "blocked", "paused"];
+function unreportedNudge(id) {
+  return `Your turn ended without a status report, so this dispatch is not finished. If the work is complete, run \`lobstah report ${id} done "<what you did>"\`, adding \`--pr <url>\` if you opened a PR. If no change was needed, report \`done\` with a note saying why. If a human has to answer a question, or you are blocked, report \`needs-decision\` or \`blocked\` with it. If you are waiting on something, run it in the background: you are woken when it finishes.`;
+}
 var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
 function deliver(run2, id, lane) {
   const msgs = unhandled(id, lane);
@@ -1695,7 +1725,14 @@ function deliver(run2, id, lane) {
   return msgs.length;
 }
 async function drive(run2, opts) {
-  const { id, lane, pollMs = 3e3, stopped = () => false } = opts;
+  const {
+    id,
+    lane,
+    pollMs = 3e3,
+    stopped = () => false,
+    backgroundWaitMs = 30 * 6e4,
+    settleGraceMs = 12e4
+  } = opts;
   let cancelled = false;
   let activity = 0;
   let finished = false;
@@ -1718,8 +1755,51 @@ async function drive(run2, opts) {
       await sleep(pollMs);
     }
   };
+  let liveBackground = 0;
+  let nudged = false;
+  let hold;
+  const runnerEvent = (data) => appendEvent(id, lane, { at: (/* @__PURE__ */ new Date()).toISOString(), type: "runner", data });
+  const releaseHold = () => {
+    if (!hold) return;
+    clearInterval(hold.heartbeat);
+    clearTimeout(hold.expiry);
+    hold = void 0;
+  };
+  const unreported = () => {
+    if (!nudged) {
+      nudged = true;
+      runnerEvent({ nudged: "unreported" });
+      run2.send(unreportedNudge(id));
+      return;
+    }
+    appendStatus(id, lane, "failed", "ended without reporting a result, after being asked to");
+    run2.end();
+  };
+  const holdOpen = (ms) => {
+    releaseHold();
+    const heartbeat = setInterval(() => {
+      if (cancelRequested(id, lane)) {
+        releaseHold();
+        cancel();
+        return;
+      }
+      touchEvents(id, lane);
+    }, pollMs);
+    const expiry = setTimeout(() => {
+      releaseHold();
+      runnerEvent({ backgroundWait: "expired", live: liveBackground });
+      unreported();
+    }, ms);
+    hold = { heartbeat, expiry };
+  };
   for await (const ev of run2.events) {
     appendEvent(id, lane, ev);
+    if (ev.type === "background") {
+      liveBackground = Number(ev.data?.live ?? 0);
+      if (hold && liveBackground === 0) holdOpen(settleGraceMs);
+      continue;
+    }
+    releaseHold();
     if (ev.type === "tool-start" || ev.type === "text") activity++;
     if (ev.type === "session" && ev.data?.sessionId) {
       mergeEvidence(id, lane, { sessionId: String(ev.data.sessionId) });
@@ -1739,8 +1819,23 @@ async function drive(run2, opts) {
       await awaitAnswer(lastVerb);
       continue;
     }
-    run2.end();
+    if (lastVerb !== void 0 && TERMINAL_VERBS.includes(lastVerb)) {
+      run2.end();
+      continue;
+    }
+    const subtype = ev.data?.subtype;
+    if (subtype !== void 0 && subtype !== "success") {
+      run2.end();
+      continue;
+    }
+    if (liveBackground > 0) {
+      runnerEvent({ holding: "background", live: liveBackground, forSecs: Math.round(backgroundWaitMs / 1e3) });
+      holdOpen(backgroundWaitMs);
+      continue;
+    }
+    unreported();
   }
+  releaseHold();
   return { cancelled, activity };
 }
 function settle(id, lane, r) {
@@ -1748,7 +1843,7 @@ function settle(id, lane, r) {
   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");
+  else if (!lastVerb || !TERMINAL_VERBS.includes(lastVerb)) appendStatus(id, lane, "failed", "stopped without reporting a result");
 }
 
 // packages/runner/src/plan.ts
@@ -1912,7 +2007,12 @@ async function main(activeDir, lane, deps = defaultDeps) {
       resumeSession
     });
     current = run2;
-    const { cancelled: cancelled2, activity } = await drive(run2, { id, lane, stopped: () => wallClockHit });
+    const { cancelled: cancelled2, activity } = await drive(run2, {
+      id,
+      lane,
+      stopped: () => wallClockHit,
+      backgroundWaitMs: cfg.limits.backgroundWaitSecs * 1e3
+    });
     const result2 = await run2.done;
     return { cancelled: cancelled2, activity, result: result2 };
   };

package/docs/configuration.md

@@ -33,6 +33,12 @@ The descriptor's `repo` field resolves here; the key is what dispatchers name.
 `[repos.<key>.harness]` — per-repo harness defaults: `default` (`claude` \|
 `codex`), `model`, `effort`.
 
+`effort` reaches both harnesses: Claude as its effort level (`low`, `medium`,
+`high`, `xhigh`, `max`), Codex as `model_reasoning_effort`. Set it for Claude
+rather than relying on the default — left unset, a Claude session takes
+`effortLevel` from the host's settings files, including the user's own
+`~/.claude/settings.json`.
+
 `lobstah repos add <path> [--pickup]` detects and appends a block (origin,
 default branch from `origin/HEAD`, setup from the lockfile); `lobstah init
 --scan <dir>...` does the same for every git repo found under the given
@@ -52,6 +58,7 @@ Same three keys as the per-repo block. Precedence for every harness setting:
 | `wedgeThresholdSecs` | `600` | No tool activity for this long while alive = wedged → killed and forked with a nudge. |
 | `maxRestartAttempts` | `2` | Bounded restart ladder for dead and wedged runners. |
 | `wallClockSecs` | `3600` | Hard per-dispatch ceiling, enforced by the runner. |
+| `backgroundWaitSecs` | `1800` | A turn that ends without a report is held open this long while background work the worker started is still running (a push behind a slow pre-push gate); the harness wakes the worker when it settles. Heartbeats keep the wedge detector off the wait. Keep it below `wallClockSecs`, which still ends the run. |
 | `choreRetentionDays` | `7` | Completed chores age out of `chores/done/`. |
 | `attachmentMaxBytes` | `26214400` (25 MiB) | Maximum size of each file supplied with repeatable `dispatch --attach` or `send --attach`. |
 

package/docs/design.md

@@ -449,8 +449,20 @@ worker's last report on `needs-decision`, `blocked`, or `paused` does not end
 the session: a headless worker waiting on a question stays alive until
 answered, cancelled, or the wall clock — the runner polls the inbox, touches the
 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`.
+answer into the next turn, and stamps `working`. A turn ending on `done` or
+`failed` ends the session.
+
+**Only the worker's report finishes a dispatch.** A turn can end with no report
+while the worker is still mid-task: it started a push behind a slow pre-push gate
+and ended the turn to be woken when it lands, which is how the harness asks a
+model to wait. Ending the session there kills the push. So a quiet turn is held
+open while the harness reports live background work (ambient watchers excluded),
+up to `[limits].backgroundWaitSecs`, with the same heartbeats as a question wait;
+the harness wakes the worker when the work settles. With nothing live, or once
+the window passes, the worker is asked once to report. Silence after that is
+`failed`, as is a run that stops on its own without a report. Stamping `done` on
+silence turned a question never asked, two in-flight pushes, and a conclusion
+nobody saw into finished work.
 
 **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

package/docs/pickup.md

@@ -356,6 +356,13 @@ design rather than by trust:
   In Progress item because the table lacks an entry for it. A missing mapping
   triggers a rebuild, and only a rebuilt table may declare an orphan. Losing a
   file must never cancel live work.
+- **Shared, so owned.** Every source writes into one table. A loop that walks
+  it acts only on the keys its source `owns()` — a Linear key handed to the
+  GitHub source, or the reverse, is not an item that source can read. And no
+  single entry may fail the walk: each is isolated, the rest still report, and
+  the loop rejects afterwards so the cycle logs it. Dispatch, report, and
+  reconcile are guarded separately, so a report that cannot land never takes
+  reconciliation down with it.
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lobstah",
-  "version": "0.5.9",
+  "version": "0.5.10",
   "description": "Harness-agnostic, token-efficient supervision framework for coding agents",
   "license": "MIT",
   "author": "aequitas labs LLC",