opencode-swarm 7.199.4 → 7.199.6

package/dist/cli/{index-hxav7nr0.js → index-cyp3r8ar.js}

@@ -1,10 +1,7 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-820pzqd6.js";
-import {
-  bunWrite
-} from "./index-2s7dvzff.js";
+} from "./index-b3ws03kp.js";
 import {
   MAX_COORDINATION_STATE_LIST_ROWS,
   acquireCoordinationLease,
@@ -13,55 +10,1410 @@ import {
   deleteCoordinationStateWithinTransaction,
   getCoordinationLease,
   getCoordinationState,
+  getCoordinationStateRaw,
   importCoordinationOnce,
   listCoordinationStates,
   releaseCoordinationLease,
   transitionCoordinationState,
   withCoordinationTransaction
-} from "./index-nr1pj3hy.js";
+} from "./index-9y6yk1n0.js";
 import {
   getProjectDb,
   projectDbExists
-} from "./index-w00dj8p5.js";
+} from "./index-snx2vb1x.js";
+import {
+  appendCoreEventSync
+} from "./index-3mzc5rqc.js";
 import {
   observeDelegationLedgerPressure
-} from "./index-hc6wa3yg.js";
+} from "./index-zbygz217.js";
 import {
   EvidenceLockTimeoutError,
   withEvidenceLock
-} from "./index-4s6kdsfr.js";
+} from "./index-dz15f98h.js";
 import {
   telemetry
-} from "./index-6dtt0brw.js";
+} from "./index-dtwj4hsk.js";
 import {
   canonicalRootKeyFresh,
   sameProjectRoot
-} from "./index-fzpt2djt.js";
+} from "./index-te9hq2f4.js";
 import {
-  exports_external,
-  init_zod
-} from "./index-gknz3bv1.js";
+  bunWrite,
+  init_bun_compat
+} from "./index-qbxk2rn6.js";
 import {
   criticalWarn,
   init_logger,
   warn
 } from "./index-zgwm4ryv.js";
+import {
+  exports_external,
+  init_zod
+} from "./index-gknz3bv1.js";
 import {
   __require
 } from "./index-a76rekgs.js";
 
