lobstah 0.6.1 → 0.6.3

package/dist/runner.js

@@ -857,6 +857,26 @@ var GB = 1024 ** 3;
 // packages/core/dist/watch.js
 import * as fs3 from "node:fs";
 import * as path3 from "node:path";
+
+// packages/core/dist/gh-errors.js
+function firstMeaningfulLine(...outputs) {
+  for (const out of outputs) {
+    for (const raw of (out ?? "").split("\n")) {
+      let line = raw.trim();
+      if (!line || /^(warning:|hint:|\(node:|\{|\})/i.test(line))
+        continue;
+      const m = /^error:\s*(.*)$/.exec(line);
+      if (m)
+        line = m[1].replace(/^"(.*)"$/, "$1").trim();
+      line = line.replace(/^(gh|GraphQL):\s*/i, "");
+      if (line)
+        return line;
+    }
+  }
+  return void 0;
+}
+
+// packages/core/dist/watch.js
 function watchesDir() {
   return path3.join(lobstahHome(), "watches");
 }
@@ -1577,6 +1597,7 @@ var COMPILED_BINARY = (() => {
 })();
 
 // packages/core/dist/pr.js
+import { spawnSync } from "node:child_process";
 function parsePrRef(s) {
   const m = /^(?:pr:)?([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)#(\d+)$/.exec(s.trim()) ?? /^https?:\/\/github\.com\/([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)\/pull\/(\d+)(?:[/?#].*)?$/.exec(s.trim());
   if (!m)
@@ -1587,6 +1608,59 @@ function parsePrRef(s) {
 }
 var PR_VIEW_FIELDS = "title,state,isDraft,headRefOid,baseRefName,baseRefOid,headRefName,mergeStateStatus,reviewDecision,statusCheckRollup,mergedAt,closedAt,updatedAt,reviews";
 var PR_VIEW_FIELDS_NO_CHECKS = PR_VIEW_FIELDS.split(",").filter((f) => f !== "statusCheckRollup").join(",");
+var FORBIDDEN = /resource not accessible by (integration|personal access token)/i;
+function ghPrView(ref) {
+  const view1 = (fields2) => spawnSync("gh", ["pr", "view", String(ref.number), "--repo", `${ref.owner}/${ref.repo}`, "--json", fields2], {
+    encoding: "utf8",
+    timeout: 6e4
+  });
+  const reason = (r) => firstMeaningfulLine(r.stderr) ?? `gh exited ${r.status}`;
+  const unknownBase = (r) => r.status !== 0 && /unknown json field.*baseRefOid/i.test(r.stderr ?? "");
+  const withoutBase = (fields2) => fields2.split(",").filter((f) => f !== "baseRefOid").join(",");
+  let fields = PR_VIEW_FIELDS;
+  let res = view1(fields);
+  if (unknownBase(res))
+    res = view1(fields = withoutBase(fields));
+  if (res.error)
+    throw new Error(`gh: ${res.error.message}`);
+  let checksError;
+  if (res.status !== 0 && FORBIDDEN.test(res.stderr ?? "")) {
+    checksError = reason(res);
+    const retry = view1(fields === PR_VIEW_FIELDS ? PR_VIEW_FIELDS_NO_CHECKS : withoutBase(PR_VIEW_FIELDS_NO_CHECKS));
+    if (retry.error)
+      throw new Error(`gh: ${retry.error.message}`);
+    if (retry.status !== 0) {
+      throw new Error(FORBIDDEN.test(retry.stderr ?? "") ? `${reason(retry)} (fails even without check results)` : reason(retry));
+    }
+    res = retry;
+  }
+  if (res.status !== 0)
+    throw new Error(reason(res));
+  const view = JSON.parse(res.stdout);
+  if (checksError)
+    view.checksError = checksError;
+  if (view.state === "OPEN") {
+    const threads = ghUnresolvedThreads(ref);
+    if (threads !== void 0)
+      view.unresolvedThreads = threads;
+  }
+  return view;
+}
+var THREADS_QUERY = "query($owner:String!,$repo:String!,$n:Int!){repository(owner:$owner,name:$repo){pullRequest(number:$n){reviewThreads(first:100){nodes{isResolved}}}}}";
+function ghUnresolvedThreads(ref) {
+  const res = spawnSync("gh", ["api", "graphql", "-f", `query=${THREADS_QUERY}`, "-f", `owner=${ref.owner}`, "-f", `repo=${ref.repo}`, "-F", `n=${ref.number}`], { encoding: "utf8", timeout: 6e4 });
+  if (res.error || res.status !== 0)
+    return void 0;
+  return parseUnresolvedThreads(res.stdout);
+}
+function parseUnresolvedThreads(stdout) {
+  try {
+    const nodes = JSON.parse(stdout).data?.repository?.pullRequest?.reviewThreads?.nodes;
+    return Array.isArray(nodes) ? nodes.filter((t) => t.isResolved === false).length : void 0;
+  } catch {
+    return void 0;
+  }
+}
 
 // packages/core/dist/prs.js
 import * as fs14 from "node:fs";
@@ -1594,6 +1668,20 @@ import * as path11 from "node:path";
 function prsDir() {
   return path11.join(lobstahHome(), "prs");
 }
+function prRecordFile(key) {
+  const ref = parsePrRef(key);
+  if (!ref)
+    throw new Error(`not a PR key: ${key}`);
+  const safe = (s) => s.replace(/[^A-Za-z0-9._-]/g, "_");
+  return path11.join(prsDir(), `${safe(ref.owner)}__${safe(ref.repo)}__${ref.number}.json`);
+}
+function readPr(key) {
+  try {
+    return JSON.parse(fs14.readFileSync(prRecordFile(key), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
 function readPrs() {
   let files;
   try {
@@ -1655,7 +1743,7 @@ function pushRule(branch, id = "<dispatch id>") {
 import * as fs15 from "node:fs";
 import * as os3 from "node:os";
 import * as path12 from "node:path";
-import { spawnSync } from "node:child_process";
+import { spawnSync as spawnSync2 } 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;
@@ -1717,7 +1805,7 @@ function isUnresumable(error) {
 function worktreeProgress(worktree, trunk) {
   if (!worktree || !fs15.existsSync(worktree))
     return "No worktree progress recorded.";
-  const git2 = (...a) => spawnSync("git", a, { cwd: worktree, encoding: "utf8" }).stdout?.trim() ?? "";
+  const git2 = (...a) => spawnSync2("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:
@@ -1827,7 +1915,7 @@ function isFinished(id, lane) {
 // packages/runner/src/run.ts
 import * as fs19 from "node:fs";
 import * as path16 from "node:path";
-import { execFileSync } from "node:child_process";
+import { execFileSync as execFileSync2 } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/adapters/dist/claude.js
@@ -2346,7 +2434,7 @@ function loadAdapter(name) {
 import * as fs17 from "node:fs";
 import * as path14 from "node:path";
 import { createHash } from "node:crypto";
-import { exec, execFile } from "node:child_process";
+import { exec, execFile, execFileSync } from "node:child_process";
 import { promisify } from "node:util";
 var run = promisify(execFile);
 var shell = promisify(exec);
@@ -2372,7 +2460,12 @@ var LOCK_CONTENTION = [
   // held by another process ("fetching ref <ref> failed: reference already
   // exists"). The files backend maps the lock's EEXIST to this reason; older
   // git printed "Unable to create '<ref>.lock': File exists" instead.
-  /reference already exists/
+  /reference already exists/,
+  // Windows: two fetches unpack the same loose object, and one cannot write
+  // the file the other holds open ("unable to write file
+  // .git/objects/<xx>/<rest>: Permission denied", then "unpack-objects
+  // failed"). Only an object path matches, not any denied write.
+  /unable to write file \S*objects[\\/][0-9a-f]{2}[\\/][0-9a-f]{38,}: Permission denied/
 ];
 function gitStderr(err) {
   const stderr = err.stderr;
@@ -2399,6 +2492,112 @@ ${gitStderr(err)}`, { cause: err });
     }
   }
 }
+var REPO_LOCK_WAIT_MS = 5 * 6e4;
+var repoQueues = /* @__PURE__ */ new Map();
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+var BUSY = /* @__PURE__ */ new Set(["EPERM", "EACCES", "EBUSY"]);
+function takeRepoLock(file, mine) {
+  try {
+    fs17.writeFileSync(file, mine, { flag: "wx" });
+    return { state: "held" };
+  } catch (err) {
+    const code = err.code ?? "";
+    if (code !== "EEXIST" && !BUSY.has(code))
+      throw err;
+  }
+  let raw = "";
+  let age = 0;
+  try {
+    raw = fs17.readFileSync(file, "utf8");
+    age = Date.now() - fs17.statSync(file).mtimeMs;
+  } catch {
+    return { state: "retry" };
+  }
+  let holder;
+  try {
+    holder = JSON.parse(raw);
+  } catch {
+    holder = void 0;
+  }
+  const stale = age > REPO_LOCK_WAIT_MS || (holder ? !pidAlive(holder.pid) : age > 5e3);
+  if (stale) {
+    try {
+      if (fs17.readFileSync(file, "utf8") === raw)
+        fs17.rmSync(file, { force: true });
+    } catch {
+    }
+    return { state: "retry" };
+  }
+  return { state: "wait", ...holder ? { holder: holder.pid } : {} };
+}
+function releaseRepoLock(file, mine) {
+  try {
+    if (fs17.readFileSync(file, "utf8") === mine)
+      fs17.rmSync(file, { force: true, recursive: true, maxRetries: 5 });
+  } catch {
+  }
+}
+async function withRepoLock(common, fn) {
+  const file = path14.join(common, "lobstah-git.lock");
+  const mine = JSON.stringify({ pid: process.pid, at: (/* @__PURE__ */ new Date()).toISOString() });
+  const deadline = Date.now() + REPO_LOCK_WAIT_MS;
+  let held = false;
+  while (Date.now() < deadline) {
+    const took = takeRepoLock(file, mine);
+    if (took.state === "held") {
+      held = true;
+      break;
+    }
+    if (took.state === "wait")
+      await new Promise((r) => setTimeout(r, 50 + Math.random() * 50));
+  }
+  try {
+    await fn();
+  } finally {
+    if (held)
+      releaseRepoLock(file, mine);
+  }
+}
+async function oneAtATime(cwd, fn) {
+  const common = await git(cwd, "rev-parse", "--path-format=absolute", "--git-common-dir");
+  const key = realpath(common);
+  const run2 = (repoQueues.get(key) ?? Promise.resolve()).then(() => withRepoLock(common, () => fn(common)));
+  const tail = run2.catch(() => {
+  });
+  repoQueues.set(key, tail);
+  try {
+    await run2;
+  } finally {
+    if (repoQueues.get(key) === tail)
+      repoQueues.delete(key);
+  }
+}
+function fetchStamps(common) {
+  try {
+    return JSON.parse(fs17.readFileSync(path14.join(common, "lobstah-fetch.json"), "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function fetchShared(cwd, remote, ref) {
+  const asked = Date.now();
+  const key = `${remote} ${ref}`;
+  await oneAtATime(cwd, async (common) => {
+    if ((fetchStamps(common)[key] ?? -Infinity) >= asked)
+      return;
+    const started = Date.now();
+    await gitShared(cwd, "fetch", remote, ref);
+    const stamps = { ...fetchStamps(common), [key]: started };
+    fs17.writeFileSync(path14.join(common, "lobstah-fetch.json"), JSON.stringify(stamps, null, 2));
+  });
+}
 async function allocate(repo, id, fromRemoteBranch = repo.trunk) {
   const dir = worktreePath(id);
   if (fs17.existsSync(dir)) {
@@ -2409,8 +2608,10 @@ async function allocate(repo, id, fromRemoteBranch = repo.trunk) {
       throw new Error(`repo path ${repo.path} missing and no origin configured`);
     await run("git", ["clone", repo.origin, repo.path], { env: process.env });
   }
-  await gitShared(repo.path, "fetch", "origin", fromRemoteBranch);
-  await gitShared(repo.path, "worktree", "add", "--no-track", dir, "-b", `lobstah/${id}`, `origin/${fromRemoteBranch}`);
+  await fetchShared(repo.path, "origin", fromRemoteBranch);
+  await oneAtATime(repo.path, async () => {
+    await gitShared(repo.path, "worktree", "add", "--no-track", dir, "-b", `lobstah/${id}`, `origin/${fromRemoteBranch}`);
+  });
   await runSetup(repo, dir);
   return dir;
 }
@@ -2544,7 +2745,7 @@ async function chooseWorktree(input) {
   return { reuse: true, path: found.path, owner: found.owner, from: found.from };
 }
 async function prepareReuse(repo, dir) {
-  await gitShared(dir, "fetch", "origin", repo.trunk);
+  await fetchShared(dir, "origin", repo.trunk);
   if (!repo.setup?.length)
     return { setupRan: false };
   if (recordedSetupHash(dir) === setupHash(repo, dir))
@@ -2874,6 +3075,7 @@ function planStart(input) {
 function startWallClock(opts) {
   const now2 = opts.now ?? Date.now;
   const tickMs = Math.max(1, Math.min(opts.tickMs ?? 5e3, opts.limitMs));
+  const sleepGapMs = opts.sleepGapMs ?? Math.max(6e4, tickMs * 6);
   let elapsed = opts.initialElapsedMs ?? 0;
   const maxMs = Math.max(opts.limitMs, opts.maxMs ?? opts.limitMs);
   let windowMs = Math.min(maxMs, Math.max(opts.limitMs, opts.initialWindowMs ?? opts.limitMs));
@@ -2887,7 +3089,8 @@ function startWallClock(opts) {
     } catch {
       paused = false;
     }
-    if (!paused) elapsed += t - last;
+    const step = Math.max(0, t - last);
+    if (!paused) elapsed += step > sleepGapMs ? Math.min(step, tickMs) : step;
     last = t;
     if (!done && elapsed >= windowMs && elapsed < maxMs) {
       let advanced = false;
@@ -3094,13 +3297,23 @@ function keepRemote(opts) {
 }
 
 // packages/runner/src/run.ts
+function livePrState(url) {
+  const ref = parsePrRef(url);
+  if (!ref) return void 0;
+  try {
+    return ghPrView(ref).state;
+  } catch {
+    return void 0;
+  }
+}
 var defaultDeps = {
   loadAdapter,
   allocate,
   chooseWorktree,
   prepareReuse,
   collectEvidence,
-  reap: async () => 0
+  reap: async () => 0,
+  prState: livePrState
 };
 var DONE_WAIT_MS = 2e3;
 function within(p, ms, fallback) {
@@ -3141,6 +3354,14 @@ async function main(activeDir, lane, seams = {}) {
     attempts
   };
   fs19.writeFileSync(path16.join(activeDir, "runner.json"), JSON.stringify(runnerInfo, null, 2));
+  if (descriptor.systemRepair && descriptor.pr?.url) {
+    const state = deps.prState(descriptor.pr.url) ?? readPr(parsePrRef(descriptor.pr.url)?.key ?? "")?.state;
+    if (state === "MERGED" || state === "CLOSED") {
+      status("failed", `cancelled: ${descriptor.pr.url} is ${state.toLowerCase()}; nothing to repair`);
+      complete(id, lane);
+      return;
+    }
+  }
   const plan = planStart({
     id,
     lane,
@@ -3240,7 +3461,7 @@ async function main(activeDir, lane, seams = {}) {
   })();
   const head = () => {
     try {
-      return execFileSync("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+      return execFileSync2("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
     } catch {
       return void 0;
     }
@@ -3412,10 +3633,10 @@ async function main(activeDir, lane, seams = {}) {
 }
 
 // packages/runner/src/reap.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
+import { execFileSync as execFileSync3 } from "node:child_process";
 function listProcesses() {
   if (process.platform === "win32") {
-    const out2 = execFileSync2(
+    const out2 = execFileSync3(
       "powershell.exe",
       [
         "-NoProfile",
@@ -3427,7 +3648,7 @@ function listProcesses() {
     );
     return out2.split(/\r?\n/).map((l) => l.trim().split(/\s+/).map(Number)).filter(([pid, ppid]) => Number.isInteger(pid) && Number.isInteger(ppid)).map(([pid, ppid]) => ({ pid, ppid }));
   }
-  const out = execFileSync2("ps", ["-A", "-o", "pid=,ppid=,pgid="], {
+  const out = execFileSync3("ps", ["-A", "-o", "pid=,ppid=,pgid="], {
     encoding: "utf8",
     timeout: 3e4,
     stdio: ["ignore", "pipe", "ignore"]
@@ -3470,7 +3691,7 @@ async function stopPids(pids, graceMs = 2e3) {
   if (process.platform === "win32") {
     for (const pid of pids) {
       try {
-        execFileSync2("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true, timeout: 3e4 });
+        execFileSync3("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true, timeout: 3e4 });
       } catch {
       }
     }

package/docs/harness/claude-code.md

@@ -66,6 +66,8 @@ For the glass's ↗ open button, give the trap its own session link with
 `claude://claude.ai/...` link in the app; copy that link from the session.
 Its app id is not the CLI session id. In the VS Code extension, use
 `vscode://anthropic.claude-code/open?session=<session-id>` with the id above.
+A CLI session in a terminal, including the Claude desktop app's terminal
+panel, passes no link; soak ignores a link that does not fit the session.
 The glass checks the stored link before showing it. `lobstah focus <trap>`
 uses the same focus steps from the terminal.
 

package/docs/harness/codex.md

@@ -124,9 +124,10 @@ Codex task ids are UUIDv7 (for example `01a0ceb8-b9bd-7d42-…`); Claude Code
 session ids are UUIDv4. When both harnesses' variables are set, lobstah uses
 this format to tell which one signed on.
 
-For the glass's ↗ open button, form `codex://threads/<task-id>` from the
-task id in the session-start brief and pass it with
-`lobstah soak --link <url>`. The glass checks the stored link before
+For the glass's ↗ open button in the Codex desktop app, form
+`codex://threads/<task-id>` from the task id in the session-start brief and
+pass it with `lobstah soak --link <url>`. A Codex CLI session in a terminal
+passes no link; soak ignores a link that does not fit the session. The glass checks the stored link before
 showing it. `lobstah focus <trap>` uses the same focus steps from the
 terminal.
 

package/docs/man.md

@@ -462,9 +462,10 @@ the helm files to keep.
   unacked first, up to 8, then "+N more", which opens the Reports tab. A
   report's card or row shows its title, then who filed it (a trap's name, a
   headless dispatch's id, nothing for the helm), its age, and `acked`. A
-  dispatch's report renders as a
-  page at the top of its dispatch modal. A helm report opens in a modal of
-  its own; `#report/<key>` links to it. The page shows headings, lists,
+  report opens on its own page, `/report/<key>`, in a new tab: from its card
+  or row, a lob, the desktop pet, or its dispatch's modal. The page renders
+  once and does not refresh; opening it does not ack the report.
+  `#report/<key>` goes to that page. The page shows headings, lists,
   tables, fenced code, links (in a new tab), bold, italics, and images.
   Raw HTML in the markdown shows as text. The glass serves the markdown and
   the images read-only, and an image only by basename from that report's
@@ -508,7 +509,9 @@ the same rule.
   `attachments/`. The claimed helm alone may ask.
 - **Standing.** A decision stands until it is answered or the helm withdraws
   it with `lobstah man ask --withdraw <key>`, which removes its directory. A
-  newer `man ask` on the same dispatch replaces the older decision.
+  newer `man ask` on the same dispatch keeps the older decisions: each shows
+  as its own card. `lobstah man ask ... --replace <key>` replaces that one
+  standing decision; a key that is not standing is refused.
 - **Attention.** A standing decision is attention of kind `decision`, in
   the default `attentionKinds`. It makes the verdict `needs-attention`. A
   worker's raw `needs-decision` or `blocked` stays a `question` until the
@@ -558,9 +561,11 @@ the same rule.
   [--text <text>] [--attach <file>]...` answers the same way, with the same
   checks.
 - **The pet.** The desktop pet shows a decision as its title only. A click
-  opens the glass at the card and acks the item for the pet
-  (`lobstah attention ack <key> --by pet`). The card stays in the glass until
-  the decision is answered or withdrawn.
+  brings up the live helm's session through the pet's focus ladder: the
+  Claude desktop app for a desktop helm, the exact terminal tab for a terminal
+  helm. With no live helm, it opens the glass at the card. Either way it acks
+  the item for the pet (`lobstah attention ack <key> --by pet`). The card
+  stays in the glass until the decision is answered or withdrawn.
 - **Cull.** `lobstah cull` removes a decision once its answer is older than
   the retention window, with the `decision-answer` request and its files. A
   standing decision is never culled.
@@ -806,7 +811,15 @@ lobstah soak --name amber-gull  # choose or change this trap's two-word name
 a VS Code extension URL of the form
 `vscode://anthropic.claude-code/open?session=<id>`, or a Codex task URL of
 the form `codex://threads/<task-id>`. It rejects all other schemes and
-malformed links. The glass checks a stored link again before rendering it.
+malformed links. A link must also fit the session's surface, taken from
+Claude Code's `CLAUDE_CODE_ENTRYPOINT` and the recorded window: a `vscode://`
+link only in the VS Code extension (`claude-vscode`), a `claude://` link only
+in the Claude desktop app's Code tab, a `codex://` link only in the Codex app.
+A CLI session in a terminal, including the Claude desktop app's terminal
+panel, has no link: soak ignores one and prints `link: ignored — <why>`. The
+glass and `lobstah focus` skip a stored link that contradicts the trap's
+window and focus the window instead. The glass checks a stored link again
+before rendering it.
 `lobstah focus <trap>` accepts the trap id with or without `wt:` and reports
 the focus step or why it could not focus. It does not revive a signed-off trap.
 

package/package.json

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