opencode-swarm 7.164.11 → 7.164.12

package/dist/cli/{index-c5v1w13g.js → index-wknpkfm8.js}

@@ -1,31 +1,42 @@
 // @bun
 import {
-  computePlanStructureHash,
-  derivePlanId
-} from "./index-e90em0x4.js";
-import {
-  canonicalExistingFilesystemPath,
-  legacyCanonicalExistingFilesystemPath
-} from "./index-ry16d01s.js";
+  computePlanStructureHash
+} from "./index-4vb56w2k.js";
 import {
   appendCoreEventSync
-} from "./index-4gqxppcx.js";
+} from "./index-mee9maf5.js";
 import {
   unsafePathTextReason
 } from "./index-556ja8an.js";
 import {
-  PlanSchema
-} from "./index-rhqdsc1x.js";
+  deleteCoordinationState,
+  derivePlanId,
+  importCoordinationOnce,
+  listCoordinationStates,
+  transitionCoordinationState,
+  transitionCoordinationStateWithinTransaction,
+  withCoordinationTransaction
+} from "./index-c45662wc.js";
+import {
+  getProjectDb
+} from "./index-es64amqt.js";
+import {
+  canonicalExistingFilesystemPath,
+  legacyCanonicalExistingFilesystemPath
+} from "./index-ry16d01s.js";
 import {
   assertProjectRoot
-} from "./index-2bgr671r.js";
+} from "./index-2bhz5k91.js";
 import {
   atomicWriteSwarmFile,
   atomicWriteSwarmFileSync
-} from "./index-9gxbjkts.js";
+} from "./index-ewv8qa8q.js";
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";
+import {
+  PlanSchema
+} from "./index-vw66q1rw.js";
 import {
   __toESM
 } from "./index-a76rekgs.js";
@@ -158,6 +169,17 @@ function registerScopeBinding(binding) {
   pendingScopeBindings.set(key, binding);
   return { ok: true, binding };
 }
