@cleocode/cleo 2026.4.23 → 2026.4.25

package/dist/cli/index.js

@@ -104181,11 +104181,11 @@ var init_registry5 = __esm({
       // orchestrate — Wave 7a: analyze parallel-safety mode (T410)
       // Note: orchestrate.analyze already registered above; this documents the new
       // mode="parallel-safety" variant via the existing analyze operation's params.
-      // conduit — agent messaging operations (replaces standalone clawmsgr scripts)
+      // conduit — agent messaging operations (ADR-042: moved under orchestrate domain)
       {
         gateway: "query",
-        domain: "conduit",
-        operation: "status",
+        domain: "orchestrate",
+        operation: "conduit.status",
         description: "conduit.status (query) \u2014 check agent connection status and unread count",
         tier: 2,
         idempotent: true,
@@ -104202,8 +104202,8 @@ var init_registry5 = __esm({
       },
       {
         gateway: "query",
-        domain: "conduit",
-        operation: "peek",
+        domain: "orchestrate",
+        operation: "conduit.peek",
         description: "conduit.peek (query) \u2014 one-shot poll for new messages without acking",
         tier: 2,
         idempotent: true,
@@ -104226,8 +104226,8 @@ var init_registry5 = __esm({
       },
       {
         gateway: "mutate",
-        domain: "conduit",
-        operation: "start",
+        domain: "orchestrate",
+        operation: "conduit.start",
         description: "conduit.start (mutate) \u2014 start continuous message polling for the active agent",
         tier: 2,
         idempotent: true,
@@ -104256,8 +104256,8 @@ var init_registry5 = __esm({
       },
       {
         gateway: "mutate",
-        domain: "conduit",
-        operation: "stop",
+        domain: "orchestrate",
+        operation: "conduit.stop",
         description: "conduit.stop (mutate) \u2014 stop the active polling loop",
         tier: 2,
         idempotent: true,
@@ -104266,8 +104266,8 @@ var init_registry5 = __esm({
       },
       {
         gateway: "mutate",
-        domain: "conduit",
-        operation: "send",
+        domain: "orchestrate",
+        operation: "conduit.send",
         description: "conduit.send (mutate) \u2014 send a message to an agent or conversation",
         tier: 2,
         idempotent: false,
@@ -106707,6 +106707,40 @@ var init_release_engine = __esm({
 });
 
 // packages/cleo/src/dispatch/engines/system-engine.ts
+var system_engine_exports = {};
+__export(system_engine_exports, {
+  backupRestore: () => backupRestore,
+  systemArchiveStats: () => systemArchiveStats,
+  systemAudit: () => systemAudit,
+  systemBackup: () => systemBackup,
+  systemCleanup: () => systemCleanup,
+  systemCompliance: () => systemCompliance,
+  systemContext: () => systemContext,
+  systemDash: () => systemDash,
+  systemDiagnostics: () => systemDiagnostics,
+  systemDoctor: () => systemDoctor,
+  systemFix: () => systemFix,
+  systemHealth: () => systemHealth,
+  systemHelp: () => systemHelp,
+  systemInjectGenerate: () => systemInjectGenerate,
+  systemLabels: () => systemLabels,
+  systemListBackups: () => systemListBackups,
+  systemLog: () => systemLog,
+  systemMetrics: () => systemMetrics,
+  systemMigrate: () => systemMigrate,
+  systemPaths: () => systemPaths,
+  systemRestore: () => systemRestore,
+  systemRoadmap: () => systemRoadmap,
+  systemRuntime: () => systemRuntime,
+  systemSafestop: () => systemSafestop,
+  systemScaffoldHub: () => systemScaffoldHub,
+  systemSequence: () => systemSequence,
+  systemSequenceRepair: () => systemSequenceRepair,
+  systemSmoke: () => systemSmoke,
+  systemStats: () => systemStats,
+  systemSync: () => systemSync,
+  systemUncancel: () => systemUncancel
+});
 import { existsSync as existsSync126, readdirSync as readdirSync40, readFileSync as readFileSync94 } from "node:fs";
 import { basename as basename18, join as join121 } from "node:path";
 async function systemDash(projectRoot, params) {
@@ -106812,6 +106846,15 @@ async function systemStats(projectRoot, params) {
     return cleoErrorToEngineError(err, "E_NOT_INITIALIZED", "Failed to get stats");
   }
 }
+async function systemLabels(projectRoot) {
+  try {
+    const accessor = await getAccessor(projectRoot);
+    const result = await getLabels(projectRoot, accessor);
+    return { success: true, data: result };
+  } catch (err) {
+    return cleoErrorToEngineError(err, "E_NOT_INITIALIZED", "Failed to get labels");
+  }
+}
 async function systemArchiveStats(projectRoot, params) {
   try {
     const accessor = await getAccessor(projectRoot);
@@ -107076,6 +107119,15 @@ async function systemInjectGenerate(projectRoot) {
     return cleoErrorToEngineError(err, "E_GENERAL", "Failed to generate injection");
   }
 }
+async function systemMetrics(projectRoot, params) {
+  try {
+    const accessor = await getAccessor(projectRoot);
+    const result = await getSystemMetrics(projectRoot, params, accessor);
+    return { success: true, data: result };
+  } catch (err) {
+    return cleoErrorToEngineError(err, "E_GENERAL", "Failed to get metrics");
+  }
+}
 async function systemHealth(projectRoot, params) {
   try {
     const result = await getSystemHealth(projectRoot, params);
@@ -107084,6 +107136,176 @@ async function systemHealth(projectRoot, params) {
     return cleoErrorToEngineError(err, "E_GENERAL", "Failed to get health");
   }
 }
+async function systemDiagnostics(projectRoot, params) {
+  try {
+    const result = await getSystemDiagnostics(projectRoot, params);
+    return { success: true, data: result };
+  } catch (err) {
+    return cleoErrorToEngineError(err, "E_GENERAL", "Failed to get diagnostics");
+  }
+}
+function systemHelp(_projectRoot, params) {
+  const topic = params?.topic;
+  if (topic) {
+    const topicHelp = HELP_TOPICS[topic];
+    if (topicHelp) {
+      return { success: true, data: topicHelp };
+    }
+    return engineError(
+      "E_NOT_FOUND",
+      `Unknown help topic: ${topic}. Available topics: ${Object.keys(HELP_TOPICS).join(", ")}`
+    );
+  }
+  return {
+    success: true,
+    data: {
+      content: [
+        "CLEO Task Management System",
+        "",
+        "Essential Commands:",
+        '  cleofind "query"    - Fuzzy search tasks',
+        "  cleoshow T1234      - Full task details",
+        '  cleoadd "Task"      - Create task',
+        "  cleodone <id>       - Complete task",
+        "  cleostart <id>      - Start working on task",
+        "  cleodash            - Project overview",
+        "  cleosession list    - List sessions",
+        "",
+        "Help Topics: session, tasks, focus, labels, compliance"
+      ].join("\n"),
+      relatedCommands: ["cleo find", "cleo show", "cleo add", "cleo done", "cleo dash"]
+    }
+  };
+}
+async function systemRoadmap(projectRoot, params) {
+  try {
+    const accessor = await getAccessor(projectRoot);
+    const result = await getRoadmap(
+      {
+        includeHistory: params?.includeHistory,
+        upcomingOnly: params?.upcomingOnly,
+        cwd: projectRoot
+      },
+      accessor
+    );
+    return { success: true, data: result };
+  } catch (err) {
+    return cleoErrorToEngineError(err, "E_NOT_INITIALIZED", "System not initialized");
+  }
+}
+function systemCompliance(projectRoot, params) {
+  try {
+    if (params?.subcommand === "trend") {
+      const compliancePath2 = join121(projectRoot, ".cleo", "metrics", "COMPLIANCE.jsonl");
+      let entries2 = [];
+      if (existsSync126(compliancePath2)) {
+        const content = readFileSync94(compliancePath2, "utf-8").trim();
+        if (content) {
+          entries2 = content.split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
+        }
+      }
+      if (params.epic) {
+        entries2 = entries2.filter((e) => {
+          const ctx = e._context ?? {};
+          return ctx.epic_id === params.epic || ctx.task_id === params.epic;
+        });
+      }
+      if (params.days) {
+        const cutoff = new Date(Date.now() - params.days * 864e5).toISOString();
+        entries2 = entries2.filter((e) => e.timestamp >= cutoff);
+      }
+      const totalEntries2 = entries2.length;
+      const compliance2 = entries2.map((e) => e.compliance ?? {});
+      const avgPassRate2 = totalEntries2 > 0 ? Math.round(
+        compliance2.reduce((sum, c) => sum + (c.compliance_pass_rate ?? 0), 0) / totalEntries2 * 1e3
+      ) / 1e3 : 0;
+      const avgAdherence2 = totalEntries2 > 0 ? Math.round(
+        compliance2.reduce((sum, c) => sum + (c.rule_adherence_score ?? 0), 0) / totalEntries2 * 1e3
+      ) / 1e3 : 0;
+      const totalViolations2 = compliance2.reduce(
+        (sum, c) => sum + (c.violation_count ?? 0),
+        0
+      );
+      const byDate = {};
+      for (const e of entries2) {
+        const date6 = e.timestamp.split("T")[0];
+        if (!byDate[date6]) byDate[date6] = [];
+        byDate[date6].push(e);
+      }
+      const dataPoints = Object.entries(byDate).sort(([a], [b2]) => a.localeCompare(b2)).map(([date6, dayEntries]) => {
+        const dayCompliance = dayEntries.map(
+          (de2) => de2.compliance ?? {}
+        );
+        return {
+          date: date6,
+          entries: dayEntries.length,
+          avgPassRate: dayCompliance.reduce((s3, c) => s3 + (c.compliance_pass_rate ?? 0), 0) / dayEntries.length,
+          violations: dayCompliance.reduce((s3, c) => s3 + (c.violation_count ?? 0), 0)
+        };
+      });
+      let trend;
+      if (dataPoints.length >= 2) {
+        const first = dataPoints[0].avgPassRate;
+        const last = dataPoints[dataPoints.length - 1].avgPassRate;
+        trend = last > first ? "improving" : last < first ? "declining" : "stable";
+      } else {
+        trend = "insufficient_data";
+      }
+      return {
+        success: true,
+        data: {
+          totalEntries: totalEntries2,
+          averagePassRate: avgPassRate2,
+          averageAdherence: avgAdherence2,
+          totalViolations: totalViolations2,
+          trend,
+          dataPoints
+        }
+      };
+    }
+    const compliancePath = join121(projectRoot, ".cleo", "metrics", "COMPLIANCE.jsonl");
+    let entries = [];
+    if (existsSync126(compliancePath)) {
+      const content = readFileSync94(compliancePath, "utf-8").trim();
+      if (content) {
+        entries = content.split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
+      }
+    }
+    if (params?.epic) {
+      entries = entries.filter((e) => {
+        const ctx = e._context ?? {};
+        return ctx.epic_id === params.epic || ctx.task_id === params.epic;
+      });
+    }
+    if (params?.days) {
+      const cutoff = new Date(Date.now() - params.days * 864e5).toISOString();
+      entries = entries.filter((e) => e.timestamp >= cutoff);
+    }
+    const totalEntries = entries.length;
+    const compliance = entries.map((e) => e.compliance ?? {});
+    const avgPassRate = totalEntries > 0 ? Math.round(
+      compliance.reduce((sum, c) => sum + (c.compliance_pass_rate ?? 0), 0) / totalEntries * 1e3
+    ) / 1e3 : 0;
+    const avgAdherence = totalEntries > 0 ? Math.round(
+      compliance.reduce((sum, c) => sum + (c.rule_adherence_score ?? 0), 0) / totalEntries * 1e3
+    ) / 1e3 : 0;
+    const totalViolations = compliance.reduce(
+      (sum, c) => sum + (c.violation_count ?? 0),
+      0
+    );
+    return {
+      success: true,
+      data: {
+        totalEntries,
+        averagePassRate: avgPassRate,
+        averageAdherence: avgAdherence,
+        totalViolations
+      }
+    };
+  } catch (err) {
+    return cleoErrorToEngineError(err, "E_GENERAL", "Failed to get roadmap");
+  }
+}
 async function systemBackup(projectRoot, params) {
   try {
     const result = await createBackup2(projectRoot, params);
@@ -107171,6 +107393,25 @@ async function systemCleanup(projectRoot, params) {
     return cleoErrorToEngineError(err, "E_CLEANUP_FAILED", "Failed to cleanup");
   }
 }
+async function systemAudit(projectRoot, params) {
+  try {
+    const result = await auditData(projectRoot, params);
+    return { success: true, data: result };
+  } catch (err) {
+    return cleoErrorToEngineError(err, "E_GENERAL", "Failed to audit");
+  }
+}
+function systemSync(_projectRoot, params) {
+  return {
+    success: true,
+    data: {
+      direction: params?.direction ?? "up",
+      synced: 0,
+      conflicts: 0,
+      message: "Sync is a no-op in native mode (no external sync targets configured)"
+    }
+  };
+}
 function systemSafestop(projectRoot, params) {
   try {
     const result = safestop(projectRoot, params);
@@ -107179,6 +107420,14 @@ function systemSafestop(projectRoot, params) {
     return cleoErrorToEngineError(err, "E_GENERAL", "Sync failed");
   }
 }
+async function systemUncancel(projectRoot, params) {
+  try {
+    const result = await uncancelTask(projectRoot, params);
+    return { success: true, data: result };
+  } catch (err) {
+    return cleoErrorToEngineError(err, "E_UNCANCEL_FAILED", "Failed to uncancel");
+  }
+}
 async function systemDoctor(projectRoot) {
   const { coreDoctorReport: coreDoctorReport2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
   try {
@@ -107248,6 +107497,23 @@ async function systemScaffoldHub() {
     return cleoErrorToEngineError(err, "E_SCAFFOLD_HUB_FAILED", "Failed to scaffold hub");
   }
 }
+async function systemSequenceRepair(projectRoot) {
+  try {
+    const repair = await repairSequence(projectRoot);
+    return {
+      success: true,
+      data: {
+        repaired: repair.repaired,
+        message: repair.message,
+        counter: repair.counter,
+        oldCounter: repair.oldCounter,
+        newCounter: repair.newCounter
+      }
+    };
+  } catch (err) {
+    return cleoErrorToEngineError(err, "E_SEQUENCE_REPAIR_FAILED", "Failed to repair sequence");
+  }
+}
 async function systemSmoke() {
   const { dispatchRaw: dispatchRaw2 } = await Promise.resolve().then(() => (init_cli(), cli_exports));
   const totalStart = Date.now();
@@ -111679,7 +111945,7 @@ async function orchestrateAnalyzeParallelSafety(taskIds, projectRoot) {
     };
   }
 }
-var OrchestrateHandler, FANOUT_MANIFEST_MAX_SIZE, fanoutManifestStore;
+var conduitHandler, OrchestrateHandler, FANOUT_MANIFEST_MAX_SIZE, fanoutManifestStore;
 var init_orchestrate2 = __esm({
   "packages/cleo/src/dispatch/domains/orchestrate.ts"() {
     "use strict";
@@ -111688,6 +111954,8 @@ var init_orchestrate2 = __esm({
     init_base();
     init_meta2();
     init_routing2();
+    init_conduit2();
+    conduitHandler = new ConduitHandler();
     OrchestrateHandler = class {
       // -----------------------------------------------------------------------
       // DomainHandler interface
@@ -111866,6 +112134,11 @@ var init_orchestrate2 = __esm({
                 page: page.page
               };
             }
+            // ADR-042: conduit sub-operations routed through orchestrate domain
+            case "conduit.status":
+              return conduitHandler.query("status", params);
+            case "conduit.peek":
+              return conduitHandler.query("peek", params);
             default:
               return errorResult(
                 "query",
@@ -112115,6 +112388,13 @@ var init_orchestrate2 = __esm({
                 data: instance
               };
             }
+            // ADR-042: conduit sub-operations routed through orchestrate domain
+            case "conduit.start":
+              return conduitHandler.mutate("start", params);
+            case "conduit.stop":
+              return conduitHandler.mutate("stop", params);
+            case "conduit.send":
+              return conduitHandler.mutate("send", params);
             default:
               return errorResult(
                 "mutate",
@@ -112147,7 +112427,10 @@ var init_orchestrate2 = __esm({
             "tessera.list",
             // Wave 7a (T379)
             "classify",
-            "fanout.status"
+            "fanout.status",
+            // ADR-042: conduit sub-operations
+            "conduit.status",
+            "conduit.peek"
           ],
           mutate: [
             "start",
@@ -112158,7 +112441,11 @@ var init_orchestrate2 = __esm({
             "parallel",
             "tessera.instantiate",
             // Wave 7a (T379)
-            "fanout"
+            "fanout",
+            // ADR-042: conduit sub-operations
+            "conduit.start",
+            "conduit.stop",
+            "conduit.send"
           ]
         };
       }
@@ -115255,7 +115542,6 @@ function createDomainHandlers() {
   handlers.set("admin", new AdminHandler());
   handlers.set("nexus", new NexusHandler());
   handlers.set("sticky", new StickyHandler());
-  handlers.set("conduit", new ConduitHandler());
   return handlers;
 }
 var init_domains = __esm({
@@ -116771,6 +117057,75 @@ function resolveFormat2(opts, defaults) {
   return resolveOutputFormat(input);
 }
 
+// packages/cleo/src/cli/commands/adapter.ts
+init_cli();
+function registerAdapterCommand(program) {
+  const adapterCmd = program.command("adapter").description("Provider adapter management: list, show, detect, health, activate, dispose");
+  adapterCmd.command("list").description("List all discovered provider adapters").action(async () => {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "adapter.list",
+      {},
+      { command: "adapter", operation: "tools.adapter.list" }
+    );
+  });
+  adapterCmd.command("show <adapter-id>").description("Show details for a specific adapter").action(async (adapterId) => {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "adapter.show",
+      { id: adapterId },
+      { command: "adapter", operation: "tools.adapter.show" }
+    );
+  });
+  adapterCmd.command("detect").description("Detect active providers in the current environment").action(async () => {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "adapter.detect",
+      {},
+      { command: "adapter", operation: "tools.adapter.detect" }
+    );
+  });
+  adapterCmd.command("health").description("Show health status for adapters").option("--id <adapter-id>", "Specific adapter ID (omit for all adapters)").action(async (opts) => {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "adapter.health",
+      { id: opts["id"] },
+      { command: "adapter", operation: "tools.adapter.health" }
+    );
+  });
+  adapterCmd.command("activate <adapter-id>").description("Load and activate a provider adapter").action(async (adapterId) => {
+    await dispatchFromCli(
+      "mutate",
+      "tools",
+      "adapter.activate",
+      { id: adapterId },
+      { command: "adapter", operation: "tools.adapter.activate" }
+    );
+  });
+  adapterCmd.command("dispose").description("Dispose one or all adapters").option("--id <adapter-id>", "Specific adapter ID to dispose (omit to dispose all)").action(async (opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "tools",
+      "adapter.dispose",
+      { id: opts["id"] },
+      { command: "adapter", operation: "tools.adapter.dispose" }
+    );
+  });
+  adapterCmd.action(async () => {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "adapter.list",
+      {},
+      { command: "adapter", operation: "tools.adapter.list" }
+    );
+  });
+}
+
 // packages/cleo/src/cli/commands/add.ts
 init_cli();
 
@@ -117206,6 +117561,76 @@ function registerAdminCommand(program) {
   ).action(async () => {
     await dispatchFromCli("mutate", "admin", "scaffold-hub", {}, { command: "admin" });
   });
+  admin.command("cleanup").description("Purge stale CLEO data (backups, logs, archive entries)").requiredOption("--target <target>", "What to clean: backups | logs | archive | sessions").option("--older-than <age>", "Remove entries older than this duration (e.g. 30d, 6m, 1y)").option("--dry-run", "Preview what would be removed without making changes").action(async (opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "cleanup",
+      {
+        target: opts["target"],
+        olderThan: opts["olderThan"],
+        dryRun: opts["dryRun"] === true
+      },
+      { command: "admin cleanup", operation: "admin.cleanup" }
+    );
+  });
+  const job = admin.command("job").description("Inspect background jobs managed by the job manager");
+  job.command("list", { isDefault: true }).description("List all background jobs (default)").option("--status <status>", "Filter by job status (pending, running, done, failed, cancelled)").option("--limit <n>", "Maximum jobs to return", "20").option("--offset <n>", "Skip N jobs", "0").action(async (opts) => {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "job",
+      {
+        action: "list",
+        status: opts["status"],
+        limit: opts["limit"] ? Number(opts["limit"]) : 20,
+        offset: opts["offset"] ? Number(opts["offset"]) : 0
+      },
+      { command: "admin job list", operation: "admin.job" }
+    );
+  });
+  job.command("status <jobId>").description("Show status of a specific background job").action(async (jobId) => {
+    await dispatchFromCli(
+      "query",
+      "admin",
+      "job",
+      { action: "status", jobId },
+      { command: "admin job status", operation: "admin.job" }
+    );
+  });
+  job.command("cancel <jobId>").description("Cancel a running background job").action(async (jobId) => {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "job.cancel",
+      { jobId },
+      { command: "admin job cancel", operation: "admin.job.cancel" }
+    );
+  });
+  admin.command("install-global").description("Refresh global CLEO setup (provider files, configs, ~/.agents/AGENTS.md)").action(async () => {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "install.global",
+      {},
+      { command: "admin install-global", operation: "admin.install.global" }
+    );
+  });
+  admin.command("context-inject <protocolType>").description(
+    "Inject protocol content into session context (e.g. cleo-base, ct-orchestrator, ct-cleo)"
+  ).option("--task <id>", "Scope injection to a specific task ID").option("--variant <variant>", "Select a named protocol variant").action(async (protocolType, opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "context.inject",
+      {
+        protocolType,
+        taskId: opts["task"],
+        variant: opts["variant"]
+      },
+      { command: "admin context-inject", operation: "admin.context.inject" }
+    );
+  });
 }
 
 // packages/cleo/src/cli/commands/adr.ts
@@ -120227,6 +120652,23 @@ function registerBugCommand(program) {
   });
 }
 
+// packages/cleo/src/cli/commands/cancel.ts
+init_cli();
+function registerCancelCommand(program) {
+  program.command("cancel <taskId>").description("Cancel a task (soft terminal state; reversible via restore)").option("--reason <reason>", "Reason for cancellation").action(async (taskId, opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "tasks",
+      "cancel",
+      {
+        taskId,
+        reason: opts["reason"]
+      },
+      { command: "cancel", operation: "tasks.cancel" }
+    );
+  });
+}
+
 // packages/cleo/src/cli/commands/cant.ts
 init_renderers();
 import { existsSync as existsSync128, mkdirSync as mkdirSync29, readFileSync as readFileSync97, writeFileSync as writeFileSync23 } from "node:fs";
@@ -120425,6 +120867,36 @@ function registerCheckCommand(program) {
   check2.command("task <taskId>").description("Validate a specific task").action(async (taskId) => {
     await dispatchFromCli("query", "check", "task", { taskId }, { command: "check" });
   });
+  check2.command("output <filePath>").description("Validate an agent output file against the manifest schema").option("--task-id <id>", "Task ID the output file belongs to").action(async (filePath, opts) => {
+    await dispatchFromCli(
+      "query",
+      "check",
+      "output",
+      {
+        filePath,
+        taskId: opts["taskId"]
+      },
+      { command: "check", operation: "check.output" }
+    );
+  });
+  check2.command("chain-validate <file>").description("Validate a WarpChain definition from a JSON file").action(async (file2) => {
+    const { readFileSync: readFileSync102 } = await import("node:fs");
+    let chain;
+    try {
+      chain = JSON.parse(readFileSync102(file2, "utf8"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`Failed to read or parse chain file: ${message}`);
+      process.exit(2);
+    }
+    await dispatchFromCli(
+      "query",
+      "check",
+      "chain.validate",
+      { chain },
+      { command: "check", operation: "check.chain.validate" }
+    );
+  });
   check2.command("protocol <protocolType>").description(
     `Validate any of the 12 RCASD-IVTR+C protocols: ${SUPPORTED_PROTOCOL_TYPES.join(", ")}`
   ).option("--task-id <id>", "Task ID to validate (mode=task, default)").option("--manifest-file <file>", "Manifest file to validate (mode=manifest)").option("--strict", "Exit with error code on violations").option("--voting-matrix-file <file>", "consensus: voting matrix JSON file").option("--epic-id <id>", "decomposition: parent epic ID").option("--sibling-count <n>", "decomposition: actual sibling count", Number).option("--max-siblings <n>", "decomposition: configured max siblings", Number).option("--spec-file <file>", "specification: path to spec markdown").option("--has-code-changes", "research: code changes detected (forbidden)").option("--has-task-tags", "implementation: @task tags present in code").option("--has-contribution-tags", "contribution: @contribution tags present").option("--version <v>", "release: target version (semver/calver)").option("--has-changelog", "release: changelog updated").option(
@@ -120576,6 +121048,34 @@ function registerCheckpointCommand(program) {
   });
 }
 
+// packages/cleo/src/cli/commands/claim.ts
+init_cli();
+function registerClaimCommand(program) {
+  program.command("claim <taskId>").description("Claim a task by assigning it to an agent").option("--agent <agentId>", "Agent ID to assign the task to (required)").action(async (taskId, opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "tasks",
+      "claim",
+      {
+        taskId,
+        agentId: opts["agent"]
+      },
+      { command: "claim", operation: "tasks.claim" }
+    );
+  });
+}
+function registerUnclaimCommand(program) {
+  program.command("unclaim <taskId>").description("Unclaim a task by removing its current assignee").action(async (taskId) => {
+    await dispatchFromCli(
+      "mutate",
+      "tasks",
+      "unclaim",
+      { taskId },
+      { command: "unclaim", operation: "tasks.unclaim" }
+    );
+  });
+}
+
 // packages/cleo/src/cli/commands/commands.ts
 init_cli();
 function registerCommandsCommand(program) {
@@ -120667,6 +121167,21 @@ function registerCompleteCommand(program) {
   });
 }
 
+// packages/cleo/src/cli/commands/complexity.ts
+init_cli();
+function registerComplexityCommand(program) {
+  const complexity = program.command("complexity").description("Task complexity analysis");
+  complexity.command("estimate <taskId>").description("Estimate complexity of a task (small / medium / large)").action(async (taskId) => {
+    await dispatchFromCli(
+      "query",
+      "tasks",
+      "complexity.estimate",
+      { taskId },
+      { command: "complexity", operation: "tasks.complexity.estimate" }
+    );
+  });
+}
+
 // packages/cleo/src/cli/commands/compliance.ts
 init_cli();
 function registerComplianceCommand(program) {
@@ -120757,9 +121272,37 @@ function registerComplianceCommand(program) {
       { command: "compliance" }
     );
   });
-}
-
-// packages/cleo/src/cli/commands/config.ts
+  compliance.command("record <taskId> <result>").description("Record a compliance check result for a task (pass|fail|warning)").option("--protocol <name>", "Protocol name the check applies to (e.g. implementation)").option(
+    "--violation <spec>",
+    'Add a violation as "code:severity:message" (repeatable)',
+    (val, prev) => [...prev, val],
+    []
+  ).action(async (taskId, result, opts) => {
+    const rawViolations = opts["violation"];
+    const violations = rawViolations.map((v2) => {
+      const [code, severity, ...rest] = v2.split(":");
+      return {
+        code: code ?? "",
+        severity: severity === "error" || severity === "warning" ? severity : "error",
+        message: rest.join(":")
+      };
+    }).filter((v2) => v2.code);
+    await dispatchFromCli(
+      "mutate",
+      "check",
+      "compliance.record",
+      {
+        taskId,
+        result,
+        protocol: opts["protocol"],
+        violations: violations.length > 0 ? violations : void 0
+      },
+      { command: "compliance", operation: "check.compliance.record" }
+    );
+  });
+}
+
+// packages/cleo/src/cli/commands/config.ts
 init_src2();
 init_cli();
 init_renderers();
@@ -121082,19 +121625,15 @@ function registerTreeCommand(program) {
 }
 
 // packages/cleo/src/cli/commands/detect.ts
-init_internal();
-init_renderers();
+init_cli();
 function registerDetectCommand(program) {
   program.command("detect").description("Re-detect project type and update project-context.json").action(async () => {
-    const projectRoot = getProjectRoot();
-    const result = await ensureProjectContext(projectRoot, { staleDays: 0 });
-    cliOutput(
-      {
-        action: result.action,
-        path: result.path,
-        details: result.details
-      },
-      { command: "detect" }
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "detect",
+      {},
+      { command: "detect", operation: "admin.detect" }
     );
   });
 }
@@ -122638,6 +123177,56 @@ function registerLifecycleCommand(program) {
       { command: "lifecycle" }
     );
   });
+  lifecycle.command("history <taskId>").description("Show full lifecycle stage history for a task or epic").action(async (taskId) => {
+    await dispatchFromCli(
+      "query",
+      "pipeline",
+      "stage.history",
+      { taskId },
+      { command: "lifecycle" }
+    );
+  });
+  lifecycle.command("reset <epicId> <stage>").description("Reset a lifecycle stage back to pending").requiredOption("--reason <reason>", "Reason for resetting the stage").action(async (epicId, stage, opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "stage.reset",
+      {
+        taskId: epicId,
+        stage,
+        reason: opts["reason"]
+      },
+      { command: "lifecycle" }
+    );
+  });
+  const gate = lifecycle.command("gate-record").description("Record a gate pass or fail for a lifecycle stage");
+  gate.command("pass <epicId> <gateName>").description("Record a gate as passed for a lifecycle stage").option("--agent <agent>", "Agent that performed the gate check").option("--notes <notes>", "Notes on gate outcome").action(async (epicId, gateName, opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "stage.gate.pass",
+      {
+        taskId: epicId,
+        gateName,
+        agent: opts["agent"],
+        notes: opts["notes"]
+      },
+      { command: "lifecycle" }
+    );
+  });
+  gate.command("fail <epicId> <gateName>").description("Record a gate as failed for a lifecycle stage").option("--reason <reason>", "Reason the gate failed").action(async (epicId, gateName, opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "stage.gate.fail",
+      {
+        taskId: epicId,
+        gateName,
+        reason: opts["reason"]
+      },
+      { command: "lifecycle" }
+    );
+  });
 }
 
 // packages/cleo/src/cli/commands/list.ts
@@ -122926,15 +123515,149 @@ function registerMemoryBrainCommand(program) {
       { command: "memory", operation: "memory.fetch" }
     );
   });
