opencode-swarm 7.164.11 → 7.164.12

package/dist/cli/{index-5jx22kwc.js → index-8vw2pjgr.js}

@@ -1,13 +1,31 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-zjg4chy2.js";
+} from "./index-qqq04n70.js";
 import {
   bunWrite
-} from "./index-r3mvsbtq.js";
+} from "./index-p612v1mv.js";
+import {
+  MAX_COORDINATION_STATE_LIST_ROWS,
+  acquireCoordinationLease,
+  countCoordinationStates,
+  deleteCoordinationState,
+  deleteCoordinationStateWithinTransaction,
+  getCoordinationLease,
+  getCoordinationState,
+  importCoordinationOnce,
+  listCoordinationStates,
+  releaseCoordinationLease,
+  transitionCoordinationState,
+  withCoordinationTransaction
+} from "./index-c45662wc.js";
+import {
+  getProjectDb,
+  projectDbExists
+} from "./index-es64amqt.js";
 import {
   observeDelegationLedgerPressure
-} from "./index-dsg9dw3b.js";
+} from "./index-eed0gkv6.js";
 import {
   canonicalRootKeyFresh,
   sameProjectRoot
@@ -15,7 +33,7 @@ import {
 import {
   EvidenceLockTimeoutError,
   withEvidenceLock
-} from "./index-2bgr671r.js";
+} from "./index-2bhz5k91.js";
 import {
   exports_external,
   init_zod
@@ -1073,6 +1091,9 @@ var MAX_BACKGROUND_OBSERVED_FILES = 5000;
 var MAX_BACKGROUND_ADVISORY_CHARS = 4000;
 var LEGACY_CODER_SETTLEMENT_PENDING_ADVISORY_MARKER = "legacy coder settlement transfer is pending";
 var MAX_BACKGROUND_DELEGATION_GENERATION = 1e6;
+var DELEGATION_COORDINATION_NAMESPACE = "background.pending-delegation";
+var RESERVATION_COORDINATION_NAMESPACE = "background.coder-reservation";
+var RESERVATION_LEASE_NAMESPACE = "background.coder-reservation.lease";
 var MAX_RECOVERY_FALLBACK_BYTES = 1024 * 1024;
 var MAX_TRACKED_LENIENT_LEDGER_SIGNALS = 32;
 var LENIENT_LEDGER_SIGNAL_SOURCE = "lenient-read";
@@ -1081,6 +1102,8 @@ var DELEGATION_COMPACTION_HIGH_WATER_BYTES = 1024 * 1024;
 var MAX_CHECKPOINT_BYTES = 2 * 1024 * 1024;
 var CHECKPOINT_SELECTION_RESERVE_BYTES = 64 * 1024;
 var MAX_CHECKPOINT_RECORDS = 2048;
+var MAX_COORDINATION_DELEGATION_ROWS = MAX_CHECKPOINT_RECORDS * 2;
+var MAX_COORDINATION_TERMINAL_ROWS = MAX_CHECKPOINT_RECORDS;
 var TOMBSTONE_MIN_AGE_MS = 72 * 60 * 60 * 1000;
 var STORE_LOCK_AGENT = "background";
 var STORE_LOCK_TASK = "background-delegations";
@@ -1174,7 +1197,7 @@ var WorktreeDescriptorSchema = exports_external.object({
 }).strict();
 var TerminalResultSchema = exports_external.object({
   eventId: exports_external.string().min(1).max(256),
-  status: exports_external.enum(["completed", "error", "cancelled"]),
+  status: exports_external.enum(["completed", "error", "cancelled", "rejected"]),
   recordedAt: exports_external.number().int().nonnegative(),
   result: ResultSchema
 }).strict();
@@ -1343,6 +1366,7 @@ var RecordSchema = exports_external.object({
     "pending",
     "running",
     "ingestion_error",
+    "rejected",
     "completed",
     "error",
     "cancelled",
@@ -1406,6 +1430,173 @@ function checkpointPath(directory) {
 function manifestPath(directory) {
   return validateSwarmPath(directory, BACKGROUND_DELEGATIONS_MANIFEST_FILE);
 }
+function importedShadowPath(filePath) {
+  return `${filePath}.imported`;
+}
+function projectionMarkerPath(filePath) {
+  return `${filePath}.sqlite-projection`;
+}
+function coordinationReservationLeaseKey(reservation) {
+  return {
+    namespace: RESERVATION_LEASE_NAMESPACE,
+    entityKey: reservation.reservationId,
+    generation: reservation.generation ?? 1,
+    ownerToken: reservation.reservationId
+  };
+}
+function releaseReservationLeaseIfPresent(directory, reservation) {
+  const leaseKey = coordinationReservationLeaseKey(reservation);
+  const existing = getCoordinationLease(directory, leaseKey.namespace, leaseKey.entityKey);
+  if (!existing)
+    return;
+  if (existing.generation !== leaseKey.generation || existing.ownerToken !== leaseKey.ownerToken || !releaseCoordinationLease(directory, leaseKey.namespace, leaseKey.entityKey, leaseKey.generation, leaseKey.ownerToken)) {
+    throw new Error(`reservation lease authority mismatch for ${reservation.reservationId}`);
+  }
+}
+function coordinationRowsToDelegations(directory) {
+  if (!projectDbExists(directory))
+    return null;
+  try {
+    const rows = listCoordinationStates(directory, DELEGATION_COORDINATION_NAMESPACE, MAX_COORDINATION_STATE_LIST_ROWS);
+    if (rows.length >= MAX_COORDINATION_STATE_LIST_ROWS) {
+      throw new Error(`delegation coordination read reached its ${MAX_COORDINATION_STATE_LIST_ROWS}-row safety bound`);
+    }
+    return rows.map((row) => {
+      const parsed = RecordSchema.safeParse(JSON.parse(row.payload));
+      if (!parsed.success || parsed.data.correlationId !== row.entityKey || Math.max(parsed.data.generation ?? 1, 1) !== row.generation || parsed.data.status !== row.status) {
+        throw new Error(`delegation coordination row failed schema or authority binding validation for ${row.entityKey}`);
+      }
+      return parsed.data;
+    }).sort((left, right) => left.createdAt === right.createdAt ? left.correlationId.localeCompare(right.correlationId) : left.createdAt - right.createdAt);
+  } catch (error) {
+    recordLedgerUncertainty(directory, error instanceof Error ? error.message : String(error), "coordination-read");
+    return null;
+  }
+}
+function archiveShadowFileBestEffort(filePath) {
+  if (!fs2.existsSync(filePath))
+    return;
+  const importedPath = importedShadowPath(filePath);
+  try {
+    if (fs2.existsSync(importedPath))
+      return;
+    fs2.renameSync(filePath, importedPath);
+  } catch (error) {
+    warn(`[background] shadow archive failed for ${path2.basename(filePath)}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function writeDelegationShadowProjection(directory, records) {
+  ensureSwarmDir(directory);
+  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");
+}
+function loadLegacyDelegationsStrict(directory) {
+  const load = loadFoldedState(directory, { strict: true });
+  if (load.status === "uncertain") {
+    recordLedgerUncertainty(directory, load.reason, "legacy-import", load.repairHint);
+    return null;
+  }
+  return [...load.records.values()];
+}
+function delegationShadowMatches(directory, records) {
+  const load = loadFoldedState(directory, { strict: false });
+  if (load.status === "uncertain")
+    return false;
+  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");
+  hash.update(JSON.stringify(records));
+  for (const filePath of [
+    storePath(directory),
+    checkpointPath(directory),
+    manifestPath(directory)
+  ]) {
+    if (!fs2.existsSync(filePath))
+      continue;
+    hash.update(path2.basename(filePath));
+    hash.update(fs2.readFileSync(filePath));
+  }
+  return hash.digest("hex");
+}
+function ensureDelegationCoordinationImported(directory, createIfNeeded) {
+  const dbExists = projectDbExists(directory);
+  if (!createIfNeeded && !dbExists)
+    return "absent";
+  const existing = dbExists ? coordinationRowsToDelegations(directory) : null;
+  if (dbExists && existing === null)
+    return "uncertain";
+  if (existing && existing.length > 0) {
+    if (createIfNeeded)
+      return "ready";
+    const markerPresent = fs2.existsSync(projectionMarkerPath(storePath(directory)));
+    const shadowMatches = markerPresent && delegationShadowMatches(directory, existing);
+    if (!shadowMatches) {
+      for (const filePath of [
+        storePath(directory),
+        checkpointPath(directory),
+        manifestPath(directory)
+      ]) {
+        archiveShadowFileBestEffort(filePath);
+      }
+      writeDelegationShadowProjection(directory, existing);
+    }
+    return "ready";
+  }
+  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 (!createIfNeeded)
+      return "absent";
+    withCoordinationTransaction(directory, () => {
+      return;
+    });
+    return "ready";
+  }
+  const outcome = importCoordinationOnce(directory, {
+    source: BACKGROUND_DELEGATIONS_FILE,
+    sourceDigest: delegationShadowDigest(directory, legacyRecords),
+    rowCount: legacyRecords.length,
+    emptyNamespace: DELEGATION_COORDINATION_NAMESPACE
+  }, () => {
+    for (const record of legacyRecords) {
+      const result = transitionCoordinationState(directory, {
+        namespace: DELEGATION_COORDINATION_NAMESPACE,
+        entityKey: record.correlationId,
+        expectedRevision: null,
+        generation: Math.max(record.generation ?? 1, 1),
+        status: record.status,
+        payload: JSON.stringify(record)
+      });
+      if (result.outcome !== "applied") {
+        throw new Error(`delegation import failed for ${record.correlationId}: ${result.outcome}`);
+      }
+    }
+  });
+  if (outcome === "imported") {
+    archiveShadowFileBestEffort(storePath(directory));
+    archiveShadowFileBestEffort(checkpointPath(directory));
+    archiveShadowFileBestEffort(manifestPath(directory));
+    writeDelegationShadowProjection(directory, legacyRecords);
+  }
+  return "ready";
+}
+function pruneCoordinationDelegationRows(directory) {
+  const rows = listCoordinationStates(directory, DELEGATION_COORDINATION_NAMESPACE, MAX_COORDINATION_STATE_LIST_ROWS);
+  const terminals = rows.filter((row) => !isCheckpointLiveRecord(JSON.parse(row.payload))).sort((left, right) => left.updatedAt.localeCompare(right.updatedAt));
+  const excessTerminals = Math.max(0, terminals.length - MAX_COORDINATION_TERMINAL_ROWS);
+  for (const row of terminals.slice(0, excessTerminals)) {
+    deleteCoordinationState(directory, DELEGATION_COORDINATION_NAMESPACE, row.entityKey, row.revision);
+  }
+  const remaining = listCoordinationStates(directory, DELEGATION_COORDINATION_NAMESPACE, MAX_COORDINATION_STATE_LIST_ROWS);
+  if (remaining.length >= MAX_COORDINATION_DELEGATION_ROWS) {
+    throw new Error(`delegation coordination state reached its ${MAX_COORDINATION_DELEGATION_ROWS}-row safety bound`);
+  }
+}
 var SHA256_HEX = /^[0-9a-f]{64}$/;
 var CheckpointSchema = exports_external.object({
   schemaVersion: exports_external.literal(1),
@@ -1814,6 +2005,15 @@ function loadLegacyLedger(directory, strict) {
   };
 }
 function loadRecordsForWrite(directory) {
+  const importState = ensureDelegationCoordinationImported(directory, true);
+  if (importState === "uncertain")
+    return null;
+  if (importState === "ready") {
+    const coordination = coordinationRowsToDelegations(directory);
+    if (coordination !== null)
+      return coordination;
+    return null;
+  }
   const load = loadFoldedState(directory, { strict: false });
   if (load.status === "uncertain") {
     recordLedgerUncertainty(directory, load.reason, "mutation", load.repairHint);
@@ -1988,7 +2188,7 @@ function terminalEventStatusOf(record) {
   if (record.terminalResult) {
     return record.terminalResult.status;
   }
-  if (record.status === "completed" || record.status === "error" || record.status === "cancelled" || record.status === "stale") {
+  if (record.status === "completed" || record.status === "error" || record.status === "cancelled" || record.status === "rejected" || record.status === "stale") {
     return record.status;
   }
   return null;
@@ -2027,7 +2227,9 @@ function mergeCheckpointAudit(previous, previousCheckpoint, folded, healthLateTe
     if (terminalStatus) {
       const prevStatus = prevRecord ? terminalEventStatusOf(prevRecord) : null;
       if (prevStatus !== terminalStatus) {
-        audit.terminalsByStatus[terminalStatus] += 1;
+        if (terminalStatus !== "rejected") {
+          audit.terminalsByStatus[terminalStatus] += 1;
+        }
       }
       maxTerminal = Math.max(maxTerminal, record.terminalResult?.recordedAt ?? record.completedAt ?? 0);
     }
@@ -2046,6 +2248,47 @@ function mergeCheckpointAudit(previous, previousCheckpoint, folded, healthLateTe
 function capCounter(previous, delta) {
   return Number.isSafeInteger(previous + delta) ? previous + delta : Number.MAX_SAFE_INTEGER;
 }
+function synchronizeCoordinationAfterCompaction(directory, retained) {
+  if (!projectDbExists(directory))
+    return;
+  const retainedById = new Map(retained.map((record) => [record.correlationId, record]));
+  withCoordinationTransaction(directory, () => {
+    const rows = listCoordinationStates(directory, DELEGATION_COORDINATION_NAMESPACE, MAX_COORDINATION_STATE_LIST_ROWS);
+    if (rows.length >= MAX_COORDINATION_STATE_LIST_ROWS) {
+      throw new Error(`delegation coordination read reached its ${MAX_COORDINATION_STATE_LIST_ROWS}-row safety bound`);
+    }
+    for (const row of rows) {
+      const record = retainedById.get(row.entityKey);
+      if (!record) {
+        if (!deleteCoordinationStateWithinTransaction(directory, DELEGATION_COORDINATION_NAMESPACE, row.entityKey, row.revision)) {
+          throw new Error(`coordination compaction delete lost a concurrent update for ${row.entityKey}`);
+        }
+        continue;
+      }
+      const current = RecordSchema.safeParse(JSON.parse(row.payload));
+      if (!current.success) {
+        throw new Error(`delegation coordination row failed schema validation for ${row.entityKey}`);
+      }
+      if (isDeepStrictEqual(current.data, record))
+        continue;
+      const result = getProjectDb(directory).run(`UPDATE coordination_state
+				 SET revision = ?, generation = ?, status = ?, payload = ?, updated_at = ?
+				 WHERE namespace = ? AND entity_key = ? AND revision = ?`, [
+        row.revision + 1,
+        Math.max(record.generation ?? 1, 1),
+        record.status,
+        JSON.stringify(record),
+        new Date().toISOString(),
+        DELEGATION_COORDINATION_NAMESPACE,
+        row.entityKey,
+        row.revision
+      ]);
+      if (result.changes !== 1) {
+        throw new Error(`coordination compaction update lost a concurrent update for ${row.entityKey}`);
+      }
+    }
+  });
+}
 async function compactBackgroundDelegations(directory, options = {}) {
   try {
     let outcome = {
@@ -2063,7 +2306,24 @@ async function compactBackgroundDelegations(directory, options = {}) {
   }
 }
 function compactDelegationsLocked(directory, options) {
-  const load = loadFoldedState(directory, { strict: false });
+  const hasAuthority = projectDbExists(directory);
+  const authoritative = hasAuthority ? coordinationRowsToDelegations(directory) : null;
+  const manifestRead = hasAuthority ? readDelegationManifest(directory) : null;
+  const checkpointRead = hasAuthority ? readDelegationCheckpoint(directory) : null;
+  const manifest = manifestRead?.kind === "ok" && sameProjectRoot(manifestRead.manifest.rootPath, directory) ? manifestRead.manifest : null;
+  const existingCheckpoint = checkpointRead?.kind === "ok" && sameProjectRoot(checkpointRead.checkpoint.rootPath, directory) ? checkpointRead.checkpoint : null;
+  if (hasAuthority && authoritative === null) {
+    const reason = "SQLite delegation coordination authority is unreadable; refusing legacy compaction fallback";
+    recordLedgerUncertainty(directory, reason, "compaction");
+    return { status: "uncertain", reason };
+  }
+  const load = hasAuthority ? {
+    status: "ok",
+    mode: "legacy",
+    records: new Map((authoritative ?? []).map((record) => [record.correlationId, record])),
+    manifest,
+    checkpoint: existingCheckpoint
+  } : loadFoldedState(directory, { strict: false });
   if (load.status === "uncertain") {
     recordLedgerUncertainty(directory, load.reason, "compaction", load.repairHint);
     return { status: "uncertain", reason: load.reason };
@@ -2218,6 +2478,13 @@ function compactDelegationsLocked(directory, options) {
   }
   const tailContent = currentSize > cutLedgerBytes ? readLedgerRegion(directory, cutLedgerBytes, currentSize - cutLedgerBytes) : Buffer.alloc(0);
   writeDurableFileSync(storePath(directory), tailContent);
+  try {
+    synchronizeCoordinationAfterCompaction(directory, [...live, ...keptClosed]);
+  } catch (error) {
+    const reason = `coordination authority could not be synchronized after compaction: ${error instanceof Error ? error.message : String(error)}`;
+    recordLedgerUncertainty(directory, reason, "compaction");
+    return { status: "uncertain", reason };
+  }
   try {
     const pressurePct = Math.min(100, Math.round(tailContent.length / MAX_RECOVERY_LEDGER_BYTES * 1000) / 10);
     writeDelegationHealthArtifact(directory, {
@@ -2275,6 +2542,15 @@ function ensureSwarmDir(directory) {
   fs2.mkdirSync(path2.resolve(directory, ".swarm"), { recursive: true });
 }
 function readDelegations(directory) {
+  const importState = ensureDelegationCoordinationImported(directory, false);
+  if (importState === "uncertain")
+    return [];
+  if (importState === "ready") {
+    const coordination = coordinationRowsToDelegations(directory);
+    if (coordination !== null)
+      return coordination;
+    return [];
+  }
   const load = loadFoldedState(directory, { strict: false });
   if (load.status === "uncertain") {
     warn(`[background] readDelegations: authoritative state uncertain (${load.reason}); returning empty`);
@@ -2283,6 +2559,29 @@ function readDelegations(directory) {
   return [...load.records.values()];
 }
 function scanDelegationsForRecovery(directory) {
+  const importState = ensureDelegationCoordinationImported(directory, false);
+  if (importState === "uncertain") {
+    return {
+      status: "uncertain",
+      reason: "background delegation coordination state is uncertain",
+      source: "unknown"
+    };
+  }
+  if (importState === "ready") {
+    const coordination = coordinationRowsToDelegations(directory);
+    if (coordination !== null) {
+      return {
+        status: "ok",
+        owners: coordination,
+        source: "checkpoint+tail"
+      };
+    }
+    return {
+      status: "uncertain",
+      reason: "background delegation coordination state is unreadable or over-bound",
+      source: "unknown"
+    };
+  }
   const load = loadFoldedState(directory, { strict: true });
   if (load.status === "uncertain") {
     const manifestKind = readDelegationManifest(directory).kind;
@@ -2306,6 +2605,39 @@ function findByCorrelationId(directory, correlationId) {
   return null;
 }
 function appendRecord(directory, record) {
+  const importState = ensureDelegationCoordinationImported(directory, true);
+  if (importState === "uncertain") {
+    throw new Error("delegation coordination authority is uncertain");
+  }
+  if (importState === "ready") {
+    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 result = transitionCoordinationState(directory, {
+      namespace: DELEGATION_COORDINATION_NAMESPACE,
+      entityKey: record.correlationId,
+      expectedRevision: current?.revision ?? null,
+      generation: Math.max(record.generation ?? 1, 1),
+      status: record.status,
+      payload: eventPayload,
+      event: {
+        streamId: record.correlationId,
+        idempotencyKey: `${record.status}:${eventDigest}`,
+        eventType: record.status,
+        payload: eventPayload
+      }
+    });
+    if (result.outcome !== "applied" && result.outcome !== "duplicate") {
+      throw new Error(`coordination append rejected for ${record.correlationId}: ${result.outcome}`);
+    }
+    if (!fs2.existsSync(projectionMarkerPath(storePath(directory)))) {
+      const records = coordinationRowsToDelegations(directory);
+      if (records)
+        writeDelegationShadowProjection(directory, records);
+    }
+    return;
+  }
   ensureSwarmDir(directory);
   fs2.appendFileSync(storePath(directory), `${JSON.stringify(record)}
 `, "utf-8");
@@ -2451,7 +2783,7 @@ async function appendDelegationTransition(directory, correlationId, transition)
         ...current,
         schemaVersion: transition.result?.prReviewResultReceipt ? 4 : current.schemaVersion === 1 ? 2 : current.schemaVersion,
         status: transition.status,
-        updatedAt: now,
+        updatedAt: transition.updatedAt ?? now,
         ...transition.completedAt !== undefined ? { completedAt: transition.completedAt } : transition.status === "completed" || transition.status === "error" ? { completedAt: now } : {},
         ...transition.result ? { result: transition.result } : {}
       };
@@ -2927,7 +3259,9 @@ var _internals = {
   resetLegacyCoderSettlementReconcilers: () => {
     legacyCoderSettlementReconcilers.clear();
     legacyCoderSettlementReconcilerOrder.length = 0;
-  }
+  },
+  reservationCoordinationRowLimit: MAX_COORDINATION_STATE_LIST_ROWS,
+  writeBackgroundCoderReservations
 };
 async function markLegacyCoderSettlementTransferPending(directory, correlationId, transfer) {
   return updateLegacyCoderSettlementTransfer(directory, correlationId, transfer);
@@ -3626,11 +3960,45 @@ var MAX_BACKGROUND_CODER_RESERVATION_STORE_BYTES = 2 * 1024 * 1024;
 function reservationStorePath(directory) {
   return validateSwarmPath(directory, BACKGROUND_CODER_RESERVATIONS_FILE);
 }
-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")}`;
+function reservationShadowDigest(directory, reservations) {
+  const hash = createHash3("sha256");
+  hash.update(JSON.stringify(reservations));
+  const filePath = reservationStorePath(directory);
+  if (fs2.existsSync(filePath)) {
+    hash.update(fs2.readFileSync(filePath));
+  }
+  return hash.digest("hex");
 }
-function scanBackgroundCoderReservationsForAdmission(directory) {
+function writeReservationShadowProjection(directory, reservations) {
+  const parsed = BackgroundCoderReservationStoreSchema.parse({
+    schemaVersion: 1,
+    reservations
+  });
+  fs2.writeFileSync(reservationStorePath(directory), `${JSON.stringify(parsed)}
+`, "utf-8");
+  fs2.writeFileSync(projectionMarkerPath(reservationStorePath(directory)), "", "utf-8");
+}
+function coordinationRowsToReservations(directory) {
+  if (!projectDbExists(directory))
+    return null;
+  try {
+    const rows = listCoordinationStates(directory, RESERVATION_COORDINATION_NAMESPACE, MAX_COORDINATION_STATE_LIST_ROWS);
+    if (rows.length >= MAX_COORDINATION_STATE_LIST_ROWS) {
+      throw new Error(`reservation coordination read reached its ${MAX_COORDINATION_STATE_LIST_ROWS}-row safety bound`);
+    }
+    return rows.map((row) => {
+      const parsed = BackgroundCoderReservationSchema.safeParse(JSON.parse(row.payload));
+      if (!parsed.success || parsed.data.reservationId !== row.entityKey || (parsed.data.generation ?? 1) !== row.generation || parsed.data.state !== row.status) {
+        throw new Error(`reservation coordination row failed schema or authority binding validation for ${row.entityKey}`);
+      }
+      return parsed.data;
+    }).sort((left, right) => left.createdAt === right.createdAt ? left.reservationId.localeCompare(right.reservationId) : left.createdAt - right.createdAt);
+  } catch (error) {
+    recordLedgerUncertainty(directory, error instanceof Error ? error.message : String(error), "reservation-coordination-read");
+    return null;
+  }
+}
+function scanLegacyBackgroundCoderReservationsForAdmission(directory) {
   let absolutePath;
   let raw;
   try {
@@ -3676,6 +4044,96 @@ function scanBackgroundCoderReservationsForAdmission(directory) {
   }
   return { status: "ok", reservations: parsed.data.reservations };
 }
+function ensureReservationCoordinationImported(directory, createIfNeeded) {
+  const dbExists = projectDbExists(directory);
+  if (!createIfNeeded && !dbExists)
+    return "absent";
+  const existing = dbExists ? coordinationRowsToReservations(directory) : null;
+  if (dbExists && existing === null)
+    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)))) {
+      archiveShadowFileBestEffort(reservationStorePath(directory));
+    }
+    writeReservationShadowProjection(directory, existing);
+    return "ready";
+  }
+  const legacy = scanLegacyBackgroundCoderReservationsForAdmission(directory);
+  if (legacy.status === "uncertain") {
+    recordLedgerUncertainty(directory, legacy.reason, "reservation-legacy-import");
+    return "uncertain";
+  }
+  if (legacy.reservations.length === 0 && !fs2.existsSync(reservationStorePath(directory))) {
+    if (!createIfNeeded)
+      return "absent";
+    withCoordinationTransaction(directory, () => {
+      return;
+    });
+    return "ready";
+  }
+  const outcome = importCoordinationOnce(directory, {
+    source: BACKGROUND_CODER_RESERVATIONS_FILE,
+    sourceDigest: reservationShadowDigest(directory, legacy.reservations),
+    rowCount: legacy.reservations.length,
+    emptyNamespace: RESERVATION_COORDINATION_NAMESPACE
+  }, () => {
+    for (const reservation of legacy.reservations) {
+      const result = transitionCoordinationState(directory, {
+        namespace: RESERVATION_COORDINATION_NAMESPACE,
+        entityKey: reservation.reservationId,
+        expectedRevision: null,
+        generation: reservation.generation ?? 1,
+        status: reservation.state,
+        payload: JSON.stringify(reservation)
+      });
+      if (result.outcome !== "applied") {
+        throw new Error(`reservation import failed for ${reservation.reservationId}: ${result.outcome}`);
+      }
+      if (reservation.leaseExpiresAt !== undefined) {
+        const lease = acquireCoordinationLease(directory, {
+          ...coordinationReservationLeaseKey(reservation),
+          leaseExpiresAt: new Date(reservation.leaseExpiresAt).toISOString(),
+          payload: JSON.stringify({
+            parentSessionId: reservation.parentSessionId,
+            correlationId: reservation.correlationId
+          })
+        });
+        if (lease.outcome === "held" || lease.outcome === "stale_generation") {
+          throw new Error(`reservation lease import failed for ${reservation.reservationId}: ${lease.outcome}`);
+        }
+      }
+    }
+  });
+  if (outcome === "imported") {
+    archiveShadowFileBestEffort(reservationStorePath(directory));
+    writeReservationShadowProjection(directory, legacy.reservations);
+  }
+  return "ready";
+}
+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")}`;
+}
+function scanBackgroundCoderReservationsForAdmission(directory) {
+  const importState = ensureReservationCoordinationImported(directory, false);
+  if (importState === "uncertain") {
+    return {
+      status: "uncertain",
+      reason: "background coder reservation coordination state is uncertain"
+    };
+  }
+  if (importState === "ready") {
+    const reservations = coordinationRowsToReservations(directory);
+    if (reservations !== null)
+      return { status: "ok", reservations };
+    return {
+      status: "uncertain",
+      reason: "background coder reservation coordination state is unreadable or over-bound"
+    };
+  }
+  return scanLegacyBackgroundCoderReservationsForAdmission(directory);
+}
 async function writeBackgroundCoderReservations(directory, reservations) {
   const parsed = BackgroundCoderReservationStoreSchema.safeParse({
     schemaVersion: 1,
@@ -3683,6 +4141,77 @@ async function writeBackgroundCoderReservations(directory, reservations) {
   });
   if (!parsed.success)
     return false;
+  const importState = ensureReservationCoordinationImported(directory, true);
+  if (importState === "uncertain")
+    return false;
+  if (importState === "ready") {
+    try {
+      withCoordinationTransaction(directory, () => {
+        const safetyBound = _internals.reservationCoordinationRowLimit;
+        const authoritativeCount = countCoordinationStates(directory, RESERVATION_COORDINATION_NAMESPACE);
+        if (authoritativeCount > safetyBound) {
+          throw new Error(`reservation coordination write exceeded its ${safetyBound}-row safety bound`);
+        }
+        const currentRows = listCoordinationStates(directory, RESERVATION_COORDINATION_NAMESPACE, safetyBound);
+        if (currentRows.length !== authoritativeCount) {
+          throw new Error("reservation coordination state changed during bounded reconciliation");
+        }
+        const current = new Map(currentRows.map((row) => [row.entityKey, row]));
+        const nextIds = new Set(parsed.data.reservations.map((entry) => entry.reservationId));
+        for (const [reservationId, row] of current) {
+          if (nextIds.has(reservationId))
+            continue;
+          const currentReservation = BackgroundCoderReservationSchema.parse(JSON.parse(row.payload));
+          const deleted = deleteCoordinationState(directory, RESERVATION_COORDINATION_NAMESPACE, reservationId, row.revision);
+          if (!deleted) {
+            throw new Error(`reservation delete conflict for ${reservationId}`);
+          }
+          releaseReservationLeaseIfPresent(directory, currentReservation);
+        }
+        for (const reservation of parsed.data.reservations) {
+          const row = current.get(reservation.reservationId);
+          const result = transitionCoordinationState(directory, {
+            namespace: RESERVATION_COORDINATION_NAMESPACE,
+            entityKey: reservation.reservationId,
+            expectedRevision: row?.revision ?? null,
+            generation: reservation.generation ?? 1,
+            status: reservation.state,
+            payload: JSON.stringify(reservation),
+            event: {
+              streamId: reservation.reservationId,
+              idempotencyKey: createHash3("sha256").update(JSON.stringify(reservation)).digest("hex"),
+              eventType: reservation.state,
+              payload: JSON.stringify(reservation)
+            }
+          });
+          if (result.outcome !== "applied" && result.outcome !== "duplicate") {
+            throw new Error(`reservation write failed for ${reservation.reservationId}: ${result.outcome}`);
+          }
+          const leaseKey = coordinationReservationLeaseKey(reservation);
+          if (reservation.leaseExpiresAt !== undefined) {
+            const lease = acquireCoordinationLease(directory, {
+              ...leaseKey,
+              leaseExpiresAt: new Date(reservation.leaseExpiresAt).toISOString(),
+              payload: JSON.stringify({
+                parentSessionId: reservation.parentSessionId,
+                correlationId: reservation.correlationId
+              })
+            });
+            if (lease.outcome === "held" || lease.outcome === "stale_generation") {
+              throw new Error(`reservation lease write failed for ${reservation.reservationId}: ${lease.outcome}`);
+            }
+          } else {
+            releaseReservationLeaseIfPresent(directory, reservation);
+          }
+        }
+      });
+      writeReservationShadowProjection(directory, parsed.data.reservations);
+      return true;
+    } catch (error) {
+      warn(`[background] reservation coordination write failed: ${error instanceof Error ? error.message : String(error)}`);
+      return false;
+    }
+  }
   try {
     await bunWrite(reservationStorePath(directory), `${JSON.stringify(parsed.data)}
 `);
@@ -3988,7 +4517,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-0rfk8y11.js");
+  const { transferCoderSettlementToBackground } = await import("./coder-settlement-yh1q5fr3.js");
   let transferred = 0;
   for (const record of candidates) {
     try {