@cleocode/cleo 2026.3.60 → 2026.3.62

package/dist/cli/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" }
+    ];
   }
 });
 
@@ -13227,7 +13259,7 @@ async function showSequence(cwd) {
     counter: seq.counter,
     lastId: seq.lastId,
     checksum: seq.checksum,
-    nextId: `T${seq.counter + 1}`
+    nextId: `T${String(seq.counter + 1).padStart(3, "0")}`
   };
 }
 async function loadAllTasks(cwd, accessor) {
@@ -41780,6 +41812,58 @@ async function addTask(options, cwd, accessor) {
   if (duplicate) {
     return { task: duplicate, duplicate: true };
   }
+  if (options.dryRun) {
+    const previewNow = (/* @__PURE__ */ new Date()).toISOString();
+    let previewParentForStage = null;
+    if (parentId) {
+      const previewParentTask = await dataAccessor.loadSingleTask(parentId);
+      previewParentForStage = previewParentTask ? { pipelineStage: previewParentTask.pipelineStage, type: previewParentTask.type } : null;
+    }
+    const previewPipelineStage = resolveDefaultPipelineStage({
+      explicitStage: options.pipelineStage,
+      taskType: taskType ?? null,
+      parentTask: previewParentForStage
+    });
+    const previewPosition = options.position !== void 0 ? options.position : await dataAccessor.getNextPosition(parentId);
+    const previewTask = {
+      id: "T???",
+      title: options.title,
+      description: options.description,
+      status,
+      priority,
+      type: taskType,
+      parentId: parentId || null,
+      position: previewPosition,
+      positionVersion: 0,
+      size,
+      pipelineStage: previewPipelineStage,
+      createdAt: previewNow,
+      updatedAt: previewNow
+    };
+    if (phase) previewTask.phase = phase;
+    if (options.labels?.length) previewTask.labels = options.labels.map((l) => l.trim());
+    if (options.files?.length) previewTask.files = options.files.map((f) => f.trim());
+    if (options.acceptance?.length)
+      previewTask.acceptance = options.acceptance.map((a) => a.trim());
+    if (options.depends?.length) previewTask.depends = options.depends.map((d) => d.trim());
+    if (options.notes) {
+      const previewNote = `${(/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace(/\.\d+Z$/, " UTC")}: ${options.notes}`;
+      previewTask.notes = [previewNote];
+    }
+    if (status === "blocked" && options.description) {
+      previewTask.blockedBy = options.description;
+    }
+    if (status === "done") {
+      previewTask.completedAt = previewNow;
+    }
+    if (taskType !== "epic") {
+      const verificationEnabledRaw = await getRawConfigValue("verification.enabled", cwd);
+      if (verificationEnabledRaw === true) {
+        previewTask.verification = buildDefaultVerification(previewNow);
+      }
+    }
+    return { task: previewTask, dryRun: true };
+  }
   const taskId = await allocateNextTaskId(cwd);
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   let resolvedParentForStage = null;
@@ -41849,9 +41933,6 @@ async function addTask(options, cwd, accessor) {
       task.verification = buildDefaultVerification(now2);
     }
   }
-  if (options.dryRun) {
-    return { task, dryRun: true };
-  }
   await dataAccessor.transaction(async (tx) => {
     if (options.position !== void 0) {
       await dataAccessor.shiftPositions(parentId, options.position, 1);
@@ -47763,8 +47844,9 @@ var init_observability = __esm({
 });
 
 // packages/core/src/phases/deps.ts
-async function loadAllTasks3(_cwd, accessor) {
-  const { tasks: tasks2 } = await accessor.queryTasks({});
+async function loadAllTasks3(cwd, accessor) {
+  const acc = accessor ?? await getAccessor(cwd);
+  const { tasks: tasks2 } = await acc.queryTasks({});
   return tasks2;
 }
 function buildGraph(tasks2) {
@@ -47840,11 +47922,45 @@ async function getExecutionWaves(epicId, cwd, accessor) {
   }
   return waves;
 }
+async function getCriticalPath2(taskId, cwd, accessor) {
+  const allTasks = await loadAllTasks3(cwd, accessor);
+  const task = allTasks.find((t) => t.id === taskId);
+  if (!task) {
+    throw new CleoError(4 /* NOT_FOUND */, `Task not found: ${taskId}`);
+  }
+  const graph = buildGraph(allTasks);
+  const taskMap = new Map(allTasks.map((t) => [t.id, t]));
+  function findLongestPath(id, visited) {
+    if (visited.has(id)) return [];
+    visited.add(id);
+    const node = graph.get(id);
+    if (!node || node.dependents.length === 0) {
+      return [id];
+    }
+    let longest = [];
+    for (const depId of node.dependents) {
+      const path3 = findLongestPath(depId, new Set(visited));
+      if (path3.length > longest.length) {
+        longest = path3;
+      }
+    }
+    return [id, ...longest];
+  }
+  const path2 = findLongestPath(taskId, /* @__PURE__ */ new Set());
+  return {
+    path: path2.map((id) => {
+      const t = taskMap.get(id);
+      return t ? { id: t.id, title: t.title, status: t.status } : { id, title: "Unknown", status: "unknown" };
+    }),
+    length: path2.length
+  };
+}
 var init_deps2 = __esm({
   "packages/core/src/phases/deps.ts"() {
     "use strict";
     init_src();
     init_errors3();
+    init_data_accessor();
   }
 });
 
@@ -52646,6 +52762,13 @@ var init_capability_matrix = __esm({
         mode: "native",
         preferredChannel: "either"
       },
+      {
+        domain: "admin",
+        operation: "backup",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
       {
         domain: "admin",
         operation: "backup",
@@ -57895,7 +58018,7 @@ async function getProjectStats(opts, accessor) {
       dbAnd(dbEq(tasksTable.status, "archived"), dbEq(tasksTable.archiveReason, "completed"))
     ).get();
     archivedCompleted = archivedDoneRow?.c ?? 0;
-    totalCompleted = (statusMap["done"] ?? 0) + archivedCompleted;
+    totalCompleted = entries.filter(isComplete).length;
   } catch {
     totalCreated = entries.filter(isCreate).length;
     totalCompleted = entries.filter(isComplete).length;
@@ -58901,7 +59024,7 @@ var init_audit2 = __esm({
 });
 
 // packages/core/src/system/backup.ts
-import { existsSync as existsSync82, mkdirSync as mkdirSync18, readFileSync as readFileSync59, writeFileSync as writeFileSync11 } from "node:fs";
+import { existsSync as existsSync82, mkdirSync as mkdirSync18, readdirSync as readdirSync27, readFileSync as readFileSync59, writeFileSync as writeFileSync11 } from "node:fs";
 import { join as join84 } from "node:path";
 function createBackup2(projectRoot, opts) {
   const cleoDir = join84(projectRoot, ".cleo");
@@ -58947,6 +59070,36 @@ function createBackup2(projectRoot, opts) {
   }
   return { backupId, path: backupDir, timestamp: timestamp2, type: btype, files: backedUp };
 }
+function listSystemBackups(projectRoot) {
+  const cleoDir = join84(projectRoot, ".cleo");
+  const backupTypes = ["snapshot", "safety", "migration"];
+  const entries = [];
+  for (const btype of backupTypes) {
+    const backupDir = join84(cleoDir, "backups", btype);
+    if (!existsSync82(backupDir)) continue;
+    try {
+      const files = readdirSync27(backupDir).filter((f) => f.endsWith(".meta.json"));
+      for (const metaFile of files) {
+        try {
+          const raw = readFileSync59(join84(backupDir, metaFile), "utf-8");
+          const meta = JSON.parse(raw);
+          if (meta.backupId && meta.timestamp) {
+            entries.push({
+              backupId: meta.backupId,
+              type: meta.type ?? btype,
+              timestamp: meta.timestamp,
+              note: meta.note,
+              files: meta.files ?? []
+            });
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return entries.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+}
 function restoreBackup(projectRoot, params) {
   if (!params.backupId) {
     throw new CleoError(2 /* INVALID_INPUT */, "backupId is required");
@@ -59071,7 +59224,7 @@ var init_audit_prune = __esm({
 });
 
 // packages/core/src/system/cleanup.ts
-import { existsSync as existsSync83, readdirSync as readdirSync27, readFileSync as readFileSync60, unlinkSync as unlinkSync5, writeFileSync as writeFileSync12 } from "node:fs";
+import { existsSync as existsSync83, readdirSync as readdirSync28, readFileSync as readFileSync60, unlinkSync as unlinkSync5, writeFileSync as writeFileSync12 } from "node:fs";
 import { join as join86 } from "node:path";
 async function cleanupSystem(projectRoot, params) {
   if (!params.target) {
@@ -59119,10 +59272,10 @@ async function cleanupSystem(projectRoot, params) {
     case "backups": {
       const backupBaseDir = join86(cleoDir, "backups");
       if (existsSync83(backupBaseDir)) {
-        for (const typeDir of readdirSync27(backupBaseDir)) {
+        for (const typeDir of readdirSync28(backupBaseDir)) {
           const fullDir = join86(backupBaseDir, typeDir);
           try {
-            for (const file2 of readdirSync27(fullDir)) {
+            for (const file2 of readdirSync28(fullDir)) {
               if (file2.endsWith(".meta.json")) {
                 const metaFilePath = join86(fullDir, file2);
                 try {
@@ -59131,7 +59284,7 @@ async function cleanupSystem(projectRoot, params) {
                     items.push(file2.replace(".meta.json", ""));
                     if (!dryRun) {
                       unlinkSync5(metaFilePath);
-                      for (const bf of readdirSync27(fullDir)) {
+                      for (const bf of readdirSync28(fullDir)) {
                         if (bf.includes(meta.backupId)) {
                           try {
                             unlinkSync5(join86(fullDir, bf));
@@ -59161,7 +59314,7 @@ async function cleanupSystem(projectRoot, params) {
       }
       const auditPattern = /^audit-log-.*\.json$/;
       if (existsSync83(cleoDir)) {
-        for (const file2 of readdirSync27(cleoDir)) {
+        for (const file2 of readdirSync28(cleoDir)) {
           if (auditPattern.test(file2)) {
             items.push(file2);
             if (!dryRun) {
@@ -59321,7 +59474,7 @@ import { randomBytes as randomBytes12 } from "node:crypto";
 import {
   existsSync as existsSync85,
   mkdirSync as mkdirSync20,
-  readdirSync as readdirSync28,
+  readdirSync as readdirSync29,
   readFileSync as readFileSync61,
   renameSync as renameSync6,
   unlinkSync as unlinkSync6,
@@ -62389,7 +62542,7 @@ var init_tasks2 = __esm({
 });
 
 // packages/core/src/templates/parser.ts
-import { existsSync as existsSync93, readdirSync as readdirSync29, readFileSync as readFileSync67 } from "fs";
+import { existsSync as existsSync93, readdirSync as readdirSync30, readFileSync as readFileSync67 } from "fs";
 import { join as join96 } from "path";
 import { parse as parseYaml } from "yaml";
 function deriveSubcommand(filename) {
@@ -62463,7 +62616,7 @@ function parseIssueTemplates2(projectRoot) {
   }
   let files;
   try {
-    files = readdirSync29(templateDir).filter((f) => /\.ya?ml$/i.test(f) && f !== "config.yml");
+    files = readdirSync30(templateDir).filter((f) => /\.ya?ml$/i.test(f) && f !== "config.yml");
   } catch (error40) {
     return {
       success: false,
@@ -62876,7 +63029,7 @@ var init_changelog = __esm({
 });
 
 // packages/core/src/ui/command-registry.ts
-import { existsSync as existsSync96, readdirSync as readdirSync30, readFileSync as readFileSync70 } from "node:fs";
+import { existsSync as existsSync96, readdirSync as readdirSync31, readFileSync as readFileSync70 } from "node:fs";
 import { basename as basename16, join as join98 } from "node:path";
 function parseCommandHeader(scriptPath) {
   if (!existsSync96(scriptPath)) return null;
@@ -62959,7 +63112,7 @@ function parseCommandHeader(scriptPath) {
 function scanAllCommands(scriptsDir) {
   const registry2 = /* @__PURE__ */ new Map();
   if (!existsSync96(scriptsDir)) return registry2;
-  for (const file2 of readdirSync30(scriptsDir)) {
+  for (const file2 of readdirSync31(scriptsDir)) {
     if (!file2.endsWith(".sh") && !file2.endsWith(".ts")) continue;
     const meta = parseCommandHeader(join98(scriptsDir, file2));
     if (meta) {
@@ -63887,12 +64040,12 @@ var init_compliance2 = __esm({
 });
 
 // packages/core/src/validation/docs-sync.ts
-import { existsSync as existsSync97, readdirSync as readdirSync31, readFileSync as readFileSync71 } from "node:fs";
+import { existsSync as existsSync97, readdirSync as readdirSync32, readFileSync as readFileSync71 } from "node:fs";
 import { join as join99 } from "node:path";
 function getScriptCommands(scriptsDir) {
   if (!existsSync97(scriptsDir)) return [];
   try {
-    return readdirSync31(scriptsDir).filter((f) => f.endsWith(".sh")).map((f) => f.replace(/\.sh$/, "")).sort();
+    return readdirSync32(scriptsDir).filter((f) => f.endsWith(".sh")).map((f) => f.replace(/\.sh$/, "")).sort();
   } catch {
     return [];
   }
@@ -65314,12 +65467,12 @@ var init_manifest = __esm({
 });
 
 // packages/core/src/validation/protocol-common.ts
-import { existsSync as existsSync100, readdirSync as readdirSync32, readFileSync as readFileSync73 } from "node:fs";
+import { existsSync as existsSync100, readdirSync as readdirSync33, readFileSync as readFileSync73 } from "node:fs";
 function checkOutputFileExists(taskId, expectedDir, pattern) {
   if (!existsSync100(expectedDir)) return false;
   const filePattern = pattern ?? `${taskId}`;
   try {
-    const files = readdirSync32(expectedDir);
+    const files = readdirSync33(expectedDir);
     return files.some((f) => f.includes(filePattern) && f.endsWith(".md"));
   } catch {
     return false;
@@ -66298,7 +66451,7 @@ __export(init_exports, {
   isAutoInitEnabled: () => isAutoInitEnabled,
   updateDocs: () => updateDocs
 });
-import { existsSync as existsSync101, readdirSync as readdirSync33, readFileSync as readFileSync74 } from "node:fs";
+import { existsSync as existsSync101, readdirSync as readdirSync34, readFileSync as readFileSync74 } from "node:fs";
 import { copyFile as copyFile3, lstat, mkdir as mkdir16, readFile as readFile17, symlink, unlink as unlink4, writeFile as writeFile11 } from "node:fs/promises";
 import { platform as platform4 } from "node:os";
 import { basename as basename17, dirname as dirname19, join as join101 } from "node:path";
@@ -66348,7 +66501,7 @@ async function initAgentDefinition(created, warnings) {
   } catch (_err) {
     try {
       await mkdir16(globalAgentsDir, { recursive: true });
-      const files = readdirSync33(agentSourceDir);
+      const files = readdirSync34(agentSourceDir);
       for (const file2 of files) {
         await copyFile3(join101(agentSourceDir, file2), join101(globalAgentsDir, file2));
       }
@@ -66497,7 +66650,7 @@ async function installGitHubTemplates(projectRoot, created, skipped) {
   await mkdir16(issueTemplateDir, { recursive: true });
   const issueSrcDir = join101(templateSrcDir, "ISSUE_TEMPLATE");
   if (existsSync101(issueSrcDir)) {
-    const issueFiles = readdirSync33(issueSrcDir);
+    const issueFiles = readdirSync34(issueSrcDir);
     for (const file2 of issueFiles) {
       const dest = join101(issueTemplateDir, file2);
       if (existsSync101(dest)) {
@@ -71530,7 +71683,7 @@ var init_model_provider_registry = __esm({
 
 // packages/core/src/metrics/token-service.ts
 import { createHash as createHash13, randomUUID as randomUUID8 } from "node:crypto";
-import { existsSync as existsSync107, readdirSync as readdirSync34, readFileSync as readFileSync79 } from "node:fs";
+import { existsSync as existsSync107, readdirSync as readdirSync35, readFileSync as readFileSync79 } from "node:fs";
 import { join as join106 } from "node:path";
 function normalizeProvider(provider, model, runtimeProvider) {
   const value = (provider ?? "").trim().toLowerCase();
@@ -71615,7 +71768,7 @@ function getOtelDir2() {
 function readOtelJsonl(dir) {
   if (!existsSync107(dir)) return [];
   const entries = [];
-  for (const file2 of readdirSync34(dir)) {
+  for (const file2 of readdirSync35(dir)) {
     if (!file2.endsWith(".json") && !file2.endsWith(".jsonl")) continue;
     const filePath = join106(dir, file2);
     const raw = readFileSync79(filePath, "utf-8").trim();
@@ -72007,7 +72160,7 @@ var init_parallel = __esm({
 });
 
 // packages/core/src/orchestration/skill-ops.ts
-import { existsSync as existsSync108, readdirSync as readdirSync35, readFileSync as readFileSync80 } from "node:fs";
+import { existsSync as existsSync108, readdirSync as readdirSync36, readFileSync as readFileSync80 } from "node:fs";
 import { join as join107 } from "node:path";
 import { getCanonicalSkillsDir as getCanonicalSkillsDir3 } from "@cleocode/caamp";
 function getSkillContent(skillName, projectRoot) {
@@ -72032,7 +72185,7 @@ function getSkillContent(skillName, projectRoot) {
   let references = [];
   if (existsSync108(refsDir)) {
     try {
-      references = readdirSync35(refsDir).filter((f) => f.endsWith(".md") || f.endsWith(".txt")).map((f) => ({
+      references = readdirSync36(refsDir).filter((f) => f.endsWith(".md") || f.endsWith(".txt")).map((f) => ({
         name: f,
         path: join107(skillDir, "references", f)
       }));
@@ -74633,6 +74786,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
@@ -74696,12 +74850,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"() {
@@ -74714,7 +74899,7 @@ import {
   copyFileSync as copyFileSync7,
   existsSync as existsSync111,
   mkdirSync as mkdirSync23,
-  readdirSync as readdirSync36,
+  readdirSync as readdirSync37,
   readFileSync as readFileSync83,
   writeFileSync as writeFileSync20
 } from "node:fs";
@@ -74927,7 +75112,7 @@ async function runUpgrade(options = {}) {
           const dbPath2 = join109(cleoDir2, "tasks.db");
           const safetyDir = join109(cleoDir2, "backups", "safety");
           if (existsSync111(safetyDir)) {
-            const backups = readdirSync36(safetyDir).filter((f) => f.startsWith("tasks.db.pre-migration.")).sort().reverse();
+            const backups = readdirSync37(safetyDir).filter((f) => f.startsWith("tasks.db.pre-migration.")).sort().reverse();
             if (backups.length > 0 && !existsSync111(dbPath2)) {
               copyFileSync7(join109(safetyDir, backups[0]), dbPath2);
             }
@@ -77854,7 +78039,7 @@ var init_bootstrap2 = __esm({
 });
 
 // packages/core/src/orchestration/critical-path.ts
-async function getCriticalPath2(cwd, accessor) {
+async function getCriticalPath3(cwd, accessor) {
   const acc = accessor ?? await getAccessor(cwd);
   const { tasks: tasks2 } = await acc.queryTasks({});
   if (tasks2.length === 0) {
@@ -78317,6 +78502,7 @@ __export(internal_exports, {
   WorkflowGateTracker: () => WorkflowGateTracker,
   adapters: () => adapters_exports,
   addChain: () => addChain,
+  addIssue: () => addIssue,
   addRemote: () => addRemote,
   addSticky: () => addSticky,
   addTask: () => addTask,
@@ -78474,6 +78660,7 @@ __export(internal_exports, {
   deletePhase: () => deletePhase,
   deleteTask: () => deleteTask,
   deleteTokenUsage: () => deleteTokenUsage,
+  depsCriticalPath: () => getCriticalPath2,
   deregisterAgent: () => deregisterAgent,
   describeChannel: () => describeChannel,
   detectCrashedAgents: () => detectCrashedAgents,
@@ -78615,6 +78802,7 @@ __export(internal_exports, {
   getSystemInfo: () => getSystemInfo2,
   getSystemMetrics: () => getSystemMetrics,
   getSystemMigrationStatus: () => getMigrationStatus2,
+  getTask: () => getTask,
   getTaskHistory: () => getTaskHistory,
   getTaskPath: () => getTaskPath,
   getTemplateForSubcommand: () => getTemplateForSubcommand2,
@@ -78690,6 +78878,7 @@ __export(internal_exports, {
   listSessions: () => listSessions,
   listStickies: () => listStickies,
   listStrictnessPresets: () => listStrictnessPresets,
+  listSystemBackups: () => listSystemBackups,
   listTasks: () => listTasks,
   listTesseraTemplates: () => listTesseraTemplates,
   listTokenUsage: () => listTokenUsage,
@@ -78750,7 +78939,7 @@ __export(internal_exports, {
   ops: () => operations_exports,
   orchestration: () => orchestration_exports,
   orchestrationAnalyzeDependencies: () => analyzeDependencies,
-  orchestrationGetCriticalPath: () => getCriticalPath2,
+  orchestrationGetCriticalPath: () => getCriticalPath3,
   orchestrationGetNextTask: () => getNextTask,
   orchestrationGetReadyTasks: () => getReadyTasks2,
   orphanDetection: () => orphanDetection,
@@ -78957,6 +79146,7 @@ var init_internal = __esm({
     init_impact();
     init_patterns2();
     init_prediction();
+    init_create();
     init_diagnostics();
     init_retry2();
     init_chain_store();
@@ -78983,6 +79173,7 @@ var init_internal = __esm({
     init_waves();
     init_otel();
     init_paths();
+    init_deps2();
     init_phases();
     init_pipeline2();
     init_platform();
@@ -82837,6 +83028,16 @@ var OPERATIONS = [
       }
     ]
   },
+  {
+    gateway: "query",
+    domain: "admin",
+    operation: "backup",
+    description: "admin.backup (query) \u2014 list available backups (read-only)",
+    tier: 1,
+    idempotent: true,
+    sessionRequired: false,
+    requiredParams: []
+  },
   {
     gateway: "mutate",
     domain: "admin",
@@ -84878,7 +85079,7 @@ async function orchestrateCriticalPath(projectRoot) {
   try {
     const root = projectRoot || resolveProjectRoot();
     const accessor = await getAccessor(root);
-    const result = await getCriticalPath2(root, accessor);
+    const result = await getCriticalPath3(root, accessor);
     return { success: true, data: result };
   } catch (err) {
     return engineError("E_GENERAL", err.message);
@@ -85634,7 +85835,7 @@ async function releaseShip(params, projectRoot) {
 // packages/cleo/src/dispatch/engines/system-engine.ts
 init_internal();
 init_error();
-import { existsSync as existsSync119, readdirSync as readdirSync37, readFileSync as readFileSync93 } from "node:fs";
+import { existsSync as existsSync119, readdirSync as readdirSync38, readFileSync as readFileSync93 } from "node:fs";
 import { basename as basename18, join as join112 } from "node:path";
 var HELP_TOPICS = {
   session: {
@@ -85941,7 +86142,7 @@ function systemContext(projectRoot, params) {
     const sessions2 = [];
     const statesDir = join112(cleoDir, "context-states");
     if (existsSync119(statesDir)) {
-      for (const file2 of readdirSync37(statesDir)) {
+      for (const file2 of readdirSync38(statesDir)) {
         if (file2.startsWith("context-state-") && file2.endsWith(".json")) {
           try {
             const state = JSON.parse(readFileSync93(join112(statesDir, file2), "utf-8"));
@@ -86078,6 +86279,14 @@ function systemBackup(projectRoot, params) {
     return engineError("E_GENERAL", err.message);
   }
 }
+function systemListBackups(projectRoot) {
+  try {
+    const result = listSystemBackups(projectRoot);
+    return { success: true, data: result };
+  } catch (err) {
+    return engineError("E_GENERAL", err.message);
+  }
+}
 function systemRestore(projectRoot, params) {
   try {
     const result = restoreBackup(projectRoot, params);
@@ -87644,6 +87853,16 @@ var AdminHandler = class {
             data: result
           };
         }
+        case "backup": {
+          const result = systemListBackups(projectRoot);
+          return wrapResult(
+            { success: true, data: { backups: result, count: result.length } },
+            "query",
+            "admin",
+            operation,
+            startTime
+          );
+        }
         case "map": {
           const { mapCodebase: mapCodebase3 } = await Promise.resolve().then(() => (init_codebase_map_engine(), codebase_map_engine_exports));
           const result = await mapCodebase3(projectRoot, {
@@ -88133,6 +88352,7 @@ var AdminHandler = class {
         "token",
         "adr.show",
         "adr.find",
+        "backup",
         "export",
         "map"
       ],
@@ -93675,7 +93895,7 @@ function registerBackupCommand(program) {
   });
   backup.command("list").description("List available backups").action(async () => {
     await dispatchFromCli(
-      "mutate",
+      "query",
       "admin",
       "backup",
       {
@@ -94081,7 +94301,7 @@ function registerConsensusCommand(program) {
 // packages/cleo/src/cli/commands/context.ts
 function registerContextCommand(program) {
   const context = program.command("context").description("Monitor context window usage for agent safeguard system");
-  context.command("status").description("Show current context state (default)").option("--session <id>", "Check specific CLEO session").action(async (opts) => {
+  context.command("status", { isDefault: true }).description("Show current context state (default)").option("--session <id>", "Check specific CLEO session").action(async (opts) => {
     await dispatchFromCli(
       "query",
       "admin",
@@ -94223,6 +94443,9 @@ function registerDeleteCommand(program) {
 }
 
 // packages/cleo/src/cli/commands/deps.ts
+init_src();
+init_internal();
+init_renderers();
 function registerDepsCommand(program) {
   const deps = program.command("deps").description("Dependency visualization and analysis");
   deps.command("overview").description("Overview of all dependencies").action(async () => {
@@ -94260,15 +94483,15 @@ function registerDepsCommand(program) {
     );
   });
   deps.command("critical-path <taskId>").description("Find longest dependency chain from task").action(async (taskId) => {
-    await dispatchFromCli(
-      "query",
-      "orchestrate",
-      "critical.path",
-      {
-        taskId
-      },
-      { command: "deps", operation: "tasks.depends" }
-    );
+    const cwd = resolveProjectRoot();
+    try {
+      const result = await getCriticalPath2(taskId, cwd);
+      cliOutput(result, { command: "deps", operation: "tasks.criticalPath" });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`critical-path: ${msg}`);
+      process.exit(4 /* NOT_FOUND */);
+    }
   });
   deps.command("impact <taskId>").description("Find all tasks affected by changes to task").option("--depth <n>", "Maximum depth for impact analysis", "10").action(async (taskId, opts) => {
     await dispatchFromCli(
@@ -94330,7 +94553,7 @@ function registerDetectCommand(program) {
 // packages/cleo/src/cli/commands/detect-drift.ts
 init_src();
 init_renderers();
-import { existsSync as existsSync121, readdirSync as readdirSync38, readFileSync as readFileSync95 } from "node:fs";
+import { existsSync as existsSync121, readdirSync as readdirSync39, readFileSync as readFileSync95 } from "node:fs";
 import { dirname as dirname22, join as join114 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function findProjectRoot() {
@@ -94482,7 +94705,7 @@ function registerDetectDriftCommand(program) {
           }
         ]);
       } else {
-        const files = readdirSync38(cliDir).filter(
+        const files = readdirSync39(cliDir).filter(
           (f) => f.endsWith(".ts") && !f.includes(".test.")
         );
         addCheck("CLI-to-core sync", "pass", `Found ${files.length} CLI command implementations`);
@@ -94502,7 +94725,7 @@ function registerDetectDriftCommand(program) {
           }
         ]);
       } else {
-        const files = readdirSync38(domainsDir).filter((f) => f.endsWith(".ts"));
+        const files = readdirSync39(domainsDir).filter((f) => f.endsWith(".ts"));
         addCheck("Domain handler coverage", "pass", `Found ${files.length} domain handlers`);
       }
     } catch (e) {
@@ -94996,24 +95219,29 @@ function registerEnvCommand(program) {
 
 // packages/cleo/src/cli/commands/exists.ts
 init_src();
+init_internal();
 init_renderers();
 function registerExistsCommand(program) {
-  program.command("exists <task-id>").description("Check if a task ID exists (exit 0=exists, 4=not found)").option("--include-archive", "Search archive file too").option("--verbose", "Show which file contains the task").action(async (taskId, opts) => {
-    const response = await dispatchRaw("query", "tasks", "exists", {
-      taskId,
-      includeArchive: opts["includeArchive"],
-      verbose: opts["verbose"]
-    });
-    if (!response.success) {
-      handleRawError(response, { command: "exists", operation: "tasks.exists" });
+  program.command("exists <task-id>").description("Check if a task ID exists (exit 0=exists, 4=not found)").option("--verbose", "Show task title and status when found").action(async (taskId, opts) => {
+    const cwd = resolveProjectRoot();
+    let task;
+    try {
+      task = await getTask(taskId, cwd);
+    } catch (err) {
+      console.error(`exists: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1 /* GENERAL_ERROR */);
     }
-    const data = response.data;
-    if (data?.exists) {
-      cliOutput(data, { command: "exists" });
-    } else {
-      cliOutput(data, { command: "exists" });
+    if (!task) {
+      const data2 = { exists: false, taskId };
+      cliOutput(data2, { command: "exists", operation: "tasks.exists" });
       process.exit(4 /* NOT_FOUND */);
     }
+    const data = { exists: true, taskId };
+    if (opts["verbose"]) {
+      data["title"] = task.title;
+      data["status"] = task.status;
+    }
+    cliOutput(data, { command: "exists", operation: "tasks.exists" });
   });
 }
 
@@ -95527,23 +95755,23 @@ function registerIssueCommand(program) {
   });
 }
 async function handleIssueType(issueType, opts) {
-  const params = {
-    issueType,
-    title: opts["title"],
-    body: opts["body"],
-    dryRun: !!opts["dryRun"]
-  };
-  if (opts["severity"]) params["severity"] = opts["severity"];
-  if (opts["area"]) params["area"] = opts["area"];
-  const opName = `issue.add.${issueType}`;
-  const response = await dispatchRaw("mutate", "tools", opName, params);
-  if (!response.success) {
-    handleRawError(response, { command: "issue", operation: `tools.${opName}` });
+  let result;
+  try {
+    result = addIssue({
+      issueType,
+      title: opts["title"],
+      body: opts["body"],
+      severity: opts["severity"],
+      area: opts["area"],
+      dryRun: !!opts["dryRun"]
+    });
+  } catch (err) {
+    console.error(`Failed to create issue: ${err instanceof Error ? err.message : String(err)}`);
+    process.exitCode = 1;
     return;
   }
-  const result = response.data;
-  if (opts["open"] && typeof result["url"] === "string" && result["url"].startsWith("https://")) {
-    const issueNumber = result["url"].match(/(\d+)$/)?.[1] ?? "unknown";
+  if (opts["open"] && typeof result.url === "string" && result.url.startsWith("https://")) {
+    const issueNumber = result.url.match(/(\d+)$/)?.[1] ?? "unknown";
     try {
       execFileSync15("gh", ["issue", "view", issueNumber, "--repo", CLEO_REPO2, "--web"], {
         stdio: ["pipe", "pipe", "pipe"]
@@ -95551,13 +95779,13 @@ async function handleIssueType(issueType, opts) {
     } catch {
     }
   }
-  cliOutput(result, { command: "issue", operation: `tools.${opName}` });
+  cliOutput(result, { command: "issue", operation: `tools.issue.add.${issueType}` });
 }
 
 // packages/cleo/src/cli/commands/labels.ts
 function registerLabelsCommand(program) {
   const labels = program.command("labels").description("List all labels with counts or show tasks with specific label");
-  labels.command("list").description("List all labels with task counts (default)").action(async () => {
+  labels.command("list", { isDefault: true }).description("List all labels with task counts (default)").action(async () => {
     await dispatchFromCli("query", "tasks", "label.list", {}, { command: "labels" });
   });
   labels.command("show <label>").description("Show tasks with specific label").action(async (label) => {
@@ -96441,7 +96669,7 @@ function registerPhaseCommand(program) {
 // packages/cleo/src/cli/commands/phases.ts
 function registerPhasesCommand(program) {
   const phases = program.command("phases").description("List phases with progress bars and statistics");
-  phases.command("list").description("List all phases with progress (default)").action(async () => {
+  phases.command("list", { isDefault: true }).description("List all phases with progress (default)").action(async () => {
     await dispatchFromCli("query", "pipeline", "phase.list", {}, { command: "phases" });
   });
   phases.command("show <phase>").description("Show phase details and task counts").action(async (phase) => {
@@ -98844,14 +99072,15 @@ function shimToCitty(shim) {
       subCommands2[alias] = shimToCitty(sub);
     }
   }
-  return defineCommand({
+  const cittyDef = defineCommand({
     meta: {
       name: shim._name,
       description: shim._description
     },
     args: cittyArgs,
     ...Object.keys(subCommands2).length > 0 ? { subCommands: subCommands2 } : {},
-    async run({ args }) {
+    async run(context) {
+      const { args } = context;
       if (shim._action) {
         const positionalValues = [];
         for (const arg of shim._args) {
@@ -98869,9 +99098,17 @@ function shimToCitty(shim) {
           }
         }
         await shim._action(...positionalValues, opts, shim);
+      } else if (shim._subcommands.length > 0) {
+        const defaultSub = shim._subcommands.find((s) => s._isDefault);
+        if (defaultSub?._action) {
+          await defaultSub._action({}, defaultSub);
+        } else {
+          await showUsage(context.cmd);
+        }
       }
     }
   });
+  return cittyDef;
 }
 var subCommands = {};
 subCommands["version"] = defineCommand({