+  memory.command("decision find [query]").description("Search decisions stored in brain.db").option("--limit <n>", "Maximum results", parseInt).option("--json", "Output as JSON").action(async (query, opts) => {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "decision.find",
+      {
+        query: query ?? "",
+        limit: opts["limit"]
+      },
+      { command: "memory", operation: "memory.decision.find" }
+    );
+  });
+  memory.command("decision store").description("Store a decision to brain.db").requiredOption("--decision <text>", "The decision that was made").requiredOption("--rationale <text>", "Rationale behind the decision").option("--alternatives <text>", "Alternatives that were considered").option("--linked-task <id>", "Task ID to associate with this decision").option("--json", "Output as JSON").action(async (opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "memory",
+      "decision.store",
+      {
+        decision: opts["decision"],
+        rationale: opts["rationale"],
+        ...opts["alternatives"] !== void 0 && { alternatives: opts["alternatives"] },
+        ...opts["linkedTask"] !== void 0 && { taskId: opts["linkedTask"] }
+      },
+      { command: "memory", operation: "memory.decision.store" }
+    );
+  });
+  memory.command("link <taskId> <entryId>").description("Link a brain entry to a task").option("--json", "Output as JSON").action(async (taskId, entryId, _opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "memory",
+      "link",
+      { taskId, entryId },
+      { command: "memory", operation: "memory.link" }
+    );
+  });
+  memory.command("graph show <nodeId>").description("Get a PageIndex graph node and its edges").option("--json", "Output as JSON").action(async (nodeId, _opts) => {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "graph.show",
+      { nodeId },
+      { command: "memory", operation: "memory.graph.show" }
+    );
+  });
+  memory.command("graph neighbors <nodeId>").description("Get neighbor nodes from the PageIndex graph").option("--depth <n>", "Traversal depth", parseInt).option("--limit <n>", "Maximum neighbors", parseInt).option("--json", "Output as JSON").action(async (nodeId, opts) => {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "graph.neighbors",
+      {
+        nodeId,
+        ...opts["depth"] !== void 0 && { depth: opts["depth"] },
+        ...opts["limit"] !== void 0 && { limit: opts["limit"] }
+      },
+      { command: "memory", operation: "memory.graph.neighbors" }
+    );
+  });
+  memory.command("graph add").description("Add a node or edge to the PageIndex graph").option("--node-id <id>", "Node ID to add").option("--label <text>", "Label for the node").option("--from <id>", "Source node ID for an edge").option("--to <id>", "Target node ID for an edge").option("--edge-type <type>", "Edge relationship type").option("--json", "Output as JSON").action(async (opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "memory",
+      "graph.add",
+      {
+        ...opts["nodeId"] !== void 0 && { nodeId: opts["nodeId"] },
+        ...opts["label"] !== void 0 && { label: opts["label"] },
+        ...opts["from"] !== void 0 && { from: opts["from"] },
+        ...opts["to"] !== void 0 && { to: opts["to"] },
+        ...opts["edgeType"] !== void 0 && { edgeType: opts["edgeType"] }
+      },
+      { command: "memory", operation: "memory.graph.add" }
+    );
+  });
+  memory.command("graph remove").description("Remove a node or edge from the PageIndex graph").option("--node-id <id>", "Node ID to remove").option("--from <id>", "Source node ID of the edge to remove").option("--to <id>", "Target node ID of the edge to remove").option("--json", "Output as JSON").action(async (opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "memory",
+      "graph.remove",
+      {
+        ...opts["nodeId"] !== void 0 && { nodeId: opts["nodeId"] },
+        ...opts["from"] !== void 0 && { from: opts["from"] },
+        ...opts["to"] !== void 0 && { to: opts["to"] }
+      },
+      { command: "memory", operation: "memory.graph.remove" }
+    );
+  });
+  memory.command("reason why <taskId>").description("Causal trace through task dependency chains").option("--depth <n>", "Maximum trace depth", parseInt).option("--json", "Output as JSON").action(async (taskId, opts) => {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "reason.why",
+      {
+        taskId,
+        ...opts["depth"] !== void 0 && { depth: opts["depth"] }
+      },
+      { command: "memory", operation: "memory.reason.why" }
+    );
+  });
+  memory.command("reason similar <entryId>").description("Find semantically similar brain entries").option("--limit <n>", "Maximum results", parseInt).option("--json", "Output as JSON").action(async (entryId, opts) => {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "reason.similar",
+      {
+        entryId,
+        ...opts["limit"] !== void 0 && { limit: opts["limit"] }
+      },
+      { command: "memory", operation: "memory.reason.similar" }
+    );
+  });
+  memory.command("search hybrid <query>").description("Hybrid search across FTS5, vector, and graph indexes").option("--limit <n>", "Maximum results", parseInt).option("--json", "Output as JSON").action(async (query, opts) => {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "search.hybrid",
+      {
+        query,
+        ...opts["limit"] !== void 0 && { limit: opts["limit"] }
+      },
+      { command: "memory", operation: "memory.search.hybrid" }
+    );
+  });
 }
 
 // packages/cleo/src/cli/commands/migrate-claude-mem.ts
 init_internal();
