@cleocode/core 2026.6.2 → 2026.6.4

package/dist/docs/export-document.js

@@ -10555,6 +10555,13 @@ var init_plugin_llm = __esm({
   }
 });
 
+// packages/contracts/src/llm/system-resolver.ts
+var init_system_resolver = __esm({
+  "packages/contracts/src/llm/system-resolver.ts"() {
+    "use strict";
+  }
+});
+
 // packages/contracts/src/memory/observe.ts
 var BRAIN_OBSERVATION_SOURCE_TYPES;
 var init_observe = __esm({
@@ -12497,6 +12504,7 @@ var init_src = __esm({
     init_invariants();
     init_lafs();
     init_plugin_llm();
+    init_system_resolver();
     init_observe();
     init_migration_parity();
     init_mvi();
@@ -14422,7 +14430,7 @@ var init_sql = __esm({
         return new SQL([new StringChunk(str)]);
       }
       _sql.raw = raw;
-      function join21(chunks, separator) {
+      function join22(chunks, separator) {
         const result = [];
         for (const [i, chunk] of chunks.entries()) {
           if (i > 0 && separator !== void 0) result.push(separator);
@@ -14430,7 +14438,7 @@ var init_sql = __esm({
         }
         return new SQL(result);
       }
-      _sql.join = join21;
+      _sql.join = join22;
       function identifier(value) {
         return new Name(value);
       }
@@ -16817,7 +16825,7 @@ var init_select2 = __esm({
           const baseTableName = this.tableName;
           const tableName = getTableLikeName(table);
           for (const item of extractUsedTable(table)) this.usedTables.add(item);
-          if (typeof tableName === "string" && this.config.joins?.some((join21) => join21.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+          if (typeof tableName === "string" && this.config.joins?.some((join22) => join22.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
           if (!this.isPartialSelect) {
             if (Object.keys(this.joinsNotNullableMap).length === 1 && typeof baseTableName === "string") this.config.fields = { [baseTableName]: this.config.fields };
             if (typeof tableName === "string" && !is(table, SQL)) {
@@ -20627,7 +20635,7 @@ var init_dialect = __esm({
           if (!joins2) return;
           const withEntries = Object.entries(joins2).filter(([_, v]) => v);
           if (!withEntries.length) return;
-          return sql.join(withEntries.map(([k, join21]) => {
+          return sql.join(withEntries.map(([k, join22]) => {
             const relation = tableConfig.relations[k];
             const isSingle2 = is(relation, One);
             const targetTable = aliasedTable(relation.targetTable, `d${currentDepth + 1}`);
@@ -20638,7 +20646,7 @@ var init_dialect = __esm({
               table: targetTable,
               mode: isSingle2 ? "first" : "many",
               schema,
-              queryConfig: join21,
+              queryConfig: join22,
               tableConfig: schema[relation.targetTableName],
               relationWhere: filter,
               isNested: true,
@@ -20652,7 +20660,7 @@ var init_dialect = __esm({
               key: k,
               selection: innerQuery.selection,
               isArray: !isSingle2,
-              isOptional: (relation.optional ?? false) || join21 !== true && !!join21.where
+              isOptional: (relation.optional ?? false) || join22 !== true && !!join22.where
             });
             const jsonColumns = sql.join(innerQuery.selection.map((s) => {
               return sql`${sql.raw(this.escapeString(s.key))}, ${s.selection ? sql`${jsonb3}(${sql.identifier(s.key)})` : sql.identifier(s.key)}`;
@@ -21473,7 +21481,7 @@ var init_update = __esm({
       createJoin(joinType) {
         return ((table, on) => {
           const tableName = getTableLikeName(table);
-          if (typeof tableName === "string" && this.config.joins.some((join21) => join21.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+          if (typeof tableName === "string" && this.config.joins.some((join22) => join22.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
           if (typeof on === "function") {
             const from = this.config.from ? is(table, SQLiteTable) ? table[Table.Symbol.Columns] : is(table, Subquery) ? table._.selectedFields : is(table, SQLiteViewBase) ? table[ViewBaseConfig].selectedFields : void 0 : void 0;
             on = on(new Proxy(this.config.table[Table.Symbol.Columns], new SelectionProxyHandler({
@@ -22506,8 +22514,8 @@ function probeAndMarkApplied(nativeDb, migration, logSubsystem) {
   });
   if (allAltersPresent && allTablesPresent && allIndexesPresent && allTriggersPresent) {
     insertJournalEntry(nativeDb, migration.hash, migration.folderMillis, migration.name ?? "");
-    const log7 = getLogger(logSubsystem);
-    log7.debug(
+    const log8 = getLogger(logSubsystem);
+    log8.debug(
       {
         migration: migration.name,
         alters: alterTargets.length,
@@ -22547,14 +22555,14 @@ function reconcileJournal(nativeDb, migrationsFolder, existenceTable2, logSubsys
     if (hasOrphanedEntries) {
       const dbHashes = new Set(dbEntries.map((e) => e.hash));
       const allLocalHashesPresentInDb = localMigrations.every((m) => dbHashes.has(m.hash));
-      const log7 = getLogger(logSubsystem);
+      const log8 = getLogger(logSubsystem);
       if (allLocalHashesPresentInDb) {
-        log7.debug(
+        log8.debug(
           { extra: orphanedEntries.length },
           `Migration journal has ${orphanedEntries.length} entries for migrations not known to this install (DB is ahead). Skipping reconciliation.`
         );
       } else {
-        log7.warn(
+        log8.warn(
           { orphaned: orphanedEntries.length },
           `Detected ${orphanedEntries.length} true-orphan journal entries from a previous CLEO lineage. Reconciling via DDL probe.`
         );
@@ -22590,8 +22598,8 @@ function reconcileJournal(nativeDb, migrationsFolder, existenceTable2, logSubsys
       if (alterMatches.length === 0) {
         const stripped = fullSql.replace(/--[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").trim();
         if (stripped === "") {
-          const log7 = getLogger(logSubsystem);
-          log7.debug(
+          const log8 = getLogger(logSubsystem);
+          log8.debug(
             { migration: migration.name },
             `Migration ${migration.name} is a comment-only baseline marker \u2014 marking applied on existing DB.`
           );
@@ -22628,8 +22636,8 @@ function reconcileJournal(nativeDb, migrationsFolder, existenceTable2, logSubsys
         }
       }
       if (missingColumns.length === 0) {
-        const log7 = getLogger(logSubsystem);
-        log7.warn(
+        const log8 = getLogger(logSubsystem);
+        log8.warn(
           { migration: migration.name, columns: alterMatches },
           `Detected partially-applied migration ${migration.name} \u2014 columns exist but journal entry missing. Auto-reconciling.`
         );
@@ -22637,8 +22645,8 @@ function reconcileJournal(nativeDb, migrationsFolder, existenceTable2, logSubsys
         continue;
       }
       if (existingColumns.length > 0 && missingColumns.length > 0) {
-        const log7 = getLogger(logSubsystem);
-        log7.warn(
+        const log8 = getLogger(logSubsystem);
+        log8.warn(
           {
             migration: migration.name,
             existingColumns: existingColumns.map((c) => `${c.table}.${c.column}`),
@@ -22650,12 +22658,12 @@ function reconcileJournal(nativeDb, migrationsFolder, existenceTable2, logSubsys
           if (!tableExists(nativeDb, table)) continue;
           try {
             nativeDb.exec(`ALTER TABLE ${table} ADD COLUMN ${column}${ddl ? ` ${ddl}` : ""}`);
-            log7.warn(
+            log8.warn(
               { migration: migration.name, table, column },
               `T920: Added missing column ${table}.${column} to complete partial migration.`
             );
           } catch {
-            log7.warn(
+            log8.warn(
               { migration: migration.name, table, column },
               `T920: Could not add missing column ${table}.${column} \u2014 will let Drizzle migrate() handle it.`
             );
@@ -22675,8 +22683,8 @@ function reconcileJournal(nativeDb, migrationsFolder, existenceTable2, logSubsys
     for (const entry of unnamedEntries) {
       const migrationName = hashToName.get(entry.hash);
       if (!migrationName) continue;
-      const log7 = getLogger(logSubsystem);
-      log7.debug(
+      const log8 = getLogger(logSubsystem);
+      log8.debug(
         { id: entry.id, hash: entry.hash, name: migrationName },
         `Backfilling missing name on journal entry id=${entry.id} (Drizzle v1 beta legacy compat).`
       );
@@ -22817,13 +22825,13 @@ function ensureColumns(nativeDb, tableName, requiredColumns, logSubsystem, conte
   const existingCols = new Set(columns.map((c) => c.name));
   for (const req of requiredColumns) {
     if (!existingCols.has(req.name)) {
-      const log7 = getLogger(logSubsystem);
+      const log8 = getLogger(logSubsystem);
       const message = `Adding missing column ${tableName}.${req.name} via ALTER TABLE`;
       const fields = { column: req.name, context };
       if (context === "fresh") {
-        log7.error(fields, `${message} \u2014 MIGRATION DEFECT (fresh DB should not need repair)`);
+        log8.error(fields, `${message} \u2014 MIGRATION DEFECT (fresh DB should not need repair)`);
       } else {
-        log7.warn(fields, message);
+        log8.warn(fields, message);
       }
       nativeDb.exec(`ALTER TABLE ${tableName} ADD COLUMN ${req.name} ${req.ddl}`);
     }
@@ -31359,14 +31367,159 @@ var init_ensure_config = __esm({
   }
 });
 
+// packages/core/src/store/exodus/archive.ts
+import {
+  copyFileSync as copyFileSync2,
+  existsSync as existsSync4,
+  mkdirSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { basename as basename3, join as join6 } from "node:path";
+function scopeBaseDir(scope, cwd) {
+  return scope === "project" ? resolveCleoDir(cwd) : getCleoHome();
+}
+function exodusArchiveDir(scope, cwd) {
+  return join6(scopeBaseDir(scope, cwd), ARCHIVE_DIR_NAME);
+}
+function exodusMarkerPath(scope, cwd) {
+  return join6(scopeBaseDir(scope, cwd), MARKER_FILENAME_BY_SCOPE[scope]);
+}
+function hasExodusCompleteMarker(scope, cwd) {
+  try {
+    return existsSync4(exodusMarkerPath(scope, cwd));
+  } catch {
+    return false;
+  }
+}
+function writeExodusCompleteMarker(scope, archivedSources, cwd) {
+  const markerPath = exodusMarkerPath(scope, cwd);
+  const baseDir = scopeBaseDir(scope, cwd);
+  mkdirSync(baseDir, { recursive: true });
+  const marker = {
+    version: 1,
+    scope,
+    cleoVersion: getCleoVersion(),
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    archivedSources: [...archivedSources]
+  };
+  const tmpPath = `${markerPath}.tmp`;
+  writeFileSync(tmpPath, JSON.stringify(marker, null, 2) + "\n", "utf8");
+  renameSync(tmpPath, markerPath);
+  log.info({ scope, markerPath, archivedSources }, "exodus: wrote completion marker");
+  return markerPath;
+}
+function moveFileInto(srcPath, destDir) {
+  mkdirSync(destDir, { recursive: true });
+  let dest = join6(destDir, basename3(srcPath));
+  if (existsSync4(dest)) {
+    const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "").replace(/Z$/, "Z");
+    dest = join6(destDir, `${basename3(srcPath)}.${stamp}`);
+  }
+  try {
+    renameSync(srcPath, dest);
+  } catch {
+    copyFileSync2(srcPath, dest);
+    unlinkSync(srcPath);
+  }
+  return dest;
+}
+function archiveSourceDb(source, cwd) {
+  if (!existsSync4(source.path)) {
+    return { name: source.name, sourcePath: source.path, archivedTo: null, action: "absent" };
+  }
+  const destDir = exodusArchiveDir(source.targetScope, cwd);
+  const archivedTo = moveFileInto(source.path, destDir);
+  for (const suffix of SIDECAR_SUFFIXES) {
+    const sidecar = `${source.path}${suffix}`;
+    if (existsSync4(sidecar)) {
+      try {
+        moveFileInto(sidecar, destDir);
+      } catch (err) {
+        log.warn(
+          { err, sidecar, sourceName: source.name },
+          "exodus-archive: failed to archive sidecar (non-fatal)"
+        );
+      }
+    }
+  }
+  log.info(
+    { sourceName: source.name, sourcePath: source.path, archivedTo, scope: source.targetScope },
+    "exodus-archive: archived legacy source DB"
+  );
+  return {
+    name: source.name,
+    sourcePath: source.path,
+    archivedTo,
+    action: "archived"
+  };
+}
+function archiveMigratedSources(consumed, cwd) {
+  const results = [];
+  const scopes = /* @__PURE__ */ new Set();
+  for (const source of consumed) {
+    scopes.add(source.targetScope);
+    results.push(archiveSourceDb(source, cwd));
+  }
+  const markersWritten = [];
+  for (const scope of scopes) {
+    const archivedForScope = consumed.filter((s) => s.targetScope === scope).map((s) => s.name);
+    writeExodusCompleteMarker(scope, archivedForScope, cwd);
+    markersWritten.push(scope);
+  }
+  return { sources: results, markersWritten };
+}
+function detectStrandedResidue(sources, cwd) {
+  const markedScopes = /* @__PURE__ */ new Set();
+  for (const scope of ["project", "global"]) {
+    if (hasExodusCompleteMarker(scope, cwd)) markedScopes.add(scope);
+  }
+  if (markedScopes.size === 0) return [];
+  const stranded = [];
+  for (const source of sources) {
+    if (!markedScopes.has(source.targetScope)) continue;
+    if (existsSync4(source.path)) {
+      stranded.push({ name: source.name, path: source.path, scope: source.targetScope });
+    }
+  }
+  return stranded;
+}
+function archiveStrandedResidue(stranded, sources, cwd) {
+  const byName = new Map(sources.map((s) => [s.name, s]));
+  const results = [];
+  for (const entry of stranded) {
+    const descriptor = byName.get(entry.name);
+    if (descriptor === void 0) continue;
+    results.push(archiveSourceDb(descriptor, cwd));
+  }
+  return results;
+}
+var log, ARCHIVE_DIR_NAME, MARKER_FILENAME_BY_SCOPE, SIDECAR_SUFFIXES;
+var init_archive2 = __esm({
+  "packages/core/src/store/exodus/archive.ts"() {
+    "use strict";
+    init_logger2();
+    init_paths();
+    init_ensure_config();
+    log = getLogger("exodus-archive");
+    ARCHIVE_DIR_NAME = "_archive";
+    MARKER_FILENAME_BY_SCOPE = {
+      project: "exodus-complete",
+      global: "exodus-complete"
+    };
+    SIDECAR_SUFFIXES = ["-wal", "-shm"];
+  }
+});
+
 // packages/core/src/project-info.ts
-import { existsSync as existsSync4, readFileSync as readFileSync2, writeFileSync } from "node:fs";
-import { join as join6 } from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join7 } from "node:path";
 function getProjectInfoSync(cwd) {
   const projectRoot = resolveOrCwd(cwd);
   const cleoDir = getCleoDirAbsolute(projectRoot);
-  const infoPath = join6(cleoDir, "project-info.json");
-  if (!existsSync4(infoPath)) return null;
+  const infoPath = join7(cleoDir, "project-info.json");
+  if (!existsSync5(infoPath)) return null;
   try {
     const raw = readFileSync2(infoPath, "utf-8");
     const data = JSON.parse(raw);
@@ -31393,8 +31546,8 @@ var init_project_info = __esm({
 });
 
 // packages/core/src/store/worktree-isolation-guard.ts
-import { existsSync as existsSync5, statSync } from "node:fs";
-import { dirname as dirname4, join as join7 } from "node:path";
+import { existsSync as existsSync6, statSync } from "node:fs";
+import { dirname as dirname4, join as join8 } from "node:path";
 function assertDbPathIsNotWorktreeResident(role, cwd) {
   let cleoDir;
   try {
@@ -31403,10 +31556,10 @@ function assertDbPathIsNotWorktreeResident(role, cwd) {
     return;
   }
   const projectRoot = dirname4(cleoDir);
-  const projectGit = join7(projectRoot, ".git");
+  const projectGit = join8(projectRoot, ".git");
   let isWorktreeGitlink = false;
   try {
-    isWorktreeGitlink = existsSync5(projectGit) && statSync(projectGit).isFile();
+    isWorktreeGitlink = existsSync6(projectGit) && statSync(projectGit).isFile();
   } catch {
   }
   if (!isWorktreeGitlink) {
@@ -31881,15 +32034,15 @@ var init_types = __esm({
 
 // packages/core/src/store/exodus/migrate.ts
 import {
-  copyFileSync as copyFileSync2,
-  existsSync as existsSync6,
-  mkdirSync,
+  copyFileSync as copyFileSync3,
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync2,
   readFileSync as readFileSync3,
-  renameSync,
-  unlinkSync,
-  writeFileSync as writeFileSync2
+  renameSync as renameSync2,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync3
 } from "node:fs";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 function getSqliteVersion(db) {
   try {
     const row = db.prepare("SELECT sqlite_version() AS v").get();
@@ -31905,14 +32058,14 @@ function listTables(db) {
   return rows.map((r) => r.name);
 }
 function writeJournal(stagingDir, journal) {
-  const journalPath = join8(stagingDir, JOURNAL_FILENAME);
+  const journalPath = join9(stagingDir, JOURNAL_FILENAME);
   const tmpPath = `${journalPath}.tmp`;
-  writeFileSync2(tmpPath, JSON.stringify(journal, null, 2) + "\n", "utf8");
-  renameSync(tmpPath, journalPath);
+  writeFileSync3(tmpPath, JSON.stringify(journal, null, 2) + "\n", "utf8");
+  renameSync2(tmpPath, journalPath);
 }
 function readJournal(stagingDir) {
-  const journalPath = join8(stagingDir, JOURNAL_FILENAME);
-  if (!existsSync6(journalPath)) return null;
+  const journalPath = join9(stagingDir, JOURNAL_FILENAME);
+  if (!existsSync7(journalPath)) return null;
   try {
     return JSON.parse(readFileSync3(journalPath, "utf8"));
   } catch {
@@ -31920,17 +32073,17 @@ function readJournal(stagingDir) {
   }
 }
 function clearExodusJournal(stagingDir) {
-  const journalPath = join8(stagingDir, JOURNAL_FILENAME);
+  const journalPath = join9(stagingDir, JOURNAL_FILENAME);
   try {
-    if (!existsSync6(journalPath)) return false;
-    unlinkSync(journalPath);
-    log.info(
+    if (!existsSync7(journalPath)) return false;
+    unlinkSync2(journalPath);
+    log2.info(
       { stagingDir },
       "exodus: cleared migrate journal after abort/rollback \u2014 a retry will RE-COPY all tables"
     );
     return true;
   } catch (err) {
-    log.warn(
+    log2.warn(
       { err, stagingDir },
       'exodus: failed to clear migrate journal after rollback (a retry may skip already-"done" tables)'
     );
@@ -31955,11 +32108,11 @@ function lockPath(dbPath) {
 }
 function acquireAdvisoryLock(dbPath) {
   const lp = lockPath(dbPath);
-  writeFileSync2(lp, JSON.stringify({ pid: process.pid, ts: (/* @__PURE__ */ new Date()).toISOString() }), "utf8");
+  writeFileSync3(lp, JSON.stringify({ pid: process.pid, ts: (/* @__PURE__ */ new Date()).toISOString() }), "utf8");
 }
 function releaseAdvisoryLock(dbPath) {
   try {
-    unlinkSync(lockPath(dbPath));
+    unlinkSync2(lockPath(dbPath));
   } catch {
   }
 }
@@ -31979,6 +32132,11 @@ function enumNormExpr(targetTableName, col, srcRef) {
   const fn = ENUM_NORMALIZATIONS.get(key);
   return fn ? fn(srcRef) : null;
 }
+function numericClampExpr(targetTableName, col, srcRef) {
+  const key = `${targetTableName}.${col}`;
+  const fn = NUMERIC_CLAMPS.get(key);
+  return fn ? fn(srcRef) : null;
+}
 function epochUnitForSource(sourceName) {
   const key = sourceName.toLowerCase();
   for (const [pattern, unit] of SOURCE_EPOCH_UNITS) {
@@ -32014,6 +32172,14 @@ function buildSelectExpr(attachAlias, legacyTable, targetTableName, col, srcType
     }
     return `${isoExpr} AS "${col}"`;
   }
+  const clampExpr = numericClampExpr(targetTableName, col, srcRef);
+  if (clampExpr !== null) {
+    if (isNotNullWithoutDefault) {
+      const defLiteral = typeDefaultLiteral(tgtInfo.type);
+      return `COALESCE(${clampExpr}, ${defLiteral}) AS "${col}"`;
+    }
+    return `${clampExpr} AS "${col}"`;
+  }
   const normExpr = enumNormExpr(targetTableName, col, srcRef);
   if (normExpr !== null) {
     if (isNotNullWithoutDefault) {
@@ -32031,7 +32197,7 @@ function buildSelectExpr(attachAlias, legacyTable, targetTableName, col, srcType
 function copyTableFromAttached(targetNativeDb, srcNativeDb, attachAlias, legacyTableName, sourceName, targetSchema = "main") {
   const resolution = resolveConsolidatedTableName(sourceName, legacyTableName);
   if (resolution.kind === "skip") {
-    log.warn(
+    log2.warn(
       { legacyTableName, sourceName, reason: resolution.reason },
       `Exodus: explicitly skipping table \u2014 ${resolution.reason}`
     );
@@ -32050,7 +32216,7 @@ function copyTableFromAttached(targetNativeDb, srcNativeDb, attachAlias, legacyT
   ).get();
   if (!existsRow) {
     const reason = `consolidated target '${targetTableName}' not found (mapped from legacy '${legacyTableName}')`;
-    log.warn(
+    log2.warn(
       { legacyTableName, targetTableName, sourceName, attachAlias, targetSchema },
       `Exodus: ${reason}`
     );
@@ -32061,13 +32227,13 @@ function copyTableFromAttached(targetNativeDb, srcNativeDb, attachAlias, legacyT
   const sharedColumns = srcPragma.map((r) => r.name).filter((col) => tgtColMap.has(col));
   if (sharedColumns.length === 0) {
     const reason = `no overlapping columns between source '${legacyTableName}' and target '${targetTableName}'`;
-    log.warn({ legacyTableName, targetTableName, sourceName }, `Exodus: ${reason}`);
+    log2.warn({ legacyTableName, targetTableName, sourceName }, `Exodus: ${reason}`);
     return { rowsCopied: 0, skipped: true, reason };
   }
   const srcOnlyColumns = srcPragma.map((r) => r.name).filter((c) => !tgtColMap.has(c));
   const tgtOnlyColumns = tgtPragma.map((r) => r.name).filter((c) => !srcColumns.has(c));
   if (srcOnlyColumns.length > 0 || tgtOnlyColumns.length > 0) {
-    log.info(
+    log2.info(
       { legacyTableName, targetTableName, sourceName, srcOnlyColumns, tgtOnlyColumns },
       "Exodus: column drift detected \u2014 copying intersection, dropping src-only cols, using defaults for tgt-only cols"
     );
@@ -32082,7 +32248,7 @@ function copyTableFromAttached(targetNativeDb, srcNativeDb, attachAlias, legacyT
       return isoGlobCols.has(col) && (upper.includes("INT") || upper === "" || upper === "NUMERIC");
     });
     if (coercedCols.length > 0) {
-      log.info(
+      log2.info(
         {
           legacyTableName,
           targetTableName,
@@ -32098,11 +32264,20 @@ function copyTableFromAttached(targetNativeDb, srcNativeDb, attachAlias, legacyT
     (col) => ENUM_NORMALIZATIONS.has(`${targetTableName}.${col}`)
   );
   if (normalizedCols.length > 0) {
-    log.info(
+    log2.info(
       { legacyTableName, targetTableName, sourceName, normalizedCols },
       `Exodus: applying enum-value normalization for ${normalizedCols.length} column(s) (T11547)`
     );
   }
+  const clampedCols = sharedColumns.filter(
+    (col) => NUMERIC_CLAMPS.has(`${targetTableName}.${col}`)
+  );
+  if (clampedCols.length > 0) {
+    log2.info(
+      { legacyTableName, targetTableName, sourceName, clampedCols },
+      `Exodus: applying non-finite numeric clamp for ${clampedCols.length} column(s) (T11782)`
+    );
+  }
   const selectExprs = sharedColumns.map((col) => {
     const srcType = srcTypeMap.get(col) ?? "";
     const tgtInfo = tgtColMap.get(col);
@@ -32139,13 +32314,13 @@ function copyTableFromAttached(targetNativeDb, srcNativeDb, attachAlias, legacyT
     const dropped = sourceCount - rowsCopied;
     if (rowsCopied === 0) {
       const reason = `INSERT OR IGNORE dropped ALL ${sourceCount} rows from '${legacyTableName}'\u2192'${targetTableName}' (rowsCopied=0, sourceCount=${sourceCount}). Likely a CHECK/type constraint violation \u2014 check epoch coercion or enum values.`;
-      log.error(
+      log2.error(
         { legacyTableName, targetTableName, sourceName, sourceCount, rowsCopied },
         `Exodus: ${reason}`
       );
       return { rowsCopied: 0, skipped: false, reason };
     }
-    log.warn(
+    log2.warn(
       { legacyTableName, targetTableName, sourceName, sourceCount, rowsCopied, dropped },
       `Exodus: INSERT OR IGNORE dropped ${dropped}/${sourceCount} rows from '${legacyTableName}'\u2192'${targetTableName}' \u2014 may be idempotent-resume dedup or a constraint violation; verify will confirm`
     );
@@ -32156,16 +32331,16 @@ function checkSchemaVersion(journal, forceCrossVersion) {
   if (journal.targetSchemaVersion !== EXODUS_TARGET_SCHEMA_VERSION) {
     const msg = `Schema version mismatch: journal=${journal.targetSchemaVersion}, expected=${EXODUS_TARGET_SCHEMA_VERSION}`;
     if (forceCrossVersion) {
-      log.warn(msg + " (--force-cross-version: continuing anyway)");
+      log2.warn(msg + " (--force-cross-version: continuing anyway)");
       return true;
     }
-    log.error(msg + " \u2014 pass --force-cross-version to override");
+    log2.error(msg + " \u2014 pass --force-cross-version to override");
     return false;
   }
   return true;
 }
 async function runExodusMigrate(plan, forceCrossVersion = false, onProgress) {
-  const { sources, stagingDir, diskPreflight, projectDbPath } = plan;
+  const { sources, stagingDir, diskPreflight, projectDbPath, globalDbPath } = plan;
   if (!diskPreflight) {
     return {
       ok: false,
@@ -32175,10 +32350,10 @@ async function runExodusMigrate(plan, forceCrossVersion = false, onProgress) {
       error: `Insufficient disk space: need \u22653\xD7 source size (${plan.totalSourceBytes} bytes source, ${plan.availableBytes} bytes available). Free up space or use a different storage location.`
     };
   }
-  mkdirSync(stagingDir, { recursive: true });
+  mkdirSync2(stagingDir, { recursive: true });
   let sqliteVersion = "unknown";
   for (const src of sources) {
-    if (existsSync6(src.path)) {
+    if (existsSync7(src.path)) {
       const snap = openCleoDbSnapshot(src.path, { readOnly: true });
       sqliteVersion = getSqliteVersion(snap.db);
       snap.close();
@@ -32203,6 +32378,8 @@ async function runExodusMigrate(plan, forceCrossVersion = false, onProgress) {
   const backupPaths = [];
   const allTableResults = [];
   const lockedPaths = [];
+  let projectHandle = null;
+  let globalHandle = null;
   try {
     let extractNativeDb2 = function(handle) {
       const drizzleHandle = handle.db;
@@ -32217,24 +32394,28 @@ async function runExodusMigrate(plan, forceCrossVersion = false, onProgress) {
     };
     var extractNativeDb = extractNativeDb2;
     for (const src of sources) {
-      if (!existsSync6(src.path)) continue;
-      const backupDest = join8(stagingDir, `${src.name.replace(/[^a-z0-9-]/g, "_")}-backup.db`);
-      if (!existsSync6(backupDest)) {
+      if (!existsSync7(src.path)) continue;
+      const backupDest = join9(stagingDir, `${src.name.replace(/[^a-z0-9-]/g, "_")}-backup.db`);
+      if (!existsSync7(backupDest)) {
         onProgress?.(`Backing up ${src.name} \u2192 staging dir\u2026`);
-        copyFileSync2(src.path, backupDest);
+        copyFileSync3(src.path, backupDest);
         backupPaths.push(backupDest);
       }
       acquireAdvisoryLock(src.path);
       lockedPaths.push(src.path);
     }
-    onProgress?.("Opening consolidated project-scope cleo.db (running migrations)\u2026");
-    const projectHandle = await openDualScopeDb("project");
-    onProgress?.("Opening consolidated global-scope cleo.db (running migrations)\u2026");
-    const globalHandle = await openDualScopeDb("global");
+    onProgress?.("Opening DEDICATED project-scope cleo.db connection (running migrations)\u2026");
+    projectHandle = await openDualScopeDbAtPath("project", projectDbPath, void 0, {
+      dedicated: true
+    });
+    onProgress?.("Opening DEDICATED global-scope cleo.db connection (running migrations)\u2026");
+    globalHandle = await openDualScopeDbAtPath("global", globalDbPath, void 0, {
+      dedicated: true
+    });
     const projectNative = extractNativeDb2(projectHandle);
     const globalNative = extractNativeDb2(globalHandle);
-    const projectSources = sources.filter((s) => s.targetScope === "project" && existsSync6(s.path));
-    const globalSources = sources.filter((s) => s.targetScope === "global" && existsSync6(s.path));
+    const projectSources = sources.filter((s) => s.targetScope === "project" && existsSync7(s.path));
+    const globalSources = sources.filter((s) => s.targetScope === "global" && existsSync7(s.path));
     await migrateScope(
       "project",
       projectSources,
@@ -32256,14 +32437,20 @@ async function runExodusMigrate(plan, forceCrossVersion = false, onProgress) {
     );
     journal.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     writeJournal(stagingDir, journal);
-    projectHandle.close();
-    globalHandle.close();
     return { ok: true, tables: allTableResults, stagingDir, backupPaths };
   } catch (err) {
     const error = err instanceof Error ? err.message : String(err);
-    log.error({ err }, "Exodus migration failed");
+    log2.error({ err }, "Exodus migration failed");
     return { ok: false, tables: allTableResults, stagingDir, backupPaths, error };
   } finally {
+    try {
+      projectHandle?.close();
+    } catch {
+    }
+    try {
+      globalHandle?.close();
+    } catch {
+    }
     for (const p of lockedPaths) {
       releaseAdvisoryLock(p);
     }
@@ -32273,7 +32460,7 @@ async function migrateScope(scope, sources, targetNativeDb, journal, stagingDir,
   if (sources.length === 0) return;
   onProgress?.(`Migrating ${scope}-scope sources\u2026`);
   targetNativeDb.exec("PRAGMA foreign_keys = OFF");
-  log.info({ scope }, "Exodus: foreign_keys=OFF for bulk copy (T11533 FK-defer)");
+  log2.info({ scope }, "Exodus: foreign_keys=OFF for bulk copy (T11533 FK-defer)");
   try {
     for (let i = 0; i < sources.length; i++) {
       const src = sources[i];
@@ -32335,12 +32522,12 @@ async function migrateScope(scope, sources, targetNativeDb, journal, stagingDir,
                 errorMsg = copyResult.reason;
                 skipped = true;
               } else if (copyResult.reason) {
-                status = "skipped";
+                status = "partial";
                 errorMsg = copyResult.reason;
               }
             } catch (err) {
               const msg = err instanceof Error ? err.message : String(err);
-              log.warn({ tableName, sourceDb: src.name, err }, "Table copy failed \u2014 skipping");
+              log2.warn({ tableName, sourceDb: src.name, err }, "Table copy failed \u2014 skipping");
               status = "skipped";
               errorMsg = msg;
               skipped = true;
@@ -32388,7 +32575,7 @@ async function migrateScope(scope, sources, targetNativeDb, journal, stagingDir,
           targetNativeDb.exec(`DETACH DATABASE "${attachAlias}"`);
           onProgress?.(`  [${src.name}] Detached "${attachAlias}"`);
         } catch (detachErr) {
-          log.warn(
+          log2.warn(
             { attachAlias, sourceDb: src.name, err: detachErr },
             "DETACH failed \u2014 alias will be released on DB close"
           );
@@ -32398,7 +32585,7 @@ async function migrateScope(scope, sources, targetNativeDb, journal, stagingDir,
             targetNativeDb.exec(`DETACH DATABASE "${crossAlias}"`);
             onProgress?.(`  [${src.name}] Cross-scope target detached "${crossAlias}"`);
           } catch (detachErr) {
-            log.warn(
+            log2.warn(
               { crossAlias, sourceDb: src.name, err: detachErr },
               "Cross-scope DETACH failed \u2014 alias will be released on DB close"
             );
@@ -32410,28 +32597,28 @@ async function migrateScope(scope, sources, targetNativeDb, journal, stagingDir,
     try {
       const orphans = targetNativeDb.prepare("PRAGMA foreign_key_check").all();
       if (orphans.length > 0) {
-        log.warn(
+        log2.warn(
           { scope, orphanCount: orphans.length, sample: orphans.slice(0, 5) },
           `Exodus: PRAGMA foreign_key_check found ${orphans.length} orphan row(s) after bulk copy \u2014 these are genuine data orphans (not ordering artifacts)`
         );
       } else {
-        log.info({ scope }, "Exodus: PRAGMA foreign_key_check PASSED \u2014 no orphan rows");
+        log2.info({ scope }, "Exodus: PRAGMA foreign_key_check PASSED \u2014 no orphan rows");
       }
     } catch (checkErr) {
-      log.warn(
+      log2.warn(
         { scope, err: checkErr },
         "Exodus: PRAGMA foreign_key_check failed (non-fatal) \u2014 target schema may not have FK constraints enabled"
       );
     }
     try {
       targetNativeDb.exec("PRAGMA foreign_keys = ON");
-      log.info({ scope }, "Exodus: foreign_keys=ON restored after bulk copy");
+      log2.info({ scope }, "Exodus: foreign_keys=ON restored after bulk copy");
     } catch (fkErr) {
-      log.warn({ scope, err: fkErr }, "Exodus: could not restore foreign_keys=ON (non-fatal)");
+      log2.warn({ scope, err: fkErr }, "Exodus: could not restore foreign_keys=ON (non-fatal)");
     }
   }
 }
-var log, LOCK_SENTINEL_SUFFIX, JOURNAL_FILENAME, ENUM_NORMALIZATIONS, ISO_CHECK_REGEX, SOURCE_EPOCH_UNITS, EPOCH_SECONDS_THRESHOLD;
+var log2, LOCK_SENTINEL_SUFFIX, JOURNAL_FILENAME, ENUM_NORMALIZATIONS, NUMERIC_CLAMPS, ISO_CHECK_REGEX, SOURCE_EPOCH_UNITS, EPOCH_SECONDS_THRESHOLD;
 var init_migrate = __esm({
   "packages/core/src/store/exodus/migrate.ts"() {
     "use strict";
@@ -32441,7 +32628,7 @@ var init_migrate = __esm({
     init_open_cleo_db();
     init_table_name_map();
     init_types();
-    log = getLogger("exodus-migrate");
+    log2 = getLogger("exodus-migrate");
     LOCK_SENTINEL_SUFFIX = ".exodus-lock";
     JOURNAL_FILENAME = "exodus-journal.json";
     ENUM_NORMALIZATIONS = /* @__PURE__ */ new Map([
@@ -32533,6 +32720,15 @@ var init_migrate = __esm({
       //  brain target = runtime shape with no CHECK; legacy values like 'accepted',
       //  'rejected', 'prime' now survive VERBATIM instead of being coerced.)
     ]);
+    NUMERIC_CLAMPS = /* @__PURE__ */ new Map([
+      // --- brain_weight_history.delta_weight (T11782) -------------------------
+      // +Inf → 1.0 (max canonical reinforcement), -Inf → -1.0 (max canonical
+      // depression), NaN → 0.0 (no-op delta). Finite values pass through.
+      [
+        "brain_weight_history.delta_weight",
+        (src) => `CASE WHEN ${src} = 9e999 THEN 1.0 WHEN ${src} = -9e999 THEN -1.0 WHEN ${src} != ${src} THEN 0.0 ELSE ${src} END`
+      ]
+    ]);
     ISO_CHECK_REGEX = /CHECK\s*\(\s*"([^"]+)"\s+IS\s+NULL\s+OR\s+"[^"]+"\s+GLOB\s+'\[0-9/gi;
     SOURCE_EPOCH_UNITS = /* @__PURE__ */ new Map([
       ["conduit", "seconds"],
@@ -32549,8 +32745,8 @@ var init_migrate = __esm({
 });
 
 // packages/core/src/store/exodus/plan.ts
-import { existsSync as existsSync7, readdirSync as readdirSync2, statfsSync, statSync as statSync2 } from "node:fs";
-import { join as join9 } from "node:path";
+import { existsSync as existsSync8, readdirSync as readdirSync2, statfsSync, statSync as statSync2 } from "node:fs";
+import { join as join10 } from "node:path";
 function buildSourceDescriptors(cwd) {
   const cleoDir = resolveCleoDir(cwd);
   const cleoHome = getCleoHome();
@@ -32558,33 +32754,33 @@ function buildSourceDescriptors(cwd) {
     // Project-tier — go into consolidated project-scope cleo.db
     {
       name: "tasks",
-      path: join9(cleoDir, "tasks.db"),
+      path: join10(cleoDir, "tasks.db"),
       targetScope: "project"
     },
     {
       name: "brain (project)",
-      path: join9(cleoDir, "brain.db"),
+      path: join10(cleoDir, "brain.db"),
       targetScope: "project"
     },
     {
       name: "conduit",
-      path: join9(cleoDir, "conduit.db"),
+      path: join10(cleoDir, "conduit.db"),
       targetScope: "project"
     },
     // Global-tier — go into consolidated global-scope cleo.db
     {
       name: "nexus",
-      path: join9(cleoHome, "nexus.db"),
+      path: join10(cleoHome, "nexus.db"),
       targetScope: "global"
     },
     {
       name: "signaldock",
-      path: join9(cleoHome, "signaldock.db"),
+      path: join10(cleoHome, "signaldock.db"),
       targetScope: "global"
     },
     {
       name: "skills",
-      path: join9(cleoHome, "skills.db"),
+      path: join10(cleoHome, "skills.db"),
       targetScope: "global"
     }
   ];
@@ -32613,7 +32809,7 @@ function findExistingStaging(cleoDir) {
     const entries = readdirSync2(cleoDir, { withFileTypes: true });
     const stagingDirs = entries.filter((e) => e.isDirectory() && e.name.startsWith("exodus-staging-")).map((e) => e.name).sort().reverse();
     if (stagingDirs.length > 0) {
-      return join9(cleoDir, stagingDirs[0]);
+      return join10(cleoDir, stagingDirs[0]);
     }
   } catch {
   }
@@ -32626,7 +32822,7 @@ function buildExodusPlan(cwd) {
   const availableBytes = getAvailableBytes(cleoDir);
   const diskPreflight = totalSourceBytes === 0 || availableBytes >= 3 * totalSourceBytes;
   const existingStaging = findExistingStaging(cleoDir);
-  const stagingDir = existingStaging ?? join9(cleoDir, deriveStagingDirName());
+  const stagingDir = existingStaging ?? join10(cleoDir, deriveStagingDirName());
   const resumeFromStaging = existingStaging !== null;
   const projectDbPath = resolveDualScopeDbPath("project", cwd);
   const globalDbPath = resolveDualScopeDbPath("global");
@@ -32642,7 +32838,7 @@ function buildExodusPlan(cwd) {
   };
 }
 function sourcesPresent(sources) {
-  return sources.some((s) => existsSync7(s.path));
+  return sources.some((s) => existsSync8(s.path));
 }
 var init_plan2 = __esm({
   "packages/core/src/store/exodus/plan.ts"() {
@@ -32653,11 +32849,11 @@ var init_plan2 = __esm({
 });
 
 // packages/core/src/store/exodus/status.ts
-import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync3 } from "node:fs";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync9, readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync3 } from "node:fs";
+import { join as join11 } from "node:path";
 function readJournal2(stagingDir) {
-  const p = join10(stagingDir, JOURNAL_FILENAME2);
-  if (!existsSync8(p)) return null;
+  const p = join11(stagingDir, JOURNAL_FILENAME2);
+  if (!existsSync9(p)) return null;
   try {
     return JSON.parse(readFileSync4(p, "utf8"));
   } catch {
@@ -32666,7 +32862,7 @@ function readJournal2(stagingDir) {
 }
 function findStagingDirs(cleoDir) {
   try {
-    return readdirSync3(cleoDir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith("exodus-staging-")).map((e) => join10(cleoDir, e.name)).sort().reverse();
+    return readdirSync3(cleoDir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith("exodus-staging-")).map((e) => join11(cleoDir, e.name)).sort().reverse();
   } catch {
     return [];
   }
@@ -32689,15 +32885,15 @@ function runExodusStatus(cwd) {
   const sourcesInfo = plan.sources.map((s) => ({
     name: s.name,
     path: s.path,
-    exists: existsSync8(s.path),
+    exists: existsSync9(s.path),
     bytes: safeBytes(s.path)
   }));
   return {
     hasStaging: latestStaging !== null,
     stagingDir: latestStaging,
     journal,
-    projectDbExists: existsSync8(projectDbPath),
-    globalDbExists: existsSync8(globalDbPath),
+    projectDbExists: existsSync9(projectDbPath),
+    globalDbExists: existsSync9(globalDbPath),
     sourcesPresent: sourcesInfo.some((s) => s.exists),
     sources: sourcesInfo
   };
@@ -32714,7 +32910,7 @@ var init_status = __esm({
 });
 
 // packages/core/src/store/exodus/verify-migration.ts
-import { existsSync as existsSync9 } from "node:fs";
+import { existsSync as existsSync10 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 function orderByClause(db, tableName) {
   try {
@@ -32737,14 +32933,15 @@ function computeTableDigest(db, tableName, columns) {
     rows = db.prepare(`SELECT ${selectClause} FROM "${tableName}" ORDER BY ${orderBy}`).all();
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    log2.warn(
+    log3.warn(
       { tableName, err: msg },
       "computeTableDigest: SELECT failed (possibly a virtual/FTS table) \u2014 treating as 0 rows"
     );
     return { count: 0, hash: "" };
   }
   for (const row of rows) {
-    hasher.update(JSON.stringify(row));
+    const rowObj = row;
+    hasher.update(JSON.stringify(rowObj, Object.keys(rowObj).sort()));
   }
   return {
     count: rows.length,
@@ -32849,7 +33046,7 @@ function foreignKeyCheck(db, scope) {
   try {
     const rows = db.prepare("PRAGMA foreign_key_check").all();
     if (rows.length > 0) {
-      log2.warn(
+      log3.warn(
         { scope, count: rows.length, sample: rows.slice(0, 5) },
         `verifyMigration: PRAGMA foreign_key_check found ${rows.length} orphan row(s)`
       );
@@ -32861,7 +33058,7 @@ function foreignKeyCheck(db, scope) {
       fkid: r.fkid
     }));
   } catch (err) {
-    log2.warn({ scope, err }, "verifyMigration: PRAGMA foreign_key_check failed (non-fatal)");
+    log3.warn({ scope, err }, "verifyMigration: PRAGMA foreign_key_check failed (non-fatal)");
     return [];
   }
 }
@@ -32898,13 +33095,13 @@ function sourceOrphanSignatures(db, sourceName, scope) {
     const rows = db.prepare("PRAGMA foreign_key_check").all();
     for (const r of rows) sigs.add(orphanSignature(db, r, sourceName));
     if (rows.length > 0) {
-      log2.warn(
+      log3.warn(
         { scope, count: rows.length, sample: rows.slice(0, 5) },
         `verifyMigration: source already has ${rows.length} pre-existing FK orphan(s) \u2014 these are tolerated (carried forward losslessly, flagged for data-hygiene)`
       );
     }
   } catch (err) {
-    log2.warn({ scope, err }, "verifyMigration: source PRAGMA foreign_key_check failed (non-fatal)");
+    log3.warn({ scope, err }, "verifyMigration: source PRAGMA foreign_key_check failed (non-fatal)");
   }
   return sigs;
 }
@@ -32916,7 +33113,7 @@ function verifyMigration(sources, projectDbPath, globalDbPath, onProgress) {
   const preExistingForeignKeyViolations = [];
   const failureLines = [];
   const sourceOrphanSigs = /* @__PURE__ */ new Set();
-  if (!existsSync9(projectDbPath)) {
+  if (!existsSync10(projectDbPath)) {
     return {
       ok: false,
       tables: [],
@@ -32927,7 +33124,7 @@ function verifyMigration(sources, projectDbPath, globalDbPath, onProgress) {
       error: `Consolidated project cleo.db not found at ${projectDbPath}. Run 'cleo exodus migrate' first.`
     };
   }
-  if (!existsSync9(globalDbPath)) {
+  if (!existsSync10(globalDbPath)) {
     return {
       ok: false,
       tables: [],
@@ -32942,7 +33139,7 @@ function verifyMigration(sources, projectDbPath, globalDbPath, onProgress) {
   const globalSnap = openCleoDbSnapshot(globalDbPath, { readOnly: true });
   try {
     for (const src of sources) {
-      if (!existsSync9(src.path)) {
+      if (!existsSync10(src.path)) {
         onProgress?.(`Skipping ${src.name} (not present)`);
         continue;
       }
@@ -33021,7 +33218,7 @@ function verifyMigration(sources, projectDbPath, globalDbPath, onProgress) {
               `[${scope}] ${src.name}.${legacyTableName} \u2192 ${targetTableName}: DEFICIT \u2014 source=${srcDigest.count} rows, target=${tgtDigest.count} rows (${srcDigest.count - tgtDigest.count} missing), hashMatch=${hashMatch}`
             );
           } else if (tgtDigest.count > srcDigest.count) {
-            log2.warn(
+            log3.warn(
               {
                 scope,
                 source: src.name,
@@ -33071,7 +33268,7 @@ function verifyMigration(sources, projectDbPath, globalDbPath, onProgress) {
       }
     }
     if (preExistingForeignKeyViolations.length > 0) {
-      log2.warn(
+      log3.warn(
         {
           count: preExistingForeignKeyViolations.length,
           sample: preExistingForeignKeyViolations.slice(0, 5)
@@ -33081,7 +33278,7 @@ function verifyMigration(sources, projectDbPath, globalDbPath, onProgress) {
     }
   } catch (err) {
     const error = err instanceof Error ? err.message : String(err);
-    log2.error({ err }, "verifyMigration failed");
+    log3.error({ err }, "verifyMigration failed");
     return {
       ok: false,
       tables,
@@ -33098,7 +33295,7 @@ function verifyMigration(sources, projectDbPath, globalDbPath, onProgress) {
   if (failureLines.length > 0) {
     const error = `verifyMigration FAILED: ${failureLines.length} issue(s):
 ${failureLines.map((l) => `  \u2022 ${l}`).join("\n")}`;
-    log2.error({ failureCount: failureLines.length }, error);
+    log3.error({ failureCount: failureLines.length }, error);
     return {
       ok: false,
       tables,
@@ -33118,7 +33315,7 @@ ${failureLines.map((l) => `  \u2022 ${l}`).join("\n")}`;
     enumDrift
   };
 }
-var log2, _require, CHECK_ENUM_REGEX;
+var log3, _require, CHECK_ENUM_REGEX;
 var init_verify_migration = __esm({
   "packages/core/src/store/exodus/verify-migration.ts"() {
     "use strict";
@@ -33126,7 +33323,7 @@ var init_verify_migration = __esm({
     init_logger2();
     init_open_cleo_db();
     init_table_name_map();
-    log2 = getLogger("verify-migration");
+    log3 = getLogger("verify-migration");
     _require = createRequire3(import.meta.url);
     CHECK_ENUM_REGEX = /CHECK\s*\(\s*"([^"]+)"\s+(?:IS\s+NULL\s+OR\s+"[^"]+"\s+)?IN\s*\(([^)]*)\)\s*\)/gi;
   }
@@ -33166,9 +33363,16 @@ var init_verify = __esm({
 var exodus_exports = {};
 __export(exodus_exports, {
   EXODUS_TARGET_SCHEMA_VERSION: () => EXODUS_TARGET_SCHEMA_VERSION,
+  archiveMigratedSources: () => archiveMigratedSources,
+  archiveSourceDb: () => archiveSourceDb,
+  archiveStrandedResidue: () => archiveStrandedResidue,
   buildExodusPlan: () => buildExodusPlan,
   clearExodusJournal: () => clearExodusJournal,
   deriveStagingDirName: () => deriveStagingDirName,
+  detectStrandedResidue: () => detectStrandedResidue,
+  exodusArchiveDir: () => exodusArchiveDir,
+  exodusMarkerPath: () => exodusMarkerPath,
+  hasExodusCompleteMarker: () => hasExodusCompleteMarker,
   isDerivedOrInternalTable: () => isDerivedOrInternalTable,
   resolveConsolidatedTableName: () => resolveConsolidatedTableName,
   reverseLookup: () => reverseLookup,
@@ -33176,11 +33380,13 @@ __export(exodus_exports, {
   runExodusStatus: () => runExodusStatus,
   runExodusVerify: () => runExodusVerify,
   sourcesPresent: () => sourcesPresent,
-  verifyMigration: () => verifyMigration
+  verifyMigration: () => verifyMigration,
+  writeExodusCompleteMarker: () => writeExodusCompleteMarker
 });
 var init_exodus = __esm({
   "packages/core/src/store/exodus/index.ts"() {
     "use strict";
+    init_archive2();
     init_migrate();
     init_plan2();
     init_status();
@@ -33198,7 +33404,7 @@ __export(on_open_exports, {
   isDataContinuityOk: () => isDataContinuityOk,
   maybeRunExodusOnOpen: () => maybeRunExodusOnOpen
 });
-import { existsSync as existsSync10 } from "node:fs";
+import { existsSync as existsSync11 } from "node:fs";
 function isDisabledByEnv() {
   const v = process.env.CLEO_DISABLE_EXODUS_ON_OPEN;
   return v === "1" || v === "true";
@@ -33224,7 +33430,7 @@ function rollbackConsolidatedToEmpty(nativeDb, scope) {
       "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '__drizzle_%'"
     ).all().map((r) => r.name);
   } catch (err) {
-    log3.error({ err, scope }, "exodus-on-open: failed to enumerate tables for rollback");
+    log4.error({ err, scope }, "exodus-on-open: failed to enumerate tables for rollback");
     return;
   }
   try {
@@ -33234,7 +33440,7 @@ function rollbackConsolidatedToEmpty(nativeDb, scope) {
       try {
         nativeDb.exec(`DELETE FROM "${table}"`);
       } catch (err) {
-        log3.warn({ err, table, scope }, "exodus-on-open: failed to clear table during rollback");
+        log4.warn({ err, table, scope }, "exodus-on-open: failed to clear table during rollback");
       }
     }
     nativeDb.exec("COMMIT");
@@ -33243,7 +33449,7 @@ function rollbackConsolidatedToEmpty(nativeDb, scope) {
       nativeDb.exec("ROLLBACK");
     } catch {
     }
-    log3.error({ err, scope }, "exodus-on-open: rollback transaction failed");
+    log4.error({ err, scope }, "exodus-on-open: rollback transaction failed");
   } finally {
     try {
       nativeDb.exec("PRAGMA foreign_keys = ON");
@@ -33251,20 +33457,27 @@ function rollbackConsolidatedToEmpty(nativeDb, scope) {
     }
   }
 }
-async function rollbackBothScopes(scope) {
-  const { openDualScopeDb: openDualScopeDb2 } = await Promise.resolve().then(() => (init_dual_scope_db(), dual_scope_db_exports));
+async function rollbackBothScopes(scope, projectDbPath, globalDbPath) {
+  const { openDualScopeDbAtPath: openDualScopeDbAtPath2 } = await Promise.resolve().then(() => (init_dual_scope_db(), dual_scope_db_exports));
   for (const s of ["project", "global"]) {
+    const path2 = s === "project" ? projectDbPath : globalDbPath;
+    let handle = null;
     try {
-      const handle = s === "project" ? await openDualScopeDb2("project") : await openDualScopeDb2("global");
+      handle = s === "project" ? await openDualScopeDbAtPath2("project", path2, void 0, { dedicated: true }) : await openDualScopeDbAtPath2("global", path2, void 0, { dedicated: true });
       const native = handle.db.$client;
       if (native) {
         rollbackConsolidatedToEmpty(native, s);
       }
     } catch (err) {
-      log3.warn(
+      log4.warn(
         { err, scope: s, openingScope: scope },
         "exodus-on-open: could not roll back scope (best-effort)"
       );
+    } finally {
+      try {
+        handle?.close();
+      } catch {
+      }
     }
   }
 }
@@ -33272,7 +33485,7 @@ function isDataContinuityOk(result) {
   const deficits = result.tables.filter((t) => t.targetCount < t.sourceCount);
   const surpluses = result.tables.filter((t) => t.targetCount > t.sourceCount);
   if (surpluses.length > 0) {
-    log3.warn(
+    log4.warn(
       {
         surpluses: surpluses.map((t) => ({
           table: t.targetTable,
@@ -33294,13 +33507,19 @@ async function maybeRunExodusOnOpen(scope, dbPath, nativeDb, cwd) {
   if (isDisabledByEnv()) {
     return { outcome: "skipped", reason: "CLEO_DISABLE_EXODUS_ON_OPEN set" };
   }
+  if (hasExodusCompleteMarker(scope, cwd)) {
+    return {
+      outcome: "skipped",
+      reason: "exodus completion marker present \u2014 scope already migrated (cutover sealed)"
+    };
+  }
   if (!consolidatedIsEmpty(nativeDb, scope)) {
     return { outcome: "skipped", reason: "consolidated cleo.db already populated" };
   }
   const { buildExodusPlan: buildExodusPlan2, runExodusMigrate: runExodusMigrate2, verifyMigration: verifyMigration2, clearExodusJournal: clearExodusJournal2 } = await Promise.resolve().then(() => (init_exodus(), exodus_exports));
   const plan = buildExodusPlan2(cwd);
   const scopeSources = plan.sources.filter((s) => s.targetScope === scope);
-  if (!scopeSources.some((s) => existsSync10(s.path))) {
+  if (!scopeSources.some((s) => existsSync11(s.path))) {
     return {
       outcome: "skipped",
       reason: `no legacy ${scope}-scope source DBs present (fresh install or cross-scope-only)`
@@ -33313,11 +33532,11 @@ async function maybeRunExodusOnOpen(scope, dbPath, nativeDb, cwd) {
       if (!consolidatedIsEmpty(nativeDb, scope)) {
         return { outcome: "skipped", reason: "migrated by a concurrent process (lock winner)" };
       }
-      log3.info(
+      log4.info(
         {
           scope,
           dbPath,
-          sources: plan.sources.filter((s) => existsSync10(s.path)).map((s) => s.name)
+          sources: plan.sources.filter((s) => existsSync11(s.path)).map((s) => s.name)
         },
         "exodus-on-open: consolidated cleo.db is empty and legacy data present \u2014 auto-migrating"
       );
@@ -33326,23 +33545,23 @@ async function maybeRunExodusOnOpen(scope, dbPath, nativeDb, cwd) {
         const migrateResult = await runExodusMigrate2(
           plan,
           false,
-          (msg) => log3.debug({ scope }, `exodus-on-open: ${msg}`)
+          (msg) => log4.debug({ scope }, `exodus-on-open: ${msg}`)
         );
         if (!migrateResult.ok) {
-          await rollbackBothScopes(scope);
+          await rollbackBothScopes(scope, plan.projectDbPath, plan.globalDbPath);
           clearExodusJournal2(migrateResult.stagingDir);
           const reason = `migration failed: ${migrateResult.error ?? "unknown error"} \u2014 legacy DBs kept as source`;
-          log3.error({ scope, error: migrateResult.error }, `exodus-on-open: ${reason}`);
+          log4.error({ scope, error: migrateResult.error }, `exodus-on-open: ${reason}`);
           return { outcome: "aborted", reason };
         }
         const verifyResult = verifyMigration2(
           plan.sources,
           plan.projectDbPath,
           plan.globalDbPath,
-          (msg) => log3.debug({ scope }, `exodus-on-open verify: ${msg}`)
+          (msg) => log4.debug({ scope }, `exodus-on-open verify: ${msg}`)
         );
         if (!verifyResult.ok) {
-          log3.warn(
+          log4.warn(
             {
               scope,
               enumDrift: verifyResult.enumDrift.length,
@@ -33352,11 +33571,11 @@ async function maybeRunExodusOnOpen(scope, dbPath, nativeDb, cwd) {
           );
         }
         if (!isDataContinuityOk(verifyResult)) {
-          await rollbackBothScopes(scope);
+          await rollbackBothScopes(scope, plan.projectDbPath, plan.globalDbPath);
           clearExodusJournal2(plan.stagingDir);
           const deficits = verifyResult.tables.filter((t) => t.targetCount < t.sourceCount).map((t) => `${t.targetTable}(${t.sourceCount}\u2192${t.targetCount})`);
           const reason = `parity verification failed \u2014 cutover aborted, legacy DBs kept as source. count deficits: [${deficits.join(", ")}]; INTRODUCED fk orphans: ${verifyResult.introducedForeignKeyViolations.length} (pre-existing source orphans tolerated: ${verifyResult.preExistingForeignKeyViolations.length}). ` + `${verifyResult.error ?? ""}`.trim();
-          log3.error(
+          log4.error(
             {
               scope,
               countDeficits: deficits,
@@ -33368,10 +33587,27 @@ async function maybeRunExodusOnOpen(scope, dbPath, nativeDb, cwd) {
           return { outcome: "aborted", reason };
         }
         const rowsCopied = migrateResult.tables.filter((t) => !t.skipped).reduce((n, t) => n + t.rowsCopied, 0);
-        log3.info(
+        log4.info(
           { scope, rowsCopied, tables: migrateResult.tables.length },
           "exodus-on-open: parity verified \u2014 legacy data migrated into consolidated cleo.db"
         );
+        try {
+          const consumed = plan.sources.filter((s) => existsSync11(s.path));
+          const archiveResult = archiveMigratedSources(consumed, cwd);
+          log4.info(
+            {
+              scope,
+              archived: archiveResult.sources.filter((s) => s.action === "archived").length,
+              markersWritten: archiveResult.markersWritten
+            },
+            "exodus-on-open: archived legacy sources + sealed completion marker(s)"
+          );
+        } catch (err) {
+          log4.error(
+            { err, scope },
+            "exodus-on-open: post-migration archive/marker step failed (migration itself succeeded \u2014 legacy DBs left in place, will be re-checked by `cleo doctor exodus-residue`)"
+          );
+        }
         return {
           outcome: "migrated",
           reason: `migrated ${rowsCopied} rows across ${migrateResult.tables.length} tables; parity verified`,
@@ -33389,13 +33625,14 @@ async function maybeRunExodusOnOpen(scope, dbPath, nativeDb, cwd) {
 function _isExodusInProgress() {
   return _exodusInProgress;
 }
-var log3, _exodusInProgress;
+var log4, _exodusInProgress;
 var init_on_open = __esm({
   "packages/core/src/store/exodus/on-open.ts"() {
     "use strict";
     init_logger2();
     init_lock();
-    log3 = getLogger("exodus-on-open");
+    init_archive2();
+    log4 = getLogger("exodus-on-open");
     _exodusInProgress = false;
   }
 });
@@ -33410,17 +33647,17 @@ __export(dual_scope_db_exports, {
   resolveDualScopeDbPath: () => resolveDualScopeDbPath,
   upsertIdempotent: () => upsertIdempotent
 });
-import { existsSync as existsSync11, mkdirSync as mkdirSync2 } from "node:fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync3 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { dirname as dirname5, join as join11 } from "node:path";
+import { dirname as dirname5, join as join12 } from "node:path";
 function cacheKey(scope, dbPath) {
   return `${scope}::${dbPath}`;
 }
 function resolveDualScopeDbPath(scope, cwd) {
   if (scope === "project") {
-    return join11(resolveCleoDir(cwd), "cleo.db");
+    return join12(resolveCleoDir(cwd), "cleo.db");
   }
-  return join11(getCleoHome(), "cleo.db");
+  return join12(getCleoHome(), "cleo.db");
 }
 function migrationsSetName(scope) {
   return scope === "project" ? "drizzle-cleo-project" : "drizzle-cleo-global";
@@ -33458,21 +33695,61 @@ async function openDualScopeDb(scope, cwd) {
   const dbPath = resolveDualScopeDbPath(scope, cwd);
   return scope === "project" ? openDualScopeDbAtPath("project", dbPath, cwd) : openDualScopeDbAtPath("global", dbPath, cwd);
 }
-async function openDualScopeDbAtPath(scope, dbPath, exodusCwd) {
+async function openDedicatedDualScopeDb(scope, dbPath, log8) {
+  log8.debug({ scope, dbPath }, "opening DEDICATED (non-cached) dual-scope cleo.db (T11782 FIX D)");
+  const dir = dirname5(dbPath);
+  if (!existsSync12(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  const DatabaseSyncCtor = getDatabaseSyncCtor();
+  const nativeDb = new DatabaseSyncCtor(dbPath, { allowExtension: true });
+  applyPerfPragmas(nativeDb);
+  const schema = scope === "project" ? await loadProjectSchema() : await loadGlobalSchema();
+  const drizzle2 = getDrizzle();
+  const db = drizzle2({ client: nativeDb, schema });
+  const migrationsFolder = resolveCorePackageMigrationsFolder(migrationsSetName(scope));
+  reconcileJournal(nativeDb, migrationsFolder, existenceTable(scope), `dual-scope-db[${scope}]`);
+  migrateWithRetry(
+    db,
+    migrationsFolder,
+    nativeDb,
+    existenceTable(scope),
+    `dual-scope-db[${scope}]`
+  );
+  log8.debug({ scope, dbPath }, "DEDICATED dual-scope cleo.db ready (T11782 FIX D)");
+  return {
+    db,
+    scope,
+    dbPath,
+    close() {
+      try {
+        nativeDb.close();
+      } catch {
+      }
+    }
+  };
+}
+async function openDualScopeDbAtPath(scope, dbPath, exodusCwd, options) {
+  const dedicated = options?.dedicated === true;
   const key = cacheKey(scope, dbPath);
-  const existing = _cache.get(key);
-  if (existing) {
-    if (existing.initPromise) {
-      return existing.initPromise;
+  if (!dedicated) {
+    const existing = _cache.get(key);
+    if (existing) {
+      if (existing.initPromise) {
+        return existing.initPromise;
+      }
+      return existing.handle;
     }
-    return existing.handle;
   }
-  const log7 = getLogger("dual-scope-db");
+  const log8 = getLogger("dual-scope-db");
+  if (dedicated) {
+    return openDedicatedDualScopeDb(scope, dbPath, log8);
+  }
   const initPromise = (async () => {
-    log7.debug({ scope, dbPath }, "opening dual-scope cleo.db");
+    log8.debug({ scope, dbPath }, "opening dual-scope cleo.db");
     const dir = dirname5(dbPath);
-    if (!existsSync11(dir)) {
-      mkdirSync2(dir, { recursive: true });
+    if (!existsSync12(dir)) {
+      mkdirSync3(dir, { recursive: true });
     }
     const DatabaseSyncCtor = getDatabaseSyncCtor();
     const nativeDb = new DatabaseSyncCtor(dbPath, { allowExtension: true });
@@ -33489,7 +33766,7 @@ async function openDualScopeDbAtPath(scope, dbPath, exodusCwd) {
       existenceTable(scope),
       `dual-scope-db[${scope}]`
     );
-    log7.debug({ scope, dbPath }, "dual-scope cleo.db ready");
+    log8.debug({ scope, dbPath }, "dual-scope cleo.db ready");
     const handle = {
       db,
       scope,
@@ -33513,7 +33790,7 @@ async function openDualScopeDbAtPath(scope, dbPath, exodusCwd) {
         const result = await maybeRunExodusOnOpen2(scope, dbPath, nativeDb, exodusCwd);
         if (result.outcome === "migrated" || result.outcome === "aborted") {
           if (result.outcome === "aborted") {
-            log7.warn(
+            log8.warn(
               { scope, reason: result.reason },
               "exodus-on-open aborted; consolidated cleo.db left empty, legacy kept as source"
             );
@@ -33521,7 +33798,7 @@ async function openDualScopeDbAtPath(scope, dbPath, exodusCwd) {
           return scope === "project" ? openDualScopeDbAtPath("project", dbPath) : openDualScopeDbAtPath("global", dbPath);
         }
       } catch (err) {
-        log7.warn(
+        log8.warn(
           { err, scope },
           "exodus-on-open hook failed (non-fatal); re-opening consolidated handle"
         );
@@ -34105,8 +34382,8 @@ __export(nexus_sqlite_exports, {
   resetNexusDbState: () => resetNexusDbState,
   resolveNexusMigrationsFolder: () => resolveNexusMigrationsFolder
 });
-import { copyFileSync as copyFileSync3, existsSync as existsSync12 } from "node:fs";
-import { join as join12 } from "node:path";
+import { copyFileSync as copyFileSync4, existsSync as existsSync13 } from "node:fs";
+import { join as join13 } from "node:path";
 function getNexusDbPath(cwd) {
   return resolveDualScopeDbPath("project", cwd);
 }
@@ -34138,7 +34415,7 @@ function resolveNexusMigrationsFolder() {
   return resolveCorePackageMigrationsFolder("drizzle-nexus");
 }
 function getNestedNexusSentinelPath() {
-  return join12(getCleoHome(), "nexus", NESTED_NEXUS_SENTINEL);
+  return join13(getCleoHome(), "nexus", NESTED_NEXUS_SENTINEL);
 }
 function detectAndWarnOnNestedNexus() {
   let nestedPath;
@@ -34147,12 +34424,12 @@ function detectAndWarnOnNestedNexus() {
   } catch {
     return false;
   }
-  if (!existsSync12(nestedPath)) return false;
+  if (!existsSync13(nestedPath)) return false;
   if (_warnedNestedPaths.has(nestedPath)) return false;
   _warnedNestedPaths.add(nestedPath);
   const canonicalPath = getNexusDbPath();
-  const log7 = getLogger("nexus-sqlite");
-  log7.warn(
+  const log8 = getLogger("nexus-sqlite");
+  log8.warn(
     {
       nestedPath,
       canonicalPath,
@@ -34306,9 +34583,9 @@ function runNexusMigrations(nativeDb, db) {
   const migrationsFolder = resolveNexusMigrationsFolder();
   if (tableExists3(nativeDb, "nexus_nodes") && _nexusDbPath) {
     const backupPath = _nexusDbPath.replace(/\.db$/, "-pre-cleo.db.bak");
-    if (!existsSync12(backupPath)) {
+    if (!existsSync13(backupPath)) {
       try {
-        copyFileSync3(_nexusDbPath, backupPath);
+        copyFileSync4(_nexusDbPath, backupPath);
       } catch {
       }
     }
@@ -34438,10 +34715,10 @@ var init_nexus_sqlite = __esm({
 
 // packages/core/src/paths.ts
 import { AsyncLocalStorage } from "node:async_hooks";
-import { existsSync as existsSync13, readFileSync as readFileSync5, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync5, statSync as statSync4 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
 import { homedir } from "node:os";
-import { basename as basename3, dirname as dirname6, join as join13, resolve as resolve3 } from "node:path";
+import { basename as basename4, dirname as dirname6, join as join14, resolve as resolve3 } from "node:path";
 import {
   computeCanonicalProjectId as _computeCanonicalProjectId,
   getCanonicalTemplatesTildePath as _getCanonicalTemplatesTildePath,
@@ -34531,8 +34808,8 @@ function getCleoDirAbsolute(cwd, opts) {
 function _resolveProjectByCwdFromNexus(cwd) {
   try {
     const cleoHome = getCleoHome();
-    const globalDbPath = join13(cleoHome, "cleo.db");
-    if (!existsSync13(globalDbPath)) return null;
+    const globalDbPath = join14(cleoHome, "cleo.db");
+    if (!existsSync14(globalDbPath)) return null;
     const start = resolve3(cwd ?? process.cwd());
     let current = start;
     const DatabaseSync3 = _getDatabaseSyncCtor();
@@ -34571,7 +34848,7 @@ function _findCleoDirRoot(cwd) {
     const isDangerousRoot = current === homeRoot || current === "/" || current === "";
     if (!isDangerousRoot) {
       try {
-        if (statSync4(join13(current, ".cleo")).isDirectory()) {
+        if (statSync4(join14(current, ".cleo")).isDirectory()) {
           return current;
         }
       } catch {
@@ -34586,7 +34863,7 @@ function _findCleoDirRoot(cwd) {
 function resolveCleoDir(cwd) {
   const scope = worktreeScope.getStore();
   if (scope !== void 0) {
-    return join13(scope.worktreeRoot, ".cleo");
+    return join14(scope.worktreeRoot, ".cleo");
   }
   const override = _cleoDirEnvOverride();
   if (override !== null) {
@@ -34594,14 +34871,14 @@ function resolveCleoDir(cwd) {
   }
   const root = _findCleoDirRoot(cwd);
   if (root !== null) {
-    return join13(root, ".cleo");
+    return join14(root, ".cleo");
   }
   const start = resolve3(cwd ?? process.cwd());
   let current = start;
   while (true) {
     const mainRepo = _resolveMainRepoFromGitlink(current);
     if (mainRepo !== null) {
-      return join13(mainRepo, ".cleo");
+      return join14(mainRepo, ".cleo");
     }
     const parent = dirname6(current);
     if (parent === current) {
@@ -34643,9 +34920,9 @@ function _cwdHasGitAncestor(cwd) {
   const start = resolve3(cwd ?? process.cwd());
   let current = start;
   while (true) {
-    const gitMarker = join13(current, ".git");
+    const gitMarker = join14(current, ".git");
     try {
-      if (existsSync13(gitMarker)) {
+      if (existsSync14(gitMarker)) {
         return true;
       }
     } catch {
@@ -34657,8 +34934,8 @@ function _cwdHasGitAncestor(cwd) {
 }
 function _resolveMainRepoFromGitlink(gitlinkDir) {
   try {
-    const gitLinkPath = join13(gitlinkDir, ".git");
-    if (!existsSync13(gitLinkPath)) return null;
+    const gitLinkPath = join14(gitlinkDir, ".git");
+    if (!existsSync14(gitLinkPath)) return null;
     const stat2 = statSync4(gitLinkPath);
     if (!stat2.isFile()) return null;
     const gitLinkContent = readFileSync5(gitLinkPath, "utf-8").trim();
@@ -34666,7 +34943,7 @@ function _resolveMainRepoFromGitlink(gitlinkDir) {
     if (!match) return null;
     const gitdir = match[1].trim();
     const mainRepo = dirname6(dirname6(dirname6(gitdir)));
-    if (existsSync13(join13(mainRepo, ".cleo")) && validateProjectRoot(mainRepo)) {
+    if (existsSync14(join14(mainRepo, ".cleo")) && validateProjectRoot(mainRepo)) {
       return mainRepo;
     }
   } catch {
@@ -34674,18 +34951,18 @@ function _resolveMainRepoFromGitlink(gitlinkDir) {
   return null;
 }
 function validateProjectRoot(candidate) {
-  const cleoDir = join13(candidate, ".cleo");
-  if (!existsSync13(cleoDir)) {
+  const cleoDir = join14(candidate, ".cleo");
+  if (!existsSync14(cleoDir)) {
     return false;
   }
-  const projectInfoPath = join13(cleoDir, "project-info.json");
-  if (existsSync13(projectInfoPath)) {
+  const projectInfoPath = join14(cleoDir, "project-info.json");
+  if (existsSync14(projectInfoPath)) {
     try {
       const raw = readFileSync5(projectInfoPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (typeof parsed === "object" && parsed !== null && "projectId" in parsed && typeof parsed["projectId"] === "string" && parsed["projectId"] !== "") {
-        const gitMarker = join13(candidate, ".git");
-        if (existsSync13(gitMarker)) {
+        const gitMarker = join14(candidate, ".git");
+        if (existsSync14(gitMarker)) {
           try {
             if (!statSync4(gitMarker).isDirectory()) {
               return false;
@@ -34699,8 +34976,8 @@ function validateProjectRoot(candidate) {
     } catch {
     }
   }
-  const gitDir = join13(candidate, ".git");
-  if (existsSync13(gitDir)) {
+  const gitDir = join14(candidate, ".git");
+  if (existsSync14(gitDir)) {
     let isRealGitDir = false;
     try {
       const stat2 = statSync4(gitDir);
@@ -34747,16 +35024,16 @@ function getProjectRoot(cwd) {
   const homeRoot = homedir();
   const skippedCleoDirs = [];
   while (true) {
-    const cleoDir = join13(current, ".cleo");
-    const gitDir = join13(current, ".git");
+    const cleoDir = join14(current, ".cleo");
+    const gitDir = join14(current, ".git");
     const isDangerousRoot = current === homeRoot || current === "/" || current === "";
-    if (existsSync13(cleoDir) && !isDangerousRoot) {
+    if (existsSync14(cleoDir) && !isDangerousRoot) {
       if (validateProjectRoot(current)) {
         return current;
       }
       skippedCleoDirs.push(current);
     }
-    if (existsSync13(gitDir) && !isDangerousRoot) {
+    if (existsSync14(gitDir) && !isDangerousRoot) {
       let isRealGitDir = false;
       try {
         isRealGitDir = statSync4(gitDir).isDirectory();
@@ -34801,18 +35078,18 @@ function resolveOrCwd(maybeRoot) {
   return getProjectRoot();
 }
 function getConfigPath(cwd) {
-  return join13(_resolveCleoDir(cwd), "config.json");
+  return join14(_resolveCleoDir(cwd), "config.json");
 }
 function getGlobalConfigPath() {
-  return join13(getCleoHome(), "config.json");
+  return join14(getCleoHome(), "config.json");
 }
 function isAbsolutePath(path2) {
   return _isAbsolutePath(path2);
 }
 function _readProjectNameFromInfo(projectRoot) {
   try {
-    const infoPath = join13(projectRoot, ".cleo", "project-info.json");
-    if (!existsSync13(infoPath)) return void 0;
+    const infoPath = join14(projectRoot, ".cleo", "project-info.json");
+    if (!existsSync14(infoPath)) return void 0;
     const raw = readFileSync5(infoPath, "utf-8");
     const data = JSON.parse(raw);
     return typeof data.name === "string" && data.name.length > 0 ? data.name : void 0;
@@ -34834,12 +35111,12 @@ async function registerProjectOnEncounter(projectRoot, infoProjectId) {
     const existingRows = await db.select().from(projectRegistry2).where(eq10(projectRegistry2.projectId, immutableId)).limit(1);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const resolvedPath = resolve3(projectRoot);
-    const projectName = _readProjectNameFromInfo(resolvedPath) || basename3(projectRoot) || "unnamed";
+    const projectName = _readProjectNameFromInfo(resolvedPath) || basename4(projectRoot) || "unnamed";
     if (existingRows.length > 0) {
       const existingPath = existingRows[0].projectPath;
       if (existingPath !== resolvedPath) {
-        const newBrainDbPath = join13(resolvedPath, ".cleo", "brain.db");
-        const newTasksDbPath = join13(resolvedPath, ".cleo", "tasks.db");
+        const newBrainDbPath = join14(resolvedPath, ".cleo", "brain.db");
+        const newTasksDbPath = join14(resolvedPath, ".cleo", "tasks.db");
         await db.update(projectRegistry2).set({
           projectPath: resolvedPath,
           projectHash: generateProjectHash2(resolvedPath),
@@ -34870,8 +35147,8 @@ async function registerProjectOnEncounter(projectRoot, infoProjectId) {
       lastSync: now,
       taskCount: 0,
       labelsJson: "[]",
-      brainDbPath: join13(resolvedPath, ".cleo", "brain.db"),
-      tasksDbPath: join13(resolvedPath, ".cleo", "tasks.db"),
+      brainDbPath: join14(resolvedPath, ".cleo", "brain.db"),
+      tasksDbPath: join14(resolvedPath, ".cleo", "tasks.db"),
       statsJson: "{}"
     }).onConflictDoNothing();
     const aliases = canonicalResult.legacyAliases ?? [];
@@ -35086,7 +35363,7 @@ __export(config_exports, {
   parseConfigValue: () => parseConfigValue,
   setConfigValue: () => setConfigValue
 });
-import { existsSync as existsSync14 } from "node:fs";
+import { existsSync as existsSync15 } from "node:fs";
 import { mkdir as mkdir3, writeFile } from "node:fs/promises";
 import { dirname as dirname7 } from "node:path";
 function getNestedValue(obj, path2) {
@@ -35210,7 +35487,7 @@ function parseConfigValue(value) {
 }
 async function setConfigValue(key, value, cwd, opts) {
   const configPath = opts?.global ? getGlobalConfigPath() : getConfigPath(cwd);
-  if (!existsSync14(configPath)) {
+  if (!existsSync15(configPath)) {
     const dir = dirname7(configPath);
     await mkdir3(dir, { recursive: true });
     await writeFile(configPath, "{}", "utf-8");
@@ -35224,7 +35501,7 @@ async function setConfigValue(key, value, cwd, opts) {
 async function applyStrictnessPreset(preset, cwd, opts) {
   const definition = STRICTNESS_PRESETS[preset];
   const configPath = opts?.global ? getGlobalConfigPath() : getConfigPath(cwd);
-  if (!existsSync14(configPath)) {
+  if (!existsSync15(configPath)) {
     const dir = dirname7(configPath);
     await mkdir3(dir, { recursive: true });
     await writeFile(configPath, "{}", "utf-8");
@@ -35570,7 +35847,7 @@ function brainTablesAreConsolidatedShape(nativeDb) {
   return createdAt !== void 0 && createdAt.type.toUpperCase() !== "INTEGER";
 }
 function establishLegacyBrainSchema(nativeDb, db) {
-  const log7 = getLogger("brain-schema");
+  const log8 = getLogger("brain-schema");
   if (brainTablesAreConsolidatedShape(nativeDb)) {
     const fkRow = nativeDb.prepare("PRAGMA foreign_keys").get();
     const fkWasOn = fkRow?.foreign_keys === 1;
@@ -35580,7 +35857,7 @@ function establishLegacyBrainSchema(nativeDb, db) {
         try {
           nativeDb.exec(`DROP TABLE IF EXISTS \`${table}\``);
         } catch (err) {
-          log7.warn(
+          log8.warn(
             { table, err },
             "Failed to drop consolidated brain table during legacy rebuild."
           );
@@ -35589,7 +35866,7 @@ function establishLegacyBrainSchema(nativeDb, db) {
     } finally {
       nativeDb.exec(`PRAGMA foreign_keys=${fkWasOn ? "ON" : "OFF"}`);
     }
-    log7.debug(
+    log8.debug(
       { count: CONSOLIDATED_BRAIN_TABLES.length },
       "Dropped consolidated (exodus-target) brain tables \u2014 rebuilding in legacy runtime shape."
     );
@@ -35600,7 +35877,7 @@ function establishLegacyBrainSchema(nativeDb, db) {
       nativeDb,
       migrationsFolder
     );
-    log7.debug(
+    log8.debug(
       { marked, applied },
       "brain consolidated cleo.db reconcile (T11647) \u2014 marked already-present migrations applied + executed the missing unprefixed-table migrations directly."
     );
@@ -36150,7 +36427,7 @@ async function upsertTask(db, row, archiveFields, allowOrphanParent = false) {
       if (allowOrphanParent) {
         row = { ...row, parentId: null };
       } else {
-        log4.warn(
+        log5.warn(
           { taskId: row.id, parentId: row.parentId },
           "upsertTask: parentId references a non-existent task \u2014 parent relationship may be lost"
         );
@@ -36333,13 +36610,13 @@ async function loadRelationsForTasks(db, tasks2) {
     task.relates = relations && relations.length > 0 ? relations : [];
   }
 }
-var log4;
+var log5;
 var init_db_helpers = __esm({
   "packages/core/src/store/db-helpers.ts"() {
     "use strict";
     init_logger2();
     init_tasks_schema();
-    log4 = getLogger("db-helpers");
+    log5 = getLogger("db-helpers");
   }
 });
 
@@ -36397,10 +36674,10 @@ var init_telemetry_schema = __esm({
 });
 
 // packages/core/src/telemetry/sqlite.ts
-import { mkdirSync as mkdirSync3 } from "node:fs";
-import { dirname as dirname8, join as join14 } from "node:path";
+import { mkdirSync as mkdirSync4 } from "node:fs";
+import { dirname as dirname8, join as join15 } from "node:path";
 function getTelemetryDbPath() {
-  return join14(getCleoHome(), DB_FILENAME);
+  return join15(getCleoHome(), DB_FILENAME);
 }
 function resolveTelemetryMigrationsFolder() {
   return resolveCorePackageMigrationsFolder("drizzle-telemetry");
@@ -36448,7 +36725,7 @@ async function getTelemetryDb() {
   _initPromise2 = (async () => {
     const dbPath = requestedPath;
     _dbPath2 = dbPath;
-    mkdirSync3(dirname8(dbPath), { recursive: true });
+    mkdirSync4(dirname8(dbPath), { recursive: true });
     const nativeDb = openNativeDatabase(dbPath);
     _nativeDb2 = nativeDb;
     const db = drizzle({ client: nativeDb, schema: telemetry_schema_exports });
@@ -36481,11 +36758,11 @@ var init_sqlite2 = __esm({
 });
 
 // packages/core/src/store/agent-registry-store.ts
-import { existsSync as existsSync15 } from "node:fs";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync16 } from "node:fs";
+import { join as join16 } from "node:path";
 function getGlobalAgentRegistryDbPath() {
   const cleoHome = getCleoHome();
-  const dbPath = join15(cleoHome, "cleo.db");
+  const dbPath = join16(cleoHome, "cleo.db");
   if (!dbPath.startsWith(cleoHome)) {
     throw new Error(
       `BUG: getGlobalAgentRegistryDbPath() resolved to "${dbPath}" which is NOT under getCleoHome() ("${cleoHome}"). The Agent Registry is global-only per ADR-037. This indicates a code path that bypasses path resolution \u2014 fix the caller, do not suppress this error.`
@@ -36526,7 +36803,7 @@ function writeAgentRegistrySchemaVersionSentinel(db) {
 }
 async function ensureGlobalAgentRegistryDb() {
   const dbPath = getGlobalAgentRegistryDbPath();
-  const alreadyExists = existsSync15(dbPath);
+  const alreadyExists = existsSync16(dbPath);
   const dualHandle = await openDualScopeDb("global");
   const nativeDb = dualHandle.db.$client ?? null;
   if (!nativeDb) {
@@ -36575,7 +36852,7 @@ var init_agent_registry_store = __esm({
 });
 
 // packages/core/src/store/conduit-sqlite.ts
-import { existsSync as existsSync16 } from "node:fs";
+import { existsSync as existsSync17 } from "node:fs";
 import { createRequire as createRequire7 } from "node:module";
 function _getDrizzle2() {
   if (_drizzle3 === null) {
@@ -36606,7 +36883,7 @@ async function ensureConduitDb(projectRoot) {
   }
   if (_initPromise3) return _initPromise3;
   _initPromise3 = (async () => {
-    const alreadyExists = existsSync16(dbPath);
+    const alreadyExists = existsSync17(dbPath);
     const dualHandle = await openDualScopeDb("project", projectRoot);
     const nativeDb = dualHandle.db.$client ?? null;
     if (!nativeDb) {
@@ -36826,11 +37103,11 @@ var init_skills_schema = __esm({
 });
 
 // packages/core/src/store/skills-db.ts
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 import { and as and3, eq as eq4 } from "drizzle-orm";
 function getDefaultSkillsDbPath() {
   const cleoHome = getCleoHome();
-  const dbPath = join16(cleoHome, "cleo.db");
+  const dbPath = join17(cleoHome, "cleo.db");
   if (!dbPath.startsWith(cleoHome)) {
     throw new Error(
       `BUG: getDefaultSkillsDbPath() resolved to "${dbPath}" which is NOT under getCleoHome() ("${cleoHome}"). The skills registry is global-only per SG-CLEO-SKILLS-architecture-v3.md \xA74. Fix the caller, do not suppress.`
@@ -36899,14 +37176,14 @@ var init_skills_db = __esm({
 // packages/core/src/store/sqlite-backup.ts
 import {
   chmodSync,
-  copyFileSync as copyFileSync4,
-  existsSync as existsSync17,
-  mkdirSync as mkdirSync4,
+  copyFileSync as copyFileSync5,
+  existsSync as existsSync18,
+  mkdirSync as mkdirSync5,
   readdirSync as readdirSync4,
   statSync as statSync5,
-  unlinkSync as unlinkSync2
+  unlinkSync as unlinkSync3
 } from "node:fs";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 function resolveInventoryPath(entry, cwd) {
   try {
     if (entry.tier === "global") {
@@ -36941,8 +37218,8 @@ async function openAgentRegistryDbForSnapshot() {
 }
 async function openTelemetryDbForSnapshot() {
   try {
-    const path2 = join17(getCleoHome(), "telemetry.db");
-    if (!existsSync17(path2)) return null;
+    const path2 = join18(getCleoHome(), "telemetry.db");
+    if (!existsSync18(path2)) return null;
   } catch {
     return null;
   }
@@ -36957,7 +37234,7 @@ function buildRawFileVacuumOpener(entry) {
   return async (cwd) => {
     const path2 = resolveInventoryPath(entry, cwd);
     if (!path2) return null;
-    if (!existsSync17(path2)) return null;
+    if (!existsSync18(path2)) return null;
     try {
       const { DatabaseSync: DatabaseSync3 } = await import("node:sqlite");
       return new DatabaseSync3(path2, { readOnly: true });
@@ -37047,13 +37324,13 @@ function rotateSnapshots(backupDir, prefix) {
     const pattern = snapshotPattern(prefix);
     const files = readdirSync4(backupDir).filter((f) => pattern.test(f)).map((f) => ({
       name: f,
-      path: join17(backupDir, f),
-      mtimeMs: statSync5(join17(backupDir, f)).mtimeMs
+      path: join18(backupDir, f),
+      mtimeMs: statSync5(join18(backupDir, f)).mtimeMs
     })).sort((a, b) => a.mtimeMs - b.mtimeMs);
     while (files.length >= MAX_SNAPSHOTS) {
       const oldest = files.shift();
       if (!oldest) break;
-      unlinkSync2(oldest.path);
+      unlinkSync3(oldest.path);
     }
   } catch {
   }
@@ -37073,7 +37350,7 @@ async function snapshotOne(target, backupDir, now, cwd) {
     if (!db) return;
     opened = db;
   }
-  const dest = join17(backupDir, `${target.prefix}-${formatTimestamp(now)}.db`);
+  const dest = join18(backupDir, `${target.prefix}-${formatTimestamp(now)}.db`);
   try {
     db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
     rotateSnapshots(backupDir, target.prefix);
@@ -37094,8 +37371,8 @@ async function vacuumIntoBackup(opts = {}) {
   }
   try {
     const cleoDir = getCleoDir(opts.cwd);
-    const backupDir = join17(cleoDir, "backups", "sqlite");
-    mkdirSync4(backupDir, { recursive: true });
+    const backupDir = join18(cleoDir, "backups", "sqlite");
+    mkdirSync5(backupDir, { recursive: true });
     const target = SNAPSHOT_TARGETS.find((t) => t.prefix === prefix);
     if (!target) return;
     await snapshotOne(target, backupDir, /* @__PURE__ */ new Date(), opts.cwd);
@@ -37106,13 +37383,13 @@ async function vacuumIntoBackup(opts = {}) {
 function listSqliteBackupsForPrefix(prefix, cwd) {
   try {
     const cleoDir = getCleoDir(cwd);
-    const backupDir = join17(cleoDir, "backups", "sqlite");
-    if (!existsSync17(backupDir)) return [];
+    const backupDir = join18(cleoDir, "backups", "sqlite");
+    if (!existsSync18(backupDir)) return [];
     const pattern = snapshotPattern(prefix);
     return readdirSync4(backupDir).filter((f) => pattern.test(f)).map((f) => ({
       name: f,
-      path: join17(backupDir, f),
-      mtimeMs: statSync5(join17(backupDir, f)).mtimeMs
+      path: join18(backupDir, f),
+      mtimeMs: statSync5(join18(backupDir, f)).mtimeMs
     })).sort((a, b) => b.mtimeMs - a.mtimeMs);
   } catch {
     return [];
@@ -37168,7 +37445,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 join18, resolve as resolve4, sep } from "node:path";
+import { delimiter, dirname as dirname9, isAbsolute, join as join19, resolve as resolve4, sep } from "node:path";
 function getDbSyncConstructor() {
   if (_ctor === null) {
     const mod = _require5("node:sqlite");
@@ -37189,7 +37466,7 @@ function resolveAbsoluteSafe(p) {
       missingParts.unshift(cursor.slice(parent.length + (parent.endsWith(sep) ? 0 : 1)));
       cursor = parent;
       try {
-        return join18(realpathSync(cursor), ...missingParts);
+        return join19(realpathSync(cursor), ...missingParts);
       } catch {
       }
     }
@@ -37280,6 +37557,7 @@ var init_sqlite_native = __esm({
 var sqlite_exports = {};
 __export(sqlite_exports, {
   SQLITE_SCHEMA_VERSION: () => SQLITE_SCHEMA_VERSION,
+  autoRecoverFromBackup: () => autoRecoverFromBackup,
   closeAllDatabases: () => closeAllDatabases,
   closeDb: () => closeDb,
   dbExists: () => dbExists,
@@ -37294,7 +37572,7 @@ __export(sqlite_exports, {
   resolveMigrationsFolder: () => resolveMigrationsFolder,
   schema: () => tasks_schema_exports
 });
-import { copyFileSync as copyFileSync5, existsSync as existsSync18, renameSync as renameSync2, unlinkSync as unlinkSync3 } from "node:fs";
+import { copyFileSync as copyFileSync6, existsSync as existsSync19, renameSync as renameSync3, unlinkSync as unlinkSync4 } from "node:fs";
 import { createRequire as createRequire9 } from "node:module";
 import { eq as eq5 } from "drizzle-orm";
 function _getDrizzle3() {
@@ -37308,6 +37586,22 @@ function _getDrizzle3() {
 function getDbPath(cwd) {
   return resolveDualScopeDbPath("project", cwd);
 }
+async function recountTasksFromDisk(dbPath) {
+  const { openNativeDatabase: openNativeDatabase2 } = await Promise.resolve().then(() => (init_sqlite_native(), sqlite_native_exports));
+  let probe = null;
+  try {
+    probe = openNativeDatabase2(dbPath, { readonly: true, enableWal: false });
+    const row = probe.prepare("SELECT COUNT(*) as cnt FROM tasks_tasks").get();
+    return row?.cnt ?? 0;
+  } catch {
+    return 0;
+  } finally {
+    try {
+      probe?.close();
+    } catch {
+    }
+  }
+}
 function countBackupTasks(backupDb) {
   for (const table of ["tasks_tasks", "tasks"]) {
     try {
@@ -37320,7 +37614,7 @@ function countBackupTasks(backupDb) {
 }
 async function autoRecoverFromBackup(nativeDb, dbPath, cwd) {
   const { openNativeDatabase: openNativeDatabase2 } = await Promise.resolve().then(() => (init_sqlite_native(), sqlite_native_exports));
-  const log7 = getLogger("sqlite");
+  const log8 = getLogger("sqlite");
   try {
     const countResult = nativeDb.prepare("SELECT COUNT(*) as cnt FROM tasks_tasks").get();
     const taskCount = countResult?.cnt ?? 0;
@@ -37340,36 +37634,56 @@ async function autoRecoverFromBackup(nativeDb, dbPath, cwd) {
     if (backupTaskCount < MIN_BACKUP_TASK_COUNT) {
       return;
     }
-    log7.warn(
-      { dbPath, backupPath: newestBackup.path, backupTasks: backupTaskCount },
-      `Empty database detected with ${backupTaskCount}-task backup available. Auto-recovering from backup. This likely happened because git-tracked WAL/SHM files were overwritten during a branch switch (T5188).`
-    );
-    nativeDb.close();
-    const walPath = dbPath + "-wal";
-    const shmPath = dbPath + "-shm";
-    try {
-      unlinkSync3(walPath);
-    } catch {
-    }
-    try {
-      unlinkSync3(shmPath);
-    } catch {
-    }
-    const tempPath = dbPath + ".recovery-tmp";
-    copyFileSync5(newestBackup.path, tempPath);
-    renameSync2(tempPath, dbPath);
-    log7.info(
-      { dbPath, backupPath: newestBackup.path, restoredTasks: backupTaskCount },
-      "Database auto-recovered from backup successfully."
+    const lockPath2 = dbPath + FIRST_OPEN_LOCK_SUFFIX;
+    await withLock(
+      lockPath2,
+      async () => {
+        const currentTaskCount = await recountTasksFromDisk(dbPath);
+        if (currentTaskCount > 0) {
+          log8.info(
+            { dbPath, currentTaskCount },
+            "Auto-recovery skipped: database was populated by a concurrent process while acquiring the first-open lock (T11662 double-checked re-query)."
+          );
+          return;
+        }
+        log8.warn(
+          { dbPath, backupPath: newestBackup.path, backupTasks: backupTaskCount },
+          `Empty database detected with ${backupTaskCount}-task backup available. Auto-recovering from backup. This likely happened because git-tracked WAL/SHM files were overwritten during a branch switch (T5188).`
+        );
+        if (nativeDb.isOpen) {
+          nativeDb.close();
+        }
+        const walPath = dbPath + "-wal";
+        const shmPath = dbPath + "-shm";
+        try {
+          unlinkSync4(walPath);
+        } catch {
+        }
+        try {
+          unlinkSync4(shmPath);
+        } catch {
+        }
+        const tempPath = dbPath + ".recovery-tmp";
+        copyFileSync6(newestBackup.path, tempPath);
+        renameSync3(tempPath, dbPath);
+        log8.info(
+          { dbPath, backupPath: newestBackup.path, restoredTasks: backupTaskCount },
+          "Database auto-recovered from backup successfully."
+        );
+        _resetDualScopeDbCache();
+        const restoredNativeDb = openNativeDatabase2(dbPath);
+        _nativeDb3 = restoredNativeDb;
+        const restoredDb = _getDrizzle3()({ client: restoredNativeDb, schema: tasks_schema_exports });
+        runMigrations(restoredNativeDb, restoredDb);
+        _db3 = restoredDb;
+      },
+      // 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
+      // auto-recovery must wait rather than time out and race.
+      { stale: 6e5, retries: 30 }
     );
-    _resetDualScopeDbCache();
-    const restoredNativeDb = openNativeDatabase2(dbPath);
-    _nativeDb3 = restoredNativeDb;
-    const restoredDb = _getDrizzle3()({ client: restoredNativeDb, schema: tasks_schema_exports });
-    runMigrations(restoredNativeDb, restoredDb);
-    _db3 = restoredDb;
   } catch (err) {
-    log7.error({ err, dbPath }, "Auto-recovery from backup failed. Continuing with empty database.");
+    log8.error({ err, dbPath }, "Auto-recovery from backup failed. Continuing with empty database.");
   }
 }
 async function getDb(cwd) {
@@ -37469,7 +37783,7 @@ async function getSchemaVersion(cwd) {
   return result[0]?.value ?? null;
 }
 function dbExists(cwd) {
-  return existsSync18(resolveDualScopeDbPath("project", cwd));
+  return existsSync19(resolveDualScopeDbPath("project", cwd));
 }
 function getNativeDb() {
   return _nativeDb3;
@@ -37490,12 +37804,13 @@ async function closeAllDatabases() {
   } catch {
   }
 }
-var _drizzle4, SQLITE_SCHEMA_VERSION, SCHEMA_VERSION, _db3, _nativeDb3, _dbPath3, _initPromise4, MIN_BACKUP_TASK_COUNT, REQUIRED_TASK_COLUMNS, REQUIRED_SESSION_COLUMNS;
+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 init_sqlite3 = __esm({
   "packages/core/src/store/sqlite.ts"() {
     "use strict";
     init_logger2();
     init_dual_scope_db();
+    init_lock();
     init_migration_manager();
     init_resolve_migrations_folder();
     init_sqlite_backup();
@@ -37511,6 +37826,7 @@ var init_sqlite3 = __esm({
     _dbPath3 = null;
     _initPromise4 = null;
     MIN_BACKUP_TASK_COUNT = 10;
+    FIRST_OPEN_LOCK_SUFFIX = ".exodus-on-open.lock";
     REQUIRED_TASK_COLUMNS = [
       { name: "pipeline_stage", ddl: "text" },
       { name: "assignee", ddl: "text" }
@@ -38655,13 +38971,13 @@ var init_sqlite_data_accessor = __esm({
 });
 
 // packages/core/src/sequence/index.ts
-import { existsSync as existsSync19, readFileSync as readFileSync6, renameSync as renameSync3 } from "node:fs";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync20, readFileSync as readFileSync6, renameSync as renameSync4 } from "node:fs";
+import { join as join20 } from "node:path";
 function getLegacySequenceJsonPath(cwd) {
-  return join19(resolveOrCwd(cwd), ".cleo", ".sequence.json");
+  return join20(resolveOrCwd(cwd), ".cleo", ".sequence.json");
 }
 function getLegacySequencePath(cwd) {
-  return join19(resolveOrCwd(cwd), ".cleo", ".sequence");
+  return join20(resolveOrCwd(cwd), ".cleo", ".sequence");
 }
 function isValidSequenceState(value) {
   if (!value || typeof value !== "object") return false;
@@ -38672,7 +38988,7 @@ function isSeedSequence(value) {
   return value.counter === 0 && value.lastId === "T000" && value.checksum === "seed";
 }
 function readLegacySequenceFile(path2) {
-  if (!existsSync19(path2)) return null;
+  if (!existsSync20(path2)) return null;
   try {
     const parsed = JSON.parse(readFileSync6(path2, "utf-8"));
     return isValidSequenceState(parsed) ? parsed : null;
@@ -38681,14 +38997,14 @@ function readLegacySequenceFile(path2) {
   }
 }
 function renameLegacyFile(path2) {
-  if (!existsSync19(path2)) return;
+  if (!existsSync20(path2)) return;
   const migratedPath = `${path2}.migrated`;
   try {
-    if (!existsSync19(migratedPath)) {
-      renameSync3(path2, migratedPath);
+    if (!existsSync20(migratedPath)) {
+      renameSync4(path2, migratedPath);
       return;
     }
-    renameSync3(path2, `${migratedPath}.${Date.now()}`);
+    renameSync4(path2, `${migratedPath}.${Date.now()}`);
   } catch {
   }
 }
@@ -38847,15 +39163,15 @@ var init_sequence = __esm({
 
 // packages/core/src/store/git-checkpoint.ts
 import { execFile as execFile2 } from "node:child_process";
-import { existsSync as existsSync20 } from "node:fs";
+import { existsSync as existsSync21 } from "node:fs";
 import { readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join20, resolve as resolve5 } from "node:path";
+import { join as join21, resolve as resolve5 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 function makeCleoGitEnv(cleoDir) {
   const abs = resolve5(cleoDir);
   return {
     ...process.env,
-    GIT_DIR: join20(abs, ".git"),
+    GIT_DIR: join21(abs, ".git"),
     GIT_WORK_TREE: abs
   };
 }
@@ -38873,7 +39189,7 @@ async function cleoGitCommand(args, cleoDir) {
   }
 }
 function isCleoGitInitialized(cleoDir) {
-  return existsSync20(join20(cleoDir, ".git", "HEAD"));
+  return existsSync21(join21(cleoDir, ".git", "HEAD"));
 }
 async function loadStateFileAllowlist(cwd) {
   try {
@@ -38917,25 +39233,25 @@ async function isCleoGitRepo(cleoDir) {
   return result.success && (result.stdout === "true" || isCleoGitInitialized(cleoDir));
 }
 function isMergeInProgress(cleoDir) {
-  return existsSync20(join20(cleoDir, ".git", "MERGE_HEAD"));
+  return existsSync21(join21(cleoDir, ".git", "MERGE_HEAD"));
 }
 async function isDetachedHead(cleoDir) {
   const result = await cleoGitCommand(["symbolic-ref", "HEAD"], cleoDir);
   return !result.success;
 }
 function isRebaseInProgress(cleoDir) {
-  return existsSync20(join20(cleoDir, ".git", "rebase-merge")) || existsSync20(join20(cleoDir, ".git", "rebase-apply"));
+  return existsSync21(join21(cleoDir, ".git", "rebase-merge")) || existsSync21(join21(cleoDir, ".git", "rebase-apply"));
 }
 async function recordCheckpointTime(cleoDir) {
   try {
-    const stateFile = join20(cleoDir, CHECKPOINT_STATE_FILE);
+    const stateFile = join21(cleoDir, CHECKPOINT_STATE_FILE);
     await writeFile2(stateFile, String(Math.floor(Date.now() / 1e3)));
   } catch {
   }
 }
 async function getLastCheckpointTime(cleoDir) {
   try {
-    const stateFile = join20(cleoDir, CHECKPOINT_STATE_FILE);
+    const stateFile = join21(cleoDir, CHECKPOINT_STATE_FILE);
     const content = await readFile3(stateFile, "utf-8");
     const epoch = parseInt(content.trim(), 10);
     return Number.isNaN(epoch) ? 0 : epoch;
@@ -38947,8 +39263,8 @@ async function getChangedStateFiles(cleoDir, cwd) {
   const changed = [];
   const allStateFiles = await getAllStateFiles(cwd);
   for (const stateFile of allStateFiles) {
-    const fullPath = join20(cleoDir, stateFile);
-    if (!existsSync20(fullPath)) continue;
+    const fullPath = join21(cleoDir, stateFile);
+    if (!existsSync21(fullPath)) continue;
     const diffResult = await cleoGitCommand(["diff", "--quiet", "--", stateFile], cleoDir);
     const cachedResult = await cleoGitCommand(
       ["diff", "--cached", "--quiet", "--", stateFile],
@@ -38975,7 +39291,7 @@ async function shouldCheckpoint(options) {
   const config = await loadCheckpointConfig(cwd);
   if (!config.enabled) return false;
   const cleoDir = getCleoDir(cwd);
-  if (!existsSync20(cleoDir)) return false;
+  if (!existsSync21(cleoDir)) return false;
   if (!isCleoGitInitialized(cleoDir)) return false;
   if (!await isCleoGitRepo(cleoDir)) return false;
   if (isMergeInProgress(cleoDir)) return false;
@@ -39053,7 +39369,7 @@ async function ensureSequenceValid(cwd, options) {
   if (!options?.validateSequence) return;
   const check = await checkSequence(cwd);
   if (!check.valid) {
-    log5.warn({ counter: check.counter, maxId: check.maxIdInData }, "Sequence behind, repairing");
+    log6.warn({ counter: check.counter, maxId: check.maxIdInData }, "Sequence behind, repairing");
     const repair = await repairSequence(cwd);
     if (!repair.repaired && options.strict) {
       throw new DataSafetyError(`Sequence repair failed: ${repair.message}`, "SEQUENCE_INVALID", {
@@ -39070,7 +39386,7 @@ async function checkpoint(context, cwd, options) {
     stats.checkpoints++;
     stats.lastCheckpoint = /* @__PURE__ */ new Date();
   } catch (err) {
-    log5.warn({ err }, "Checkpoint failed (non-fatal)");
+    log6.warn({ err }, "Checkpoint failed (non-fatal)");
   }
   vacuumIntoBackup({ cwd }).catch(() => {
   });
@@ -39132,7 +39448,7 @@ async function safeAppendLog(accessor, entry, cwd, options) {
   stats.writes++;
   await checkpoint("log entry", cwd, opts);
 }
-var log5, DataSafetyError, DEFAULT_SAFETY, stats;
+var log6, DataSafetyError, DEFAULT_SAFETY, stats;
 var init_data_safety_central = __esm({
   "packages/core/src/store/data-safety-central.ts"() {
     "use strict";
@@ -39142,7 +39458,7 @@ var init_data_safety_central = __esm({
     init_sqlite3();
     init_sqlite_backup();
     init_tasks_schema();
-    log5 = getLogger("data-safety");
+    log6 = getLogger("data-safety");
     DataSafetyError = class extends Error {
       constructor(message, code, context) {
         super(message);
@@ -39182,7 +39498,7 @@ function isSafetyDisabled() {
 }
 function wrapWithSafety(accessor, cwd) {
   if (isSafetyDisabled()) {
-    log6.warn(
+    log7.warn(
       "Safety disabled - emergency mode (CLEO_DISABLE_SAFETY=true). Data integrity checks bypassed."
     );
     return accessor;
@@ -39203,13 +39519,13 @@ function getSafetyStatus() {
     enabled: true
   };
 }
-var log6, SafetyDataAccessor;
+var log7, SafetyDataAccessor;
 var init_safety_data_accessor = __esm({
   "packages/core/src/store/safety-data-accessor.ts"() {
     "use strict";
     init_logger2();
     init_data_safety_central();
-    log6 = getLogger("data-safety");
+    log7 = getLogger("data-safety");
     SafetyDataAccessor = class {
       /** The underlying accessor being wrapped. */
       inner;
@@ -39233,7 +39549,7 @@ var init_safety_data_accessor = __esm({
           ...config
         };
         if (this.config.verbose) {
-          log6.debug({ engine: inner.engine }, "SafetyDataAccessor initialized");
+          log7.debug({ engine: inner.engine }, "SafetyDataAccessor initialized");
         }
       }
       /** The storage engine backing this accessor. */
@@ -39245,7 +39561,7 @@ var init_safety_data_accessor = __esm({
        */
       logVerbose(message) {
         if (this.config.verbose) {
-          log6.debug(message);
+          log7.debug(message);
         }
       }
       /**