+function getActiveScopeBindingsForSession(input) {
+  sweepExpired();
+  const workspaceIdentity = canonicalWorkspaceIdentity(input.directory);
+  if (!workspaceIdentity || !input.activeSessionId.trim())
+    return [];
+  const now = Date.now();
+  return [...pendingScopeBindings.values()].filter((binding) => binding.workspaceIdentity === workspaceIdentity && binding.ownerSessionId === input.activeSessionId && binding.activation === "active" && binding.lifecycleState === "live" && binding.expiresAt > now && isDispatchCorrelated(binding));
+}
+function isDispatchCorrelated(binding) {
+  return typeof binding.dispatchCallId === "string" && binding.dispatchCallId.length > 0 && binding.ownerMessageId === binding.dispatchCallId && typeof binding.parentOwnerSessionId === "string" && binding.parentOwnerSessionId.length > 0 && binding.ownerSessionId !== binding.parentOwnerSessionId && binding.parentCallId === binding.dispatchCallId;
+}
 function clearScopeBindings(predicate) {
   const removed = [];
   if (!predicate) {
@@ -278,28 +300,22 @@ var MAX_SCOPE_BYTES = 2 * 1024 * 1024;
 var MAX_BINDING_FILES_TO_SCAN = 1e4;
 var MAX_TOMBSTONE_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 var MAX_DURABLE_TOMBSTONES = 256;
+var SCOPE_BINDING_COORDINATION_NAMESPACE = "scope-binding";
+var SCOPE_BINDING_COORDINATION_IMPORT_SOURCE = "scope-binding-v2";
 var liveBindingCapacity = MAX_PENDING_SCOPE_BINDINGS;
 var bindingFileScanCapacity = MAX_BINDING_FILES_TO_SCAN;
 var maintenanceFileScanCapacity = MAX_BINDING_FILES_TO_SCAN * 2;
 var MAX_MAINTENANCE_JOBS = 64;
 var maintenanceJobs = new Map;
 var lockfileWithSync = import_proper_lockfile.default;
-var syncLockWait = new Int32Array(new SharedArrayBuffer(4));
-function lockSyncWithBoundedRetry(targetPath, attempts = 41) {
-  let lastError;
-  for (let attempt = 0;attempt < attempts; attempt++) {
-    try {
-      return lockfileWithSync.lockSync(targetPath, {
-        stale: LOCK_STALE_MS,
-        realpath: false
-      });
-    } catch (error) {
-      lastError = error;
-      if (attempt + 1 < attempts)
-        Atomics.wait(syncLockWait, 0, 0, 25);
-    }
+
+class ScopeCoordinationAbort extends Error {
+  failure;
+  constructor(failure) {
+    super(failure.message);
+    this.failure = failure;
+    this.name = "ScopeCoordinationAbort";
   }
-  throw lastError instanceof Error ? lastError : new Error("Lock unavailable");
 }
 var WINDOWS_RESERVED = new Set([
   "CON",
@@ -438,9 +454,6 @@ function ensureLockTargetSync(targetPath) {
     return false;
   }
 }
-function exactBindingPrefix(taskId) {
-  return `binding-${taskId}-`;
-}
 function readBoundedFile(filePath) {
   const nofollow = fs.constants.O_NOFOLLOW ?? 0;
   let fd;
@@ -464,6 +477,365 @@ function readBoundedFile(filePath) {
     } catch {}
   }
 }
+function scopeBindingArchivePath(filePath) {
+  return `${filePath}.imported`;
+}
+function collisionSafeScopeBindingArchivePath(filePath) {
+  const canonical = scopeBindingArchivePath(filePath);
+  if (!fs.existsSync(canonical))
+    return canonical;
+  for (let suffix = 1;suffix <= 1e4; suffix += 1) {
+    const candidate = `${canonical}.${suffix}`;
+    if (!fs.existsSync(candidate))
+      return candidate;
+  }
+  throw new Error(`No collision-safe archive path available for ${path2.basename(filePath)}.`);
+}
+function scopeBindingShadowPayload(binding) {
+  return JSON.stringify(binding, null, 2);
+}
+function coordinationScopeEntityKey(binding) {
+  return binding.generationId;
+}
+function parseCoordinationScopeBinding(directory, row) {
+  try {
+    const binding = validateScopeBindingPayload(directory, JSON.parse(row.payload));
+    if (!binding || binding.generationId !== row.entityKey || binding.revision !== row.revision || binding.lifecycleState !== row.status) {
+      return null;
+    }
+    return binding;
+  } catch {
+    return null;
+  }
+}
+function transitionScopeBindingState(directory, binding, expectedRevision) {
+  const payload = scopeBindingShadowPayload(binding);
+  const idempotencyKey = createHash("sha256").update(`${binding.bindingId}\x00${binding.generationId}\x00${binding.revision}\x00${binding.lifecycleState}\x00${payload}`).digest("hex");
+  try {
+    const result = transitionCoordinationState(directory, {
+      namespace: SCOPE_BINDING_COORDINATION_NAMESPACE,
+      entityKey: coordinationScopeEntityKey(binding),
+      expectedRevision,
+      generation: 1,
+      status: binding.lifecycleState,
+      payload,
+      event: {
+        streamId: `scope-binding:${binding.bindingId}`,
+        idempotencyKey,
+        eventType: binding.lifecycleState,
+        payload
+      }
+    });
+    if (result.outcome !== "applied" && result.outcome !== "duplicate") {
+      return {
+        ok: false,
+        code: result.outcome === "revision_conflict" || result.outcome === "stale_generation" ? "SCOPE_BINDING_STALE" : "SCOPE_BINDING_PERSISTENCE_FAILED",
+        message: `Scope binding transition failed: ${result.outcome}.`
+      };
+    }
+    const persisted = result.state && parseCoordinationScopeBinding(directory, result.state);
+    return persisted ? { ok: true, value: persisted } : persistenceFailure("Scope binding transition could not be re-read from coordination state.");
+  } catch (error) {
+    return persistenceFailure(`Scope binding transition failed: ${error instanceof Error ? error.message : "unknown coordination error"}`);
+  }
+}
+function transitionScopeBindingStateWithinTransaction(directory, binding, expectedRevision) {
+  const payload = scopeBindingShadowPayload(binding);
+  const idempotencyKey = createHash("sha256").update(`${binding.bindingId}\x00${binding.generationId}\x00${binding.revision}\x00${binding.lifecycleState}\x00${payload}`).digest("hex");
+  try {
+    const result = transitionCoordinationStateWithinTransaction(directory, {
+      namespace: SCOPE_BINDING_COORDINATION_NAMESPACE,
+      entityKey: coordinationScopeEntityKey(binding),
+      expectedRevision,
+      generation: 1,
+      status: binding.lifecycleState,
+      payload,
+      event: {
+        streamId: `scope-binding:${binding.bindingId}`,
+        idempotencyKey,
+        eventType: binding.lifecycleState,
+        payload
+      }
+    });
+    if (result.outcome !== "applied" && result.outcome !== "duplicate") {
+      return {
+        ok: false,
+        code: result.outcome === "revision_conflict" || result.outcome === "stale_generation" ? "SCOPE_BINDING_STALE" : "SCOPE_BINDING_PERSISTENCE_FAILED",
+        message: `Scope binding transition failed: ${result.outcome}.`
+      };
+    }
+    const persisted = result.state && parseCoordinationScopeBinding(directory, result.state);
+    return persisted ? { ok: true, value: persisted } : persistenceFailure("Scope binding transition could not be re-read from coordination state.");
+  } catch (error) {
+    return persistenceFailure(`Scope binding transition failed: ${error instanceof Error ? error.message : "unknown coordination error"}`);
+  }
+}
+function coordinationTimestampFromMs(value, label) {
+  if (!Number.isFinite(value)) {
+    throw new Error(`${label} must be a finite epoch-millisecond timestamp.`);
+  }
+  const iso = new Date(value).toISOString();
+  if (Number.isNaN(Date.parse(iso))) {
+    throw new Error(`${label} must be a valid epoch-millisecond timestamp.`);
+  }
+  return iso;
+}
+function importScopeBindingStateRows(directory, bindings) {
+  const db = getProjectDb(directory);
+  for (const binding of bindings) {
+    if (!Number.isSafeInteger(binding.revision) || binding.revision < 1) {
+      throw new Error(`Legacy binding ${binding.generationId} has invalid revision ${binding.revision}.`);
+    }
+    db.run(`INSERT INTO coordination_state
+			 (namespace, entity_key, revision, generation, status, payload, updated_at)
+			 VALUES (?, ?, ?, ?, ?, ?, ?)`, [
+      SCOPE_BINDING_COORDINATION_NAMESPACE,
+      coordinationScopeEntityKey(binding),
+      binding.revision,
+      1,
+      binding.lifecycleState,
+      scopeBindingShadowPayload(binding),
+      coordinationTimestampFromMs(binding.updatedAt, "binding.updatedAt")
+    ]);
+  }
+}
+function writeScopeBindingShadow(directory, binding) {
+  try {
+    const scopesDir = getScopesDir(directory);
+    fs.mkdirSync(scopesDir, { recursive: true });
+    if (!isScopesDirSafe(directory, scopesDir))
+      return;
+    atomicWriteSync(getBindingFilePath(directory, binding), scopeBindingShadowPayload(binding));
+  } catch {}
+}
+function archiveImportedScopeAuthorityFiles(paths) {
+  for (const filePath of paths) {
+    try {
+      if (!fs.existsSync(filePath))
+        continue;
+      const archivedPath = collisionSafeScopeBindingArchivePath(filePath);
+      fs.renameSync(filePath, archivedPath);
+    } catch {}
+  }
+}
+function fingerprintCommittedScopeImportSource(directory) {
+  const scopesDir = getScopesDir(directory);
+  try {
+    fs.lstatSync(scopesDir);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+  if (!isScopesDirSafe(directory, scopesDir))
+    return null;
+  const names = fs.readdirSync(scopesDir).sort();
+  if (names.length > bindingFileScanCapacity)
+    return null;
+  const authorityFiles = [];
+  for (const name of names) {
+    if (!name.startsWith("binding-") || !name.endsWith(".json"))
+      continue;
+    const filePath = path2.join(scopesDir, name);
+    authorityFiles.push(filePath);
+    const intentPath = getRetirementIntentPath(filePath);
+    if (fs.existsSync(intentPath))
+      authorityFiles.push(intentPath);
+  }
+  for (const name of names) {
+    if (/^claim-[a-f0-9]{40}\.json$/i.test(name)) {
+      authorityFiles.push(path2.join(scopesDir, name));
+    }
+  }
+  if (authorityFiles.length === 0)
+    return null;
+  const digest = createHash("sha256");
+  for (const filePath of authorityFiles) {
+    const raw = readBoundedFile(filePath);
+    if (raw === null)
+      return null;
+    digest.update(path2.basename(filePath));
+    digest.update(raw);
+  }
+  return { authorityFiles, sourceDigest: digest.digest("hex") };
+}
+function collectLegacyScopeBindingsForImport(directory) {
+  const scopesDir = getScopesDir(directory);
+  try {
+    fs.lstatSync(scopesDir);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return {
+        bindings: [],
+        authorityFiles: [],
+        sourceDigest: "empty",
+        rowCount: 0
+      };
+    }
+    throw error;
+  }
+  if (!isScopesDirSafe(directory, scopesDir)) {
+    throw new Error("The durable scope store failed containment checks.");
+  }
+  if (!migrateLegacyBindingsSync(directory)) {
+    throw new Error("The durable binding set could not be completely evaluated.");
+  }
+  const names = fs.readdirSync(scopesDir).sort();
+  if (names.length > bindingFileScanCapacity) {
+    throw new Error("The durable binding set exceeds the scan capacity.");
+  }
+  const authorityFiles = [];
+  const bindings = [];
+  for (const name of names) {
+    if (!name.startsWith("binding-") || !name.endsWith(".json"))
+      continue;
+    const filePath = path2.join(scopesDir, name);
+    authorityFiles.push(filePath);
+    const raw = readBoundedFile(filePath);
+    if (!raw) {
+      throw new Error(`Legacy scope binding ${name} is unreadable.`);
+    }
+    const binding = validateScopeBindingPayload(directory, JSON.parse(raw));
+    if (!binding || !exactFilenameMatches(directory, filePath, binding)) {
+      throw new Error(`Legacy scope binding ${name} is malformed.`);
+    }
+    const intentPath = getRetirementIntentPath(filePath);
+    if (hasDurableRetirementIntent(filePath, binding)) {
+      authorityFiles.push(intentPath);
+      let createdAt = Date.now();
+      const rawIntent = readBoundedFile(intentPath);
+      if (!rawIntent) {
+        throw new Error(`Legacy retirement intent ${path2.basename(intentPath)} is unreadable.`);
+      }
+      const parsedIntent = JSON.parse(rawIntent);
+      if (parsedIntent.bindingId !== binding.bindingId || parsedIntent.generationId !== binding.generationId) {
+        throw new Error(`Legacy retirement intent ${path2.basename(intentPath)} mismatches its generation.`);
+      }
+      if (typeof parsedIntent.createdAt === "number")
+        createdAt = parsedIntent.createdAt;
+      bindings.push({
+        ...binding,
+        lifecycleState: "revoked",
+        updatedAt: createdAt,
+        expiresAt: Math.min(binding.expiresAt, createdAt)
+      });
+      continue;
+    }
+    bindings.push(binding);
+  }
+  for (const name of names) {
+    if (!/^claim-[a-f0-9]{40}\.json$/i.test(name))
+      continue;
+    const filePath = path2.join(scopesDir, name);
+    authorityFiles.push(filePath);
+    const raw = readBoundedFile(filePath);
+    if (!raw)
+      throw new Error(`Legacy claim receipt ${name} is unreadable.`);
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 1 || !isScopeBindingIdentity(parsed.predecessorGenerationId) || !isScopeBindingIdentity(parsed.winnerGenerationId) || typeof parsed.childSessionId !== "string" || !parsed.childSessionId.trim() || typeof parsed.dispatchCallId !== "string" || !parsed.dispatchCallId.trim()) {
+      throw new Error(`Legacy claim receipt ${name} is malformed.`);
+    }
+    const winner = bindings.find((binding) => binding.generationId === parsed.winnerGenerationId);
+    if (!winner) {
+      throw new Error(`Legacy claim receipt ${name} has no winner generation.`);
+    }
+    if (winner.lifecycleState === "live" && winner.ownerSessionId !== parsed.childSessionId) {
+      throw new Error(`Legacy claim receipt ${name} disagrees with the winner generation.`);
+    }
+  }
+  const digest = createHash("sha256");
+  for (const filePath of authorityFiles) {
+    if (!fs.existsSync(filePath))
+      continue;
+    digest.update(path2.basename(filePath));
+    digest.update(fs.readFileSync(filePath));
+  }
+  return {
+    bindings,
+    authorityFiles,
+    sourceDigest: digest.digest("hex"),
+    rowCount: bindings.length
+  };
+}
+function ensureScopeBindingAuthorityImported(directory) {
+  try {
+    const authorityExists = listCoordinationStates(directory, SCOPE_BINDING_COORDINATION_NAMESPACE, 1).length > 0;
+    if (authorityExists) {
+      const importStatement = getProjectDb(directory).prepare("SELECT source_digest FROM coordination_import WHERE source = ?");
+      let importRow;
+      try {
+        importRow = importStatement.get(SCOPE_BINDING_COORDINATION_IMPORT_SOURCE);
+      } finally {
+        importStatement.finalize();
+      }
+      const committedSource = fingerprintCommittedScopeImportSource(directory);
+      if (!importRow || !committedSource || importRow.source_digest !== committedSource.sourceDigest) {
+        return { ok: true, value: undefined };
+      }
+    }
+    const legacy = collectLegacyScopeBindingsForImport(directory);
+    if (legacy.rowCount === 0 && legacy.authorityFiles.length === 0) {
+      return { ok: true, value: undefined };
+    }
+    const importedBindings = legacy.bindings.map((binding) => ({ ...binding }));
+    if (authorityExists) {
+      archiveImportedScopeAuthorityFiles(legacy.authorityFiles);
+      for (const binding of importedBindings) {
+        writeScopeBindingShadow(directory, binding);
+      }
+      return { ok: true, value: undefined };
+    }
+    const outcome = importCoordinationOnce(directory, {
+      source: SCOPE_BINDING_COORDINATION_IMPORT_SOURCE,
+      sourceDigest: legacy.sourceDigest,
+      rowCount: legacy.rowCount,
+      emptyNamespace: SCOPE_BINDING_COORDINATION_NAMESPACE
+    }, () => {
+      importScopeBindingStateRows(directory, importedBindings);
+    });
+    if (outcome === "imported" || outcome === "already_imported") {
+      archiveImportedScopeAuthorityFiles(legacy.authorityFiles);
+      for (const binding of importedBindings) {
+        writeScopeBindingShadow(directory, binding);
+      }
+    }
+    return { ok: true, value: undefined };
+  } catch (error) {
+    return persistenceFailure(`Scope binding import failed closed: ${error instanceof Error ? error.message : "unknown import error"}`);
+  }
+}
+function readAllAuthoritativeScopeBindings(directory, options = {}) {
+  const imported = ensureScopeBindingAuthorityImported(directory);
+  if (!imported.ok)
+    return imported;
+  try {
+    const scanCapacity = options.maintenanceScan ? maintenanceFileScanCapacity : bindingFileScanCapacity;
+    const rows = listCoordinationStates(directory, SCOPE_BINDING_COORDINATION_NAMESPACE, scanCapacity + 1);
+    if (rows.length > scanCapacity) {
+      return {
+        ok: false,
+        code: "SCOPE_BINDING_STORE_OVERLOADED",
+        message: "The durable binding set exceeds the scan capacity."
+      };
+    }
+    const bindings = rows.map((row) => parseCoordinationScopeBinding(directory, row));
+    if (bindings.some((binding) => binding === null)) {
+      return persistenceFailure("The authoritative scope binding set contains malformed coordination rows.");
+    }
+    const complete = bindings;
+    const liveCount = complete.filter((binding) => binding.lifecycleState === "live" && binding.expiresAt > Date.now()).length;
+    if (options.enforceLiveCapacity !== false && liveCount > liveBindingCapacity) {
+      return {
+        ok: false,
+        code: "SCOPE_BINDING_STORE_OVERLOADED",
+        message: "The durable binding set exceeds the live binding capacity."
+      };
+    }
+    return { ok: true, value: complete };
+  } catch (error) {
+    return persistenceFailure(`Authoritative scope binding read failed: ${error instanceof Error ? error.message : "unknown coordination error"}`);
+  }
+}
 function deterministicIdentity(value) {
   const hex = createHash("sha256").update(value).digest("hex").slice(0, 32);
   return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-a${hex.slice(17, 20)}-${hex.slice(20)}`;
@@ -683,49 +1055,38 @@ async function writeScopeBindingToDisk(directory, binding) {
   const files = normalizeScopeFiles(binding.files);
   if (!workspaceIdentity || workspaceIdentity !== binding.workspaceIdentity || !files || !binding.ownerSessionId || !binding.ownerMessageId || !isScopeBindingIdentity(binding.bindingId) || !isScopeBindingIdentity(binding.generationId) || binding.revision < 1 || binding.lifecycleState === "live" && binding.expiresAt <= Date.now())
     return persistenceFailure("Binding identity, workspace, scope, or lease is invalid.");
-  const scopesDir = getScopesDir(directory);
-  const scopePath = getBindingFilePath(directory, binding);
-  try {
-    fs.mkdirSync(scopesDir, { recursive: true });
-  } catch {
-    return persistenceFailure("Could not create the durable scope store.");
+  const imported = ensureScopeBindingAuthorityImported(directory);
+  if (!imported.ok)
+    return imported;
+  const all = readAllAuthoritativeScopeBindings(directory, {
+    enforceLiveCapacity: false
+  });
+  if (!all.ok)
+    return all;
+  const current = all.value.find((candidate) => candidate.generationId === binding.generationId);
+  if (current && current.bindingId !== binding.bindingId) {
+    return {
+      ok: false,
+      code: "SCOPE_BINDING_STALE",
+      message: "The exact generation identity collides with another binding."
+    };
   }
-  if (!isScopesDirSafe(directory, scopesDir))
-    return persistenceFailure("The durable scope store failed containment checks.");
-  const content = JSON.stringify({ ...binding, files }, null, 2);
-  try {
-    const flags = fs.constants.O_WRONLY | fs.constants.O_CREAT;
-    const nofollow = fs.constants.O_NOFOLLOW ?? 0;
-    const fd = fs.openSync(scopePath, flags | nofollow);
-    fs.closeSync(fd);
-  } catch {
-    return persistenceFailure("Could not create the exact generation record.");
+  if (current && current.revision === binding.revision && current.lifecycleState === binding.lifecycleState && JSON.stringify(current.files) === JSON.stringify(files)) {
+    writeScopeBindingShadow(directory, current);
+    return { ok: true, value: current };
   }
-  let release;
-  try {
-    const lockPath = getGenerationLockPath(scopePath);
-    if (!await ensureLockTarget(lockPath))
-      return persistenceFailure("Could not prepare exact generation lock.");
-    release = await import_proper_lockfile.default.lock(lockPath, {
-      stale: LOCK_STALE_MS,
-      retries: { retries: 3, minTimeout: 50, maxTimeout: 200 },
-      realpath: false
-    });
-    await atomicWrite(scopePath, content);
-    const verifiedRaw = readBoundedFile(scopePath);
-    const verified = verifiedRaw ? validateScopeBindingPayload(directory, JSON.parse(verifiedRaw)) : null;
-    if (!verified || verified.bindingId !== binding.bindingId || verified.generationId !== binding.generationId || verified.revision !== binding.revision)
-      return persistenceFailure("Exact generation verification failed after write.");
-    return { ok: true, value: verified };
-  } catch (error) {
-    return persistenceFailure(`Exact generation write failed: ${error instanceof Error ? error.message : "unknown I/O error"}`);
-  } finally {
-    if (release) {
-      try {
-        await release();
-      } catch {}
-    }
+  const expectedRevision = current ? binding.revision - 1 : null;
+  if (binding.revision !== (current?.revision ?? 0) + 1) {
+    return {
+      ok: false,
+      code: "SCOPE_BINDING_STALE",
+      message: "Exact generation write requires the next CAS revision."
+    };
   }
+  const persisted = transitionScopeBindingState(directory, { ...binding, files }, expectedRevision);
+  if (persisted.ok)
+    writeScopeBindingShadow(directory, persisted.value);
+  return persisted;
 }
 function persistenceFailure(message) {
   return { ok: false, code: "SCOPE_BINDING_PERSISTENCE_FAILED", message };
@@ -746,6 +1107,69 @@ async function persistAndRegisterScopeBinding(directory, binding) {
     message: rollback.ok ? admission.message : `Memory admission failed and rollback failed: ${rollback.message}`
   };
 }
+function rollbackAdmissionFailure(directory, persisted, predecessors, admission) {
+  const now = Date.now();
+  const revokedCandidate = {
+    ...persisted,
+    revision: persisted.revision + 1,
+    lifecycleState: "revoked",
+    updatedAt: now,
+    expiresAt: Math.min(persisted.expiresAt, now)
+  };
+  const restoredCandidates = predecessors.map(({ original, superseded }) => ({
+    ...original,
+    revision: superseded.revision + 1,
+    lifecycleState: "live",
+    updatedAt: now
+  }));
+  let failureMessage = null;
+  try {
+    withCoordinationTransaction(directory, () => {
+      const revoked = _scopePersistenceInternals.transitionScopeBindingStateWithinTransaction(directory, revokedCandidate, persisted.revision);
+      if (!revoked.ok) {
+        failureMessage = revoked.message;
+        throw new Error("Scope rollback revocation transition failed.");
+      }
+      for (let index = 0;index < restoredCandidates.length; index += 1) {
+        const restored = restoredCandidates[index];
+        const superseded = predecessors[index].superseded;
+        const result = _scopePersistenceInternals.transitionScopeBindingStateWithinTransaction(directory, restored, superseded.revision);
+        if (!result.ok) {
+          failureMessage = result.message;
+          throw new Error("Scope rollback predecessor restore failed.");
+        }
+      }
+    });
+  } catch (error) {
+    return persistenceFailure(`Memory admission failed and durable rollback failed: ${failureMessage ?? (error instanceof Error ? error.message : "unknown coordination error")}`);
+  }
+  installScopeBindingTombstone(revokedCandidate);
+  writeScopeBindingShadow(directory, revokedCandidate);
+  const admitted = [];
+  for (const restored of restoredCandidates) {
+    writeScopeBindingShadow(directory, restored);
+    const memory = updateExactScopeBinding(restored);
+    const admissionResult = memory.ok ? memory : registerScopeBinding(restored);
+    if (!admissionResult.ok) {
+      for (const applied of admitted) {
+        installScopeBindingTombstone({
+          ...applied,
+          revision: applied.revision + 1,
+          lifecycleState: "revoked",
+          updatedAt: Date.now(),
+          expiresAt: Math.min(applied.expiresAt, Date.now())
+        });
+      }
+      return persistenceFailure(`Memory admission failed and predecessor re-admission failed: ${admissionResult.message}`);
+    }
+    admitted.push(restored);
+  }
+  return {
+    ok: false,
+    code: admission.code,
+    message: admission.message
+  };
+}
 function readScopeBindingFromDisk(input) {
   const resolved = resolveScopeBindingFromDisk({
     ...input,
@@ -756,12 +1180,14 @@ function readScopeBindingFromDisk(input) {
 function resolveScopeBindingFromDisk(input) {
   if (!isSafeTaskId(input.taskId))
     return { status: "not_declared" };
-  const completeSet = readAllExactBindings(input.directory);
-  if (!completeSet) {
-    scheduleScopeBindingMaintenance(input.directory);
+  const completeSet = readAllAuthoritativeScopeBindings(input.directory);
+  if (!completeSet.ok) {
+    if (completeSet.code === "SCOPE_BINDING_STORE_OVERLOADED") {
+      scheduleScopeBindingMaintenance(input.directory);
+    }
     return { status: "overloaded" };
   }
-  const candidates = completeSet.filter((parsed) => parsed.taskId === input.taskId && parsed.planId === derivePlanId(input.plan) && parsed.planStructureHash === computePlanStructureHash(input.plan) && parsed.ownerSessionId === input.ownerSessionId && (input.requireDispatchCorrelation !== true || isDispatchCorrelated(parsed)) && (input.requireDeclaration !== true || parsed.activation === "declaration" && parsed.dispatchCallId === undefined) && (input.parentCallId === undefined || parsed.parentCallId === input.parentCallId));
+  const candidates = completeSet.value.filter((parsed) => parsed.taskId === input.taskId && parsed.planId === derivePlanId(input.plan) && parsed.planStructureHash === computePlanStructureHash(input.plan) && parsed.ownerSessionId === input.ownerSessionId && (input.requireDispatchCorrelation !== true || isDispatchCorrelated2(parsed)) && (input.requireDeclaration !== true || parsed.activation === "declaration" && parsed.dispatchCallId === undefined) && (input.parentCallId === undefined || parsed.parentCallId === input.parentCallId));
   const live = candidates.filter((candidate) => candidate.lifecycleState === "live" && candidate.expiresAt > Date.now());
   if (live.length > 1)
     return {
@@ -772,13 +1198,29 @@ function resolveScopeBindingFromDisk(input) {
   if (live.length === 1)
     return { status: "found", binding: live[0] };
   const expired = candidates.filter((candidate) => candidate.lifecycleState !== "live" || candidate.expiresAt <= Date.now());
+  if (candidates.length > 0 && !input.includeExpired) {
+    return { status: "not_declared" };
+  }
   return input.includeExpired && expired.length > 0 ? {
     status: "expired",
     candidates: expired.slice(0, 8),
     totalCandidates: expired.length
-  } : { status: "not_declared" };
+  } : (() => {
+    const inMemory = input.requireDeclaration === true ? [] : getActiveScopeBindingsForSession({
+      directory: input.directory,
+      activeSessionId: input.ownerSessionId
+    }).filter((binding) => binding.taskId === input.taskId && binding.planId === derivePlanId(input.plan) && binding.planStructureHash === computePlanStructureHash(input.plan) && (input.requireDispatchCorrelation !== true || isDispatchCorrelated2(binding)) && (input.parentCallId === undefined || binding.parentCallId === input.parentCallId));
+    if (inMemory.length > 1) {
+      return {
+        status: "ambiguous",
+        candidates: inMemory.slice(0, 8),
+        totalCandidates: inMemory.length
+      };
+    }
+    return inMemory.length === 1 ? { status: "found", binding: inMemory[0] } : { status: "not_declared" };
+  })();
 }
-function isDispatchCorrelated(binding) {
+function isDispatchCorrelated2(binding) {
   return binding.activation === "active" && typeof binding.dispatchCallId === "string" && binding.dispatchCallId.length > 0 && binding.ownerMessageId === binding.dispatchCallId && typeof binding.parentOwnerSessionId === "string" && binding.parentOwnerSessionId.length > 0 && binding.ownerSessionId !== binding.parentOwnerSessionId && binding.parentCallId === binding.dispatchCallId;
 }
 function clearScopeBindingFromDisk(input) {
@@ -788,285 +1230,156 @@ function clearScopeBindingFromDisk(input) {
   } catch (error) {
     return persistenceFailure(`Scope retirement project-root validation failed: ${error instanceof Error ? error.message : "unknown validation error"}`);
   }
-  let release;
-  try {
-    const resolvedWorkspace = fs.realpathSync(input.directory);
-    const scopePath = getBindingFilePath(resolvedWorkspace, input.binding);
-    if (!isScopesDirSafe(resolvedWorkspace, getScopesDir(resolvedWorkspace)))
-      return persistenceFailure("The durable scope store failed containment checks.");
-    const retirementIntentPath = getRetirementIntentPath(scopePath);
-    atomicWriteSync(retirementIntentPath, JSON.stringify({
-      version: 1,
-      bindingId: input.binding.bindingId,
-      generationId: input.binding.generationId,
-      createdAt: Date.now()
-    }));
-    scheduleScopeBindingMaintenance(resolvedWorkspace);
-    const lockPath = getGenerationLockPath(scopePath);
-    if (!ensureLockTargetSync(lockPath))
-      return persistenceFailure("Could not prepare exact retirement lock.");
-    release = lockSyncWithBoundedRetry(lockPath);
-    const raw = readBoundedFile(scopePath);
-    if (!raw) {
-      try {
-        fs.unlinkSync(retirementIntentPath);
-      } catch {}
-      return localRetirement ? { ok: true, value: localRetirement } : persistenceFailure("Exact generation disappeared before serialized retirement.");
-    }
-    const current = validateScopeBindingPayload(resolvedWorkspace, JSON.parse(raw));
-    if (!current || current.bindingId !== input.binding.bindingId || current.generationId !== input.binding.generationId)
-      return persistenceFailure("Exact generation identity changed before serialized retirement.");
-    if (current.lifecycleState !== "live") {
-      installScopeBindingTombstone(current);
-      try {
-        fs.unlinkSync(retirementIntentPath);
-      } catch {}
-      return { ok: true, value: current };
-    }
-    const now = Date.now();
-    const tombstone = {
-      ...current,
-      revision: current.revision + 1,
-      lifecycleState: "revoked",
-      updatedAt: now,
-      expiresAt: Math.min(current.expiresAt, now)
-    };
-    atomicWriteSync(scopePath, JSON.stringify(tombstone, null, 2));
-    const verifiedRaw = readBoundedFile(scopePath);
-    const verified = verifiedRaw ? validateScopeBindingPayload(resolvedWorkspace, JSON.parse(verifiedRaw)) : null;
-    if (!verified || verified.revision !== tombstone.revision || verified.lifecycleState !== "revoked")
-      return persistenceFailure("Serialized retirement verification failed.");
-    installScopeBindingTombstone(verified);
-    try {
-      fs.unlinkSync(retirementIntentPath);
-    } catch {}
-    scheduleScopeBindingMaintenance(resolvedWorkspace);
-    return { ok: true, value: verified };
-  } catch (error) {
-    return persistenceFailure(`Serialized retirement failed: ${error instanceof Error ? error.message : "unknown I/O error"}`);
-  } finally {
-    try {
-      release?.();
-    } catch {}
+  const imported = ensureScopeBindingAuthorityImported(input.directory);
+  if (!imported.ok)
+    return imported;
+  const all = readAllAuthoritativeScopeBindings(input.directory, {
+    enforceLiveCapacity: false
+  });
+  if (!all.ok)
+    return all;
+  const current = all.value.find((candidate) => candidate.generationId === input.binding.generationId && candidate.bindingId === input.binding.bindingId);
+  if (!current) {
+    return localRetirement ? { ok: true, value: localRetirement } : persistenceFailure("Exact generation disappeared before serialized retirement.");
   }
-}
-async function tombstoneScopeBinding(directory, binding, reason) {
-  const currentPath = getBindingFilePath(directory, binding);
-  const generationLockPath = getGenerationLockPath(currentPath);
-  const lockReady = await ensureLockTarget(generationLockPath);
-  if (!lockReady) {
-    installFailedRevocationOverlay(binding, reason);
-    return persistenceFailure("Could not prepare exact generation lock.");
+  if (current.lifecycleState !== "live") {
+    installScopeBindingTombstone(current);
+    writeScopeBindingShadow(input.directory, current);
+    return { ok: true, value: current };
   }
-  let release;
-  try {
-    release = await import_proper_lockfile.default.lock(generationLockPath, {
-      stale: LOCK_STALE_MS,
-      retries: { retries: 3, minTimeout: 50, maxTimeout: 200 },
-      realpath: false
-    });
-    const raw = readBoundedFile(currentPath);
-    if (!raw) {
-      installFailedRevocationOverlay(binding, reason);
-      return persistenceFailure("Exact generation disappeared before tombstone.");
-    }
-    const current = validateScopeBindingPayload(directory, JSON.parse(raw));
-    if (!current || current.bindingId !== binding.bindingId || current.generationId !== binding.generationId) {
-      installFailedRevocationOverlay(binding, reason);
-      return persistenceFailure("Exact generation identity changed before tombstone.");
-    }
-    if (current.revision !== binding.revision)
-      return {
-        ok: false,
-        code: "SCOPE_BINDING_STALE",
-        message: "Tombstone CAS revision is stale."
-      };
-    if (current.lifecycleState !== "live")
-      return { ok: true, value: current };
-    const now = Date.now();
-    const tombstone = {
-      ...current,
-      revision: current.revision + 1,
-      lifecycleState: reason,
-      updatedAt: now,
-      expiresAt: Math.min(current.expiresAt, now)
+  const now = Date.now();
+  const tombstone = {
+    ...current,
+    revision: current.revision + 1,
+    lifecycleState: "revoked",
+    updatedAt: now,
+    expiresAt: Math.min(current.expiresAt, now)
+  };
+  const retired = transitionScopeBindingState(input.directory, tombstone, current.revision);
+  if (!retired.ok)
+    return retired;
+  installScopeBindingTombstone(retired.value);
+  writeScopeBindingShadow(input.directory, retired.value);
+  scheduleScopeBindingMaintenance(input.directory);
+  return retired;
+}
+async function tombstoneScopeBinding(directory, binding, reason) {
+  const imported = ensureScopeBindingAuthorityImported(directory);
+  if (!imported.ok) {
+    installFailedRevocationOverlay(binding, reason);
+    return imported;
+  }
+  const all = readAllAuthoritativeScopeBindings(directory, {
+    enforceLiveCapacity: false
+  });
+  if (!all.ok) {
+    installFailedRevocationOverlay(binding, reason);
+    return all;
+  }
+  const current = all.value.find((candidate) => candidate.generationId === binding.generationId && candidate.bindingId === binding.bindingId);
+  if (!current) {
+    installFailedRevocationOverlay(binding, reason);
+    return persistenceFailure("Exact generation disappeared before tombstone.");
+  }
+  if (current.revision !== binding.revision) {
+    return {
+      ok: false,
+      code: "SCOPE_BINDING_STALE",
+      message: "Tombstone CAS revision is stale."
     };
-    await atomicWrite(currentPath, JSON.stringify(tombstone, null, 2));
-    const verifiedRaw = readBoundedFile(currentPath);
-    const verified = verifiedRaw ? validateScopeBindingPayload(directory, JSON.parse(verifiedRaw)) : null;
-    if (!verified || verified.revision !== tombstone.revision || verified.lifecycleState !== reason) {
-      installFailedRevocationOverlay(binding, reason);
-      return persistenceFailure("Tombstone verification failed.");
-    }
-    clearExactScopeBinding(binding);
-    installScopeBindingTombstone(verified);
-    scheduleScopeBindingMaintenance(directory);
-    return { ok: true, value: verified };
-  } catch (error) {
+  }
+  if (current.lifecycleState !== "live")
+    return { ok: true, value: current };
+  const now = Date.now();
+  const tombstone = {
+    ...current,
+    revision: current.revision + 1,
+    lifecycleState: reason,
+    updatedAt: now,
+    expiresAt: Math.min(current.expiresAt, now)
+  };
+  const persisted = transitionScopeBindingState(directory, tombstone, current.revision);
+  if (!persisted.ok) {
     installFailedRevocationOverlay(binding, reason);
-    return persistenceFailure(`Tombstone failed: ${error instanceof Error ? error.message : "unknown I/O error"}`);
-  } finally {
-    if (release)
-      try {
-        await release();
-      } catch {}
+    return persisted;
   }
+  clearExactScopeBinding(binding);
+  installScopeBindingTombstone(persisted.value);
+  writeScopeBindingShadow(directory, persisted.value);
+  scheduleScopeBindingMaintenance(directory);
+  return persisted;
 }
 async function ensureLockTarget(targetPath) {
   return ensureLockTargetSync(targetPath);
 }
 async function refreshScopeBindingLease(input) {
-  let scopePath;
-  try {
-    scopePath = getBindingFilePath(input.directory, input);
-  } catch {
-    return persistenceFailure("Invalid refresh identity.");
-  }
-  const generationLockPath = getGenerationLockPath(scopePath);
-  const createdGenerationLockTarget = !fs.existsSync(generationLockPath);
-  if (!await ensureLockTarget(generationLockPath))
-    return persistenceFailure("Could not prepare refresh lock.");
-  let release;
-  try {
-    release = await import_proper_lockfile.default.lock(generationLockPath, {
-      stale: LOCK_STALE_MS,
-      retries: { retries: 3, minTimeout: 50, maxTimeout: 200 },
-      realpath: false
-    });
-    if (hasDurableRetirementIntent(scopePath, input))
-      return {
-        ok: false,
-        code: "SCOPE_BINDING_STALE",
-        message: "Refresh cannot renew a generation with durable retirement intent."
-      };
-    const raw = readBoundedFile(scopePath);
-    const current = raw ? validateScopeBindingPayload(input.directory, JSON.parse(raw)) : null;
-    if (!current || current.bindingId !== input.bindingId || current.generationId !== input.generationId || current.taskId !== input.taskId || current.ownerSessionId !== input.activeSessionId)
-      return {
-        ok: false,
-        code: "SCOPE_BINDING_STALE",
-        message: "Refresh identity is not the exact current session/task generation."
-      };
-    if (current.lifecycleState !== "live" || current.expiresAt <= Date.now() || current.revision !== input.expectedRevision)
-      return {
-        ok: false,
-        code: current.expiresAt <= Date.now() ? "SCOPE_BINDING_EXPIRED" : "SCOPE_BINDING_STALE",
-        message: "Refresh cannot renew an expired, tombstoned, or stale generation."
-      };
-    const now = Date.now();
-    const refreshed = {
-      ...current,
-      revision: current.revision + 1,
-      updatedAt: now,
-      leaseStartedAt: now,
-      expiresAt: now + Math.max(1, input.ttlMs ?? DEFAULT_SCOPE_BINDING_TTL_MS)
+  const imported = ensureScopeBindingAuthorityImported(input.directory);
+  if (!imported.ok)
+    return imported;
+  const all = readAllAuthoritativeScopeBindings(input.directory, {
+    enforceLiveCapacity: false
+  });
+  if (!all.ok)
+    return all;
+  const current = all.value.find((candidate) => candidate.bindingId === input.bindingId && candidate.generationId === input.generationId && candidate.taskId === input.taskId && candidate.ownerSessionId === input.activeSessionId);
+  if (!current) {
+    return {
+      ok: false,
+      code: "SCOPE_BINDING_STALE",
+      message: "Refresh identity is not the exact current session/task generation."
     };
-    await atomicWrite(scopePath, JSON.stringify(refreshed, null, 2));
-    const verifyRaw = readBoundedFile(scopePath);
-    const verified = verifyRaw ? validateScopeBindingPayload(input.directory, JSON.parse(verifyRaw)) : null;
-    if (!verified || verified.revision !== refreshed.revision || verified.expiresAt !== refreshed.expiresAt)
-      return persistenceFailure("Refreshed lease verification failed.");
-    updateExactScopeBinding(verified);
-    return { ok: true, value: verified };
-  } catch (error) {
-    return persistenceFailure(`Lease refresh failed: ${error instanceof Error ? error.message : "unknown I/O error"}`);
-  } finally {
-    if (release)
-      try {
-        await release();
-      } catch {}
-    if (createdGenerationLockTarget && !fs.existsSync(scopePath)) {
-      try {
-        fs.unlinkSync(generationLockPath);
-      } catch {}
-    }
   }
-}
-function claimBaseName(binding) {
-  const digest = createHash("sha256").update(`${binding.bindingId}\x00${binding.generationId}\x00${binding.dispatchCallId ?? ""}`).digest("hex").slice(0, 40);
-  return `claim-${digest}`;
-}
-function readAllExactBindings(directory, options = {}) {
-  const scopesDir = getScopesDir(directory);
-  try {
-    fs.lstatSync(scopesDir);
-  } catch (error) {
-    return error.code === "ENOENT" ? [] : null;
-  }
-  if (!isScopesDirSafe(directory, scopesDir))
-    return null;
-  const scanCapacity = options.maintenanceScan ? maintenanceFileScanCapacity : bindingFileScanCapacity;
-  if (!migrateLegacyBindingsSync(directory, scanCapacity))
-    return null;
-  let names;
-  try {
-    names = fs.readdirSync(scopesDir).sort();
-  } catch {
-    return [];
-  }
-  if (names.length > scanCapacity)
-    return null;
-  const bindings = [];
-  for (const name of names) {
-    if (!name.startsWith("binding-") || !name.endsWith(".json"))
-      continue;
-    const filePath = path2.join(scopesDir, name);
-    const raw = readBoundedFile(filePath);
-    if (!raw)
-      continue;
-    try {
-      const binding = validateScopeBindingPayload(directory, JSON.parse(raw));
-      if (binding && exactFilenameMatches(directory, filePath, binding)) {
-        if (hasDurableRetirementIntent(filePath, binding)) {
-          let createdAt = Date.now();
-          try {
-            const rawIntent = readBoundedFile(getRetirementIntentPath(filePath));
-            const parsedIntent = rawIntent ? JSON.parse(rawIntent) : null;
-            if (typeof parsedIntent?.createdAt === "number")
-              createdAt = parsedIntent.createdAt;
-          } catch {}
-          bindings.push({
-            ...binding,
-            lifecycleState: "revoked",
-            updatedAt: createdAt,
-            expiresAt: Math.min(binding.expiresAt, createdAt)
-          });
-        } else
-          bindings.push(binding);
-      }
-    } catch {}
+  if (current.lifecycleState !== "live" || current.expiresAt <= Date.now() || current.revision !== input.expectedRevision) {
+    return {
+      ok: false,
+      code: current.expiresAt <= Date.now() ? "SCOPE_BINDING_EXPIRED" : "SCOPE_BINDING_STALE",
+      message: "Refresh cannot renew an expired, tombstoned, or stale generation."
+    };
   }
-  const liveCount = bindings.filter((binding) => binding.lifecycleState === "live" && binding.expiresAt > Date.now()).length;
-  if (options.enforceLiveCapacity !== false && liveCount > liveBindingCapacity)
-    return null;
-  return bindings;
+  const now = Date.now();
+  const refreshed = {
+    ...current,
+    revision: current.revision + 1,
+    updatedAt: now,
+    leaseStartedAt: now,
+    expiresAt: now + Math.max(1, input.ttlMs ?? DEFAULT_SCOPE_BINDING_TTL_MS)
+  };
+  const persisted = transitionScopeBindingState(input.directory, refreshed, current.revision);
+  if (!persisted.ok)
+    return persisted;
+  updateExactScopeBinding(persisted.value);
+  writeScopeBindingShadow(input.directory, persisted.value);
+  return persisted;
 }
 async function claimScopeBindingForChildDurably(input) {
   if (!input.parentSessionId.trim() || !input.childSessionId.trim() || !input.dispatchCallId.trim() || input.parentSessionId === input.childSessionId)
     return persistenceFailure("Claim requires distinct non-empty parent/child identities and an exact dispatch call.");
-  const initial = readAllExactBindings(input.directory);
-  if (!initial)
-    return {
-      ok: false,
-      code: "SCOPE_BINDING_STORE_OVERLOADED",
-      message: "The complete durable binding set could not be evaluated."
-    };
-  const pending = initial.filter((binding) => binding.lifecycleState === "live" && binding.expiresAt > Date.now() && binding.activation === "pending_child" && binding.ownerSessionId === input.parentSessionId && binding.dispatchCallId === input.dispatchCallId && binding.ownerMessageId === input.dispatchCallId);
-  if (pending.length > 1)
+  const imported = ensureScopeBindingAuthorityImported(input.directory);
+  if (!imported.ok)
+    return imported;
+  const initial = readAllAuthoritativeScopeBindings(input.directory, {
+    enforceLiveCapacity: false
+  });
+  if (!initial.ok)
+    return initial;
+  const pending = initial.value.filter((binding) => binding.lifecycleState === "live" && binding.expiresAt > Date.now() && binding.activation === "pending_child" && binding.ownerSessionId === input.parentSessionId && binding.dispatchCallId === input.dispatchCallId && binding.ownerMessageId === input.dispatchCallId);
+  if (pending.length > 1) {
     return {
       ok: false,
       code: "SCOPE_BINDING_AMBIGUOUS",
       message: "Multiple pending generations match this exact Task dispatch."
     };
+  }
   let predecessor = pending[0];
   if (!predecessor) {
-    const successors = initial.filter((binding) => binding.lifecycleState === "live" && binding.expiresAt > Date.now() && binding.activation === "active" && binding.parentOwnerSessionId === input.parentSessionId && binding.dispatchCallId === input.dispatchCallId && binding.predecessorGenerationId);
-    if (successors.length > 1)
+    const successors = initial.value.filter((binding) => binding.lifecycleState === "live" && binding.expiresAt > Date.now() && binding.activation === "active" && binding.parentOwnerSessionId === input.parentSessionId && binding.dispatchCallId === input.dispatchCallId && binding.predecessorGenerationId);
+    if (successors.length > 1) {
       return {
         ok: false,
         code: "SCOPE_BINDING_AMBIGUOUS",
         message: "Multiple active successors match this Task dispatch."
       };
+    }
     const existing = successors[0];
     if (existing?.ownerSessionId === input.childSessionId) {
       const admission = registerScopeBinding(existing);
@@ -1080,7 +1393,7 @@ async function claimScopeBindingForChildDurably(input) {
       ok: false,
       code: "SCOPE_BINDING_ALREADY_CLAIMED",
       message: "This Task dispatch was already claimed by a different child session."
-    } : initial.some((candidate) => candidate.ownerSessionId === input.parentSessionId && candidate.dispatchCallId === input.dispatchCallId) ? {
+    } : initial.value.some((candidate) => candidate.ownerSessionId === input.parentSessionId && candidate.dispatchCallId === input.dispatchCallId) ? {
       ok: false,
       code: "SCOPE_BINDING_EXPIRED",
       message: "No live pending generation remains for this Task dispatch."
@@ -1090,136 +1403,91 @@ async function claimScopeBindingForChildDurably(input) {
       message: "No pending generation matches this Task dispatch."
     };
   }
-  const claimPath = path2.join(getScopesDir(input.directory), `${claimBaseName(predecessor)}.json`);
-  if (!await ensureLockTarget(claimPath))
-    return persistenceFailure("Could not prepare the stable predecessor claim lock.");
-  let release;
   try {
-    release = await import_proper_lockfile.default.lock(claimPath, {
-      stale: LOCK_STALE_MS,
-      retries: { retries: 5, minTimeout: 50, maxTimeout: 250 },
-      realpath: false
-    });
-    const currentSet = readAllExactBindings(input.directory);
-    if (!currentSet)
-      return {
-        ok: false,
-        code: "SCOPE_BINDING_STORE_OVERLOADED",
-        message: "The durable binding set became incomplete during claim."
-      };
-    const currentPredecessor = currentSet.find((binding) => binding.generationId === predecessor.generationId && binding.bindingId === predecessor.bindingId);
-    const allSuccessors = currentSet.filter((binding) => binding.predecessorGenerationId === predecessor.generationId && binding.bindingId === predecessor.bindingId);
-    const successors = allSuccessors.filter((binding) => binding.lifecycleState === "live" && binding.expiresAt > Date.now());
-    if (successors.length > 1)
-      return {
-        ok: false,
-        code: "SCOPE_BINDING_AMBIGUOUS",
-        message: "Incompatible successors exist for one predecessor generation."
-      };
-    const receiptRaw = readBoundedFile(claimPath);
-    let receipt = null;
-    if (receiptRaw) {
-      try {
-        const parsed = JSON.parse(receiptRaw);
-        if (parsed.version !== 1 || parsed.predecessorGenerationId !== predecessor.generationId || !isScopeBindingIdentity(parsed.winnerGenerationId) || typeof parsed.childSessionId !== "string" || parsed.dispatchCallId !== input.dispatchCallId)
-          return persistenceFailure("Claim winner receipt is malformed or belongs to another predecessor.");
-        receipt = parsed;
-      } catch {
-        return persistenceFailure("Claim winner receipt is malformed.");
+    let claimed = null;
+    let retired = null;
+    let alreadyClaimed = null;
+    withCoordinationTransaction(input.directory, () => {
+      const currentSet = readAllAuthoritativeScopeBindings(input.directory, {
+        enforceLiveCapacity: false
+      });
+      if (!currentSet.ok) {
+        throw new ScopeCoordinationAbort(currentSet);
       }
-    }
-    if (receipt) {
-      const receiptWinner = allSuccessors.find((candidate) => candidate.generationId === receipt?.winnerGenerationId);
-      if (!receiptWinner)
-        return persistenceFailure("Claim receipt has no verified successor; pending remains fail-closed for restart reconciliation.");
-      if (receiptWinner.lifecycleState !== "live" || receiptWinner.expiresAt <= Date.now()) {
-        fs.writeFileSync(claimPath, "");
-        receipt = null;
+      const currentPredecessor = currentSet.value.find((binding) => binding.generationId === predecessor.generationId && binding.bindingId === predecessor.bindingId);
+      const liveSuccessors = currentSet.value.filter((binding) => binding.predecessorGenerationId === predecessor.generationId && binding.bindingId === predecessor.bindingId && binding.lifecycleState === "live" && binding.expiresAt > Date.now());
+      if (liveSuccessors.length > 1) {
+        throw new ScopeCoordinationAbort({
+          ok: false,
+          code: "SCOPE_BINDING_AMBIGUOUS",
+          message: "Incompatible successors exist for one predecessor generation."
+        });
       }
-    }
-    if (receipt && successors[0] && receipt.winnerGenerationId !== successors[0].generationId)
-      return {
-        ok: false,
-        code: "SCOPE_BINDING_AMBIGUOUS",
-        message: "Claim receipt and durable successor disagree."
-      };
-    const existing = successors[0];
-    if (existing) {
-      if (existing.ownerSessionId !== input.childSessionId)
-        return {
+      const existing = liveSuccessors[0];
+      if (existing) {
+        if (existing.ownerSessionId !== input.childSessionId) {
+          throw new ScopeCoordinationAbort({
+            ok: false,
+            code: "SCOPE_BINDING_ALREADY_CLAIMED",
+            message: "This pending generation has a winner in another child session."
+          });
+        }
+        alreadyClaimed = existing;
+        return;
+      }
+      if (!currentPredecessor || currentPredecessor.lifecycleState !== "live" || currentPredecessor.expiresAt <= Date.now()) {
+        throw new ScopeCoordinationAbort({
           ok: false,
-          code: "SCOPE_BINDING_ALREADY_CLAIMED",
-          message: "This pending generation has a winner in another child session."
-        };
-      await writeClaimReceipt(claimPath, predecessor, existing, input);
-      if (currentPredecessor?.lifecycleState === "live")
-        await tombstoneScopeBinding(input.directory, currentPredecessor, "superseded");
-      const admission2 = registerScopeBinding(existing);
-      return admission2.ok ? { ok: true, value: { previous: predecessor, claimed: existing } } : {
+          code: "SCOPE_BINDING_EXPIRED",
+          message: "The pending predecessor expired before claim."
+        });
+      }
+      predecessor = currentPredecessor;
+      const nextClaimed = createClaimedScopeBinding(predecessor, input);
+      const claimedWrite = _scopePersistenceInternals.transitionScopeBindingStateWithinTransaction(input.directory, nextClaimed, null);
+      if (!claimedWrite.ok) {
+        throw new ScopeCoordinationAbort(claimedWrite);
+      }
+      const superseded = {
+        ...predecessor,
+        revision: predecessor.revision + 1,
+        lifecycleState: "superseded",
+        updatedAt: claimedWrite.value.updatedAt,
+        expiresAt: Math.min(predecessor.expiresAt, claimedWrite.value.updatedAt)
+      };
+      const retiredWrite = _scopePersistenceInternals.transitionScopeBindingStateWithinTransaction(input.directory, superseded, predecessor.revision);
+      if (!retiredWrite.ok) {
+        throw new ScopeCoordinationAbort(retiredWrite);
+      }
+      claimed = claimedWrite.value;
+      retired = retiredWrite.value;
+    });
+    if (alreadyClaimed) {
+      const admission2 = registerScopeBinding(alreadyClaimed);
+      return admission2.ok ? {
+        ok: true,
+        value: { previous: predecessor, claimed: alreadyClaimed }
+      } : {
         ok: false,
         code: admission2.code,
         message: admission2.message
       };
     }
-    if (!currentPredecessor || currentPredecessor.lifecycleState !== "live" || currentPredecessor.expiresAt <= Date.now())
-      return {
-        ok: false,
-        code: "SCOPE_BINDING_EXPIRED",
-        message: "The pending predecessor expired before claim."
-      };
-    predecessor = currentPredecessor;
-    const claimed = createClaimedScopeBinding(predecessor, input);
-    const persisted = await writeScopeBindingToDisk(input.directory, claimed);
-    if (!persisted.ok)
-      return persisted;
-    const receiptWrite = await writeClaimReceipt(claimPath, predecessor, persisted.value, input);
-    if (!receiptWrite.ok) {
-      await tombstoneScopeBinding(input.directory, persisted.value, "revoked");
-      return receiptWrite;
+    if (!predecessor || !claimed || !retired) {
+      return persistenceFailure("Claim transaction did not settle a winner.");
     }
-    const admission = registerScopeBinding(persisted.value);
+    writeScopeBindingShadow(input.directory, claimed);
+    writeScopeBindingShadow(input.directory, retired);
+    const admission = registerScopeBinding(claimed);
     if (!admission.ok) {
-      await tombstoneScopeBinding(input.directory, persisted.value, "revoked");
-      return {
-        ok: false,
-        code: admission.code,
-        message: admission.message
-      };
-    }
-    const retired = await tombstoneScopeBinding(input.directory, predecessor, "superseded");
-    if (!retired.ok) {
-      await tombstoneScopeBinding(input.directory, persisted.value, "revoked");
-      return persistenceFailure(`Successor was persisted but predecessor retirement failed: ${retired.message}`);
+      return rollbackAdmissionFailure(input.directory, claimed, [{ original: predecessor, superseded: retired }], admission);
     }
-    return {
-      ok: true,
-      value: { previous: predecessor, claimed: persisted.value }
-    };
+    installScopeBindingTombstone(retired);
+    return { ok: true, value: { previous: predecessor, claimed } };
   } catch (error) {
-    return persistenceFailure(`Claim transaction failed: ${error instanceof Error ? error.message : "unknown I/O error"}`);
-  } finally {
-    if (release)
-      try {
-        await release();
-      } catch {}
-  }
-}
-async function writeClaimReceipt(claimPath, previous, claimed, input) {
-  const receipt = {
-    version: 1,
-    predecessorGenerationId: previous.generationId,
-    winnerGenerationId: claimed.generationId,
-    childSessionId: input.childSessionId,
-    dispatchCallId: input.dispatchCallId,
-    createdAt: Date.now()
-  };
-  try {
-    await atomicWrite(claimPath, JSON.stringify(receipt, null, 2));
-    const raw = readBoundedFile(claimPath);
-    const verified = raw ? JSON.parse(raw) : null;
-    return verified?.winnerGenerationId === receipt.winnerGenerationId && verified.childSessionId === receipt.childSessionId ? { ok: true, value: verified } : persistenceFailure("Claim winner receipt verification failed.");
-  } catch (error) {
-    return persistenceFailure(`Claim winner receipt write failed: ${error instanceof Error ? error.message : "unknown I/O error"}`);
+    if (error instanceof ScopeCoordinationAbort)
+      return error.failure;
+    return persistenceFailure(`Claim transaction failed: ${error instanceof Error ? error.message : "unknown coordination error"}`);
   }
 }
 async function replaceExistingScopeDeclaration(input) {
@@ -1231,58 +1499,69 @@ async function replaceExistingScopeDeclaration(input) {
   const { binding } = input;
   if (binding.activation !== "declaration" || binding.dispatchCallId !== undefined)
     return persistenceFailure("declare_scope may persist only a declaration generation.");
-  const digest = createHash("sha256").update(`${binding.workspaceIdentity}\x00${binding.taskId}\x00${binding.ownerSessionId}`).digest("hex").slice(0, 40);
-  const lockPath = path2.join(getScopesDir(input.directory), `declaration-${digest}.lock-target`);
-  if (!await ensureLockTarget(lockPath))
-    return persistenceFailure("Could not prepare declaration transaction lock.");
-  let release;
+  const imported = ensureScopeBindingAuthorityImported(input.directory);
+  if (!imported.ok)
+    return imported;
+  const all = readAllAuthoritativeScopeBindings(input.directory, {
+    enforceLiveCapacity: false
+  });
+  if (!all.ok)
+    return all;
+  const owned = all.value.filter((candidate) => candidate.lifecycleState === "live" && candidate.expiresAt > Date.now() && candidate.workspaceIdentity === binding.workspaceIdentity && candidate.taskId === binding.taskId && candidate.ownerSessionId === binding.ownerSessionId && candidate.generationId !== binding.generationId);
+  if (owned.length > 0 && !input.replaceExisting) {
+    return {
+      ok: false,
+      code: "SCOPE_BINDING_AMBIGUOUS",
+      message: "A live owned generation already exists; retry declare_scope with replace_existing=true to revoke it atomically."
+    };
+  }
   try {
-    release = await import_proper_lockfile.default.lock(lockPath, {
-      stale: LOCK_STALE_MS,
-      retries: { retries: 5, minTimeout: 50, maxTimeout: 250 },
-      realpath: false
-    });
-    const all = readAllExactBindings(input.directory);
-    if (!all)
-      return {
-        ok: false,
-        code: "SCOPE_BINDING_STORE_OVERLOADED",
-        message: "The durable binding set cannot be completely evaluated."
-      };
-    const owned = all.filter((candidate) => candidate.lifecycleState === "live" && candidate.expiresAt > Date.now() && candidate.workspaceIdentity === binding.workspaceIdentity && candidate.taskId === binding.taskId && candidate.ownerSessionId === binding.ownerSessionId && candidate.generationId !== binding.generationId);
-    if (owned.length > 0 && !input.replaceExisting)
-      return {
-        ok: false,
-        code: "SCOPE_BINDING_AMBIGUOUS",
-        message: "A live owned generation already exists; retry declare_scope with replace_existing=true to revoke it atomically."
-      };
-    const persisted = await writeScopeBindingToDisk(input.directory, binding);
-    if (!persisted.ok)
-      return persisted;
-    for (const prior of owned) {
-      const retired = await tombstoneScopeBinding(input.directory, prior, "superseded");
-      if (!retired.ok) {
-        await tombstoneScopeBinding(input.directory, persisted.value, "revoked");
-        return persistenceFailure(`Replacement could not retire generation ${prior.generationId}: ${retired.message}`);
+    let persisted = null;
+    const retired = [];
+    withCoordinationTransaction(input.directory, () => {
+      const create = _scopePersistenceInternals.transitionScopeBindingStateWithinTransaction(input.directory, binding, null);
+      if (!create.ok) {
+        throw new ScopeCoordinationAbort(create);
+      }
+      persisted = create.value;
+      for (const prior of owned) {
+        const superseded = {
+          ...prior,
+          revision: prior.revision + 1,
+          lifecycleState: "superseded",
+          updatedAt: create.value.updatedAt,
+          expiresAt: Math.min(prior.expiresAt, create.value.updatedAt)
+        };
+        const result = _scopePersistenceInternals.transitionScopeBindingStateWithinTransaction(input.directory, superseded, prior.revision);
+        if (!result.ok) {
+          throw new ScopeCoordinationAbort(result);
+        }
+        retired.push(result.value);
       }
+    });
+    if (!persisted) {
+      return persistenceFailure("Declaration transaction did not persist a generation.");
+    }
+    writeScopeBindingShadow(input.directory, persisted);
+    for (const prior of retired) {
+      writeScopeBindingShadow(input.directory, prior);
+      installScopeBindingTombstone(prior);
     }
-    const admission = registerScopeBinding(persisted.value);
+    const admission = registerScopeBinding(persisted);
     if (!admission.ok) {
-      await tombstoneScopeBinding(input.directory, persisted.value, "revoked");
-      return {
-        ok: false,
-        code: admission.code,
-        message: admission.message
-      };
+      if (retired.length !== owned.length) {
+        return persistenceFailure("Memory admission failed after an incomplete predecessor transition.");
+      }
+      return rollbackAdmissionFailure(input.directory, persisted, owned.map((original, index) => ({
+        original,
+        superseded: retired[index]
+      })), admission);
     }
-    return { ok: true, value: persisted.value };
+    return { ok: true, value: persisted };
   } catch (error) {
-    return persistenceFailure(`Declaration transaction failed: ${error instanceof Error ? error.message : "unknown I/O error"}`);
-  } finally {
-    if (release)
-      try {
-        await release();
-      } catch {}
+    if (error instanceof ScopeCoordinationAbort)
+      return error.failure;
+    return persistenceFailure(`Declaration transaction failed: ${error instanceof Error ? error.message : "unknown coordination error"}`);
   }
 }
 function scheduleScopeBindingMaintenance(directory) {
@@ -1322,32 +1601,13 @@ async function pruneScopeBindingTombstones(directory) {
       retries: { retries: 3, minTimeout: 50, maxTimeout: 200 },
       realpath: false
     });
-    let all = readAllExactBindings(directory, {
+    const readAll = readAllAuthoritativeScopeBindings(directory, {
       enforceLiveCapacity: false,
       maintenanceScan: true
     });
-    if (!all)
-      return {
-        ok: false,
-        code: "SCOPE_BINDING_STORE_OVERLOADED",
-        message: "The durable binding set cannot be completely evaluated."
-      };
-    for (const binding of all) {
-      const filePath = getBindingFilePath(directory, binding);
-      if (!hasDurableRetirementIntent(filePath, binding))
-        continue;
-      const finalized = await tombstoneScopeBinding(directory, binding, "revoked");
-      if (finalized.ok)
-        try {
-          fs.unlinkSync(getRetirementIntentPath(filePath));
-        } catch {}
-    }
-    all = readAllExactBindings(directory, {
-      enforceLiveCapacity: false,
-      maintenanceScan: true
-    });
-    if (!all)
-      return persistenceFailure("The durable binding set changed during maintenance reconciliation.");
+    if (!readAll.ok)
+      return readAll;
+    const all = readAll.value;
     const tombstones = all.filter((binding) => binding.lifecycleState !== "live").sort((left, right) => left.updatedAt - right.updatedAt);
     const now = Date.now();
     const removable = tombstones.filter((binding, index) => now - binding.updatedAt > MAX_TOMBSTONE_AGE_MS || index < tombstones.length - MAX_DURABLE_TOMBSTONES);
@@ -1371,6 +1631,7 @@ async function pruneScopeBindingTombstones(directory) {
         const latest = latestRaw ? validateScopeBindingPayload(directory, JSON.parse(latestRaw)) : null;
         if (!latest || latest.generationId !== binding.generationId || latest.revision !== binding.revision || latest.lifecycleState === "live" && !hasDurableRetirementIntent(filePath, latest))
           continue;
+        deleteCoordinationState(directory, SCOPE_BINDING_COORDINATION_NAMESPACE, binding.generationId, binding.revision);
         fs.unlinkSync(filePath);
         removedExact = true;
         removed++;
@@ -1475,47 +1736,33 @@ function attemptIdleScopeBindingRevival(directory, resolution) {
     return null;
   if (hasDeliberateScopeBindingDenyOverlay(candidate))
     return null;
-  let release;
-  try {
-    const resolvedWorkspace = fs.realpathSync(directory);
-    assertProjectRoot(resolvedWorkspace);
-    const scopePath = getBindingFilePath(resolvedWorkspace, candidate);
-    if (!isScopesDirSafe(resolvedWorkspace, getScopesDir(resolvedWorkspace)))
-      return null;
-    const lockPath = getGenerationLockPath(scopePath);
-    if (!ensureLockTargetSync(lockPath))
-      return null;
-    release = lockSyncWithBoundedRetry(lockPath);
-    const raw = readBoundedFile(scopePath);
-    if (!raw)
-      return null;
-    const current = validateScopeBindingPayload(resolvedWorkspace, JSON.parse(raw));
-    if (!current || current.bindingId !== candidate.bindingId || current.generationId !== candidate.generationId || current.revision !== candidate.revision || current.lifecycleState !== "live" || current.expiresAt > Date.now() || Date.now() - current.expiresAt > SCOPE_BINDING_AUTO_REVIVE_WINDOW_MS)
-      return null;
-    const revivedAt = Date.now();
-    const revived = {
-      ...current,
-      revision: current.revision + 1,
-      updatedAt: revivedAt,
-      leaseStartedAt: revivedAt,
-      expiresAt: revivedAt + DEFAULT_SCOPE_BINDING_TTL_MS
-    };
-    atomicWriteSync(scopePath, JSON.stringify(revived, null, 2));
-    const verifiedRaw = readBoundedFile(scopePath);
-    const verified = verifiedRaw ? validateScopeBindingPayload(resolvedWorkspace, JSON.parse(verifiedRaw)) : null;
-    if (!verified || verified.revision !== revived.revision || verified.lifecycleState !== "live" || verified.expiresAt !== revived.expiresAt)
-      return null;
-    clearSweepTombstoneForRevival(revived);
-    appendScopeBindingRevivalEvent(resolvedWorkspace, revived);
-    return revived;
-  } catch {
+  const imported = ensureScopeBindingAuthorityImported(directory);
+  if (!imported.ok)
+    return null;
+  const all = readAllAuthoritativeScopeBindings(directory, {
+    enforceLiveCapacity: false
+  });
+  if (!all.ok)
+    return null;
+  const current = all.value.find((binding) => binding.bindingId === candidate.bindingId && binding.generationId === candidate.generationId);
+  if (!current || current.revision !== candidate.revision || current.lifecycleState !== "live" || current.expiresAt > Date.now() || Date.now() - current.expiresAt > SCOPE_BINDING_AUTO_REVIVE_WINDOW_MS) {
     return null;
-  } finally {
-    if (release)
-      try {
-        release();
-      } catch {}
   }
+  const revivedAt = Date.now();
+  const revived = {
+    ...current,
+    revision: current.revision + 1,
+    updatedAt: revivedAt,
+    leaseStartedAt: revivedAt,
+    expiresAt: revivedAt + DEFAULT_SCOPE_BINDING_TTL_MS
+  };
+  const persisted = transitionScopeBindingState(directory, revived, current.revision);
+  if (!persisted.ok)
+    return null;
+  writeScopeBindingShadow(directory, persisted.value);
+  clearSweepTombstoneForRevival(persisted.value);
+  appendScopeBindingRevivalEvent(directory, persisted.value);
+  return persisted.value;
 }
 function resolveAuthorizedScopeBindingForPlan(input) {
   const resolution = resolveAuthorizedScopeBindingForPlanDetailed(input);
@@ -1603,87 +1850,16 @@ function resolveAuthorizedScopeBindingForSessionDetailed(input) {
     totalCandidates: expiredTotal
   } : { status: "not_declared" };
 }
-function readPrFeedbackBindingFile(directory, filePath, activeSessionId, taskId) {
-  try {
-    const leaf = fs.lstatSync(filePath);
-    if (!leaf.isFile() || leaf.isSymbolicLink())
-      return null;
-    if (normalizePathForComparison(fs.realpathSync(filePath)) !== normalizePathForComparison(filePath))
-      return null;
-  } catch {
-    return null;
-  }
-  const nofollow = fs.constants.O_NOFOLLOW ?? 0;
-  let fd;
-  try {
-    fd = fs.openSync(filePath, fs.constants.O_RDONLY | nofollow);
-  } catch {
-    return null;
-  }
-  let raw = "";
-  try {
-    const stat = fs.fstatSync(fd);
-    if (!stat.isFile() || stat.size > MAX_SCOPE_BYTES)
-      return null;
-    const buffer = Buffer.alloc(stat.size);
-    fs.readSync(fd, buffer, 0, stat.size, 0);
-    raw = buffer.toString("utf8");
-  } catch {
-    return null;
-  } finally {
-    try {
-      fs.closeSync(fd);
-    } catch {}
-  }
-  let parsed;
-  try {
-    parsed = validateScopeBindingPayload(directory, JSON.parse(raw));
-  } catch {
-    return null;
-  }
-  if (!parsed)
-    return null;
-  if (hasScopeBindingDenyOverlay(parsed))
-    return null;
-  const now = Date.now();
-  if (parsed.source !== "pr_feedback" || taskId !== undefined && parsed.taskId !== taskId || parsed.ownerSessionId !== activeSessionId || parsed.activation !== "active" || typeof parsed.dispatchCallId !== "string" || !parsed.dispatchCallId || parsed.ownerMessageId !== parsed.dispatchCallId || typeof parsed.parentOwnerSessionId !== "string" || !parsed.parentOwnerSessionId || parsed.ownerSessionId === parsed.parentOwnerSessionId || parsed.parentCallId !== parsed.dispatchCallId || parsed.workflowSessionId !== parsed.parentOwnerSessionId || typeof parsed.workflowRevisionDigest !== "string" || !parsed.workflowRevisionDigest || parsed.planId !== `pr-feedback:${parsed.workflowSessionId}` || parsed.planStructureHash !== parsed.workflowRevisionDigest || parsed.declaredAt > now || parsed.expiresAt <= now || parsed.lifecycleState !== "live")
-    return null;
-  const expectedPath = getBindingFilePath(directory, parsed);
-  if (normalizePathForComparison(expectedPath) !== normalizePathForComparison(filePath))
-    return null;
-  return parsed;
-}
 function resolveAuthorizedPrFeedbackScopeBindingFromDisk(input) {
   if (!input.activeSessionId.trim())
     return null;
-  const scopesDir = getScopesDir(input.directory);
-  if (!isScopesDirSafe(input.directory, scopesDir))
-    return null;
-  if (!migrateLegacyBindingsSync(input.directory))
+  const authoritative = readAllAuthoritativeScopeBindings(input.directory, {
+    enforceLiveCapacity: false
+  });
+  if (!authoritative.ok)
     return null;
-  let candidates;
-  if (input.taskId) {
-    if (!isSafeTaskId(input.taskId))
-      return null;
-    try {
-      const names = fs.readdirSync(scopesDir);
-      if (names.length > MAX_BINDING_FILES_TO_SCAN)
-        return null;
-      candidates = names.filter((name) => name.startsWith(exactBindingPrefix(input.taskId)) && name.endsWith(".json")).map((name) => path2.join(scopesDir, name));
-    } catch {
-      return null;
-    }
-  } else {
-    try {
-      const names = fs.readdirSync(scopesDir);
-      if (names.length > MAX_BINDING_FILES_TO_SCAN)
-        return null;
-      candidates = names.filter((name) => name.startsWith("binding-") && name.endsWith(".json")).map((name) => path2.join(scopesDir, name));
-    } catch {
-      return null;
-    }
-  }
-  const matches = candidates.map((candidate) => readPrFeedbackBindingFile(input.directory, candidate, input.activeSessionId, input.taskId)).filter((binding) => binding !== null);
+  const now = Date.now();
+  const matches = authoritative.value.filter((parsed) => parsed.source === "pr_feedback" && (!input.taskId || parsed.taskId === input.taskId) && parsed.ownerSessionId === input.activeSessionId && parsed.activation === "active" && typeof parsed.dispatchCallId === "string" && parsed.dispatchCallId.length > 0 && parsed.ownerMessageId === parsed.dispatchCallId && typeof parsed.parentOwnerSessionId === "string" && parsed.parentOwnerSessionId.length > 0 && parsed.ownerSessionId !== parsed.parentOwnerSessionId && parsed.parentCallId === parsed.dispatchCallId && parsed.workflowSessionId === parsed.parentOwnerSessionId && typeof parsed.workflowRevisionDigest === "string" && parsed.workflowRevisionDigest.length > 0 && parsed.planId === `pr-feedback:${parsed.workflowSessionId}` && parsed.planStructureHash === parsed.workflowRevisionDigest && parsed.declaredAt <= now && parsed.expiresAt > now && parsed.lifecycleState === "live" && !hasScopeBindingDenyOverlay(parsed));
   if (matches.length !== 1)
     return null;
   const admission = registerScopeBinding(matches[0]);
@@ -1696,6 +1872,8 @@ function atomicWriteSync(targetPath, content) {
   atomicWriteSwarmFileSync(targetPath, content);
 }
 var _scopePersistenceInternals = {
+  transitionScopeBindingState,
+  transitionScopeBindingStateWithinTransaction,
   get liveBindingCapacity() {
     return liveBindingCapacity;
   },