+init_cli();
 function registerMigrateClaudeMemCommand(program) {
   let migrateCmd = program.commands.find((c) => c.name() === "migrate");
   if (!migrateCmd) {
     migrateCmd = program.command("migrate").description("Data migration utilities");
   }
+  migrateCmd.command("storage").description("Run CLEO internal storage and schema migrations").option("--target <version>", "Target schema version to migrate to").option("--dry-run", "Preview migration steps without making changes").action(async (opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "admin",
+      "migrate",
+      {
+        target: opts["target"],
+        dryRun: opts["dryRun"] === true
+      },
+      { command: "migrate storage", operation: "admin.migrate" }
+    );
+  });
   migrateCmd.command("claude-mem").description("Import observations from claude-mem into brain.db").option("--dry-run", "Show what would be imported without making changes").option("--source <path>", "Path to claude-mem.db (default: ~/.claude-mem/claude-mem.db)").option("--project <name>", "Project tag for imported entries").option("--batch-size <n>", "Rows per transaction batch (default: 100)", parseInt).action(async (opts) => {
     const root = getProjectRoot();
     try {
@@ -123012,13 +123735,24 @@ function registerNexusCommand(program) {
   nexus.command("status").description("Show NEXUS registry status").action(async () => {
     await dispatchFromCli("query", "nexus", "status", {}, { command: "nexus" });
   });
-  nexus.command("show <taskId>").alias("query").description("Show a task across projects (project:T### or T###)").action(async (taskId) => {
+  nexus.command("show <name>").description("Show details for a registered project by name").action(async (name2) => {
+    await dispatchFromCli(
+      "query",
+      "nexus",
+      "show",
+      {
+        name: name2
+      },
+      { command: "nexus" }
+    );
+  });
+  nexus.command("resolve <taskRef>").alias("query").description("Resolve a task reference across projects (project:T### or T###)").action(async (taskRef) => {
     await dispatchFromCli(
       "query",
       "nexus",
       "resolve",
       {
-        query: taskId
+        query: taskRef
       },
       { command: "nexus" }
     );
@@ -123106,6 +123840,80 @@ function registerNexusCommand(program) {
       { command: "nexus" }
     );
   });
+  nexus.command("graph").description("Show full dependency graph across all registered projects").action(async () => {
+    await dispatchFromCli("query", "nexus", "graph", {}, { command: "nexus" });
+  });
+  nexus.command("share-status").description("Show multi-contributor sharing status for the current project").action(async () => {
+    await dispatchFromCli("query", "nexus", "share.status", {}, { command: "nexus" });
+  });
+  nexus.command("transfer-preview <taskIds...>").description("Preview a task transfer between projects (dry-run, no changes made)").requiredOption("--from <project>", "Source project name").requiredOption("--to <project>", "Target project name").option("--mode <mode>", "Transfer mode: copy|move", "copy").option("--scope <scope>", "Transfer scope: single|subtree", "subtree").action(async (taskIds, opts) => {
+    await dispatchFromCli(
+      "query",
+      "nexus",
+      "transfer.preview",
+      {
+        taskIds,
+        sourceProject: opts["from"],
+        targetProject: opts["to"],
+        mode: opts["mode"],
+        scope: opts["scope"]
+      },
+      { command: "nexus" }
+    );
+  });
+  nexus.command("transfer <taskIds...>").description("Transfer tasks from one project to another").requiredOption("--from <project>", "Source project name").requiredOption("--to <project>", "Target project name").option("--mode <mode>", "Transfer mode: copy|move", "copy").option("--scope <scope>", "Transfer scope: single|subtree", "subtree").option("--on-conflict <strategy>", "Conflict strategy: rename|skip|duplicate|fail", "rename").option("--transfer-brain", "Also transfer associated brain memory entries", false).action(async (taskIds, opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "nexus",
+      "transfer",
+      {
+        taskIds,
+        sourceProject: opts["from"],
+        targetProject: opts["to"],
+        mode: opts["mode"],
+        scope: opts["scope"],
+        onConflict: opts["onConflict"],
+        transferBrain: opts["transferBrain"]
+      },
+      { command: "nexus" }
+    );
+  });
+  const permission = nexus.command("permission").description("Manage permissions for registered projects");
+  permission.command("set <name> <level>").description("Set permission level for a registered project (read|write|execute)").action(async (name2, level) => {
+    await dispatchFromCli(
+      "mutate",
+      "nexus",
+      "permission.set",
+      {
+        name: name2,
+        level
+      },
+      { command: "nexus" }
+    );
+  });
+  const share = nexus.command("share").description("Multi-contributor sharing operations");
+  share.command("export").description("Export a snapshot of current project state for sharing").option("--output <path>", "Output file path (default: auto-generated in current directory)").action(async (opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "nexus",
+      "share.snapshot.export",
+      {
+        outputPath: opts["output"]
+      },
+      { command: "nexus" }
+    );
+  });
+  share.command("import <file>").description("Import a shared project snapshot").action(async (file2) => {
+    await dispatchFromCli(
+      "mutate",
+      "nexus",
+      "share.snapshot.import",
+      {
+        inputPath: file2
+      },
+      { command: "nexus" }
+    );
+  });
 }
 
 // packages/cleo/src/cli/commands/observe.ts
@@ -123152,12 +123960,23 @@ function registerOrchestrateCommand(program) {
       { command: "orchestrate" }
     );
   });
-  orch.command("analyze <epicId>").description("Analyze epic dependency structure").action(async (epicId) => {
+  orch.command("status").description("Get orchestration status for an epic or overall project").option("--epic <epicId>", "Epic ID to scope status to").action(async (opts) => {
+    await dispatchFromCli(
+      "query",
+      "orchestrate",
+      "status",
+      { epicId: opts["epic"] },
+      { command: "orchestrate" }
+    );
+  });
+  orch.command("analyze <epicId>").description("Analyze epic dependency structure").option("--mode <mode>", "Analysis mode: critical-path or parallel-safety").option("--tasks <ids>", "Comma-separated task IDs for parallel-safety mode").action(async (epicId, opts) => {
+    const mode = opts["mode"];
+    const taskIds = typeof opts["tasks"] === "string" ? opts["tasks"].split(",").map((s3) => s3.trim()) : void 0;
     await dispatchFromCli(
       "query",
       "orchestrate",
       "analyze",
-      { epicId },
+      { epicId, mode, taskIds },
       { command: "orchestrate" }
     );
   });
@@ -123173,12 +123992,21 @@ function registerOrchestrateCommand(program) {
   orch.command("next <epicId>").description("Get next task to spawn").action(async (epicId) => {
     await dispatchFromCli("query", "orchestrate", "next", { epicId }, { command: "orchestrate" });
   });
-  orch.command("spawn <taskId>").description("Prepare spawn context for a subagent").action(async (taskId) => {
+  orch.command("waves <epicId>").description("Compute dependency waves for an epic").action(async (epicId) => {
+    await dispatchFromCli(
+      "query",
+      "orchestrate",
+      "waves",
+      { epicId },
+      { command: "orchestrate" }
+    );
+  });
+  orch.command("spawn <taskId>").description("Prepare spawn context for a subagent").option("--protocol <type>", "Protocol type override").option("--tier <tier>", "Protocol tier (0, 1, or 2)", parseInt).action(async (taskId, opts) => {
     await dispatchFromCli(
       "mutate",
       "orchestrate",
       "spawn",
-      { taskId },
+      { taskId, protocolType: opts["protocol"], tier: opts["tier"] },
       { command: "orchestrate" }
     );
   });
@@ -123204,6 +124032,53 @@ function registerOrchestrateCommand(program) {
       { command: "orchestrate" }
     );
   });
+  orch.command("parallel <action> <epicId>").description("Manage parallel wave execution (action: start | end)").option("--wave <number>", "Wave number", parseInt).action(async (action, epicId, opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "orchestrate",
+      "parallel",
+      { action, epicId, wave: opts["wave"] },
+      { command: "orchestrate" }
+    );
+  });
+  const tessera = orch.command("tessera").description("Tessera template operations for multi-agent orchestration");
+  tessera.command("list").description("List available tessera templates").option("--id <templateId>", "Show details for a specific template").option("--limit <n>", "Max results to return", parseInt).option("--offset <n>", "Results offset for pagination", parseInt).action(async (opts) => {
+    await dispatchFromCli(
+      "query",
+      "orchestrate",
+      "tessera.list",
+      { id: opts["id"], limit: opts["limit"], offset: opts["offset"] },
+      { command: "orchestrate" }
+    );
+  });
+  tessera.command("instantiate <templateId> <epicId>").description("Instantiate a tessera template for an epic").option("--var <pairs...>", "Key=value variable overrides").action(async (templateId, epicId, opts) => {
+    const variables = {};
+    const pairs = opts["var"];
+    if (Array.isArray(pairs)) {
+      for (const pair of pairs) {
+        const eqIdx = pair.indexOf("=");
+        if (eqIdx > 0) {
+          variables[pair.slice(0, eqIdx)] = pair.slice(eqIdx + 1);
+        }
+      }
+    }
+    await dispatchFromCli(
+      "mutate",
+      "orchestrate",
+      "tessera.instantiate",
+      { templateId, epicId, variables },
+      { command: "orchestrate" }
+    );
+  });
+  orch.command("unblock").description("Analyze dependency graph for unblocking opportunities").action(async () => {
+    await dispatchFromCli(
+      "query",
+      "orchestrate",
+      "unblock.opportunities",
+      {},
+      { command: "orchestrate" }
+    );
+  });
 }
 
 // packages/cleo/src/cli/commands/otel.ts
@@ -123423,6 +124298,85 @@ function registerPromoteCommand(program) {
   });
 }
 