-// src/background/pending-delegations.ts
+// src/background/pending-delegations.ts
+init_zod();
+import { createHash as createHash5 } from "crypto";
+import * as fs3 from "fs";
+import * as path4 from "path";
+import { isDeepStrictEqual } from "util";
+
+// src/pr-review/persistence.ts
+import { createHash, randomUUID } from "crypto";
+import * as fsp from "fs/promises";
+import * as path from "path";
+function normalizeSessionID(sessionID) {
+  const normalized = sessionID.trim();
+  if (!normalized) {
+    throw new Error("BLOCKED: PR workflow gate requires a non-empty sessionID");
+  }
+  return normalized;
+}
+function prWorkflowSessionFileStem(sessionID) {
+  const normalized = normalizeSessionID(sessionID);
+  const slug = normalized.replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 80) || "session";
+  const digest = createHash("sha256").update(normalized).digest("hex").slice(0, 12);
+  return `${slug}-${digest}`;
+}
+var WORKFLOW_GATE_DIR = "pr-workflow-gates";
+var WORKFLOW_STATE_COORDINATION_PREFIX = "pr-workflow.state";
+var WORKFLOW_STATE_ENTITY_KEY = "state";
+function workflowGateStateRelativePath(sessionID) {
+  return path.join(WORKFLOW_GATE_DIR, `${prWorkflowSessionFileStem(sessionID)}.json`);
+}
+function workflowGateStateLockRelativePath(sessionID) {
+  return path.join(WORKFLOW_GATE_DIR, `${prWorkflowSessionFileStem(sessionID)}.lock`);
+}
+function workflowCheckoutMutationLockRelativePath() {
+  return path.join(WORKFLOW_GATE_DIR, "checkout.lock");
+}
+function workflowGateStatePath(directory, sessionID) {
+  return validateSwarmPath(directory, workflowGateStateRelativePath(sessionID));
+}
+function workflowGateStateImportedPath(directory, sessionID) {
+  return `${workflowGateStatePath(directory, sessionID)}.imported`;
+}
+function workflowGateStateProjectionMarkerPath(directory, sessionID) {
+  return `${workflowGateStatePath(directory, sessionID)}.sqlite-projection`;
+}
+function workflowGateStateCoordinationNamespace(sessionID) {
+  return `${WORKFLOW_STATE_COORDINATION_PREFIX}:${prWorkflowSessionFileStem(sessionID)}`;
+}
+function workflowGateStateLockPath(directory, sessionID) {
+  return validateSwarmPath(directory, workflowGateStateLockRelativePath(sessionID));
+}
+function workflowCheckoutMutationLockPath(directory) {
+  return validateSwarmPath(directory, workflowCheckoutMutationLockRelativePath());
+}
+var MAX_TRACKED_SESSIONS = 200;
+var MAX_COMPLETED_CHECKOUT_LOCK_OWNERS = 64;
+var WINDOWS_RENAME_MAX_RETRIES = 3;
+var RENAME_RETRY_DELAY_MS = 10;
+var STATE_MUTATION_LOCK_MAX_ATTEMPTS = 50;
+var STATE_MUTATION_LOCK_RETRY_DELAY_MS = 10;
+var STATE_MUTATION_LOCK_UNINITIALIZED_STALE_MS = 30000;
+var CHECKOUT_MUTATION_ACTION_TIMEOUT_MS = 5 * 60000;
+var MAX_COORDINATION_PAYLOAD_CHARS = 1048576;
+var trackedStatesByProjectSession = new Map;
+var pendingStateMutationsByProjectSession = new Map;
+var pendingCheckoutMutationsByProject = new Map;
+var completedCheckoutLockOwners = new Map;
+function isoNow() {
+  return new Date().toISOString();
+}
+function delay(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function sameBigIntFileIdentity(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
+function normalizeComparableFsPath(value) {
+  const normalized = path.normalize(path.resolve(value));
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function stateCacheKey(directory, sessionID) {
+  return `${canonicalRootKeyFresh(directory)}\x00${normalizeSessionID(sessionID)}`;
+}
+function rememberState(directory, state) {
+  const cacheKey = stateCacheKey(directory, state.sessionID);
+  trackedStatesByProjectSession.delete(cacheKey);
+  trackedStatesByProjectSession.set(cacheKey, state);
+  while (trackedStatesByProjectSession.size > MAX_TRACKED_SESSIONS) {
+    const oldestKey = trackedStatesByProjectSession.keys().next().value;
+    if (!oldestKey)
+      break;
+    trackedStatesByProjectSession.delete(oldestKey);
+  }
+}
+function forgetTrackedPrWorkflowState(directory, sessionID) {
+  trackedStatesByProjectSession.delete(stateCacheKey(directory, sessionID));
+}
+function resetPrReviewPersistenceCaches() {
+  trackedStatesByProjectSession.clear();
+  pendingStateMutationsByProjectSession.clear();
+  pendingCheckoutMutationsByProject.clear();
+  completedCheckoutLockOwners.clear();
+}
+function defaultIsProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+var defaultPersistenceHooks = {
+  nowMs: () => Date.now(),
+  isProcessAlive: defaultIsProcessAlive,
+  openCheckoutLock: (lockPath) => fsp.open(lockPath, "wx"),
+  removeCheckoutLock: (lockPath) => fsp.rm(lockPath),
+  checkoutMutationActionTimeoutMs: CHECKOUT_MUTATION_ACTION_TIMEOUT_MS,
+  rename: (from, to) => fsp.rename(from, to)
+};
+var hooks = defaultPersistenceHooks;
+function bindPrReviewPersistenceHooks(nextHooks) {
+  hooks = nextHooks;
+}
+var codec;
+var observabilityFieldNames = [];
+function bindPrReviewStateCodec(nextCodec, nextObservabilityFieldNames) {
+  codec = nextCodec;
+  observabilityFieldNames = nextObservabilityFieldNames;
+}
+function requireCodec() {
+  if (!codec) {
+    throw new Error("BLOCKED: PR workflow persistence codec is not bound (the gate must bind it at module init)");
+  }
+  return codec;
+}
+async function ensurePrWorkflowSafeParentDirectory(directory, filePath) {
+  const swarmRoot = path.resolve(directory, ".swarm");
+  const parentPath = path.dirname(path.resolve(filePath));
+  const relativeParent = path.relative(swarmRoot, parentPath);
+  if (relativeParent === ".." || relativeParent.startsWith(`..${path.sep}`) || path.isAbsolute(relativeParent)) {
+    throw new Error("BLOCKED: PR workflow atomic destination escapes the project .swarm directory");
+  }
+  await fsp.mkdir(swarmRoot, { recursive: true });
+  let currentPath = swarmRoot;
+  let currentIdentity = await assertSafeDirectory(currentPath, undefined);
+  for (const segment of relativeParent.split(path.sep).filter(Boolean)) {
+    const nextPath = path.join(currentPath, segment);
+    await hooks.beforeSafeDirectoryCreate?.(currentPath, nextPath);
+    await assertSafeDirectory(currentPath, currentIdentity);
+    try {
+      await fsp.mkdir(nextPath);
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+    }
+    await assertSafeDirectory(currentPath, currentIdentity);
+    const nextIdentity = await assertSafeDirectory(nextPath, undefined);
+    const [realCurrent, realNext] = await Promise.all([
+      fsp.realpath(currentPath),
+      fsp.realpath(nextPath)
+    ]);
+    if (normalizeComparableFsPath(path.dirname(realNext)) !== normalizeComparableFsPath(realCurrent)) {
+      throw new Error("BLOCKED: PR workflow directory creation escaped the project .swarm tree");
+    }
+    currentPath = nextPath;
+    currentIdentity = nextIdentity;
+  }
+  const realRoot = await fsp.realpath(swarmRoot);
+  const realParent = await fsp.realpath(parentPath);
+  const relativeRealParent = path.relative(realRoot, realParent);
+  if (relativeRealParent === ".." || relativeRealParent.startsWith(`..${path.sep}`) || path.isAbsolute(relativeRealParent)) {
+    throw new Error("BLOCKED: PR workflow atomic parent escapes the project .swarm directory");
+  }
+  return realParent;
+}
+async function assertSafeDirectory(directoryPath, expectedIdentity) {
+  const stat2 = await fsp.lstat(directoryPath, { bigint: true });
+  if (stat2.isSymbolicLink() || !stat2.isDirectory() || expectedIdentity && !sameBigIntFileIdentity(stat2, expectedIdentity)) {
+    throw new Error("BLOCKED: PR workflow .swarm path must be a real directory and must not change during the operation");
+  }
+  return { dev: stat2.dev, ino: stat2.ino };
+}
+async function assertOpenedSwarmFileIdentity(directory, filePath, handle, expectedParent, label) {
+  const openedStat = await handle.stat({ bigint: true });
+  if (!openedStat.isFile())
+    throw new Error(`BLOCKED: ${label} is not a file`);
+  await assertClosedSwarmFileIdentity(directory, filePath, openedStat, expectedParent, label);
+  return { dev: openedStat.dev, ino: openedStat.ino };
+}
+async function assertClosedSwarmFileIdentity(directory, filePath, expectedIdentity, expectedParent, label) {
+  if (!expectedIdentity)
+    throw new Error(`BLOCKED: ${label} has no identity`);
+  const [stat2, realRoot, realFile, realParent] = await Promise.all([
+    fsp.lstat(filePath, { bigint: true }),
+    fsp.realpath(path.resolve(directory, ".swarm")),
+    fsp.realpath(filePath),
+    fsp.realpath(path.dirname(filePath))
+  ]);
+  const relativeFile = path.relative(realRoot, realFile);
+  if (stat2.isSymbolicLink() || !stat2.isFile() || !sameBigIntFileIdentity(stat2, expectedIdentity) || normalizeComparableFsPath(realParent) !== normalizeComparableFsPath(expectedParent) || relativeFile === "" || relativeFile === ".." || relativeFile.startsWith(`..${path.sep}`) || path.isAbsolute(relativeFile)) {
+    throw new Error(`BLOCKED: ${label} changed or escaped .swarm`);
+  }
+}
+async function writeAtomicJson(directory, filePath, value) {
+  const safeParent = await ensurePrWorkflowSafeParentDirectory(directory, filePath);
+  const tempPath = `${filePath}.tmp.${process.pid}.${randomUUID()}`;
+  let tempIdentity;
+  let lastError;
+  try {
+    const handle = await fsp.open(tempPath, "wx");
+    try {
+      await hooks.beforeAtomicTempWrite?.();
+      tempIdentity = await assertOpenedSwarmFileIdentity(directory, tempPath, handle, safeParent, "PR workflow atomic temporary file");
+      await handle.writeFile(JSON.stringify(value, null, 2), "utf-8");
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await hooks.beforeAtomicRename?.();
+    await assertClosedSwarmFileIdentity(directory, tempPath, tempIdentity, safeParent, "PR workflow atomic temporary file");
+    for (let attempt = 0;attempt < WINDOWS_RENAME_MAX_RETRIES; attempt++) {
+      try {
+        await hooks.rename(tempPath, filePath);
+        lastError = undefined;
+        break;
+      } catch (error) {
+        lastError = error;
+        const code = error.code;
+        if (code !== "EEXIST" && code !== "EPERM" && code !== "EBUSY") {
+          break;
+        }
+        if (attempt < WINDOWS_RENAME_MAX_RETRIES - 1) {
+          await delay(RENAME_RETRY_DELAY_MS);
+        }
+      }
+    }
+    if (lastError) {
+      throw lastError;
+    }
+    await assertClosedSwarmFileIdentity(directory, filePath, tempIdentity, safeParent, "PR workflow atomic destination file");
+  } finally {
+    try {
+      await fsp.rm(tempPath, { force: true });
+    } catch {}
+  }
+}
+async function writePrWorkflowAtomicJson(directory, filePath, value) {
+  await writeAtomicJson(directory, filePath, value);
+}
+async function readPrWorkflowGateStateFromDisk(directory, sessionID, options = {}) {
+  const authoritative = await readPrWorkflowGateStateFromCoordination(directory, sessionID);
+  if (authoritative) {
+    await repairImportedWorkflowGateShadow(directory, sessionID, authoritative);
+    return authoritative;
+  }
+  return importLegacyPrWorkflowGateStateIfNeeded(directory, sessionID, options.allowSalvagedImport === true);
+}
+async function readPrWorkflowGateStateFileRawFromDisk(filePath, stateLabel) {
+  let raw;
+  try {
+    raw = await fsp.readFile(filePath, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+  let parsedJson;
+  try {
+    parsedJson = JSON.parse(raw);
+  } catch {
+    throw new Error(`BLOCKED: PR workflow gate state for session "${stateLabel}" is not valid JSON`);
+  }
+  const bound = requireCodec();
+  const parsed = bound.safeParse(parsedJson);
+  if (!parsed.success) {
+    throw new Error(`BLOCKED: PR workflow gate state for session "${stateLabel}" is invalid`);
+  }
+  return parsed.data;
+}
+async function readPrWorkflowGateStateFileFromDisk(filePath, stateLabel) {
+  return readPrWorkflowGateStateFileRawFromDisk(filePath, stateLabel);
+}
+async function readPrWorkflowGateStateFromCoordination(directory, sessionID) {
+  const decoded = readPrWorkflowGateStateCoordinationRow(directory, sessionID);
+  return decoded?.state ?? null;
+}
+function readPrWorkflowGateStateCoordinationForRecovery(directory, sessionID) {
+  const normalizedSessionID = normalizeSessionID(sessionID);
+  const row = getCoordinationStateRaw(directory, workflowGateStateCoordinationNamespace(normalizedSessionID), WORKFLOW_STATE_ENTITY_KEY);
+  if (!row)
+    return { kind: "absent" };
+  if (row.payload.length > MAX_COORDINATION_PAYLOAD_CHARS) {
+    return {
+      kind: "corrupt",
+      rowRevision: row.revision,
+      generation: row.generation,
+      reason: "coordination payload exceeds the maximum size"
+    };
+  }
+  let parsedJson;
+  try {
+    parsedJson = JSON.parse(row.payload);
+  } catch {
+    return {
+      kind: "corrupt",
+      rowRevision: row.revision,
+      generation: row.generation,
+      reason: "coordination payload is not valid JSON"
+    };
+  }
+  const bound = requireCodec();
+  const parsed = bound.safeParse(parsedJson);
+  if (!parsed.success) {
+    return {
+      kind: "corrupt",
+      rowRevision: row.revision,
+      generation: row.generation,
+      reason: "coordination payload failed the workflow state schema"
+    };
+  }
+  if (parsed.data.sessionID !== normalizedSessionID) {
+    return {
+      kind: "invalid",
+      reason: "coordination payload session identity does not match the requested session"
+    };
+  }
+  if (parsed.data.revision !== row.generation) {
+    return {
+      kind: "corrupt",
+      rowRevision: row.revision,
+      generation: row.generation,
+      reason: "coordination payload revision does not match its generation"
+    };
+  }
+  return {
+    kind: "valid",
+    rowRevision: row.revision,
+    generation: row.generation,
+    state: parsed.data
+  };
+}
+function readPrWorkflowGateStateCoordinationRow(directory, sessionID) {
+  const row = getCoordinationState(directory, workflowGateStateCoordinationNamespace(sessionID), WORKFLOW_STATE_ENTITY_KEY);
+  if (!row)
+    return null;
+  let parsedJson;
+  try {
+    parsedJson = JSON.parse(row.payload);
+  } catch {
+    throw new Error(`BLOCKED: PR workflow gate state for session "${sessionID}" is not valid JSON`);
+  }
+  const bound = requireCodec();
+  const parsed = bound.safeParse(parsedJson);
+  if (!parsed.success || parsed.data.sessionID !== normalizeSessionID(sessionID) || parsed.data.revision !== row.generation) {
+    throw new Error(`BLOCKED: PR workflow gate state for session "${sessionID}" is invalid`);
+  }
+  return { rowRevision: row.revision, state: parsed.data };
+}
+function workflowStateStatus(state) {
+  const mode = state.mode;
+  return typeof mode === "string" && mode.trim().length > 0 ? mode : "active";
+}
+async function fileExists(filePath) {
+  try {
+    await fsp.stat(filePath);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return false;
+    throw error;
+  }
+}
+function serializeWorkflowGateState(state) {
+  return JSON.stringify(state, null, 2);
+}
+async function readTextFileIfExists(filePath) {
+  try {
+    return await fsp.readFile(filePath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+}
+async function writeProjectionMarker(directory, filePath) {
+  await ensurePrWorkflowSafeParentDirectory(directory, filePath);
+  await fsp.writeFile(filePath, `sqlite-projection
+`, "utf8");
+}
+async function renameWithRetry(from, to) {
+  let lastError;
+  for (let attempt = 0;attempt < WINDOWS_RENAME_MAX_RETRIES; attempt++) {
+    try {
+      await hooks.rename(from, to);
+      return;
+    } catch (error) {
+      lastError = error;
+      const code = error.code;
+      if (code !== "EEXIST" && code !== "EPERM" && code !== "EBUSY") {
+        throw error;
+      }
+      if (attempt < WINDOWS_RENAME_MAX_RETRIES - 1) {
+        await delay(RENAME_RETRY_DELAY_MS);
+      }
+    }
+  }
+  throw lastError;
+}
+async function collisionSafeImportedPath(filePath) {
+  const canonical = `${filePath}.imported`;
+  if (!await fileExists(canonical))
+    return canonical;
+  for (let suffix = 1;suffix <= 1e4; suffix += 1) {
+    const candidate = `${canonical}.${suffix}`;
+    if (!await fileExists(candidate))
+      return candidate;
+  }
+  throw new Error(`No collision-safe archive path available for ${path.basename(filePath)}`);
+}
+async function archiveShadowSource(filePath) {
+  if (!await fileExists(filePath))
+    return;
+  await renameWithRetry(filePath, await collisionSafeImportedPath(filePath));
+}
+async function syncWorkflowGateShadowProjection(directory, sessionID, state, options) {
+  const filePath = workflowGateStatePath(directory, sessionID);
+  if (options.archiveLegacy && await fileExists(filePath)) {
+    await archiveShadowSource(filePath);
+  }
+  await writeAtomicJson(directory, filePath, state);
+  await writeProjectionMarker(directory, workflowGateStateProjectionMarkerPath(directory, sessionID));
+}
+async function repairImportedWorkflowGateShadow(directory, sessionID, state) {
+  const filePath = workflowGateStatePath(directory, sessionID);
+  const markerPath = workflowGateStateProjectionMarkerPath(directory, sessionID);
+  const live = await readTextFileIfExists(filePath);
+  if (live === null) {
+    await syncWorkflowGateShadowProjection(directory, sessionID, state, {
+      archiveLegacy: false
+    });
+    return;
+  }
+  const canonicalImportedExists = await fileExists(workflowGateStateImportedPath(directory, sessionID));
+  const markerExists = await fileExists(markerPath);
+  const projected = serializeWorkflowGateState(state);
+  if (canonicalImportedExists && markerExists && live === projected)
+    return;
+  if (canonicalImportedExists && live === projected) {
+    await writeProjectionMarker(directory, markerPath);
+    return;
+  }
+  await syncWorkflowGateShadowProjection(directory, sessionID, state, {
+    archiveLegacy: true
+  });
+}
+async function removeWorkflowGateShadowProjection(directory, sessionID) {
+  for (const filePath of [
+    workflowGateStatePath(directory, sessionID),
+    workflowGateStateProjectionMarkerPath(directory, sessionID)
+  ]) {
+    try {
+      await (hooks.removeShadowProjection ?? ((target) => fsp.rm(target, { force: true })))(filePath);
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+  }
+}
+function appendSessionTerminalizationEvent(directory, sessionID, rowRevision) {
+  try {
+    appendCoreEventSync(directory, {
+      type: "pr_workflow_session_terminalized",
+      timestamp: isoNow(),
+      sessionID,
+      rowRevision
+    });
+  } catch {}
+}
+async function importLegacyPrWorkflowGateStateIfNeeded(directory, sessionID, allowSalvagedImport = false) {
+  const filePath = workflowGateStatePath(directory, sessionID);
+  let raw;
+  try {
+    raw = await fsp.readFile(filePath, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+  const legacy = allowSalvagedImport ? (await (await import("./pr-workflow-gate-bj66aa9k.js")).readPrWorkflowGateStateForRecovery(directory, sessionID))?.state ?? null : await readPrWorkflowGateStateFileFromDisk(filePath, sessionID);
+  if (!legacy)
+    return null;
+  const namespace = workflowGateStateCoordinationNamespace(sessionID);
+  const outcome = importCoordinationOnce(directory, {
+    source: workflowGateStateRelativePath(sessionID),
+    sourceDigest: createHash("sha256").update(raw).digest("hex"),
+    rowCount: 1,
+    emptyNamespace: namespace
+  }, () => {
+    const result = transitionCoordinationState(directory, {
+      namespace,
+      entityKey: WORKFLOW_STATE_ENTITY_KEY,
+      expectedRevision: null,
+      generation: legacy.revision,
+      status: workflowStateStatus(legacy),
+      payload: JSON.stringify(legacy)
+    });
+    if (result.outcome !== "applied") {
+      throw new Error(`PR workflow gate state import failed: ${result.outcome}`);
+    }
+  });
+  const authoritative = await readPrWorkflowGateStateFromCoordination(directory, sessionID);
+  if (authoritative && outcome === "imported") {
+    await syncWorkflowGateShadowProjection(directory, sessionID, authoritative, {
+      archiveLegacy: true
+    });
+  }
+  return authoritative;
+}
+function withDurableObservabilityFields(incoming, current) {
+  if (!current || observabilityFieldNames.length === 0)
+    return incoming;
+  const merged = {
+    ...{ ...incoming }
+  };
+  const durable = current;
+  const instanceReplaced = current.workflowInstanceId !== undefined && current.workflowInstanceId !== incoming.workflowInstanceId;
+  for (const field of observabilityFieldNames) {
+    if (instanceReplaced)
+      delete merged[field];
+    else if (durable[field] !== undefined)
+      merged[field] = durable[field];
+    else
+      delete merged[field];
+  }
+  return merged;
+}
+function enforceObservabilityOnlyMutation(validated, current) {
+  if (!current)
+    return;
+  const incoming = validated;
+  const durable = current;
+  const skip = new Set(observabilityFieldNames);
+  skip.add("updatedAt");
+  skip.add("revision");
+  const keys = new Set([...Object.keys(incoming), ...Object.keys(durable)]);
+  for (const key of keys) {
+    if (skip.has(key))
+      continue;
+    if (JSON.stringify(incoming[key]) !== JSON.stringify(durable[key])) {
+      throw new Error(`BLOCKED: appendObservabilityStateWhileLocked may change only observability fields and updatedAt; field "${key}" also differs from the durable state`);
+    }
+  }
+}
+async function persistStateRowWhileLocked(directory, validated, bumpRevision, options = {}) {
+  const bound = requireCodec();
+  let currentAuthoritative = readPrWorkflowGateStateCoordinationRow(directory, validated.sessionID);
+  let current = currentAuthoritative?.state ?? null;
+  if (!current) {
+    current = await readPrWorkflowGateStateFromDisk(directory, validated.sessionID);
+    currentAuthoritative = readPrWorkflowGateStateCoordinationRow(directory, validated.sessionID);
+  }
+  let effective = validated;
+  if (bumpRevision) {
+    effective = withDurableObservabilityFields(validated, current);
+  } else {
+    enforceObservabilityOnlyMutation(validated, current);
+  }
+  if (current ? current.revision !== validated.revision : validated.revision !== 0) {
+    throw new Error("BLOCKED: PR workflow gate state changed concurrently; reload the active session state before retrying");
+  }
+  if (current?.workflowInstanceId && validated.workflowInstanceId !== current.workflowInstanceId && options.replaceWorkflowInstanceId !== current.workflowInstanceId) {
+    throw new Error("BLOCKED: PR workflow gate state changed concurrently; reload the active session state before retrying");
+  }
+  const nextState = bound.parse(bumpRevision ? { ...effective, revision: validated.revision + 1 } : effective);
+  const result = transitionCoordinationState(directory, {
+    namespace: workflowGateStateCoordinationNamespace(validated.sessionID),
+    entityKey: WORKFLOW_STATE_ENTITY_KEY,
+    expectedRevision: currentAuthoritative?.rowRevision ?? null,
+    generation: nextState.revision,
+    status: workflowStateStatus(nextState),
+    payload: JSON.stringify(nextState)
+  });
+  if (result.outcome !== "applied") {
+    throw new Error("BLOCKED: PR workflow gate state changed concurrently; reload the active session state before retrying");
+  }
+  await syncWorkflowGateShadowProjection(directory, validated.sessionID, nextState, { archiveLegacy: false });
+  rememberState(directory, nextState);
+  return nextState;
+}
+async function writeStateWhileLocked(directory, state, options = {}) {
+  const bound = requireCodec();
+  const validated = bound.parse(state);
+  return persistStateRowWhileLocked(directory, validated, true, options);
+}
+async function appendObservabilityStateWhileLocked(directory, state) {
+  const bound = requireCodec();
+  const validated = bound.parse(state);
+  return persistStateRowWhileLocked(directory, validated, false);
+}
+async function deleteStateWhileLocked(directory, sessionID, options = {}) {
+  const normalizedSessionID = normalizeSessionID(sessionID);
+  let currentAuthoritative = null;
+  let corruptCoordinationRowRevision;
+  if (options.allowSalvagedRead) {
+    const coordination = readPrWorkflowGateStateCoordinationForRecovery(directory, normalizedSessionID);
+    if (coordination.kind === "invalid") {
+      throw new Error(`BLOCKED: PR workflow gate state for session "${normalizedSessionID}" is invalid (${coordination.reason})`);
+    }
+    if (coordination.kind === "valid") {
+      currentAuthoritative = {
+        rowRevision: coordination.rowRevision,
+        state: coordination.state
+      };
+    } else if (coordination.kind === "corrupt") {
+      corruptCoordinationRowRevision = coordination.rowRevision;
+    }
+  } else {
+    currentAuthoritative = readPrWorkflowGateStateCoordinationRow(directory, normalizedSessionID);
+  }
+  let recoveryState = null;
+  if (!currentAuthoritative) {
+    if (options.allowSalvagedRead) {
+      const { readPrWorkflowGateStateForRecovery } = await import("./pr-workflow-gate-bj66aa9k.js");
+      recoveryState = (await readPrWorkflowGateStateForRecovery(directory, normalizedSessionID))?.state ?? null;
+    }
+    if (!recoveryState) {
+      await readPrWorkflowGateStateFromDisk(directory, normalizedSessionID, {
+        allowSalvagedImport: options.allowSalvagedRead === true
+      });
+      currentAuthoritative = readPrWorkflowGateStateCoordinationRow(directory, normalizedSessionID);
+    }
+  }
+  const currentRevision = currentAuthoritative?.state.revision ?? recoveryState?.revision;
+  if (options.expectedStateRevision !== undefined && currentRevision !== options.expectedStateRevision) {
+    throw new Error("BLOCKED: PR workflow gate state changed concurrently; reload the active session state before retrying");
+  }
+  const authoritativeRowRevision = currentAuthoritative?.rowRevision ?? (recoveryState ? corruptCoordinationRowRevision : undefined);
+  if (authoritativeRowRevision !== undefined) {
+    const deleted = deleteCoordinationState(directory, workflowGateStateCoordinationNamespace(normalizedSessionID), WORKFLOW_STATE_ENTITY_KEY, authoritativeRowRevision);
+    if (!deleted) {
+      throw new Error("BLOCKED: PR workflow gate state changed concurrently; reload the active session state before retrying");
+    }
+  }
+  await removeWorkflowGateShadowProjection(directory, normalizedSessionID);
+  forgetTrackedPrWorkflowState(directory, normalizedSessionID);
+}
+async function terminalizePrWorkflowGateForSession(directory, sessionID) {
+  const normalizedSessionID = normalizeSessionID(sessionID);
+  await withSessionStateMutation(directory, normalizedSessionID, async () => {
+    const row = getCoordinationStateRaw(directory, workflowGateStateCoordinationNamespace(normalizedSessionID), WORKFLOW_STATE_ENTITY_KEY);
+    await removeWorkflowGateShadowProjection(directory, normalizedSessionID);
+    await hooks.beforeTerminalizationDelete?.();
+    if (row) {
+      const deleted = deleteCoordinationState(directory, workflowGateStateCoordinationNamespace(normalizedSessionID), WORKFLOW_STATE_ENTITY_KEY, row.revision);
+      if (!deleted) {
+        throw new Error("BLOCKED: PR workflow gate state changed concurrently; retry session terminalization");
+      }
+      appendSessionTerminalizationEvent(directory, normalizedSessionID, row.revision);
+    }
+    forgetTrackedPrWorkflowState(directory, normalizedSessionID);
+  });
+}
+function checkoutMutationProjectKey(directory) {
+  return canonicalRootKeyFresh(directory);
+}
+
+class PrWorkflowCheckoutMutationTimeoutError extends Error {
+  phase;
+  code = "PR_WORKFLOW_CHECKOUT_MUTATION_TIMEOUT";
+  retryable = false;
+  constructor(phase) {
+    super(phase === "queue" ? "BLOCKED: timed out waiting for the active PR workflow checkout mutation; the existing owner still holds serialization and must settle before retrying" : "BLOCKED: PR workflow checkout mutation exceeded its execution deadline; serialization remains held until the in-flight action actually settles");
+    this.phase = phase;
+    this.name = "PrWorkflowCheckoutMutationTimeoutError";
+  }
+}
+async function withCheckoutMutationDeadline(promise, phase) {
+  let timeout;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((resolve2) => {
+        timeout = setTimeout(() => {
+          resolve2({
+            status: "timeout",
+            error: new PrWorkflowCheckoutMutationTimeoutError(phase)
+          });
+        }, hooks.checkoutMutationActionTimeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeout)
+      clearTimeout(timeout);
+  }
+}
+async function withPrWorkflowCheckoutMutationLock(directory, action) {
+  const key = checkoutMutationProjectKey(directory);
+  const previous = pendingCheckoutMutationsByProject.get(key) ?? Promise.resolve();
+  let release;
+  const current = new Promise((resolve2) => {
+    release = resolve2;
+  });
+  const queued = previous.then(() => current);
+  pendingCheckoutMutationsByProject.set(key, queued);
+  const previousResult = await withCheckoutMutationDeadline(previous.then(() => ({ status: "ready" })), "queue");
+  if (previousResult.status === "timeout") {
+    release();
+    queued.then(() => {
+      if (pendingCheckoutMutationsByProject.get(key) === queued) {
+        pendingCheckoutMutationsByProject.delete(key);
+      }
+    });
+    throw previousResult.error;
+  }
+  let lock;
+  try {
+    lock = await acquireCheckoutMutationLock(directory);
+  } catch (error) {
+    release();
+    if (pendingCheckoutMutationsByProject.get(key) === queued) {
+      pendingCheckoutMutationsByProject.delete(key);
+    }
+    throw error;
+  }
+  const actionOutcome = Promise.resolve().then(action).then((value) => ({ status: "fulfilled", value }), (error) => ({ status: "rejected", error }));
+  const outcome = await withCheckoutMutationDeadline(actionOutcome, "action");
+  if (outcome.status === "timeout") {
+    actionOutcome.then(async () => {
+      try {
+        await releaseCheckoutMutationLock(lock);
+      } catch {} finally {
+        release();
+        if (pendingCheckoutMutationsByProject.get(key) === queued) {
+          pendingCheckoutMutationsByProject.delete(key);
+        }
+      }
+    });
+    throw outcome.error;
+  }
+  try {
+    if (outcome.status === "rejected")
+      throw outcome.error;
+    return outcome.value;
+  } finally {
+    try {
+      await releaseCheckoutMutationLock(lock);
+    } finally {
+      release();
+      if (pendingCheckoutMutationsByProject.get(key) === queued) {
+        pendingCheckoutMutationsByProject.delete(key);
+      }
+    }
+  }
+}
+async function acquireCheckoutMutationLock(directory) {
+  const lockPath = workflowCheckoutMutationLockPath(directory);
+  const verifiedParent = await ensurePrWorkflowSafeParentDirectory(directory, lockPath);
+  for (let attempt = 0;attempt < STATE_MUTATION_LOCK_MAX_ATTEMPTS; attempt++) {
+    try {
+      const handle = await hooks.openCheckoutLock(lockPath);
+      const lock = {
+        ownerToken: randomUUID(),
+        pid: process.pid,
+        createdAtMs: hooks.nowMs()
+      };
+      let lockIdentity;
+      let writeError;
+      try {
+        const openedStat = await handle.stat({ bigint: true });
+        lockIdentity = { dev: openedStat.dev, ino: openedStat.ino };
+        lockIdentity = await assertOpenedSwarmFileIdentity(directory, lockPath, handle, verifiedParent, "PR workflow checkout mutation lock");
+        await hooks.beforeCheckoutLockWrite?.();
+        await handle.writeFile(JSON.stringify(lock), "utf-8");
+      } catch (error) {
+        writeError = error;
+      } finally {
+        await handle.close().catch(() => {
+          return;
+        });
+      }
+      if (writeError) {
+        if (lockIdentity) {
+          await removeCheckoutMutationLockByIdentity(directory, lockPath, lockIdentity, verifiedParent);
+        }
+        throw writeError;
+      }
+      return { path: lockPath, ownerToken: lock.ownerToken };
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+      if (await reclaimAbandonedCheckoutMutationLock(lockPath))
+        continue;
+      if (attempt < STATE_MUTATION_LOCK_MAX_ATTEMPTS - 1) {
+        await delay(STATE_MUTATION_LOCK_RETRY_DELAY_MS);
+      }
+    }
+  }
+  throw new Error("BLOCKED: PR workflow checkout mutation is being handled by another process; retry after that checkout settles");
+}
+async function releaseCheckoutMutationLock(lock) {
+  let lastError;
+  for (let attempt = 0;attempt < WINDOWS_RENAME_MAX_RETRIES; attempt++) {
+    try {
+      if (await removeCheckoutMutationLockIfOwned(lock.path, lock.ownerToken)) {
+        completedCheckoutLockOwners.delete(lock.path);
+        return;
+      }
+      lastError = new Error("PR workflow checkout mutation lock ownership changed before release");
+    } catch (error) {
+      lastError = error;
+    }
+    if (attempt < WINDOWS_RENAME_MAX_RETRIES - 1) {
+      await delay(RENAME_RETRY_DELAY_MS);
+    }
+  }
+  rememberCompletedCheckoutLockOwner(lock.path, lock.ownerToken);
+  throw lastError instanceof Error ? lastError : new Error("PR workflow checkout mutation lock release failed");
+}
+async function reclaimAbandonedCheckoutMutationLock(lockPath) {
+  const lock = await readCheckoutMutationLock(lockPath);
+  if (lock) {
+    if (lock.pid === process.pid && completedCheckoutLockOwners.get(lockPath) === lock.ownerToken) {
+      const removed = await removeCheckoutMutationLockIfOwned(lockPath, lock.ownerToken);
+      if (removed)
+        completedCheckoutLockOwners.delete(lockPath);
+      return removed;
+    }
+    if (hooks.isProcessAlive(lock.pid))
+      return false;
+    return removeCheckoutMutationLockIfOwned(lockPath, lock.ownerToken);
+  }
+  try {
+    const stat2 = await fsp.stat(lockPath);
+    if (hooks.nowMs() - stat2.mtimeMs < STATE_MUTATION_LOCK_UNINITIALIZED_STALE_MS) {
+      return false;
+    }
+    await fsp.rm(lockPath, { force: true });
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return true;
+    throw error;
+  }
+}
+async function readCheckoutMutationLock(lockPath) {
+  let raw;
+  try {
+    raw = await fsp.readFile(lockPath, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && typeof parsed.ownerToken === "string" && parsed.ownerToken.length > 0 && typeof parsed.pid === "number" && Number.isInteger(parsed.pid) && parsed.pid > 0 && typeof parsed.createdAtMs === "number" && Number.isFinite(parsed.createdAtMs)) {
+      return parsed;
+    }
+  } catch {}
+  return null;
+}
+async function removeCheckoutMutationLockIfOwned(lockPath, ownerToken) {
+  const lock = await readCheckoutMutationLock(lockPath);
+  if (!lock || lock.ownerToken !== ownerToken)
+    return false;
+  try {
+    await hooks.removeCheckoutLock(lockPath);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return false;
+    throw error;
+  }
+}
+async function removeCheckoutMutationLockByIdentity(directory, lockPath, identity, verifiedParent) {
+  let lastError;
+  for (let attempt = 0;attempt < WINDOWS_RENAME_MAX_RETRIES; attempt++) {
+    try {
+      await assertClosedSwarmFileIdentity(directory, lockPath, identity, verifiedParent, "PR workflow checkout mutation lock");
+      await hooks.removeCheckoutLock(lockPath);
+      return;
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return;
+      lastError = error;
+      if (attempt < WINDOWS_RENAME_MAX_RETRIES - 1) {
+        await delay(RENAME_RETRY_DELAY_MS);
+      }
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error("PR workflow checkout mutation lock cleanup failed");
+}
+function rememberCompletedCheckoutLockOwner(lockPath, ownerToken) {
+  completedCheckoutLockOwners.delete(lockPath);
+  completedCheckoutLockOwners.set(lockPath, ownerToken);
+  while (completedCheckoutLockOwners.size > MAX_COMPLETED_CHECKOUT_LOCK_OWNERS) {
+    const oldest = completedCheckoutLockOwners.keys().next().value;
+    if (oldest === undefined)
+      break;
+    completedCheckoutLockOwners.delete(oldest);
+  }
+}
+async function withSessionStateMutation(directory, sessionID, action) {
+  const key = stateCacheKey(directory, sessionID);
+  const previous = pendingStateMutationsByProjectSession.get(key) ?? Promise.resolve();
+  let release;
+  const current = new Promise((resolve2) => {
+    release = resolve2;
+  });
+  const queued = previous.then(() => current);
+  pendingStateMutationsByProjectSession.set(key, queued);
+  await previous;
+  try {
+    const lock = await acquireSessionStateMutationLock(directory, sessionID);
+    try {
+      return await action();
+    } finally {
+      await releaseSessionStateMutationLock(lock);
+    }
+  } finally {
+    release();
+    if (pendingStateMutationsByProjectSession.get(key) === queued) {
+      pendingStateMutationsByProjectSession.delete(key);
+    }
+  }
+}
+async function acquireSessionStateMutationLock(directory, sessionID) {
+  const lockPath = workflowGateStateLockPath(directory, sessionID);
+  const verifiedParent = await ensurePrWorkflowSafeParentDirectory(directory, lockPath);
+  for (let attempt = 0;attempt < STATE_MUTATION_LOCK_MAX_ATTEMPTS; attempt++) {
+    try {
+      const handle = await fsp.open(lockPath, "wx");
+      const lock = {
+        ownerToken: randomUUID(),
+        pid: process.pid,
+        createdAtMs: hooks.nowMs()
+      };
+      let writeError;
+      try {
+        await hooks.beforeSessionStateLockWrite?.();
+        await assertOpenedSwarmFileIdentity(directory, lockPath, handle, verifiedParent, "PR workflow state mutation lock");
+        await handle.writeFile(JSON.stringify(lock), "utf-8");
+      } catch (error) {
+        writeError = error;
+      } finally {
+        await handle.close().catch(() => {
+          return;
+        });
+      }
+      if (writeError) {
+        await removeSessionStateMutationLockIfOwned(lockPath, lock.ownerToken);
+        throw writeError;
+      }
+      return { path: lockPath, ownerToken: lock.ownerToken };
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+      if (await reclaimAbandonedSessionStateMutationLock(lockPath))
+        continue;
+      if (attempt < STATE_MUTATION_LOCK_MAX_ATTEMPTS - 1) {
+        await delay(STATE_MUTATION_LOCK_RETRY_DELAY_MS);
+      }
+    }
+  }
+  throw new Error("BLOCKED: PR workflow gate state is being mutated by another process; retry after that session transition finishes");
+}
+async function releaseSessionStateMutationLock(lock) {
+  try {
+    await removeSessionStateMutationLockIfOwned(lock.path, lock.ownerToken);
+  } catch {}
+}
+async function reclaimAbandonedSessionStateMutationLock(lockPath) {
+  const lock = await readSessionStateMutationLock(lockPath);
+  if (lock) {
+    if (hooks.isProcessAlive(lock.pid))
+      return false;
+    return removeSessionStateMutationLockIfOwned(lockPath, lock.ownerToken);
+  }
+  try {
+    const stat2 = await fsp.stat(lockPath);
+    if (hooks.nowMs() - stat2.mtimeMs < STATE_MUTATION_LOCK_UNINITIALIZED_STALE_MS) {
+      return false;
+    }
+    await fsp.rm(lockPath, { force: true });
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return true;
+    throw error;
+  }
+}
+async function readSessionStateMutationLock(lockPath) {
+  let raw;
+  try {
+    raw = await fsp.readFile(lockPath, "utf-8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && typeof parsed.ownerToken === "string" && parsed.ownerToken.length > 0 && typeof parsed.pid === "number" && Number.isInteger(parsed.pid) && parsed.pid > 0 && typeof parsed.createdAtMs === "number" && Number.isFinite(parsed.createdAtMs)) {
+      return parsed;
+    }
+  } catch {}
+  return null;
+}
+async function removeSessionStateMutationLockIfOwned(lockPath, ownerToken) {
+  const lock = await readSessionStateMutationLock(lockPath);
+  if (!lock || lock.ownerToken !== ownerToken)
+    return false;
+  try {
+    await fsp.rm(lockPath);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return false;
+    throw error;
+  }
+}
+
+// src/pr-review/verdict-settlement.ts
 init_zod();
-import { createHash as createHash3 } from "crypto";
-import * as fs2 from "fs";
+import { createHash as createHash2 } from "crypto";
+import * as fs from "fs";
 import * as path2 from "path";
-import { isDeepStrictEqual } from "util";
+var PR_REVIEW_VERDICT_RETRY_BUDGET = 2;
+var VERDICT_SETTLEMENT_SCHEMA_VERSION = 1;
+var VERDICT_SETTLEMENT_MAX_RECEIPT_BYTES = 65536;
+var VERDICT_SETTLEMENT_MAX_RECEIPT_ITEMS = 128;
+var PrReviewVerdictSettlementPhaseSchema = exports_external.enum([
+  "reviewer",
+  "critic"
+]);
+var PrReviewVerdictSettlementItemSchema = exports_external.object({
+  itemId: exports_external.string().trim().min(1),
+  sourceBatchId: exports_external.string().trim().min(1),
+  sourceLaneId: exports_external.string().trim().min(1),
+  disposition: exports_external.enum([
+    "liveness_dead",
+    "verdict_contract_dead",
+    "resource_dead"
+  ]),
+  evidenceClass: exports_external.enum(["liveness", "verdict_contract", "resource"]),
+  terminalStatus: exports_external.enum(["stale", "cancelled", "error"])
+}).strict();
+var PrReviewVerdictSettlementReceiptSchema = exports_external.object({
+  schemaVersion: exports_external.literal(VERDICT_SETTLEMENT_SCHEMA_VERSION),
+  runId: exports_external.string().trim().min(1),
+  prHeadSha: exports_external.string().trim().min(1),
+  revisionDigest: exports_external.string().trim().min(1),
+  phase: PrReviewVerdictSettlementPhaseSchema,
+  items: exports_external.array(PrReviewVerdictSettlementItemSchema).min(1).max(VERDICT_SETTLEMENT_MAX_RECEIPT_ITEMS)
+}).strict();
+function verdictSettlementRelativePath(runId, phase) {
+  return path2.join("pr-review", runId, `verdict-settlement.${phase}.json`);
+}
+function typedDeadDisclosureClassForRecord(record) {
+  if (record.status !== "cancelled" && record.status !== "stale" && record.status !== "error") {
+    return null;
+  }
+  const terminalClass = record.terminalResult?.result.workflowLaneFailureClass ?? null;
+  const resultClass = record.result?.workflowLaneFailureClass ?? null;
+  for (const cls of [terminalClass, resultClass]) {
+    switch (cls) {
+      case "liveness":
+        return "liveness";
+      case "verdict_contract":
+      case "contract":
+        return "verdict_contract";
+      case "resource":
+        return "resource";
+      default:
+        break;
+    }
+  }
+  return null;
+}
+function deriveVerdictSettlementAdmission(args) {
+  const { directory, prHeadSha, phase, window, unclaimed } = args;
+  if (unclaimed.length === 0) {
+    return {
+      admitted: false,
+      reason: "no unclaimed items",
+      items: []
+    };
+  }
+  const expectedMode = `swarm-pr-review:${phase}`;
+  const items = [];
+  const batchReads = new Map;
+  for (const itemId of unclaimed) {
+    const owners = window.flatMap((batch) => batch.lanes.filter((lane) => (lane.reviewItemIds ?? []).includes(itemId)).map((lane) => ({ batch, lane })));
+    if (owners.length === 0) {
+      return {
+        admitted: false,
+        reason: `item ${itemId} has no declared owner lane in the phase window (absence is not terminality evidence)`,
+        items: []
+      };
+    }
+    const itemAttemptBatchIds = new Set;
+    const dead = [];
+    for (const { batch, lane } of owners) {
+      itemAttemptBatchIds.add(batch.batchId);
+      let read = batchReads.get(batch.batchId);
+      if (!read) {
+        read = _internals.findByBatchIdDetailed(directory, batch.batchId, {
+          parentSessionId: args.parentSessionId
+        });
+        batchReads.set(batch.batchId, read);
+      }
+      if (read.status === "uncertain") {
+        return {
+          admitted: false,
+          reason: `delegation store read was uncertain for batch ${batch.batchId}`,
+          items: []
+        };
+      }
+      const record = read.value.find((candidate) => candidate.batchId === batch.batchId && candidate.laneId === lane.laneId && candidate.mode === expectedMode && candidate.workspace?.prHeadSha === prHeadSha);
+      if (!record) {
+        return {
+          admitted: false,
+          reason: `item ${itemId} still has a non-admissible owner lane ${lane.laneId} (missing delegation record)`,
+          items: []
+        };
+      }
+      if (record.status === "completed") {
+        continue;
+      }
+      const disclosure = typedDeadDisclosureClassForRecord(record);
+      if (!disclosure) {
+        const blockingClass = record.terminalResult?.result.workflowLaneFailureClass ?? record.result?.workflowLaneFailureClass ?? "classless";
+        return {
+          admitted: false,
+          reason: `item ${itemId} still has a non-admissible owner lane ${lane.laneId} (${blockingClass})`,
+          items: []
+        };
+      }
+      dead.push({
+        batchId: batch.batchId,
+        laneId: lane.laneId,
+        status: record.status === "cancelled" || record.status === "error" ? record.status : "stale",
+        disclosure
+      });
+    }
+    if (itemAttemptBatchIds.size < 1 + PR_REVIEW_VERDICT_RETRY_BUDGET) {
+      return {
+        admitted: false,
+        reason: `item ${itemId} verdict retry budget not exhausted (${itemAttemptBatchIds.size} of ${1 + PR_REVIEW_VERDICT_RETRY_BUDGET} required attempts)`,
+        items: []
+      };
+    }
+    if (dead.length === 0) {
+      return {
+        admitted: false,
+        reason: `item ${itemId} has no typed-dead owner lane to cite (completed owners consume attempts but are never terminality evidence)`,
+        items: []
+      };
+    }
+    const first = dead[0];
+    items.push({
+      itemId,
+      sourceBatchId: first.batchId,
+      sourceLaneId: first.laneId,
+      disposition: `${first.disclosure}_dead`,
+      evidenceClass: first.disclosure,
+      terminalStatus: first.status
+    });
+  }
+  return { admitted: true, reason: "admitted", items };
+}
+function deriveVerdictAttemptCounts(args) {
+  const attemptsRequired = 1 + PR_REVIEW_VERDICT_RETRY_BUDGET;
+  return args.unclaimed.map((itemId) => {
+    const batches = new Set;
+    for (const batch of args.window) {
+      if (batch.lanes.some((lane) => (lane.reviewItemIds ?? []).includes(itemId))) {
+        batches.add(batch.batchId);
+      }
+    }
+    const attemptsUsed = batches.size;
+    return {
+      itemId,
+      attemptsUsed,
+      attemptsRequired,
+      remaining: Math.max(0, attemptsRequired - attemptsUsed)
+    };
+  });
+}
+function buildVerdictSettlementReceipt(args) {
+  return {
+    schemaVersion: VERDICT_SETTLEMENT_SCHEMA_VERSION,
+    runId: args.runId,
+    prHeadSha: args.prHeadSha,
+    revisionDigest: args.revisionDigest,
+    phase: args.phase,
+    items: [...args.items]
+  };
+}
+async function persistVerdictSettlementReceipt(directory, receipt) {
+  if (receipt.items.length > VERDICT_SETTLEMENT_MAX_RECEIPT_ITEMS) {
+    throw new Error(`verdict-settlement receipt exceeds the ${VERDICT_SETTLEMENT_MAX_RECEIPT_ITEMS}-item bounded-reader cap (${receipt.items.length} items); narrow the disclosed dead set before settling`);
+  }
+  const serialized = JSON.stringify(receipt, null, 2);
+  const serializedBytes = Buffer.byteLength(serialized, "utf8");
+  if (serializedBytes > VERDICT_SETTLEMENT_MAX_RECEIPT_BYTES) {
+    throw new Error(`verdict-settlement receipt exceeds the ${VERDICT_SETTLEMENT_MAX_RECEIPT_BYTES}-byte bounded-reader cap (${serializedBytes} bytes); narrow the disclosed dead set before settling`);
+  }
+  const absolute = path2.join(directory, ".swarm", verdictSettlementRelativePath(receipt.runId, receipt.phase));
+  await writeAtomicJson(directory, absolute, receipt);
+}
+function boundedReadErrno(error) {
+  if (error?.code === "ENOENT") {
+    return { status: "absent" };
+  }
+  const code = error?.code ?? "unknown";
+  return {
+    status: "invalid",
+    reason: `receipt is unreadable (${String(code)})`
+  };
+}
+function readBoundedSwarmRegularFileBytes(swarmRoot, absolute, maxBytes) {
+  const rootStat = fs.lstatSync(swarmRoot, {
+    bigint: true,
+    throwIfNoEntry: false
+  });
+  if (!rootStat)
+    return { status: "absent" };
+  if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
+    return {
+      status: "invalid",
+      reason: "receipt root must be a real project .swarm directory"
+    };
+  }
+  const fileStat = fs.lstatSync(absolute, {
+    bigint: true,
+    throwIfNoEntry: false
+  });
+  if (!fileStat)
+    return { status: "absent" };
+  if (fileStat.isSymbolicLink() || !fileStat.isFile()) {
+    return {
+      status: "invalid",
+      reason: "receipt must be a bounded regular file"
+    };
+  }
+  if (fileStat.size > BigInt(maxBytes)) {
+    return { status: "invalid", reason: "receipt exceeds size bound" };
+  }
+  let realRoot;
+  let realFile;
+  try {
+    realRoot = fs.realpathSync(swarmRoot);
+    realFile = fs.realpathSync(absolute);
+  } catch (error) {
+    return boundedReadErrno(error);
+  }
+  const relative3 = path2.relative(realRoot, realFile);
+  if (relative3 === "" || relative3 === ".." || relative3.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative3)) {
+    return {
+      status: "invalid",
+      reason: "receipt escapes the project .swarm directory"
+    };
+  }
+  let fd;
+  try {
+    fd = fs.openSync(realFile, "r");
+  } catch (error) {
+    return boundedReadErrno(error);
+  }
+  try {
+    const openedStat = fs.fstatSync(fd, { bigint: true });
+    if (!openedStat.isFile() || openedStat.size > BigInt(maxBytes) || openedStat.dev !== fileStat.dev || openedStat.ino !== fileStat.ino) {
+      return {
+        status: "invalid",
+        reason: "receipt changed or grew during its bounded read"
+      };
+    }
+    const buffer = Buffer.allocUnsafe(maxBytes + 1);
+    const bytesRead = fs.readSync(fd, buffer, 0, maxBytes + 1, 0);
+    if (bytesRead > maxBytes) {
+      return { status: "invalid", reason: "receipt exceeds size bound" };
+    }
+    const postStat = fs.lstatSync(absolute, {
+      bigint: true,
+      throwIfNoEntry: false
+    });
+    if (!postStat || postStat.isSymbolicLink() || !postStat.isFile() || postStat.dev !== fileStat.dev || postStat.ino !== fileStat.ino) {
+      return {
+        status: "invalid",
+        reason: "receipt changed during its bounded read"
+      };
+    }
+    return { status: "ok", bytes: buffer.subarray(0, bytesRead) };
+  } catch (error) {
+    return boundedReadErrno(error);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+function readVerdictSettlementReceipt(directory, runId, phase) {
+  const relative3 = verdictSettlementRelativePath(runId, phase);
+  const absolute = path2.join(directory, ".swarm", relative3);
+  const read = readBoundedSwarmRegularFileBytes(path2.join(directory, ".swarm"), absolute, VERDICT_SETTLEMENT_MAX_RECEIPT_BYTES);
+  if (read.status !== "ok")
+    return read;
+  let parsed;
+  try {
+    parsed = JSON.parse(read.bytes.toString("utf-8"));
+  } catch {
+    return { status: "invalid", reason: "receipt is not valid JSON" };
+  }
+  const validated = PrReviewVerdictSettlementReceiptSchema.safeParse(parsed);
+  if (!validated.success) {
+    return { status: "invalid", reason: "receipt fails schema validation" };
+  }
+  return {
+    status: "ok",
+    receipt: validated.data,
+    rawSha256: createHash2("sha256").update(read.bytes).digest("hex")
+  };
+}
+function effectiveVerdictSettlementItems(receipt, currentUnclaimed) {
+  if (!receipt || currentUnclaimed.length === 0)
+    return [];
+  const unclaimed = new Set(currentUnclaimed);
+  return receipt.items.filter((item) => unclaimed.has(item.itemId));
+}
+function verdictSettlementDegradationActive(args) {
+  const { directory, runId, prHeadSha, revisionDigest } = args;
+  if (!runId || !prHeadSha || !revisionDigest)
+    return false;
+  const phases = [
+    { phase: "reviewer", unclaimed: args.reviewerUnclaimed },
+    { phase: "critic", unclaimed: args.criticUnclaimed }
+  ];
+  for (const { phase, unclaimed } of phases) {
+    if (unclaimed.length === 0)
+      continue;
+    const read = readVerdictSettlementReceipt(directory, runId, phase);
+    if (read.status !== "ok" || read.receipt.prHeadSha !== prHeadSha || read.receipt.revisionDigest !== revisionDigest) {
+      continue;
+    }
+    if (effectiveVerdictSettlementItems(read.receipt, unclaimed).length > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+var _internals = { findByBatchIdDetailed };
+
+// src/background/pending-delegations.ts
+init_bun_compat();
 init_logger();
 
 // src/background/delegation-health.ts
 init_zod();
-import * as fs from "fs";
-import * as path from "path";
+import * as fs2 from "fs";
+import * as path3 from "path";
 var BACKGROUND_DELEGATIONS_HEALTH_FILE = "background-delegations-health.json";
 var MAX_RECOVERY_LEDGER_BYTES = 4 * 1024 * 1024;
 var DelegationCheckpointAuditSchema = exports_external.object({
@@ -169,7 +1521,7 @@ function sleepSync(ms) {
 }
 var _healthInternals = {
   renameOnce: (from, to) => {
-    fs.renameSync(from, to);
+    fs2.renameSync(from, to);
   }
 };
 function healthArtifactPath(directory) {
@@ -178,7 +1530,7 @@ function healthArtifactPath(directory) {
 function readDelegationHealthArtifact(directory) {
   let raw;
   try {
-    raw = fs.readFileSync(healthArtifactPath(directory), "utf-8");
+    raw = fs2.readFileSync(healthArtifactPath(directory), "utf-8");
   } catch {
     return null;
   }
@@ -228,10 +1580,10 @@ function writeDelegationHealthArtifact(directory, update) {
   if (!parsed.success)
     return null;
   try {
-    fs.mkdirSync(path.resolve(directory, ".swarm"), { recursive: true });
+    fs2.mkdirSync(path3.resolve(directory, ".swarm"), { recursive: true });
     const target = healthArtifactPath(directory);
     const tmp = `${target}.tmp-${process.pid}-${Math.random().toString(36).slice(2, 10)}`;
-    fs.writeFileSync(tmp, `${JSON.stringify(parsed.data)}
+    fs2.writeFileSync(tmp, `${JSON.stringify(parsed.data)}
 `, "utf-8");
     let lastError;
     for (let attempt = 0;attempt < 5; attempt++) {
@@ -251,7 +1603,7 @@ function writeDelegationHealthArtifact(directory, update) {
     }
     if (lastError !== undefined) {
       try {
-        fs.rmSync(tmp, { force: true });
+        fs2.rmSync(tmp, { force: true });
       } catch {}
       return null;
     }
@@ -285,7 +1637,7 @@ function collectDelegationLedgerHealth(directory, options) {
   let ledgerBytes = 0;
   let ledgerExists = false;
   try {
-    ledgerBytes = fs.statSync(validateSwarmPath(directory, "background-delegations.jsonl")).size;
+    ledgerBytes = fs2.statSync(validateSwarmPath(directory, "background-delegations.jsonl")).size;
     ledgerExists = true;
   } catch {
     ledgerExists = false;
@@ -320,7 +1672,7 @@ function collectDelegationLedgerHealth(directory, options) {
 
 // src/background/pr-review-collection-receipt.ts
 init_zod();
-import { createHash } from "crypto";
+import { createHash as createHash3 } from "crypto";
 var PR_REVIEW_COLLECTION_RECEIPT_PREFIX = "[PR_REVIEW_COLLECTION_RECEIPT_V1] ";
 var PR_REVIEW_COLLECTION_RECEIPT_SHED_PREFIX = "[PR_REVIEW_COLLECTION_RECEIPT_SHED_V1] ";
 var MAX_PR_REVIEW_COLLECTION_RECEIPT_CHARS = 64 * 1024;
@@ -357,7 +1709,7 @@ var PrReviewCollectionReceiptShedMarkerSchema = exports_external.object({
   reviewItemDigest: exports_external.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
 function reviewItemDigest(reviewItemIds) {
-  return createHash("sha256").update(JSON.stringify(reviewItemIds)).digest("hex");
+  return createHash3("sha256").update(JSON.stringify(reviewItemIds)).digest("hex");
 }
 function encodePrReviewCollectionReceiptShedMarker(payload) {
   const marker = {
@@ -419,7 +1771,7 @@ function parsePrReviewCollectionReceiptFooter(binding, result) {
 
 // src/background/pr-review-contract.ts
 init_zod();
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 
 // src/pr-review/critic-routing.ts
 function prReviewFindingRequiresCritic(input) {
@@ -541,18 +1893,18 @@ var PrReviewResultLaneIdSchema = exports_external.string().trim().min(1).max(120
 var PrReviewResultChildSessionSchema = exports_external.string().trim().min(1).max(256);
 var PrReviewResultShaSchema = exports_external.string().trim().regex(/^[0-9a-f]{6,64}$/i);
 var PrReviewResultDigestSchema = exports_external.string().trim().regex(/^[0-9a-f]{64}$/i);
-function addDuplicateIssue(ctx, path2, label, value) {
+function addDuplicateIssue(ctx, path4, label, value) {
   ctx.addIssue({
     code: exports_external.ZodIssueCode.custom,
-    path: path2,
+    path: path4,
     message: `${label} must not contain duplicate value "${value}"`
   });
 }
-function assertUniqueStrings(values, ctx, path2, label) {
+function assertUniqueStrings(values, ctx, path4, label) {
   const seen = new Set;
   for (const value of values) {
     if (seen.has(value)) {
-      addDuplicateIssue(ctx, path2, label, value);
+      addDuplicateIssue(ctx, path4, label, value);
       return;
     }
     seen.add(value);
@@ -747,7 +2099,7 @@ function serializedPrReviewResultReceiptBytes(value) {
   return new TextEncoder().encode(JSON.stringify(value)).byteLength;
 }
 function prReviewLaneResultEnvelopeDigest(value) {
-  return createHash2("sha256").update(JSON.stringify(value)).digest("hex");
+  return createHash4("sha256").update(JSON.stringify(value)).digest("hex");
 }
 var PrReviewResultReceiptSchema = exports_external.object({
   schemaVersion: exports_external.literal(1),
@@ -1509,15 +2861,15 @@ function coordinationRowsToDelegations(directory) {
   }
 }
 function archiveShadowFileBestEffort(filePath) {
-  if (!fs2.existsSync(filePath))
+  if (!fs3.existsSync(filePath))
     return;
   const importedPath = importedShadowPath(filePath);
   try {
-    if (fs2.existsSync(importedPath))
+    if (fs3.existsSync(importedPath))
       return;
-    fs2.renameSync(filePath, importedPath);
+    fs3.renameSync(filePath, importedPath);
   } catch (error) {
-    warn(`[background] shadow archive failed for ${path2.basename(filePath)}: ${error instanceof Error ? error.message : String(error)}`);
+    warn(`[background] shadow archive failed for ${path4.basename(filePath)}: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
 function writeDelegationShadowProjection(directory, records) {
@@ -1525,8 +2877,8 @@ function writeDelegationShadowProjection(directory, records) {
   const payload = records.map((record) => JSON.stringify(record)).join(`
 `) + (records.length > 0 ? `
 ` : "");
-  fs2.writeFileSync(storePath(directory), payload, "utf-8");
-  fs2.writeFileSync(projectionMarkerPath(storePath(directory)), "", "utf-8");
+  fs3.writeFileSync(storePath(directory), payload, "utf-8");
+  fs3.writeFileSync(projectionMarkerPath(storePath(directory)), "", "utf-8");
 }
 function loadLegacyDelegationsStrict(directory) {
   const load = loadFoldedState(directory, { strict: true });
@@ -1543,17 +2895,17 @@ function delegationShadowMatches(directory, records) {
   return isDeepStrictEqual([...load.records.values()].sort((left, right) => left.correlationId.localeCompare(right.correlationId)), [...records].sort((left, right) => left.correlationId.localeCompare(right.correlationId)));
 }
 function delegationShadowDigest(directory, records) {
-  const hash = createHash3("sha256");
+  const hash = createHash5("sha256");
   hash.update(JSON.stringify(records));
   for (const filePath of [
     storePath(directory),
     checkpointPath(directory),
     manifestPath(directory)
   ]) {
-    if (!fs2.existsSync(filePath))
+    if (!fs3.existsSync(filePath))
       continue;
-    hash.update(path2.basename(filePath));
-    hash.update(fs2.readFileSync(filePath));
+    hash.update(path4.basename(filePath));
+    hash.update(fs3.readFileSync(filePath));
   }
   return hash.digest("hex");
 }
@@ -1567,7 +2919,7 @@ function ensureDelegationCoordinationImported(directory, createIfNeeded) {
   if (existing && existing.length > 0) {
     if (createIfNeeded)
       return "ready";
-    const markerPresent = fs2.existsSync(projectionMarkerPath(storePath(directory)));
+    const markerPresent = fs3.existsSync(projectionMarkerPath(storePath(directory)));
     const shadowMatches = markerPresent && delegationShadowMatches(directory, existing);
     if (!shadowMatches) {
       for (const filePath of [
@@ -1584,7 +2936,7 @@ function ensureDelegationCoordinationImported(directory, createIfNeeded) {
   const legacyRecords = loadLegacyDelegationsStrict(directory);
   if (legacyRecords === null)
     return "uncertain";
-  if (legacyRecords.length === 0 && !fs2.existsSync(storePath(directory)) && !fs2.existsSync(checkpointPath(directory)) && !fs2.existsSync(manifestPath(directory))) {
+  if (legacyRecords.length === 0 && !fs3.existsSync(storePath(directory)) && !fs3.existsSync(checkpointPath(directory)) && !fs3.existsSync(manifestPath(directory))) {
     if (!createIfNeeded)
       return "absent";
     withCoordinationTransaction(directory, () => {
@@ -1682,44 +3034,44 @@ var _checkpointInternals = {
     throw lastError;
   },
   renameOnce: (from, to) => {
-    fs2.renameSync(from, to);
+    fs3.renameSync(from, to);
   },
   syncSleep: portableSyncSleep
 };
 function writeDurableFileSync(target, contents) {
   const tmp = `${target}.tmp-${process.pid}-${Math.random().toString(36).slice(2, 10)}`;
   try {
-    const fd = fs2.openSync(tmp, "w");
+    const fd = fs3.openSync(tmp, "w");
     try {
       if (typeof contents === "string") {
-        fs2.writeSync(fd, contents);
+        fs3.writeSync(fd, contents);
       } else {
-        fs2.writeSync(fd, contents, 0, contents.length);
+        fs3.writeSync(fd, contents, 0, contents.length);
       }
-      fs2.fsyncSync(fd);
+      fs3.fsyncSync(fd);
     } finally {
-      fs2.closeSync(fd);
+      fs3.closeSync(fd);
     }
     _checkpointInternals.renameWithRetry(tmp, target);
   } catch (err) {
     try {
-      fs2.rmSync(tmp, { force: true });
+      fs3.rmSync(tmp, { force: true });
     } catch {}
     throw err;
   }
   try {
-    const dfd = fs2.openSync(path2.dirname(target), "r");
+    const dfd = fs3.openSync(path4.dirname(target), "r");
     try {
-      fs2.fsyncSync(dfd);
+      fs3.fsyncSync(dfd);
     } finally {
-      fs2.closeSync(dfd);
+      fs3.closeSync(dfd);
     }
   } catch {}
 }
 function readJsonFileWithRetry(target) {
   let raw;
   try {
-    raw = fs2.readFileSync(target, "utf-8");
+    raw = fs3.readFileSync(target, "utf-8");
   } catch (err) {
     const code = err.code;
     if (code === "ENOENT")
@@ -1753,7 +3105,7 @@ function readDelegationManifest(directory) {
 function readDelegationCheckpoint(directory) {
   let bytes = 0;
   try {
-    bytes = fs2.statSync(checkpointPath(directory)).size;
+    bytes = fs3.statSync(checkpointPath(directory)).size;
   } catch {}
   if (bytes > MAX_CHECKPOINT_BYTES) {
     return {
@@ -1773,7 +3125,7 @@ function readDelegationCheckpoint(directory) {
   return { kind: "ok", checkpoint: parsed.data, bytes };
 }
 function sha256Hex(data) {
-  return createHash3("sha256").update(data).digest("hex");
+  return createHash5("sha256").update(data).digest("hex");
 }
 function checkpointPayloadChecksum(checkpoint) {
   return sha256Hex(JSON.stringify([
@@ -1844,9 +3196,9 @@ function loadFoldedState(directory, options) {
       repairHint: CHECKPOINT_RESET_HINT
     };
   }
-  let stat;
+  let stat2;
   try {
-    stat = fs2.statSync(storePath(directory));
+    stat2 = fs3.statSync(storePath(directory));
   } catch (error) {
     return {
       status: "uncertain",
@@ -1855,10 +3207,10 @@ function loadFoldedState(directory, options) {
   }
   let tail;
   let mode;
-  if (stat.size >= checkpoint.cutLedgerBytes && checkpoint.cutLedgerBytes > 0) {
+  if (stat2.size >= checkpoint.cutLedgerBytes && checkpoint.cutLedgerBytes > 0) {
     const prefix = readLedgerRegion(directory, 0, checkpoint.cutLedgerBytes);
     if (sha256Hex(prefix) === checkpoint.cutLedgerDigest) {
-      const suffixBytes = stat.size - checkpoint.cutLedgerBytes;
+      const suffixBytes = stat2.size - checkpoint.cutLedgerBytes;
       if (suffixBytes > MAX_RECOVERY_LEDGER_BYTES) {
         return {
           status: "uncertain",
@@ -1868,11 +3220,11 @@ function loadFoldedState(directory, options) {
       tail = suffixBytes === 0 ? Buffer.alloc(0) : readLedgerRegion(directory, checkpoint.cutLedgerBytes, suffixBytes);
       mode = "checkpoint+ledger-suffix";
     } else {
-      tail = readBoundedRecentLedgerWindow(directory, stat.size);
+      tail = readBoundedRecentLedgerWindow(directory, stat2.size);
       mode = "checkpoint+tail";
     }
   } else {
-    tail = readBoundedRecentLedgerWindow(directory, stat.size);
+    tail = readBoundedRecentLedgerWindow(directory, stat2.size);
     mode = "checkpoint+tail";
   }
   const records = new Map;
@@ -1898,19 +3250,19 @@ function loadFoldedState(directory, options) {
   };
 }
 function readLedgerRegion(directory, offset, length) {
-  const fd = fs2.openSync(storePath(directory), "r");
+  const fd = fs3.openSync(storePath(directory), "r");
   try {
     const buffer = Buffer.alloc(length);
     let read = 0;
     while (read < length) {
-      const n = fs2.readSync(fd, buffer, read, length - read, offset + read);
+      const n = fs3.readSync(fd, buffer, read, length - read, offset + read);
       if (n <= 0)
         break;
       read += n;
     }
     return read === length ? buffer : buffer.subarray(0, read);
   } finally {
-    fs2.closeSync(fd);
+    fs3.closeSync(fd);
   }
 }
 function readBoundedRecentLedgerWindow(directory, size) {
@@ -1963,7 +3315,7 @@ function loadLegacyLedger(directory, strict) {
   if (!strict) {
     let raw2;
     try {
-      raw2 = fs2.readFileSync(storePath(directory), "utf-8");
+      raw2 = fs3.readFileSync(storePath(directory), "utf-8");
     } catch (err) {
       if (err.code !== "ENOENT") {
         warn(`[background] readDelegations failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -1991,8 +3343,8 @@ function loadLegacyLedger(directory, strict) {
   let absolutePath;
   try {
     absolutePath = storePath(directory);
-    const stat = fs2.statSync(absolutePath);
-    if (stat.size > MAX_RECOVERY_LEDGER_BYTES) {
+    const stat2 = fs3.statSync(absolutePath);
+    if (stat2.size > MAX_RECOVERY_LEDGER_BYTES) {
       return {
         status: "uncertain",
         reason: `background delegation ledger exceeds the ${MAX_RECOVERY_LEDGER_BYTES}-byte recovery bound`
@@ -2015,7 +3367,7 @@ function loadLegacyLedger(directory, strict) {
   }
   let raw;
   try {
-    raw = fs2.readFileSync(absolutePath, "utf-8");
+    raw = fs3.readFileSync(absolutePath, "utf-8");
   } catch (error) {
     return {
       status: "uncertain",
@@ -2366,7 +3718,7 @@ function compactDelegationsLocked(directory, options) {
   }
   let ledgerBytes;
   try {
-    ledgerBytes = fs2.readFileSync(storePath(directory));
+    ledgerBytes = fs3.readFileSync(storePath(directory));
   } catch (err) {
     if (err.code === "ENOENT") {
       return { status: "skipped", reason: "no ledger to compact" };
@@ -2407,7 +3759,7 @@ function compactDelegationsLocked(directory, options) {
     schemaVersion: 1,
     sequence: 1,
     writerId: WRITER_ID,
-    rootPath: path2.resolve(directory),
+    rootPath: path4.resolve(directory),
     createdAt: now,
     cutLedgerBytes,
     cutLedgerDigest: sha256Hex(ledgerBytes),
@@ -2459,7 +3811,7 @@ function compactDelegationsLocked(directory, options) {
     schemaVersion: 1,
     sequence,
     writerId: WRITER_ID,
-    rootPath: path2.resolve(directory),
+    rootPath: path4.resolve(directory),
     createdAt: now,
     cutLedgerBytes,
     cutLedgerDigest: sha256Hex(ledgerBytes),
@@ -2499,7 +3851,7 @@ function compactDelegationsLocked(directory, options) {
 `);
   let currentSize;
   try {
-    currentSize = fs2.statSync(storePath(directory)).size;
+    currentSize = fs3.statSync(storePath(directory)).size;
   } catch (err) {
     return {
       status: "uncertain",
@@ -2563,8 +3915,8 @@ function countCompleteLines(buffer) {
 }
 function maybeCompactDelegationsLocked(directory) {
   try {
-    const stat = fs2.statSync(storePath(directory));
-    if (stat.size <= DELEGATION_COMPACTION_HIGH_WATER_BYTES)
+    const stat2 = fs3.statSync(storePath(directory));
+    if (stat2.size <= DELEGATION_COMPACTION_HIGH_WATER_BYTES)
       return;
     const outcome = compactDelegationsLocked(directory, {});
     if (outcome.status === "uncertain") {
@@ -2575,7 +3927,7 @@ function maybeCompactDelegationsLocked(directory) {
   }
 }
 function ensureSwarmDir(directory) {
-  fs2.mkdirSync(path2.resolve(directory, ".swarm"), { recursive: true });
+  fs3.mkdirSync(path4.resolve(directory, ".swarm"), { recursive: true });
 }
 var DELEGATION_READ_RETRY_DELAY_MS = 25;
 var MAX_TRACKED_DELEGATION_READ_UNCERTAIN_ROOTS = 32;
@@ -2627,7 +3979,7 @@ function emitDelegationReadUncertainBounded(directory, outcome) {
     const rootKey = canonicalRootKeyFresh(directory);
     const now = Date.now();
     const last = delegationReadUncertainEmitAtByRoot.get(rootKey);
-    if (last !== undefined && now - last < _internals.delegationReadUncertainEmitCooldownMs) {
+    if (last !== undefined && now - last < _internals2.delegationReadUncertainEmitCooldownMs) {
       return;
     }
     delegationReadUncertainEmitAtByRoot.delete(rootKey);
@@ -2658,7 +4010,7 @@ function readDelegationsDetailed(directory) {
   const first = readDelegationLoadAttempt(directory);
   if (first.status === "ok")
     return first;
-  portableSyncSleep(_internals.readRetryDelayMs);
+  portableSyncSleep(_internals2.readRetryDelayMs);
   const second = readDelegationLoadAttempt(directory);
   if (second.status === "ok")
     return second;
@@ -2735,7 +4087,7 @@ function appendRecord(directory, record) {
     pruneCoordinationDelegationRows(directory);
     const current = getCoordinationState(directory, DELEGATION_COORDINATION_NAMESPACE, record.correlationId);
     const eventPayload = JSON.stringify(record);
-    const eventDigest = createHash3("sha256").update(eventPayload).digest("hex");
+    const eventDigest = createHash5("sha256").update(eventPayload).digest("hex");
     const result = transitionCoordinationState(directory, {
       namespace: DELEGATION_COORDINATION_NAMESPACE,
       entityKey: record.correlationId,
@@ -2753,7 +4105,7 @@ function appendRecord(directory, record) {
     if (result.outcome !== "applied" && result.outcome !== "duplicate") {
       throw new Error(`coordination append rejected for ${record.correlationId}: ${result.outcome}`);
     }
-    if (!fs2.existsSync(projectionMarkerPath(storePath(directory)))) {
+    if (!fs3.existsSync(projectionMarkerPath(storePath(directory)))) {
       const records = coordinationRowsToDelegations(directory);
       if (records)
         writeDelegationShadowProjection(directory, records);
@@ -2761,7 +4113,7 @@ function appendRecord(directory, record) {
     return;
   }
   ensureSwarmDir(directory);
-  fs2.appendFileSync(storePath(directory), `${JSON.stringify(record)}
+  fs3.appendFileSync(storePath(directory), `${JSON.stringify(record)}
 `, "utf-8");
 }
 function buildPendingRecord(input, now) {
@@ -2879,7 +4231,7 @@ function buildPromptSnapshot(text, maxChars) {
     text: bounded,
     chars: text.length,
     truncated,
-    digest: createHash3("sha256").update(text).digest("hex")
+    digest: createHash5("sha256").update(text).digest("hex")
   };
 }
 function isTypedTerminalStatus(status) {
@@ -2987,11 +4339,19 @@ async function publishPrReviewResultReceipt(directory, input) {
         };
         return;
       }
+      const duplicateFindingIdOwner = findCrossLaneFindingIdOwner(records, current, parsed.data);
+      if (duplicateFindingIdOwner) {
+        outcome = {
+          status: "conflict",
+          reason: `duplicate id ${duplicateFindingIdOwner.findingId} already published by lane ${duplicateFindingIdOwner.ownerLaneId}`
+        };
+        return;
+      }
       const staleContractAdmissionResult = {
         ...current.result ?? {
           chars: 0,
           truncated: false,
-          digest: createHash3("sha256").update("").digest("hex")
+          digest: createHash5("sha256").update("").digest("hex")
         },
         prReviewResultReceipt: parsed.data
       };
@@ -3005,7 +4365,7 @@ async function publishPrReviewResultReceipt(directory, input) {
         ...current.result ?? {
           chars: 0,
           truncated: false,
-          digest: createHash3("sha256").update("").digest("hex")
+          digest: createHash5("sha256").update("").digest("hex")
         },
         prReviewResultReceipt: parsed.data
       };
@@ -3036,6 +4396,142 @@ async function publishPrReviewResultReceipt(directory, input) {
     };
   }
 }
+async function supersedeStaleLivenessVerdictLane(directory, input) {
+  let outcome = {
+    status: "refused",
+    reason: "liveness supersession did not complete"
+  };
+  try {
+    await withEvidenceLock(directory, BACKGROUND_DELEGATIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+      const records = loadRecordsForWrite(directory);
+      if (records === null) {
+        outcome = {
+          status: "refused",
+          reason: "delegation state is uncertain"
+        };
+        return;
+      }
+      const record = findRecordForWrite(records, input.correlationId);
+      if (!record) {
+        outcome = {
+          status: "refused",
+          reason: `no delegation record for correlationId ${input.correlationId}`
+        };
+        return;
+      }
+      if (record.mode !== "swarm-pr-review:reviewer" && record.mode !== "swarm-pr-review:critic") {
+        outcome = {
+          status: "refused",
+          reason: `mode ${record.mode ?? "<none>"} is not a verdict lane (swarm-pr-review:reviewer|critic only)`
+        };
+        return;
+      }
+      if (record.status !== "stale") {
+        outcome = {
+          status: "refused",
+          reason: `record status is ${record.status}, not the liveness sweep's stale`
+        };
+        return;
+      }
+      const terminalClass = record.terminalResult?.result.workflowLaneFailureClass ?? record.result?.workflowLaneFailureClass;
+      if (terminalClass === "operator_cancelled") {
+        outcome = {
+          status: "refused",
+          reason: "terminal failure class operator_cancelled is never superseded by a later transcript"
+        };
+        return;
+      }
+      if (terminalClass !== "liveness") {
+        outcome = {
+          status: "refused",
+          reason: `terminal failure class ${terminalClass ?? "<none>"} is not liveness`
+        };
+        return;
+      }
+      let parentState;
+      try {
+        parentState = await readPrWorkflowGateStateFromDisk(directory, record.parentSessionId);
+      } catch (error) {
+        outcome = {
+          status: "refused",
+          reason: `parent gate state read failed (${error instanceof Error ? error.message : String(error)}); cannot verify verdict-settlement receipts`
+        };
+        return;
+      }
+      if (!parentState) {
+        outcome = {
+          status: "refused",
+          reason: `no PR_REVIEW gate state for parent session ${record.parentSessionId}; cannot verify verdict-settlement receipts`
+        };
+        return;
+      }
+      const runId = parentState.prReviewArtifactRunId ?? parentState.prReviewReservedRunId ?? parentState.prReviewTriggerEvalRunId;
+      if (!runId) {
+        outcome = {
+          status: "refused",
+          reason: "no resolvable pr-review run id in parent gate state; cannot verify verdict-settlement receipts"
+        };
+        return;
+      }
+      for (const phase of ["reviewer", "critic"]) {
+        const receiptRead = readVerdictSettlementReceipt(directory, runId, phase);
+        if (receiptRead.status === "absent")
+          continue;
+        if (receiptRead.status === "invalid") {
+          outcome = {
+            status: "refused",
+            reason: `verdict-settlement receipt for phase ${phase} under run ${runId} is unreadable (${receiptRead.reason}); cannot prove the lane uncited`
+          };
+          return;
+        }
+        if (receiptRead.receipt.runId !== runId) {
+          outcome = {
+            status: "refused",
+            reason: `verdict-settlement receipt under run ${runId} carries runId ${receiptRead.receipt.runId}; cannot prove the lane uncited`
+          };
+          return;
+        }
+        const cited = receiptRead.receipt.items.find((item) => item.sourceBatchId === record.batchId && item.sourceLaneId === record.laneId);
+        if (cited) {
+          outcome = {
+            status: "refused",
+            reason: `verdict-settlement receipt for phase ${phase} under run ${runId} cites lane ${record.laneId ?? record.correlationId} (batch ${record.batchId ?? "<none>"}, item ${cited.itemId}, ${cited.disposition}); a disclosed dead lane is never resurrected by a later transcript`
+          };
+          return;
+        }
+      }
+      const now = Date.now();
+      const supersedeResult = {
+        ...input.validatedResult
+      };
+      delete supersedeResult.error;
+      delete supersedeResult.workflowLaneFailureClass;
+      const terminal = buildTypedDelegationTerminal(record, "completed", supersedeResult, now);
+      const next = {
+        ...record,
+        schemaVersion: record.schemaVersion === 4 ? 4 : 3,
+        status: "completed",
+        updatedAt: now,
+        result: supersedeResult,
+        terminalResult: terminal,
+        completedAt: terminal.recordedAt
+      };
+      appendRecord(directory, next);
+      maybeCompactDelegationsLocked(directory);
+      outcome = {
+        status: "superseded",
+        reason: `lane ${record.laneId ?? record.correlationId} superseded its stale/liveness terminal with validated rows`
+      };
+    });
+    return outcome;
+  } catch (error) {
+    warn(`[background] supersedeStaleLivenessVerdictLane failed: ${error instanceof Error ? error.message : String(error)}`);
+    return {
+      status: "refused",
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
 function buildBackgroundCompletionEventId(input) {
   const canonical = JSON.stringify([
     input.correlationId,
@@ -3043,7 +4539,7 @@ function buildBackgroundCompletionEventId(input) {
     input.status,
     input.resultDigest
   ]);
-  return `bgc1:${createHash3("sha256").update(canonical).digest("hex")}`;
+  return `bgc1:${createHash5("sha256").update(canonical).digest("hex")}`;
 }
 function buildTypedDelegationTerminal(record, status, result, now) {
   return {
@@ -3110,6 +4606,31 @@ function findReceiptPublicationTarget(records, input) {
   }
   return { count, record: count === 1 ? record : null };
 }
+function findCrossLaneFindingIdOwner(records, incoming, receipt) {
+  const ownedByLane = new Map;
+  for (const sibling of records) {
+    if (sibling.correlationId === incoming.correlationId)
+      continue;
+    const siblingReceipt = recordedPrReviewResultReceipt(sibling);
+    if (!siblingReceipt)
+      continue;
+    if (siblingReceipt.workflowInstanceId !== receipt.workflowInstanceId) {
+      continue;
+    }
+    for (const finding of siblingReceipt.envelope.findings) {
+      if (!ownedByLane.has(finding.id)) {
+        ownedByLane.set(finding.id, siblingReceipt.laneId);
+      }
+    }
+  }
+  for (const finding of receipt.envelope.findings) {
+    const ownerLaneId = ownedByLane.get(finding.id);
+    if (ownerLaneId !== undefined) {
+      return { findingId: finding.id, ownerLaneId };
+    }
+  }
+  return null;
+}
 function settlementProvenanceFor(record) {
   const baseline = record.taskChangeContext?.baseline;
   if (!baseline)
@@ -3289,10 +4810,10 @@ function normalizeObservedFile(value) {
   if (typeof value !== "string")
     return null;
   const trimmed = value.trim().replace(/\\/g, "/");
-  if (trimmed.length === 0 || trimmed.length > 4096 || trimmed.includes("\x00") || path2.posix.isAbsolute(trimmed) || /^[A-Za-z]:\//.test(trimmed)) {
+  if (trimmed.length === 0 || trimmed.length > 4096 || trimmed.includes("\x00") || path4.posix.isAbsolute(trimmed) || /^[A-Za-z]:\//.test(trimmed)) {
     return null;
   }
-  const normalized = path2.posix.normalize(trimmed).replace(/^\.\//, "");
+  const normalized = path4.posix.normalize(trimmed).replace(/^\.\//, "");
   if (normalized === "." || normalized === ".." || normalized.startsWith("../") || normalized.endsWith("/")) {
     return null;
   }
@@ -3426,7 +4947,7 @@ function registerLegacyCoderSettlementReconciler(directory, reconciler) {
 function getLegacyCoderSettlementReconciler(directory) {
   return legacyCoderSettlementReconcilers.get(canonicalRootKeyFresh(directory));
 }
-var _internals = {
+var _internals2 = {
   readRetryDelayMs: DELEGATION_READ_RETRY_DELAY_MS,
   delegationReadUncertainEmitCooldownMs: DELEGATION_READ_UNCERTAIN_EMIT_COOLDOWN_MS,
   resetDelegationReadUncertainRegistry: () => {
@@ -3535,7 +5056,7 @@ async function claimDelegationIngestion(directory, correlationId, options) {
       }
       const disposition = current.status === "ingestion_error" || current.ingestion?.state === "claimed" ? "retry" : "claimed";
       const attempt = (current.ingestion?.attempt ?? 0) + 1;
-      const claimToken = createHash3("sha256").update(JSON.stringify([correlationId, options.claimantId, attempt, now])).digest("hex");
+      const claimToken = createHash5("sha256").update(JSON.stringify([correlationId, options.claimantId, attempt, now])).digest("hex");
       const next = {
         ...current,
         schemaVersion: current.schemaVersion === 4 ? 4 : 3,
@@ -3880,7 +5401,7 @@ function sweepStaleLocked(directory, timeoutMs, now, statuses = DEFAULT_SWEEPABL
       error: staleReason,
       chars: staleReason.length,
       truncated: false,
-      digest: createHash3("sha256").update(staleReason).digest("hex"),
+      digest: createHash5("sha256").update(staleReason).digest("hex"),
       workflowLaneFailureClass: failureClass
     };
     const staleTerminal = buildTypedDelegationTerminal(record, "stale", livenessResult, now);
@@ -3922,24 +5443,24 @@ async function sweepStaleDelegations(directory, timeoutMs, options = {}) {
   }
 }
 function fallbackRelativePath(correlationId) {
-  const digest = createHash3("sha256").update(correlationId).digest("hex");
-  return path2.join(BACKGROUND_DELEGATION_FALLBACK_DIR, `${digest}.json`);
+  const digest = createHash5("sha256").update(correlationId).digest("hex");
+  return path4.join(BACKGROUND_DELEGATION_FALLBACK_DIR, `${digest}.json`);
 }
 function fallbackPath(directory, correlationId) {
   return validateSwarmPath(directory, fallbackRelativePath(correlationId));
 }
 function fallbackDirectoryPath(directory) {
-  return path2.dirname(validateSwarmPath(directory, path2.join(BACKGROUND_DELEGATION_FALLBACK_DIR, ".containment-anchor")));
+  return path4.dirname(validateSwarmPath(directory, path4.join(BACKGROUND_DELEGATION_FALLBACK_DIR, ".containment-anchor")));
 }
 function readFallbackDirectory(directory) {
-  return fs2.readdirSync(fallbackDirectoryPath(directory), {
+  return fs3.readdirSync(fallbackDirectoryPath(directory), {
     withFileTypes: true
   });
 }
 async function readFallbackFile(directory, correlationId) {
   for (let attempt = 0;attempt < 5; attempt++) {
     try {
-      const raw = await fs2.promises.readFile(fallbackPath(directory, correlationId), "utf-8");
+      const raw = await fs3.promises.readFile(fallbackPath(directory, correlationId), "utf-8");
       const parsedJson = JSON.parse(raw);
       const parsed = FallbackArtifactSchema.safeParse(parsedJson);
       if (!parsed.success || parsed.data.correlationId !== correlationId) {
@@ -3949,7 +5470,7 @@ async function readFallbackFile(directory, correlationId) {
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT" && attempt < 4) {
-        await new Promise((resolve3) => setTimeout(resolve3, 10));
+        await new Promise((resolve4) => setTimeout(resolve4, 10));
         continue;
       }
       return null;
@@ -3965,14 +5486,14 @@ async function readDelegationFallback(directory, correlationId) {
 async function listDelegationFallbacks(directory) {
   let entries;
   try {
-    entries = _internals.readFallbackDirectory(directory).sort((a, b) => compareCodeUnits(a.name, b.name)).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).slice(0, MAX_LIVE_BACKGROUND_FALLBACKS);
+    entries = _internals2.readFallbackDirectory(directory).sort((a, b) => compareCodeUnits(a.name, b.name)).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).slice(0, MAX_LIVE_BACKGROUND_FALLBACKS);
   } catch {
     return [];
   }
   const artifacts = [];
   for (const entry of entries) {
     try {
-      const raw = await fs2.promises.readFile(path2.join(fallbackDirectoryPath(directory), entry.name), "utf-8");
+      const raw = await fs3.promises.readFile(path4.join(fallbackDirectoryPath(directory), entry.name), "utf-8");
       const parsed = FallbackArtifactSchema.safeParse(JSON.parse(raw));
       if (parsed.success)
         artifacts.push(parsed.data);
@@ -3985,7 +5506,7 @@ async function scanDelegationFallbacksForRecovery(directory) {
   let entries;
   try {
     fallbackDir = fallbackDirectoryPath(directory);
-    entries = _internals.readFallbackDirectory(directory).sort((a, b) => compareCodeUnits(a.name, b.name)).filter((entry) => entry.isFile() && entry.name.endsWith(".json"));
+    entries = _internals2.readFallbackDirectory(directory).sort((a, b) => compareCodeUnits(a.name, b.name)).filter((entry) => entry.isFile() && entry.name.endsWith(".json"));
   } catch (error) {
     if (error.code === "ENOENT") {
       return { status: "ok", owners: [] };
@@ -4003,17 +5524,17 @@ async function scanDelegationFallbacksForRecovery(directory) {
   }
   const artifacts = [];
   for (const entry of entries) {
-    const artifactPath = path2.join(fallbackDir, entry.name);
+    const artifactPath = path4.join(fallbackDir, entry.name);
     let raw;
     try {
-      const stat = fs2.statSync(artifactPath);
-      if (stat.size > MAX_RECOVERY_FALLBACK_BYTES) {
+      const stat2 = fs3.statSync(artifactPath);
+      if (stat2.size > MAX_RECOVERY_FALLBACK_BYTES) {
         return {
           status: "uncertain",
           reason: `background fallback artifact "${entry.name}" exceeds the recovery size bound`
         };
       }
-      raw = await fs2.promises.readFile(artifactPath, "utf-8");
+      raw = await fs3.promises.readFile(artifactPath, "utf-8");
     } catch (error) {
       return {
         status: "uncertain",
@@ -4048,7 +5569,7 @@ async function scanDelegationFallbacksForRecovery(directory) {
 }
 function countFallbackFiles(directory) {
   try {
-    return fs2.readdirSync(fallbackDirectoryPath(directory), {
+    return fs3.readdirSync(fallbackDirectoryPath(directory), {
       withFileTypes: true
     }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).length;
   } catch (err) {
@@ -4083,7 +5604,7 @@ async function writeDelegationFallback(directory, input, options = {}) {
       if (countFallbackFiles(directory) >= maxLive)
         return null;
       const absPath = fallbackPath(directory, input.correlationId);
-      fs2.mkdirSync(path2.dirname(absPath), { recursive: true });
+      fs3.mkdirSync(path4.dirname(absPath), { recursive: true });
       await bunWrite(absPath, `${JSON.stringify(parsed.data)}
 `);
       return parsed.data;
@@ -4099,7 +5620,7 @@ async function removeDelegationFallback(directory, correlationId) {
   try {
     return await withEvidenceLock(directory, BACKGROUND_DELEGATION_FALLBACK_DIR, STORE_LOCK_AGENT, FALLBACK_LOCK_TASK, async () => {
       try {
-        await fs2.promises.unlink(fallbackPath(directory, correlationId));
+        await fs3.promises.unlink(fallbackPath(directory, correlationId));
         return true;
       } catch (err) {
         return err.code === "ENOENT";
@@ -4171,7 +5692,7 @@ async function promoteDelegationFallback(directory, correlationId) {
       if (!promoted)
         return null;
       try {
-        await fs2.promises.unlink(fallbackPath(directory, correlationId));
+        await fs3.promises.unlink(fallbackPath(directory, correlationId));
       } catch (err) {
         if (err.code !== "ENOENT") {
           return null;
@@ -4189,11 +5710,11 @@ function reservationStorePath(directory) {
   return validateSwarmPath(directory, BACKGROUND_CODER_RESERVATIONS_FILE);
 }
 function reservationShadowDigest(directory, reservations) {
-  const hash = createHash3("sha256");
+  const hash = createHash5("sha256");
   hash.update(JSON.stringify(reservations));
   const filePath = reservationStorePath(directory);
-  if (fs2.existsSync(filePath)) {
-    hash.update(fs2.readFileSync(filePath));
+  if (fs3.existsSync(filePath)) {
+    hash.update(fs3.readFileSync(filePath));
   }
   return hash.digest("hex");
 }
@@ -4202,9 +5723,9 @@ function writeReservationShadowProjection(directory, reservations) {
     schemaVersion: 1,
     reservations
   });
-  fs2.writeFileSync(reservationStorePath(directory), `${JSON.stringify(parsed)}
+  fs3.writeFileSync(reservationStorePath(directory), `${JSON.stringify(parsed)}
 `, "utf-8");
-  fs2.writeFileSync(projectionMarkerPath(reservationStorePath(directory)), "", "utf-8");
+  fs3.writeFileSync(projectionMarkerPath(reservationStorePath(directory)), "", "utf-8");
 }
 function coordinationRowsToReservations(directory) {
   if (!projectDbExists(directory))
@@ -4231,14 +5752,14 @@ function scanLegacyBackgroundCoderReservationsForAdmission(directory) {
   let raw;
   try {
     absolutePath = reservationStorePath(directory);
-    const stat = fs2.statSync(absolutePath);
-    if (stat.size > MAX_BACKGROUND_CODER_RESERVATION_STORE_BYTES) {
+    const stat2 = fs3.statSync(absolutePath);
+    if (stat2.size > MAX_BACKGROUND_CODER_RESERVATION_STORE_BYTES) {
       return {
         status: "uncertain",
         reason: `background coder reservation store exceeds the ${MAX_BACKGROUND_CODER_RESERVATION_STORE_BYTES}-byte safety bound`
       };
     }
-    raw = fs2.readFileSync(absolutePath, "utf-8");
+    raw = fs3.readFileSync(absolutePath, "utf-8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return { status: "ok", reservations: [] };
@@ -4281,7 +5802,7 @@ function ensureReservationCoordinationImported(directory, createIfNeeded) {
     return "uncertain";
   if (existing && existing.length > 0) {
     const legacy2 = scanLegacyBackgroundCoderReservationsForAdmission(directory);
-    if (!fs2.existsSync(projectionMarkerPath(reservationStorePath(directory))) || legacy2.status !== "ok" || !isDeepStrictEqual(legacy2.reservations.sort((left, right) => left.reservationId.localeCompare(right.reservationId)), [...existing].sort((left, right) => left.reservationId.localeCompare(right.reservationId)))) {
+    if (!fs3.existsSync(projectionMarkerPath(reservationStorePath(directory))) || legacy2.status !== "ok" || !isDeepStrictEqual(legacy2.reservations.sort((left, right) => left.reservationId.localeCompare(right.reservationId)), [...existing].sort((left, right) => left.reservationId.localeCompare(right.reservationId)))) {
       archiveShadowFileBestEffort(reservationStorePath(directory));
     }
     writeReservationShadowProjection(directory, existing);
@@ -4292,7 +5813,7 @@ function ensureReservationCoordinationImported(directory, createIfNeeded) {
     recordLedgerUncertainty(directory, legacy.reason, "reservation-legacy-import");
     return "uncertain";
   }
-  if (legacy.reservations.length === 0 && !fs2.existsSync(reservationStorePath(directory))) {
+  if (legacy.reservations.length === 0 && !fs3.existsSync(reservationStorePath(directory))) {
     if (!createIfNeeded)
       return "absent";
     withCoordinationTransaction(directory, () => {
@@ -4341,7 +5862,7 @@ function ensureReservationCoordinationImported(directory, createIfNeeded) {
 }
 function buildBackgroundCoderReservationId(input) {
   const ownerIdentity = input.planTaskId === null ? ["call", input.parentSessionId, input.callID] : ["task", input.parentSessionId, input.planTaskId];
-  return `bgcr1:${createHash3("sha256").update(JSON.stringify(ownerIdentity)).digest("hex")}`;
+  return `bgcr1:${createHash5("sha256").update(JSON.stringify(ownerIdentity)).digest("hex")}`;
 }
 function scanBackgroundCoderReservationsForAdmission(directory) {
   const importState = ensureReservationCoordinationImported(directory, false);
@@ -4375,7 +5896,7 @@ async function writeBackgroundCoderReservations(directory, reservations) {
   if (importState === "ready") {
     try {
       withCoordinationTransaction(directory, () => {
-        const safetyBound = _internals.reservationCoordinationRowLimit;
+        const safetyBound = _internals2.reservationCoordinationRowLimit;
         const authoritativeCount = countCoordinationStates(directory, RESERVATION_COORDINATION_NAMESPACE);
         if (authoritativeCount > safetyBound) {
           throw new Error(`reservation coordination write exceeded its ${safetyBound}-row safety bound`);
@@ -4407,7 +5928,7 @@ async function writeBackgroundCoderReservations(directory, reservations) {
             payload: JSON.stringify(reservation),
             event: {
               streamId: reservation.reservationId,
-              idempotencyKey: createHash3("sha256").update(JSON.stringify(reservation)).digest("hex"),
+              idempotencyKey: createHash5("sha256").update(JSON.stringify(reservation)).digest("hex"),
               eventType: reservation.state,
               payload: JSON.stringify(reservation)
             }
@@ -4745,7 +6266,7 @@ async function reconcileLegacyCoderSettlements(directory, maxRecords, onReconcil
   const candidates = readDelegations(directory).filter((record) => record.normalizedAgent === "coder" && Boolean(record.legacyCoderSettlementTransfer) && Boolean(record.terminalResult)).slice(0, maxRecords);
   if (candidates.length === 0)
     return 0;
-  const { transferCoderSettlementToBackground } = await import("./coder-settlement-wwgdrzcb.js");
+  const { transferCoderSettlementToBackground } = await import("./coder-settlement-21zd1g3a.js");
   let transferred = 0;
   for (const record of candidates) {
     try {
@@ -5102,4 +6623,4 @@ async function maintainBackgroundDelegations(directory, options = {}) {
   return emitObservation("ok");
 }
 
-export { prReviewFindingRequiresCritic, PR_REVIEW_BASE_DIMENSION_IDS, PR_REVIEW_RISK_IMPACTS, PR_REVIEW_RISK_TAGS, prReviewLegacyTranscriptCompatibilityEnabled, PrReviewLaneResultEnvelopeSchema, decodePrReviewWorkflowBinding, prReviewLaneResultEnvelopeDigest, PrReviewResultReceiptSchema, PR_REVIEW_FINDINGS_MAX_BYTES, PR_REVIEW_HANDOFF_MAX_BYTES, PR_REVIEW_DISCARDED_EXAMPLE_ITEM_ID, PrReviewRunIdSchema, parsePrReviewRiskTagsField, PrReviewReviewerVerdictFieldsSchema, PrReviewCriticVerdictFieldsSchema, PR_REVIEW_VERDICT_ROW_DESCRIPTORS, parsePrReviewVerdictRow, generatePrReviewRunId, MAX_RECOVERY_LEDGER_BYTES, readDelegationHealthArtifact, collectDelegationLedgerHealth, MAX_PR_REVIEW_COLLECTION_RECEIPT_ITEM_IDS, BACKGROUND_DELEGATIONS_FILE, BACKGROUND_DELEGATION_FALLBACK_DIR, BACKGROUND_CODER_RESERVATIONS_FILE, BACKGROUND_DELEGATIONS_CHECKPOINT_FILE, BACKGROUND_DELEGATIONS_MANIFEST_FILE, MAX_LIVE_BACKGROUND_FALLBACKS, MAX_LIVE_BACKGROUND_CODER_RESERVATIONS, MAX_BACKGROUND_OBSERVED_FILES, MAX_BACKGROUND_ADVISORY_CHARS, LEGACY_CODER_SETTLEMENT_PENDING_ADVISORY_MARKER, DELEGATION_COMPACTION_LOW_WATER_BYTES, DELEGATION_COMPACTION_HIGH_WATER_BYTES, MAX_CHECKPOINT_BYTES, MAX_CHECKPOINT_RECORDS, TOMBSTONE_MIN_AGE_MS, BACKGROUND_INGESTION_LEASE_MS, BACKGROUND_CODER_RESERVATION_LEASE_MS, BACKGROUND_CODER_RESERVATION_LEASE_MAX_MS, BACKGROUND_CODER_RESERVATION_LEASE_MIN_MS, DEFAULT_STALE_DELEGATION_TIMEOUT_MS, DEFAULT_SWEEPABLE_DELEGATION_STATUSES, _checkpointInternals, isUnsettledWorktreeOwner, compactBackgroundDelegations, DELEGATION_READ_RETRY_DELAY_MS, readDelegationsDetailed, readDelegations, scanDelegationsForRecovery, findByCorrelationIdDetailed, findByCorrelationId, recordPendingDelegationDetailed, recordPendingDelegation, buildPromptSnapshot, appendDelegationTransition, publishPrReviewResultReceipt, buildBackgroundCompletionEventId, buildTypedDelegationTerminal, recordedPrReviewResultReceipt, claimTerminalResult, claimCoderSettlement, normalizeBackgroundObservedFiles, updateCoderSettlement, registerLegacyCoderSettlementReconciler, _internals, markLegacyCoderSettlementTransferPending, clearLegacyCoderSettlementTransferPending, claimDelegationIngestion, recordDelegationIngestionResult, putPendingBackgroundAdvisory, replacePendingBackgroundAdvisory, preparePendingBackgroundAdvisories, acknowledgeObservedBackgroundAdvisories, releasePreparedBackgroundAdvisories, findByBatchIdDetailed, findByBatchId, findOpenAsyncLaneBatches, isTerminalDelegationStatus, registerStaleSweepObserver, sweepStaleDelegations, readDelegationFallback, listDelegationFallbacks, scanDelegationFallbacksForRecovery, writeDelegationFallback, removeDelegationFallback, findDelegationForCompletion, promoteDelegationFallback, buildBackgroundCoderReservationId, scanBackgroundCoderReservationsForAdmission, reserveBackgroundCoderSlot, bindBackgroundCoderReservation, releaseBackgroundCoderReservation, maintainBackgroundDelegations };
+export { prReviewFindingRequiresCritic, PR_REVIEW_BASE_DIMENSION_IDS, PR_REVIEW_RISK_IMPACTS, PR_REVIEW_RISK_TAGS, prReviewLegacyTranscriptCompatibilityEnabled, PrReviewLaneResultEnvelopeSchema, decodePrReviewWorkflowBinding, prReviewLaneResultEnvelopeDigest, PrReviewResultReceiptSchema, PR_REVIEW_FINDINGS_MAX_BYTES, PR_REVIEW_HANDOFF_MAX_BYTES, PR_REVIEW_DISCARDED_EXAMPLE_ITEM_ID, PrReviewRunIdSchema, parsePrReviewRiskTagsField, PrReviewReviewerVerdictFieldsSchema, PrReviewCriticVerdictFieldsSchema, PR_REVIEW_VERDICT_ROW_DESCRIPTORS, parsePrReviewVerdictRow, generatePrReviewRunId, normalizeSessionID, prWorkflowSessionFileStem, WORKFLOW_GATE_DIR, workflowGateStateRelativePath, workflowGateStateLockRelativePath, workflowCheckoutMutationLockRelativePath, workflowGateStatePath, MAX_TRACKED_SESSIONS, CHECKOUT_MUTATION_ACTION_TIMEOUT_MS, isoNow, sameBigIntFileIdentity, normalizeComparableFsPath, rememberState, forgetTrackedPrWorkflowState, resetPrReviewPersistenceCaches, defaultPersistenceHooks, bindPrReviewPersistenceHooks, bindPrReviewStateCodec, ensurePrWorkflowSafeParentDirectory, writeAtomicJson, writePrWorkflowAtomicJson, readPrWorkflowGateStateFromDisk, readPrWorkflowGateStateFileFromDisk, readPrWorkflowGateStateCoordinationForRecovery, writeStateWhileLocked, appendObservabilityStateWhileLocked, deleteStateWhileLocked, terminalizePrWorkflowGateForSession, PrWorkflowCheckoutMutationTimeoutError, withPrWorkflowCheckoutMutationLock, withSessionStateMutation, deriveVerdictSettlementAdmission, deriveVerdictAttemptCounts, buildVerdictSettlementReceipt, persistVerdictSettlementReceipt, readVerdictSettlementReceipt, effectiveVerdictSettlementItems, verdictSettlementDegradationActive, MAX_RECOVERY_LEDGER_BYTES, readDelegationHealthArtifact, collectDelegationLedgerHealth, MAX_PR_REVIEW_COLLECTION_RECEIPT_ITEM_IDS, BACKGROUND_DELEGATIONS_FILE, BACKGROUND_DELEGATION_FALLBACK_DIR, BACKGROUND_CODER_RESERVATIONS_FILE, BACKGROUND_DELEGATIONS_CHECKPOINT_FILE, BACKGROUND_DELEGATIONS_MANIFEST_FILE, MAX_LIVE_BACKGROUND_FALLBACKS, MAX_LIVE_BACKGROUND_CODER_RESERVATIONS, MAX_BACKGROUND_OBSERVED_FILES, MAX_BACKGROUND_ADVISORY_CHARS, LEGACY_CODER_SETTLEMENT_PENDING_ADVISORY_MARKER, DELEGATION_COMPACTION_LOW_WATER_BYTES, DELEGATION_COMPACTION_HIGH_WATER_BYTES, MAX_CHECKPOINT_BYTES, MAX_CHECKPOINT_RECORDS, TOMBSTONE_MIN_AGE_MS, BACKGROUND_INGESTION_LEASE_MS, BACKGROUND_CODER_RESERVATION_LEASE_MS, BACKGROUND_CODER_RESERVATION_LEASE_MAX_MS, BACKGROUND_CODER_RESERVATION_LEASE_MIN_MS, DEFAULT_STALE_DELEGATION_TIMEOUT_MS, DEFAULT_SWEEPABLE_DELEGATION_STATUSES, _checkpointInternals, isUnsettledWorktreeOwner, compactBackgroundDelegations, DELEGATION_READ_RETRY_DELAY_MS, readDelegationsDetailed, readDelegations, scanDelegationsForRecovery, findByCorrelationIdDetailed, findByCorrelationId, recordPendingDelegationDetailed, recordPendingDelegation, buildPromptSnapshot, appendDelegationTransition, publishPrReviewResultReceipt, supersedeStaleLivenessVerdictLane, buildBackgroundCompletionEventId, buildTypedDelegationTerminal, recordedPrReviewResultReceipt, claimTerminalResult, claimCoderSettlement, normalizeBackgroundObservedFiles, updateCoderSettlement, registerLegacyCoderSettlementReconciler, _internals2 as _internals, markLegacyCoderSettlementTransferPending, clearLegacyCoderSettlementTransferPending, claimDelegationIngestion, recordDelegationIngestionResult, putPendingBackgroundAdvisory, replacePendingBackgroundAdvisory, preparePendingBackgroundAdvisories, acknowledgeObservedBackgroundAdvisories, releasePreparedBackgroundAdvisories, findByBatchIdDetailed, findByBatchId, findOpenAsyncLaneBatches, isTerminalDelegationStatus, registerStaleSweepObserver, sweepStaleDelegations, readDelegationFallback, listDelegationFallbacks, scanDelegationFallbacksForRecovery, writeDelegationFallback, removeDelegationFallback, findDelegationForCompletion, promoteDelegationFallback, buildBackgroundCoderReservationId, scanBackgroundCoderReservationsForAdmission, reserveBackgroundCoderSlot, bindBackgroundCoderReservation, releaseBackgroundCoderReservation, maintainBackgroundDelegations };