@cleocode/core 2026.3.59 → 2026.3.61

package/dist/index.js

@@ -11225,16 +11225,33 @@ function runMigrations(nativeDb, db) {
       );
     }
   }
-  let lastError;
+  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 });
-      return;
+      break;
     } catch (err) {
       if (!isSqliteBusy(err) || attempt === MAX_MIGRATION_RETRIES) {
         throw err;
       }
-      lastError = err;
       const delay = Math.min(
         MIGRATION_RETRY_BASE_DELAY_MS * 2 ** (attempt - 1) * (1 + Math.random() * 0.5),
         MIGRATION_RETRY_MAX_DELAY_MS
@@ -11242,7 +11259,19 @@ function runMigrations(nativeDb, db) {
       Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, Math.round(delay));
     }
   }
-  throw lastError;
+  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}`);
+    }
+  }
 }
 function closeDb() {
   if (_nativeDb2) {
@@ -11299,7 +11328,7 @@ 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;
+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 init_sqlite2 = __esm({
   "packages/core/src/store/sqlite.ts"() {
     "use strict";
@@ -11324,6 +11353,9 @@ var init_sqlite2 = __esm({
     MAX_MIGRATION_RETRIES = 5;
     MIGRATION_RETRY_BASE_DELAY_MS = 100;
     MIGRATION_RETRY_MAX_DELAY_MS = 2e3;
+    REQUIRED_TASK_COLUMNS = [
+      { name: "pipeline_stage", ddl: "text" }
+    ];
   }
 });
 
@@ -19102,6 +19134,7 @@ import { execFile as execFile3 } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { existsSync as existsSync33, constants as fsConstants3, readFileSync as readFileSync22, statSync as statSync8 } from "node:fs";
 import { access as access3, mkdir as mkdir5, readFile as readFile6, rm as rm2, writeFile as writeFile5 } from "node:fs/promises";
+import { homedir as getHomedir } from "node:os";
 import { dirname as dirname8, join as join37, resolve as resolve5 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { promisify as promisify3 } from "node:util";
@@ -19913,12 +19946,30 @@ function checkGlobalTemplates() {
       fix: "cleo init (or restart MCP server)"
     };
   }
+  const xdgContent = readFileSync22(injectionPath, "utf-8");
+  const xdgVersion = xdgContent.match(/^Version:\s*(.+)$/m)?.[1]?.trim();
+  const home = getHomedir();
+  const legacyPath = join37(home, ".cleo", "templates", "CLEO-INJECTION.md");
+  if (existsSync33(legacyPath)) {
+    const legacyContent = readFileSync22(legacyPath, "utf-8");
+    const legacyVersion = legacyContent.match(/^Version:\s*(.+)$/m)?.[1]?.trim();
+    if (legacyVersion && xdgVersion && legacyVersion !== xdgVersion) {
+      return {
+        id: "global_templates",
+        category: "global",
+        status: "warning",
+        message: `Legacy template version (${legacyVersion}) out of sync with XDG (${xdgVersion})`,
+        details: { path: injectionPath, exists: true, xdgVersion, legacyVersion, legacyPath },
+        fix: "npm install -g @cleocode/cleo (reinstall syncs both paths)"
+      };
+    }
+  }
   return {
     id: "global_templates",
     category: "global",
     status: "passed",
-    message: "Global injection template present",
-    details: { path: injectionPath, exists: true },
+    message: `Global injection template present (v${xdgVersion ?? "unknown"})`,
+    details: { path: injectionPath, exists: true, version: xdgVersion },
     fix: null
   };
 }
@@ -64457,46 +64508,68 @@ async function bootstrapGlobalCleo(options) {
   await installSkillsGlobally(ctx);
   await installAgentDefinitionGlobally(ctx);
   await installProviderAdapters(ctx, options?.packageRoot);
+  await verifyBootstrapHealth(ctx);
   return ctx;
 }
+async function writeTemplateTo(content, destPath, isDryRun) {
+  if (isDryRun) return false;
+  const { dirname: dirname20 } = await import("node:path");
+  await mkdir17(dirname20(destPath), { recursive: true });
+  await writeFile12(destPath, content);
+  return true;
+}
 async function ensureGlobalTemplatesBootstrap(ctx, packageRootOverride) {
   const globalTemplatesDir = getCleoTemplatesDir();
   if (!ctx.isDryRun) {
     await mkdir17(globalTemplatesDir, { recursive: true });
   }
+  let templateContent = null;
   try {
     const pkgRoot = packageRootOverride ?? getPackageRoot();
     const templatePath = join104(pkgRoot, "templates", "CLEO-INJECTION.md");
     if (existsSync103(templatePath)) {
-      const content = readFileSync77(templatePath, "utf-8");
-      const destPath = join104(globalTemplatesDir, "CLEO-INJECTION.md");
-      if (!ctx.isDryRun) {
-        await writeFile12(destPath, content);
-      }
-      ctx.created.push(
-        `~/.cleo/templates/CLEO-INJECTION.md (${ctx.isDryRun ? "would refresh" : "refreshed"})`
-      );
-    } else {
-      try {
-        const { getInjectionTemplateContent: getInjectionTemplateContent2 } = await Promise.resolve().then(() => (init_injection(), injection_exports));
-        const content = getInjectionTemplateContent2();
-        if (content) {
-          const destPath = join104(globalTemplatesDir, "CLEO-INJECTION.md");
-          if (!ctx.isDryRun) {
-            await writeFile12(destPath, content);
-          }
-          ctx.created.push(
-            `~/.cleo/templates/CLEO-INJECTION.md (${ctx.isDryRun ? "would refresh" : "refreshed"} from embedded)`
-          );
-        }
-      } catch {
-        ctx.warnings.push("Could not refresh CLEO-INJECTION.md template");
-      }
+      templateContent = readFileSync77(templatePath, "utf-8");
     }
   } catch {
+  }
+  if (!templateContent) {
+    try {
+      const { getInjectionTemplateContent: getInjectionTemplateContent2 } = await Promise.resolve().then(() => (init_injection(), injection_exports));
+      templateContent = getInjectionTemplateContent2() ?? null;
+    } catch {
+      ctx.warnings.push("Could not refresh CLEO-INJECTION.md template");
+      return;
+    }
+  }
+  if (!templateContent) {
     ctx.warnings.push("Could not refresh CLEO-INJECTION.md template");
+    return;
+  }
+  const xdgDest = join104(globalTemplatesDir, "CLEO-INJECTION.md");
+  const xdgWritten = await writeTemplateTo(templateContent, xdgDest, ctx.isDryRun);
+  ctx.created.push(
+    `${getCleoTemplatesTildePath()}/CLEO-INJECTION.md (${xdgWritten ? "refreshed" : "would refresh"})`
+  );
+  const home = homedir6();
+  const legacyTemplatesDir = join104(home, ".cleo", "templates");
+  if (legacyTemplatesDir !== globalTemplatesDir && existsSync103(join104(home, ".cleo"))) {
+    const legacyDest = join104(legacyTemplatesDir, "CLEO-INJECTION.md");
+    const legacyWritten = await writeTemplateTo(templateContent, legacyDest, ctx.isDryRun);
+    if (legacyWritten) {
+      ctx.created.push("~/.cleo/templates/CLEO-INJECTION.md (legacy sync)");
+    }
   }
 }
+function sanitizeCaampFile(content) {
+  let cleaned = content.replace(/(<!-- CAAMP:END -->)\s*(<!-- CAAMP:END -->)/g, "$1");
+  cleaned = cleaned.replace(
+    /<!-- CAAMP:END -->\s*[A-Z][A-Za-z-]*\.md\s*(?:<!-- CAAMP:END -->)?/g,
+    "<!-- CAAMP:END -->"
+  );
+  cleaned = cleaned.replace(/^[A-Z][A-Za-z-]*\.md\s*$/gm, "");
+  cleaned = cleaned.replace(/\n{3,}/g, "\n\n");
+  return cleaned.trim() + "\n";
+}
 async function injectAgentsHub(ctx) {
   const globalAgentsDir = getAgentsHome();
   const globalAgentsMd = join104(globalAgentsDir, "AGENTS.md");
@@ -64510,13 +64583,23 @@ async function injectAgentsHub(ctx) {
           /\n?<!-- CLEO:START[^>]*-->[\s\S]*?<!-- CLEO:END -->\n?/g,
           ""
         );
-        if (stripped !== content) {
-          await writeFile12(globalAgentsMd, stripped, "utf8");
+        const sanitized = sanitizeCaampFile(stripped);
+        if (sanitized !== content) {
+          await writeFile12(globalAgentsMd, sanitized, "utf8");
+          ctx.created.push("~/.agents/AGENTS.md (sanitized CAAMP corruption)");
         }
       }
       const templateRef = `@${getCleoTemplatesTildePath()}/CLEO-INJECTION.md`;
       const action = await inject2(globalAgentsMd, templateRef);
       ctx.created.push(`~/.agents/AGENTS.md (${action})`);
+      const postContent = await readFile19(globalAgentsMd, "utf8");
+      const caampBlocks = postContent.match(/<!-- CAAMP:START -->/g);
+      const caampEnds = postContent.match(/<!-- CAAMP:END -->/g);
+      if (caampBlocks && caampEnds && caampBlocks.length !== caampEnds.length) {
+        ctx.warnings.push(
+          `~/.agents/AGENTS.md has mismatched CAAMP markers (${caampBlocks.length} START vs ${caampEnds.length} END)`
+        );
+      }
     } else {
       ctx.created.push("~/.agents/AGENTS.md (would create/update CAAMP block)");
     }
@@ -64650,6 +64733,45 @@ async function installProviderAdapters(ctx, packageRootOverride) {
     );
   }
 }
+async function verifyBootstrapHealth(ctx) {
+  if (ctx.isDryRun) return;
+  try {
+    const xdgTemplatePath = join104(getCleoTemplatesDir(), "CLEO-INJECTION.md");
+    const agentsMd = join104(getAgentsHome(), "AGENTS.md");
+    if (!existsSync103(xdgTemplatePath)) {
+      ctx.warnings.push("Health: XDG template missing after bootstrap");
+      return;
+    }
+    const xdgContent = await readFile19(xdgTemplatePath, "utf8");
+    const xdgVersion = xdgContent.match(/^Version:\s*(.+)$/m)?.[1]?.trim();
+    const home = homedir6();
+    const legacyTemplatePath = join104(home, ".cleo", "templates", "CLEO-INJECTION.md");
+    if (existsSync103(legacyTemplatePath)) {
+      const legacyContent = await readFile19(legacyTemplatePath, "utf8");
+      const legacyVersion = legacyContent.match(/^Version:\s*(.+)$/m)?.[1]?.trim();
+      if (legacyVersion !== xdgVersion) {
+        ctx.warnings.push(
+          `Health: Legacy template version (${legacyVersion}) != XDG version (${xdgVersion})`
+        );
+      }
+    }
+    if (existsSync103(agentsMd)) {
+      const agentsContent = await readFile19(agentsMd, "utf8");
+      const expectedRef = `@${getCleoTemplatesTildePath()}/CLEO-INJECTION.md`;
+      if (!agentsContent.includes(expectedRef)) {
+        ctx.warnings.push(`Health: ~/.agents/AGENTS.md does not reference ${expectedRef}`);
+      }
+      const outsideCaamp = agentsContent.replace(
+        /<!-- CAAMP:START -->[\s\S]*?<!-- CAAMP:END -->/g,
+        ""
+      );
+      if (/[A-Z][A-Za-z-]*\.md/.test(outsideCaamp)) {
+        ctx.warnings.push("Health: ~/.agents/AGENTS.md has orphaned content outside CAAMP blocks");
+      }
+    }
+  } catch {
+  }
+}
 
 // packages/core/src/cleo.ts
 import path from "node:path";
@@ -64724,7 +64846,10 @@ var Cleo = class _Cleo {
       ),
       complete: (p) => completeTask({ taskId: p.taskId, notes: p.notes }, root, store),
       delete: (p) => deleteTask({ taskId: p.taskId, force: p.force }, root, store),
-      archive: (p) => archiveTasks({ before: p?.before, taskIds: p?.taskIds, dryRun: p?.dryRun }, root, store)
+      archive: (p) => archiveTasks({ before: p?.before, taskIds: p?.taskIds, dryRun: p?.dryRun }, root, store),
+      start: (taskId) => startTask(taskId, root, store),
+      stop: () => stopTask(root, store),
+      current: () => currentTask(root, store)
     };
   }
   // === Sessions ===
@@ -64732,7 +64857,11 @@ var Cleo = class _Cleo {
     const root = this.projectRoot;
     const store = this._store ?? void 0;
     return {
-      start: (p) => startSession({ name: p.name, scope: p.scope, agent: p.agent }, root, store),
+      start: (p) => startSession(
+        { name: p.name, scope: p.scope, agent: p.agent, startTask: p.startTask },
+        root,
+        store
+      ),
       end: (p) => endSession({ note: p?.note }, root, store),
       status: () => sessionStatus(root, store),
       resume: (id) => resumeSession(id, root, store),
@@ -64870,6 +64999,35 @@ var Cleo = class _Cleo {
       sharingStatus: () => getSharingStatus()
     };
   }
+  // === Agents ===
+  get agents() {
+    const root = this.projectRoot;
+    return {
+      register: (opts) => registerAgent(opts, root),
+      deregister: (agentId) => deregisterAgent(agentId, root),
+      health: (agentId) => checkAgentHealth2(agentId, void 0, root),
+      detectCrashed: (thresholdMs) => detectCrashedAgents(thresholdMs, root),
+      recordHeartbeat: (agentId) => heartbeat(agentId, root),
+      capacity: (agentId) => getAgentCapacity(agentId, root),
+      isOverloaded: (threshold) => isOverloaded(threshold, root),
+      list: (p) => listAgentInstances(
+        {
+          status: p?.status,
+          agentType: p?.agentType
+        },
+        root
+      )
+    };
+  }
+  // === Intelligence ===
+  get intelligence() {
+    const root = this.projectRoot;
+    const store = this._store ?? void 0;
+    return {
+      predictImpact: (change) => predictImpact(change, root, store ?? void 0),
+      blastRadius: (taskId) => calculateBlastRadius(taskId, store ?? void 0, root)
+    };
+  }
   // === Sync (Task Reconciliation) ===
   get sync() {
     const root = this.projectRoot;