+// packages/cleo/src/cli/commands/provider.ts
+init_cli();
+function registerProviderCommand(program) {
+  const providerCmd = program.command("provider").description("CAAMP provider registry: list, detect, supports, hooks, inject");
+  providerCmd.command("list").description("List all registered CAAMP providers").option("--limit <n>", "Maximum providers to return").option("--offset <n>", "Offset for pagination").action(async (opts) => {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "provider.list",
+      {
+        limit: opts["limit"] ? Number(opts["limit"]) : void 0,
+        offset: opts["offset"] ? Number(opts["offset"]) : void 0
+      },
+      { command: "provider", operation: "tools.provider.list" }
+    );
+  });
+  providerCmd.command("detect").description("Detect which provider is active in the current environment").action(async () => {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "provider.detect",
+      {},
+      { command: "provider", operation: "tools.provider.detect" }
+    );
+  });
+  providerCmd.command("inject-status").description("Show provider injection status for project or global scope").option("--scope <scope>", "Scope: project or global (default: project)").option("--content <content>", "Content string to check against").action(async (opts) => {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "provider.inject.status",
+      {
+        scope: opts["scope"] ?? "project",
+        content: opts["content"]
+      },
+      { command: "provider", operation: "tools.provider.inject.status" }
+    );
+  });
+  providerCmd.command("supports <provider-id> <capability>").description("Check if a provider supports a capability (e.g., spawn.supportsSubagents)").action(async (providerId, capability) => {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "provider.supports",
+      { providerId, capability },
+      { command: "provider", operation: "tools.provider.supports" }
+    );
+  });
+  providerCmd.command("hooks <event>").description("List providers that support a specific hook event (e.g., onSessionStart)").action(async (event) => {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "provider.hooks",
+      { event },
+      { command: "provider", operation: "tools.provider.hooks" }
+    );
+  });
+  providerCmd.command("inject").description("Inject provider references into AGENTS.md (project or global scope)").option("--scope <scope>", "Scope: project or global (default: project)").option("--references <refs...>", "Provider reference IDs to inject").option("--content <content>", "Content string to inject directly").action(async (opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "tools",
+      "provider.inject",
+      {
+        scope: opts["scope"] ?? "project",
+        references: opts["references"],
+        content: opts["content"]
+      },
+      { command: "provider", operation: "tools.provider.inject" }
+    );
+  });
+  providerCmd.action(async () => {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "provider.list",
+      {},
+      { command: "provider", operation: "tools.provider.list" }
+    );
+  });
+}
+
 // packages/cleo/src/cli/commands/reason.ts
 init_cli();
 function registerReasonCommand(program) {
@@ -123599,6 +124553,27 @@ function registerReleaseCommand(program) {
       { command: "release" }
     );
   });
