@cleocode/core 2026.6.9 → 2026.6.11

package/dist/llm/plugin-facade.js

@@ -14656,7 +14656,7 @@ var init_sql = __esm({
         return new SQL([new StringChunk(str)]);
       }
       _sql.raw = raw;
-      function join27(chunks, separator) {
+      function join28(chunks, separator) {
         const result = [];
         for (const [i, chunk] of chunks.entries()) {
           if (i > 0 && separator !== void 0) result.push(separator);
@@ -14664,7 +14664,7 @@ var init_sql = __esm({
         }
         return new SQL(result);
       }
-      _sql.join = join27;
+      _sql.join = join28;
       function identifier(value) {
         return new Name(value);
       }
@@ -17051,7 +17051,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((join27) => join27.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+          if (typeof tableName === "string" && this.config.joins?.some((join28) => join28.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)) {
@@ -20861,7 +20861,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, join27]) => {
+          return sql.join(withEntries.map(([k, join28]) => {
             const relation = tableConfig.relations[k];
             const isSingle2 = is(relation, One);
             const targetTable = aliasedTable(relation.targetTable, `d${currentDepth + 1}`);
@@ -20872,7 +20872,7 @@ var init_dialect = __esm({
               table: targetTable,
               mode: isSingle2 ? "first" : "many",
               schema,
-              queryConfig: join27,
+              queryConfig: join28,
               tableConfig: schema[relation.targetTableName],
               relationWhere: filter2,
               isNested: true,
@@ -20886,7 +20886,7 @@ var init_dialect = __esm({
               key: k,
               selection: innerQuery.selection,
               isArray: !isSingle2,
-              isOptional: (relation.optional ?? false) || join27 !== true && !!join27.where
+              isOptional: (relation.optional ?? false) || join28 !== true && !!join28.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)}`;
@@ -21707,7 +21707,7 @@ var init_update = __esm({
       createJoin(joinType) {
         return ((table, on) => {
           const tableName = getTableLikeName(table);
-          if (typeof tableName === "string" && this.config.joins.some((join27) => join27.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+          if (typeof tableName === "string" && this.config.joins.some((join28) => join28.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({
@@ -22651,6 +22651,67 @@ var init_with_retry = __esm({
 });
 
 // packages/core/src/store/migration-manager.ts
+import { copyFileSync, existsSync as existsSync2 } from "node:fs";
+import { dirname, join as join3 } from "node:path";
+function stripSqlComments(sql32) {
+  return sql32.replace(/--[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+}
+function computeEliminatedTables(migrations) {
+  const createTableRegex = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?[`"]?(\w+)[`"]?/i;
+  const dropTableRegex = /DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?[`"]?(\w+)[`"]?/i;
+  const renameRegex = /ALTER\s+TABLE\s+[`"]?(\w+)[`"]?\s+RENAME\s+TO\s+[`"]?(\w+)[`"]?/i;
+  const disposition = /* @__PURE__ */ new Map();
+  const ordered = [...migrations].sort((a, b) => a.folderMillis - b.folderMillis);
+  for (const migration of ordered) {
+    const statements = Array.isArray(migration.sql) ? migration.sql : [migration.sql ?? ""];
+    for (const rawStatement of statements) {
+      const stripped = stripSqlComments(rawStatement);
+      for (const clause of stripped.split(";")) {
+        const create = createTableRegex.exec(clause);
+        if (create) {
+          disposition.set(create[1], true);
+          continue;
+        }
+        const rename2 = renameRegex.exec(clause);
+        if (rename2) {
+          disposition.set(rename2[2], true);
+          continue;
+        }
+        const drop = dropTableRegex.exec(clause);
+        if (drop) {
+          disposition.set(drop[1], false);
+        }
+      }
+    }
+  }
+  const eliminated = /* @__PURE__ */ new Set();
+  for (const [table, present] of disposition) {
+    if (!present) eliminated.add(table);
+  }
+  return eliminated;
+}
+function resolveConsolidationCutoverPrefix(migrationsFolder) {
+  const parent = dirname(migrationsFolder);
+  for (const setName of ["drizzle-cleo-project", "drizzle-cleo-global"]) {
+    const folder = join3(parent, setName);
+    if (!existsSync2(folder)) continue;
+    try {
+      const consolidation = readMigrationFiles({ migrationsFolder: folder }).find(
+        (m) => /-consolidation-cleo-/.test(m.name ?? "")
+      );
+      if (consolidation?.name) {
+        return consolidation.name.slice(0, MIGRATION_TIMESTAMP_PREFIX_LEN);
+      }
+    } catch {
+    }
+  }
+  return CONSOLIDATION_CUTOVER_PREFIX;
+}
+function isAtOrBeforeCutover(migrationName, cutoverPrefix) {
+  const prefix = (migrationName ?? "").slice(0, MIGRATION_TIMESTAMP_PREFIX_LEN);
+  if (prefix.length < MIGRATION_TIMESTAMP_PREFIX_LEN) return true;
+  return prefix <= cutoverPrefix;
+}
 function tableExists(nativeDb, tableName) {
   const result = nativeDb.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(tableName);
   return !!result;
@@ -22668,9 +22729,9 @@ function insertJournalEntry(nativeDb, hash2, createdAt, name15) {
     `INSERT OR IGNORE INTO "__drizzle_migrations" ("hash", "created_at", "name") VALUES ('${hash2}', ${createdAt}, '${name15}')`
   );
 }
-function probeAndMarkApplied(nativeDb, migration, logSubsystem) {
+function probeAndMarkApplied(nativeDb, migration, logSubsystem, eliminatedTables = /* @__PURE__ */ new Set(), consolidationCutoverPrefix = CONSOLIDATION_CUTOVER_PREFIX) {
   const sqlStatements = Array.isArray(migration.sql) ? migration.sql : [migration.sql ?? ""];
-  const fullSql = sqlStatements.join("\n");
+  const fullSql = stripSqlComments(sqlStatements.join("\n"));
   const alterColumnRegex = /ALTER\s+TABLE\s+[`"]?(\w+)[`"]?\s+ADD\s+COLUMN\s+[`"]?(\w+)[`"]?/gi;
   const createTableRegex = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?[`"]?(\w+)[`"]?/gi;
   const createIndexRegex = /CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?[`"]?(\w+)[`"]?/gi;
@@ -22697,10 +22758,17 @@ function probeAndMarkApplied(nativeDb, migration, logSubsystem) {
   }
   const isRebuildOnlyMigration = allCreatedTablesAreRenamed && tableTargets.length > 0 && alterTargets.length === 0;
   const performsTableRebuild = renameMap.size > 0;
+  const createIndexWithTableRegex = /CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?[`"]?(\w+)[`"]?\s+ON\s+[`"]?(\w+)[`"]?/gi;
+  const indexOnTable = /* @__PURE__ */ new Map();
+  for (const m of fullSql.matchAll(createIndexWithTableRegex)) {
+    indexOnTable.set(m[1], m[2]);
+  }
   const indexTargets = [];
   if (!isRebuildOnlyMigration && !performsTableRebuild) {
     for (const m of fullSql.matchAll(createIndexRegex)) {
-      indexTargets.push(m[1]);
+      const idx = m[1];
+      if (eliminatedTables.has(indexOnTable.get(idx) ?? "")) continue;
+      indexTargets.push(idx);
     }
   }
   const triggerTargets = [];
@@ -22709,6 +22777,14 @@ function probeAndMarkApplied(nativeDb, migration, logSubsystem) {
   }
   const totalTargets = alterTargets.length + tableTargets.length + indexTargets.length + triggerTargets.length;
   if (totalTargets === 0) {
+    if (isAtOrBeforeCutover(migration.name, consolidationCutoverPrefix)) {
+      insertJournalEntry(nativeDb, migration.hash, migration.folderMillis, migration.name ?? "");
+      getLogger(logSubsystem).debug(
+        { migration: migration.name },
+        `Zero-DDL pre-consolidation migration ${migration.name} stamped applied (subsumed; not re-run).`
+      );
+      return true;
+    }
     return false;
   }
   const allAltersPresent = alterTargets.every(({ table, column }) => {
@@ -22716,7 +22792,9 @@ function probeAndMarkApplied(nativeDb, migration, logSubsystem) {
     const cols = nativeDb.prepare(`PRAGMA table_info(${table})`).all();
     return cols.some((c) => c.name === column);
   });
-  const allTablesPresent = tableTargets.every((t) => tableExists(nativeDb, t));
+  const allTablesPresent = tableTargets.every(
+    (t) => tableExists(nativeDb, t) || eliminatedTables.has(t)
+  );
   const allIndexesPresent = indexTargets.every((idx) => {
     const rows = nativeDb.prepare(`SELECT name FROM sqlite_master WHERE type='index' AND name=?`).all(idx);
     return rows.length > 0;
@@ -22742,7 +22820,28 @@ function probeAndMarkApplied(nativeDb, migration, logSubsystem) {
   }
   return false;
 }
-function reconcileJournal(nativeDb, migrationsFolder, existenceTable2, logSubsystem) {
+function readSiblingMigrationHashes(siblingFolder) {
+  try {
+    return new Set(readMigrationFiles({ migrationsFolder: siblingFolder }).map((m) => m.hash));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function ensureJournalHashUnique(nativeDb) {
+  if (!tableExists(nativeDb, "__drizzle_migrations")) return;
+  try {
+    nativeDb.exec(
+      'DELETE FROM "__drizzle_migrations" WHERE id NOT IN (SELECT MIN(id) FROM "__drizzle_migrations" GROUP BY hash)'
+    );
+    nativeDb.exec(
+      'CREATE UNIQUE INDEX IF NOT EXISTS "idx_drizzle_migrations_hash" ON "__drizzle_migrations" ("hash")'
+    );
+  } catch {
+  }
+}
+function reconcileJournal(nativeDb, migrationsFolder, existenceTable2, logSubsystem, siblingMigrationsFolders = []) {
+  const eliminatedTables = computeEliminatedTables(readMigrationFiles({ migrationsFolder }));
+  const cutoverPrefix = resolveConsolidationCutoverPrefix(migrationsFolder);
   if (tableExists(nativeDb, existenceTable2) && !tableExists(nativeDb, "__drizzle_migrations")) {
     const migrations = readMigrationFiles({ migrationsFolder });
     const baseline = migrations[0];
@@ -22759,11 +22858,19 @@ function reconcileJournal(nativeDb, migrationsFolder, existenceTable2, logSubsys
       insertJournalEntry(nativeDb, baseline.hash, baseline.folderMillis, baseline.name ?? "");
     }
   }
+  ensureJournalHashUnique(nativeDb);
   if (tableExists(nativeDb, "__drizzle_migrations") && tableExists(nativeDb, existenceTable2)) {
     const localMigrations = readMigrationFiles({ migrationsFolder });
     const localHashes = new Set(localMigrations.map((m) => m.hash));
+    const knownHashes = new Set(localHashes);
+    for (const siblingFolder of siblingMigrationsFolders) {
+      if (siblingFolder === migrationsFolder) continue;
+      for (const m of readSiblingMigrationHashes(siblingFolder)) {
+        knownHashes.add(m);
+      }
+    }
     const dbEntries = nativeDb.prepare('SELECT id, hash FROM "__drizzle_migrations"').all();
-    const orphanedEntries = dbEntries.filter((e) => !localHashes.has(e.hash));
+    const orphanedEntries = dbEntries.filter((e) => !knownHashes.has(e.hash));
     const hasOrphanedEntries = orphanedEntries.length > 0;
     if (hasOrphanedEntries) {
       const dbHashes = new Set(dbEntries.map((e) => e.hash));
@@ -22786,7 +22893,7 @@ function reconcileJournal(nativeDb, migrationsFolder, existenceTable2, logSubsys
         );
         for (const m of localMigrations) {
           if (journaledHashesAfter.has(m.hash)) continue;
-          probeAndMarkApplied(nativeDb, m, logSubsystem);
+          probeAndMarkApplied(nativeDb, m, logSubsystem, eliminatedTables, cutoverPrefix);
         }
       }
     }
@@ -22809,7 +22916,7 @@ function reconcileJournal(nativeDb, migrationsFolder, existenceTable2, logSubsys
         });
       }
       if (alterMatches.length === 0) {
-        const stripped = fullSql.replace(/--[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").trim();
+        const stripped = stripSqlComments(fullSql).trim();
         if (stripped === "") {
           const log7 = getLogger(logSubsystem);
           log7.debug(
@@ -22828,9 +22935,11 @@ function reconcileJournal(nativeDb, migrationsFolder, existenceTable2, logSubsys
         const createTableRe = /CREATE\s+TABLE/i;
         const createTriggerRe = /CREATE\s+TRIGGER/i;
         if (renameRe.test(fullSql) && createTableRe.test(fullSql)) {
-          probeAndMarkApplied(nativeDb, migration, logSubsystem);
+          probeAndMarkApplied(nativeDb, migration, logSubsystem, eliminatedTables, cutoverPrefix);
         } else if (createTableRe.test(fullSql) || createTriggerRe.test(fullSql)) {
-          probeAndMarkApplied(nativeDb, migration, logSubsystem);
+          probeAndMarkApplied(nativeDb, migration, logSubsystem, eliminatedTables, cutoverPrefix);
+        } else {
+          probeAndMarkApplied(nativeDb, migration, logSubsystem, eliminatedTables, cutoverPrefix);
         }
         continue;
       }
@@ -22907,13 +23016,22 @@ function reconcileJournal(nativeDb, migrationsFolder, existenceTable2, logSubsys
     }
   }
 }
+function collectErrorMessages(err) {
+  const messages = [];
+  let current = err;
+  for (let depth = 0; current instanceof Error && depth < 16; depth++) {
+    messages.push(current.message);
+    current = current.cause;
+  }
+  return messages.join("\n");
+}
 function isDuplicateColumnError(err) {
   if (!(err instanceof Error)) return false;
-  return /duplicate column name/i.test(err.message);
+  return /duplicate column name/i.test(collectErrorMessages(err));
 }
 function isTableAlreadyExistsError(err) {
   if (!(err instanceof Error)) return false;
-  return /table .+ already exists/i.test(err.message);
+  return /table .+ already exists/i.test(collectErrorMessages(err));
 }
 function isExecutableStatement(stmt) {
   if (stmt.trim() === "") return false;
@@ -22984,7 +23102,7 @@ function ensureColumns(nativeDb, tableName, requiredColumns, logSubsystem, conte
     }
   }
 }
-var MAX_MIGRATION_RETRIES, MIGRATION_RETRY_BASE_DELAY_MS, MIGRATION_RETRY_MAX_DELAY_MS;
+var MAX_MIGRATION_RETRIES, MIGRATION_RETRY_BASE_DELAY_MS, MIGRATION_RETRY_MAX_DELAY_MS, CONSOLIDATION_CUTOVER_PREFIX, MIGRATION_TIMESTAMP_PREFIX_LEN;
 var init_migration_manager = __esm({
   "packages/core/src/store/migration-manager.ts"() {
     "use strict";
@@ -22994,36 +23112,55 @@ var init_migration_manager = __esm({
     MAX_MIGRATION_RETRIES = 5;
     MIGRATION_RETRY_BASE_DELAY_MS = 100;
     MIGRATION_RETRY_MAX_DELAY_MS = 2e3;
+    CONSOLIDATION_CUTOVER_PREFIX = "20260531000001";
+    MIGRATION_TIMESTAMP_PREFIX_LEN = 14;
   }
 });
 
 // packages/core/src/store/resolve-migrations-folder.ts
 import { createRequire } from "node:module";
-import { dirname, join as join3 } from "node:path";
+import { dirname as dirname2, join as join4 } from "node:path";
 import { fileURLToPath } from "node:url";
 function coreRootFromEntry(entryPath) {
-  return dirname(dirname(entryPath));
+  return dirname2(dirname2(entryPath));
+}
+function resolveConsolidatedJournalSiblings(ownSetName) {
+  return CONSOLIDATED_JOURNAL_LINEAGES.filter((name15) => name15 !== ownSetName).map(
+    (name15) => resolveCorePackageMigrationsFolder(name15)
+  );
 }
 function resolveCorePackageMigrationsFolder(setName) {
   try {
     const resolved = import.meta.resolve("@cleocode/core", import.meta.url);
     const entryPath = fileURLToPath(resolved);
-    return join3(coreRootFromEntry(entryPath), "migrations", setName);
+    return join4(coreRootFromEntry(entryPath), "migrations", setName);
   } catch {
   }
   const _require3 = createRequire(import.meta.url);
   try {
     const entryPath = _require3.resolve("@cleocode/core");
-    return join3(coreRootFromEntry(entryPath), "migrations", setName);
+    return join4(coreRootFromEntry(entryPath), "migrations", setName);
   } catch (err) {
     throw new Error(
       `resolveCorePackageMigrationsFolder("${setName}"): cannot locate @cleocode/core from "${import.meta.url}". Ensure @cleocode/core is installed (workspace or npm). Original error: ${err.message}`
     );
   }
 }
+var CONSOLIDATED_JOURNAL_LINEAGES;
 var init_resolve_migrations_folder = __esm({
   "packages/core/src/store/resolve-migrations-folder.ts"() {
     "use strict";
+    CONSOLIDATED_JOURNAL_LINEAGES = [
+      "drizzle-tasks",
+      "drizzle-cleo-project",
+      "drizzle-nexus",
+      "drizzle-brain",
+      "drizzle-conduit",
+      "drizzle-cleo-global",
+      "drizzle-agent-registry",
+      "drizzle-skills",
+      "drizzle-telemetry"
+    ];
   }
 });
 
@@ -31094,11 +31231,11 @@ var init_lock = __esm({
 
 // packages/core/src/store/atomic.ts
 import { mkdir, readFile as readFile2, rename, unlink } from "node:fs/promises";
-import { dirname as dirname2 } from "node:path";
+import { dirname as dirname3 } from "node:path";
 import writeFileAtomic from "write-file-atomic";
 async function atomicWrite(filePath, data, options) {
   try {
-    await mkdir(dirname2(filePath), { recursive: true });
+    await mkdir(dirname3(filePath), { recursive: true });
     await writeFileAtomic(filePath, data, {
       encoding: options?.encoding ?? "utf8",
       mode: options?.mode
@@ -31131,7 +31268,7 @@ var init_atomic = __esm({
 
 // packages/core/src/store/backup.ts
 import { copyFile, rename as fsRename, mkdir as mkdir2, readdir, stat, unlink as unlink2 } from "node:fs/promises";
-import { basename, join as join4 } from "node:path";
+import { basename, join as join5 } from "node:path";
 async function createBackup(filePath, backupDir, maxBackups = DEFAULT_MAX_BACKUPS) {
   try {
     await mkdir2(backupDir, { recursive: true });
@@ -31142,14 +31279,14 @@ async function createBackup(filePath, backupDir, maxBackups = DEFAULT_MAX_BACKUP
       throw new CleoError(3 /* FILE_ERROR */, `Cannot backup: source file not found: ${filePath}`);
     }
     for (let i = maxBackups; i >= 1; i--) {
-      const current = join4(backupDir, `${fileName}.${i}`);
+      const current = join5(backupDir, `${fileName}.${i}`);
       if (i === maxBackups) {
         try {
           await unlink2(current);
         } catch {
         }
       } else {
-        const next = join4(backupDir, `${fileName}.${i + 1}`);
+        const next = join5(backupDir, `${fileName}.${i + 1}`);
         try {
           await stat(current);
           await fsRename(current, next);
@@ -31157,7 +31294,7 @@ async function createBackup(filePath, backupDir, maxBackups = DEFAULT_MAX_BACKUP
         }
       }
     }
-    const backupPath = join4(backupDir, `${fileName}.1`);
+    const backupPath = join5(backupDir, `${fileName}.1`);
     await copyFile(filePath, backupPath);
     return backupPath;
   } catch (err) {
@@ -31436,16 +31573,16 @@ var init_json2 = __esm({
 });
 
 // packages/core/src/scaffold/ensure-config.ts
-import { existsSync as existsSync2, readFileSync } from "node:fs";
-import { basename as basename2, dirname as dirname3, join as join5, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync3, readFileSync } from "node:fs";
+import { basename as basename2, dirname as dirname4, join as join6, resolve as resolve2 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function getPackageRoot() {
   const thisFile = fileURLToPath2(import.meta.url);
-  return resolve2(dirname3(thisFile), "..", "..");
+  return resolve2(dirname4(thisFile), "..", "..");
 }
 function getCleoVersion() {
   try {
-    const pkgPath = join5(getPackageRoot(), "package.json");
+    const pkgPath = join6(getPackageRoot(), "package.json");
     const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
     return pkg.version ?? "0.0.0";
   } catch {
@@ -31463,26 +31600,26 @@ var init_ensure_config = __esm({
 
 // packages/core/src/store/exodus/archive.ts
 import {
-  copyFileSync,
-  existsSync as existsSync3,
+  copyFileSync as copyFileSync2,
+  existsSync as existsSync4,
   mkdirSync,
   renameSync,
   unlinkSync,
   writeFileSync
 } from "node:fs";
-import { basename as basename3, join as join6 } from "node:path";
+import { basename as basename3, join as join7 } 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);
+  return join7(scopeBaseDir(scope, cwd), ARCHIVE_DIR_NAME);
 }
 function exodusMarkerPath(scope, cwd) {
-  return join6(scopeBaseDir(scope, cwd), MARKER_FILENAME_BY_SCOPE[scope]);
+  return join7(scopeBaseDir(scope, cwd), MARKER_FILENAME_BY_SCOPE[scope]);
 }
 function hasExodusCompleteMarker(scope, cwd) {
   try {
-    return existsSync3(exodusMarkerPath(scope, cwd));
+    return existsSync4(exodusMarkerPath(scope, cwd));
   } catch {
     return false;
   }
@@ -31506,28 +31643,28 @@ function writeExodusCompleteMarker(scope, archivedSources, cwd) {
 }
 function moveFileInto(srcPath, destDir) {
   mkdirSync(destDir, { recursive: true });
-  let dest = join6(destDir, basename3(srcPath));
-  if (existsSync3(dest)) {
+  let dest = join7(destDir, basename3(srcPath));
+  if (existsSync4(dest)) {
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "").replace(/Z$/, "Z");
-    dest = join6(destDir, `${basename3(srcPath)}.${stamp}`);
+    dest = join7(destDir, `${basename3(srcPath)}.${stamp}`);
   }
   try {
     renameSync(srcPath, dest);
   } catch {
-    copyFileSync(srcPath, dest);
+    copyFileSync2(srcPath, dest);
     unlinkSync(srcPath);
   }
   return dest;
 }
 function archiveSourceDb(source, cwd) {
-  if (!existsSync3(source.path)) {
+  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 (existsSync3(sidecar)) {
+    if (existsSync4(sidecar)) {
       try {
         moveFileInto(sidecar, destDir);
       } catch (err) {
@@ -31573,7 +31710,7 @@ function detectStrandedResidue(sources, cwd) {
   const stranded = [];
   for (const source of sources) {
     if (!markedScopes.has(source.targetScope)) continue;
-    if (existsSync3(source.path)) {
+    if (existsSync4(source.path)) {
       stranded.push({ name: source.name, path: source.path, scope: source.targetScope });
     }
   }
@@ -31990,7 +32127,7 @@ var init_table_name_map = __esm({
 });
 
 // packages/core/src/store/exodus/count-parity.ts
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync5 } from "node:fs";
 function listTables(db) {
   return db.prepare(
     "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '__drizzle_%' ORDER BY name"
@@ -32011,14 +32148,14 @@ function rowCount(db, tableName) {
 function computeCountParity(sources, projectDbPath, globalDbPath) {
   const entries = [];
   let skipped = 0;
-  if (!existsSync4(projectDbPath) || !existsSync4(globalDbPath)) {
+  if (!existsSync5(projectDbPath) || !existsSync5(globalDbPath)) {
     return { ok: false, entries: [], deficits: [], checked: 0, skipped: 0 };
   }
   const projectSnap = openCleoDbSnapshot(projectDbPath, { readOnly: true });
   const globalSnap = openCleoDbSnapshot(globalDbPath, { readOnly: true });
   try {
     for (const src of sources) {
-      if (!existsSync4(src.path)) continue;
+      if (!existsSync5(src.path)) continue;
       const srcSnap = openCleoDbSnapshot(src.path, { readOnly: true });
       try {
         for (const legacyTable of listTables(srcSnap.db)) {
@@ -32076,8 +32213,8 @@ var init_count_parity = __esm({
 });
 
 // packages/core/src/store/exodus/plan.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2, statfsSync, statSync } from "node:fs";
-import { join as join7 } from "node:path";
+import { existsSync as existsSync6, readdirSync as readdirSync2, statfsSync, statSync } from "node:fs";
+import { join as join8 } from "node:path";
 function computeRequiredBytes(totalSourceBytes, largestSourceBytes) {
   return Math.ceil(STAGING_HEADROOM_FACTOR * largestSourceBytes) + totalSourceBytes;
 }
@@ -32088,33 +32225,33 @@ function buildSourceDescriptors(cwd) {
     // Project-tier — go into consolidated project-scope cleo.db
     {
       name: "tasks",
-      path: join7(cleoDir, "tasks.db"),
+      path: join8(cleoDir, "tasks.db"),
       targetScope: "project"
     },
     {
       name: "brain (project)",
-      path: join7(cleoDir, "brain.db"),
+      path: join8(cleoDir, "brain.db"),
       targetScope: "project"
     },
     {
       name: "conduit",
-      path: join7(cleoDir, "conduit.db"),
+      path: join8(cleoDir, "conduit.db"),
       targetScope: "project"
     },
     // Global-tier — go into consolidated global-scope cleo.db
     {
       name: "nexus",
-      path: join7(cleoHome, "nexus.db"),
+      path: join8(cleoHome, "nexus.db"),
       targetScope: "global"
     },
     {
       name: "signaldock",
-      path: join7(cleoHome, "signaldock.db"),
+      path: join8(cleoHome, "signaldock.db"),
       targetScope: "global"
     },
     {
       name: "skills",
-      path: join7(cleoHome, "skills.db"),
+      path: join8(cleoHome, "skills.db"),
       targetScope: "global"
     }
   ];
@@ -32143,7 +32280,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 join7(cleoDir, stagingDirs[0]);
+      return join8(cleoDir, stagingDirs[0]);
     }
   } catch {
   }
@@ -32159,7 +32296,7 @@ function buildExodusPlan(cwd) {
   const availableBytes = getAvailableBytes(cleoDir);
   const diskPreflight = totalSourceBytes === 0 || availableBytes >= requiredBytes;
   const existingStaging = findExistingStaging(cleoDir);
-  const stagingDir = existingStaging ?? join7(cleoDir, deriveStagingDirName());
+  const stagingDir = existingStaging ?? join8(cleoDir, deriveStagingDirName());
   const resumeFromStaging = existingStaging !== null;
   const projectDbPath = resolveDualScopeDbPath("project", cwd);
   const globalDbPath = resolveDualScopeDbPath("global");
@@ -32178,7 +32315,7 @@ function buildExodusPlan(cwd) {
   };
 }
 function sourcesPresent(sources) {
-  return sources.some((s) => existsSync5(s.path));
+  return sources.some((s) => existsSync6(s.path));
 }
 var STAGING_HEADROOM_FACTOR, STAGING_COPY_SKIP_THRESHOLD_BYTES;
 var init_plan2 = __esm({
@@ -32192,18 +32329,18 @@ var init_plan2 = __esm({
 });
 
 // packages/core/src/store/exodus/health.ts
-import { existsSync as existsSync6, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync7, statSync as statSync2 } from "node:fs";
 function buildExodusHealth(cwd) {
   const plan = buildExodusPlan(cwd);
-  const anyLegacyPresent = plan.sources.some((s) => existsSync6(s.path));
+  const anyLegacyPresent = plan.sources.some((s) => existsSync7(s.path));
   const parity = anyLegacyPresent ? computeCountParity(plan.sources, plan.projectDbPath, plan.globalDbPath) : { ok: true, entries: [], deficits: [], checked: 0, skipped: 0 };
   const consolidatedExistsByScope = {
-    project: existsSync6(plan.projectDbPath),
-    global: existsSync6(plan.globalDbPath)
+    project: existsSync7(plan.projectDbPath),
+    global: existsSync7(plan.globalDbPath)
   };
   const buildScope = (scope) => {
     const sources = plan.sources.filter((s) => s.targetScope === scope).map((s) => {
-      const present = existsSync6(s.path);
+      const present = existsSync7(s.path);
       let bytes = 0;
       if (present) {
         try {
@@ -32469,8 +32606,8 @@ var init_types = __esm({
 
 // packages/core/src/store/exodus/migrate.ts
 import {
-  copyFileSync as copyFileSync2,
-  existsSync as existsSync7,
+  copyFileSync as copyFileSync3,
+  existsSync as existsSync8,
   mkdirSync as mkdirSync2,
   readFileSync as readFileSync2,
   renameSync as renameSync2,
@@ -32478,7 +32615,7 @@ import {
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync2
 } 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();
@@ -32494,14 +32631,14 @@ function listTables2(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");
   renameSync2(tmpPath, journalPath);
 }
 function readJournal(stagingDir) {
-  const journalPath = join8(stagingDir, JOURNAL_FILENAME);
-  if (!existsSync7(journalPath)) return null;
+  const journalPath = join9(stagingDir, JOURNAL_FILENAME);
+  if (!existsSync8(journalPath)) return null;
   try {
     return JSON.parse(readFileSync2(journalPath, "utf8"));
   } catch {
@@ -32509,9 +32646,9 @@ function readJournal(stagingDir) {
   }
 }
 function clearExodusJournal(stagingDir) {
-  const journalPath = join8(stagingDir, JOURNAL_FILENAME);
+  const journalPath = join9(stagingDir, JOURNAL_FILENAME);
   try {
-    if (!existsSync7(journalPath)) return false;
+    if (!existsSync8(journalPath)) return false;
     unlinkSync2(journalPath);
     log3.info(
       { stagingDir },
@@ -32776,7 +32913,7 @@ async function runExodusMigrate(plan, forceCrossVersion = false, onProgress) {
   mkdirSync2(stagingDir, { recursive: true });
   let sqliteVersion = "unknown";
   for (const src of sources) {
-    if (existsSync7(src.path)) {
+    if (existsSync8(src.path)) {
       const snap = openCleoDbSnapshot(src.path, { readOnly: true });
       sqliteVersion = getSqliteVersion(snap.db);
       snap.close();
@@ -32817,17 +32954,17 @@ async function runExodusMigrate(plan, forceCrossVersion = false, onProgress) {
     };
     var extractNativeDb = extractNativeDb2;
     for (const src of sources) {
-      if (!existsSync7(src.path)) continue;
-      const backupDest = join8(stagingDir, `${src.name.replace(/[^a-z0-9-]/g, "_")}-backup.db`);
+      if (!existsSync8(src.path)) continue;
+      const backupDest = join9(stagingDir, `${src.name.replace(/[^a-z0-9-]/g, "_")}-backup.db`);
       const srcBytes = safeStatBytes(src.path);
       const skipStagingCopy = srcBytes > plan.stagingCopyThresholdBytes;
       if (skipStagingCopy) {
         onProgress?.(
           `Skipping full staging copy of ${src.name} (${srcBytes} bytes > ${plan.stagingCopyThresholdBytes} threshold) \u2014 source is archived, not deleted, on success.`
         );
-      } else if (!existsSync7(backupDest)) {
+      } else if (!existsSync8(backupDest)) {
         onProgress?.(`Backing up ${src.name} \u2192 staging dir\u2026`);
-        copyFileSync2(src.path, backupDest);
+        copyFileSync3(src.path, backupDest);
         backupPaths.push(backupDest);
       }
       acquireAdvisoryLock(src.path);
@@ -32843,8 +32980,8 @@ async function runExodusMigrate(plan, forceCrossVersion = false, onProgress) {
     });
     const projectNative = extractNativeDb2(projectHandle);
     const globalNative = extractNativeDb2(globalHandle);
-    const projectSources = sources.filter((s) => s.targetScope === "project" && existsSync7(s.path));
-    const globalSources = sources.filter((s) => s.targetScope === "global" && existsSync7(s.path));
+    const projectSources = sources.filter((s) => s.targetScope === "project" && existsSync8(s.path));
+    const globalSources = sources.filter((s) => s.targetScope === "global" && existsSync8(s.path));
     await migrateScope(
       "project",
       projectSources,
@@ -33119,11 +33256,11 @@ var init_seal = __esm({
 });
 
 // packages/core/src/store/exodus/status.ts
-import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync3, statSync as statSync4 } from "node:fs";
-import { join as join9 } from "node:path";
+import { existsSync as existsSync9, readdirSync as readdirSync3, readFileSync as readFileSync3, statSync as statSync4 } from "node:fs";
+import { join as join10 } from "node:path";
 function readJournal2(stagingDir) {
-  const p = join9(stagingDir, JOURNAL_FILENAME2);
-  if (!existsSync8(p)) return null;
+  const p = join10(stagingDir, JOURNAL_FILENAME2);
+  if (!existsSync9(p)) return null;
   try {
     return JSON.parse(readFileSync3(p, "utf8"));
   } catch {
@@ -33132,7 +33269,7 @@ function readJournal2(stagingDir) {
 }
 function findStagingDirs(cleoDir) {
   try {
-    return readdirSync3(cleoDir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith("exodus-staging-")).map((e) => join9(cleoDir, e.name)).sort().reverse();
+    return readdirSync3(cleoDir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith("exodus-staging-")).map((e) => join10(cleoDir, e.name)).sort().reverse();
   } catch {
     return [];
   }
@@ -33155,15 +33292,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
   };
@@ -33180,7 +33317,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 {
@@ -33428,7 +33565,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: [],
@@ -33439,7 +33576,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: [],
@@ -33454,7 +33591,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;
       }
@@ -33737,7 +33874,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";
@@ -33852,7 +33989,7 @@ async function maybeRunExodusOnOpen(scope, dbPath, nativeDb, cwd) {
   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)`
@@ -33869,7 +34006,7 @@ async function maybeRunExodusOnOpen(scope, dbPath, nativeDb, cwd) {
         {
           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"
       );
@@ -33925,7 +34062,7 @@ async function maybeRunExodusOnOpen(scope, dbPath, nativeDb, cwd) {
           "exodus-on-open: parity verified \u2014 legacy data migrated into consolidated cleo.db"
         );
         try {
-          const consumed = plan.sources.filter((s) => existsSync10(s.path));
+          const consumed = plan.sources.filter((s) => existsSync11(s.path));
           const archiveResult = archiveMigratedSources(consumed, cwd);
           log6.info(
             {
@@ -33982,9 +34119,9 @@ __export(dual_scope_db_exports, {
   resolveDualScopeDbPath: () => resolveDualScopeDbPath,
   upsertIdempotent: () => upsertIdempotent
 });
-import { existsSync as existsSync11, mkdirSync as mkdirSync3 } from "node:fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync3 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { dirname as dirname4, join as join10 } from "node:path";
+import { dirname as dirname5, join as join11 } from "node:path";
 function assertWriteDurable(handle) {
   if (handle.exodusAbort) {
     throw new ExodusAbortWriteUnsafeError(handle.exodusAbort);
@@ -34001,9 +34138,9 @@ function cacheKey(scope, dbPath) {
 }
 function resolveDualScopeDbPath(scope, cwd) {
   if (scope === "project") {
-    return join10(resolveCleoDir(cwd), "cleo.db");
+    return join11(resolveCleoDir(cwd), "cleo.db");
   }
-  return join10(getCleoHome(), "cleo.db");
+  return join11(getCleoHome(), "cleo.db");
 }
 function migrationsSetName(scope) {
   return scope === "project" ? "drizzle-cleo-project" : "drizzle-cleo-global";
@@ -34037,24 +34174,35 @@ async function loadGlobalSchema() {
 function existenceTable(scope) {
   return scope === "project" ? "tasks_tasks" : "nexus_project_registry";
 }
+function memoryBoundedPragmaOverrides() {
+  if (process.env.CLEO_SENTIENT_DAEMON === "1") return {};
+  if (process.env.CLEO_DB_FULL_MEM === "1") return {};
+  return { mmapSizeBytes: 0, cacheSizeKb: 8e3 };
+}
 async function openDualScopeDb(scope, cwd) {
   const dbPath = resolveDualScopeDbPath(scope, cwd);
   return scope === "project" ? openDualScopeDbAtPath("project", dbPath, cwd) : openDualScopeDbAtPath("global", dbPath, cwd);
 }
 async function openDedicatedDualScopeDb(scope, dbPath, log7) {
   log7.debug({ scope, dbPath }, "opening DEDICATED (non-cached) dual-scope cleo.db (T11782 FIX D)");
-  const dir = dirname4(dbPath);
-  if (!existsSync11(dir)) {
+  const dir = dirname5(dbPath);
+  if (!existsSync12(dir)) {
     mkdirSync3(dir, { recursive: true });
   }
   const DatabaseSyncCtor = getDatabaseSyncCtor();
   const nativeDb = new DatabaseSyncCtor(dbPath, { allowExtension: true });
-  applyPerfPragmas(nativeDb);
+  applyPerfPragmas(nativeDb, memoryBoundedPragmaOverrides());
   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}]`);
+  reconcileJournal(
+    nativeDb,
+    migrationsFolder,
+    existenceTable(scope),
+    `dual-scope-db[${scope}]`,
+    resolveConsolidatedJournalSiblings(migrationsSetName(scope))
+  );
   migrateWithRetry(
     db,
     migrationsFolder,
@@ -34093,18 +34241,24 @@ async function openDualScopeDbAtPath(scope, dbPath, exodusCwd, options) {
   }
   const initPromise = (async () => {
     log7.debug({ scope, dbPath }, "opening dual-scope cleo.db");
-    const dir = dirname4(dbPath);
-    if (!existsSync11(dir)) {
+    const dir = dirname5(dbPath);
+    if (!existsSync12(dir)) {
       mkdirSync3(dir, { recursive: true });
     }
     const DatabaseSyncCtor = getDatabaseSyncCtor();
     const nativeDb = new DatabaseSyncCtor(dbPath, { allowExtension: true });
-    applyPerfPragmas(nativeDb);
+    applyPerfPragmas(nativeDb, memoryBoundedPragmaOverrides());
     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}]`);
+    reconcileJournal(
+      nativeDb,
+      migrationsFolder,
+      existenceTable(scope),
+      `dual-scope-db[${scope}]`,
+      resolveConsolidatedJournalSiblings(migrationsSetName(scope))
+    );
     migrateWithRetry(
       db,
       migrationsFolder,
@@ -34172,6 +34326,12 @@ async function openDualScopeDbAtPath(scope, dbPath, exodusCwd, options) {
     nativeDb: null,
     initPromise
   });
+  initPromise.catch(() => {
+    const entry = _cache.get(key);
+    if (entry && entry.initPromise === initPromise) {
+      _cache.delete(key);
+    }
+  });
   return initPromise;
 }
 function _resetDualScopeDbCache(scope) {
@@ -34762,8 +34922,8 @@ __export(nexus_sqlite_exports, {
   resetNexusDbState: () => resetNexusDbState,
   resolveNexusMigrationsFolder: () => resolveNexusMigrationsFolder
 });
-import { copyFileSync as copyFileSync3, existsSync as existsSync12 } from "node:fs";
-import { join as join11 } from "node:path";
+import { copyFileSync as copyFileSync4, existsSync as existsSync13 } from "node:fs";
+import { join as join12 } from "node:path";
 function getNexusDbPath(cwd) {
   return resolveDualScopeDbPath("project", cwd);
 }
@@ -34795,7 +34955,7 @@ function resolveNexusMigrationsFolder() {
   return resolveCorePackageMigrationsFolder("drizzle-nexus");
 }
 function getNestedNexusSentinelPath() {
-  return join11(getCleoHome(), "nexus", NESTED_NEXUS_SENTINEL);
+  return join12(getCleoHome(), "nexus", NESTED_NEXUS_SENTINEL);
 }
 function detectAndWarnOnNestedNexus() {
   let nestedPath;
@@ -34804,7 +34964,7 @@ 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();
@@ -34963,14 +35123,20 @@ function runNexusMigrations(nativeDb, db) {
   const migrationsFolder = resolveNexusMigrationsFolder();
   if (tableExists4(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 {
       }
     }
   }
-  reconcileJournal(nativeDb, migrationsFolder, "_nexus_meta", "nexus");
+  reconcileJournal(
+    nativeDb,
+    migrationsFolder,
+    "_nexus_meta",
+    "nexus",
+    resolveConsolidatedJournalSiblings("drizzle-nexus")
+  );
   const MAX_RETRIES2 = 5;
   const BASE_DELAY_MS = 100;
   const MAX_DELAY_MS = 2e3;
@@ -35095,10 +35261,10 @@ var init_nexus_sqlite = __esm({
 
 // packages/core/src/paths.ts
 import { AsyncLocalStorage } from "node:async_hooks";
-import { existsSync as existsSync13, readFileSync as readFileSync4, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync4, statSync as statSync5 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
 import { homedir } from "node:os";
-import { basename as basename4, dirname as dirname5, join as join12, resolve as resolve3 } from "node:path";
+import { basename as basename4, dirname as dirname6, join as join13, resolve as resolve3 } from "node:path";
 import {
   computeCanonicalProjectId as _computeCanonicalProjectId,
   getCanonicalTemplatesTildePath as _getCanonicalTemplatesTildePath,
@@ -35188,8 +35354,8 @@ function getCleoDirAbsolute(cwd, opts) {
 function _resolveProjectByCwdFromNexus(cwd) {
   try {
     const cleoHome = getCleoHome();
-    const globalDbPath = join12(cleoHome, "cleo.db");
-    if (!existsSync13(globalDbPath)) return null;
+    const globalDbPath = join13(cleoHome, "cleo.db");
+    if (!existsSync14(globalDbPath)) return null;
     const start = resolve3(cwd ?? process.cwd());
     let current = start;
     const DatabaseSync2 = _getDatabaseSyncCtor();
@@ -35203,7 +35369,7 @@ function _resolveProjectByCwdFromNexus(cwd) {
         if (row && typeof row.project_id === "string" && row.project_id.length > 0) {
           return row.project_id;
         }
-        const parent = dirname5(current);
+        const parent = dirname6(current);
         if (parent === current) break;
         current = parent;
       }
@@ -35228,13 +35394,13 @@ function _findCleoDirRoot(cwd) {
     const isDangerousRoot = current === homeRoot || current === "/" || current === "";
     if (!isDangerousRoot) {
       try {
-        if (statSync5(join12(current, ".cleo")).isDirectory()) {
+        if (statSync5(join13(current, ".cleo")).isDirectory()) {
           return current;
         }
       } catch {
       }
     }
-    const parent = dirname5(current);
+    const parent = dirname6(current);
     if (parent === current) break;
     current = parent;
   }
@@ -35243,7 +35409,7 @@ function _findCleoDirRoot(cwd) {
 function resolveCleoDir(cwd) {
   const scope = worktreeScope.getStore();
   if (scope !== void 0) {
-    return join12(scope.worktreeRoot, ".cleo");
+    return join13(scope.worktreeRoot, ".cleo");
   }
   const override = _cleoDirEnvOverride();
   if (override !== null) {
@@ -35251,16 +35417,16 @@ function resolveCleoDir(cwd) {
   }
   const root = _findCleoDirRoot(cwd);
   if (root !== null) {
-    return join12(root, ".cleo");
+    return join13(root, ".cleo");
   }
   const start = resolve3(cwd ?? process.cwd());
   let current = start;
   while (true) {
     const mainRepo = _resolveMainRepoFromGitlink(current);
     if (mainRepo !== null) {
-      return join12(mainRepo, ".cleo");
+      return join13(mainRepo, ".cleo");
     }
-    const parent = dirname5(current);
+    const parent = dirname6(current);
     if (parent === current) {
       break;
     }
@@ -35300,30 +35466,30 @@ function _cwdHasGitAncestor(cwd) {
   const start = resolve3(cwd ?? process.cwd());
   let current = start;
   while (true) {
-    const gitMarker = join12(current, ".git");
+    const gitMarker = join13(current, ".git");
     try {
-      if (existsSync13(gitMarker)) {
+      if (existsSync14(gitMarker)) {
         return true;
       }
     } catch {
     }
-    const parent = dirname5(current);
+    const parent = dirname6(current);
     if (parent === current) return false;
     current = parent;
   }
 }
 function _resolveMainRepoFromGitlink(gitlinkDir) {
   try {
-    const gitLinkPath = join12(gitlinkDir, ".git");
-    if (!existsSync13(gitLinkPath)) return null;
+    const gitLinkPath = join13(gitlinkDir, ".git");
+    if (!existsSync14(gitLinkPath)) return null;
     const stat2 = statSync5(gitLinkPath);
     if (!stat2.isFile()) return null;
     const gitLinkContent = readFileSync4(gitLinkPath, "utf-8").trim();
     const match = gitLinkContent.match(/^gitdir:\s*(.+)$/m);
     if (!match) return null;
     const gitdir = match[1].trim();
-    const mainRepo = dirname5(dirname5(dirname5(gitdir)));
-    if (existsSync13(join12(mainRepo, ".cleo")) && validateProjectRoot(mainRepo)) {
+    const mainRepo = dirname6(dirname6(dirname6(gitdir)));
+    if (existsSync14(join13(mainRepo, ".cleo")) && validateProjectRoot(mainRepo)) {
       return mainRepo;
     }
   } catch {
@@ -35331,18 +35497,18 @@ function _resolveMainRepoFromGitlink(gitlinkDir) {
   return null;
 }
 function validateProjectRoot(candidate) {
-  const cleoDir = join12(candidate, ".cleo");
-  if (!existsSync13(cleoDir)) {
+  const cleoDir = join13(candidate, ".cleo");
+  if (!existsSync14(cleoDir)) {
     return false;
   }
-  const projectInfoPath = join12(cleoDir, "project-info.json");
-  if (existsSync13(projectInfoPath)) {
+  const projectInfoPath = join13(cleoDir, "project-info.json");
+  if (existsSync14(projectInfoPath)) {
     try {
       const raw = readFileSync4(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 = join12(candidate, ".git");
-        if (existsSync13(gitMarker)) {
+        const gitMarker = join13(candidate, ".git");
+        if (existsSync14(gitMarker)) {
           try {
             if (!statSync5(gitMarker).isDirectory()) {
               return false;
@@ -35356,8 +35522,8 @@ function validateProjectRoot(candidate) {
     } catch {
     }
   }
-  const gitDir = join12(candidate, ".git");
-  if (existsSync13(gitDir)) {
+  const gitDir = join13(candidate, ".git");
+  if (existsSync14(gitDir)) {
     let isRealGitDir = false;
     try {
       const stat2 = statSync5(gitDir);
@@ -35393,7 +35559,7 @@ function getProjectRoot(cwd) {
   const cleoDirEnv = process.env["CLEO_DIR"];
   if (cleoDirEnv && isAbsolutePath(cleoDirEnv)) {
     if (cleoDirEnv.endsWith("/.cleo") || cleoDirEnv.endsWith("\\.cleo")) {
-      return dirname5(cleoDirEnv);
+      return dirname6(cleoDirEnv);
     }
     return cleoDirEnv;
   }
@@ -35404,16 +35570,16 @@ function getProjectRoot(cwd) {
   const homeRoot = homedir();
   const skippedCleoDirs = [];
   while (true) {
-    const cleoDir = join12(current, ".cleo");
-    const gitDir = join12(current, ".git");
+    const cleoDir = join13(current, ".cleo");
+    const gitDir = join13(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 = statSync5(gitDir).isDirectory();
@@ -35428,7 +35594,7 @@ function getProjectRoot(cwd) {
       const mainRepoFromWalk = _resolveMainRepoFromGitlink(current);
       if (mainRepoFromWalk !== null) return mainRepoFromWalk;
     }
-    const parent = dirname5(current);
+    const parent = dirname6(current);
     if (parent === current) {
       break;
     }
@@ -35458,18 +35624,18 @@ function resolveOrCwd(maybeRoot) {
   return getProjectRoot();
 }
 function getConfigPath(cwd) {
-  return join12(_resolveCleoDir(cwd), "config.json");
+  return join13(_resolveCleoDir(cwd), "config.json");
 }
 function getGlobalConfigPath() {
-  return join12(getCleoHome(), "config.json");
+  return join13(getCleoHome(), "config.json");
 }
 function isAbsolutePath(path) {
   return _isAbsolutePath(path);
 }
 function _readProjectNameFromInfo(projectRoot) {
   try {
-    const infoPath = join12(projectRoot, ".cleo", "project-info.json");
-    if (!existsSync13(infoPath)) return void 0;
+    const infoPath = join13(projectRoot, ".cleo", "project-info.json");
+    if (!existsSync14(infoPath)) return void 0;
     const raw = readFileSync4(infoPath, "utf-8");
     const data = JSON.parse(raw);
     return typeof data.name === "string" && data.name.length > 0 ? data.name : void 0;
@@ -35495,8 +35661,8 @@ async function registerProjectOnEncounter(projectRoot, infoProjectId) {
     if (existingRows.length > 0) {
       const existingPath = existingRows[0].projectPath;
       if (existingPath !== resolvedPath) {
-        const newBrainDbPath = join12(resolvedPath, ".cleo", "brain.db");
-        const newTasksDbPath = join12(resolvedPath, ".cleo", "tasks.db");
+        const newBrainDbPath = join13(resolvedPath, ".cleo", "brain.db");
+        const newTasksDbPath = join13(resolvedPath, ".cleo", "tasks.db");
         await db.update(projectRegistry2).set({
           projectPath: resolvedPath,
           projectHash: generateProjectHash2(resolvedPath),
@@ -35527,8 +35693,8 @@ async function registerProjectOnEncounter(projectRoot, infoProjectId) {
       lastSync: now,
       taskCount: 0,
       labelsJson: "[]",
-      brainDbPath: join12(resolvedPath, ".cleo", "brain.db"),
-      tasksDbPath: join12(resolvedPath, ".cleo", "tasks.db"),
+      brainDbPath: join13(resolvedPath, ".cleo", "brain.db"),
+      tasksDbPath: join13(resolvedPath, ".cleo", "tasks.db"),
       statsJson: "{}"
     }).onConflictDoNothing();
     const aliases = canonicalResult.legacyAliases ?? [];
@@ -35561,7 +35727,7 @@ var init_paths = __esm({
 // packages/core/src/store/file-utils.ts
 import { randomBytes } from "node:crypto";
 import {
-  existsSync as existsSync14,
+  existsSync as existsSync15,
   mkdirSync as mkdirSync4,
   readdirSync as readdirSync4,
   readFileSync as readFileSync5,
@@ -35569,34 +35735,34 @@ import {
   unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync3
 } from "node:fs";
-import { basename as basename5, dirname as dirname6, join as join13 } from "node:path";
+import { basename as basename5, dirname as dirname7, join as join14 } from "node:path";
 import * as lockfile2 from "proper-lockfile";
 function rotateBackup(filePath, mode) {
-  const dir = dirname6(filePath);
+  const dir = dirname7(filePath);
   const name15 = basename5(filePath);
-  const backupDir = join13(dir, ".backups");
+  const backupDir = join14(dir, ".backups");
   const dirMode = typeof mode === "number" ? modeToDirMode(mode) : void 0;
-  if (!existsSync14(backupDir)) {
+  if (!existsSync15(backupDir)) {
     mkdirSync4(backupDir, { recursive: true, mode: dirMode });
   }
   for (let i = MAX_BACKUPS; i >= 1; i--) {
-    const current = join13(backupDir, `${name15}.${i}`);
+    const current = join14(backupDir, `${name15}.${i}`);
     if (i === MAX_BACKUPS) {
       try {
         unlinkSync3(current);
       } catch {
       }
     } else {
-      const next = join13(backupDir, `${name15}.${i + 1}`);
+      const next = join14(backupDir, `${name15}.${i + 1}`);
       try {
-        if (existsSync14(current)) renameSync3(current, next);
+        if (existsSync15(current)) renameSync3(current, next);
       } catch {
       }
     }
   }
   try {
     const content = readFileSync5(filePath, "utf-8");
-    const backupPath = join13(backupDir, `${name15}.1`);
+    const backupPath = join14(backupDir, `${name15}.1`);
     if (typeof mode === "number") {
       writeFileSync3(backupPath, content, { encoding: "utf-8", mode });
     } else {
@@ -35616,8 +35782,8 @@ function writeJsonFileAtomic(filePath, data, optsOrIndent = 2) {
   const opts = typeof optsOrIndent === "number" ? { indent: optsOrIndent } : optsOrIndent;
   const indent = opts.indent ?? 2;
   const mode = opts.mode;
-  const dir = dirname6(filePath);
-  const tempPath = join13(dir, `.${basename5(filePath)}.${randomBytes(6).toString("hex")}.tmp`);
+  const dir = dirname7(filePath);
+  const tempPath = join14(dir, `.${basename5(filePath)}.${randomBytes(6).toString("hex")}.tmp`);
   const content = JSON.stringify(data, null, indent) + "\n";
   if (typeof mode === "number") {
     writeFileSync3(tempPath, content, { encoding: "utf-8", mode });
@@ -35625,7 +35791,7 @@ function writeJsonFileAtomic(filePath, data, optsOrIndent = 2) {
     writeFileSync3(tempPath, content, "utf-8");
   }
   try {
-    if (existsSync14(filePath)) {
+    if (existsSync15(filePath)) {
       rotateBackup(filePath, mode);
     }
     renameSync3(tempPath, filePath);
@@ -35649,12 +35815,12 @@ function readJsonFile(filePath) {
   }
 }
 async function withLock2(filePath, transform2, opts = {}) {
-  const dir = dirname6(filePath);
+  const dir = dirname7(filePath);
   const dirMode = typeof opts.mode === "number" ? modeToDirMode(opts.mode) : void 0;
-  if (!existsSync14(dir)) {
+  if (!existsSync15(dir)) {
     mkdirSync4(dir, { recursive: true, mode: dirMode });
   }
-  if (!existsSync14(filePath)) {
+  if (!existsSync15(filePath)) {
     if (typeof opts.mode === "number") {
       writeFileSync3(filePath, "", { encoding: "utf-8", mode: opts.mode });
     } else {
@@ -35675,11 +35841,11 @@ async function withLock2(filePath, transform2, opts = {}) {
   }
 }
 async function withFileLock(filePath, operation) {
-  const dir = dirname6(filePath);
-  if (!existsSync14(dir)) {
+  const dir = dirname7(filePath);
+  if (!existsSync15(dir)) {
     mkdirSync4(dir, { recursive: true });
   }
-  if (!existsSync14(filePath)) {
+  if (!existsSync15(filePath)) {
     writeFileSync3(filePath, "", "utf-8");
   }
   let release;
@@ -35713,10 +35879,10 @@ var init_file_utils = __esm({
 
 // packages/core/src/llm/credential-removal.ts
 import { unlinkSync as unlinkSync4 } from "node:fs";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 import { getCleoHome as getCleoHome2 } from "@cleocode/paths";
 function suppressionStatePath() {
-  return join14(getCleoHome2(), SUPPRESSION_FILENAME);
+  return join15(getCleoHome2(), SUPPRESSION_FILENAME);
 }
 function readSuppressionFile() {
   const data = readJsonFile(suppressionStatePath());
@@ -35820,7 +35986,7 @@ var init_credential_removal = __esm({
       sourceId: "cleo-pkce",
       description: "Delete CLEO-issued PKCE token at <CLEO_HOME>/anthropic-oauth.json",
       async remove() {
-        const path = join14(getCleoHome2(), "anthropic-oauth.json");
+        const path = join15(getCleoHome2(), "anthropic-oauth.json");
         const cleaned = [];
         try {
           unlinkSync4(path);
@@ -35899,9 +36065,9 @@ __export(config_exports, {
   parseConfigValue: () => parseConfigValue,
   setConfigValue: () => setConfigValue
 });
-import { existsSync as existsSync15 } from "node:fs";
+import { existsSync as existsSync16 } from "node:fs";
 import { mkdir as mkdir3, writeFile } from "node:fs/promises";
-import { dirname as dirname7 } from "node:path";
+import { dirname as dirname8 } from "node:path";
 function getNestedValue(obj, path) {
   const parts = path.split(".");
   let current = obj;
@@ -36023,8 +36189,8 @@ function parseConfigValue(value) {
 }
 async function setConfigValue(key, value, cwd, opts) {
   const configPath = opts?.global ? getGlobalConfigPath() : getConfigPath(cwd);
-  if (!existsSync15(configPath)) {
-    const dir = dirname7(configPath);
+  if (!existsSync16(configPath)) {
+    const dir = dirname8(configPath);
     await mkdir3(dir, { recursive: true });
     await writeFile(configPath, "{}", "utf-8");
   }
@@ -36037,8 +36203,8 @@ 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 (!existsSync15(configPath)) {
-    const dir = dirname7(configPath);
+  if (!existsSync16(configPath)) {
+    const dir = dirname8(configPath);
     await mkdir3(dir, { recursive: true });
     await writeFile(configPath, "{}", "utf-8");
   }
@@ -36239,10 +36405,10 @@ var init_config = __esm({
 // packages/core/src/llm/credential-seeders/claude-code-seeder.ts
 import { readFileSync as readFileSync6 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 function defaultReadCredentialFile() {
   try {
-    return readFileSync6(join15(homedir2(), ".claude", ".credentials.json"), "utf-8");
+    return readFileSync6(join16(homedir2(), ".claude", ".credentials.json"), "utf-8");
   } catch {
     return null;
   }
@@ -36337,9 +36503,9 @@ var init_claude_code_seeder = __esm({
 
 // packages/core/src/llm/credential-seeders/cleo-pkce-seeder.ts
 import { readFileSync as readFileSync7 } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 function defaultCleoPkcePath() {
-  return join16(getCleoHome(), "anthropic-oauth.json");
+  return join17(getCleoHome(), "anthropic-oauth.json");
 }
 function defaultReadCredentialFile2() {
   try {
@@ -36410,13 +36576,13 @@ var init_cleo_pkce_seeder = __esm({
 });
 
 // packages/core/src/llm/credential-seeders/codex-cli-seeder.ts
-import { existsSync as existsSync16, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync17, readFileSync as readFileSync8 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 function getCodexAuthPath() {
   const codexHome = (process.env["CODEX_HOME"] ?? "").trim();
-  const root = codexHome || join17(homedir3(), ".codex");
-  return join17(root, "auth.json");
+  const root = codexHome || join18(homedir3(), ".codex");
+  return join18(root, "auth.json");
 }
 var CodexCliSeeder, codexCliSeeder;
 var init_codex_cli_seeder = __esm({
@@ -36435,7 +36601,7 @@ var init_codex_cli_seeder = __esm({
        */
       async seed() {
         const authPath = getCodexAuthPath();
-        if (!existsSync16(authPath)) {
+        if (!existsSync17(authPath)) {
           return { entries: [] };
         }
         let raw;
@@ -36565,11 +36731,11 @@ var init_google_pkce = __esm({
 });
 
 // packages/core/src/llm/credential-seeders/gemini-cli-seeder.ts
-import { existsSync as existsSync17, readFileSync as readFileSync9 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync9 } from "node:fs";
+import { join as join19 } from "node:path";
 import { getCleoHome as getCleoHome3 } from "@cleocode/paths";
 function getGoogleOauthPath() {
-  return join18(getCleoHome3(), "google_oauth.json");
+  return join19(getCleoHome3(), "google_oauth.json");
 }
 function parseGoogleOauthFile(raw) {
   let json3;
@@ -36614,7 +36780,7 @@ var init_gemini_cli_seeder = __esm({
        */
       async seed() {
         const path = getGoogleOauthPath();
-        if (!existsSync17(path)) {
+        if (!existsSync18(path)) {
           return { entries: [] };
         }
         let raw;
@@ -36839,23 +37005,23 @@ var init_credential_seeders = __esm({
 
 // packages/core/src/llm/global-config-migration.ts
 import {
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   mkdirSync as mkdirSync5,
   readFileSync as readFileSync10,
   renameSync as renameSync4,
   unlinkSync as unlinkSync5,
   writeFileSync as writeFileSync4
 } from "node:fs";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 import { getCleoHome as getCleoHome4, getCleoPlatformPaths as getCleoPlatformPaths2 } from "@cleocode/paths";
 function configDirGlobalConfigPath() {
-  return join19(getCleoPlatformPaths2().config, GLOBAL_CONFIG_FILENAME);
+  return join20(getCleoPlatformPaths2().config, GLOBAL_CONFIG_FILENAME);
 }
 function legacyGlobalConfigPath() {
-  return join19(getCleoHome4(), GLOBAL_CONFIG_FILENAME);
+  return join20(getCleoHome4(), GLOBAL_CONFIG_FILENAME);
 }
 function migrationMarkerPath() {
-  return join19(getCleoHome4(), MIGRATIONS_SUBDIR, MIGRATION_MARKER);
+  return join20(getCleoHome4(), MIGRATIONS_SUBDIR, MIGRATION_MARKER);
 }
 function tempTargetPath() {
   return `${configDirGlobalConfigPath()}.tmp`;
@@ -36865,12 +37031,12 @@ function migrateGlobalConfigToConfigDir() {
     const source = legacyGlobalConfigPath();
     const target = configDirGlobalConfigPath();
     const marker16 = migrationMarkerPath();
-    if (existsSync18(marker16)) return false;
-    if (!existsSync18(source)) {
+    if (existsSync19(marker16)) return false;
+    if (!existsSync19(source)) {
       stampMarker(marker16);
       return false;
     }
-    if (existsSync18(target)) {
+    if (existsSync19(target)) {
       backupSourceQuiet(source);
       stampMarker(marker16);
       return false;
@@ -36903,7 +37069,7 @@ function migrateGlobalConfigToConfigDir() {
   } catch (err) {
     try {
       const temp = tempTargetPath();
-      if (existsSync18(temp)) unlinkSync5(temp);
+      if (existsSync19(temp)) unlinkSync5(temp);
     } catch {
     }
     console.error(
@@ -36914,7 +37080,7 @@ function migrateGlobalConfigToConfigDir() {
 }
 function stampMarker(markerPath) {
   try {
-    mkdirSync5(join19(getCleoHome4(), MIGRATIONS_SUBDIR), { recursive: true });
+    mkdirSync5(join20(getCleoHome4(), MIGRATIONS_SUBDIR), { recursive: true });
     writeFileSync4(markerPath, `${(/* @__PURE__ */ new Date()).toISOString()}
 `, { mode: 420 });
   } catch {
@@ -36923,7 +37089,7 @@ function stampMarker(markerPath) {
 function backupSourceQuiet(source) {
   try {
     const backup = `${source}${BACKUP_SUFFIX}`;
-    if (existsSync18(backup)) return;
+    if (existsSync19(backup)) return;
     renameSync4(source, backup);
   } catch {
   }
@@ -36946,15 +37112,15 @@ var init_global_config_migration = __esm({
 });
 
 // packages/core/src/llm/legacy-flat-key-import.ts
-import { existsSync as existsSync19, readFileSync as readFileSync11, renameSync as renameSync5, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync20, readFileSync as readFileSync11, renameSync as renameSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join21 } from "node:path";
 import { getCleoHome as getCleoHome5 } from "@cleocode/paths";
 function migrationPaths() {
   const home = getCleoHome5();
   return {
-    flatPath: join20(home, "anthropic-key"),
-    bakPath: join20(home, `anthropic-key${LEGACY_FLAT_KEY_BAK_SUFFIX}`),
-    markerPath: join20(home, LEGACY_FLAT_KEY_MARKER)
+    flatPath: join21(home, "anthropic-key"),
+    bakPath: join21(home, `anthropic-key${LEGACY_FLAT_KEY_BAK_SUFFIX}`),
+    markerPath: join21(home, LEGACY_FLAT_KEY_MARKER)
   };
 }
 function writeMarker(markerPath) {
@@ -36975,7 +37141,7 @@ function writeMarker(markerPath) {
 }
 function readFlatKey(flatPath) {
   try {
-    if (!existsSync19(flatPath)) return null;
+    if (!existsSync20(flatPath)) return null;
     const raw = readFileSync11(flatPath, "utf-8").trim();
     return raw || null;
   } catch (err) {
@@ -36988,7 +37154,7 @@ function readFlatKey(flatPath) {
 }
 async function importLegacyFlatAnthropicKey() {
   const { flatPath, bakPath, markerPath } = migrationPaths();
-  if (existsSync19(markerPath)) {
+  if (existsSync20(markerPath)) {
     return { status: "marker-present", flatPath, bakPath: null, markerPath };
   }
   let existing = null;
@@ -37005,7 +37171,7 @@ async function importLegacyFlatAnthropicKey() {
     writeMarker(markerPath);
     return { status: "already-imported", flatPath, bakPath: null, markerPath };
   }
-  if (!existsSync19(flatPath)) {
+  if (!existsSync20(flatPath)) {
     writeMarker(markerPath);
     return { status: "no-flat-file", flatPath, bakPath: null, markerPath };
   }
@@ -37081,15 +37247,15 @@ __export(credentials_exports, {
   resolveProviderStatus: () => resolveProviderStatus,
   storeAnthropicApiKey: () => storeAnthropicApiKey
 });
-import { existsSync as existsSync20, mkdirSync as mkdirSync6, readFileSync as readFileSync12, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join21 } from "node:path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync6, readFileSync as readFileSync12, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join22 } from "node:path";
 import { getCleoHome as getCleoHome6 } from "@cleocode/paths";
 function globalConfigPath() {
   return configDirGlobalConfigPath();
 }
 function projectConfigPath(projectRoot) {
   const cleoDir = process.env["CLEO_DIR"] ?? ".cleo";
-  return join21(projectRoot, cleoDir, "config.json");
+  return join22(projectRoot, cleoDir, "config.json");
 }
 function readGlobalProviderKey(provider) {
   ensureGlobalConfigMigrated();
@@ -37099,8 +37265,8 @@ function readGlobalProviderKey(provider) {
 }
 function readFlatAnthropicKey() {
   try {
-    const keyFile = join21(getCleoHome6(), "anthropic-key");
-    if (!existsSync20(keyFile)) return null;
+    const keyFile = join22(getCleoHome6(), "anthropic-key");
+    if (!existsSync21(keyFile)) return null;
     const stored = readFileSync12(keyFile, "utf-8").trim();
     return stored || null;
   } catch {
@@ -37109,7 +37275,7 @@ function readFlatAnthropicKey() {
 }
 function readProviderKeyFromConfig(configFile, provider) {
   try {
-    if (!existsSync20(configFile)) return null;
+    if (!existsSync21(configFile)) return null;
     const raw = readFileSync12(configFile, "utf-8");
     const config2 = JSON.parse(raw);
     const llm = config2["llm"];
@@ -37272,10 +37438,10 @@ function resolveProviderStatus(provider) {
 }
 function storeAnthropicApiKey(apiKey) {
   const dir = getCleoHome6();
-  if (!existsSync20(dir)) {
+  if (!existsSync21(dir)) {
     mkdirSync6(dir, { recursive: true });
   }
-  const keyFile = join21(dir, "anthropic-key");
+  const keyFile = join22(dir, "anthropic-key");
   writeFileSync6(keyFile, apiKey.trim(), { mode: 384 });
 }
 function clearAnthropicKeyCache() {
@@ -37327,16 +37493,16 @@ var init_credentials2 = __esm({
 });
 
 // packages/core/src/llm/credentials-store.ts
-import { chmodSync, existsSync as existsSync21, mkdirSync as mkdirSync7, readFileSync as readFileSync13, statSync as statSync6, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname8, join as join22 } from "node:path";
+import { chmodSync, existsSync as existsSync22, mkdirSync as mkdirSync7, readFileSync as readFileSync13, statSync as statSync6, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname9, join as join23 } from "node:path";
 import { getCleoHome as getCleoHome7 } from "@cleocode/paths";
 function credentialsStorePath() {
-  return join22(getCleoHome7(), "llm-credentials.json");
+  return join23(getCleoHome7(), "llm-credentials.json");
 }
 function ensureFileInitialized(path) {
-  if (existsSync21(path)) return;
-  const dir = dirname8(path);
-  if (!existsSync21(dir)) {
+  if (existsSync22(path)) return;
+  const dir = dirname9(path);
+  if (!existsSync22(dir)) {
     mkdirSync7(dir, { recursive: true, mode: 448 });
   } else {
     try {
@@ -37713,13 +37879,13 @@ var init_gemini = __esm({
 
 // packages/core/src/llm/stable-device-id.ts
 import { randomUUID } from "node:crypto";
-import { existsSync as existsSync22, mkdirSync as mkdirSync8, readFileSync as readFileSync14, renameSync as renameSync6, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname9, join as join23 } from "node:path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync8, readFileSync as readFileSync14, renameSync as renameSync6, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname10, join as join24 } from "node:path";
 import { getCleoHome as getCleoHome8 } from "@cleocode/paths";
 function getStableDeviceId() {
   if (_cachedDeviceId !== null) return _cachedDeviceId;
-  const path = join23(getCleoHome8(), DEVICE_ID_FILE);
-  if (existsSync22(path)) {
+  const path = join24(getCleoHome8(), DEVICE_ID_FILE);
+  if (existsSync23(path)) {
     try {
       const raw = readFileSync14(path, "utf-8").trim();
       if (raw.length > 0) {
@@ -37731,8 +37897,8 @@ function getStableDeviceId() {
   }
   const fresh = randomUUID();
   try {
-    const dir = dirname9(path);
-    if (!existsSync22(dir)) {
+    const dir = dirname10(path);
+    if (!existsSync23(dir)) {
       mkdirSync8(dir, { recursive: true });
     }
     const tmpPath = `${path}.tmp.${process.pid}`;
@@ -38035,13 +38201,13 @@ var init_xai = __esm({
 
 // packages/core/src/llm/provider-registry/loader.ts
 import { readdirSync as readdirSync5, statSync as statSync7 } from "node:fs";
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 import { pathToFileURL } from "node:url";
 function isPluginFile(filename) {
   return PLUGIN_EXTENSIONS.some((ext) => filename.endsWith(ext));
 }
 function getPluginDir() {
-  return join24(getCleoHome(), "plugins", "model-providers");
+  return join25(getCleoHome(), "plugins", "model-providers");
 }
 async function loadOnePlugin(absPath, api) {
   let mod;
@@ -38089,13 +38255,13 @@ async function scanAndLoadPlugins(pluginDir, api) {
   }
   const pluginFiles = entries.filter((name15) => !name15.startsWith(".") && isPluginFile(name15)).filter((name15) => {
     try {
-      return statSync7(join24(pluginDir, name15)).isFile();
+      return statSync7(join25(pluginDir, name15)).isFile();
     } catch {
       return false;
     }
   }).sort();
   for (const filename of pluginFiles) {
-    await loadOnePlugin(join24(pluginDir, filename), api);
+    await loadOnePlugin(join25(pluginDir, filename), api);
   }
 }
 async function runDiscovery(registerProvider2, builtins) {
@@ -38176,15 +38342,15 @@ var init_provider_registry = __esm({
 });
 
 // packages/core/src/llm/rate-limit-guard.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync9, unlinkSync as unlinkSync6 } from "node:fs";
-import { join as join25 } from "node:path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync9, unlinkSync as unlinkSync6 } from "node:fs";
+import { join as join26 } from "node:path";
 import { getCleoHome as getCleoHome9 } from "@cleocode/paths";
 function sanitize(value) {
   return value.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 function rateLimitStatePath(provider, label) {
-  const dir = join25(getCleoHome9(), "rate-limit-state");
-  return join25(dir, `${sanitize(provider)}-${sanitize(label)}.json`);
+  const dir = join26(getCleoHome9(), "rate-limit-state");
+  return join26(dir, `${sanitize(provider)}-${sanitize(label)}.json`);
 }
 function parseResetFromHeaders(headers) {
   const get = (k) => {
@@ -38231,8 +38397,8 @@ async function recordRateLimit(provider, label, opts) {
     source = "default";
   }
   const filePath = rateLimitStatePath(provider, label);
-  const dir = join25(getCleoHome9(), "rate-limit-state");
-  if (!existsSync23(dir)) {
+  const dir = join26(getCleoHome9(), "rate-limit-state");
+  if (!existsSync24(dir)) {
     mkdirSync9(dir, { recursive: true });
   }
   const state = { resetAt, recordedAt: now, source };
@@ -39075,14 +39241,14 @@ var init_catalog_cache = __esm({
 
 // packages/core/src/llm/model-metadata.ts
 import { readFileSync as readFileSync15 } from "node:fs";
-import { dirname as dirname10, join as join26 } from "node:path";
+import { dirname as dirname11, join as join27 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function getCuratedTable() {
   if (_curated !== void 0) {
     return _curated;
   }
-  const thisDir = dirname10(fileURLToPath3(import.meta.url));
-  const jsonPath = join26(thisDir, "curated-models.json");
+  const thisDir = dirname11(fileURLToPath3(import.meta.url));
+  const jsonPath = join27(thisDir, "curated-models.json");
   const raw = JSON.parse(readFileSync15(jsonPath, "utf-8"));
   _curated = raw.models;
   return _curated;