@cleocode/core 2026.8.1 → 2026.8.2

package/dist/docs/export-document.js

@@ -15670,6 +15670,18 @@ var init_service_provider = __esm({
   }
 });
 
+// packages/contracts/src/caamp-markers.ts
+var H, damagedMarkerSource, CAAMP_DAMAGED_START_PATTERN_SOURCE, CAAMP_DAMAGED_END_PATTERN_SOURCE;
+var init_caamp_markers = __esm({
+  "packages/contracts/src/caamp-markers.ts"() {
+    "use strict";
+    H = "[ \\t\\r]";
+    damagedMarkerSource = (keyword) => `^${H}*[<!-]{1,4}${H}*CAAMP${H}*:${H}*${keyword}${H}*[->]{1,3}${H}*$`;
+    CAAMP_DAMAGED_START_PATTERN_SOURCE = damagedMarkerSource("START");
+    CAAMP_DAMAGED_END_PATTERN_SOURCE = damagedMarkerSource("END");
+  }
+});
+
 // packages/contracts/src/index.ts
 var init_src = __esm({
   "packages/contracts/src/index.ts"() {
@@ -15737,6 +15749,7 @@ var init_src = __esm({
     init_validator();
     init_service_provider();
     init_workgraph();
+    init_caamp_markers();
   }
 });
 
@@ -22852,7 +22865,7 @@ async function withWriteRetry(fn, opts = {}) {
   throw contentionErr;
 }
 function sleep(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve8) => setTimeout(resolve8, ms));
 }
 var DEFAULT_MAX_ATTEMPTS, DEFAULT_BASE_DELAY_MS, DEFAULT_JITTER_MS;
 var init_with_retry = __esm({
@@ -23673,7 +23686,7 @@ function resolveDbIdentity(db) {
   return identity;
 }
 function sleepAsync(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, Math.max(0, Math.round(ms))));
+  return new Promise((resolve8) => setTimeout(resolve8, Math.max(0, Math.round(ms))));
 }
 function isPidAlive(pid) {
   try {
@@ -24491,7 +24504,7 @@ async function sendResourceRelease(socketPath, cls, holderId) {
   return { unavailable: true, reason: `unexpected response kind: ${result.kind}` };
 }
 function sendLeaseRequest(socketPath, request, expectedKind) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const id = `ra-${process.pid}-${request.kind}`;
     const envelope = LeaseIpcRequestEnvelopeSchema.parse({
       protocol_version: LEASE_IPC_PROTOCOL_VERSION,
@@ -24509,7 +24522,7 @@ function sendLeaseRequest(socketPath, request, expectedKind) {
       settled = true;
       socket.removeAllListeners();
       socket.destroy();
-      resolve7(value);
+      resolve8(value);
     };
     const degrade = (reason) => done({ unavailable: true, reason });
     socket.setTimeout(REQUEST_TIMEOUT_MS);
@@ -28062,8 +28075,8 @@ async function openDualScopeDbAtPath(scope, dbPath, exodusCwd, options) {
   }
   let initResolve = null;
   let initReject = null;
-  const initPromise = new Promise((resolve7, reject) => {
-    initResolve = resolve7;
+  const initPromise = new Promise((resolve8, reject) => {
+    initResolve = resolve8;
     initReject = reject;
   });
   _cache.set(key, {
@@ -28316,24 +28329,35 @@ var init_dual_scope_db = __esm({
       async openProject(dbPath, options) {
         const normalized = resolve3(dbPath);
         if (options?.dedicated) {
-          const handle = await openDualScopeDbAtPath("project", normalized, void 0, {
+          const handle = await openDualScopeDbAtPath("project", normalized, options?.exodusCwd, {
             dedicated: true
           });
           return this.buildStore("project", handle, 0);
         }
-        return this.openEntry("project", normalized);
+        return this.openEntry("project", normalized, 0, options?.exodusCwd);
       }
       /** @inheritdoc */
       async openGlobal(options) {
         const dbPath = resolveDualScopeDbPath("global");
         const normalized = resolve3(dbPath);
         if (options?.dedicated) {
-          const handle = await openDualScopeDbAtPath("global", normalized, void 0, {
+          const handle = await openDualScopeDbAtPath("global", normalized, options?.exodusCwd, {
+            dedicated: true
+          });
+          return this.buildStore("global", handle, 0);
+        }
+        return this.openEntry("global", normalized, 0, options?.exodusCwd);
+      }
+      /** @inheritdoc */
+      async openGlobalAt(dbPath, options) {
+        const normalized = resolve3(dbPath);
+        if (options?.dedicated) {
+          const handle = await openDualScopeDbAtPath("global", normalized, options?.exodusCwd, {
             dedicated: true
           });
           return this.buildStore("global", handle, 0);
         }
-        return this.openEntry("global", normalized);
+        return this.openEntry("global", normalized, 0, options?.exodusCwd);
       }
       /** @inheritdoc */
       closeProject(dbPath) {
@@ -28359,7 +28383,7 @@ var init_dual_scope_db = __esm({
        *   retry calls this with `depth + 1`. A second dead handle at depth 1
        *   throws {@link LivenessExhaustedError} instead of recursing further.
        */
-      async openEntry(scope, dbPath, depth = 0) {
+      async openEntry(scope, dbPath, depth = 0, exodusCwd) {
         const key = cacheKey(scope, dbPath);
         const existing = this._registry.get(key);
         if (existing) {
@@ -28374,8 +28398,8 @@ var init_dual_scope_db = __esm({
         const entryId = ++this._nextId;
         let initResolve;
         let initReject;
-        const initPromise = new Promise((resolve7, reject) => {
-          initResolve = resolve7;
+        const initPromise = new Promise((resolve8, reject) => {
+          initResolve = resolve8;
           initReject = reject;
         });
         this._registry.set(key, { id: entryId, store: null, initPromise });
@@ -28386,7 +28410,7 @@ var init_dual_scope_db = __esm({
           }
         });
         try {
-          const dualHandle = scope === "project" ? await this.openDualScopeFn("project", dbPath) : await this.openDualScopeFn("global", dbPath);
+          const dualHandle = scope === "project" ? await this.openDualScopeFn("project", dbPath, exodusCwd) : await this.openDualScopeFn("global", dbPath, exodusCwd);
           const current = this._registry.get(key);
           if (!current || current.id !== entryId) {
             throw new EntryCancelledError(scope, dbPath);
@@ -28397,7 +28421,7 @@ var init_dual_scope_db = __esm({
             if (depth >= 1) {
               throw new LivenessExhaustedError(scope, dbPath);
             }
-            const retryStore = await this.openEntry(scope, dbPath, depth + 1);
+            const retryStore = await this.openEntry(scope, dbPath, depth + 1, exodusCwd);
             initResolve(retryStore);
             return retryStore;
           }
@@ -28493,6 +28517,197 @@ var init_dual_scope_db = __esm({
   }
 });
 
+// packages/core/src/store/ports/domain-binding.ts
+import { resolve as resolve4 } from "node:path";
+function getCleoRuntime() {
+  if (!_runtime) {
+    _runtime = createCleoRuntime();
+  }
+  return _runtime;
+}
+function resetCleoRuntime() {
+  releaseAllDomainBindings();
+  if (_runtime) {
+    try {
+      _runtime.closeAll();
+    } catch {
+    }
+    _runtime = null;
+  }
+}
+function bindingKey(scope, dbPath, domain) {
+  return `${scope}::${dbPath}::${domain}`;
+}
+function nativeOf(store) {
+  const native = store.db.$client;
+  if (!native) {
+    throw new Error(
+      `T12037: CleoRuntime store for ${store.scope}::${store.dbPath} exposed no $client \u2014 cannot bind a domain schema to it.`
+    );
+  }
+  return native;
+}
+function reuseValid(key, store) {
+  const row = _bindings.get(key);
+  if (!row) return void 0;
+  if (row.store !== store || !store.isOpen || !row.native.isOpen) {
+    _bindings.delete(key);
+    return void 0;
+  }
+  return row;
+}
+async function bindAgainst(key, store, establish) {
+  const cached = reuseValid(key, store);
+  if (cached) return cached;
+  const pending = _inflight.get(key);
+  if (pending) {
+    const row = await pending;
+    if (row.store === store && row.native.isOpen) return row;
+    return bindAgainst(key, store, establish);
+  }
+  const native = nativeOf(store);
+  const flight = (async () => {
+    const db = await establish(native, store);
+    const row = { store, native, db };
+    if (store.isOpen && native.isOpen) {
+      _bindings.set(key, row);
+    }
+    return row;
+  })();
+  _inflight.set(key, flight);
+  try {
+    return await flight;
+  } finally {
+    if (_inflight.get(key) === flight) {
+      _inflight.delete(key);
+    }
+  }
+}
+async function bindLive(scope, key, dbPath, openStore, establish) {
+  let lastError;
+  for (let attempt = 0; attempt < MAX_LIVENESS_ATTEMPTS; attempt += 1) {
+    let store;
+    try {
+      store = await openStore();
+    } catch (err) {
+      lastError = err;
+      releaseDomainBindings({ scope, dbPath });
+      if (attempt + 1 >= MAX_LIVENESS_ATTEMPTS) throw err;
+      continue;
+    }
+    try {
+      const row = await bindAgainst(key, store, establish);
+      if (row.store.isOpen && row.native.isOpen) return row;
+    } catch (err) {
+      lastError = err;
+      if (store.isOpen) throw err;
+    }
+    releaseDomainBindings({ scope, dbPath });
+    try {
+      store.close();
+    } catch {
+    }
+  }
+  if (lastError !== void 0) throw lastError;
+  throw new Error(
+    `T12037: could not bind ${key} over a live connection after ${MAX_LIVENESS_ATTEMPTS} attempts \u2014 the consolidated handle was closed each time.`
+  );
+}
+async function bindProjectDomain(domain, cwd, establish) {
+  const dbPath = resolve4(resolveDualScopeDbPath("project", cwd));
+  const row = await bindLive(
+    "project",
+    bindingKey("project", dbPath, domain),
+    dbPath,
+    () => getCleoRuntime().openProject(dbPath, { exodusCwd: cwd }),
+    establish
+  );
+  return row;
+}
+async function bindGlobalDomain(domain, establish, cwd) {
+  const dbPath = resolve4(resolveDualScopeDbPath("global"));
+  const row = await bindLive(
+    "global",
+    bindingKey("global", dbPath, domain),
+    dbPath,
+    () => getCleoRuntime().openGlobal({ exodusCwd: cwd }),
+    establish
+  );
+  return row;
+}
+async function bindGlobalDomainAtPath(domain, dbPath, establish) {
+  const normalized = resolve4(dbPath);
+  const row = await bindLive(
+    "global",
+    bindingKey("global", normalized, domain),
+    normalized,
+    () => getCleoRuntime().openGlobalAt(normalized),
+    establish
+  );
+  return row;
+}
+function peekDomainAtPath(scope, dbPath, domain) {
+  const row = _bindings.get(bindingKey(scope, resolve4(dbPath), domain));
+  if (!row?.native.isOpen) return null;
+  return row;
+}
+function releaseDomainBindings(filter) {
+  if (!filter) {
+    _bindings.clear();
+    return;
+  }
+  const wantPath = filter.dbPath === void 0 ? void 0 : resolve4(filter.dbPath);
+  for (const key of [..._bindings.keys()]) {
+    const sep2 = key.indexOf("::");
+    const lastSep = key.lastIndexOf("::");
+    const scope = key.slice(0, sep2);
+    const dbPath = key.slice(sep2 + 2, lastSep);
+    const domain = key.slice(lastSep + 2);
+    if (filter.scope !== void 0 && scope !== filter.scope) continue;
+    if (wantPath !== void 0 && dbPath !== wantPath) continue;
+    if (filter.domain !== void 0 && domain !== filter.domain) continue;
+    _bindings.delete(key);
+  }
+}
+function releaseAllDomainBindings() {
+  _bindings.clear();
+}
+function boundProjectNative(domain, cwd) {
+  return peekProjectDomain(domain, cwd)?.native ?? null;
+}
+function peekProjectDomain(domain, cwd) {
+  const dbPath = resolve4(resolveDualScopeDbPath("project", cwd));
+  const row = _bindings.get(bindingKey("project", dbPath, domain));
+  if (row?.native.isOpen) return row;
+  if (cwd !== void 0) return null;
+  const suffix = `::${domain}`;
+  let sole;
+  for (const [key, candidate] of _bindings) {
+    if (!key.startsWith("project::") || !key.endsWith(suffix)) continue;
+    if (!candidate.native.isOpen) continue;
+    if (sole) return null;
+    sole = candidate;
+  }
+  return sole ?? null;
+}
+function peekGlobalDomain(domain) {
+  const dbPath = resolve4(resolveDualScopeDbPath("global"));
+  const row = _bindings.get(bindingKey("global", dbPath, domain));
+  if (!row || !row.native.isOpen) return null;
+  return row;
+}
+var _runtime, _bindings, _inflight, MAX_LIVENESS_ATTEMPTS;
+var init_domain_binding = __esm({
+  "packages/core/src/store/ports/domain-binding.ts"() {
+    "use strict";
+    init_dual_scope_db();
+    _runtime = null;
+    _bindings = /* @__PURE__ */ new Map();
+    _inflight = /* @__PURE__ */ new Map();
+    MAX_LIVENESS_ATTEMPTS = 2;
+  }
+});
+
 // packages/core/src/store/schema/nexus-schema.ts
 var nexus_schema_exports = {};
 __export(nexus_schema_exports, {
@@ -29001,6 +29216,7 @@ var nexus_sqlite_exports = {};
 __export(nexus_sqlite_exports, {
   NEXUS_SCHEMA_VERSION: () => NEXUS_SCHEMA_VERSION,
   _resetNestedNexusWarningGate: () => _resetNestedNexusWarningGate,
+  bindNexusDomain: () => bindNexusDomain,
   closeNexusDb: () => closeNexusDb,
   detectAndWarnOnNestedNexus: () => detectAndWarnOnNestedNexus,
   getNestedNexusSentinelPath: () => getNestedNexusSentinelPath,
@@ -29209,13 +29425,13 @@ function ensureNexusRelationWeights(nativeDb) {
     nativeDb.exec(`PRAGMA foreign_keys=${fkWasOn ? "ON" : "OFF"}`);
   }
 }
-function runNexusMigrations(nativeDb, db) {
+function runNexusMigrations(nativeDb, db, dbPath) {
   const migrationsFolder = resolveNexusMigrationsFolder();
-  if (tableExists4(nativeDb, "nexus_nodes") && _nexusDbPath) {
-    const backupPath = _nexusDbPath.replace(/\.db$/, "-pre-cleo.db.bak");
+  if (tableExists4(nativeDb, "nexus_nodes")) {
+    const backupPath = dbPath.replace(/\.db$/, "-pre-cleo.db.bak");
     if (!existsSync16(backupPath)) {
       try {
-        copyFileSync4(_nexusDbPath, backupPath);
+        copyFileSync4(dbPath, backupPath);
       } catch {
       }
     }
@@ -29257,75 +29473,45 @@ function runNexusMigrations(nativeDb, db) {
   ensureNexusFts5(nativeDb);
 }
 async function getNexusDb() {
-  const requestedPath = getNexusDbPath();
+  return (await bindNexusDomain()).db.drizzle;
+}
+async function bindNexusDomain() {
   const requestedRegistryPath = getNexusRegistryDbPath();
-  if (_nexusDb && _nexusDbPath !== requestedPath) {
-    resetNexusDbState();
+  const bound = peekProjectDomain("nexus");
+  if (bound && bound.db.registryPath !== requestedRegistryPath) {
+    releaseDomainBindings({ scope: "project", domain: "nexus" });
   }
-  if (_nexusDb && _nexusRegistryPath !== requestedRegistryPath) {
-    resetNexusDbState();
-  }
-  if (_nexusDb && (_nexusNativeDb === null || !_nexusNativeDb.isOpen)) {
-    resetNexusDbState();
-  }
-  if (_nexusDb) {
-    if (_nexusNativeDb) {
-      try {
-        ensureGlobalRegistryAttached(_nexusNativeDb);
-      } catch {
-        resetNexusDbState();
-      }
-    }
-    if (_nexusDb) return _nexusDb;
-  }
-  if (_nexusInitPromise) return _nexusInitPromise;
-  _nexusInitPromise = (async () => {
-    const dbPath = requestedPath;
-    _nexusDbPath = dbPath;
-    _nexusRegistryPath = requestedRegistryPath;
-    detectAndWarnOnNestedNexus();
-    await openDualScopeDb("global");
-    const dualHandle = await openDualScopeDb("project");
-    const nativeDb = dualHandle.db.$client ?? null;
-    if (!nativeDb) {
-      throw new Error(
-        "T11648: openDualScopeDb returned a handle without $client \u2014 cannot extract DatabaseSync for the nexus-schema drizzle wrapping."
-      );
-    }
-    _nexusNativeDb = nativeDb;
+  detectAndWarnOnNestedNexus();
+  await openDualScopeDb("global");
+  const binding = await bindProjectDomain("nexus", void 0, (nativeDb, store) => {
     ensureGlobalRegistryAttached(nativeDb);
     const db = drizzle({ client: nativeDb });
-    runNexusMigrations(nativeDb, db);
+    runNexusMigrations(nativeDb, db, store.dbPath);
     nativeDb.prepare(
       `INSERT OR IGNORE INTO nexus_schema_meta (key, value) VALUES ('schemaVersion', '${NEXUS_SCHEMA_VERSION}')`
     ).run();
-    _nexusDb = db;
-    return db;
-  })();
+    return { drizzle: db, registryPath: requestedRegistryPath };
+  });
   try {
-    return await _nexusInitPromise;
-  } finally {
-    _nexusInitPromise = null;
+    ensureGlobalRegistryAttached(binding.native);
+  } catch {
+    releaseDomainBindings({ scope: "project", domain: "nexus" });
+    throw new Error(
+      "T12039: nexus binding lost its GLOBAL registry ATTACH and could not re-attach."
+    );
   }
+  return binding;
 }
 function closeNexusDb() {
-  _nexusNativeDb = null;
-  _nexusDb = null;
-  _nexusDbPath = null;
-  _nexusRegistryPath = null;
-  _nexusInitPromise = null;
+  releaseDomainBindings({ scope: "project", domain: "nexus" });
 }
 function resetNexusDbState() {
-  _nexusNativeDb = null;
-  _nexusDb = null;
-  _nexusDbPath = null;
-  _nexusRegistryPath = null;
-  _nexusInitPromise = null;
+  releaseDomainBindings({ scope: "project", domain: "nexus" });
 }
 function getNexusNativeDb() {
-  return _nexusNativeDb;
+  return boundProjectNative("nexus");
 }
-var NEXUS_SCHEMA_VERSION, _nexusDb, _nexusNativeDb, _nexusDbPath, _nexusRegistryPath, _nexusInitPromise, NEXUS_GLOBAL_ATTACH_ALIAS, NESTED_NEXUS_SENTINEL, _warnedNestedPaths;
+var NEXUS_SCHEMA_VERSION, NEXUS_GLOBAL_ATTACH_ALIAS, NESTED_NEXUS_SENTINEL, _warnedNestedPaths;
 var init_nexus_sqlite = __esm({
   "packages/core/src/store/nexus-sqlite.ts"() {
     "use strict";
@@ -29334,15 +29520,11 @@ var init_nexus_sqlite = __esm({
     init_paths();
     init_dual_scope_db();
     init_migration_manager();
+    init_domain_binding();
     init_resolve_migrations_folder();
     init_nexus_schema();
     init_with_retry();
     NEXUS_SCHEMA_VERSION = "1.0.0";
-    _nexusDb = null;
-    _nexusNativeDb = null;
-    _nexusDbPath = null;
-    _nexusRegistryPath = null;
-    _nexusInitPromise = null;
     NEXUS_GLOBAL_ATTACH_ALIAS = "nexus_global";
     NESTED_NEXUS_SENTINEL = "nexus.db";
     _warnedNestedPaths = /* @__PURE__ */ new Set();
@@ -29354,7 +29536,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { existsSync as existsSync17, readFileSync as readFileSync5, statSync as statSync6 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
 import { homedir } from "node:os";
-import { basename as basename4, dirname as dirname7, join as join17, resolve as resolve4 } from "node:path";
+import { basename as basename4, dirname as dirname7, join as join17, resolve as resolve5 } from "node:path";
 import {
   computeCanonicalProjectId as _computeCanonicalProjectId,
   getCanonicalTemplatesTildePath as _getCanonicalTemplatesTildePath,
@@ -29421,24 +29603,24 @@ function getCleoDirAbsolute(cwd, opts) {
     try {
       const projectRoot = getProjectRoot(cwd);
       const canonical = _resolveCanonicalCleoDir(project.projectId);
-      if (canonical !== null && canonical === resolve4(projectRoot, cleoDir)) {
+      if (canonical !== null && canonical === resolve5(projectRoot, cleoDir)) {
         return canonical;
       }
-      return resolve4(projectRoot, cleoDir);
+      return resolve5(projectRoot, cleoDir);
     } catch {
-      return resolve4(project.projectRoot, cleoDir);
+      return resolve5(project.projectRoot, cleoDir);
     }
   }
   try {
-    return resolve4(getProjectRoot(cwd), cleoDir);
+    return resolve5(getProjectRoot(cwd), cleoDir);
   } catch (err) {
     if (opts?.bootstrap) {
-      return resolve4(cwd ?? process.cwd(), cleoDir);
+      return resolve5(cwd ?? process.cwd(), cleoDir);
     }
     if (_cwdHasGitAncestor(cwd)) {
       throw err;
     }
-    return resolve4(cwd ?? process.cwd(), cleoDir);
+    return resolve5(cwd ?? process.cwd(), cleoDir);
   }
 }
 function _resolveProjectByCwdFromNexus(cwd) {
@@ -29446,7 +29628,7 @@ function _resolveProjectByCwdFromNexus(cwd) {
     const cleoHome = getCleoHome();
     const globalDbPath = join17(cleoHome, "cleo.db");
     if (!existsSync17(globalDbPath)) return null;
-    const start = resolve4(cwd ?? process.cwd());
+    const start = resolve5(cwd ?? process.cwd());
     let current = start;
     const DatabaseSync3 = _getDatabaseSyncCtor();
     const db = new DatabaseSync3(globalDbPath, { readOnly: true });
@@ -29479,7 +29661,7 @@ function _cleoDirEnvOverride() {
 }
 function _findCleoDirRoot(cwd) {
   const homeRoot = homedir();
-  let current = resolve4(cwd ?? process.cwd());
+  let current = resolve5(cwd ?? process.cwd());
   while (true) {
     const isDangerousRoot = current === homeRoot || current === "/" || current === "";
     if (!isDangerousRoot) {
@@ -29509,7 +29691,7 @@ function resolveCleoDir(cwd) {
   if (root !== null) {
     return join17(root, ".cleo");
   }
-  const start = resolve4(cwd ?? process.cwd());
+  const start = resolve5(cwd ?? process.cwd());
   let current = start;
   while (true) {
     const mainRepo = _resolveMainRepoFromGitlink(current);
@@ -29545,15 +29727,15 @@ function _resolveCleoDir(cwd) {
   const project = _pathsResolveProjectByCwd(cwd);
   if (project !== null) {
     try {
-      return resolve4(getProjectRoot(cwd), cleoDir);
+      return resolve5(getProjectRoot(cwd), cleoDir);
     } catch {
-      return resolve4(project.projectRoot, cleoDir);
+      return resolve5(project.projectRoot, cleoDir);
     }
   }
   return getCleoDirAbsolute(cwd);
 }
 function _cwdHasGitAncestor(cwd) {
-  const start = resolve4(cwd ?? process.cwd());
+  const start = resolve5(cwd ?? process.cwd());
   let current = start;
   while (true) {
     const gitMarker = join17(current, ".git");
@@ -29653,7 +29835,7 @@ function getProjectRoot(cwd) {
     }
     return cleoDirEnv;
   }
-  const start = resolve4(cwd ?? process.cwd());
+  const start = resolve5(cwd ?? process.cwd());
   let current = start;
   const mainRepoFromStart = _resolveMainRepoFromGitlink(start);
   if (mainRepoFromStart !== null) return mainRepoFromStart;
@@ -29746,7 +29928,7 @@ async function registerProjectOnEncounter(projectRoot, infoProjectId) {
     const db = await getNexusDb2();
     const existingRows = await db.select().from(projectRegistry2).where(eq11(projectRegistry2.projectId, immutableId)).limit(1);
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const resolvedPath = resolve4(projectRoot);
+    const resolvedPath = resolve5(projectRoot);
     const projectName = _readProjectNameFromInfo(resolvedPath) || basename4(projectRoot) || "unnamed";
     if (existingRows.length > 0) {
       const existingPath = existingRows[0].projectPath;
@@ -32315,6 +32497,7 @@ var init_brain_embedding = __esm({
 var memory_sqlite_exports = {};
 __export(memory_sqlite_exports, {
   BRAIN_SCHEMA_VERSION: () => BRAIN_SCHEMA_VERSION,
+  bindBrainDomain: () => bindBrainDomain,
   brainSchema: () => memory_schema_exports,
   closeBrainDb: () => closeBrainDb,
   getBrainDb: () => getBrainDb,
@@ -32344,7 +32527,7 @@ function brainTablesAreConsolidatedShape(nativeDb) {
   const createdAt = cols.find((c) => c.name === "created_at");
   return createdAt !== void 0 && createdAt.type.toUpperCase() !== "INTEGER";
 }
-function establishLegacyBrainSchema(nativeDb, db) {
+function establishLegacyBrainSchema(nativeDb, db, dbPath) {
   const log12 = getLogger("brain-schema");
   if (brainTablesAreConsolidatedShape(nativeDb)) {
     const fkRow = nativeDb.prepare("PRAGMA foreign_keys").get();
@@ -32381,8 +32564,8 @@ function establishLegacyBrainSchema(nativeDb, db) {
     );
     return;
   }
-  if (tableExists(nativeDb, "brain_decisions") && _dbPath) {
-    createSafetyBackup(_dbPath);
+  if (tableExists(nativeDb, "brain_decisions")) {
+    createSafetyBackup(dbPath);
   }
   reconcileJournal(nativeDb, migrationsFolder, "brain_decisions", "brain");
   migrateWithRetry(db, migrationsFolder, nativeDb, "brain_decisions", "brain");
@@ -32401,8 +32584,8 @@ function initializeBrainVec(nativeDb) {
     "CREATE VIRTUAL TABLE IF NOT EXISTS brain_embeddings USING vec0(id TEXT PRIMARY KEY, embedding FLOAT[384])"
   ).run();
 }
-function isBrainVecLoaded() {
-  return _vecLoaded;
+function isBrainVecLoaded(cwd) {
+  return peekProjectDomain("brain", cwd)?.db.vecLoaded ?? false;
 }
 async function initEmbeddingProvider(cwd) {
   try {
@@ -32416,92 +32599,52 @@ async function initEmbeddingProvider(cwd) {
   }
 }
 async function getBrainDb(cwd) {
-  const requestedPath = getBrainDbPath(cwd);
+  return (await bindBrainDomain(cwd)).db.drizzle;
+}
+async function bindBrainDomain(cwd) {
   const { assertTestEnv: assertTestEnv2 } = await Promise.resolve().then(() => (init_data_accessor(), data_accessor_exports));
-  assertTestEnv2(requestedPath);
-  if (_db && _dbPath !== requestedPath) {
-    resetBrainDbState();
-  }
-  if (_db && (_nativeDb === null || !_nativeDb.isOpen)) {
-    resetBrainDbState();
-  }
-  if (_db) return _db;
-  if (_initPromise) return _initPromise;
-  _initPromise = (async () => {
-    let nativeDb = null;
-    for (let attempt = 0; attempt < 2; attempt += 1) {
-      const dualHandle = await openDualScopeDb("project", cwd);
-      nativeDb = dualHandle.db.$client ?? null;
-      if (!nativeDb) {
-        throw new Error(
-          "E6-L2: openDualScopeDb returned a handle without $client \u2014 cannot extract DatabaseSync for legacy brain-schema wrapping."
-        );
-      }
-      if (nativeDb.isOpen) break;
-    }
-    if (!nativeDb?.isOpen) {
-      throw new Error("E6-L2: openDualScopeDb repeatedly returned a closed DatabaseSync handle.");
-    }
-    _nativeDb = nativeDb;
-    _dbPath = requestedPath;
-    _vecLoaded = loadBrainVecExtension(nativeDb);
-    const db = _getDrizzle()({ client: nativeDb });
-    establishLegacyBrainSchema(nativeDb, db);
-    if (_vecLoaded) {
+  assertTestEnv2(getBrainDbPath(cwd));
+  return bindProjectDomain("brain", cwd, (nativeDb, store) => {
+    const vecLoaded = loadBrainVecExtension(nativeDb);
+    const drizzle2 = _getDrizzle()({ client: nativeDb });
+    establishLegacyBrainSchema(nativeDb, drizzle2, store.dbPath);
+    if (vecLoaded) {
       initializeBrainVec(nativeDb);
     }
     nativeDb.prepare(
       `INSERT OR IGNORE INTO brain_schema_meta (key, value) VALUES ('schemaVersion', '${BRAIN_SCHEMA_VERSION}')`
     ).run();
-    _db = db;
-    if (_vecLoaded) {
+    if (vecLoaded) {
       setImmediate(() => {
         initEmbeddingProvider(cwd).catch(() => {
         });
       });
     }
-    return db;
-  })();
-  try {
-    return await _initPromise;
-  } finally {
-    _initPromise = null;
-  }
+    return { drizzle: drizzle2, vecLoaded };
+  });
 }
 function closeBrainDb() {
-  _nativeDb = null;
-  _db = null;
-  _dbPath = null;
-  _initPromise = null;
-  _vecLoaded = false;
+  releaseDomainBindings({ scope: "project", domain: "brain" });
 }
 function resetBrainDbState() {
-  _nativeDb = null;
-  _db = null;
-  _dbPath = null;
-  _initPromise = null;
-  _vecLoaded = false;
+  releaseDomainBindings({ scope: "project", domain: "brain" });
 }
-function getBrainNativeDb() {
-  return _nativeDb;
+function getBrainNativeDb(cwd) {
+  return boundProjectNative("brain", cwd);
 }
-var _require3, _drizzle2, BRAIN_SCHEMA_VERSION, _db, _nativeDb, _dbPath, _initPromise, _vecLoaded, CONSOLIDATED_BRAIN_TABLES;
+var _require3, _drizzle2, BRAIN_SCHEMA_VERSION, CONSOLIDATED_BRAIN_TABLES;
 var init_memory_sqlite = __esm({
   "packages/core/src/store/memory-sqlite.ts"() {
     "use strict";
     init_logger2();
     init_dual_scope_db();
     init_migration_manager();
+    init_domain_binding();
     init_resolve_migrations_folder();
     init_memory_schema();
     _require3 = createRequire6(import.meta.url);
     _drizzle2 = null;
     BRAIN_SCHEMA_VERSION = "1.0.0";
-    _db = null;
-    _nativeDb = null;
-    _dbPath = null;
-    _initPromise = null;
-    _vecLoaded = false;
     CONSOLIDATED_BRAIN_TABLES = [
       "brain_attention",
       "brain_backfill_runs",
@@ -36324,41 +36467,41 @@ function runTelemetryMigrations(nativeDb, db) {
 }
 function resetTelemetryDbState() {
   try {
-    _nativeDb2?.close();
+    _nativeDb?.close();
   } catch {
   }
-  _db2 = null;
-  _nativeDb2 = null;
-  _dbPath2 = null;
-  _initPromise2 = null;
+  _db = null;
+  _nativeDb = null;
+  _dbPath = null;
+  _initPromise = null;
 }
 function getTelemetryNativeDb() {
-  return _nativeDb2;
+  return _nativeDb;
 }
 async function getTelemetryDb() {
   const requestedPath = getTelemetryDbPath();
-  if (_db2 && _dbPath2 !== requestedPath) {
+  if (_db && _dbPath !== requestedPath) {
     resetTelemetryDbState();
   }
-  if (_db2) return _db2;
-  if (_initPromise2) return _initPromise2;
-  _initPromise2 = (async () => {
+  if (_db) return _db;
+  if (_initPromise) return _initPromise;
+  _initPromise = (async () => {
     const dbPath = requestedPath;
-    _dbPath2 = dbPath;
+    _dbPath = dbPath;
     mkdirSync5(dirname8(dbPath), { recursive: true });
     const nativeDb = openNativeDatabase(dbPath);
-    _nativeDb2 = nativeDb;
+    _nativeDb = nativeDb;
     const db = drizzle({ client: nativeDb });
     runTelemetryMigrations(nativeDb, db);
     nativeDb.prepare(
       `INSERT OR IGNORE INTO telemetry_schema_meta (key, value) VALUES ('schemaVersion', '${TELEMETRY_SCHEMA_VERSION}')`
     ).run();
-    _db2 = db;
+    _db = db;
     return db;
   })();
-  return _initPromise2;
+  return _initPromise;
 }
-var DB_FILENAME, TELEMETRY_SCHEMA_VERSION, _db2, _nativeDb2, _dbPath2, _initPromise2;
+var DB_FILENAME, TELEMETRY_SCHEMA_VERSION, _db, _nativeDb, _dbPath, _initPromise;
 var init_sqlite2 = __esm({
   "packages/core/src/telemetry/sqlite.ts"() {
     "use strict";
@@ -36369,10 +36512,10 @@ var init_sqlite2 = __esm({
     init_sqlite3();
     DB_FILENAME = "telemetry.db";
     TELEMETRY_SCHEMA_VERSION = "1.0.0";
-    _db2 = null;
-    _nativeDb2 = null;
-    _dbPath2 = null;
-    _initPromise2 = null;
+    _db = null;
+    _nativeDb = null;
+    _dbPath = null;
+    _initPromise = null;
   }
 });
 
@@ -36404,6 +36547,9 @@ function runAgentRegistryMigrations(nativeDb) {
   const db = drizzle({ client: nativeDb });
   migrateSanitized(db, { migrationsFolder });
 }
+function boundAgentRegistryNative() {
+  return peekDomainAtPath("global", getGlobalAgentRegistryDbPath(), AGENT_REGISTRY_DOMAIN)?.native ?? null;
+}
 function readAgentRegistrySchemaVersionSentinel(db) {
   try {
     const row = db.prepare("SELECT value FROM _agent_registry_meta WHERE key = 'schema_version'").get();
@@ -36426,16 +36572,36 @@ function writeAgentRegistrySchemaVersionSentinel(db) {
   } catch {
   }
 }
+function establishAgentRegistrySchema(native) {
+  const hasSchema = (() => {
+    try {
+      return !!native.prepare(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='agent_registry_agents'"
+      ).get();
+    } catch {
+      return false;
+    }
+  })();
+  if (hasSchema && readAgentRegistrySchemaVersionSentinel(native) === GLOBAL_AGENT_REGISTRY_SCHEMA_VERSION) {
+    return false;
+  }
+  runAgentRegistryMigrations(native);
+  writeAgentRegistrySchemaVersionSentinel(native);
+  return true;
+}
 async function ensureGlobalAgentRegistryDb() {
   const dbPath = getGlobalAgentRegistryDbPath();
   const alreadyExists = existsSync19(dbPath);
-  const dualHandle = await openDualScopeDbAtPath("global", dbPath);
-  const nativeDb = dualHandle.db.$client ?? null;
-  if (!nativeDb) {
-    throw new Error(
-      "E6-L5: openDualScopeDb returned a handle without $client \u2014 cannot extract DatabaseSync for the Agent Registry ledger reconcile."
-    );
-  }
+  let created = false;
+  const { native: nativeDb } = await bindGlobalDomainAtPath(
+    AGENT_REGISTRY_DOMAIN,
+    dbPath,
+    (native) => {
+      const applied = establishAgentRegistrySchema(native);
+      created = created || applied;
+      return native;
+    }
+  );
   const hasSchema = (() => {
     try {
       const result = nativeDb.prepare(
@@ -36446,22 +36612,15 @@ async function ensureGlobalAgentRegistryDb() {
       return false;
     }
   })();
-  if (hasSchema && readAgentRegistrySchemaVersionSentinel(nativeDb) === GLOBAL_AGENT_REGISTRY_SCHEMA_VERSION) {
-    _globalAgentRegistryNativeDb = nativeDb;
-    return { action: "exists", path: dbPath };
-  }
-  runAgentRegistryMigrations(nativeDb);
-  writeAgentRegistrySchemaVersionSentinel(nativeDb);
-  _globalAgentRegistryNativeDb = nativeDb;
   return {
     action: alreadyExists && hasSchema ? "exists" : "created",
     path: dbPath
   };
 }
 function getGlobalAgentRegistryNativeDb() {
-  return _globalAgentRegistryNativeDb;
+  return boundAgentRegistryNative();
 }
-var GLOBAL_AGENT_REGISTRY_SCHEMA_VERSION, _globalAgentRegistryNativeDb;
+var GLOBAL_AGENT_REGISTRY_SCHEMA_VERSION, AGENT_REGISTRY_DOMAIN;
 var init_agent_registry_store = __esm({
   "packages/core/src/store/agent-registry-store.ts"() {
     "use strict";
@@ -36469,9 +36628,10 @@ var init_agent_registry_store = __esm({
     init_paths();
     init_dual_scope_db();
     init_migration_manager();
+    init_domain_binding();
     init_resolve_migrations_folder();
     GLOBAL_AGENT_REGISTRY_SCHEMA_VERSION = "2026.4.12";
-    _globalAgentRegistryNativeDb = null;
+    AGENT_REGISTRY_DOMAIN = "agents";
   }
 });
 
@@ -36505,60 +36665,36 @@ function runConduitMigrations(nativeDb) {
 }
 async function ensureConduitDb(projectRoot) {
   const dbPath = getConduitDbPath(projectRoot);
-  if (_conduitNativeDb && (!_conduitNativeDb.isOpen || _conduitDbPath !== dbPath)) {
-    resetConduitDbState();
-  }
-  if (_conduitNativeDb && _conduitDbPath === dbPath) {
-    return { action: "exists", path: dbPath };
-  }
-  if (_initPromise3) return _initPromise3;
-  _initPromise3 = (async () => {
-    const alreadyExists = existsSync20(dbPath);
-    const dualHandle = await openDualScopeDb("project", projectRoot);
-    const nativeDb = dualHandle.db.$client ?? null;
-    if (!nativeDb) {
-      throw new Error(
-        "E6-L3: openDualScopeDb returned a handle without $client \u2014 cannot extract DatabaseSync for legacy conduit-schema wrapping."
-      );
-    }
+  const alreadyExists = peekProjectDomain("conduit", projectRoot) !== null || existsSync20(dbPath);
+  await bindConduitDomain(projectRoot);
+  return { action: alreadyExists ? "exists" : "created", path: dbPath };
+}
+async function bindConduitDomain(projectRoot) {
+  return bindProjectDomain("conduit", projectRoot, (nativeDb) => {
     runConduitMigrations(nativeDb);
     nativeDb.exec(
       `INSERT OR REPLACE INTO _conduit_meta (key, value, updated_at)
        VALUES ('schema_version', '${CONDUIT_SCHEMA_VERSION}', strftime('%s', 'now'))`
     );
-    _conduitNativeDb = nativeDb;
-    _conduitDbPath = dbPath;
-    return { action: alreadyExists ? "exists" : "created", path: dbPath };
-  })();
-  try {
-    return await _initPromise3;
-  } finally {
-    _initPromise3 = null;
-  }
-}
-function getConduitNativeDb() {
-  return _conduitNativeDb;
+    return nativeDb;
+  });
 }
-function resetConduitDbState() {
-  _conduitNativeDb = null;
-  _conduitDbPath = null;
-  _initPromise3 = null;
+function getConduitNativeDb(projectRoot) {
+  return boundProjectNative("conduit", projectRoot);
 }
-var _require4, DatabaseSync2, _drizzle3, CONDUIT_SCHEMA_VERSION, _conduitNativeDb, _conduitDbPath, _initPromise3;
+var _require4, DatabaseSync2, _drizzle3, CONDUIT_SCHEMA_VERSION;
 var init_conduit_sqlite = __esm({
   "packages/core/src/store/conduit-sqlite.ts"() {
     "use strict";
     init_dual_scope_db();
     init_migration_manager();
+    init_domain_binding();
     init_resolve_migrations_folder();
     init_sqlite_pragmas();
     _require4 = createRequire7(import.meta.url);
     ({ DatabaseSync: DatabaseSync2 } = _require4("node:sqlite"));
     _drizzle3 = null;
     CONDUIT_SCHEMA_VERSION = "2026.4.23";
-    _conduitNativeDb = null;
-    _conduitDbPath = null;
-    _initPromise3 = null;
   }
 });
 
@@ -36738,47 +36874,26 @@ function getDefaultSkillsDbPath() {
   return dbPath;
 }
 async function openSkillsDb(options) {
-  if (_skillsDb && !options?.path) return _skillsDb;
-  const requestedPath = options?.path ?? getDefaultSkillsDbPath();
-  if (_skillsDb && _skillsDbPath !== requestedPath) {
-    resetSkillsDbState();
-  }
-  if (_skillsDb && (_skillsNativeDb === null || !_skillsNativeDb.isOpen)) {
-    resetSkillsDbState();
-  }
-  if (_skillsDb) return _skillsDb;
-  if (_skillsInitPromise) return _skillsInitPromise;
-  _skillsInitPromise = (async () => {
-    _skillsDbPath = requestedPath;
-    const dualHandle = options?.path ? await openDualScopeDbAtPath("global", options.path) : await openDualScopeDb("global");
-    const nativeDb = dualHandle.db.$client ?? null;
-    if (!nativeDb) {
-      throw new Error(
-        "E6-L5: openDualScopeDb returned a handle without $client \u2014 cannot extract DatabaseSync for the skills-schema wrapping."
-      );
-    }
-    _skillsNativeDb = nativeDb;
-    const db = drizzle({ client: nativeDb });
-    _skillsDb = db;
-    return db;
-  })();
-  try {
-    return await _skillsInitPromise;
-  } finally {
-    _skillsInitPromise = null;
+  return (await bindSkillsDomain(options)).db;
+}
+function resolveSkillsBindPath(options) {
+  if (options?.path) {
+    _skillsOverridePath = options.path;
+    return { path: options.path, canonical: false };
   }
+  if (_skillsOverridePath) return { path: _skillsOverridePath, canonical: false };
+  return { path: getDefaultSkillsDbPath(), canonical: true };
 }
-function resetSkillsDbState() {
-  _skillsNativeDb = null;
-  _skillsDb = null;
-  _skillsDbPath = null;
-  _skillsInitPromise = null;
-  _resetDualScopeDbCache("global");
+async function bindSkillsDomain(options) {
+  const { path: path2, canonical } = resolveSkillsBindPath(options);
+  const establish = (nativeDb) => drizzle({ client: nativeDb });
+  return canonical ? bindGlobalDomain("skills", establish) : bindGlobalDomainAtPath("skills", path2, establish);
 }
 function getSkillsNativeDb() {
-  return _skillsNativeDb;
+  const bound = _skillsOverridePath ? peekDomainAtPath("global", _skillsOverridePath, "skills") : peekGlobalDomain("skills");
+  return bound?.native ?? null;
 }
-var _skillsDb, _skillsNativeDb, _skillsDbPath, _skillsInitPromise;
+var _skillsOverridePath;
 var init_skills_db = __esm({
   "packages/core/src/store/skills-db.ts"() {
     "use strict";
@@ -36786,12 +36901,10 @@ var init_skills_db = __esm({
     init_paths();
     init_skill_provenance();
     init_dual_scope_db();
+    init_domain_binding();
     init_skills_schema();
     init_skills_schema();
-    _skillsDb = null;
-    _skillsNativeDb = null;
-    _skillsDbPath = null;
-    _skillsInitPromise = null;
+    _skillsOverridePath = null;
   }
 });
 
@@ -36820,11 +36933,11 @@ function resolveInventoryPath(entry, cwd) {
 }
 async function openBrainDbForSnapshot(cwd) {
   await getBrainDb(cwd);
-  return getBrainNativeDb();
+  return getBrainNativeDb(cwd);
 }
 async function openTasksDbForSnapshot(cwd) {
   await getDb(cwd);
-  return getNativeDb();
+  return getNativeDb(cwd);
 }
 async function openConduitDbForSnapshot(cwd) {
   await ensureConduitDb(resolveOrCwd(cwd));
@@ -37067,7 +37180,7 @@ __export(sqlite_native_exports, {
 import { realpathSync } from "node:fs";
 import { createRequire as createRequire8 } from "node:module";
 import { tmpdir } from "node:os";
-import { delimiter, dirname as dirname9, isAbsolute, join as join22, resolve as resolve5, sep } from "node:path";
+import { delimiter, dirname as dirname9, isAbsolute, join as join22, resolve as resolve6, sep } from "node:path";
 function getDbSyncConstructor() {
   if (_ctor === null) {
     const mod = _require5("node:sqlite");
@@ -37076,7 +37189,7 @@ function getDbSyncConstructor() {
   return _ctor;
 }
 function resolveAbsoluteSafe(p) {
-  const abs = isAbsolute(p) ? p : resolve5(p);
+  const abs = isAbsolute(p) ? p : resolve6(p);
   try {
     return realpathSync(abs);
   } catch {
@@ -37180,6 +37293,7 @@ var sqlite_exports = {};
 __export(sqlite_exports, {
   SQLITE_SCHEMA_VERSION: () => SQLITE_SCHEMA_VERSION,
   autoRecoverFromBackup: () => autoRecoverFromBackup,
+  bindTasksDomain: () => bindTasksDomain,
   closeAllDatabases: () => closeAllDatabases,
   closeDb: () => closeDb,
   dbExists: () => dbExists,
@@ -37237,13 +37351,14 @@ function countBackupTasks(backupDb) {
 async function autoRecoverFromBackup(nativeDb, dbPath, cwd) {
   const { openNativeDatabase: openNativeDatabase2 } = await Promise.resolve().then(() => (init_sqlite_native(), sqlite_native_exports));
   const log12 = getLogger("sqlite");
+  let restored = false;
   try {
     const countResult = nativeDb.prepare("SELECT COUNT(*) as cnt FROM tasks_tasks").get();
     const taskCount = countResult?.cnt ?? 0;
-    if (taskCount > 0) return;
+    if (taskCount > 0) return false;
     const backups = listSqliteBackups(cwd);
     if (backups.length === 0) {
-      return;
+      return false;
     }
     const newestBackup = backups[0];
     const backupDb = openNativeDatabase2(newestBackup.path, { readonly: true, enableWal: false });
@@ -37254,7 +37369,7 @@ async function autoRecoverFromBackup(nativeDb, dbPath, cwd) {
       backupDb.close();
     }
     if (backupTaskCount < MIN_BACKUP_TASK_COUNT) {
-      return;
+      return false;
     }
     const lockPath2 = dbPath + FIRST_OPEN_LOCK_SUFFIX;
     await withLock(
@@ -37293,11 +37408,7 @@ async function autoRecoverFromBackup(nativeDb, dbPath, cwd) {
           "Database auto-recovered from backup successfully."
         );
         _resetDualScopeDbCache();
-        const restoredNativeDb = openNativeDatabase2(dbPath);
-        _nativeDb3 = restoredNativeDb;
-        const restoredDb = _getDrizzle3()({ client: restoredNativeDb });
-        runMigrations(restoredNativeDb, restoredDb);
-        _db3 = restoredDb;
+        restored = true;
       },
       // Allow a generous stale window + retries: an exodus migration holding this
       // lock can take a while on a large fleet (matches on-open.ts), so a blocked
@@ -37307,64 +37418,46 @@ async function autoRecoverFromBackup(nativeDb, dbPath, cwd) {
   } catch (err) {
     log12.error({ err, dbPath }, "Auto-recovery from backup failed. Continuing with empty database.");
   }
+  return restored;
 }
 async function getDb(cwd) {
+  return (await bindTasksDomain(cwd)).db;
+}
+async function bindTasksDomain(cwd) {
   assertDbPathIsNotWorktreeResident("tasks", cwd);
-  const requestedPath = resolveDualScopeDbPath("project", cwd);
-  if (_db3 && _dbPath3 !== requestedPath) {
-    resetDbState();
-  }
-  if (_db3 && (_nativeDb3 === null || !_nativeDb3.isOpen)) {
-    resetDbState();
-  }
-  if (_db3) return _db3;
-  if (_initPromise4) return _initPromise4;
-  _initPromise4 = (async () => {
-    let nativeDb = null;
-    for (let attempt = 0; attempt < 2; attempt += 1) {
-      const dualHandle = await openDualScopeDb("project", cwd);
-      nativeDb = dualHandle.db.$client ?? null;
-      if (!nativeDb) {
-        throw new Error(
-          "E6-L1: openDualScopeDb returned a handle without $client \u2014 cannot extract DatabaseSync for legacy tasks-schema wrapping."
-        );
-      }
-      if (nativeDb.isOpen) break;
-      dualHandle.close();
-    }
-    if (!nativeDb?.isOpen) {
-      throw new Error("E6-L1: openDualScopeDb repeatedly returned a closed DatabaseSync handle.");
-    }
-    _nativeDb3 = nativeDb;
-    _dbPath3 = requestedPath;
-    const db = _getDrizzle3()({ client: nativeDb });
-    runMigrations(nativeDb, db);
-    if (process.env.VITEST) {
-      nativeDb.exec("PRAGMA foreign_keys=OFF");
-    }
-    nativeDb.exec(
-      `INSERT OR IGNORE INTO schema_meta (key, value) VALUES ('schemaVersion', '${SCHEMA_VERSION}')`
-    );
-    nativeDb.exec(
-      `INSERT OR IGNORE INTO schema_meta (key, value) VALUES ('task_id_sequence', '{"counter":0,"lastId":"T000","checksum":"seed"}')`
-    );
-    await autoRecoverFromBackup(nativeDb, requestedPath, cwd);
-    _db3 = db;
-    return db;
-  })();
-  try {
-    return await _initPromise4;
-  } finally {
-    _initPromise4 = null;
+  let coldBind = false;
+  const binding = await bindProjectDomain("tasks", cwd, (nativeDb, store) => {
+    coldBind = true;
+    return establishTasksSchema(nativeDb, store);
+  });
+  if (!coldBind) return binding;
+  if (await autoRecoverFromBackup(binding.native, binding.store.dbPath, cwd)) {
+    releaseDomainBindings({ scope: "project", dbPath: binding.store.dbPath });
+    return bindProjectDomain("tasks", cwd, establishTasksSchema);
   }
+  return binding;
+}
+function establishTasksSchema(nativeDb, store) {
+  const db = _getDrizzle3()({ client: nativeDb });
+  runMigrations(nativeDb, db, store.dbPath);
+  if (process.env.VITEST) {
+    nativeDb.exec("PRAGMA foreign_keys=OFF");
+  }
+  nativeDb.exec(
+    `INSERT OR IGNORE INTO schema_meta (key, value) VALUES ('schemaVersion', '${SCHEMA_VERSION}')`
+  );
+  nativeDb.exec(
+    `INSERT OR IGNORE INTO schema_meta (key, value) VALUES ('task_id_sequence', '{"counter":0,"lastId":"T000","checksum":"seed"}')`
+  );
+  return db;
 }
 function resolveMigrationsFolder() {
   return resolveCorePackageMigrationsFolder("drizzle-tasks");
 }
-function runMigrations(nativeDb, db) {
+function runMigrations(nativeDb, db, dbPath) {
   const migrationsFolder = resolveMigrationsFolder();
-  if (tableExists(nativeDb, "tasks") && _dbPath3) {
-    createSafetyBackup(_dbPath3);
+  if (tableExists(nativeDb, "tasks")) {
+    createSafetyBackup(dbPath);
   }
   reconcileJournal(
     nativeDb,
@@ -37388,33 +37481,11 @@ function runMigrations(nativeDb, db) {
 }
 function closeDb() {
   _resetDualScopeDbCache("project");
-  if (_nativeDb3) {
-    try {
-      if (_nativeDb3.isOpen) {
-        _nativeDb3.close();
-      }
-    } catch {
-    }
-    _nativeDb3 = null;
-  }
-  _db3 = null;
-  _dbPath3 = null;
-  _initPromise4 = null;
+  releaseDomainBindings({ scope: "project" });
 }
 function resetDbState() {
   _resetDualScopeDbCache("project");
-  if (_nativeDb3) {
-    try {
-      if (_nativeDb3.isOpen) {
-        _nativeDb3.close();
-      }
-    } catch {
-    }
-    _nativeDb3 = null;
-  }
-  _db3 = null;
-  _dbPath3 = null;
-  _initPromise4 = null;
+  releaseDomainBindings({ scope: "project" });
 }
 async function getSchemaVersion(cwd) {
   const db = await getDb(cwd);
@@ -37424,11 +37495,11 @@ async function getSchemaVersion(cwd) {
 function dbExists(cwd) {
   return existsSync22(resolveDualScopeDbPath("project", cwd));
 }
-function getNativeDb() {
-  return _nativeDb3;
+function getNativeDb(cwd) {
+  return boundProjectNative("tasks", cwd);
 }
-function getNativeTasksDb() {
-  return _nativeDb3;
+function getNativeTasksDb(cwd) {
+  return boundProjectNative("tasks", cwd);
 }
 async function closeAllDatabases() {
   closeDb();
@@ -37442,8 +37513,9 @@ async function closeAllDatabases() {
     closeNexusDb2();
   } catch {
   }
+  resetCleoRuntime();
 }
-var _drizzle4, SQLITE_SCHEMA_VERSION, SCHEMA_VERSION, _db3, _nativeDb3, _dbPath3, _initPromise4, MIN_BACKUP_TASK_COUNT, FIRST_OPEN_LOCK_SUFFIX, REQUIRED_TASK_COLUMNS, REQUIRED_SESSION_COLUMNS;
+var _drizzle4, SQLITE_SCHEMA_VERSION, SCHEMA_VERSION, MIN_BACKUP_TASK_COUNT, FIRST_OPEN_LOCK_SUFFIX, REQUIRED_TASK_COLUMNS, REQUIRED_SESSION_COLUMNS;
 var init_sqlite3 = __esm({
   "packages/core/src/store/sqlite.ts"() {
     "use strict";
@@ -37451,6 +37523,7 @@ var init_sqlite3 = __esm({
     init_dual_scope_db();
     init_lock();
     init_migration_manager();
+    init_domain_binding();
     init_resolve_migrations_folder();
     init_sqlite_backup();
     init_worktree_isolation_guard();
@@ -37460,10 +37533,6 @@ var init_sqlite3 = __esm({
     _drizzle4 = null;
     SQLITE_SCHEMA_VERSION = "2.0.0";
     SCHEMA_VERSION = SQLITE_SCHEMA_VERSION;
-    _db3 = null;
-    _nativeDb3 = null;
-    _dbPath3 = null;
-    _initPromise4 = null;
     MIN_BACKUP_TASK_COUNT = 10;
     FIRST_OPEN_LOCK_SUFFIX = ".exodus-on-open.lock";
     REQUIRED_TASK_COLUMNS = [
@@ -38403,7 +38472,7 @@ async function createSqliteDataAccessor(cwd) {
     },
     async transaction(fn) {
       const db = await getDb(cwd);
-      const nativeDb = getNativeTasksDb();
+      const nativeDb = getNativeTasksDb(cwd);
       if (!nativeDb) {
         throw new Error("Native database not initialized");
       }
@@ -38846,10 +38915,10 @@ var init_sequence = __esm({
 import { execFile as execFile2 } from "node:child_process";
 import { existsSync as existsSync24 } from "node:fs";
 import { readFile as readFile4, writeFile } from "node:fs/promises";
-import { join as join24, resolve as resolve6 } from "node:path";
+import { join as join24, resolve as resolve7 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 function makeCleoGitEnv(cleoDir) {
-  const abs = resolve6(cleoDir);
+  const abs = resolve7(cleoDir);
   return {
     ...process.env,
     GIT_DIR: join24(abs, ".git"),
@@ -38859,7 +38928,7 @@ function makeCleoGitEnv(cleoDir) {
 async function cleoGitCommand(args, cleoDir) {
   try {
     const result = await execFileAsync2("git", args, {
-      cwd: resolve6(cleoDir),
+      cwd: resolve7(cleoDir),
       // absolute cwd so relative paths in args resolve correctly
       env: makeCleoGitEnv(cleoDir),
       timeout: 1e4