@cleocode/cleo 2026.3.59 → 2026.3.61

package/dist/mcp/index.js

@@ -11229,16 +11229,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 log11 = getLogger("sqlite");
+      log11.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
@@ -11246,7 +11263,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 log11 = getLogger("sqlite");
+      log11.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) {
@@ -11303,7 +11332,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";
@@ -11328,6 +11357,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" }
+    ];
   }
 });
 
@@ -35862,6 +35894,7 @@ import { execFile as execFile3 } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { existsSync as existsSync34, 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";
@@ -36673,12 +36706,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 (existsSync34(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
   };
 }
@@ -66950,46 +67001,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: dirname22 } = await import("node:path");
+  await mkdir17(dirname22(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 (existsSync104(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 && existsSync104(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");
@@ -67003,13 +67076,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)");
     }
@@ -67143,6 +67226,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 (!existsSync104(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 (existsSync104(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 (existsSync104(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 {
+  }
+}
 var init_bootstrap = __esm({
   "packages/core/src/bootstrap.ts"() {
     "use strict";
@@ -67159,6 +67281,8 @@ var init_cleo = __esm({
     "use strict";
     init_export();
     init_import();
+    init_agents();
+    init_intelligence();
     init_lifecycle2();
     init_brain_retrieval();
     init_brain_search();
@@ -67173,6 +67297,7 @@ var init_cleo = __esm({
     init_sessions();
     init_sticky();
     init_data_accessor();
+    init_task_work();
     init_add();
     init_archive2();
     init_complete();
@@ -67244,7 +67369,10 @@ var init_cleo = __esm({
           ),
           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 ===
@@ -67252,7 +67380,11 @@ var init_cleo = __esm({
         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),
@@ -67390,6 +67522,35 @@ var init_cleo = __esm({
           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;
@@ -74248,6 +74409,7 @@ var init_migration_sqlite = __esm({
 // packages/core/src/repair.ts
 var repair_exports = {};
 __export(repair_exports, {
+  repairMissingColumns: () => repairMissingColumns,
   repairMissingCompletedAt: () => repairMissingCompletedAt,
   repairMissingSizes: () => repairMissingSizes,
   runAllRepairs: () => runAllRepairs
@@ -74311,12 +74473,43 @@ async function repairMissingCompletedAt(cwd, dryRun) {
     details: `Set completedAt for ${affected.length} done/cancelled task(s)`
   };
 }
+async function repairMissingColumns(cwd, dryRun) {
+  const { getDb: getDb4 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
+  const db = await getDb4(cwd);
+  const { sql: sql12 } = await import("drizzle-orm");
+  const columns = db.all(sql12`PRAGMA table_info(tasks)`);
+  const existingCols = new Set(columns.map((c) => c.name));
+  const missingCols = ["pipeline_stage"].filter((c) => !existingCols.has(c));
+  if (missingCols.length === 0) {
+    return {
+      action: "fix_missing_columns",
+      status: "skipped",
+      details: "All required columns present on tasks table"
+    };
+  }
+  if (dryRun) {
+    return {
+      action: "fix_missing_columns",
+      status: "preview",
+      details: `Would add missing column(s): ${missingCols.join(", ")}`
+    };
+  }
+  for (const col of missingCols) {
+    db.run(sql12.raw(`ALTER TABLE tasks ADD COLUMN ${col} text`));
+  }
+  return {
+    action: "fix_missing_columns",
+    status: "applied",
+    details: `Added missing column(s): ${missingCols.join(", ")}`
+  };
+}
 async function runAllRepairs(cwd, dryRun) {
-  const [sizes, completedAt] = await Promise.all([
+  const [sizes, completedAt, columns] = await Promise.all([
     repairMissingSizes(cwd, dryRun),
-    repairMissingCompletedAt(cwd, dryRun)
+    repairMissingCompletedAt(cwd, dryRun),
+    repairMissingColumns(cwd, dryRun)
   ]);
-  return [sizes, completedAt];
+  return [sizes, completedAt, columns];
 }
 var init_repair = __esm({
   "packages/core/src/repair.ts"() {
@@ -77932,6 +78125,7 @@ __export(internal_exports, {
   WorkflowGateTracker: () => WorkflowGateTracker,
   adapters: () => adapters_exports,
   addChain: () => addChain,
+  addIssue: () => addIssue,
   addRemote: () => addRemote,
   addSticky: () => addSticky,
   addTask: () => addTask,
@@ -78572,6 +78766,7 @@ var init_internal = __esm({
     init_impact();
     init_patterns2();
     init_prediction();
+    init_create();
     init_diagnostics();
     init_retry2();
     init_chain_store();