+  release2.command("rollback <version>").description("Roll back a shipped release (marks it as rolled-back in CLEO records)").option("--reason <reason>", "Reason for rollback").action(async (version2, opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "release.rollback",
+      {
+        version: version2,
+        reason: opts["reason"]
+      },
+      { command: "release" }
+    );
+  });
+  release2.command("channel").description("Show the current release channel based on git branch (latest/beta/alpha)").action(async () => {
+    await dispatchFromCli(
+      "query",
+      "pipeline",
+      "release.channel.show",
+      {},
+      { command: "release" }
+    );
+  });
 }
 
 // packages/cleo/src/cli/commands/remote.ts
@@ -124814,7 +125789,9 @@ async function runPostUpdateDiagnostics(opts) {
 }
 
 // packages/cleo/src/cli/commands/sequence.ts
+init_internal();
 init_cli();
+init_renderers();
 function registerSequenceCommand(program) {
   const sequence = program.command("sequence").description("Inspect and manage task ID sequence (show/check/repair)");
   sequence.command("show").description("Display current sequence state").action(async () => {
@@ -124836,13 +125813,10 @@ function registerSequenceCommand(program) {
     );
   });
   sequence.command("repair").description("Reset counter to max + 1 if behind").action(async () => {
-    await dispatchFromCli(
-      "mutate",
-      "admin",
-      "config.set",
-      { key: "sequence", value: "repair" },
-      { command: "sequence" }
-    );
+    const { systemSequenceRepair: systemSequenceRepair2 } = await Promise.resolve().then(() => (init_system_engine(), system_engine_exports));
+    const projectRoot = getProjectRoot();
+    const result = await systemSequenceRepair2(projectRoot);
+    cliOutput(result, { command: "sequence", operation: "admin.sequence.repair" });
   });
 }
 
