lazycodex-ai 5.0.0-beta.45 → 5.0.0-beta.47

package/packages/omo-codex/plugin/components/ulw-loop/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // components/ulw-loop/src/checkpoint.ts
-import { existsSync as existsSync4, statSync } from "node:fs";
+import { existsSync as existsSync4, statSync as statSync2 } from "node:fs";
 import { readFile as readFile5 } from "node:fs/promises";
 import { resolve as resolve3 } from "node:path";
 
@@ -123,6 +123,7 @@ var ULW_LOOP_DIR = ".omo/ulw-loop";
 var ULW_LOOP_BRIEF = "brief.md";
 var ULW_LOOP_GOALS = "goals.json";
 var ULW_LOOP_LEDGER = "ledger.jsonl";
+var ULW_LOOP_STATE_LOCK = ".state.lock";
 var ULW_LOOP_STEERING_MUTATION_KINDS = [
   "add_subgoal",
   "split_subgoal",
@@ -195,6 +196,9 @@ function ulwLoopGoalsPath(repoRoot, scope) {
 function ulwLoopLedgerPath(repoRoot, scope) {
   return join(ulwLoopDir(repoRoot, scope), ULW_LOOP_LEDGER);
 }
+function ulwLoopStateLockPath(repoRoot, scope) {
+  return join(ulwLoopDir(repoRoot, scope), ULW_LOOP_STATE_LOCK);
+}
 function repoRelative(absolutePath, repoRoot) {
   const slashPrefix = `${repoRoot}/`;
   const backslashPrefix = `${repoRoot}\\`;
@@ -205,7 +209,10 @@ function repoRelative(absolutePath, repoRoot) {
   return absolutePath.split("\\").join("/");
 }
 function ulwLoopAttemptEvidenceDir(goalId, attempt, scope) {
-  const sessionId = normalizeUlwLoopSessionId(scope?.sessionId) ?? resolveUlwLoopSessionIdFromEnv() ?? "session";
+  const sessionId = normalizeUlwLoopSessionId(scope?.sessionId);
+  if (sessionId === null) {
+    throw new UlwLoopError(`Evidence for ${goalId} attempt ${attempt} needs a session scope; pass --session-id <id> so the attempt directory lives under .omo/evidence/ulw/<id>/.`, "ULW_LOOP_SESSION_SCOPE_REQUIRED", { details: { goalId, attempt } });
+  }
   return `.omo/evidence/ulw/${sessionId}/${goalId}/a${attempt}`;
 }
 var PLATFORM_PATH_API = { relative, isAbsolute, sep };
@@ -418,6 +425,7 @@ ${gateError.message}`, "ULW_LOOP_QUALITY_GATE_INVALID", {
 }
 
 // components/ulw-loop/src/plan-io.ts
+import { AsyncLocalStorage } from "node:async_hooks";
 import { createReadStream, readdirSync } from "node:fs";
 import { appendFile, mkdir, readFile as readFile3, rename, writeFile } from "node:fs/promises";
 import { createInterface } from "node:readline";
@@ -433,6 +441,17 @@ function planMissingRecovery(existingSessionIds) {
   return { message: lines.join(`
 `), details: { existingSessionIds } };
 }
+function sessionScopeRequiredMessage(flag, existingSessionIds) {
+  const lines = [
+    "No ulw-loop session scope: neither the session env (OMO_ULW_LOOP_SESSION_ID / CODEX_SESSION_ID / CODEX_THREAD_ID / PI_SESSION_ID) nor the flag names this run, and the shared .omo/ulw-loop root is never used implicitly because every session in this directory would read and overwrite it.",
+    `Recovery: pass the scope explicitly: \`${flag} <id>\` (subprocess, eval, and hook contexts do not inherit the session env).`
+  ];
+  if (existingSessionIds.length > 0) {
+    lines.push(`Existing ulw-loop session ids under .omo/ulw-loop/: ${existingSessionIds.join(", ")}.`);
+  }
+  return lines.join(`
+`);
+}
 function sessionIdRequiredMessage(flag) {
   return [
     `${flag} requires a non-empty value.`,
@@ -442,11 +461,205 @@ function sessionIdRequiredMessage(flag) {
 `);
 }
 
+// components/ulw-loop/src/state-lock.ts
+import { randomUUID } from "node:crypto";
+import { closeSync, mkdirSync, openSync, readFileSync, statSync, unlinkSync, writeSync } from "node:fs";
+import { dirname } from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
+var ULW_LOOP_LOCK_TIMEOUT_CODE = "ULW_LOOP_LOCK_TIMEOUT";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_STALE_MS = 60000;
+var MIN_DELAY_MS = 5;
+var MAX_DELAY_MS = 100;
+var SLEEP_CELL = new Int32Array(new SharedArrayBuffer(4));
+async function withStateLock(lockPath, fn, options = {}) {
+  const token = await acquireAsync(lockPath, options);
+  try {
+    return await fn();
+  } finally {
+    release(lockPath, token);
+  }
+}
+function withStateLockSync(lockPath, fn, options = {}) {
+  const token = acquireSync(lockPath, options);
+  try {
+    return fn();
+  } finally {
+    release(lockPath, token);
+  }
+}
+function isStateLockTimeout(error) {
+  return error instanceof UlwLoopError && error.code === ULW_LOOP_LOCK_TIMEOUT_CODE;
+}
+async function acquireAsync(lockPath, options) {
+  const deadline = Date.now() + (options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  const staleMs = options.staleMs ?? DEFAULT_STALE_MS;
+  mkdirSync(dirname(lockPath), { recursive: true });
+  for (let attempt = 0;; ) {
+    const outcome = attemptOnce(lockPath, staleMs);
+    if (outcome.kind === "acquired")
+      return outcome.token;
+    if (outcome.kind === "retry")
+      continue;
+    if (Date.now() >= deadline)
+      throw lockTimeout(lockPath, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    await sleep(backoffMs(attempt));
+    attempt += 1;
+  }
+}
+function acquireSync(lockPath, options) {
+  const deadline = Date.now() + (options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  const staleMs = options.staleMs ?? DEFAULT_STALE_MS;
+  mkdirSync(dirname(lockPath), { recursive: true });
+  for (let attempt = 0;; ) {
+    const outcome = attemptOnce(lockPath, staleMs);
+    if (outcome.kind === "acquired")
+      return outcome.token;
+    if (outcome.kind === "retry")
+      continue;
+    if (Date.now() >= deadline)
+      throw lockTimeout(lockPath, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    Atomics.wait(SLEEP_CELL, 0, 0, backoffMs(attempt));
+    attempt += 1;
+  }
+}
+function attemptOnce(lockPath, staleMs) {
+  try {
+    const token = tryCreate(lockPath);
+    if (token !== null)
+      return { kind: "acquired", token };
+    const snapshot = readSnapshot(lockPath);
+    if (snapshot === null)
+      return { kind: "retry" };
+    if (isStale(snapshot, staleMs) && reclaim(lockPath, snapshot.raw))
+      return { kind: "retry" };
+    return { kind: "wait" };
+  } catch (error) {
+    if (hasCode(error, "EINTR"))
+      return { kind: "wait" };
+    throw error;
+  }
+}
+function tryCreate(lockPath) {
+  let fd;
+  try {
+    fd = openSync(lockPath, "wx");
+  } catch (error) {
+    if (hasCode(error, "EEXIST"))
+      return null;
+    throw error;
+  }
+  const record = { pid: process.pid, createdAt: new Date().toISOString(), token: randomUUID() };
+  try {
+    writeSync(fd, JSON.stringify(record));
+  } catch (error) {
+    closeSync(fd);
+    try {
+      unlinkSync(lockPath);
+    } catch {}
+    throw error;
+  }
+  closeSync(fd);
+  return record.token;
+}
+function readSnapshot(lockPath) {
+  try {
+    const raw = readFileSync(lockPath, "utf8");
+    const ageMs = Date.now() - statSync(lockPath).mtimeMs;
+    return { raw, record: parseRecord(raw), ageMs };
+  } catch (error) {
+    if (hasCode(error, "ENOENT"))
+      return null;
+    throw error;
+  }
+}
+function parseRecord(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null)
+      return null;
+    const record = parsed;
+    const pid = record["pid"];
+    const createdAt = record["createdAt"];
+    const token = record["token"];
+    if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0 || typeof createdAt !== "string")
+      return null;
+    if (typeof token !== "string" || token.length === 0)
+      return null;
+    return { pid, createdAt, token };
+  } catch (error) {
+    if (error instanceof SyntaxError)
+      return null;
+    throw error;
+  }
+}
+function isStale(snapshot, staleMs) {
+  if (snapshot.record === null)
+    return snapshot.ageMs > staleMs;
+  return !isProcessAlive(snapshot.record.pid);
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (hasCode(error, "ESRCH"))
+      return false;
+    if (hasCode(error, "EPERM"))
+      return true;
+    throw error;
+  }
+}
+function reclaim(lockPath, expectedRaw) {
+  const current = readSnapshot(lockPath);
+  if (current === null)
+    return true;
+  if (current.raw !== expectedRaw)
+    return false;
+  try {
+    unlinkSync(lockPath);
+  } catch (error) {
+    if (!hasCode(error, "ENOENT"))
+      throw error;
+  }
+  return true;
+}
+function release(lockPath, token) {
+  const current = readSnapshot(lockPath);
+  if (current === null || current.record?.token !== token)
+    return;
+  try {
+    unlinkSync(lockPath);
+  } catch (error) {
+    if (!hasCode(error, "ENOENT"))
+      throw error;
+  }
+}
+function backoffMs(attempt) {
+  const exponential = Math.min(MAX_DELAY_MS, MIN_DELAY_MS * 2 ** attempt);
+  return exponential + Math.random() * MIN_DELAY_MS;
+}
+function lockTimeout(lockPath, timeoutMs) {
+  const holder = readSnapshot(lockPath)?.record;
+  const owner = holder === undefined || holder === null ? "another process" : `pid ${holder.pid}`;
+  return new UlwLoopError(`ulw-loop state lock ${lockPath} is held by ${owner} for more than ${timeoutMs}ms; retry once that process finishes, or delete the lock file if that process is gone.`, ULW_LOOP_LOCK_TIMEOUT_CODE, {
+    details: {
+      lockPath,
+      timeoutMs,
+      ...holder === undefined || holder === null ? {} : { holderPid: holder.pid }
+    }
+  });
+}
+function hasCode(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+
 // components/ulw-loop/src/plan-io.ts
 var LEGACY_OBJECTIVE_PREFIX = `Complete all ulw-loop stories in ${ULW_LOOP_DIR}/${ULW_LOOP_GOALS}: `;
 var LEGACY_OBJECTIVE = `Complete all ulw-loop stories listed in ${ULW_LOOP_DIR}/${ULW_LOOP_GOALS}. Use ${ULW_LOOP_DIR}/${ULW_LOOP_LEDGER} as the durable audit trail.`;
 var locks = new Map;
-function hasCode(error, code) {
+var heldLocks = new AsyncLocalStorage;
+function hasCode2(error, code) {
   return error instanceof Error && "code" in error && error.code === code;
 }
 function isLegacyEnumeratedAggregateObjective(objective) {
@@ -461,8 +674,10 @@ async function withUlwLoopMutationLock(repoRoot, scopeOrFn, maybeFn) {
   if (fn === undefined)
     throw new UlwLoopError("Missing ulw-loop mutation body.", "ULW_LOOP_LOCK_BODY_MISSING");
   const lockKey = `${repoRoot}\x00${ulwLoopRelativeDir(scope)}`;
+  const lockPath = ulwLoopStateLockPath(repoRoot, scope);
+  const locked = () => withStateLock(lockPath, () => heldLocks.run(new Set([...heldLocks.getStore() ?? [], lockKey]), fn));
   const prior = locks.get(lockKey) ?? Promise.resolve(undefined);
-  const run = prior.then(fn, fn);
+  const run = prior.then(locked, locked);
   const gate = run.then(() => {
     return;
   }, () => {
@@ -481,9 +696,9 @@ async function readUlwLoopPlan(repoRoot, scope) {
   try {
     raw = await readFile3(path, "utf8");
   } catch (error) {
-    if (!hasCode(error, "ENOENT"))
+    if (!hasCode2(error, "ENOENT"))
       throw error;
-    const recovery = planMissingRecovery(readSessionDirs(repoRoot));
+    const recovery = planMissingRecovery(listUlwLoopSessionIds(repoRoot));
     throw new UlwLoopError(`No ulw-loop plan found at ${repoRelative(path, repoRoot)}.
 ${recovery.message}`, "ULW_LOOP_PLAN_MISSING", { cause: error, ...recovery.details === undefined ? {} : { details: recovery.details } });
   }
@@ -493,6 +708,9 @@ ${recovery.message}`, "ULW_LOOP_PLAN_MISSING", { cause: error, ...recovery.detai
   }
   const previousObjective = parsed.codexObjective;
   if ((parsed.codexGoalMode ?? "per_story") === "aggregate" && isLegacyEnumeratedAggregateObjective(previousObjective)) {
+    if (!(heldLocks.getStore()?.has(`${repoRoot}\x00${ulwLoopRelativeDir(scope)}`) ?? false)) {
+      throw new UlwLoopError(`The ulw-loop plan at ${repoRelative(path, repoRoot)} carries a legacy enumerated aggregate objective that must be migrated before reads continue. Run any state-mutating ulw-loop command once (e.g. \`record-evidence\`, \`steer\`, \`checkpoint\`) to migrate it under the state lock, then retry.`, "ULW_LOOP_MIGRATION_REQUIRED");
+    }
     const now = iso();
     parsed.codexObjective = aggregateCodexObjectiveForScope(scope);
     parsed.codexObjectiveAliases = [...new Set([...parsed.codexObjectiveAliases ?? [], previousObjective])];
@@ -508,7 +726,7 @@ ${recovery.message}`, "ULW_LOOP_PLAN_MISSING", { cause: error, ...recovery.detai
   }
   return parsed;
 }
-function readSessionDirs(repoRoot) {
+function listUlwLoopSessionIds(repoRoot) {
   try {
     return readdirSync(ulwLoopDir(repoRoot), { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
   } catch {
@@ -543,7 +761,7 @@ async function* ledgerLines(repoRoot, scope) {
         yield line;
     }
   } catch (error) {
-    if (!hasCode(error, "ENOENT"))
+    if (!hasCode2(error, "ENOENT"))
       throw error;
   } finally {
     lines.close();
@@ -895,8 +1113,8 @@ function adversarialVerdict(row, field) {
 }
 
 // components/ulw-loop/src/surface.ts
-import { existsSync as existsSync3, readFileSync } from "node:fs";
-import { dirname, join as join2 } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
 import { fileURLToPath } from "node:url";
 var REVIEWER_ROLES_BY_SURFACE = {
   lazycodex: {
@@ -935,7 +1153,7 @@ function resolveToolkitSurface(options) {
   const fromEnv = parseSurface(env[SURFACE_ENV_KEY]);
   if (fromEnv !== null)
     return fromEnv;
-  const entryDir = options?.entryDir ?? dirname(fileURLToPath(import.meta.url));
+  const entryDir = options?.entryDir ?? dirname2(fileURLToPath(import.meta.url));
   const markerPath = join2(entryDir, SURFACE_MARKER_FILENAME);
   return readMarkerSurface(markerPath) ?? "lazycodex";
 }
@@ -943,7 +1161,7 @@ function readMarkerSurface(markerPath) {
   try {
     if (!existsSync3(markerPath))
       return null;
-    const parsed = JSON.parse(readFileSync(markerPath, "utf8"));
+    const parsed = JSON.parse(readFileSync2(markerPath, "utf8"));
     return parseSurface(parsed["surface"]);
   } catch (error) {
     if (error instanceof Error)
@@ -1356,7 +1574,7 @@ function fail(message, code = "ULW_LOOP_VALIDATION_BATCH_INVALID") {
 }
 
 // components/ulw-loop/src/checkpoint.ts
-var QUALITY_GATE_FS = { existsSync: existsSync4, statSync };
+var QUALITY_GATE_FS = { existsSync: existsSync4, statSync: statSync2 };
 function ulwLoopFail2(message, code) {
   throw new UlwLoopError(message, code);
 }
@@ -1659,7 +1877,7 @@ var ULW_LOOP_HELP = `Usage:
   omo-agent-toolkit ulw-loop add-goal --title "..." --objective "..." [--json]
   omo-agent-toolkit ulw-loop record-review-blockers --goal-id <id> --title "..." --objective "..." --evidence "..." --codex-goal-json <...> [--json]
 
-All subcommands accept [--session-id <id>] to isolate state under .omo/ulw-loop/<id>/; without it, Codex session env is used when present.
+Every state subcommand needs a session scope: [--session-id <id>] or the session env (OMO_ULW_LOOP_SESSION_ID / CODEX_SESSION_ID / CODEX_THREAD_ID / PI_SESSION_ID); state lives under .omo/ulw-loop/<id>/ and the unscoped root is never used implicitly.
 Every subcommand accepts --help | -h to print its own usage line.`;
 function subcommandHelp(subcommand) {
   const lines = ULW_LOOP_HELP.split(`
@@ -3171,7 +3389,6 @@ async function ulwLoopCommand(argv) {
   const repoRoot = process.cwd();
   const json = hasFlag(rest, "--json");
   try {
-    const scope = commandScope(rest);
     if (!isUlwLoopSubcommand(command)) {
       if (json) {
         printJsonError(new UlwLoopError(`Unknown ulw-loop subcommand: ${command}.`, "ULW_LOOP_SUBCOMMAND_UNKNOWN", {
@@ -3188,11 +3405,13 @@ async function ulwLoopCommand(argv) {
 `);
       return 0;
     }
-    switch (command) {
-      case "help":
-        process.stdout.write(`${ULW_LOOP_HELP}
+    if (command === "help") {
+      process.stdout.write(`${ULW_LOOP_HELP}
 `);
-        return 0;
+      return 0;
+    }
+    const scope = commandScope(repoRoot, rest);
+    switch (command) {
       case "create-goals":
         return await createGoals(repoRoot, rest, json, scope);
       case "status":
@@ -3238,7 +3457,7 @@ var SESSION_ID_FLAG = "--session-id";
 function sessionIdFlagPresent(argv) {
   return hasFlag(argv, SESSION_ID_FLAG) || argv.some((arg) => arg.startsWith(`${SESSION_ID_FLAG}=`));
 }
-function commandScope(argv) {
+function commandScope(repoRoot, argv) {
   if (sessionIdFlagPresent(argv)) {
     const sessionId2 = readValue(argv, SESSION_ID_FLAG)?.trim();
     if (!sessionId2) {
@@ -3249,14 +3468,17 @@ function commandScope(argv) {
     return { sessionId: sessionId2 };
   }
   const sessionId = resolveUlwLoopSessionIdFromEnv();
-  return sessionId === null ? undefined : { sessionId };
+  if (sessionId !== null)
+    return { sessionId };
+  const existingSessionIds = listUlwLoopSessionIds(repoRoot);
+  throw new UlwLoopError(sessionScopeRequiredMessage(SESSION_ID_FLAG, existingSessionIds), "ULW_LOOP_SESSION_SCOPE_REQUIRED", { details: { flag: SESSION_ID_FLAG, existingSessionIds } });
 }
 
 // components/ulw-loop/src/ultrawork-directive.ts
-import { readFileSync as readFileSync3 } from "node:fs";
+import { readFileSync as readFileSync4 } from "node:fs";
 
 // components/ulw-loop/src/ultrawork-skill-pointer.ts
-import { existsSync as existsSync6, readFileSync as readFileSync2 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var ULTRAWORK_SKILL_POINTER_TEMPLATE = `<ultrawork-mode>
 ULTRAWORK MODE IS ACTIVE FOR THIS TASK.
@@ -3288,7 +3510,7 @@ Do not start the requested work until all three steps are complete.
 `;
 var ULTRAWORK_SKILL_PATH_PLACEHOLDER = "{{ULTRAWORK_SKILL_PATH}}";
 var ULTRAWORK_SKILL_FILE_URL = new URL("../../../skills/ultrawork/SKILL.md", import.meta.url);
-var ULTRAWORK_DIRECTIVE = readFileSync2(new URL("../directive.md", import.meta.url), "utf8");
+var ULTRAWORK_DIRECTIVE = readFileSync3(new URL("../directive.md", import.meta.url), "utf8");
 function resolveUltraworkSkillFilePath() {
   return fileURLToPath2(ULTRAWORK_SKILL_FILE_URL);
 }
@@ -3351,7 +3573,7 @@ function hasUltraworkDirectiveAlreadyInTranscript(transcriptPath) {
   return false;
 }
 function readTranscriptTail(transcriptPath) {
-  const rawTranscript = readFileSync3(transcriptPath);
+  const rawTranscript = readFileSync4(transcriptPath);
   return rawTranscript.subarray(Math.max(0, rawTranscript.byteLength - TRANSCRIPT_SEARCH_BYTES)).toString("utf8");
 }
 function isUltraworkPrompt(prompt) {
@@ -3545,18 +3767,8 @@ function readAll(stdin) {
 
 // components/ulw-loop/src/spawn-guard.ts
 import { randomBytes } from "node:crypto";
-import {
-  existsSync as existsSync7,
-  mkdirSync,
-  openSync,
-  readdirSync as readdirSync2,
-  readFileSync as readFileSync4,
-  renameSync,
-  statSync as statSync2,
-  unlinkSync,
-  writeFileSync
-} from "node:fs";
-import { dirname as dirname2, join as join3 } from "node:path";
+import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync5, renameSync, statSync as statSync3, writeFileSync } from "node:fs";
+import { dirname as dirname3, join as join3 } from "node:path";
 var SPAWN_TOOL_TOKENS = new Set(["spawn_agent", "collaborationspawn_agent", "collaboration.spawn_agent"]);
 var DEFAULT_FANOUT_LIMIT = 60;
 var DEFAULT_REVIEW_SPAWN_LIMIT = 3;
@@ -3567,13 +3779,24 @@ var REVIEW_AGENT_TYPES = [
   ...Object.values(REVIEWER_ROLES_BY_SURFACE).map((roles) => roles.manualQa)
 ];
 var REVIEW_AGENT_TYPE_SET = new Set(REVIEW_AGENT_TYPES);
-function applySpawnGuards(payload) {
+function applySpawnGuards(payload, options = {}) {
   if (payload.hook_event_name !== "PreToolUse" || !SPAWN_TOOL_TOKENS.has(payload.tool_name))
     return "";
-  const stateDir = ulwLoopDir(payload.cwd, { sessionId: payload.session_id });
+  const scope = { sessionId: payload.session_id };
+  const stateDir = ulwLoopDir(payload.cwd, scope);
   const plan = readPlan(join3(stateDir, "goals.json"));
   if (plan === null)
     return "";
+  const lockOptions = options.lockTimeoutMs === undefined ? {} : { timeoutMs: options.lockTimeoutMs };
+  try {
+    return withStateLockSync(ulwLoopStateLockPath(payload.cwd, scope), () => evaluateGuards(payload, plan, stateDir), lockOptions);
+  } catch (error) {
+    if (isStateLockTimeout(error))
+      return deny(`ulw-loop spawn guard could not take the session state lock: ${error.message}`);
+    throw error;
+  }
+}
+function evaluateGuards(payload, plan, stateDir) {
   const fanOutPeek = peekFanOutBudget(stateDir);
   if (fanOutPeek !== null)
     return deny(fanOutPeek);
@@ -3629,18 +3852,15 @@ function consumeReviewSpawnBudget(payload, plan, stateDir) {
   if (goal3 === undefined)
     return null;
   const counterPath = join3(stateDir, "review-spawn-counts.json");
-  const lockPath = `${counterPath}.lock`;
   const limit = reviewSpawnLimit();
-  return withExclusiveLock(lockPath, () => {
-    const counts = readCounts(counterPath);
-    const key = `${agentType}:${goal3.id}:a${goal3.attempt}`;
-    const count = (counts[key] ?? 0) + 1;
-    if (count > limit)
-      return `ulw-loop reviewer no-progress cap reached (${agentType} ${count}/${limit}) for ${goal3.id} attempt ${goal3.attempt}. Consolidate existing review findings, or checkpoint and start a new attempt after concrete progress.`;
-    counts[key] = count;
-    atomicWriteJson(counterPath, counts);
-    return null;
-  });
+  const counts = readCounts(counterPath);
+  const key = `${agentType}:${goal3.id}:a${goal3.attempt}`;
+  const count = (counts[key] ?? 0) + 1;
+  if (count > limit)
+    return `ulw-loop reviewer no-progress cap reached (${agentType} ${count}/${limit}) for ${goal3.id} attempt ${goal3.attempt}. Consolidate existing review findings, or checkpoint and start a new attempt after concrete progress.`;
+  counts[key] = count;
+  atomicWriteJson(counterPath, counts);
+  return null;
 }
 function missingGateArtifact(payload, plan) {
   if (!isGateReviewerSpawn(payload.tool_input))
@@ -3718,40 +3938,8 @@ function activeSurfaceReviewerAlias(reviewer) {
   }
   return reviewer;
 }
-function withExclusiveLock(lockPath, fn) {
-  mkdirSync(dirname2(lockPath), { recursive: true });
-  const maxAttempts = 10;
-  const baseDelayMs = 10;
-  for (let attempt = 0;attempt < maxAttempts; attempt++) {
-    let fd = null;
-    try {
-      fd = openSync(lockPath, "wx");
-      writeFileSync(fd, process.pid.toString());
-      try {
-        return fn();
-      } finally {
-        try {
-          unlinkSync(lockPath);
-        } catch {}
-      }
-    } catch (error) {
-      if (fd !== null) {
-        try {
-          unlinkSync(lockPath);
-        } catch {}
-      }
-      if (error.code !== "EEXIST") {
-        return fn();
-      }
-      const delayMs = baseDelayMs * 2 ** attempt + Math.random() * baseDelayMs;
-      const deadline = Date.now() + delayMs;
-      while (Date.now() < deadline) {}
-    }
-  }
-  return fn();
-}
 function atomicWriteJson(targetPath, data) {
-  const tmp = join3(dirname2(targetPath), `.tmp-${randomBytes(6).toString("hex")}`);
+  const tmp = join3(dirname3(targetPath), `.tmp-${randomBytes(6).toString("hex")}`);
   writeFileSync(tmp, JSON.stringify(data));
   renameSync(tmp, targetPath);
 }
@@ -3782,7 +3970,7 @@ function reviewSpawnLimit() {
 }
 function isNonEmptyFile(path) {
   try {
-    return existsSync7(path) && statSync2(path).size > 0;
+    return existsSync7(path) && statSync3(path).size > 0;
   } catch (error) {
     if (error instanceof Error)
       return false;
@@ -3800,7 +3988,7 @@ function hasOtherEvidenceFile(evidenceDir, excludedName) {
 }
 function readCount(counterPath) {
   try {
-    const parsed = JSON.parse(readFileSync4(counterPath, "utf8"));
+    const parsed = JSON.parse(readFileSync5(counterPath, "utf8"));
     return typeof parsed["count"] === "number" && parsed["count"] >= 0 ? parsed["count"] : 0;
   } catch (error) {
     if (error instanceof Error)
@@ -3810,7 +3998,7 @@ function readCount(counterPath) {
 }
 function readCounts(counterPath) {
   try {
-    const parsed = JSON.parse(readFileSync4(counterPath, "utf8"));
+    const parsed = JSON.parse(readFileSync5(counterPath, "utf8"));
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
       return {};
     const counts = {};
@@ -3827,7 +4015,7 @@ function readCounts(counterPath) {
 }
 function readPlan(goalsPath) {
   try {
-    return JSON.parse(readFileSync4(goalsPath, "utf8"));
+    return JSON.parse(readFileSync5(goalsPath, "utf8"));
   } catch (error) {
     if (error instanceof Error)
       return null;
@@ -3836,7 +4024,7 @@ function readPlan(goalsPath) {
 }
 
 // components/ulw-loop/src/stop-resume-hook.ts
-import { existsSync as existsSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "node:fs";
 import { isAbsolute as isAbsolute2, join as join4, resolve as resolve4, sep as sep2 } from "node:path";
 var RESUME_CAP = 2;
 var CONTEXT_PRESSURE_MARKERS2 = [
@@ -3856,14 +4044,15 @@ function runStopResumeHook(input) {
     return "";
   if (boulderContinuationWillFire(payload.cwd, payload.session_id))
     return "";
-  const stateDir = ulwLoopDir(payload.cwd, { sessionId: payload.session_id });
+  const scope = { sessionId: payload.session_id };
+  const stateDir = ulwLoopDir(payload.cwd, scope);
   const plan = readPlan2(join4(stateDir, "goals.json"));
   if (plan === null || plan.aggregateCompletion?.status === "complete")
     return "";
   const goal3 = resumableGoal(plan);
   if (goal3 === undefined)
     return "";
-  if (!consumeResumeBudget(stateDir, goal3.id))
+  if (!consumeResumeBudgetLocked(ulwLoopStateLockPath(payload.cwd, scope), stateDir, goal3.id))
     return "";
   const output = {
     decision: "block",
@@ -3893,6 +4082,15 @@ function resumableGoal(plan) {
 function isResumableStatus(status2) {
   return status2 === "pending" || status2 === "in_progress";
 }
+function consumeResumeBudgetLocked(lockPath, stateDir, goalId) {
+  try {
+    return withStateLockSync(lockPath, () => consumeResumeBudget(stateDir, goalId));
+  } catch (error) {
+    if (isStateLockTimeout(error))
+      return false;
+    throw error;
+  }
+}
 function consumeResumeBudget(stateDir, goalId) {
   const ledgerLineCount = countLedgerLines(join4(stateDir, "ledger.jsonl"));
   const counterPath = resolve4(stateDir, `auto-resume-${goalId}.json`);
@@ -3927,7 +4125,7 @@ function renderResumeDirective(plan, goal3, sessionId) {
 }
 function readPlan2(goalsPath) {
   try {
-    return JSON.parse(readFileSync5(goalsPath, "utf8"));
+    return JSON.parse(readFileSync6(goalsPath, "utf8"));
   } catch (error) {
     if (error instanceof Error)
       return null;
@@ -3936,7 +4134,7 @@ function readPlan2(goalsPath) {
 }
 function countLedgerLines(ledgerPath) {
   try {
-    return readFileSync5(ledgerPath, "utf8").split(`
+    return readFileSync6(ledgerPath, "utf8").split(`
 `).filter(Boolean).length;
   } catch (error) {
     if (error instanceof Error)
@@ -3948,7 +4146,7 @@ function readCounter(counterPath) {
   try {
     if (!existsSync8(counterPath))
       return null;
-    const parsed = JSON.parse(readFileSync5(counterPath, "utf8"));
+    const parsed = JSON.parse(readFileSync6(counterPath, "utf8"));
     if (typeof parsed["count"] !== "number" || typeof parsed["ledgerLineCount"] !== "number")
       return null;
     return { count: parsed["count"], ledgerLineCount: parsed["ledgerLineCount"] };
@@ -3960,7 +4158,7 @@ function readCounter(counterPath) {
 }
 function boulderContinuationWillFire(cwd, sessionId) {
   try {
-    const raw = JSON.parse(readFileSync5(join4(cwd, ".omo", "boulder.json"), "utf8"));
+    const raw = JSON.parse(readFileSync6(join4(cwd, ".omo", "boulder.json"), "utf8"));
     const works = raw["works"];
     const entries = typeof works === "object" && works !== null ? Object.values(works) : [raw];
     return entries.some((work) => {
@@ -3979,7 +4177,7 @@ function boulderContinuationWillFire(cwd, sessionId) {
 }
 function transcriptShowsContextPressure(transcriptPath) {
   try {
-    const transcript = readFileSync5(transcriptPath, "utf8").toLowerCase();
+    const transcript = readFileSync6(transcriptPath, "utf8").toLowerCase();
     return CONTEXT_PRESSURE_MARKERS2.some((marker) => transcript.includes(marker));
   } catch (error) {
     if (error instanceof Error)
@@ -3996,7 +4194,7 @@ function boulderPlanHasChecklist(cwd, entry) {
   const candidates = typeof worktree === "string" && worktree.trim().length > 0 && !isAbsolute2(activePlan) ? [join4(isAbsolute2(worktree) ? worktree : join4(cwd, worktree), activePlan), planPath] : [planPath];
   for (const candidate of candidates) {
     try {
-      return readFileSync5(candidate, "utf8").split(/\r?\n/).some((line) => line.startsWith("- [ ] ") || line.startsWith("- [x] ") || line.startsWith("- [X] "));
+      return readFileSync6(candidate, "utf8").split(/\r?\n/).some((line) => line.startsWith("- [ ] ") || line.startsWith("- [x] ") || line.startsWith("- [X] "));
     } catch (error) {
       if (!(error instanceof Error))
         throw error;