@cleocode/cleo 2026.4.24 → 2026.4.26

package/dist/cli/index.js

@@ -38789,10 +38789,10 @@ async function readProjectMeta(projectPath) {
 }
 async function readProjectId(projectPath) {
   try {
-    const { readFileSync: readFileSync102, existsSync: existsSync131 } = await import("node:fs");
+    const { readFileSync: readFileSync103, existsSync: existsSync131 } = await import("node:fs");
     const infoPath = join64(projectPath, ".cleo", "project-info.json");
     if (!existsSync131(infoPath)) return "";
-    const data = JSON.parse(readFileSync102(infoPath, "utf-8"));
+    const data = JSON.parse(readFileSync103(infoPath, "utf-8"));
     return typeof data.projectId === "string" ? data.projectId : "";
   } catch {
     return "";
@@ -75190,6 +75190,7 @@ var init_cleo = __esm({
 // packages/core/src/index.ts
 var init_src2 = __esm({
   "packages/core/src/index.ts"() {
+    "use strict";
     init_src();
     init_adapters();
     init_admin();
@@ -102133,6 +102134,30 @@ var init_registry5 = __esm({
         sessionRequired: false,
         requiredParams: []
       },
+      {
+        gateway: "query",
+        domain: "admin",
+        operation: "roadmap",
+        description: "admin.roadmap (query) \u2014 project roadmap from task provenance, epics grouped by status with progress",
+        tier: 1,
+        idempotent: true,
+        sessionRequired: false,
+        requiredParams: [],
+        params: [
+          {
+            name: "includeHistory",
+            type: "boolean",
+            required: false,
+            description: "Include release history from CHANGELOG.md"
+          },
+          {
+            name: "upcomingOnly",
+            type: "boolean",
+            required: false,
+            description: "Only show pending/upcoming epics (exclude completed)"
+          }
+        ]
+      },
       {
         gateway: "query",
         domain: "admin",
@@ -106707,6 +106732,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 +106871,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 +107144,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 +107161,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 +107418,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 +107445,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 +107522,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();
@@ -109131,6 +109422,13 @@ var init_admin2 = __esm({
               });
               return wrapResult(result, "query", "admin", operation, startTime);
             }
+            case "roadmap": {
+              const result = await systemRoadmap(projectRoot, {
+                includeHistory: params?.includeHistory,
+                upcomingOnly: params?.upcomingOnly
+              });
+              return wrapResult(result, "query", "admin", operation, startTime);
+            }
             case "smoke": {
               const result = await systemSmoke();
               return wrapResult(result, "query", "admin", operation, startTime);
@@ -109631,6 +109929,7 @@ var init_admin2 = __esm({
             "backup",
             "export",
             "map",
+            "roadmap",
             "smoke",
             "hooks.matrix"
           ],
@@ -111441,7 +111740,7 @@ var init_nexus2 = __esm({
 async function orchestrateClassify(request, context, projectRoot) {
   try {
     const { getCleoCantWorkflowsDir: getCleoCantWorkflowsDir2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
-    const { readFileSync: readFileSync102, readdirSync: readdirSync42, existsSync: existsSync131 } = await import("node:fs");
+    const { readFileSync: readFileSync103, readdirSync: readdirSync42, existsSync: existsSync131 } = await import("node:fs");
     const { join: join131 } = await import("node:path");
     const workflowsDir = getCleoCantWorkflowsDir2();
     const combined = `${request} ${context ?? ""}`.toLowerCase();
@@ -111450,7 +111749,7 @@ async function orchestrateClassify(request, context, projectRoot) {
       const files = readdirSync42(workflowsDir).filter((f2) => f2.endsWith(".cant"));
       for (const file2 of files) {
         try {
-          const src = readFileSync102(join131(workflowsDir, file2), "utf-8");
+          const src = readFileSync103(join131(workflowsDir, file2), "utf-8");
           const teamMatch = /^team\s+(\S+):/m.exec(src);
           if (!teamMatch) continue;
           const teamName = teamMatch[1];
@@ -111470,7 +111769,7 @@ async function orchestrateClassify(request, context, projectRoot) {
       const files = readdirSync42(localCantDir).filter((f2) => f2.endsWith(".cant"));
       for (const file2 of files) {
         try {
-          const src = readFileSync102(join131(localCantDir, file2), "utf-8");
+          const src = readFileSync103(join131(localCantDir, file2), "utf-8");
           const teamMatch = /^team\s+(\S+):/m.exec(src);
           if (!teamMatch) continue;
           const teamName = teamMatch[1];
@@ -116010,7 +116309,7 @@ var init_cli = __esm({
 
 // packages/cleo/src/cli/index.ts
 init_internal();
-import { readFileSync as readFileSync101 } from "node:fs";
+import { readFileSync as readFileSync102 } from "node:fs";
 import { dirname as dirname28, join as join130 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 
@@ -116791,6 +117090,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();
 
@@ -117226,6 +117594,83 @@ 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) => {
+    if (!protocolType || typeof protocolType !== "string" || protocolType.trim() === "") {
+      console.error("Error: missing required argument <protocolType>");
+      console.error(
+        "Usage: cleo admin context-inject <protocolType> [--task <id>] [--variant <variant>]"
+      );
+      process.exit(1);
+    }
+    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
@@ -117468,7 +117913,7 @@ agent ${agentId}:
     try {
       const { AgentRegistryAccessor: AgentRegistryAccessor2, getDb: getDb4 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
       const { createRuntime } = await import("@cleocode/runtime");
-      const { existsSync: existsSync131, readFileSync: readFileSync102 } = await import("node:fs");
+      const { existsSync: existsSync131, readFileSync: readFileSync103 } = await import("node:fs");
       const { join: join131 } = await import("node:path");
       await getDb4();
       const registry2 = new AgentRegistryAccessor2(process.cwd());
@@ -117491,7 +117936,7 @@ agent ${agentId}:
       let cantValidation = null;
       const cantPath = opts["cant"] ?? join131(".cleo", "agents", `${agentId}.cant`);
       if (existsSync131(cantPath)) {
-        profile = readFileSync102(cantPath, "utf-8");
+        profile = readFileSync103(cantPath, "utf-8");
         try {
           const cantModule = await import("@cleocode/cant");
           const validate = "validate" in cantModule ? cantModule.validate : null;
@@ -118531,7 +118976,7 @@ Task ${taskId} reassigned to you by ${active.agentId}. Run: cleo show ${taskId}
   });
   agent.command("install <path>").description("Install an agent from a .cantz archive or agent directory").option("--global", "Install to global tier (~/.local/share/cleo/cant/agents/)").action(async (sourcePath, opts) => {
     try {
-      const { existsSync: existsSync131, mkdirSync: mkdirSync31, cpSync, readFileSync: readFileSync102, rmSync: rmSync3, statSync: statSync22 } = await import("node:fs");
+      const { existsSync: existsSync131, mkdirSync: mkdirSync31, cpSync, readFileSync: readFileSync103, rmSync: rmSync3, statSync: statSync22 } = await import("node:fs");
       const { join: join131, basename: basename19, resolve: resolve16 } = await import("node:path");
       const { homedir: homedir7 } = await import("node:os");
       const { tmpdir: tmpdir3 } = await import("node:os");
@@ -118650,7 +119095,7 @@ Task ${taskId} reassigned to you by ${active.agentId}. Run: cleo show ${taskId}
       }
       let registered = false;
       try {
-        const persona = readFileSync102(join131(targetDir, "persona.cant"), "utf-8");
+        const persona = readFileSync103(join131(targetDir, "persona.cant"), "utf-8");
         const descMatch = persona.match(/description:\s*"([^"]+)"/);
         const displayName = descMatch?.[1] ?? agentName;
         const { AgentRegistryAccessor: AgentRegistryAccessor2, getDb: getDb4 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
@@ -120247,6 +120692,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";
@@ -120418,6 +120880,47 @@ async function loadMigrateEngine() {
   throw new Error("Cannot load CANT migration engine. Ensure @cleocode/cant is installed.");
 }
 
+// packages/cleo/src/cli/commands/chain.ts
+init_cli();
+import { readFileSync as readFileSync98 } from "node:fs";
+function registerChainCommand(program) {
+  const chain = program.command("chain").description("WarpChain pipeline management (tier-2 orchestrator)");
+  chain.command("show <chainId>").description("Show details for a WarpChain definition").action(async (chainId) => {
+    await dispatchFromCli("query", "pipeline", "chain.show", { chainId }, { command: "chain" });
+  });
+  chain.command("list").description("List all WarpChain definitions").action(async () => {
+    await dispatchFromCli("query", "pipeline", "chain.list", {}, { command: "chain" });
+  });
+  chain.command("add <file>").description("Add a new WarpChain definition from a JSON file").action(async (file2) => {
+    const chainJson = JSON.parse(readFileSync98(file2, "utf-8"));
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "chain.add",
+      { chain: chainJson },
+      { command: "chain" }
+    );
+  });
+  chain.command("instantiate <chainId> <epicId>").description("Instantiate a WarpChain for an epic").action(async (chainId, epicId) => {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "chain.instantiate",
+      { chainId, epicId },
+      { command: "chain" }
+    );
+  });
+  chain.command("advance <instanceId> <nextStage>").description("Advance a WarpChain instance to the next stage").action(async (instanceId, nextStage) => {
+    await dispatchFromCli(
+      "mutate",
+      "pipeline",
+      "chain.advance",
+      { instanceId, nextStage },
+      { command: "chain" }
+    );
+  });
+}
+
 // packages/cleo/src/cli/commands/check.ts
 init_cli();
 var SUPPORTED_PROTOCOL_TYPES = [
@@ -120445,6 +120948,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: readFileSync103 } = await import("node:fs");
+    let chain;
+    try {
+      chain = JSON.parse(readFileSync103(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(
@@ -120596,6 +121129,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",
+      {
+        id: 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",
+      { id: taskId },
+      { command: "unclaim", operation: "tasks.unclaim" }
+    );
+  });
+}
+
 // packages/cleo/src/cli/commands/commands.ts
 init_cli();
 function registerCommandsCommand(program) {
@@ -120687,6 +121248,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) {
@@ -120777,6 +121353,34 @@ function registerComplianceCommand(program) {
       { command: "compliance" }
     );
   });
+  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
@@ -121048,7 +121652,7 @@ function registerDepsCommand(program) {
       {
         epicId
       },
-      { command: "deps", operation: "tasks.depends" }
+      { command: "deps", operation: "orchestrate.waves" }
     );
   });
   deps.command("critical-path <taskId>").description("Find longest dependency chain from task").action(async (taskId) => {
@@ -121102,19 +121706,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" }
     );
   });
 }
@@ -121122,7 +121722,7 @@ function registerDetectCommand(program) {
 // packages/cleo/src/cli/commands/detect-drift.ts
 init_src();
 init_renderers();
-import { existsSync as existsSync129, readdirSync as readdirSync41, readFileSync as readFileSync98 } from "node:fs";
+import { existsSync as existsSync129, readdirSync as readdirSync41, readFileSync as readFileSync99 } from "node:fs";
 import { dirname as dirname26, join as join125 } from "node:path";
 function findProjectRoot() {
   let currentDir = process.cwd();
@@ -121142,7 +121742,7 @@ function registerDetectDriftCommand(program) {
     const isCleoRepo = existsSync129(join125(projectRoot, "src", "cli", "commands")) || existsSync129(join125(projectRoot, "packages", "cleo", "src"));
     const safeRead = (filePath) => {
       try {
-        return readFileSync98(filePath, "utf-8");
+        return readFileSync99(filePath, "utf-8");
       } catch {
         return "";
       }
@@ -121877,27 +122477,6 @@ function registerDoctorCommand(program) {
   });
 }
 
-// packages/cleo/src/cli/commands/env.ts
-init_internal();
-init_renderers();
-async function getEnvStatus() {
-  return getRuntimeDiagnostics({ detailed: false });
-}
-async function getEnvInfo() {
-  return getRuntimeDiagnostics({ detailed: true });
-}
-function registerEnvCommand(program) {
-  const env = program.command("env").description("Environment and mode inspection");
-  env.command("status", { isDefault: true }).description("Show current environment mode and runtime info").action(async () => {
-    const result = await getEnvStatus();
-    cliOutput(result, { command: "env" });
-  });
-  env.command("info").description("Show detailed environment info including binary paths and compilation status").action(async () => {
-    const result = await getEnvInfo();
-    cliOutput(result, { command: "env" });
-  });
-}
-
 // packages/cleo/src/cli/commands/exists.ts
 init_src();
 init_internal();
@@ -122122,12 +122701,12 @@ init_src();
 init_src2();
 init_renderers();
 import { execFileSync as execFileSync16 } from "node:child_process";
-import { existsSync as existsSync130, mkdirSync as mkdirSync30, readFileSync as readFileSync99, writeFileSync as writeFileSync24 } from "node:fs";
+import { existsSync as existsSync130, mkdirSync as mkdirSync30, readFileSync as readFileSync100, writeFileSync as writeFileSync24 } from "node:fs";
 import { dirname as dirname27, join as join127 } from "node:path";
 function getChangelogSource(cwd) {
   const configPath = getConfigPath(cwd);
   try {
-    const config2 = JSON.parse(readFileSync99(configPath, "utf-8"));
+    const config2 = JSON.parse(readFileSync100(configPath, "utf-8"));
     return config2?.release?.changelog?.source ?? "CHANGELOG.md";
   } catch {
     return "CHANGELOG.md";
@@ -122136,7 +122715,7 @@ function getChangelogSource(cwd) {
 function getEnabledPlatforms(cwd) {
   const configPath = getConfigPath(cwd);
   try {
-    const config2 = JSON.parse(readFileSync99(configPath, "utf-8"));
+    const config2 = JSON.parse(readFileSync100(configPath, "utf-8"));
     const outputs = config2?.release?.changelog?.outputs ?? [];
     return outputs.filter((o) => o.enabled);
   } catch {
@@ -122265,7 +122844,7 @@ function registerGenerateChangelogCommand(program) {
       if (!existsSync130(sourcePath)) {
         throw new CleoError(4 /* NOT_FOUND */, `Changelog source not found: ${sourcePath}`);
       }
-      const sourceContent = readFileSync99(sourcePath, "utf-8");
+      const sourceContent = readFileSync100(sourcePath, "utf-8");
       const repoSlug = getGitHubRepoSlug();
       const results = [];
       if (targetPlatform) {
@@ -122658,6 +123237,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
@@ -122907,9 +123536,20 @@ function registerMemoryBrainCommand(program) {
     }
     cliOutput(result, { command: "memory", operation: "memory.stats" });
   });
-  memory.command("observe <text>").description("Save an observation to brain.db").option("--title <title>", "Short title for the observation").option(
+  memory.command("observe <text>").description(
+    "Save an observation to brain.db \u2014 captures facts, decisions, and discoveries for cross-session memory"
+  ).option(
+    "--title <title>",
+    "Short title for the observation (defaults to first 120 chars of text)"
+  ).option(
+    "--type <type>",
+    "Category: discovery (found something new), decision (choice made), bugfix (bug found/fixed), refactor (code restructured), feature (feature added), change (general change), pattern (recurring pattern), session_summary (end-of-session recap)"
+  ).option(
     "--agent <name>",
-    "Tag this observation with the producing agent name (Wave 8 mental models)"
+    "Name of the agent producing this observation (enables per-agent memory retrieval)"
+  ).option(
+    "--source-type <sourceType>",
+    "How this observation was captured: manual (typed by human/agent), auto (lifecycle hook), transcript (extracted from session)"
   ).action(async (text3, opts) => {
     await dispatchFromCli(
       "mutate",
@@ -122918,7 +123558,9 @@ function registerMemoryBrainCommand(program) {
       {
         text: text3,
         title: opts["title"],
-        ...opts["agent"] !== void 0 && { agent: opts["agent"] }
+        ...opts["agent"] !== void 0 && { agent: opts["agent"] },
+        ...opts["type"] !== void 0 && { type: opts["type"] },
+        sourceType: opts["sourceType"] ?? "manual"
       },
       { command: "memory", operation: "memory.observe" }
     );
@@ -122946,15 +123588,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 {
@@ -123032,13 +123808,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" }
     );
@@ -123126,28 +123913,116 @@ function registerNexusCommand(program) {
       { command: "nexus" }
     );
   });
-}
-
-// packages/cleo/src/cli/commands/observe.ts
-init_cli();
-function registerObserveCommand(program) {
-  program.command("observe <text>").description("Save an observation to brain.db").option("-t, --title <title>", "Optional title (defaults to first 120 chars of text)").option(
-    "--type <type>",
-    "Observation type (discovery, decision, bugfix, refactor, feature, change, pattern, session_summary)"
-  ).action(async (text3, opts) => {
+  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",
-      "memory",
-      "observe",
+      "nexus",
+      "transfer",
       {
-        text: text3,
-        title: opts.title,
-        ...opts.type !== void 0 && { type: opts.type },
-        sourceType: "manual"
+        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: "observe", operation: "memory.observe" }
+      { 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
+init_cli();
+function registerObserveCommand(program) {
+  program.command("observe <text>").description(
+    "Save an observation to brain.db \u2014 captures facts, decisions, and discoveries for cross-session memory"
+  ).option(
+    "-t, --title <title>",
+    "Short title for the observation (defaults to first 120 chars of text)"
+  ).option(
+    "--type <type>",
+    "Category: discovery (found something new), decision (choice made), bugfix (bug found/fixed), refactor (code restructured), feature (feature added), change (general change), pattern (recurring pattern), session_summary (end-of-session recap)"
+  ).option(
+    "--agent <name>",
+    "Name of the agent producing this observation (enables per-agent memory retrieval)"
+  ).option(
+    "--source-type <sourceType>",
+    "How this observation was captured: manual (typed by human/agent), auto (lifecycle hook), transcript (extracted from session)"
+  ).action(
+    async (text3, opts) => {
+      await dispatchFromCli(
+        "mutate",
+        "memory",
+        "observe",
+        {
+          text: text3,
+          title: opts.title,
+          ...opts.type !== void 0 && { type: opts.type },
+          ...opts.agent !== void 0 && { agent: opts.agent },
+          sourceType: opts.sourceType ?? "manual"
+        },
+        { command: "observe", operation: "memory.observe" }
+      );
+    }
+  );
 }
 
 // packages/cleo/src/cli/commands/ops.ts
@@ -123172,12 +124047,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" }
     );
   });
@@ -123193,12 +124079,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" }
     );
   });
@@ -123224,6 +124119,157 @@ 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" }
+    );
+  });
+  orch.command("bootstrap").description("Load brain state for agent bootstrapping").option("--epic <epicId>", "Epic ID to scope bootstrap context to").action(async (opts) => {
+    await dispatchFromCli(
+      "query",
+      "orchestrate",
+      "bootstrap",
+      { epicId: opts["epic"] },
+      { command: "orchestrate" }
+    );
+  });
+  orch.command("classify <request>").description("Classify a request using CANT prompt-based team routing").action(async (request) => {
+    await dispatchFromCli(
+      "query",
+      "orchestrate",
+      "classify",
+      { request },
+      { command: "orchestrate" }
+    );
+  });
+  orch.command("fanout-status").description("Get fanout status for an epic").option("--epic <epicId>", "Epic ID to scope fanout status to").action(async (opts) => {
+    await dispatchFromCli(
+      "query",
+      "orchestrate",
+      "fanout.status",
+      { epicId: opts["epic"] },
+      { command: "orchestrate" }
+    );
+  });
+  orch.command("handoff <taskId>").description("Perform session handoff and spawn successor for a task").requiredOption("--protocol <type>", "Protocol type for handoff").action(async (taskId, opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "orchestrate",
+      "handoff",
+      { taskId, protocolType: opts["protocol"] },
+      { command: "orchestrate" }
+    );
+  });
+  orch.command("spawn-execute <taskId>").description("Execute spawn for a task via the adapter registry").action(async (taskId) => {
+    await dispatchFromCli(
+      "mutate",
+      "orchestrate",
+      "spawn.execute",
+      { taskId },
+      { command: "orchestrate" }
+    );
+  });
+  orch.command("fanout <epicId>").description("Fan out tasks for an epic using parallel spawn").option("--tasks <ids>", "Comma-separated task IDs to fan out").action(async (epicId, opts) => {
+    const taskIds = typeof opts["tasks"] === "string" ? opts["tasks"].split(",").map((s3) => s3.trim()) : void 0;
+    await dispatchFromCli(
+      "mutate",
+      "orchestrate",
+      "fanout",
+      { epicId, taskIds },
+      { command: "orchestrate" }
+    );
+  });
+  orch.command("conduit-status").description("Get conduit messaging status").action(async () => {
+    await dispatchFromCli(
+      "query",
+      "orchestrate",
+      "conduit.status",
+      {},
+      { command: "orchestrate" }
+    );
+  });
+  orch.command("conduit-peek").description("Peek at queued conduit messages").option("--limit <n>", "Maximum number of messages to return", parseInt).action(async (opts) => {
+    await dispatchFromCli(
+      "query",
+      "orchestrate",
+      "conduit.peek",
+      { limit: opts["limit"] },
+      { command: "orchestrate" }
+    );
+  });
+  orch.command("conduit-start").description("Start the conduit message loop").option("--poll-interval <ms>", "Polling interval in milliseconds", parseInt).action(async (opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "orchestrate",
+      "conduit.start",
+      { pollInterval: opts["pollInterval"] },
+      { command: "orchestrate" }
+    );
+  });
+  orch.command("conduit-stop").description("Stop the conduit message loop").action(async () => {
+    await dispatchFromCli(
+      "mutate",
+      "orchestrate",
+      "conduit.stop",
+      {},
+      { command: "orchestrate" }
+    );
+  });
+  orch.command("conduit-send <content>").description("Send a message via conduit to an agent or conversation").option("--to <agentId>", "Target agent ID").option("--conversation <id>", "Conversation ID to send into").action(async (content, opts) => {
+    await dispatchFromCli(
+      "mutate",
+      "orchestrate",
+      "conduit.send",
+      {
+        content,
+        agentId: opts["to"],
+        conversationId: opts["conversation"]
+      },
+      { command: "orchestrate" }
+    );
+  });
 }
 
 // packages/cleo/src/cli/commands/otel.ts
@@ -123443,6 +124489,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) {
@@ -123619,6 +124744,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
@@ -124367,17 +125513,18 @@ function registerRestoreCommand(program) {
 // packages/cleo/src/cli/commands/roadmap.ts
 init_cli();
 function registerRoadmapCommand(program) {
-  program.command("roadmap").description("Generate roadmap from pending epics and CHANGELOG history").option("--include-history", "Include release history from CHANGELOG").option("--upcoming-only", "Only show upcoming/planned releases").action(async (opts) => {
+  program.command("roadmap").description(
+    "Generate project roadmap from task provenance \u2014 epics grouped by status with progress"
+  ).option("--include-history", "Include release history from CHANGELOG.md").option("--upcoming-only", "Only show pending/upcoming epics (exclude completed)").action(async (opts) => {
     await dispatchFromCli(
       "query",
       "admin",
-      "dash",
+      "roadmap",
       {
-        type: "roadmap",
         includeHistory: opts["includeHistory"],
         upcomingOnly: opts["upcomingOnly"]
       },
-      { command: "roadmap" }
+      { command: "roadmap", operation: "admin.roadmap" }
     );
   });
 }
@@ -124834,7 +125981,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 () => {
@@ -124856,13 +126005,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" });
   });
 }
 
@@ -125003,6 +126149,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",
@@ -125054,7 +126249,7 @@ function registerShowCommand(program) {
 // packages/cleo/src/cli/commands/skills.ts
 init_cli();
 function registerSkillsCommand(program) {
-  const skillsCmd = program.command("skills").description("Skill management: list, discover, validate, info, install");
+  const skillsCmd = program.command("skills").description("Skill management: list, search, validate, info, install");
   skillsCmd.command("list").description("List installed skills").option("--global", "Use global skills directory").action(async (opts) => {
     await dispatchFromCli(
       "query",
@@ -125078,17 +126273,6 @@ function registerSkillsCommand(program) {
       { command: "skills", operation: "tools.skill.find" }
     );
   });
-  skillsCmd.command("discover").description("Scan and discover available skills").action(async () => {
-    await dispatchFromCli(
-      "query",
-      "tools",
-      "skill.list",
-      {
-        scope: "project"
-      },
-      { command: "skills", operation: "tools.skill.list" }
-    );
-  });
   skillsCmd.command("validate <skill-name>").description("Validate skill against protocol").action(async (skillName) => {
     await dispatchFromCli(
       "query",
@@ -125168,6 +126352,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",
@@ -125482,6 +126723,73 @@ 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" }
+    );
+  });
+  sync.command("reconcile <file>").description("Reconcile external tasks from a JSON file against CLEO tasks").requiredOption("--provider <providerId>", "Provider ID (e.g. linear, jira, github)").option(
+    "--conflict-policy <policy>",
+    "How to resolve conflicts: keep-cleo, keep-external, or newest (default: keep-cleo)",
+    "keep-cleo"
+  ).action(async (file2, opts) => {
+    const { readFileSync: readFileSync103 } = await import("node:fs");
+    let externalTasks;
+    try {
+      externalTasks = JSON.parse(readFileSync103(file2, "utf8"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`Failed to read or parse external tasks file: ${message}`);
+      process.exit(2);
+    }
+    if (!Array.isArray(externalTasks)) {
+      console.error("External tasks file must contain a JSON array");
+      process.exit(2);
+    }
+    await dispatchFromCli(
+      "mutate",
+      "tasks",
+      "sync.reconcile",
+      {
+        providerId: opts["provider"],
+        externalTasks,
+        conflictPolicy: opts["conflictPolicy"]
+      },
+      { command: "sync", operation: "tasks.sync.reconcile" }
+    );
+  });
+}
+
 // packages/cleo/src/cli/commands/testing.ts
 init_cli();
 function registerTestingCommand(program) {
@@ -125490,13 +126798,14 @@ function registerTestingCommand(program) {
     await dispatchFromCli(
       "query",
       "check",
-      "manifest",
+      "protocol",
       {
+        protocolType: "testing",
+        mode: "task",
         taskId,
-        strict: !!opts["strict"],
-        type: "testing"
+        strict: !!opts["strict"]
       },
-      { command: "testing", operation: "check.manifest" }
+      { command: "testing", operation: "check.protocol" }
     );
   });
   testingCmd.command("check <manifestFile>").description("Validate testing protocol from a manifest file").option("--strict", "Exit with error code on violations").action(async (manifestFile, opts) => {
@@ -125553,11 +126862,11 @@ function registerTestingCommand(program) {
 init_internal();
 init_cli();
 init_renderers();
-import { readFileSync as readFileSync100 } from "node:fs";
+import { readFileSync as readFileSync101 } from "node:fs";
 function readPayload(opts, textKey, fileKey) {
   const text3 = opts[textKey];
   const file2 = opts[fileKey];
-  if (file2) return readFileSync100(file2, "utf-8");
+  if (file2) return readFileSync101(file2, "utf-8");
   return text3;
 }
 function registerTokenCommand(program) {
@@ -126143,7 +127452,7 @@ var codeCommand = defineCommand({
 // packages/cleo/src/cli/index.ts
 function getPackageVersion() {
   const pkgPath = join130(dirname28(fileURLToPath5(import.meta.url)), "../../package.json");
-  const pkg = JSON.parse(readFileSync101(pkgPath, "utf-8"));
+  const pkg = JSON.parse(readFileSync102(pkgPath, "utf-8"));
   return pkg.version;
 }
 var CLI_VERSION = getPackageVersion();
@@ -126169,9 +127478,9 @@ registerDepsCommand(rootShim);
 registerTreeCommand(rootShim);
 registerResearchCommand(rootShim);
 registerOrchestrateCommand(rootShim);
+registerChainCommand(rootShim);
 registerLifecycleCommand(rootShim);
 registerReleaseCommand(rootShim);
-registerEnvCommand(rootShim);
 registerCheckpointCommand(rootShim);
 registerCommandsCommand(rootShim);
 registerDocsCommand(rootShim);
@@ -126185,8 +127494,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);