@@ -124983,6 +125957,55 @@ function registerSessionCommand(program) {
       { command: "session", operation: "session.gc" }
     );
   });
+  session.command("show <sessionId>").description("Show full details for a session (absorbs debrief.show via --include debrief)").option("--include <include>", "Include extra data (debrief)").action(async (sessionId, opts) => {
+    await dispatchFromCli(
+      "query",
+      "session",
+      "show",
+      {
+        sessionId,
+        include: opts["include"]
+      },
+      { command: "session", operation: "session.show" }
+    );
+  });
+  session.command("context-drift").description("Detect context drift in the current or specified session").option("--session-id <sessionId>", "Session ID to check (defaults to active session)").action(async (opts) => {
+    await dispatchFromCli(
+      "query",
+      "session",
+      "context.drift",
+      {
+        sessionId: opts["sessionId"]
+      },
+      { command: "session", operation: "session.context.drift" }
+    );
+  });
+  session.command("suspend <sessionId>").description("Suspend an active session (pause without ending)").option("--reason <reason>", "Reason for suspension").action(async (sessionId, opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "session",
+      "suspend",
+      {
+        sessionId,
+        reason: opts["reason"]
+      },
+      { command: "session", operation: "session.suspend" }
+    );
+  });
+  session.command("record-assumption").description("Record an assumption made during the current session").requiredOption("--assumption <assumption>", "Assumption text").requiredOption("--confidence <confidence>", "Confidence level (high|medium|low)").option("--session-id <sessionId>", "Session ID (defaults to active session)").option("--task-id <taskId>", "Task ID the assumption relates to").action(async (opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "session",
+      "record.assumption",
+      {
+        sessionId: opts["sessionId"],
+        taskId: opts["taskId"],
+        assumption: opts["assumption"],
+        confidence: opts["confidence"]
+      },
+      { command: "session", operation: "session.record.assumption" }
+    );
+  });
   session.command("record-decision").description("Record a decision made during the current session").requiredOption("--session-id <sessionId>", "Session ID").requiredOption("--task-id <taskId>", "Task ID the decision relates to").requiredOption("--decision <decision>", "Decision text").requiredOption("--rationale <rationale>", "Rationale for the decision").option("--alternatives <alternatives>", "Alternatives considered").action(async (opts) => {
     await dispatchFromCli(
       "mutate",
@@ -125148,6 +126171,63 @@ function registerSkillsCommand(program) {
       }
     );
   });
