@cleocode/core 2026.6.8 → 2026.6.10

package/dist/docs/export-document.js

@@ -14555,7 +14555,7 @@ var init_sql = __esm({
         return new SQL([new StringChunk(str)]);
       }
       _sql.raw = raw;
-      function join22(chunks, separator) {
+      function join23(chunks, separator) {
         const result = [];
         for (const [i, chunk] of chunks.entries()) {
           if (i > 0 && separator !== void 0) result.push(separator);
@@ -14563,7 +14563,7 @@ var init_sql = __esm({
         }
         return new SQL(result);
       }
-      _sql.join = join22;
+      _sql.join = join23;
       function identifier(value) {
         return new Name(value);
       }
@@ -16950,7 +16950,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((join22) => join22.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+          if (typeof tableName === "string" && this.config.joins?.some((join23) => join23.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)) {
@@ -20760,7 +20760,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, join22]) => {
+          return sql.join(withEntries.map(([k, join23]) => {
             const relation = tableConfig.relations[k];
             const isSingle2 = is(relation, One);
             const targetTable = aliasedTable(relation.targetTable, `d${currentDepth + 1}`);
@@ -20771,7 +20771,7 @@ var init_dialect = __esm({
               table: targetTable,
               mode: isSingle2 ? "first" : "many",
               schema,
-              queryConfig: join22,
+              queryConfig: join23,
               tableConfig: schema[relation.targetTableName],
               relationWhere: filter,
               isNested: true,
@@ -20785,7 +20785,7 @@ var init_dialect = __esm({
               key: k,
               selection: innerQuery.selection,
               isArray: !isSingle2,
-              isOptional: (relation.optional ?? false) || join22 !== true && !!join22.where
+              isOptional: (relation.optional ?? false) || join23 !== true && !!join23.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)}`;
@@ -21606,7 +21606,7 @@ var init_update = __esm({
       createJoin(joinType) {
         return ((table, on) => {
           const tableName = getTableLikeName(table);
-          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 tableName === "string" && this.config.joins.some((join23) => join23.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({
@@ -22596,6 +22596,66 @@ 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(sql39) {
+  return sql39.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;
@@ -22622,9 +22682,9 @@ function insertJournalEntry(nativeDb, hash, createdAt, name2) {
     `INSERT OR IGNORE INTO "__drizzle_migrations" ("hash", "created_at", "name") VALUES ('${hash}', ${createdAt}, '${name2}')`
   );
 }
-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;
@@ -22651,10 +22711,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 = [];
@@ -22663,6 +22730,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 }) => {
@@ -22670,7 +22745,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;
@@ -22697,6 +22774,8 @@ function probeAndMarkApplied(nativeDb, migration, logSubsystem) {
   return false;
 }
 function reconcileJournal(nativeDb, migrationsFolder, existenceTable2, logSubsystem) {
+  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];
@@ -22740,7 +22819,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);
         }
       }
     }
@@ -22763,7 +22842,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 log10 = getLogger(logSubsystem);
           log10.debug(
@@ -22782,9 +22861,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;
       }
@@ -22875,6 +22956,7 @@ function reconcileBrainMigrationsForConsolidatedDb(nativeDb, migrationsFolder) {
   const existingHashes = new Set(
     nativeDb.prepare('SELECT hash FROM "__drizzle_migrations"').all().map((r) => r.hash)
   );
+  const eliminatedTables = computeEliminatedTables(localMigrations);
   const createTableRegex = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?[`"]?(\w+)[`"]?/gi;
   const renameRegex = /ALTER\s+TABLE\s+[`"]?(\w+)[`"]?\s+RENAME\s+TO\s+[`"]?(\w+)[`"]?/gi;
   const addColumnRegex = /ALTER\s+TABLE\s+[`"]?(\w+)[`"]?\s+ADD\s+COLUMN\s+[`"]?(\w+)[`"]?/gi;
@@ -22883,7 +22965,6 @@ function reconcileBrainMigrationsForConsolidatedDb(nativeDb, migrationsFolder) {
     const cols = nativeDb.prepare(`PRAGMA table_info("${table}")`).all();
     return cols.some((c) => c.name === column);
   };
-  const stripSqlComments = (sql39) => sql39.replace(/--[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
   let marked = 0;
   let applied = 0;
   for (const m of localMigrations) {
@@ -22904,7 +22985,7 @@ function reconcileBrainMigrationsForConsolidatedDb(nativeDb, migrationsFolder) {
     for (const match of fullSql.matchAll(addColumnRegex)) {
       addColumns.push({ table: match[1], column: match[2] });
     }
-    const tablesSatisfied = resultTables.size > 0 && [...resultTables].every((t) => tableExists(nativeDb, t));
+    const tablesSatisfied = resultTables.size > 0 && [...resultTables].every((t) => tableExists(nativeDb, t) || eliminatedTables.has(t));
     const altersSatisfied = resultTables.size === 0 && addColumns.length > 0 && addColumns.every(({ table, column }) => columnExists(table, column));
     if (tablesSatisfied || altersSatisfied) {
       for (const statement of m.sql) {
@@ -22927,13 +23008,22 @@ function reconcileBrainMigrationsForConsolidatedDb(nativeDb, migrationsFolder) {
   }
   return { marked, applied };
 }
+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;
@@ -23004,7 +23094,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";
@@ -23014,27 +23104,29 @@ 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 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 _require6 = createRequire(import.meta.url);
   try {
     const entryPath = _require6.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}`
@@ -27439,12 +27531,42 @@ var init_attachments = __esm({
          *
          * @task T11181 (Epic T10518 / Saga T10516)
          */
-        docVersion: integer("doc_version").notNull().default(1)
+        docVersion: integer("doc_version").notNull().default(1),
+        /**
+         * Optional explicit display-alias NUMBER for the doc, DECOUPLED from the
+         * slug string.
+         *
+         * Background (T11875 · ADR reconcile T11676): under the ratified
+         * slug-primary model the kebab `slug` is the canonical handle and the
+         * displayed number (e.g. ADR "051") is a DISPLAY ALIAS only. Previously
+         * that number was DERIVED by parsing the digits out of the slug
+         * (`adr-051-*` → 051), so three distinct ADRs that all slug as `adr-051-*`
+         * collided on the rendered number with no way to disambiguate.
+         *
+         * When non-null, this column is the authoritative display number and is
+         * PREFERRED over the slug-derived number by
+         * {@link import('../../docs/numbering.js').resolveDisplayNumber}. When null,
+         * rendering falls back to the slug-derived number unchanged — so docs that
+         * never had an alias assigned keep their historical behaviour.
+         *
+         * Uniqueness among `type='adr'` docs is enforced at the dispatch layer (not
+         * via a SQL UNIQUE constraint) by
+         * {@link import('../../docs/display-alias.js').setDisplayAlias}, mirroring
+         * the dispatch-validated discipline used for `lifecycle_status` /
+         * `relation` so future taxonomy changes never require a schema migration.
+         *
+         * @task T11875 (Epic T11781 / Saga T11778)
+         */
+        displayAlias: integer("display_alias")
       },
       (table) => [
         index("idx_attachments_sha256").on(table.sha256),
         index("idx_attachments_lifecycle_status").on(table.lifecycleStatus),
-        index("idx_attachments_supersedes").on(table.supersedes)
+        index("idx_attachments_supersedes").on(table.supersedes),
+        // Speeds the per-type uniqueness scan in `setDisplayAlias` (T11875). Not a
+        // UNIQUE index — uniqueness is scoped to `type='adr'` and enforced at the
+        // dispatch layer so non-adr kinds may reuse numbers freely.
+        index("idx_attachments_display_alias").on(table.displayAlias)
       ]
     );
     attachmentRefs = sqliteTable(
@@ -31195,11 +31317,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
@@ -31232,7 +31354,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 });
@@ -31243,14 +31365,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);
@@ -31258,7 +31380,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) {
@@ -31538,15 +31660,15 @@ var init_json2 = __esm({
 
 // packages/core/src/scaffold/ensure-config.ts
 import { existsSync as existsSync3, readFileSync } from "node:fs";
-import { basename as basename2, dirname as dirname3, join as join5, resolve as resolve2 } from "node:path";
+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 {
@@ -31571,15 +31693,15 @@ import {
   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 {
@@ -31607,10 +31729,10 @@ function writeExodusCompleteMarker(scope, archivedSources, cwd) {
 }
 function moveFileInto(srcPath, destDir) {
   mkdirSync(destDir, { recursive: true });
-  let dest = join6(destDir, basename3(srcPath));
+  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);
@@ -31709,11 +31831,11 @@ var init_archive2 = __esm({
 
 // packages/core/src/project-info.ts
 import { existsSync as existsSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 function getProjectInfoSync(cwd) {
   const projectRoot = resolveOrCwd(cwd);
   const cleoDir = getCleoDirAbsolute(projectRoot);
-  const infoPath = join7(cleoDir, "project-info.json");
+  const infoPath = join8(cleoDir, "project-info.json");
   if (!existsSync5(infoPath)) return null;
   try {
     const raw = readFileSync2(infoPath, "utf-8");
@@ -31742,7 +31864,7 @@ var init_project_info = __esm({
 
 // packages/core/src/store/worktree-isolation-guard.ts
 import { existsSync as existsSync6, statSync } from "node:fs";
-import { dirname as dirname4, join as join8 } from "node:path";
+import { dirname as dirname5, join as join9 } from "node:path";
 function assertDbPathIsNotWorktreeResident(role, cwd) {
   let cleoDir;
   try {
@@ -31750,8 +31872,8 @@ function assertDbPathIsNotWorktreeResident(role, cwd) {
   } catch {
     return;
   }
-  const projectRoot = dirname4(cleoDir);
-  const projectGit = join8(projectRoot, ".git");
+  const projectRoot = dirname5(cleoDir);
+  const projectGit = join9(projectRoot, ".git");
   let isWorktreeGitlink = false;
   try {
     isWorktreeGitlink = existsSync6(projectGit) && statSync(projectGit).isFile();
@@ -32306,7 +32428,7 @@ var init_count_parity = __esm({
 
 // packages/core/src/store/exodus/plan.ts
 import { existsSync as existsSync8, readdirSync as readdirSync2, statfsSync, statSync as statSync2 } from "node:fs";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 function computeRequiredBytes(totalSourceBytes, largestSourceBytes) {
   return Math.ceil(STAGING_HEADROOM_FACTOR * largestSourceBytes) + totalSourceBytes;
 }
@@ -32317,33 +32439,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"
     }
   ];
@@ -32372,7 +32494,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 {
   }
@@ -32388,7 +32510,7 @@ function buildExodusPlan(cwd) {
   const availableBytes = getAvailableBytes(cleoDir);
   const diskPreflight = totalSourceBytes === 0 || availableBytes >= requiredBytes;
   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");
@@ -32707,7 +32829,7 @@ import {
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync3
 } from "node:fs";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 function getSqliteVersion(db) {
   try {
     const row = db.prepare("SELECT sqlite_version() AS v").get();
@@ -32723,13 +32845,13 @@ function listTables2(db) {
   return rows.map((r) => r.name);
 }
 function writeJournal(stagingDir, journal) {
-  const journalPath = join10(stagingDir, JOURNAL_FILENAME);
+  const journalPath = join11(stagingDir, JOURNAL_FILENAME);
   const tmpPath = `${journalPath}.tmp`;
   writeFileSync3(tmpPath, JSON.stringify(journal, null, 2) + "\n", "utf8");
   renameSync2(tmpPath, journalPath);
 }
 function readJournal(stagingDir) {
-  const journalPath = join10(stagingDir, JOURNAL_FILENAME);
+  const journalPath = join11(stagingDir, JOURNAL_FILENAME);
   if (!existsSync10(journalPath)) return null;
   try {
     return JSON.parse(readFileSync3(journalPath, "utf8"));
@@ -32738,7 +32860,7 @@ function readJournal(stagingDir) {
   }
 }
 function clearExodusJournal(stagingDir) {
-  const journalPath = join10(stagingDir, JOURNAL_FILENAME);
+  const journalPath = join11(stagingDir, JOURNAL_FILENAME);
   try {
     if (!existsSync10(journalPath)) return false;
     unlinkSync2(journalPath);
@@ -33047,7 +33169,7 @@ async function runExodusMigrate(plan, forceCrossVersion = false, onProgress) {
     var extractNativeDb = extractNativeDb2;
     for (const src of sources) {
       if (!existsSync10(src.path)) continue;
-      const backupDest = join10(stagingDir, `${src.name.replace(/[^a-z0-9-]/g, "_")}-backup.db`);
+      const backupDest = join11(stagingDir, `${src.name.replace(/[^a-z0-9-]/g, "_")}-backup.db`);
       const srcBytes = safeStatBytes(src.path);
       const skipStagingCopy = srcBytes > plan.stagingCopyThresholdBytes;
       if (skipStagingCopy) {
@@ -33349,9 +33471,9 @@ var init_seal = __esm({
 
 // packages/core/src/store/exodus/status.ts
 import { existsSync as existsSync11, readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync5 } from "node:fs";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 function readJournal2(stagingDir) {
-  const p = join11(stagingDir, JOURNAL_FILENAME2);
+  const p = join12(stagingDir, JOURNAL_FILENAME2);
   if (!existsSync11(p)) return null;
   try {
     return JSON.parse(readFileSync4(p, "utf8"));
@@ -33361,7 +33483,7 @@ function readJournal2(stagingDir) {
 }
 function findStagingDirs(cleoDir) {
   try {
-    return readdirSync3(cleoDir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith("exodus-staging-")).map((e) => join11(cleoDir, e.name)).sort().reverse();
+    return readdirSync3(cleoDir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith("exodus-staging-")).map((e) => join12(cleoDir, e.name)).sort().reverse();
   } catch {
     return [];
   }
@@ -34213,7 +34335,7 @@ __export(dual_scope_db_exports, {
 });
 import { existsSync as existsSync14, mkdirSync as mkdirSync3 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { dirname as dirname5, join as join12 } from "node:path";
+import { dirname as dirname6, join as join13 } from "node:path";
 function assertWriteDurable(handle) {
   if (handle.exodusAbort) {
     throw new ExodusAbortWriteUnsafeError(handle.exodusAbort);
@@ -34230,9 +34352,9 @@ function cacheKey(scope, dbPath) {
 }
 function resolveDualScopeDbPath(scope, cwd) {
   if (scope === "project") {
-    return join12(resolveCleoDir(cwd), "cleo.db");
+    return join13(resolveCleoDir(cwd), "cleo.db");
   }
-  return join12(getCleoHome(), "cleo.db");
+  return join13(getCleoHome(), "cleo.db");
 }
 function migrationsSetName(scope) {
   return scope === "project" ? "drizzle-cleo-project" : "drizzle-cleo-global";
@@ -34272,7 +34394,7 @@ async function openDualScopeDb(scope, cwd) {
 }
 async function openDedicatedDualScopeDb(scope, dbPath, log10) {
   log10.debug({ scope, dbPath }, "opening DEDICATED (non-cached) dual-scope cleo.db (T11782 FIX D)");
-  const dir = dirname5(dbPath);
+  const dir = dirname6(dbPath);
   if (!existsSync14(dir)) {
     mkdirSync3(dir, { recursive: true });
   }
@@ -34322,7 +34444,7 @@ async function openDualScopeDbAtPath(scope, dbPath, exodusCwd, options) {
   }
   const initPromise = (async () => {
     log10.debug({ scope, dbPath }, "opening dual-scope cleo.db");
-    const dir = dirname5(dbPath);
+    const dir = dirname6(dbPath);
     if (!existsSync14(dir)) {
       mkdirSync3(dir, { recursive: true });
     }
@@ -34401,6 +34523,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) {
@@ -34992,7 +35120,7 @@ __export(nexus_sqlite_exports, {
   resolveNexusMigrationsFolder: () => resolveNexusMigrationsFolder
 });
 import { copyFileSync as copyFileSync4, existsSync as existsSync15 } from "node:fs";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 function getNexusDbPath(cwd) {
   return resolveDualScopeDbPath("project", cwd);
 }
@@ -35024,7 +35152,7 @@ function resolveNexusMigrationsFolder() {
   return resolveCorePackageMigrationsFolder("drizzle-nexus");
 }
 function getNestedNexusSentinelPath() {
-  return join13(getCleoHome(), "nexus", NESTED_NEXUS_SENTINEL);
+  return join14(getCleoHome(), "nexus", NESTED_NEXUS_SENTINEL);
 }
 function detectAndWarnOnNestedNexus() {
   let nestedPath;
@@ -35327,7 +35455,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { existsSync as existsSync16, readFileSync as readFileSync5, statSync as statSync6 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
 import { homedir } from "node:os";
-import { basename as basename4, dirname as dirname6, join as join14, resolve as resolve3 } from "node:path";
+import { basename as basename4, dirname as dirname7, join as join15, resolve as resolve3 } from "node:path";
 import {
   computeCanonicalProjectId as _computeCanonicalProjectId,
   getCanonicalTemplatesTildePath as _getCanonicalTemplatesTildePath,
@@ -35417,7 +35545,7 @@ function getCleoDirAbsolute(cwd, opts) {
 function _resolveProjectByCwdFromNexus(cwd) {
   try {
     const cleoHome = getCleoHome();
-    const globalDbPath = join14(cleoHome, "cleo.db");
+    const globalDbPath = join15(cleoHome, "cleo.db");
     if (!existsSync16(globalDbPath)) return null;
     const start = resolve3(cwd ?? process.cwd());
     let current = start;
@@ -35432,7 +35560,7 @@ function _resolveProjectByCwdFromNexus(cwd) {
         if (row && typeof row.project_id === "string" && row.project_id.length > 0) {
           return row.project_id;
         }
-        const parent = dirname6(current);
+        const parent = dirname7(current);
         if (parent === current) break;
         current = parent;
       }
@@ -35457,13 +35585,13 @@ function _findCleoDirRoot(cwd) {
     const isDangerousRoot = current === homeRoot || current === "/" || current === "";
     if (!isDangerousRoot) {
       try {
-        if (statSync6(join14(current, ".cleo")).isDirectory()) {
+        if (statSync6(join15(current, ".cleo")).isDirectory()) {
           return current;
         }
       } catch {
       }
     }
-    const parent = dirname6(current);
+    const parent = dirname7(current);
     if (parent === current) break;
     current = parent;
   }
@@ -35472,7 +35600,7 @@ function _findCleoDirRoot(cwd) {
 function resolveCleoDir(cwd) {
   const scope = worktreeScope.getStore();
   if (scope !== void 0) {
-    return join14(scope.worktreeRoot, ".cleo");
+    return join15(scope.worktreeRoot, ".cleo");
   }
   const override = _cleoDirEnvOverride();
   if (override !== null) {
@@ -35480,16 +35608,16 @@ function resolveCleoDir(cwd) {
   }
   const root = _findCleoDirRoot(cwd);
   if (root !== null) {
-    return join14(root, ".cleo");
+    return join15(root, ".cleo");
   }
   const start = resolve3(cwd ?? process.cwd());
   let current = start;
   while (true) {
     const mainRepo = _resolveMainRepoFromGitlink(current);
     if (mainRepo !== null) {
-      return join14(mainRepo, ".cleo");
+      return join15(mainRepo, ".cleo");
     }
-    const parent = dirname6(current);
+    const parent = dirname7(current);
     if (parent === current) {
       break;
     }
@@ -35529,21 +35657,21 @@ function _cwdHasGitAncestor(cwd) {
   const start = resolve3(cwd ?? process.cwd());
   let current = start;
   while (true) {
-    const gitMarker = join14(current, ".git");
+    const gitMarker = join15(current, ".git");
     try {
       if (existsSync16(gitMarker)) {
         return true;
       }
     } catch {
     }
-    const parent = dirname6(current);
+    const parent = dirname7(current);
     if (parent === current) return false;
     current = parent;
   }
 }
 function _resolveMainRepoFromGitlink(gitlinkDir) {
   try {
-    const gitLinkPath = join14(gitlinkDir, ".git");
+    const gitLinkPath = join15(gitlinkDir, ".git");
     if (!existsSync16(gitLinkPath)) return null;
     const stat2 = statSync6(gitLinkPath);
     if (!stat2.isFile()) return null;
@@ -35551,8 +35679,8 @@ function _resolveMainRepoFromGitlink(gitlinkDir) {
     const match = gitLinkContent.match(/^gitdir:\s*(.+)$/m);
     if (!match) return null;
     const gitdir = match[1].trim();
-    const mainRepo = dirname6(dirname6(dirname6(gitdir)));
-    if (existsSync16(join14(mainRepo, ".cleo")) && validateProjectRoot(mainRepo)) {
+    const mainRepo = dirname7(dirname7(dirname7(gitdir)));
+    if (existsSync16(join15(mainRepo, ".cleo")) && validateProjectRoot(mainRepo)) {
       return mainRepo;
     }
   } catch {
@@ -35560,17 +35688,17 @@ function _resolveMainRepoFromGitlink(gitlinkDir) {
   return null;
 }
 function validateProjectRoot(candidate) {
-  const cleoDir = join14(candidate, ".cleo");
+  const cleoDir = join15(candidate, ".cleo");
   if (!existsSync16(cleoDir)) {
     return false;
   }
-  const projectInfoPath = join14(cleoDir, "project-info.json");
+  const projectInfoPath = join15(cleoDir, "project-info.json");
   if (existsSync16(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 = join14(candidate, ".git");
+        const gitMarker = join15(candidate, ".git");
         if (existsSync16(gitMarker)) {
           try {
             if (!statSync6(gitMarker).isDirectory()) {
@@ -35585,7 +35713,7 @@ function validateProjectRoot(candidate) {
     } catch {
     }
   }
-  const gitDir = join14(candidate, ".git");
+  const gitDir = join15(candidate, ".git");
   if (existsSync16(gitDir)) {
     let isRealGitDir = false;
     try {
@@ -35622,7 +35750,7 @@ function getProjectRoot(cwd) {
   const cleoDirEnv = process.env["CLEO_DIR"];
   if (cleoDirEnv && isAbsolutePath(cleoDirEnv)) {
     if (cleoDirEnv.endsWith("/.cleo") || cleoDirEnv.endsWith("\\.cleo")) {
-      return dirname6(cleoDirEnv);
+      return dirname7(cleoDirEnv);
     }
     return cleoDirEnv;
   }
@@ -35633,8 +35761,8 @@ function getProjectRoot(cwd) {
   const homeRoot = homedir();
   const skippedCleoDirs = [];
   while (true) {
-    const cleoDir = join14(current, ".cleo");
-    const gitDir = join14(current, ".git");
+    const cleoDir = join15(current, ".cleo");
+    const gitDir = join15(current, ".git");
     const isDangerousRoot = current === homeRoot || current === "/" || current === "";
     if (existsSync16(cleoDir) && !isDangerousRoot) {
       if (validateProjectRoot(current)) {
@@ -35657,7 +35785,7 @@ function getProjectRoot(cwd) {
       const mainRepoFromWalk = _resolveMainRepoFromGitlink(current);
       if (mainRepoFromWalk !== null) return mainRepoFromWalk;
     }
-    const parent = dirname6(current);
+    const parent = dirname7(current);
     if (parent === current) {
       break;
     }
@@ -35687,17 +35815,17 @@ function resolveOrCwd(maybeRoot) {
   return getProjectRoot();
 }
 function getConfigPath(cwd) {
-  return join14(_resolveCleoDir(cwd), "config.json");
+  return join15(_resolveCleoDir(cwd), "config.json");
 }
 function getGlobalConfigPath() {
-  return join14(getCleoHome(), "config.json");
+  return join15(getCleoHome(), "config.json");
 }
 function isAbsolutePath(path2) {
   return _isAbsolutePath(path2);
 }
 function _readProjectNameFromInfo(projectRoot) {
   try {
-    const infoPath = join14(projectRoot, ".cleo", "project-info.json");
+    const infoPath = join15(projectRoot, ".cleo", "project-info.json");
     if (!existsSync16(infoPath)) return void 0;
     const raw = readFileSync5(infoPath, "utf-8");
     const data = JSON.parse(raw);
@@ -35724,8 +35852,8 @@ async function registerProjectOnEncounter(projectRoot, infoProjectId) {
     if (existingRows.length > 0) {
       const existingPath = existingRows[0].projectPath;
       if (existingPath !== resolvedPath) {
-        const newBrainDbPath = join14(resolvedPath, ".cleo", "brain.db");
-        const newTasksDbPath = join14(resolvedPath, ".cleo", "tasks.db");
+        const newBrainDbPath = join15(resolvedPath, ".cleo", "brain.db");
+        const newTasksDbPath = join15(resolvedPath, ".cleo", "tasks.db");
         await db.update(projectRegistry2).set({
           projectPath: resolvedPath,
           projectHash: generateProjectHash2(resolvedPath),
@@ -35756,8 +35884,8 @@ async function registerProjectOnEncounter(projectRoot, infoProjectId) {
       lastSync: now,
       taskCount: 0,
       labelsJson: "[]",
-      brainDbPath: join14(resolvedPath, ".cleo", "brain.db"),
-      tasksDbPath: join14(resolvedPath, ".cleo", "tasks.db"),
+      brainDbPath: join15(resolvedPath, ".cleo", "brain.db"),
+      tasksDbPath: join15(resolvedPath, ".cleo", "tasks.db"),
       statsJson: "{}"
     }).onConflictDoNothing();
     const aliases = canonicalResult.legacyAliases ?? [];
@@ -35974,7 +36102,7 @@ __export(config_exports, {
 });
 import { existsSync as existsSync17 } 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, path2) {
   const parts = path2.split(".");
   let current = obj;
@@ -36097,7 +36225,7 @@ function parseConfigValue(value) {
 async function setConfigValue(key, value, cwd, opts) {
   const configPath = opts?.global ? getGlobalConfigPath() : getConfigPath(cwd);
   if (!existsSync17(configPath)) {
-    const dir = dirname7(configPath);
+    const dir = dirname8(configPath);
     await mkdir3(dir, { recursive: true });
     await writeFile(configPath, "{}", "utf-8");
   }
@@ -36111,7 +36239,7 @@ async function applyStrictnessPreset(preset, cwd, opts) {
   const definition = STRICTNESS_PRESETS[preset];
   const configPath = opts?.global ? getGlobalConfigPath() : getConfigPath(cwd);
   if (!existsSync17(configPath)) {
-    const dir = dirname7(configPath);
+    const dir = dirname8(configPath);
     await mkdir3(dir, { recursive: true });
     await writeFile(configPath, "{}", "utf-8");
   }
@@ -37286,9 +37414,9 @@ var init_telemetry_schema = __esm({
 
 // packages/core/src/telemetry/sqlite.ts
 import { mkdirSync as mkdirSync4 } from "node:fs";
-import { dirname as dirname8, join as join15 } from "node:path";
+import { dirname as dirname9, join as join16 } from "node:path";
 function getTelemetryDbPath() {
-  return join15(getCleoHome(), DB_FILENAME);
+  return join16(getCleoHome(), DB_FILENAME);
 }
 function resolveTelemetryMigrationsFolder() {
   return resolveCorePackageMigrationsFolder("drizzle-telemetry");
@@ -37336,7 +37464,7 @@ async function getTelemetryDb() {
   _initPromise2 = (async () => {
     const dbPath = requestedPath;
     _dbPath2 = dbPath;
-    mkdirSync4(dirname8(dbPath), { recursive: true });
+    mkdirSync4(dirname9(dbPath), { recursive: true });
     const nativeDb = openNativeDatabase(dbPath);
     _nativeDb2 = nativeDb;
     const db = drizzle({ client: nativeDb, schema: telemetry_schema_exports });
@@ -37370,10 +37498,10 @@ var init_sqlite2 = __esm({
 
 // packages/core/src/store/agent-registry-store.ts
 import { existsSync as existsSync18 } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 function getGlobalAgentRegistryDbPath() {
   const cleoHome = getCleoHome();
-  const dbPath = join16(cleoHome, "cleo.db");
+  const dbPath = join17(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.`
@@ -37714,11 +37842,11 @@ var init_skills_schema = __esm({
 });
 
 // packages/core/src/store/skills-db.ts
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 import { and as and3, eq as eq4 } from "drizzle-orm";
 function getDefaultSkillsDbPath() {
   const cleoHome = getCleoHome();
-  const dbPath = join17(cleoHome, "cleo.db");
+  const dbPath = join18(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.`
@@ -37794,7 +37922,7 @@ import {
   statSync as statSync7,
   unlinkSync as unlinkSync3
 } from "node:fs";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 function resolveInventoryPath(entry, cwd) {
   try {
     if (entry.tier === "global") {
@@ -37829,7 +37957,7 @@ async function openAgentRegistryDbForSnapshot() {
 }
 async function openTelemetryDbForSnapshot() {
   try {
-    const path2 = join18(getCleoHome(), "telemetry.db");
+    const path2 = join19(getCleoHome(), "telemetry.db");
     if (!existsSync20(path2)) return null;
   } catch {
     return null;
@@ -37935,8 +38063,8 @@ function rotateSnapshots(backupDir, prefix) {
     const pattern = snapshotPattern(prefix);
     const files = readdirSync4(backupDir).filter((f) => pattern.test(f)).map((f) => ({
       name: f,
-      path: join18(backupDir, f),
-      mtimeMs: statSync7(join18(backupDir, f)).mtimeMs
+      path: join19(backupDir, f),
+      mtimeMs: statSync7(join19(backupDir, f)).mtimeMs
     })).sort((a, b) => a.mtimeMs - b.mtimeMs);
     while (files.length >= MAX_SNAPSHOTS) {
       const oldest = files.shift();
@@ -37961,7 +38089,7 @@ async function snapshotOne(target, backupDir, now, cwd) {
     if (!db) return;
     opened = db;
   }
-  const dest = join18(backupDir, `${target.prefix}-${formatTimestamp(now)}.db`);
+  const dest = join19(backupDir, `${target.prefix}-${formatTimestamp(now)}.db`);
   try {
     db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
     rotateSnapshots(backupDir, target.prefix);
@@ -37982,7 +38110,7 @@ async function vacuumIntoBackup(opts = {}) {
   }
   try {
     const cleoDir = getCleoDir(opts.cwd);
-    const backupDir = join18(cleoDir, "backups", "sqlite");
+    const backupDir = join19(cleoDir, "backups", "sqlite");
     mkdirSync5(backupDir, { recursive: true });
     const target = SNAPSHOT_TARGETS.find((t) => t.prefix === prefix);
     if (!target) return;
@@ -37994,13 +38122,13 @@ async function vacuumIntoBackup(opts = {}) {
 function listSqliteBackupsForPrefix(prefix, cwd) {
   try {
     const cleoDir = getCleoDir(cwd);
-    const backupDir = join18(cleoDir, "backups", "sqlite");
+    const backupDir = join19(cleoDir, "backups", "sqlite");
     if (!existsSync20(backupDir)) return [];
     const pattern = snapshotPattern(prefix);
     return readdirSync4(backupDir).filter((f) => pattern.test(f)).map((f) => ({
       name: f,
-      path: join18(backupDir, f),
-      mtimeMs: statSync7(join18(backupDir, f)).mtimeMs
+      path: join19(backupDir, f),
+      mtimeMs: statSync7(join19(backupDir, f)).mtimeMs
     })).sort((a, b) => b.mtimeMs - a.mtimeMs);
   } catch {
     return [];
@@ -38056,7 +38184,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 join19, resolve as resolve4, sep } from "node:path";
+import { delimiter, dirname as dirname10, isAbsolute, join as join20, resolve as resolve4, sep } from "node:path";
 function getDbSyncConstructor() {
   if (_ctor === null) {
     const mod = _require5("node:sqlite");
@@ -38072,12 +38200,12 @@ function resolveAbsoluteSafe(p) {
     const missingParts = [];
     let cursor = abs;
     while (true) {
-      const parent = dirname9(cursor);
+      const parent = dirname10(cursor);
       if (parent === cursor) return abs;
       missingParts.unshift(cursor.slice(parent.length + (parent.endsWith(sep) ? 0 : 1)));
       cursor = parent;
       try {
-        return join19(realpathSync(cursor), ...missingParts);
+        return join20(realpathSync(cursor), ...missingParts);
       } catch {
       }
     }
@@ -39583,12 +39711,12 @@ var init_sqlite_data_accessor = __esm({
 
 // packages/core/src/sequence/index.ts
 import { existsSync as existsSync22, readFileSync as readFileSync6, renameSync as renameSync4 } from "node:fs";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 function getLegacySequenceJsonPath(cwd) {
-  return join20(resolveOrCwd(cwd), ".cleo", ".sequence.json");
+  return join21(resolveOrCwd(cwd), ".cleo", ".sequence.json");
 }
 function getLegacySequencePath(cwd) {
-  return join20(resolveOrCwd(cwd), ".cleo", ".sequence");
+  return join21(resolveOrCwd(cwd), ".cleo", ".sequence");
 }
 function isValidSequenceState(value) {
   if (!value || typeof value !== "object") return false;
@@ -39776,13 +39904,13 @@ var init_sequence = __esm({
 import { execFile as execFile2 } from "node:child_process";
 import { existsSync as existsSync23 } from "node:fs";
 import { readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join21, resolve as resolve5 } from "node:path";
+import { join as join22, 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: join21(abs, ".git"),
+    GIT_DIR: join22(abs, ".git"),
     GIT_WORK_TREE: abs
   };
 }
@@ -39800,7 +39928,7 @@ async function cleoGitCommand(args, cleoDir) {
   }
 }
 function isCleoGitInitialized(cleoDir) {
-  return existsSync23(join21(cleoDir, ".git", "HEAD"));
+  return existsSync23(join22(cleoDir, ".git", "HEAD"));
 }
 async function loadStateFileAllowlist(cwd) {
   try {
@@ -39844,25 +39972,25 @@ async function isCleoGitRepo(cleoDir) {
   return result.success && (result.stdout === "true" || isCleoGitInitialized(cleoDir));
 }
 function isMergeInProgress(cleoDir) {
-  return existsSync23(join21(cleoDir, ".git", "MERGE_HEAD"));
+  return existsSync23(join22(cleoDir, ".git", "MERGE_HEAD"));
 }
 async function isDetachedHead(cleoDir) {
   const result = await cleoGitCommand(["symbolic-ref", "HEAD"], cleoDir);
   return !result.success;
 }
 function isRebaseInProgress(cleoDir) {
-  return existsSync23(join21(cleoDir, ".git", "rebase-merge")) || existsSync23(join21(cleoDir, ".git", "rebase-apply"));
+  return existsSync23(join22(cleoDir, ".git", "rebase-merge")) || existsSync23(join22(cleoDir, ".git", "rebase-apply"));
 }
 async function recordCheckpointTime(cleoDir) {
   try {
-    const stateFile = join21(cleoDir, CHECKPOINT_STATE_FILE);
+    const stateFile = join22(cleoDir, CHECKPOINT_STATE_FILE);
     await writeFile2(stateFile, String(Math.floor(Date.now() / 1e3)));
   } catch {
   }
 }
 async function getLastCheckpointTime(cleoDir) {
   try {
-    const stateFile = join21(cleoDir, CHECKPOINT_STATE_FILE);
+    const stateFile = join22(cleoDir, CHECKPOINT_STATE_FILE);
     const content = await readFile3(stateFile, "utf-8");
     const epoch = parseInt(content.trim(), 10);
     return Number.isNaN(epoch) ? 0 : epoch;
@@ -39874,7 +40002,7 @@ async function getChangedStateFiles(cleoDir, cwd) {
   const changed = [];
   const allStateFiles = await getAllStateFiles(cwd);
   for (const stateFile of allStateFiles) {
-    const fullPath = join21(cleoDir, stateFile);
+    const fullPath = join22(cleoDir, stateFile);
     if (!existsSync23(fullPath)) continue;
     const diffResult = await cleoGitCommand(["diff", "--quiet", "--", stateFile], cleoDir);
     const cachedResult = await cleoGitCommand(