opencode-swarm 7.138.3 → 7.138.4

package/dist/cli/index-smsy2p8n.js

@@ -0,0 +1,1725 @@
+// @bun
+import {
+  unsafePathTextReason
+} from "./index-556ja8an.js";
+import {
+  computePlanStructureHash,
+  derivePlanId
+} from "./index-4fmztnrq.js";
+import {
+  PlanSchema
+} from "./index-1kz6da87.js";
+import {
+  require_proper_lockfile
+} from "./index-7g4c7s5r.js";
+import {
+  bunWrite
+} from "./index-y111zefa.js";
+import {
+  __toESM
+} from "./index-a76rekgs.js";
+
+// src/scope/scope-persistence.ts
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import { createHash } from "crypto";
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/scope/scope-binding.ts
+import { randomUUID } from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+var MAX_PENDING_SCOPE_BINDINGS = 256;
+var DEFAULT_SCOPE_BINDING_TTL_MS = 60 * 60 * 1000;
+var MAX_SCOPE_BINDING_TOMBSTONES = 256;
+var pendingScopeBindings = new Map;
+var scopeBindingTombstones = new Map;
+var MAX_SCOPE_PATH_BYTES = 4096;
+var MAX_SCOPE_FILES_BYTES = 1024 * 1024;
+function newIdentity() {
+  return randomUUID();
+}
+function isScopeBindingIdentity(value) {
+  return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f-]{27}$/i.test(value);
+}
+function canonicalWorkspaceIdentity(directory) {
+  try {
+    const real = fs.realpathSync(directory).replace(/\\/g, "/");
+    return process.platform === "win32" ? real.toLowerCase() : real;
+  } catch {
+    return null;
+  }
+}
+function normalizeScopePath(value) {
+  if (typeof value !== "string")
+    return null;
+  if (unsafePathTextReason(value))
+    return null;
+  const trimmed = value.trim().replace(/\\/g, "/");
+  if (trimmed.length === 0 || trimmed.includes("\x00") || trimmed.split("/").includes("..") || path.posix.isAbsolute(trimmed) || /^[A-Za-z]:\//.test(trimmed))
+    return null;
+  const normalized = path.posix.normalize(trimmed).replace(/^\.\//, "");
+  if (normalized === "." || normalized === ".." || normalized.startsWith("../"))
+    return null;
+  return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+function normalizeScopeFiles(files) {
+  if (!Array.isArray(files) || files.length === 0 || files.length > 1e4)
+    return null;
+  const normalized = new Set;
+  let totalBytes = 0;
+  for (const file of files) {
+    const candidate = normalizeScopePath(file);
+    if (!candidate)
+      return null;
+    const bytes = Buffer.byteLength(candidate, "utf8");
+    totalBytes += bytes;
+    if (bytes > MAX_SCOPE_PATH_BYTES || totalBytes > MAX_SCOPE_FILES_BYTES) {
+      return null;
+    }
+    normalized.add(candidate);
+  }
+  return normalized.size > 0 ? [...normalized].sort() : null;
+}
+function bindingKey(binding) {
+  return binding.generationId;
+}
+function sweepExpired(now = Date.now()) {
+  for (const [key, binding] of pendingScopeBindings) {
+    if (binding.expiresAt <= now) {
+      pendingScopeBindings.delete(key);
+      const expired = {
+        ...binding,
+        revision: binding.revision + 1,
+        lifecycleState: "expired",
+        updatedAt: now
+      };
+      scopeBindingTombstones.set(bindingKey(expired), expired);
+    }
+  }
+  while (scopeBindingTombstones.size > MAX_SCOPE_BINDING_TOMBSTONES) {
+    const oldest = scopeBindingTombstones.keys().next().value;
+    if (!oldest)
+      break;
+    scopeBindingTombstones.delete(oldest);
+  }
+}
+function registerScopeBinding(binding) {
+  sweepExpired();
+  if (binding.lifecycleState !== "live" || binding.expiresAt <= Date.now()) {
+    return {
+      ok: false,
+      code: "SCOPE_BINDING_CAPACITY",
+      message: "Only an unexpired live binding can be admitted."
+    };
+  }
+  const exact = pendingScopeBindings.get(bindingKey(binding));
+  if (exact && exact.bindingId !== binding.bindingId) {
+    return {
+      ok: false,
+      code: "SCOPE_BINDING_STALE",
+      message: "The generation identity collides with a different binding."
+    };
+  }
+  if (exact && exact.revision > binding.revision) {
+    return {
+      ok: false,
+      code: "SCOPE_BINDING_STALE",
+      message: "A newer revision of this generation is already admitted."
+    };
+  }
+  if (binding.activation === "declaration" && binding.dispatchCallId === undefined) {
+    for (const [existingKey, existing] of pendingScopeBindings) {
+      if (existing.generationId !== binding.generationId && existing.activation === "declaration" && existing.dispatchCallId === undefined && existing.workspaceIdentity === binding.workspaceIdentity && existing.taskId === binding.taskId && existing.ownerSessionId === binding.ownerSessionId) {
+        pendingScopeBindings.delete(existingKey);
+        scopeBindingTombstones.set(existingKey, {
+          ...existing,
+          revision: existing.revision + 1,
+          lifecycleState: "superseded",
+          updatedAt: Date.now()
+        });
+      }
+    }
+  }
+  if (!exact && pendingScopeBindings.size >= MAX_PENDING_SCOPE_BINDINGS) {
+    return {
+      ok: false,
+      code: "SCOPE_BINDING_CAPACITY",
+      message: `Scope binding capacity ${MAX_PENDING_SCOPE_BINDINGS} is exhausted; complete or expire a live task before retrying.`
+    };
+  }
+  const key = bindingKey(binding);
+  pendingScopeBindings.delete(key);
+  pendingScopeBindings.set(key, binding);
+  return { ok: true, binding };
+}
+function clearScopeBindings(predicate) {
+  const removed = [];
+  if (!predicate) {
+    removed.push(...pendingScopeBindings.values());
+    pendingScopeBindings.clear();
+    scopeBindingTombstones.clear();
+    return removed;
+  }
+  for (const [key, binding] of pendingScopeBindings) {
+    if (predicate(binding)) {
+      removed.push(binding);
+      pendingScopeBindings.delete(key);
+    }
+  }
+  return removed;
+}
+function clearExactScopeBinding(input) {
+  const candidate = pendingScopeBindings.get(input.generationId);
+  if (!candidate || candidate.bindingId !== input.bindingId)
+    return null;
+  pendingScopeBindings.delete(input.generationId);
+  return candidate;
+}
+function installScopeBindingTombstone(binding) {
+  pendingScopeBindings.delete(binding.generationId);
+  scopeBindingTombstones.delete(binding.generationId);
+  scopeBindingTombstones.set(binding.generationId, binding);
+  while (scopeBindingTombstones.size > MAX_SCOPE_BINDING_TOMBSTONES) {
+    const oldest = scopeBindingTombstones.keys().next().value;
+    if (!oldest)
+      break;
+    scopeBindingTombstones.delete(oldest);
+  }
+}
+function hasScopeBindingDenyOverlay(binding) {
+  const tombstone = scopeBindingTombstones.get(binding.generationId);
+  return Boolean(tombstone && tombstone.bindingId === binding.bindingId && tombstone.revision >= binding.revision && tombstone.lifecycleState !== "live");
+}
+function installFailedRevocationOverlay(binding, reason) {
+  const current = pendingScopeBindings.get(binding.generationId);
+  if (!current || current.bindingId !== binding.bindingId || current.revision !== binding.revision)
+    return false;
+  const now = Date.now();
+  installScopeBindingTombstone({
+    ...current,
+    revision: current.revision + 1,
+    lifecycleState: reason,
+    updatedAt: now,
+    expiresAt: Math.min(current.expiresAt, now)
+  });
+  return true;
+}
+function installScopeBindingRetirementIntent(binding) {
+  const current = pendingScopeBindings.get(binding.generationId);
+  const source = current ?? (binding.version === 2 ? binding : null);
+  if (!source || source.bindingId !== binding.bindingId)
+    return null;
+  const now = Date.now();
+  const tombstone = {
+    ...source,
+    revision: source.revision + 1,
+    lifecycleState: "revoked",
+    updatedAt: now,
+    expiresAt: Math.min(source.expiresAt, now)
+  };
+  installScopeBindingTombstone(tombstone);
+  return tombstone;
+}
+function updateExactScopeBinding(binding) {
+  const current = pendingScopeBindings.get(binding.generationId);
+  if (!current || current.bindingId !== binding.bindingId || binding.revision <= current.revision)
+    return {
+      ok: false,
+      code: "SCOPE_BINDING_CAPACITY",
+      message: "The exact binding generation is stale or no longer active."
+    };
+  pendingScopeBindings.set(binding.generationId, binding);
+  return { ok: true, binding };
+}
+function createClaimedScopeBinding(previous, input) {
+  const now = Date.now();
+  return {
+    ...previous,
+    generationId: newIdentity(),
+    revision: 1,
+    ownerSessionId: input.childSessionId,
+    childSessionId: input.childSessionId,
+    ownerMessageId: input.dispatchCallId,
+    dispatchCallId: input.dispatchCallId,
+    parentOwnerSessionId: input.parentSessionId,
+    parentCallId: input.dispatchCallId,
+    activation: "active",
+    predecessorGenerationId: previous.generationId,
+    updatedAt: now,
+    leaseStartedAt: now,
+    expiresAt: now + DEFAULT_SCOPE_BINDING_TTL_MS
+  };
+}
+
+// src/scope/scope-persistence.ts
+var SCOPE_SCHEMA_VERSION = 1;
+var DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+var LOCK_STALE_MS = 30 * 1000;
+var SCOPES_DIR = ".swarm/scopes";
+var MAX_FILES_PER_SCOPE = 1e4;
+var MAX_PLAN_BYTES = 10 * 1024 * 1024;
+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 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);
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error("Lock unavailable");
+}
+var WINDOWS_RESERVED = new Set([
+  "CON",
+  "PRN",
+  "AUX",
+  "NUL",
+  "COM1",
+  "COM2",
+  "COM3",
+  "COM4",
+  "COM5",
+  "COM6",
+  "COM7",
+  "COM8",
+  "COM9",
+  "LPT1",
+  "LPT2",
+  "LPT3",
+  "LPT4",
+  "LPT5",
+  "LPT6",
+  "LPT7",
+  "LPT8",
+  "LPT9"
+]);
+function getScopesDir(directory) {
+  return path2.join(directory, SCOPES_DIR);
+}
+function normalizePathForComparison(value) {
+  const normalized = path2.resolve(value);
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function isSafeTaskId(taskId) {
+  if (typeof taskId !== "string")
+    return false;
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(taskId))
+    return false;
+  const head = taskId.replace(/\.+$/, "").split(".")[0].toUpperCase();
+  if (WINDOWS_RESERVED.has(head))
+    return false;
+  return true;
+}
+function isScopesDirSafe(directory, scopesDir) {
+  try {
+    const resolvedWorkspace = fs2.realpathSync(directory);
+    const expectedSwarmDir = path2.join(resolvedWorkspace, ".swarm");
+    const expectedScopesDir = path2.join(expectedSwarmDir, "scopes");
+    const swarmStat = fs2.lstatSync(expectedSwarmDir);
+    const scopesStat = fs2.lstatSync(expectedScopesDir);
+    if (!swarmStat.isDirectory() || swarmStat.isSymbolicLink() || !scopesStat.isDirectory() || scopesStat.isSymbolicLink())
+      return false;
+    const resolvedScopes = fs2.realpathSync(scopesDir);
+    if (normalizePathForComparison(resolvedScopes) !== normalizePathForComparison(expectedScopesDir))
+      return false;
+    const rel = path2.relative(resolvedWorkspace, resolvedScopes);
+    return rel.length > 0 && !rel.startsWith("..") && !path2.isAbsolute(rel);
+  } catch {
+    return false;
+  }
+}
+function resolveSafeScopeFileForUnlink(directory, targetPath) {
+  try {
+    const resolvedWorkspace = fs2.realpathSync(directory);
+    const scopesDir = path2.join(resolvedWorkspace, SCOPES_DIR);
+    if (!isScopesDirSafe(resolvedWorkspace, scopesDir))
+      return null;
+    const candidate = path2.resolve(targetPath);
+    const resolvedCandidate = fs2.realpathSync(candidate);
+    if (normalizePathForComparison(path2.dirname(candidate)) !== normalizePathForComparison(scopesDir) || normalizePathForComparison(resolvedCandidate) !== normalizePathForComparison(candidate))
+      return null;
+    const relative2 = path2.relative(resolvedWorkspace, resolvedCandidate);
+    if (relative2.length === 0 || relative2 === ".." || relative2.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative2))
+      return null;
+    const leafStat = fs2.lstatSync(candidate);
+    if (!leafStat.isFile() || leafStat.isSymbolicLink())
+      return null;
+    if (!isScopesDirSafe(resolvedWorkspace, scopesDir))
+      return null;
+    const finalResolvedCandidate = fs2.realpathSync(candidate);
+    const finalLeafStat = fs2.lstatSync(candidate);
+    if (normalizePathForComparison(finalResolvedCandidate) !== normalizePathForComparison(candidate) || !finalLeafStat.isFile() || finalLeafStat.isSymbolicLink() || finalLeafStat.dev !== leafStat.dev || finalLeafStat.ino !== leafStat.ino)
+      return null;
+    return candidate;
+  } catch {
+    return null;
+  }
+}
+function getScopeFilePath(directory, taskId) {
+  if (!isSafeTaskId(taskId)) {
+    throw new Error(`Invalid taskId for scope persistence: ${taskId}`);
+  }
+  return path2.join(getScopesDir(directory), `scope-${taskId}.json`);
+}
+function getLegacyBindingFilePath(directory, taskId, ownerSessionId) {
+  if (!isSafeTaskId(taskId) || !ownerSessionId.trim()) {
+    throw new Error("Invalid identity for scope binding persistence");
+  }
+  const ownerHash = createHash("sha256").update(ownerSessionId).digest("hex").slice(0, 24);
+  return path2.join(getScopesDir(directory), `binding-${taskId}-${ownerHash}.json`);
+}
+function getBindingFilePath(directory, binding) {
+  if (!isSafeTaskId(binding.taskId) || !isScopeBindingIdentity(binding.bindingId) || !isScopeBindingIdentity(binding.generationId))
+    throw new Error("Invalid exact identity for scope binding persistence");
+  return path2.join(getScopesDir(directory), `binding-${binding.taskId}-${binding.bindingId}-${binding.generationId}.json`);
+}
+function getGenerationLockPath(bindingPath) {
+  return `${bindingPath}.generation-lock`;
+}
+function getRetirementIntentPath(bindingPath) {
+  return `${bindingPath}.retirement-intent`;
+}
+function hasDurableRetirementIntent(bindingPath, binding) {
+  const raw = readBoundedFile(getRetirementIntentPath(bindingPath));
+  if (!raw)
+    return false;
+  try {
+    const intent = JSON.parse(raw);
+    return intent.bindingId === binding.bindingId && intent.generationId === binding.generationId;
+  } catch {
+    return false;
+  }
+}
+function ensureLockTargetSync(targetPath) {
+  try {
+    fs2.mkdirSync(path2.dirname(targetPath), { recursive: true });
+    const nofollow = fs2.constants.O_NOFOLLOW ?? 0;
+    const fd = fs2.openSync(targetPath, fs2.constants.O_WRONLY | fs2.constants.O_CREAT | nofollow);
+    fs2.closeSync(fd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function exactBindingPrefix(taskId) {
+  return `binding-${taskId}-`;
+}
+function readBoundedFile(filePath) {
+  const nofollow = fs2.constants.O_NOFOLLOW ?? 0;
+  let fd;
+  try {
+    fd = fs2.openSync(filePath, fs2.constants.O_RDONLY | nofollow);
+  } catch {
+    return null;
+  }
+  try {
+    const stat = fs2.fstatSync(fd);
+    if (!stat.isFile() || stat.size <= 0 || stat.size > MAX_SCOPE_BYTES)
+      return null;
+    const buffer = Buffer.alloc(stat.size);
+    fs2.readSync(fd, buffer, 0, stat.size, 0);
+    return buffer.toString("utf8");
+  } catch {
+    return null;
+  } finally {
+    try {
+      fs2.closeSync(fd);
+    } catch {}
+  }
+}
+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)}`;
+}
+function validateScopeBindingPayload(directory, parsed, options = {}) {
+  const workspaceIdentity = canonicalWorkspaceIdentity(directory);
+  const files = Array.isArray(parsed.files) ? normalizeScopeFiles(parsed.files.filter((file) => typeof file === "string")) : null;
+  if (parsed.version !== 2 || !workspaceIdentity || parsed.workspaceIdentity !== workspaceIdentity || !isSafeTaskId(parsed.taskId ?? "") || !files || typeof parsed.planId !== "string" || !parsed.planId || typeof parsed.planStructureHash !== "string" || !parsed.planStructureHash || typeof parsed.ownerSessionId !== "string" || !parsed.ownerSessionId.trim() || typeof parsed.ownerMessageId !== "string" || !parsed.ownerMessageId.trim() || !["declaration", "pending_child", "active"].includes(parsed.activation ?? "") || ![
+    "declare_scope",
+    "plan",
+    "file_directive",
+    "pr_feedback",
+    "worktree_derived"
+  ].includes(parsed.source ?? "") || typeof parsed.declaredAt !== "number" || !Number.isFinite(parsed.declaredAt) || typeof parsed.expiresAt !== "number" || !Number.isFinite(parsed.expiresAt))
+    return null;
+  const legacySeed = JSON.stringify({
+    workspaceIdentity,
+    planId: parsed.planId,
+    planStructureHash: parsed.planStructureHash,
+    taskId: parsed.taskId,
+    ownerSessionId: parsed.ownerSessionId,
+    ownerMessageId: parsed.ownerMessageId,
+    dispatchCallId: parsed.dispatchCallId,
+    activation: parsed.activation,
+    source: parsed.source,
+    files,
+    declaredAt: parsed.declaredAt
+  });
+  const bindingId = isScopeBindingIdentity(parsed.bindingId) ? parsed.bindingId : options.allowLegacy ? deterministicIdentity(`binding\x00${legacySeed}`) : null;
+  const generationId = isScopeBindingIdentity(parsed.generationId) ? parsed.generationId : options.allowLegacy ? deterministicIdentity(`generation\x00${legacySeed}`) : null;
+  if (!bindingId || !generationId)
+    return null;
+  const lifecycleState = parsed.lifecycleState ?? (options.allowLegacy ? "live" : undefined);
+  if (!lifecycleState || !["live", "expired", "revoked", "superseded"].includes(lifecycleState))
+    return null;
+  const revision = parsed.revision ?? (options.allowLegacy ? 1 : undefined);
+  if (!Number.isSafeInteger(revision) || (revision ?? 0) < 1)
+    return null;
+  const updatedAt = parsed.updatedAt ?? parsed.declaredAt;
+  const leaseStartedAt = parsed.leaseStartedAt ?? parsed.declaredAt;
+  if (typeof updatedAt !== "number" || typeof leaseStartedAt !== "number")
+    return null;
+  const now = Date.now();
+  if (parsed.declaredAt > now || updatedAt < parsed.declaredAt || leaseStartedAt < parsed.declaredAt || parsed.activation === "declaration" && parsed.dispatchCallId !== undefined || parsed.activation === "pending_child" && (typeof parsed.dispatchCallId !== "string" || !parsed.dispatchCallId || parsed.ownerMessageId !== parsed.dispatchCallId) || 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))
+    return null;
+  return {
+    ...parsed,
+    bindingId,
+    generationId,
+    revision,
+    lifecycleState,
+    files,
+    workspaceIdentity,
+    updatedAt,
+    leaseStartedAt
+  };
+}
+function exactFilenameMatches(filePath, binding) {
+  return normalizePathForComparison(filePath) === normalizePathForComparison(getBindingFilePath(binding.workspaceIdentity, binding));
+}
+function migrateLegacyBindingsSync(directory, scanCapacity = bindingFileScanCapacity) {
+  const scopesDir = getScopesDir(directory);
+  if (!isScopesDirSafe(directory, scopesDir))
+    return false;
+  let names;
+  try {
+    names = fs2.readdirSync(scopesDir).sort();
+  } catch {
+    return true;
+  }
+  if (names.length > scanCapacity)
+    return false;
+  for (const name of names) {
+    const match = /^binding-(.+)-([a-f0-9]{24})\.json$/i.exec(name);
+    if (!match || !isSafeTaskId(match[1]))
+      continue;
+    const legacyPath = path2.join(scopesDir, name);
+    let releaseMigration;
+    try {
+      releaseMigration = lockfileWithSync.lockSync(legacyPath, {
+        stale: LOCK_STALE_MS,
+        realpath: false
+      });
+    } catch {
+      return false;
+    }
+    try {
+      const raw = readBoundedFile(legacyPath);
+      let binding = null;
+      try {
+        binding = raw ? validateScopeBindingPayload(directory, JSON.parse(raw), { allowLegacy: true }) : null;
+      } catch {
+        binding = null;
+      }
+      const ownerHash = binding ? createHash("sha256").update(binding.ownerSessionId).digest("hex").slice(0, 24) : "";
+      const valid = binding && binding.taskId === match[1] && ownerHash.toLowerCase() === match[2].toLowerCase() && normalizePathForComparison(getLegacyBindingFilePath(directory, binding.taskId, binding.ownerSessionId)) === normalizePathForComparison(legacyPath);
+      const archiveDir = path2.join(scopesDir, "archive");
+      fs2.mkdirSync(archiveDir, { recursive: true });
+      const archiveStat = fs2.lstatSync(archiveDir);
+      if (!archiveStat.isDirectory() || archiveStat.isSymbolicLink())
+        return false;
+      const archiveDigest = createHash("sha256").update(raw ?? name).digest("hex").slice(0, 32);
+      if (valid && binding) {
+        const exactPath = getBindingFilePath(directory, binding);
+        if (!fs2.existsSync(exactPath)) {
+          const temp = `${exactPath}.migration-${process.pid}`;
+          fs2.writeFileSync(temp, JSON.stringify(binding, null, 2), {
+            flag: "wx"
+          });
+          fs2.renameSync(temp, exactPath);
+        } else {
+          const existingRaw = readBoundedFile(exactPath);
+          const existing = existingRaw ? validateScopeBindingPayload(directory, JSON.parse(existingRaw)) : null;
+          if (!existing || existing.bindingId !== binding.bindingId || existing.generationId !== binding.generationId)
+            return false;
+        }
+      }
+      const archivePath = path2.join(archiveDir, `${valid ? "migrated" : "quarantined"}-${archiveDigest}.json`);
+      if (!fs2.existsSync(archivePath))
+        fs2.renameSync(legacyPath, archivePath);
+      else
+        fs2.unlinkSync(legacyPath);
+      fs2.writeFileSync(`${archivePath}.receipt.json`, JSON.stringify({
+        version: 1,
+        legacyName: name,
+        result: valid ? "migrated" : "quarantined",
+        bindingId: binding?.bindingId,
+        generationId: binding?.generationId
+      }, null, 2));
+      const archiveEntries = fs2.readdirSync(archiveDir).sort();
+      for (const stale of archiveEntries.slice(0, Math.max(0, archiveEntries.length - 2 * MAX_DURABLE_TOMBSTONES))) {
+        const stalePath = path2.join(archiveDir, stale);
+        try {
+          const stat = fs2.lstatSync(stalePath);
+          if (stat.isFile() && !stat.isSymbolicLink())
+            fs2.unlinkSync(stalePath);
+        } catch {}
+      }
+    } catch {
+      return false;
+    } finally {
+      try {
+        releaseMigration?.();
+      } catch {}
+    }
+  }
+  return true;
+}
+async function writeScopeToDisk(directory, taskId, files, ttlMs = DEFAULT_TTL_MS) {
+  if (!isSafeTaskId(taskId))
+    return;
+  if (!Array.isArray(files) || files.length === 0)
+    return;
+  if (files.length > MAX_FILES_PER_SCOPE)
+    return;
+  const scopesDir = getScopesDir(directory);
+  const scopePath = getScopeFilePath(directory, taskId);
+  try {
+    fs2.mkdirSync(scopesDir, { recursive: true });
+  } catch {
+    return;
+  }
+  if (!isScopesDirSafe(directory, scopesDir))
+    return;
+  const now = Date.now();
+  const payload = {
+    version: SCOPE_SCHEMA_VERSION,
+    taskId,
+    declaredAt: now,
+    expiresAt: now + ttlMs,
+    files: [...files]
+  };
+  const content = JSON.stringify(payload, null, 2);
+  try {
+    const flags = fs2.constants.O_WRONLY | fs2.constants.O_CREAT;
+    const nofollow = fs2.constants.O_NOFOLLOW ?? 0;
+    const fd = fs2.openSync(scopePath, flags | nofollow);
+    fs2.closeSync(fd);
+  } catch {
+    return;
+  }
+  let release;
+  try {
+    const lockPath = getGenerationLockPath(scopePath);
+    if (!await ensureLockTarget(lockPath))
+      return;
+    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);
+  } catch {} finally {
+    if (release) {
+      try {
+        await release();
+      } catch {}
+    }
+  }
+}
+async function writeScopeBindingToDisk(directory, binding) {
+  if (!isSafeTaskId(binding.taskId) || binding.version !== 2)
+    return persistenceFailure("Invalid binding schema or task identity.");
+  const workspaceIdentity = canonicalWorkspaceIdentity(directory);
+  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 {
+    fs2.mkdirSync(scopesDir, { recursive: true });
+  } catch {
+    return persistenceFailure("Could not create the durable scope store.");
+  }
+  if (!isScopesDirSafe(directory, scopesDir))
+    return persistenceFailure("The durable scope store failed containment checks.");
+  const content = JSON.stringify({ ...binding, files }, null, 2);
+  try {
+    const flags = fs2.constants.O_WRONLY | fs2.constants.O_CREAT;
+    const nofollow = fs2.constants.O_NOFOLLOW ?? 0;
+    const fd = fs2.openSync(scopePath, flags | nofollow);
+    fs2.closeSync(fd);
+  } catch {
+    return persistenceFailure("Could not create the exact generation record.");
+  }
+  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 {}
+    }
+  }
+}
+function persistenceFailure(message) {
+  return { ok: false, code: "SCOPE_BINDING_PERSISTENCE_FAILED", message };
+}
+async function persistAndRegisterScopeBinding(directory, binding) {
+  const persisted = await writeScopeBindingToDisk(directory, binding);
+  if (!persisted.ok)
+    return persisted;
+  const admission = registerScopeBinding(persisted.value);
+  if (admission.ok) {
+    scheduleScopeBindingMaintenance(directory);
+    return { ok: true, value: persisted.value };
+  }
+  const rollback = await tombstoneScopeBinding(directory, persisted.value, "superseded");
+  return {
+    ok: false,
+    code: rollback.ok ? admission.code : "SCOPE_BINDING_PERSISTENCE_FAILED",
+    message: rollback.ok ? admission.message : `Memory admission failed and rollback failed: ${rollback.message}`
+  };
+}
+function readScopeBindingFromDisk(input) {
+  const resolved = resolveScopeBindingFromDisk({
+    ...input,
+    includeExpired: false
+  });
+  return resolved.status === "found" ? resolved.binding : null;
+}
+function resolveScopeBindingFromDisk(input) {
+  if (!isSafeTaskId(input.taskId))
+    return { status: "not_declared" };
+  const completeSet = readAllExactBindings(input.directory);
+  if (!completeSet) {
+    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 live = candidates.filter((candidate) => candidate.lifecycleState === "live" && candidate.expiresAt > Date.now());
+  if (live.length > 1)
+    return {
+      status: "ambiguous",
+      candidates: live.slice(0, 8),
+      totalCandidates: live.length
+    };
+  if (live.length === 1)
+    return { status: "found", binding: live[0] };
+  const expired = candidates.filter((candidate) => candidate.lifecycleState !== "live" || candidate.expiresAt <= Date.now());
+  return input.includeExpired && expired.length > 0 ? {
+    status: "expired",
+    candidates: expired.slice(0, 8),
+    totalCandidates: expired.length
+  } : { status: "not_declared" };
+}
+function isDispatchCorrelated(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) {
+  const localRetirement = installScopeBindingRetirementIntent(input.binding);
+  let release;
+  try {
+    const resolvedWorkspace = fs2.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 {
+        fs2.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 {
+        fs2.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 {
+      fs2.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 {}
+  }
+}
+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.");
+  }
+  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)
+    };
+    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) {
+    installFailedRevocationOverlay(binding, reason);
+    return persistenceFailure(`Tombstone failed: ${error instanceof Error ? error.message : "unknown I/O error"}`);
+  } finally {
+    if (release)
+      try {
+        await release();
+      } catch {}
+  }
+}
+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 = !fs2.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)
+    };
+    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 && !fs2.existsSync(scopePath)) {
+      try {
+        fs2.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 {
+    fs2.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 = fs2.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(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 {}
+  }
+  const liveCount = bindings.filter((binding) => binding.lifecycleState === "live" && binding.expiresAt > Date.now()).length;
+  if (options.enforceLiveCapacity !== false && liveCount > liveBindingCapacity)
+    return null;
+  return bindings;
+}
+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)
+    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)
+      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);
+      return admission.ok ? { ok: true, value: { previous: existing, claimed: existing } } : {
+        ok: false,
+        code: admission.code,
+        message: admission.message
+      };
+    }
+    return existing ? {
+      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) ? {
+      ok: false,
+      code: "SCOPE_BINDING_EXPIRED",
+      message: "No live pending generation remains for this Task dispatch."
+    } : {
+      ok: false,
+      code: "SCOPE_NOT_DECLARED",
+      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.");
+      }
+    }
+    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()) {
+        fs2.writeFileSync(claimPath, "");
+        receipt = null;
+      }
+    }
+    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 {
+          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 } } : {
+        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;
+    }
+    const admission = registerScopeBinding(persisted.value);
+    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 {
+      ok: true,
+      value: { previous: predecessor, claimed: persisted.value }
+    };
+  } 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"}`);
+  }
+}
+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;
+  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}`);
+      }
+    }
+    const admission = registerScopeBinding(persisted.value);
+    if (!admission.ok) {
+      await tombstoneScopeBinding(input.directory, persisted.value, "revoked");
+      return {
+        ok: false,
+        code: admission.code,
+        message: admission.message
+      };
+    }
+    return { ok: true, value: persisted.value };
+  } catch (error) {
+    return persistenceFailure(`Declaration transaction failed: ${error instanceof Error ? error.message : "unknown I/O error"}`);
+  } finally {
+    if (release)
+      try {
+        await release();
+      } catch {}
+  }
+}
+function scheduleScopeBindingMaintenance(directory) {
+  const key = normalizePathForComparison(directory);
+  if (maintenanceJobs.has(key))
+    return;
+  while (maintenanceJobs.size >= MAX_MAINTENANCE_JOBS) {
+    const oldest = maintenanceJobs.keys().next().value;
+    if (!oldest)
+      break;
+    maintenanceJobs.delete(oldest);
+  }
+  const job = Promise.resolve().then(() => pruneScopeBindingTombstones(directory)).then(() => {
+    return;
+  }).catch(() => {
+    return;
+  }).finally(() => maintenanceJobs.delete(key));
+  maintenanceJobs.set(key, job);
+}
+async function flushScopeBindingMaintenance(directory) {
+  const key = directory ? normalizePathForComparison(directory) : undefined;
+  const job = key ? maintenanceJobs.get(key) : undefined;
+  await Promise.all(job ? [job] : [...maintenanceJobs.values()]);
+}
+async function pruneScopeBindingTombstones(directory) {
+  const lockPath = path2.join(getScopesDir(directory), "maintenance.lock-target");
+  if (!await ensureLockTarget(lockPath))
+    return persistenceFailure("Could not prepare scope maintenance lock.");
+  let release;
+  try {
+    release = await import_proper_lockfile.default.lock(lockPath, {
+      stale: LOCK_STALE_MS,
+      retries: { retries: 3, minTimeout: 50, maxTimeout: 200 },
+      realpath: false
+    });
+    let all = readAllExactBindings(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 {
+          fs2.unlinkSync(getRetirementIntentPath(filePath));
+        } catch {}
+    }
+    all = readAllExactBindings(directory, {
+      enforceLiveCapacity: false,
+      maintenanceScan: true
+    });
+    if (!all)
+      return persistenceFailure("The durable binding set changed during maintenance reconciliation.");
+    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);
+    let removed = 0;
+    for (const binding of removable) {
+      const filePath = resolveSafeScopeFileForUnlink(directory, getBindingFilePath(directory, binding));
+      if (!filePath)
+        continue;
+      const exactLockPath = getGenerationLockPath(filePath);
+      if (!await ensureLockTarget(exactLockPath))
+        continue;
+      let releaseExact;
+      let removedExact = false;
+      try {
+        releaseExact = await import_proper_lockfile.default.lock(exactLockPath, {
+          stale: LOCK_STALE_MS,
+          retries: { retries: 0 },
+          realpath: false
+        });
+        const latestRaw = readBoundedFile(filePath);
+        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;
+        fs2.unlinkSync(filePath);
+        removedExact = true;
+        removed++;
+      } catch {} finally {
+        if (releaseExact)
+          try {
+            await releaseExact();
+          } catch {}
+      }
+      if (removedExact && !fs2.existsSync(filePath)) {
+        try {
+          fs2.unlinkSync(exactLockPath);
+        } catch {}
+        try {
+          fs2.unlinkSync(getRetirementIntentPath(filePath));
+        } catch {}
+      }
+    }
+    let receiptNames = [];
+    try {
+      receiptNames = fs2.readdirSync(getScopesDir(directory)).filter((name) => /^claim-[a-f0-9]{40}\.json$/i.test(name)).slice(0, MAX_BINDING_FILES_TO_SCAN);
+    } catch {}
+    for (const name of receiptNames) {
+      const receiptPath = path2.join(getScopesDir(directory), name);
+      let releaseReceipt;
+      try {
+        releaseReceipt = await import_proper_lockfile.default.lock(receiptPath, {
+          stale: LOCK_STALE_MS,
+          retries: { retries: 0 },
+          realpath: false
+        });
+        const raw = readBoundedFile(receiptPath);
+        if (!raw)
+          continue;
+        let receipt = null;
+        try {
+          receipt = JSON.parse(raw);
+        } catch {}
+        const winner = receipt ? all.find((binding) => binding.generationId === receipt?.winnerGenerationId) : undefined;
+        const old = Date.now() - fs2.statSync(receiptPath).mtimeMs > MAX_TOMBSTONE_AGE_MS;
+        if (old || Boolean(winner && (winner.lifecycleState !== "live" || winner.expiresAt <= Date.now()))) {
+          fs2.unlinkSync(receiptPath);
+          removed++;
+        }
+      } catch {} finally {
+        if (releaseReceipt)
+          try {
+            await releaseReceipt();
+          } catch {}
+      }
+    }
+    return { ok: true, value: removed };
+  } catch (error) {
+    return persistenceFailure(`Scope maintenance failed: ${error instanceof Error ? error.message : "unknown I/O error"}`);
+  } finally {
+    if (release)
+      try {
+        await release();
+      } catch {}
+  }
+}
+function readCurrentPlan(directory) {
+  try {
+    const planPath = path2.join(directory, ".swarm", "plan.json");
+    const stat = fs2.statSync(planPath);
+    if (!stat.isFile() || stat.size > MAX_PLAN_BYTES)
+      return null;
+    const parsed = PlanSchema.safeParse(JSON.parse(fs2.readFileSync(planPath, "utf8")));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+function resolveAuthorizedScopeBindingForPlan(input) {
+  const resolution = resolveAuthorizedScopeBindingForPlanDetailed(input);
+  return resolution.status === "found" ? resolution.binding : null;
+}
+function resolveAuthorizedScopeBindingForPlanDetailed(input) {
+  const durable = resolveScopeBindingFromDisk({
+    directory: input.directory,
+    taskId: input.taskId,
+    plan: input.plan,
+    ownerSessionId: input.activeSessionId,
+    requireDispatchCorrelation: true,
+    includeExpired: true
+  });
+  if (durable.status === "found") {
+    if (hasScopeBindingDenyOverlay(durable.binding))
+      return {
+        status: "expired",
+        candidates: [durable.binding],
+        totalCandidates: 1
+      };
+    const admission = registerScopeBinding(durable.binding);
+    return admission.ok ? durable : { status: "overloaded" };
+  }
+  if (durable.status !== "not_declared")
+    return durable;
+  return { status: "not_declared" };
+}
+function resolveAuthorizedScopeBinding(input) {
+  const plan = readCurrentPlan(input.directory);
+  return plan ? resolveAuthorizedScopeBindingForPlan({ ...input, plan }) : null;
+}
+function resolveAuthorizedScopeBindingDetailed(input) {
+  const plan = readCurrentPlan(input.directory);
+  return plan ? resolveAuthorizedScopeBindingForPlanDetailed({ ...input, plan }) : { status: "not_declared" };
+}
+function resolveAuthorizedScopeBindingForSession(input) {
+  const resolution = resolveAuthorizedScopeBindingForSessionDetailed(input);
+  return resolution.status === "found" ? resolution.binding : null;
+}
+function resolveAuthorizedScopeBindingForSessionDetailed(input) {
+  const plan = readCurrentPlan(input.directory);
+  if (!plan)
+    return { status: "not_declared" };
+  const matches = [];
+  const expired = [];
+  let expiredTotal = 0;
+  for (const task of plan.phases.flatMap((phase) => phase.tasks)) {
+    const resolution = resolveAuthorizedScopeBindingForPlanDetailed({
+      directory: input.directory,
+      plan,
+      taskId: task.id,
+      activeSessionId: input.activeSessionId
+    });
+    if (resolution.status === "overloaded")
+      return resolution;
+    if (resolution.status === "ambiguous")
+      return resolution;
+    if (resolution.status === "found")
+      matches.push(resolution.binding);
+    if (resolution.status === "expired") {
+      expired.push(...resolution.candidates);
+      expiredTotal += resolution.totalCandidates;
+    }
+    if (matches.length > 1)
+      return {
+        status: "ambiguous",
+        candidates: matches.slice(0, 8),
+        totalCandidates: matches.length
+      };
+  }
+  if (matches[0])
+    return { status: "found", binding: matches[0] };
+  return expired.length > 0 ? {
+    status: "expired",
+    candidates: expired.slice(0, 8),
+    totalCandidates: expiredTotal
+  } : { status: "not_declared" };
+}
+function readPrFeedbackBindingFile(directory, filePath, activeSessionId, taskId) {
+  try {
+    const leaf = fs2.lstatSync(filePath);
+    if (!leaf.isFile() || leaf.isSymbolicLink())
+      return null;
+    if (normalizePathForComparison(fs2.realpathSync(filePath)) !== normalizePathForComparison(filePath))
+      return null;
+  } catch {
+    return null;
+  }
+  const nofollow = fs2.constants.O_NOFOLLOW ?? 0;
+  let fd;
+  try {
+    fd = fs2.openSync(filePath, fs2.constants.O_RDONLY | nofollow);
+  } catch {
+    return null;
+  }
+  let raw = "";
+  try {
+    const stat = fs2.fstatSync(fd);
+    if (!stat.isFile() || stat.size > MAX_SCOPE_BYTES)
+      return null;
+    const buffer = Buffer.alloc(stat.size);
+    fs2.readSync(fd, buffer, 0, stat.size, 0);
+    raw = buffer.toString("utf8");
+  } catch {
+    return null;
+  } finally {
+    try {
+      fs2.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))
+    return null;
+  let candidates;
+  if (input.taskId) {
+    if (!isSafeTaskId(input.taskId))
+      return null;
+    try {
+      const names = fs2.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 = fs2.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);
+  if (matches.length !== 1)
+    return null;
+  const admission = registerScopeBinding(matches[0]);
+  return admission.ok ? matches[0] : null;
+}
+async function atomicWrite(targetPath, content) {
+  const tempPath = `${targetPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
+  try {
+    await bunWrite(tempPath, content);
+    fs2.renameSync(tempPath, targetPath);
+  } finally {
+    try {
+      fs2.unlinkSync(tempPath);
+    } catch {}
+  }
+}
+function atomicWriteSync(targetPath, content) {
+  const tempPath = `${targetPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
+  try {
+    fs2.writeFileSync(tempPath, content, { flag: "wx" });
+    fs2.renameSync(tempPath, targetPath);
+  } finally {
+    try {
+      fs2.unlinkSync(tempPath);
+    } catch {}
+  }
+}
+var _scopePersistenceInternals = {
+  get liveBindingCapacity() {
+    return liveBindingCapacity;
+  },
+  set liveBindingCapacity(value) {
+    liveBindingCapacity = Math.max(1, Math.floor(value));
+  },
+  get bindingFileScanCapacity() {
+    return bindingFileScanCapacity;
+  },
+  set bindingFileScanCapacity(value) {
+    bindingFileScanCapacity = Math.max(1, Math.floor(value));
+  },
+  get maintenanceFileScanCapacity() {
+    return maintenanceFileScanCapacity;
+  },
+  set maintenanceFileScanCapacity(value) {
+    maintenanceFileScanCapacity = Math.max(1, Math.floor(value));
+  }
+};
+function readScopeFromDisk(directory, taskId) {
+  if (!isSafeTaskId(taskId))
+    return null;
+  const scopesDir = getScopesDir(directory);
+  if (!isScopesDirSafe(directory, scopesDir))
+    return null;
+  const scopePath = getScopeFilePath(directory, taskId);
+  const nofollow = fs2.constants.O_NOFOLLOW ?? 0;
+  let fd;
+  try {
+    fd = fs2.openSync(scopePath, fs2.constants.O_RDONLY | nofollow);
+  } catch {
+    return null;
+  }
+  let raw;
+  try {
+    const stat = fs2.fstatSync(fd);
+    if (!stat.isFile())
+      return null;
+    if (stat.size > MAX_SCOPE_BYTES)
+      return null;
+    const buf = Buffer.alloc(stat.size);
+    fs2.readSync(fd, buf, 0, stat.size, 0);
+    raw = buf.toString("utf-8");
+  } catch {
+    return null;
+  } finally {
+    try {
+      fs2.closeSync(fd);
+    } catch {}
+  }
+  if (!raw.trim())
+    return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (parsed.version !== SCOPE_SCHEMA_VERSION)
+    return null;
+  if (parsed.taskId !== taskId)
+    return null;
+  const now = Date.now();
+  if (typeof parsed.declaredAt !== "number" || parsed.declaredAt > now) {
+    return null;
+  }
+  if (typeof parsed.expiresAt !== "number" || now >= parsed.expiresAt) {
+    return null;
+  }
+  if (!Array.isArray(parsed.files))
+    return null;
+  if (parsed.files.length > MAX_FILES_PER_SCOPE)
+    return null;
+  const files = parsed.files.filter((f) => typeof f === "string");
+  return files.length > 0 ? files : null;
+}
+function readPlanScope(directory, taskId) {
+  if (!isSafeTaskId(taskId))
+    return null;
+  try {
+    const planPath = path2.join(directory, ".swarm", "plan.json");
+    const stat = fs2.statSync(planPath);
+    if (!stat.isFile())
+      return null;
+    if (stat.size > MAX_PLAN_BYTES)
+      return null;
+    const raw = fs2.readFileSync(planPath, "utf-8");
+    const plan = JSON.parse(raw);
+    for (const phase of plan.phases ?? []) {
+      for (const task of phase.tasks ?? []) {
+        if (task.id !== taskId)
+          continue;
+        const ft = task.files_touched;
+        if (Array.isArray(ft) && ft.length > 0) {
+          if (ft.length > MAX_FILES_PER_SCOPE)
+            return null;
+          return ft.filter((f) => typeof f === "string");
+        }
+        if (typeof ft === "string" && ft.length > 0)
+          return [ft];
+        return null;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function clearScopeForTask(directory, taskId) {
+  if (!isSafeTaskId(taskId))
+    return;
+  try {
+    fs2.unlinkSync(getScopeFilePath(directory, taskId));
+  } catch {}
+}
+function clearAllScopes(directory) {
+  try {
+    fs2.rmSync(getScopesDir(directory), { recursive: true, force: true });
+  } catch {}
+}
+function resolveScopeWithFallbacks(input) {
+  const { directory, taskId, inMemoryScope, pendingMapScope } = input;
+  if (inMemoryScope && inMemoryScope.length > 0)
+    return inMemoryScope;
+  if (taskId) {
+    const disk = readScopeFromDisk(directory, taskId);
+    if (disk && disk.length > 0)
+      return disk;
+    const plan = readPlanScope(directory, taskId);
+    if (plan && plan.length > 0)
+      return plan;
+  }
+  if (pendingMapScope && pendingMapScope.length > 0)
+    return pendingMapScope;
+  return null;
+}
+
+export { MAX_PENDING_SCOPE_BINDINGS, clearScopeBindings, writeScopeToDisk, writeScopeBindingToDisk, persistAndRegisterScopeBinding, readScopeBindingFromDisk, resolveScopeBindingFromDisk, clearScopeBindingFromDisk, tombstoneScopeBinding, refreshScopeBindingLease, claimScopeBindingForChildDurably, replaceExistingScopeDeclaration, flushScopeBindingMaintenance, pruneScopeBindingTombstones, resolveAuthorizedScopeBinding, resolveAuthorizedScopeBindingDetailed, resolveAuthorizedScopeBindingForSession, resolveAuthorizedScopeBindingForSessionDetailed, resolveAuthorizedPrFeedbackScopeBindingFromDisk, _scopePersistenceInternals, readScopeFromDisk, readPlanScope, clearScopeForTask, clearAllScopes, resolveScopeWithFallbacks };