+  skillsCmd.command("dispatch <skill-name>").description("Resolve dispatch path for a skill").action(async (skillName) => {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "skill.dispatch",
+      { name: skillName },
+      { command: "skills", operation: "tools.skill.dispatch" }
+    );
+  });
+  skillsCmd.command("catalog").description("Browse CAAMP skill catalog (protocols, profiles, resources, info)").option("--type <type>", "Catalog type: protocols, profiles, resources, info (default: info)").option("--limit <n>", "Maximum items to return").option("--offset <n>", "Offset for pagination").action(async (opts) => {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "skill.catalog",
+      {
+        type: opts["type"] ?? "info",
+        limit: opts["limit"] ? Number(opts["limit"]) : void 0,
+        offset: opts["offset"] ? Number(opts["offset"]) : void 0
+      },
+      { command: "skills", operation: "tools.skill.catalog" }
+    );
+  });
+  skillsCmd.command("precedence").description("Show or resolve skill provider precedence").option("--resolve <provider-id>", "Resolve precedence for a specific provider").option("--scope <scope>", "Scope: global or project (default: global)").action(async (opts) => {
+    const providerId = opts["resolve"];
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "skill.precedence",
+      {
+        action: providerId ? "resolve" : "show",
+        providerId,
+        scope: opts["scope"] ?? "global"
+      },
+      { command: "skills", operation: "tools.skill.precedence" }
+    );
+  });
+  skillsCmd.command("deps <skill-name>").description("Show skill dependency tree").action(async (skillName) => {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "skill.dependencies",
+      { name: skillName },
+      { command: "skills", operation: "tools.skill.dependencies" }
+    );
+  });
+  skillsCmd.command("spawn-providers").description("List providers capable of spawning subagents").option(
+    "--capability <cap>",
+    "Filter by capability: supportsSubagents, supportsProgrammaticSpawn, supportsInterAgentComms, supportsParallelSpawn"
+  ).action(async (opts) => {
+    await dispatchFromCli(
+      "query",
+      "tools",
+      "skill.spawn.providers",
+      { capability: opts["capability"] },
+      { command: "skills", operation: "tools.skill.spawn.providers" }
+    );
+  });
   skillsCmd.action(async () => {
     await dispatchFromCli(
       "query",
@@ -125462,6 +126542,43 @@ function registerStopCommand(program) {
   });
 }
 
+// packages/cleo/src/cli/commands/sync.ts
+init_cli();
+function registerSyncCommand(program) {
+  const sync = program.command("sync").description("External task synchronisation management");
+  const links = sync.command("links").description("List external task links");
+  links.command("list").description("List external task links (filter by provider or task)").option("--provider <providerId>", "Filter links by provider (e.g. linear, jira, github)").option("--task <taskId>", "Filter links by CLEO task ID").action(async (opts) => {
+    await dispatchFromCli(
+      "query",
+      "tasks",
+      "sync.links",
+      {
+        providerId: opts["provider"],
+        taskId: opts["task"]
+      },
+      { command: "sync", operation: "tasks.sync.links" }
+    );
+  });
+  links.command("remove <providerId>").description("Remove all external task links for a provider").action(async (providerId) => {
+    await dispatchFromCli(
+      "mutate",
+      "tasks",
+      "sync.links.remove",
+      { providerId },
+      { command: "sync", operation: "tasks.sync.links.remove" }
+    );
+  });
+  links.action(async () => {
+    await dispatchFromCli(
+      "query",
+      "tasks",
+      "sync.links",
+      {},
+      { command: "sync", operation: "tasks.sync.links" }
+    );
+  });
+}
+
 // packages/cleo/src/cli/commands/testing.ts
 init_cli();
 function registerTestingCommand(program) {
@@ -126165,8 +127282,15 @@ registerArchiveStatsCommand(rootShim);
 registerGenerateChangelogCommand(rootShim);
 registerIssueCommand(rootShim);
 registerSkillsCommand(rootShim);
+registerProviderCommand(rootShim);
+registerAdapterCommand(rootShim);
 registerExistsCommand(rootShim);
 registerBugCommand(rootShim);
+registerCancelCommand(rootShim);
+registerClaimCommand(rootShim);
+registerUnclaimCommand(rootShim);
+registerComplexityCommand(rootShim);
+registerSyncCommand(rootShim);
 registerAnalyzeCommand(rootShim);
 registerMapCommand(rootShim);
 registerBackupCommand(rootShim);