@cleocode/core 2026.3.65 → 2026.3.67

package/dist/index.js

@@ -9820,43 +9820,6 @@ var init_db_helpers = __esm({
   }
 });
 
-// node_modules/.pnpm/drizzle-orm@1.0.0-beta.19-d95b7a4_@types+mssql@9.1.9_@azure+core-client@1.10.1__mssql@1_735b8d50d0ee1e3e16a97e41691265be/node_modules/drizzle-orm/migrator.js
-import crypto2 from "node:crypto";
-import fs, { existsSync as existsSync3, readdirSync as readdirSync2 } from "node:fs";
-import { join as join4 } from "node:path";
-function readMigrationFiles(config2) {
-  if (fs.existsSync(`${config2.migrationsFolder}/meta/_journal.json`)) throw Error('We detected that you have old drizzle-kit migration folders. You must upgrade drizzle-kit and run "drizzle-kit up"');
-  const migrationFolderTo = config2.migrationsFolder;
-  const migrationQueries = [];
-  const migrations = readdirSync2(migrationFolderTo).map((subdir) => ({
-    path: join4(migrationFolderTo, subdir, "migration.sql"),
-    name: subdir
-  })).filter((it) => existsSync3(it.path));
-  migrations.sort((a, b) => a.name.localeCompare(b.name));
-  for (const migration of migrations) {
-    const migrationPath = migration.path;
-    const migrationDate = migration.name.slice(0, 14);
-    const query = fs.readFileSync(migrationPath).toString();
-    const result = query.split("--> statement-breakpoint").map((it) => {
-      return it;
-    });
-    const millis = formatToMillis(migrationDate);
-    migrationQueries.push({
-      sql: result,
-      bps: true,
-      folderMillis: millis,
-      hash: crypto2.createHash("sha256").update(query).digest("hex"),
-      name: migration.name
-    });
-  }
-  return migrationQueries;
-}
-var init_migrator = __esm({
-  "node_modules/.pnpm/drizzle-orm@1.0.0-beta.19-d95b7a4_@types+mssql@9.1.9_@azure+core-client@1.10.1__mssql@1_735b8d50d0ee1e3e16a97e41691265be/node_modules/drizzle-orm/migrator.js"() {
-    init_migrator_utils();
-  }
-});
-
 // node_modules/.pnpm/drizzle-orm@1.0.0-beta.19-d95b7a4_@types+mssql@9.1.9_@azure+core-client@1.10.1__mssql@1_735b8d50d0ee1e3e16a97e41691265be/node_modules/drizzle-orm/logger.js
 var ConsoleLogWriter, DefaultLogger, NoopLogger;
 var init_logger2 = __esm({
@@ -10089,17 +10052,6 @@ var init_node_sqlite = __esm({
   }
 });
 
-// node_modules/.pnpm/drizzle-orm@1.0.0-beta.19-d95b7a4_@types+mssql@9.1.9_@azure+core-client@1.10.1__mssql@1_735b8d50d0ee1e3e16a97e41691265be/node_modules/drizzle-orm/node-sqlite/migrator.js
-function migrate(db, config2) {
-  const migrations = readMigrationFiles(config2);
-  return db.dialect.migrate(migrations, db.session, config2);
-}
-var init_migrator2 = __esm({
-  "node_modules/.pnpm/drizzle-orm@1.0.0-beta.19-d95b7a4_@types+mssql@9.1.9_@azure+core-client@1.10.1__mssql@1_735b8d50d0ee1e3e16a97e41691265be/node_modules/drizzle-orm/node-sqlite/migrator.js"() {
-    init_migrator();
-  }
-});
-
 // packages/core/src/system/platform-paths.ts
 import { arch, hostname, platform, release } from "node:os";
 import envPaths from "env-paths";
@@ -10145,22 +10097,22 @@ var init_platform_paths = __esm({
 });
 
 // packages/core/src/paths.ts
-import { existsSync as existsSync4, readFileSync as readFileSync2 } from "node:fs";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
 import { homedir } from "node:os";
-import { dirname as dirname2, join as join5, resolve as resolve2 } from "node:path";
+import { dirname as dirname2, join as join4, resolve as resolve2 } from "node:path";
 function isProjectInitialized(projectRoot) {
   const root = projectRoot ?? getProjectRoot();
-  const cleoDir = join5(root, ".cleo");
-  return existsSync4(cleoDir) && existsSync4(join5(cleoDir, "tasks.db"));
+  const cleoDir = join4(root, ".cleo");
+  return existsSync3(cleoDir) && existsSync3(join4(cleoDir, "tasks.db"));
 }
 function getCleoHome() {
   return getPlatformPaths().data;
 }
 function getCleoTemplatesDir() {
-  return join5(getCleoHome(), "templates");
+  return join4(getCleoHome(), "templates");
 }
 function getCleoSchemasDir() {
-  return join5(getCleoHome(), "schemas");
+  return join4(getCleoHome(), "schemas");
 }
 function getCleoDir(cwd) {
   if (cwd) {
@@ -10195,21 +10147,21 @@ function resolveProjectPath(relativePath, cwd) {
   return resolve2(getProjectRoot(cwd), relativePath);
 }
 function getTaskPath(cwd) {
-  return join5(getCleoDirAbsolute(cwd), "tasks.db");
+  return join4(getCleoDirAbsolute(cwd), "tasks.db");
 }
 function getConfigPath(cwd) {
-  return join5(getCleoDirAbsolute(cwd), "config.json");
+  return join4(getCleoDirAbsolute(cwd), "config.json");
 }
 function getBackupDir(cwd) {
-  return join5(getCleoDirAbsolute(cwd), "backups", "operational");
+  return join4(getCleoDirAbsolute(cwd), "backups", "operational");
 }
 function getGlobalConfigPath() {
-  return join5(getCleoHome(), "config.json");
+  return join4(getCleoHome(), "config.json");
 }
 function getAgentOutputsDir(cwd) {
   const projectRoot = getProjectRoot(cwd);
-  const configPath = join5(projectRoot, ".cleo", "config.json");
-  if (existsSync4(configPath)) {
+  const configPath = join4(projectRoot, ".cleo", "config.json");
+  if (existsSync3(configPath)) {
     try {
       const config2 = JSON.parse(readFileSync2(configPath, "utf-8"));
       if (typeof config2.agentOutputs === "object" && config2.agentOutputs?.directory) {
@@ -10239,9 +10191,9 @@ function getAgentOutputsAbsolute(cwd) {
 function getManifestPath(cwd) {
   const outputDir = getAgentOutputsDir(cwd);
   const projectRoot = getProjectRoot(cwd);
-  const configPath = join5(projectRoot, ".cleo", "config.json");
+  const configPath = join4(projectRoot, ".cleo", "config.json");
   let manifestFile = "MANIFEST.jsonl";
-  if (existsSync4(configPath)) {
+  if (existsSync3(configPath)) {
     try {
       const config2 = JSON.parse(readFileSync2(configPath, "utf-8"));
       const customFile = config2.agentOutputs?.manifestFile ?? config2.research?.manifestFile;
@@ -10273,11 +10225,11 @@ function getCleoTemplatesTildePath() {
   return absPath;
 }
 function getAgentsHome() {
-  return process.env["AGENTS_HOME"] ?? join5(homedir(), ".agents");
+  return process.env["AGENTS_HOME"] ?? join4(homedir(), ".agents");
 }
 function getClaudeAgentsDir() {
-  const claudeDir = process.env["CLAUDE_HOME"] ?? join5(homedir(), ".claude");
-  return join5(claudeDir, "agents");
+  const claudeDir = process.env["CLAUDE_HOME"] ?? join4(homedir(), ".claude");
+  return join4(claudeDir, "agents");
 }
 var DEFAULT_AGENT_OUTPUTS_DIR;
 var init_paths = __esm({
@@ -10288,8 +10240,159 @@ var init_paths = __esm({
   }
 });
 
+// node_modules/.pnpm/drizzle-orm@1.0.0-beta.19-d95b7a4_@types+mssql@9.1.9_@azure+core-client@1.10.1__mssql@1_735b8d50d0ee1e3e16a97e41691265be/node_modules/drizzle-orm/migrator.js
+import crypto2 from "node:crypto";
+import fs, { existsSync as existsSync4, readdirSync as readdirSync2 } from "node:fs";
+import { join as join5 } from "node:path";
+function readMigrationFiles(config2) {
+  if (fs.existsSync(`${config2.migrationsFolder}/meta/_journal.json`)) throw Error('We detected that you have old drizzle-kit migration folders. You must upgrade drizzle-kit and run "drizzle-kit up"');
+  const migrationFolderTo = config2.migrationsFolder;
+  const migrationQueries = [];
+  const migrations = readdirSync2(migrationFolderTo).map((subdir) => ({
+    path: join5(migrationFolderTo, subdir, "migration.sql"),
+    name: subdir
+  })).filter((it) => existsSync4(it.path));
+  migrations.sort((a, b) => a.name.localeCompare(b.name));
+  for (const migration of migrations) {
+    const migrationPath = migration.path;
+    const migrationDate = migration.name.slice(0, 14);
+    const query = fs.readFileSync(migrationPath).toString();
+    const result = query.split("--> statement-breakpoint").map((it) => {
+      return it;
+    });
+    const millis = formatToMillis(migrationDate);
+    migrationQueries.push({
+      sql: result,
+      bps: true,
+      folderMillis: millis,
+      hash: crypto2.createHash("sha256").update(query).digest("hex"),
+      name: migration.name
+    });
+  }
+  return migrationQueries;
+}
+var init_migrator = __esm({
+  "node_modules/.pnpm/drizzle-orm@1.0.0-beta.19-d95b7a4_@types+mssql@9.1.9_@azure+core-client@1.10.1__mssql@1_735b8d50d0ee1e3e16a97e41691265be/node_modules/drizzle-orm/migrator.js"() {
+    init_migrator_utils();
+  }
+});
+
+// node_modules/.pnpm/drizzle-orm@1.0.0-beta.19-d95b7a4_@types+mssql@9.1.9_@azure+core-client@1.10.1__mssql@1_735b8d50d0ee1e3e16a97e41691265be/node_modules/drizzle-orm/node-sqlite/migrator.js
+function migrate(db, config2) {
+  const migrations = readMigrationFiles(config2);
+  return db.dialect.migrate(migrations, db.session, config2);
+}
+var init_migrator2 = __esm({
+  "node_modules/.pnpm/drizzle-orm@1.0.0-beta.19-d95b7a4_@types+mssql@9.1.9_@azure+core-client@1.10.1__mssql@1_735b8d50d0ee1e3e16a97e41691265be/node_modules/drizzle-orm/node-sqlite/migrator.js"() {
+    init_migrator();
+  }
+});
+
+// packages/core/src/store/migration-manager.ts
+import { copyFileSync, existsSync as existsSync5 } from "node:fs";
+function tableExists(nativeDb, tableName) {
+  const result = nativeDb.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(tableName);
+  return !!result;
+}
+function isSqliteBusy(err) {
+  if (!(err instanceof Error)) return false;
+  const msg = err.message.toLowerCase();
+  return msg.includes("sqlite_busy") || msg.includes("database is locked");
+}
+function createSafetyBackup(dbPath) {
+  const backupPath = dbPath.replace(/\.db$/, "-pre-cleo.db.bak");
+  if (!existsSync5(backupPath)) {
+    try {
+      copyFileSync(dbPath, backupPath);
+    } catch {
+    }
+  }
+}
+function reconcileJournal(nativeDb, migrationsFolder, existenceTable, logSubsystem) {
+  if (tableExists(nativeDb, existenceTable) && !tableExists(nativeDb, "__drizzle_migrations")) {
+    const migrations = readMigrationFiles({ migrationsFolder });
+    const baseline = migrations[0];
+    if (baseline) {
+      nativeDb.exec(`
+        CREATE TABLE IF NOT EXISTS "__drizzle_migrations" (
+          id SERIAL PRIMARY KEY,
+          hash text NOT NULL,
+          created_at numeric
+        )
+      `);
+      nativeDb.exec(
+        `INSERT INTO "__drizzle_migrations" ("hash", "created_at") VALUES ('${baseline.hash}', ${baseline.folderMillis})`
+      );
+    }
+  }
+  if (tableExists(nativeDb, "__drizzle_migrations") && tableExists(nativeDb, existenceTable)) {
+    const localMigrations = readMigrationFiles({ migrationsFolder });
+    const localHashes = new Set(localMigrations.map((m) => m.hash));
+    const dbEntries = nativeDb.prepare('SELECT hash FROM "__drizzle_migrations"').all();
+    const hasOrphanedEntries = dbEntries.some((e) => !localHashes.has(e.hash));
+    if (hasOrphanedEntries) {
+      const log9 = getLogger(logSubsystem);
+      log9.warn(
+        { orphaned: dbEntries.filter((e) => !localHashes.has(e.hash)).length },
+        `Detected stale migration journal entries from a previous CLEO version. Reconciling.`
+      );
+      nativeDb.exec('DELETE FROM "__drizzle_migrations"');
+      for (const m of localMigrations) {
+        nativeDb.exec(
+          `INSERT INTO "__drizzle_migrations" ("hash", "created_at") VALUES ('${m.hash}', ${m.folderMillis})`
+        );
+      }
+    }
+  }
+}
+function migrateWithRetry(db, migrationsFolder) {
+  for (let attempt = 1; attempt <= MAX_MIGRATION_RETRIES; attempt++) {
+    try {
+      migrate(db, { migrationsFolder });
+      return;
+    } catch (err) {
+      if (!isSqliteBusy(err) || attempt === MAX_MIGRATION_RETRIES) {
+        throw err;
+      }
+      const delay = Math.min(
+        MIGRATION_RETRY_BASE_DELAY_MS * 2 ** (attempt - 1) * (1 + Math.random() * 0.5),
+        MIGRATION_RETRY_MAX_DELAY_MS
+      );
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, Math.round(delay));
+    }
+  }
+}
+function ensureColumns(nativeDb, tableName, requiredColumns, logSubsystem) {
+  if (!tableExists(nativeDb, tableName)) return;
+  if (requiredColumns.length === 0) return;
+  const columns = nativeDb.prepare(`PRAGMA table_info(${tableName})`).all();
+  const existingCols = new Set(columns.map((c) => c.name));
+  for (const req of requiredColumns) {
+    if (!existingCols.has(req.name)) {
+      const log9 = getLogger(logSubsystem);
+      log9.warn(
+        { column: req.name },
+        `Adding missing column ${tableName}.${req.name} via ALTER TABLE`
+      );
+      nativeDb.exec(`ALTER TABLE ${tableName} ADD COLUMN ${req.name} ${req.ddl}`);
+    }
+  }
+}
+var MAX_MIGRATION_RETRIES, MIGRATION_RETRY_BASE_DELAY_MS, MIGRATION_RETRY_MAX_DELAY_MS;
+var init_migration_manager = __esm({
+  "packages/core/src/store/migration-manager.ts"() {
+    "use strict";
+    init_migrator();
+    init_migrator2();
+    init_logger();
+    MAX_MIGRATION_RETRIES = 5;
+    MIGRATION_RETRY_BASE_DELAY_MS = 100;
+    MIGRATION_RETRY_MAX_DELAY_MS = 2e3;
+  }
+});
+
 // packages/core/src/store/sqlite-backup.ts
-import { existsSync as existsSync5, mkdirSync, readdirSync as readdirSync3, statSync, unlinkSync } from "node:fs";
+import { existsSync as existsSync6, mkdirSync, readdirSync as readdirSync3, statSync, unlinkSync } from "node:fs";
 import { join as join6 } from "node:path";
 function formatTimestamp(d) {
   const pad = (n, len = 2) => String(n).padStart(len, "0");
@@ -10333,7 +10436,7 @@ function listSqliteBackups(cwd) {
   try {
     const cleoDir = getCleoDir(cwd);
     const backupDir = join6(cleoDir, "backups", "sqlite");
-    if (!existsSync5(backupDir)) return [];
+    if (!existsSync6(backupDir)) return [];
     return readdirSync3(backupDir).filter((f) => f.match(/^tasks-\d{8}-\d{6}\.db$/)).map((f) => ({
       name: f,
       path: join6(backupDir, f),
@@ -10621,7 +10724,7 @@ __export(brain_sqlite_exports, {
   resetBrainDbState: () => resetBrainDbState,
   resolveBrainMigrationsFolder: () => resolveBrainMigrationsFolder
 });
-import { copyFileSync, existsSync as existsSync6, mkdirSync as mkdirSync2 } from "node:fs";
+import { mkdirSync as mkdirSync2 } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname as dirname3, join as join7 } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -10635,75 +10738,13 @@ function resolveBrainMigrationsFolder() {
   const pkgRoot = isBundled ? join7(__dirname, "..") : join7(__dirname, "..", "..");
   return join7(pkgRoot, "migrations", "drizzle-brain");
 }
-function tableExists(nativeDb, tableName) {
-  const result = nativeDb.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(tableName);
-  return !!result;
-}
 function runBrainMigrations(nativeDb, db) {
   const migrationsFolder = resolveBrainMigrationsFolder();
   if (tableExists(nativeDb, "brain_decisions") && _dbPath) {
-    const backupPath = _dbPath.replace(/\.db$/, "-pre-cleo.db.bak");
-    if (!existsSync6(backupPath)) {
-      try {
-        copyFileSync(_dbPath, backupPath);
-      } catch {
-      }
-    }
-  }
-  if (tableExists(nativeDb, "brain_decisions") && !tableExists(nativeDb, "__drizzle_migrations")) {
-    const migrations = readMigrationFiles({ migrationsFolder });
-    const baseline = migrations[0];
-    if (baseline) {
-      nativeDb.exec(`
-        CREATE TABLE IF NOT EXISTS "__drizzle_migrations" (
-          id SERIAL PRIMARY KEY,
-          hash text NOT NULL,
-          created_at numeric
-        )
-      `);
-      nativeDb.exec(
-        `INSERT INTO "__drizzle_migrations" ("hash", "created_at") VALUES ('${baseline.hash}', ${baseline.folderMillis})`
-      );
-    }
-  }
-  if (tableExists(nativeDb, "__drizzle_migrations") && tableExists(nativeDb, "brain_decisions")) {
-    const localMigrations = readMigrationFiles({ migrationsFolder });
-    const localHashes = new Set(localMigrations.map((m) => m.hash));
-    const dbEntries = nativeDb.prepare('SELECT hash FROM "__drizzle_migrations"').all();
-    const hasOrphanedEntries = dbEntries.some((e) => !localHashes.has(e.hash));
-    if (hasOrphanedEntries) {
-      const log9 = getLogger("brain");
-      log9.warn(
-        { orphaned: dbEntries.filter((e) => !localHashes.has(e.hash)).length },
-        "Detected stale migration journal entries from a previous CLEO version. Reconciling brain.db."
-      );
-      nativeDb.exec('DELETE FROM "__drizzle_migrations"');
-      for (const m of localMigrations) {
-        nativeDb.exec(
-          `INSERT INTO "__drizzle_migrations" ("hash", "created_at") VALUES ('${m.hash}', ${m.folderMillis})`
-        );
-      }
-    }
+    createSafetyBackup(_dbPath);
   }
-  const MAX_RETRIES = 5;
-  const BASE_DELAY_MS = 100;
-  const MAX_DELAY_MS = 2e3;
-  let lastError;
-  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-    try {
-      migrate(db, { migrationsFolder });
-      return;
-    } catch (err) {
-      if (!isSqliteBusy(err) || attempt === MAX_RETRIES) throw err;
-      lastError = err;
-      const delay = Math.min(
-        BASE_DELAY_MS * 2 ** (attempt - 1) * (1 + Math.random() * 0.5),
-        MAX_DELAY_MS
-      );
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, Math.round(delay));
-    }
-  }
-  throw lastError;
+  reconcileJournal(nativeDb, migrationsFolder, "brain_decisions", "brain");
+  migrateWithRetry(db, migrationsFolder);
 }
 function loadBrainVecExtension(nativeDb) {
   try {
@@ -10789,12 +10830,10 @@ var _require, DB_FILENAME, BRAIN_SCHEMA_VERSION, _db, _nativeDb, _dbPath, _initP
 var init_brain_sqlite = __esm({
   "packages/core/src/store/brain-sqlite.ts"() {
     "use strict";
-    init_migrator();
     init_node_sqlite();
-    init_migrator2();
-    init_logger();
     init_paths();
     init_brain_schema();
+    init_migration_manager();
     init_sqlite2();
     _require = createRequire(import.meta.url);
     DB_FILENAME = "brain.db";
@@ -11209,89 +11248,14 @@ function resolveMigrationsFolder() {
   const pkgRoot = isBundled ? join9(__dirname, "..") : join9(__dirname, "..", "..");
   return join9(pkgRoot, "migrations", "drizzle-tasks");
 }
-function tableExists3(nativeDb, tableName) {
-  const result = nativeDb.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(tableName);
-  return !!result;
-}
-function isSqliteBusy(err) {
-  if (!(err instanceof Error)) return false;
-  const msg = err.message.toLowerCase();
-  return msg.includes("sqlite_busy") || msg.includes("database is locked");
-}
 function runMigrations(nativeDb, db) {
   const migrationsFolder = resolveMigrationsFolder();
-  if (tableExists3(nativeDb, "tasks") && _dbPath2) {
-    const backupPath = _dbPath2.replace(/\.db$/, "-pre-cleo.db.bak");
-    if (!existsSync8(backupPath)) {
-      try {
-        copyFileSync3(_dbPath2, backupPath);
-      } catch {
-      }
-    }
-  }
-  if (tableExists3(nativeDb, "tasks") && !tableExists3(nativeDb, "__drizzle_migrations")) {
-    const migrations = readMigrationFiles({ migrationsFolder });
-    const baseline = migrations[0];
-    if (baseline) {
-      nativeDb.exec(`
-        CREATE TABLE IF NOT EXISTS "__drizzle_migrations" (
-          id SERIAL PRIMARY KEY,
-          hash text NOT NULL,
-          created_at numeric
-        )
-      `);
-      nativeDb.exec(
-        `INSERT INTO "__drizzle_migrations" ("hash", "created_at") VALUES ('${baseline.hash}', ${baseline.folderMillis})`
-      );
-    }
-  }
-  if (tableExists3(nativeDb, "__drizzle_migrations") && tableExists3(nativeDb, "tasks")) {
-    const localMigrations = readMigrationFiles({ migrationsFolder });
-    const localHashes = new Set(localMigrations.map((m) => m.hash));
-    const dbEntries = nativeDb.prepare('SELECT hash FROM "__drizzle_migrations"').all();
-    const hasOrphanedEntries = dbEntries.some((e) => !localHashes.has(e.hash));
-    if (hasOrphanedEntries) {
-      const log9 = getLogger("sqlite");
-      log9.warn(
-        { orphaned: dbEntries.filter((e) => !localHashes.has(e.hash)).length },
-        "Detected stale migration journal entries from a previous CLEO version. Reconciling."
-      );
-      nativeDb.exec('DELETE FROM "__drizzle_migrations"');
-      for (const m of localMigrations) {
-        nativeDb.exec(
-          `INSERT INTO "__drizzle_migrations" ("hash", "created_at") VALUES ('${m.hash}', ${m.folderMillis})`
-        );
-      }
-    }
-  }
-  for (let attempt = 1; attempt <= MAX_MIGRATION_RETRIES; attempt++) {
-    try {
-      migrate(db, { migrationsFolder });
-      break;
-    } catch (err) {
-      if (!isSqliteBusy(err) || attempt === MAX_MIGRATION_RETRIES) {
-        throw err;
-      }
-      const delay = Math.min(
-        MIGRATION_RETRY_BASE_DELAY_MS * 2 ** (attempt - 1) * (1 + Math.random() * 0.5),
-        MIGRATION_RETRY_MAX_DELAY_MS
-      );
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, Math.round(delay));
-    }
-  }
-  ensureRequiredColumns(nativeDb);
-}
-function ensureRequiredColumns(nativeDb) {
-  if (!tableExists3(nativeDb, "tasks")) return;
-  const columns = nativeDb.prepare("PRAGMA table_info(tasks)").all();
-  const existingCols = new Set(columns.map((c) => c.name));
-  for (const req of REQUIRED_TASK_COLUMNS) {
-    if (!existingCols.has(req.name)) {
-      const log9 = getLogger("sqlite");
-      log9.warn({ column: req.name }, `Adding missing column tasks.${req.name} via ALTER TABLE`);
-      nativeDb.exec(`ALTER TABLE tasks ADD COLUMN ${req.name} ${req.ddl}`);
-    }
+  if (tableExists(nativeDb, "tasks") && _dbPath2) {
+    createSafetyBackup(_dbPath2);
   }
+  reconcileJournal(nativeDb, migrationsFolder, "tasks", "sqlite");
+  migrateWithRetry(db, migrationsFolder);
+  ensureColumns(nativeDb, "tasks", REQUIRED_TASK_COLUMNS, "sqlite");
 }
 function closeDb() {
   if (_nativeDb2) {
@@ -11348,17 +11312,17 @@ async function closeAllDatabases() {
   } catch {
   }
 }
-var _require2, DatabaseSync2, DB_FILENAME3, SQLITE_SCHEMA_VERSION, SCHEMA_VERSION, _db2, _nativeDb2, _dbPath2, _initPromise2, _gitTrackingChecked, MIN_BACKUP_TASK_COUNT, MAX_MIGRATION_RETRIES, MIGRATION_RETRY_BASE_DELAY_MS, MIGRATION_RETRY_MAX_DELAY_MS, REQUIRED_TASK_COLUMNS;
+var _require2, DatabaseSync2, DB_FILENAME3, SQLITE_SCHEMA_VERSION, SCHEMA_VERSION, _db2, _nativeDb2, _dbPath2, _initPromise2, _gitTrackingChecked, MIN_BACKUP_TASK_COUNT, REQUIRED_TASK_COLUMNS;
 var init_sqlite2 = __esm({
   "packages/core/src/store/sqlite.ts"() {
     "use strict";
-    init_migrator();
     init_node_sqlite();
-    init_migrator2();
     init_logger();
     init_paths();
+    init_migration_manager();
     init_sqlite_backup();
     init_tasks_schema();
+    init_migration_manager();
     _require2 = createRequire2(import.meta.url);
     ({ DatabaseSync: DatabaseSync2 } = _require2("node:sqlite"));
     DB_FILENAME3 = "tasks.db";
@@ -11370,12 +11334,7 @@ var init_sqlite2 = __esm({
     _initPromise2 = null;
     _gitTrackingChecked = false;
     MIN_BACKUP_TASK_COUNT = 10;
-    MAX_MIGRATION_RETRIES = 5;
-    MIGRATION_RETRY_BASE_DELAY_MS = 100;
-    MIGRATION_RETRY_MAX_DELAY_MS = 2e3;
-    REQUIRED_TASK_COLUMNS = [
-      { name: "pipeline_stage", ddl: "text" }
-    ];
+    REQUIRED_TASK_COLUMNS = [{ name: "pipeline_stage", ddl: "text" }];
   }
 });
 
@@ -14876,6 +14835,63 @@ var init_registry2 = __esm({
   }
 });
 
+// packages/core/src/lib/retry.ts
+var retry_exports = {};
+__export(retry_exports, {
+  computeDelay: () => computeDelay,
+  withRetry: () => withRetry
+});
+async function withRetry(fn, options) {
+  const maxAttempts = options?.maxAttempts ?? 3;
+  const baseDelayMs = options?.baseDelayMs ?? 2e3;
+  const maxDelayMs = options?.maxDelayMs ?? 3e4;
+  const retryableErrors = options?.retryableErrors;
+  let lastError;
+  let totalDelayMs = 0;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      const isLastAttempt = attempt === maxAttempts;
+      if (isLastAttempt) break;
+      if (retryableErrors !== void 0 && !isRetryable(err, retryableErrors)) break;
+      const delay = computeDelay(attempt, baseDelayMs, maxDelayMs);
+      totalDelayMs += delay;
+      await sleep(delay);
+    }
+  }
+  const context = { attempts: maxAttempts, totalDelayMs };
+  augmentError(lastError, context);
+  throw lastError;
+}
+function computeDelay(attempt, baseDelayMs, maxDelayMs) {
+  const exponential = baseDelayMs * 2 ** (attempt - 1);
+  return Math.min(exponential, maxDelayMs);
+}
+function isRetryable(err, predicates) {
+  const message = err instanceof Error ? err.message : String(err);
+  return predicates.some((predicate) => {
+    if (predicate instanceof RegExp) return predicate.test(message);
+    return predicate(err);
+  });
+}
+function augmentError(err, context) {
+  if (err instanceof Error) {
+    const mutableErr = err;
+    mutableErr.attempts = context.attempts;
+    mutableErr.totalDelayMs = context.totalDelayMs;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
+}
+var init_retry = __esm({
+  "packages/core/src/lib/retry.ts"() {
+    "use strict";
+  }
+});
+
 // packages/core/src/store/project-detect.ts
 var project_detect_exports = {};
 __export(project_detect_exports, {
@@ -20394,6 +20410,19 @@ var init_config = __esm({
         requireNotes: false,
         multiSession: false
       },
+      enforcement: {
+        acceptance: {
+          mode: "block",
+          requiredForPriorities: ["critical", "high", "medium", "low"],
+          minimumCriteria: 3
+        },
+        session: { requiredForMutate: true }
+      },
+      verification: {
+        enabled: true,
+        maxRounds: 3,
+        requiredGates: ["implemented", "testsPassed", "qaPassed"]
+      },
       lifecycle: {
         mode: "strict"
       },
@@ -22722,17 +22751,17 @@ function checkMin(criteria, min) {
 }
 async function createAcceptanceEnforcement(cwd) {
   const isTest = !!process.env.VITEST;
-  const modeRaw = await getRawConfigValue("enforcement.acceptance.mode", cwd);
-  const prioritiesRaw = await getRawConfigValue(
-    "enforcement.acceptance.requiredForPriorities",
-    cwd
-  );
-  const minCriteriaRaw = await getRawConfigValue("enforcement.acceptance.minimumCriteria", cwd);
-  const defaultPriorityRaw = await getRawConfigValue("defaults.priority", cwd);
-  const mode = modeRaw === "off" || modeRaw === "warn" || modeRaw === "block" ? modeRaw : isTest ? "off" : "block";
-  const requiredForPriorities = Array.isArray(prioritiesRaw) ? prioritiesRaw.filter((p) => typeof p === "string") : ["critical", "high", "medium", "low"];
-  const minCriteria = typeof minCriteriaRaw === "number" && Number.isInteger(minCriteriaRaw) ? minCriteriaRaw : 3;
-  const defaultPriority = typeof defaultPriorityRaw === "string" ? defaultPriorityRaw : "medium";
+  const config2 = await loadConfig(cwd);
+  const acceptance = config2.enforcement?.acceptance;
+  const mode = acceptance?.mode ?? (isTest ? "off" : "block");
+  const requiredForPriorities = acceptance?.requiredForPriorities ?? [
+    "critical",
+    "high",
+    "medium",
+    "low"
+  ];
+  const minCriteria = acceptance?.minimumCriteria ?? 3;
+  const defaultPriority = "medium";
   return {
     checkMinimumCriteria: checkMin,
     validateCreation(options) {
@@ -23462,8 +23491,8 @@ async function addTask(options, cwd, accessor) {
       previewTask.completedAt = previewNow;
     }
     if (taskType !== "epic") {
-      const verificationEnabledRaw = await getRawConfigValue("verification.enabled", cwd);
-      if (verificationEnabledRaw === true) {
+      const pCfg = await loadConfig(cwd);
+      if (pCfg.verification?.enabled) {
         previewTask.verification = buildDefaultVerification(previewNow);
       }
     }
@@ -23533,8 +23562,8 @@ async function addTask(options, cwd, accessor) {
     task.completedAt = now;
   }
   if (taskType !== "epic") {
-    const verificationEnabledRaw = await getRawConfigValue("verification.enabled", cwd);
-    if (verificationEnabledRaw === true) {
+    const aCfg = await loadConfig(cwd);
+    if (aCfg.verification?.enabled) {
       task.verification = buildDefaultVerification(now);
     }
   }
@@ -24364,21 +24393,15 @@ function isVerificationGate(value) {
 }
 async function loadCompletionEnforcement(cwd) {
   const isTest = !!process.env.VITEST;
-  const modeRaw = await getRawConfigValue("enforcement.acceptance.mode", cwd);
-  const prioritiesRaw = await getRawConfigValue(
-    "enforcement.acceptance.requiredForPriorities",
-    cwd
-  );
-  const verificationEnabledRaw = await getRawConfigValue("verification.enabled", cwd);
-  const verificationRequiredGatesRaw = await getRawConfigValue("verification.requiredGates", cwd);
-  const verificationMaxRoundsRaw = await getRawConfigValue("verification.maxRounds", cwd);
-  const lifecycleModeRaw = await getRawConfigValue("lifecycle.mode", cwd);
-  const acceptanceMode = modeRaw === "off" || modeRaw === "warn" || modeRaw === "block" ? modeRaw : isTest ? "off" : "block";
-  const acceptanceRequiredForPriorities = Array.isArray(prioritiesRaw) ? prioritiesRaw.filter((p) => typeof p === "string") : isTest ? [] : ["critical", "high", "medium", "low"];
-  const verificationEnabled = verificationEnabledRaw === true ? true : verificationEnabledRaw === false ? false : !isTest;
-  const verificationRequiredGates = Array.isArray(verificationRequiredGatesRaw) ? verificationRequiredGatesRaw.filter((g) => typeof g === "string").filter(isVerificationGate) : DEFAULT_VERIFICATION_REQUIRED_GATES;
-  const verificationMaxRounds = typeof verificationMaxRoundsRaw === "number" && Number.isInteger(verificationMaxRoundsRaw) ? verificationMaxRoundsRaw : 5;
-  const lifecycleMode = lifecycleModeRaw === "strict" || lifecycleModeRaw === "warn" || lifecycleModeRaw === "advisory" || lifecycleModeRaw === "none" || lifecycleModeRaw === "off" ? lifecycleModeRaw : isTest ? "off" : "strict";
+  const config2 = await loadConfig(cwd);
+  const acceptance = config2.enforcement?.acceptance;
+  const verificationCfg = config2.verification;
+  const acceptanceMode = acceptance?.mode ?? (isTest ? "off" : "block");
+  const acceptanceRequiredForPriorities = acceptance?.requiredForPriorities ?? (isTest ? [] : ["critical", "high", "medium", "low"]);
+  const verificationEnabled = verificationCfg?.enabled ?? !isTest;
+  const verificationRequiredGates = (verificationCfg?.requiredGates ?? []).filter(isVerificationGate).length > 0 ? (verificationCfg?.requiredGates ?? []).filter(isVerificationGate) : DEFAULT_VERIFICATION_REQUIRED_GATES;
+  const verificationMaxRounds = verificationCfg?.maxRounds ?? 5;
+  const lifecycleMode = config2.lifecycle?.mode ?? (isTest ? "off" : "strict");
   return {
     acceptanceMode,
     acceptanceRequiredForPriorities,
@@ -26710,7 +26733,7 @@ __export(agents_exports, {
   updateAgentSpecializations: () => updateAgentSpecializations,
   updateAgentStatus: () => updateAgentStatus,
   updateCapacity: () => updateCapacity,
-  withRetry: () => withRetry
+  withRetry: () => withRetry2
 });
 
 // packages/core/src/agents/agent-registry.ts
@@ -27245,42 +27268,34 @@ function shouldRetry(error40, attempt, policy) {
   if (classification === "retriable") return true;
   return policy.retryOnUnknown;
 }
-async function withRetry(fn, policy) {
+async function withRetry2(fn, policy) {
   const effectivePolicy = createRetryPolicy(policy);
-  let lastError;
-  let totalDelayMs = 0;
-  for (let attempt = 0; attempt <= effectivePolicy.maxRetries; attempt++) {
-    try {
-      const value = await fn();
-      return {
-        success: true,
-        value,
-        attempts: attempt + 1,
-        totalDelayMs
-      };
-    } catch (err) {
-      lastError = err instanceof Error ? err : new Error(String(err));
-      if (!shouldRetry(err, attempt, effectivePolicy)) {
-        return {
-          success: false,
-          error: lastError,
-          attempts: attempt + 1,
-          totalDelayMs
-        };
-      }
-      if (attempt < effectivePolicy.maxRetries) {
-        const delay = calculateDelay(attempt, effectivePolicy);
-        totalDelayMs += delay;
-        await sleep(delay);
+  const { withRetry: coreRetry } = await Promise.resolve().then(() => (init_retry(), retry_exports));
+  let attemptCount = 0;
+  try {
+    const value = await coreRetry(
+      async () => {
+        attemptCount++;
+        return fn();
+      },
+      {
+        maxAttempts: effectivePolicy.maxRetries + 1,
+        baseDelayMs: effectivePolicy.baseDelayMs,
+        maxDelayMs: effectivePolicy.maxDelayMs,
+        retryableErrors: [(err) => shouldRetry(err, attemptCount - 1, effectivePolicy)]
       }
-    }
+    );
+    return { success: true, value, attempts: attemptCount, totalDelayMs: 0 };
+  } catch (err) {
+    const error40 = err instanceof Error ? err : new Error(String(err));
+    const context = err;
+    return {
+      success: false,
+      error: error40,
+      attempts: attemptCount,
+      totalDelayMs: context.totalDelayMs ?? 0
+    };
   }
-  return {
-    success: false,
-    error: lastError ?? new Error("Retry exhausted without error"),
-    attempts: effectivePolicy.maxRetries + 1,
-    totalDelayMs
-  };
 }
 async function recoverCrashedAgents(thresholdMs = 3e4, cwd) {
   const results = [];
@@ -27327,9 +27342,6 @@ async function recoverCrashedAgents(thresholdMs = 3e4, cwd) {
   }
   return results;
 }
-function sleep(ms) {
-  return new Promise((resolve10) => setTimeout(resolve10, ms));
-}
 
 // packages/core/src/caamp/index.ts
 var caamp_exports = {};
@@ -41519,55 +41531,9 @@ function addIssue(params) {
 var lib_exports = {};
 __export(lib_exports, {
   computeDelay: () => computeDelay,
-  withRetry: () => withRetry2
+  withRetry: () => withRetry
 });
-
-// packages/core/src/lib/retry.ts
-async function withRetry2(fn, options) {
-  const maxAttempts = options?.maxAttempts ?? 3;
-  const baseDelayMs = options?.baseDelayMs ?? 2e3;
-  const maxDelayMs = options?.maxDelayMs ?? 3e4;
-  const retryableErrors = options?.retryableErrors;
-  let lastError;
-  let totalDelayMs = 0;
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    try {
-      return await fn();
-    } catch (err) {
-      lastError = err;
-      const isLastAttempt = attempt === maxAttempts;
-      if (isLastAttempt) break;
-      if (retryableErrors !== void 0 && !isRetryable(err, retryableErrors)) break;
-      const delay = computeDelay(attempt, baseDelayMs, maxDelayMs);
-      totalDelayMs += delay;
-      await sleep2(delay);
-    }
-  }
-  const context = { attempts: maxAttempts, totalDelayMs };
-  augmentError(lastError, context);
-  throw lastError;
-}
-function computeDelay(attempt, baseDelayMs, maxDelayMs) {
-  const exponential = baseDelayMs * 2 ** (attempt - 1);
-  return Math.min(exponential, maxDelayMs);
-}
-function isRetryable(err, predicates) {
-  const message = err instanceof Error ? err.message : String(err);
-  return predicates.some((predicate) => {
-    if (predicate instanceof RegExp) return predicate.test(message);
-    return predicate(err);
-  });
-}
-function augmentError(err, context) {
-  if (err instanceof Error) {
-    const mutableErr = err;
-    mutableErr.attempts = context.attempts;
-    mutableErr.totalDelayMs = context.totalDelayMs;
-  }
-}
-function sleep2(ms) {
-  return new Promise((resolve10) => setTimeout(resolve10, ms));
-}
+init_retry();
 
 // packages/core/src/lifecycle/index.ts
 var lifecycle_exports = {};
@@ -64561,6 +64527,16 @@ function getProjectInfoSync(cwd) {
     return null;
   }
 }
+function updateProjectName(cwd, name2) {
+  const cleoDir = getCleoDirAbsolute(cwd);
+  const infoPath = join103(cleoDir, "project-info.json");
+  if (!existsSync102(infoPath)) return;
+  const data = JSON.parse(readFileSync76(infoPath, "utf-8"));
+  data.projectName = name2;
+  data.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync19(infoPath, `${JSON.stringify(data, null, 2)}
+`);
+}
 
 // packages/core/src/index.ts
 init_scaffold();
@@ -65232,6 +65208,7 @@ export {
   getCleoDirAbsolute,
   getCleoErrorRegistry,
   getCleoHome,
+  getCleoTemplatesTildePath,
   getCleoVersion,
   getConfigPath,
   getConfigValue,
@@ -65363,6 +65340,7 @@ export {
   tokenUsageMethodSchema,
   tokenUsageTransportSchema,
   ui_exports as ui,
+  updateProjectName,
   updateTask,
   validateAgainstSchema,
   validation_exports as validation