@cleocode/cleo 2026.3.45 → 2026.3.47

package/dist/cli/index.js

@@ -34593,7 +34593,7 @@ async function ensureInjection(projectRoot) {
     }
   }
   const agentsMdPath = join36(projectRoot, "AGENTS.md");
-  const agentsMdLines = ["@~/.cleo/templates/CLEO-INJECTION.md"];
+  const agentsMdLines = ["@~/.agents/AGENTS.md"];
   const projectContextPath = join36(projectRoot, ".cleo", "project-context.json");
   if (existsSync33(projectContextPath)) {
     agentsMdLines.push("@.cleo/project-context.json");
@@ -34606,7 +34606,8 @@ async function ensureInjection(projectRoot) {
   if (contributorBlock) {
     agentsMdLines.push(contributorBlock);
   }
-  const agentsAction = await inject2(agentsMdPath, agentsMdLines.join("\n"));
+  const agentsMdContent = agentsMdLines.join("\n");
+  const agentsAction = await inject2(agentsMdPath, agentsMdContent);
   actions.push(`AGENTS.md CLEO content (${agentsAction})`);
   const content = getInjectionTemplateContent();
   if (content) {
@@ -34621,8 +34622,9 @@ async function ensureInjection(projectRoot) {
   try {
     const globalAgentsDir = getAgentsHome();
     const globalAgentsMd = join36(globalAgentsDir, "AGENTS.md");
+    const globalHubContent = "@~/.cleo/templates/CLEO-INJECTION.md";
     await mkdir4(globalAgentsDir, { recursive: true });
-    await inject2(globalAgentsMd, "@~/.cleo/templates/CLEO-INJECTION.md");
+    await inject2(globalAgentsMd, globalHubContent);
   } catch {
   }
   return {
@@ -34802,6 +34804,7 @@ __export(scaffold_exports, {
   CLEO_GITIGNORE_FALLBACK: () => CLEO_GITIGNORE_FALLBACK,
   REQUIRED_CLEO_SUBDIRS: () => REQUIRED_CLEO_SUBDIRS,
   REQUIRED_GLOBAL_SUBDIRS: () => REQUIRED_GLOBAL_SUBDIRS,
+  STALE_GLOBAL_ENTRIES: () => STALE_GLOBAL_ENTRIES,
   checkBrainDb: () => checkBrainDb,
   checkCleoGitRepo: () => checkCleoGitRepo,
   checkCleoStructure: () => checkCleoStructure,
@@ -34838,7 +34841,7 @@ __export(scaffold_exports, {
 import { execFile as execFile3 } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { existsSync as existsSync34, constants as fsConstants3, readFileSync as readFileSync22, statSync as statSync8 } from "node:fs";
-import { access as access3, mkdir as mkdir5, readFile as readFile6, writeFile as writeFile5 } from "node:fs/promises";
+import { access as access3, mkdir as mkdir5, readFile as readFile6, rm as rm2, writeFile as writeFile5 } from "node:fs/promises";
 import { dirname as dirname8, join as join37, resolve as resolve5 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { promisify as promisify3 } from "node:util";
@@ -34853,7 +34856,7 @@ async function fileExists(path2) {
 async function stripCLEOBlocks(filePath) {
   if (!existsSync34(filePath)) return;
   const content = await readFile6(filePath, "utf8");
-  const stripped = content.replace(/\n?<!-- CLEO:START -->[\s\S]*?<!-- CLEO:END -->\n?/g, "");
+  const stripped = content.replace(/\n?<!-- CLEO:START[^>]*-->[\s\S]*?<!-- CLEO:END -->\n?/g, "");
   if (stripped !== content) await writeFile5(filePath, stripped, "utf8");
 }
 async function removeCleoFromRootGitignore(projectRoot) {
@@ -35130,7 +35133,7 @@ async function ensureProjectContext(projectRoot, opts) {
   try {
     const schemaPath = join37(
       dirname8(fileURLToPath4(import.meta.url)),
-      "../../schemas/project-context.schema.json"
+      "../schemas/project-context.schema.json"
     );
     if (existsSync34(schemaPath)) {
       const AjvModule2 = await import("ajv");
@@ -35536,6 +35539,19 @@ async function ensureGlobalHome() {
   for (const subdir of REQUIRED_GLOBAL_SUBDIRS) {
     await mkdir5(join37(cleoHome, subdir), { recursive: true });
   }
+  for (const stale of STALE_GLOBAL_ENTRIES) {
+    const stalePath = join37(cleoHome, stale);
+    if (existsSync34(stalePath)) {
+      try {
+        await rm2(stalePath, { recursive: true, force: true });
+        console.warn(`[CLEO] Removed stale global entry: ${stalePath}`);
+      } catch (err) {
+        console.warn(
+          `[CLEO] Could not remove stale global entry ${stalePath}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
   return {
     action: alreadyExists ? "skipped" : "created",
     path: cleoHome,
@@ -35571,11 +35587,9 @@ async function ensureGlobalTemplates() {
   return { action: "created", path: injectionPath };
 }
 async function ensureGlobalScaffold() {
-  const { ensureGlobalSchemas: ensureGlobalSchemas2 } = await Promise.resolve().then(() => (init_schema_management(), schema_management_exports));
   const home = await ensureGlobalHome();
-  const schemas = ensureGlobalSchemas2();
   const templates2 = await ensureGlobalTemplates();
-  return { home, schemas, templates: templates2 };
+  return { home, templates: templates2 };
 }
 function checkGlobalHome() {
   const cleoHome = getCleoHome();
@@ -35652,7 +35666,7 @@ function checkLogDir(projectRoot) {
     fix: null
   };
 }
-var execFileAsync3, REQUIRED_CLEO_SUBDIRS, CLEO_GITIGNORE_FALLBACK, REQUIRED_GLOBAL_SUBDIRS;
+var execFileAsync3, REQUIRED_CLEO_SUBDIRS, CLEO_GITIGNORE_FALLBACK, REQUIRED_GLOBAL_SUBDIRS, STALE_GLOBAL_ENTRIES;
 var init_scaffold = __esm({
   "packages/core/src/scaffold.ts"() {
     "use strict";
@@ -35709,7 +35723,21 @@ metrics/
 .backups/
 backups/
 `;
-    REQUIRED_GLOBAL_SUBDIRS = ["schemas", "templates"];
+    REQUIRED_GLOBAL_SUBDIRS = ["logs", "templates"];
+    STALE_GLOBAL_ENTRIES = [
+      "adrs",
+      "rcasd",
+      "agent-outputs",
+      "backups",
+      "sandbox",
+      "tasks.db",
+      "tasks.db-shm",
+      "tasks.db-wal",
+      "brain-worker.pid",
+      "VERSION",
+      "schemas",
+      "bin"
+    ];
   }
 });
 
@@ -39445,8 +39473,8 @@ function parseTokenMetrics(inputFile, cwd) {
     const raw = JSON.parse(readFileSync28(file2, "utf-8"));
     if (raw.resourceMetrics) {
       const points = [];
-      for (const rm3 of raw.resourceMetrics ?? []) {
-        for (const sm of rm3.scopeMetrics ?? []) {
+      for (const rm4 of raw.resourceMetrics ?? []) {
+        for (const sm of rm4.scopeMetrics ?? []) {
           for (const metric of sm.metrics ?? []) {
             if (metric.name !== "claude_code.token.usage") continue;
             for (const dp of metric.sum?.dataPoints ?? []) {
@@ -42219,10 +42247,10 @@ async function readProjectMeta(projectPath) {
 }
 async function readProjectId(projectPath) {
   try {
-    const { readFileSync: readFileSync97, existsSync: existsSync122 } = await import("node:fs");
+    const { readFileSync: readFileSync98, existsSync: existsSync122 } = await import("node:fs");
     const infoPath = join57(projectPath, ".cleo", "project-info.json");
     if (!existsSync122(infoPath)) return "";
-    const data = JSON.parse(readFileSync97(infoPath, "utf-8"));
+    const data = JSON.parse(readFileSync98(infoPath, "utf-8"));
     return typeof data.projectId === "string" ? data.projectId : "";
   } catch {
     return "";
@@ -46879,8 +46907,8 @@ var init_release_config = __esm({
 // packages/core/src/release/ci.ts
 import { existsSync as existsSync60, mkdirSync as mkdirSync12, readFileSync as readFileSync42, writeFileSync as writeFileSync6 } from "node:fs";
 import { dirname as dirname13, join as join63 } from "node:path";
-function getPlatformPath(platform3) {
-  return PLATFORM_PATHS[platform3];
+function getPlatformPath(platform5) {
+  return PLATFORM_PATHS[platform5];
 }
 function detectCIPlatform(projectDir) {
   const dir = projectDir ?? process.cwd();
@@ -46974,10 +47002,10 @@ workflows:
               only: /^v.*/
 `;
 }
-function generateCIConfig(platform3, cwd) {
+function generateCIConfig(platform5, cwd) {
   const releaseConfig = loadReleaseConfig(cwd);
   const gates = releaseConfig.gates.map((g) => ({ name: g.name, command: g.command }));
-  switch (platform3) {
+  switch (platform5) {
     case "github-actions":
       return generateGitHubActions({ gates });
     case "gitlab-ci":
@@ -46986,10 +47014,10 @@ function generateCIConfig(platform3, cwd) {
       return generateCircleCI({ gates });
   }
 }
-function writeCIConfig(platform3, options = {}) {
+function writeCIConfig(platform5, options = {}) {
   const projectDir = options.projectDir ?? process.cwd();
-  const outputPath = join63(projectDir, getPlatformPath(platform3));
-  const content = generateCIConfig(platform3, projectDir);
+  const outputPath = join63(projectDir, getPlatformPath(platform5));
+  const content = generateCIConfig(platform5, projectDir);
   if (options.dryRun) {
     return { action: "would_write", path: outputPath, content };
   }
@@ -46997,9 +47025,9 @@ function writeCIConfig(platform3, options = {}) {
   writeFileSync6(outputPath, content, "utf-8");
   return { action: "wrote", path: outputPath, content };
 }
-function validateCIConfig(platform3, projectDir) {
+function validateCIConfig(platform5, projectDir) {
   const dir = projectDir ?? process.cwd();
-  const configPath = join63(dir, getPlatformPath(platform3));
+  const configPath = join63(dir, getPlatformPath(platform5));
   if (!existsSync60(configPath)) {
     return { valid: false, exists: false, errors: ["Config file not found"] };
   }
@@ -48702,239 +48730,1463 @@ var init_capability_matrix = __esm({
     CAPABILITY_MATRIX = [
       // === Tasks Domain ===
       // Query operations
-      { domain: "tasks", operation: "show", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "list", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "find", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "tree", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "blockers", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "depends", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "analyze", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "next", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "plan", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "relates", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "complexity.estimate", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "history", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "current", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "label.list", gateway: "query", mode: "native" },
+      { domain: "tasks", operation: "show", gateway: "query", mode: "native", preferredChannel: "mcp" },
+      { domain: "tasks", operation: "list", gateway: "query", mode: "native", preferredChannel: "mcp" },
+      { domain: "tasks", operation: "find", gateway: "query", mode: "native", preferredChannel: "mcp" },
+      {
+        domain: "tasks",
+        operation: "tree",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "blockers",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "depends",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "analyze",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      { domain: "tasks", operation: "next", gateway: "query", mode: "native", preferredChannel: "mcp" },
+      { domain: "tasks", operation: "plan", gateway: "query", mode: "native", preferredChannel: "mcp" },
+      {
+        domain: "tasks",
+        operation: "relates",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "complexity.estimate",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "history",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "current",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tasks",
+        operation: "label.list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Mutate operations
-      { domain: "tasks", operation: "add", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "update", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "complete", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "cancel", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "delete", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "archive", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "restore", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "reparent", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "reorder", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "relates.add", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "start", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "stop", gateway: "mutate", mode: "native" },
+      { domain: "tasks", operation: "add", gateway: "mutate", mode: "native", preferredChannel: "mcp" },
+      {
+        domain: "tasks",
+        operation: "update",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tasks",
+        operation: "complete",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tasks",
+        operation: "cancel",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "delete",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "archive",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "restore",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "reparent",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "reorder",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "relates.add",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "start",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tasks",
+        operation: "stop",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
       // Sync sub-domain (provider-agnostic task reconciliation)
-      { domain: "tasks", operation: "sync.reconcile", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "sync.links", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "sync.links.remove", gateway: "mutate", mode: "native" },
+      {
+        domain: "tasks",
+        operation: "sync.reconcile",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "sync.links",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "sync.links.remove",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // === Session Domain ===
       // Query operations
-      { domain: "session", operation: "status", gateway: "query", mode: "native" },
-      { domain: "session", operation: "list", gateway: "query", mode: "native" },
-      { domain: "session", operation: "show", gateway: "query", mode: "native" },
-      { domain: "session", operation: "decision.log", gateway: "query", mode: "native" },
-      { domain: "session", operation: "context.drift", gateway: "query", mode: "native" },
-      { domain: "session", operation: "handoff.show", gateway: "query", mode: "native" },
-      { domain: "session", operation: "briefing.show", gateway: "query", mode: "native" },
-      { domain: "session", operation: "find", gateway: "query", mode: "native" },
+      {
+        domain: "session",
+        operation: "status",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "session",
+        operation: "list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "session",
+        operation: "show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "session",
+        operation: "decision.log",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "session",
+        operation: "context.drift",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "session",
+        operation: "handoff.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "session",
+        operation: "briefing.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "session",
+        operation: "find",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Mutate operations
-      { domain: "session", operation: "start", gateway: "mutate", mode: "native" },
-      { domain: "session", operation: "end", gateway: "mutate", mode: "native" },
-      { domain: "session", operation: "resume", gateway: "mutate", mode: "native" },
-      { domain: "session", operation: "suspend", gateway: "mutate", mode: "native" },
-      { domain: "session", operation: "gc", gateway: "mutate", mode: "native" },
-      { domain: "session", operation: "record.decision", gateway: "mutate", mode: "native" },
-      { domain: "session", operation: "record.assumption", gateway: "mutate", mode: "native" },
+      {
+        domain: "session",
+        operation: "start",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "session",
+        operation: "end",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "session",
+        operation: "resume",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "session",
+        operation: "suspend",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "session",
+        operation: "gc",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "session",
+        operation: "record.decision",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "session",
+        operation: "record.assumption",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // === Admin Domain ===
       // Query operations
-      { domain: "admin", operation: "version", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "health", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "config.show", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "stats", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "context", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "runtime", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "job", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "dash", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "log", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "sequence", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "help", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "token", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "export", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "adr.show", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "adr.find", gateway: "query", mode: "native" },
+      {
+        domain: "admin",
+        operation: "version",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "health",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "config.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "stats",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "context",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "runtime",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "job",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      { domain: "admin", operation: "dash", gateway: "query", mode: "native", preferredChannel: "mcp" },
+      {
+        domain: "admin",
+        operation: "log",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "sequence",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      { domain: "admin", operation: "help", gateway: "query", mode: "native", preferredChannel: "mcp" },
+      {
+        domain: "admin",
+        operation: "token",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "export",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "adr.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "adr.find",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      { domain: "admin", operation: "map", gateway: "query", mode: "native", preferredChannel: "mcp" },
       // Mutate operations
-      { domain: "admin", operation: "init", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "config.set", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "backup", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "migrate", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "cleanup", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "safestop", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "inject.generate", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "job.cancel", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "install.global", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "token", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "health", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "detect", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "import", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "context.inject", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "adr.sync", gateway: "mutate", mode: "native" },
+      {
+        domain: "admin",
+        operation: "init",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "config.set",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "backup",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "migrate",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "cleanup",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "safestop",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "inject.generate",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "job.cancel",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "install.global",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "token",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "health",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "detect",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "import",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "context.inject",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "adr.sync",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "map",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // === Check Domain ===
       // Query operations
-      { domain: "check", operation: "schema", gateway: "query", mode: "native" },
-      { domain: "check", operation: "protocol", gateway: "query", mode: "native" },
-      { domain: "check", operation: "task", gateway: "query", mode: "native" },
-      { domain: "check", operation: "manifest", gateway: "query", mode: "native" },
-      { domain: "check", operation: "output", gateway: "query", mode: "native" },
-      { domain: "check", operation: "compliance.summary", gateway: "query", mode: "native" },
-      { domain: "check", operation: "test", gateway: "query", mode: "native" },
-      { domain: "check", operation: "coherence", gateway: "query", mode: "native" },
-      { domain: "check", operation: "gate.status", gateway: "query", mode: "native" },
-      { domain: "check", operation: "archive.stats", gateway: "query", mode: "native" },
-      { domain: "check", operation: "grade", gateway: "query", mode: "native" },
-      { domain: "check", operation: "grade.list", gateway: "query", mode: "native" },
-      { domain: "check", operation: "chain.validate", gateway: "query", mode: "native" },
+      {
+        domain: "check",
+        operation: "schema",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "protocol",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "task",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "manifest",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "output",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "compliance.summary",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "check",
+        operation: "test",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "coherence",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "gate.status",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "archive.stats",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "grade",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "grade.list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "chain.validate",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Mutate operations
-      { domain: "check", operation: "compliance.record", gateway: "mutate", mode: "native" },
-      { domain: "check", operation: "test.run", gateway: "mutate", mode: "native" },
-      { domain: "check", operation: "gate.set", gateway: "mutate", mode: "native" },
+      {
+        domain: "check",
+        operation: "compliance.record",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "check",
+        operation: "test.run",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "gate.set",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "compliance.sync",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // === Orchestrate Domain ===
       // Query operations
-      { domain: "orchestrate", operation: "status", gateway: "query", mode: "native" },
-      { domain: "orchestrate", operation: "next", gateway: "query", mode: "native" },
-      { domain: "orchestrate", operation: "ready", gateway: "query", mode: "native" },
-      { domain: "orchestrate", operation: "analyze", gateway: "query", mode: "native" },
-      { domain: "orchestrate", operation: "context", gateway: "query", mode: "native" },
-      { domain: "orchestrate", operation: "waves", gateway: "query", mode: "native" },
-      { domain: "orchestrate", operation: "bootstrap", gateway: "query", mode: "native" },
-      { domain: "orchestrate", operation: "unblock.opportunities", gateway: "query", mode: "native" },
-      { domain: "orchestrate", operation: "tessera.list", gateway: "query", mode: "native" },
+      {
+        domain: "orchestrate",
+        operation: "status",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "next",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "ready",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "analyze",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "context",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "waves",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "bootstrap",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "unblock.opportunities",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "tessera.list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Mutate operations
-      { domain: "orchestrate", operation: "start", gateway: "mutate", mode: "native" },
-      { domain: "orchestrate", operation: "spawn", gateway: "mutate", mode: "native" },
-      { domain: "orchestrate", operation: "handoff", gateway: "mutate", mode: "native" },
-      { domain: "orchestrate", operation: "spawn.execute", gateway: "mutate", mode: "native" },
-      { domain: "orchestrate", operation: "validate", gateway: "mutate", mode: "native" },
-      { domain: "orchestrate", operation: "parallel", gateway: "mutate", mode: "native" },
-      { domain: "orchestrate", operation: "tessera.instantiate", gateway: "mutate", mode: "native" },
+      {
+        domain: "orchestrate",
+        operation: "start",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "spawn",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "orchestrate",
+        operation: "handoff",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "spawn.execute",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "validate",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "parallel",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "tessera.instantiate",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // === Memory Domain (brain.db cognitive memory -- T5241) ===
       // Query operations
-      { domain: "memory", operation: "find", gateway: "query", mode: "native" },
-      { domain: "memory", operation: "timeline", gateway: "query", mode: "native" },
-      { domain: "memory", operation: "fetch", gateway: "query", mode: "native" },
-      { domain: "memory", operation: "decision.find", gateway: "query", mode: "native" },
-      { domain: "memory", operation: "pattern.find", gateway: "query", mode: "native" },
-      { domain: "memory", operation: "learning.find", gateway: "query", mode: "native" },
-      { domain: "memory", operation: "graph.show", gateway: "query", mode: "native" },
-      { domain: "memory", operation: "graph.neighbors", gateway: "query", mode: "native" },
-      { domain: "memory", operation: "reason.why", gateway: "query", mode: "native" },
-      { domain: "memory", operation: "reason.similar", gateway: "query", mode: "native" },
-      { domain: "memory", operation: "search.hybrid", gateway: "query", mode: "native" },
+      {
+        domain: "memory",
+        operation: "find",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "memory",
+        operation: "timeline",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "memory",
+        operation: "fetch",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "memory",
+        operation: "decision.find",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "memory",
+        operation: "pattern.find",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "memory",
+        operation: "learning.find",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "memory",
+        operation: "graph.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "memory",
+        operation: "graph.neighbors",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "memory",
+        operation: "reason.why",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "memory",
+        operation: "reason.similar",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "memory",
+        operation: "search.hybrid",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Mutate operations
-      { domain: "memory", operation: "observe", gateway: "mutate", mode: "native" },
-      { domain: "memory", operation: "decision.store", gateway: "mutate", mode: "native" },
-      { domain: "memory", operation: "pattern.store", gateway: "mutate", mode: "native" },
-      { domain: "memory", operation: "learning.store", gateway: "mutate", mode: "native" },
-      { domain: "memory", operation: "link", gateway: "mutate", mode: "native" },
-      { domain: "memory", operation: "graph.add", gateway: "mutate", mode: "native" },
-      { domain: "memory", operation: "graph.remove", gateway: "mutate", mode: "native" },
+      {
+        domain: "memory",
+        operation: "observe",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "memory",
+        operation: "decision.store",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "memory",
+        operation: "pattern.store",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "memory",
+        operation: "learning.store",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "memory",
+        operation: "link",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "memory",
+        operation: "graph.add",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "memory",
+        operation: "graph.remove",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // === Pipeline Domain ===
       // Stage sub-domain (RCASD lifecycle)
-      { domain: "pipeline", operation: "stage.validate", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "stage.status", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "stage.history", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "stage.record", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "stage.skip", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "stage.reset", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "stage.gate.pass", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "stage.gate.fail", gateway: "mutate", mode: "native" },
+      {
+        domain: "pipeline",
+        operation: "stage.validate",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "pipeline",
+        operation: "stage.status",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "pipeline",
+        operation: "stage.history",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "stage.record",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "stage.skip",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "stage.reset",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "stage.gate.pass",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "stage.gate.fail",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Manifest sub-domain (T5241)
-      { domain: "pipeline", operation: "manifest.show", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "manifest.list", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "manifest.find", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "manifest.stats", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "manifest.append", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "manifest.archive", gateway: "mutate", mode: "native" },
+      {
+        domain: "pipeline",
+        operation: "manifest.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "manifest.list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "manifest.find",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "manifest.stats",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "manifest.append",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "manifest.archive",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Phase sub-domain (T5326)
-      { domain: "pipeline", operation: "phase.show", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "phase.list", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "phase.set", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "phase.advance", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "phase.rename", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "phase.delete", gateway: "mutate", mode: "native" },
+      {
+        domain: "pipeline",
+        operation: "phase.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "phase.list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "phase.set",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "phase.advance",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "phase.rename",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "phase.delete",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Chain sub-domain (T5405)
-      { domain: "pipeline", operation: "chain.show", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "chain.list", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "chain.add", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "chain.instantiate", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "chain.advance", gateway: "mutate", mode: "native" },
+      {
+        domain: "pipeline",
+        operation: "chain.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "chain.list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "chain.add",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "chain.instantiate",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "chain.advance",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Release sub-domain (T5615 consolidated)
-      { domain: "pipeline", operation: "release.list", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "release.show", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "release.channel.show", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "release.ship", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "release.cancel", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "release.rollback", gateway: "mutate", mode: "native" },
+      {
+        domain: "pipeline",
+        operation: "release.list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "release.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "release.channel.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "release.ship",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "cli"
+      },
+      {
+        domain: "pipeline",
+        operation: "release.cancel",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "release.rollback",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // === Tools Domain ===
       // Issue operations
-      { domain: "tools", operation: "issue.diagnostics", gateway: "query", mode: "native" },
+      {
+        domain: "tools",
+        operation: "issue.diagnostics",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Skill operations
-      { domain: "tools", operation: "skill.list", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "skill.show", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "skill.find", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "skill.dispatch", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "skill.verify", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "skill.dependencies", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "skill.spawn.providers", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "skill.catalog", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "skill.precedence", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "skill.install", gateway: "mutate", mode: "native" },
-      { domain: "tools", operation: "skill.uninstall", gateway: "mutate", mode: "native" },
-      { domain: "tools", operation: "skill.refresh", gateway: "mutate", mode: "native" },
+      {
+        domain: "tools",
+        operation: "skill.list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tools",
+        operation: "skill.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tools",
+        operation: "skill.find",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tools",
+        operation: "skill.dispatch",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "skill.verify",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "skill.dependencies",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "skill.spawn.providers",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "skill.catalog",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "skill.precedence",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "skill.install",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "skill.uninstall",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "skill.refresh",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Provider operations
-      { domain: "tools", operation: "provider.list", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "provider.detect", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "provider.inject.status", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "provider.supports", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "provider.hooks", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "provider.inject", gateway: "mutate", mode: "native" },
+      {
+        domain: "tools",
+        operation: "provider.list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tools",
+        operation: "provider.detect",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tools",
+        operation: "provider.inject.status",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "provider.supports",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "provider.hooks",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "provider.inject",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      // Adapter sub-domain (T5240)
+      {
+        domain: "tools",
+        operation: "adapter.list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tools",
+        operation: "adapter.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tools",
+        operation: "adapter.detect",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "adapter.health",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "adapter.activate",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tools",
+        operation: "adapter.dispose",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // === Nexus Domain ===
       // Query operations
-      { domain: "nexus", operation: "status", gateway: "query", mode: "native" },
-      { domain: "nexus", operation: "list", gateway: "query", mode: "native" },
-      { domain: "nexus", operation: "show", gateway: "query", mode: "native" },
-      { domain: "nexus", operation: "search", gateway: "query", mode: "native" },
-      { domain: "nexus", operation: "graph", gateway: "query", mode: "native" },
-      { domain: "nexus", operation: "deps", gateway: "query", mode: "native" },
-      { domain: "nexus", operation: "resolve", gateway: "query", mode: "native" },
-      { domain: "nexus", operation: "discover", gateway: "query", mode: "native" },
-      { domain: "nexus", operation: "orphans.list", gateway: "query", mode: "native" },
-      { domain: "nexus", operation: "blockers.show", gateway: "query", mode: "native" },
-      { domain: "nexus", operation: "path.show", gateway: "query", mode: "native" },
-      { domain: "nexus", operation: "share.status", gateway: "query", mode: "native" },
+      {
+        domain: "nexus",
+        operation: "status",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "search",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "graph",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "deps",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "resolve",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "discover",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "orphans.list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "blockers.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "path.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "share.status",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "transfer.preview",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Mutate operations
-      { domain: "nexus", operation: "init", gateway: "mutate", mode: "native" },
-      { domain: "nexus", operation: "register", gateway: "mutate", mode: "native" },
-      { domain: "nexus", operation: "unregister", gateway: "mutate", mode: "native" },
-      { domain: "nexus", operation: "sync", gateway: "mutate", mode: "native" },
-      { domain: "nexus", operation: "reconcile", gateway: "mutate", mode: "native" },
-      { domain: "nexus", operation: "permission.set", gateway: "mutate", mode: "native" },
-      { domain: "nexus", operation: "share.snapshot.export", gateway: "mutate", mode: "native" },
-      { domain: "nexus", operation: "share.snapshot.import", gateway: "mutate", mode: "native" },
+      {
+        domain: "nexus",
+        operation: "init",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "register",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "unregister",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "sync",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "reconcile",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "permission.set",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "share.snapshot.export",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "share.snapshot.import",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "transfer",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // === Sticky Domain ===
       // Query operations
-      { domain: "sticky", operation: "list", gateway: "query", mode: "native" },
-      { domain: "sticky", operation: "show", gateway: "query", mode: "native" },
+      {
+        domain: "sticky",
+        operation: "list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "sticky",
+        operation: "show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
       // Mutate operations
-      { domain: "sticky", operation: "add", gateway: "mutate", mode: "native" },
-      { domain: "sticky", operation: "archive", gateway: "mutate", mode: "native" },
-      { domain: "sticky", operation: "convert", gateway: "mutate", mode: "native" },
-      { domain: "sticky", operation: "purge", gateway: "mutate", mode: "native" }
+      {
+        domain: "sticky",
+        operation: "add",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "sticky",
+        operation: "archive",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "sticky",
+        operation: "convert",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "sticky",
+        operation: "purge",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      }
     ];
   }
 });
@@ -51697,6 +52949,7 @@ var init_config2 = __esm({
 
 // packages/core/src/skills/agents/install.ts
 import { existsSync as existsSync67, mkdirSync as mkdirSync14, readdirSync as readdirSync25, readlinkSync, symlinkSync, unlinkSync as unlinkSync4 } from "node:fs";
+import { platform as platform2 } from "node:os";
 import { basename as basename12, join as join70 } from "node:path";
 function getAgentInstallDir() {
   return getClaudeAgentsDir();
@@ -51727,7 +52980,7 @@ function installAgent(agentDir) {
     }
   }
   try {
-    symlinkSync(agentDir, targetPath, "dir");
+    symlinkSync(agentDir, targetPath, DIR_SYMLINK_TYPE);
     return { installed: true, path: targetPath };
   } catch (err) {
     return { installed: false, path: targetPath, error: `Symlink failed: ${err}` };
@@ -51767,11 +53020,13 @@ function uninstallAgent(agentName) {
     return false;
   }
 }
+var DIR_SYMLINK_TYPE;
 var init_install = __esm({
   "packages/core/src/skills/agents/install.ts"() {
     "use strict";
     init_paths();
     init_config2();
+    DIR_SYMLINK_TYPE = platform2() === "win32" ? "junction" : "dir";
   }
 });
 
@@ -53704,8 +54959,9 @@ var init_validator = __esm({
 // packages/core/src/skills/skill-paths.ts
 import { existsSync as existsSync77, lstatSync, readlinkSync as readlinkSync2, realpathSync as realpathSync2 } from "node:fs";
 import { delimiter, join as join79, resolve as resolve9 } from "node:path";
+import { getCanonicalSkillsDir as getCanonicalSkillsDir2 } from "@cleocode/caamp";
 function getCaampCanonical() {
-  return join79(getAgentsHome(), "skills");
+  return getCanonicalSkillsDir2();
 }
 function getProjectEmbedded(projectRoot) {
   const root = projectRoot ?? process.cwd();
@@ -53825,7 +55081,6 @@ function getSkillSourceType(skillDir, projectRoot) {
 var init_skill_paths = __esm({
   "packages/core/src/skills/skill-paths.ts"() {
     "use strict";
-    init_paths();
   }
 });
 
@@ -56206,7 +57461,7 @@ function getNodeVersionInfo() {
   };
 }
 function getNodeUpgradeInstructions() {
-  const platform3 = detectPlatform();
+  const platform5 = detectPlatform();
   const arch2 = process.arch;
   const instructions = [];
   const hasFnm = commandExists2("fnm");
@@ -56221,7 +57476,7 @@ function getNodeUpgradeInstructions() {
   if (hasVolta) {
     instructions.push(`volta install node@${MINIMUM_NODE_MAJOR}`);
   }
-  switch (platform3) {
+  switch (platform5) {
     case "linux":
       if (commandExists2("dnf")) {
         instructions.push(
@@ -56253,7 +57508,7 @@ function getNodeUpgradeInstructions() {
   }
   instructions.push(`https://nodejs.org/en/download/`);
   const recommended = instructions[0] ?? `https://nodejs.org/en/download/`;
-  return { platform: platform3, arch: arch2, instructions, recommended };
+  return { platform: platform5, arch: arch2, instructions, recommended };
 }
 function getSystemInfo2() {
   return {
@@ -57788,12 +59043,22 @@ async function startupHealthCheck(projectRoot) {
         message: scaffoldResult.home.action === "skipped" ? "Global home already current" : `Global home ${scaffoldResult.home.action}: ${scaffoldResult.home.details ?? ""}`,
         repaired: scaffoldResult.home.action !== "skipped"
       });
-      checks.push({
-        check: "global_schemas",
-        status: "pass",
-        message: `Schemas: ${scaffoldResult.schemas.installed} installed, ${scaffoldResult.schemas.updated} updated of ${scaffoldResult.schemas.total}`,
-        repaired: scaffoldResult.schemas.installed > 0 || scaffoldResult.schemas.updated > 0
-      });
+      if (!globalSchemaCheck.ok) {
+        const { ensureGlobalSchemas: ensureGlobalSchemas2 } = await Promise.resolve().then(() => (init_schema_management(), schema_management_exports));
+        const schemaResult = ensureGlobalSchemas2();
+        checks.push({
+          check: "global_schemas",
+          status: "pass",
+          message: `Schemas: ${schemaResult.installed} installed, ${schemaResult.updated} updated of ${schemaResult.total}`,
+          repaired: schemaResult.installed > 0 || schemaResult.updated > 0
+        });
+      } else {
+        checks.push({
+          check: "global_schemas",
+          status: "pass",
+          message: `All ${globalSchemaCheck.installed} schemas current`
+        });
+      }
       checks.push({
         check: "global_templates",
         status: "pass",
@@ -59330,13 +60595,13 @@ var init_templates = __esm({
 
 // packages/core/src/ui/aliases.ts
 import { existsSync as existsSync93, readFileSync as readFileSync67, writeFileSync as writeFileSync15 } from "node:fs";
-import { homedir as homedir5, platform as platform2 } from "node:os";
+import { homedir as homedir5, platform as platform3 } from "node:os";
 import { join as join96 } from "node:path";
 function getCurrentShell() {
   const shell = process.env.SHELL ?? "";
   if (shell.includes("zsh")) return "zsh";
   if (shell.includes("bash")) return "bash";
-  if (platform2() === "win32") return "powershell";
+  if (platform3() === "win32") return "powershell";
   return "bash";
 }
 function getRcFilePath(shell) {
@@ -59360,7 +60625,7 @@ function detectAvailableShells() {
   const shells = [];
   if (existsSync93(getRcFilePath("bash")) || existsSync93("/bin/bash")) shells.push("bash");
   if (existsSync93(getRcFilePath("zsh")) || existsSync93("/bin/zsh")) shells.push("zsh");
-  if (platform2() === "win32") shells.push("powershell");
+  if (platform3() === "win32") shells.push("powershell");
   return shells;
 }
 function generateBashAliases(cleoPath) {
@@ -59824,27 +61089,10 @@ var init_flags = __esm({
   }
 });
 
-// packages/core/src/ui/injection-legacy.ts
-function getValidationKey(target) {
-  return INJECTION_VALIDATION_KEYS[target] ?? target.toLowerCase().replace(/[^a-z0-9]/g, "_");
-}
-var INJECTION_VALIDATION_KEYS;
-var init_injection_legacy = __esm({
-  "packages/core/src/ui/injection-legacy.ts"() {
-    "use strict";
-    INJECTION_VALIDATION_KEYS = {
-      "CLAUDE.md": "claude_md",
-      "AGENTS.md": "agents_md",
-      "GEMINI.md": "gemini_md"
-    };
-  }
-});
-
 // packages/core/src/ui/index.ts
 var ui_exports = {};
 __export(ui_exports, {
   ALIASES_VERSION: () => ALIASES_VERSION,
-  INJECTION_VALIDATION_KEYS: () => INJECTION_VALIDATION_KEYS,
   appendToChangelog: () => appendToChangelog,
   checkAliasesStatus: () => checkAliasesStatus,
   defaultFlags: () => defaultFlags,
@@ -59861,7 +61109,6 @@ __export(ui_exports, {
   getCurrentShell: () => getCurrentShell,
   getInstalledVersion: () => getInstalledVersion,
   getRcFilePath: () => getRcFilePath,
-  getValidationKey: () => getValidationKey,
   groupTasksIntoSections: () => groupTasksIntoSections,
   hasAliasBlock: () => hasAliasBlock,
   injectAliases: () => injectAliases,
@@ -59881,7 +61128,6 @@ var init_ui = __esm({
     init_changelog();
     init_command_registry();
     init_flags();
-    init_injection_legacy();
   }
 });
 
@@ -63056,11 +64302,29 @@ __export(init_exports, {
 });
 import { existsSync as existsSync100, readdirSync as readdirSync33, readFileSync as readFileSync73 } from "node:fs";
 import { copyFile as copyFile3, lstat, mkdir as mkdir16, readFile as readFile17, symlink, unlink as unlink4, writeFile as writeFile11 } from "node:fs/promises";
+import { platform as platform4 } from "node:os";
 import { basename as basename17, dirname as dirname19, join as join100 } from "node:path";
 async function initAgentDefinition(created, warnings) {
-  const packageRoot = getPackageRoot();
-  const agentSourceDir = join100(packageRoot, "agents", "cleo-subagent");
-  if (!existsSync100(agentSourceDir)) {
+  let agentSourceDir = null;
+  try {
+    const { createRequire: createRequire6 } = await import("node:module");
+    const req = createRequire6(import.meta.url);
+    const agentsPkgMain = req.resolve("@cleocode/agents/package.json");
+    const agentsPkgRoot = dirname19(agentsPkgMain);
+    const candidate = join100(agentsPkgRoot, "cleo-subagent");
+    if (existsSync100(candidate)) {
+      agentSourceDir = candidate;
+    }
+  } catch {
+  }
+  if (!agentSourceDir) {
+    const packageRoot = getPackageRoot();
+    const bundled = join100(packageRoot, "agents", "cleo-subagent");
+    if (existsSync100(bundled)) {
+      agentSourceDir = bundled;
+    }
+  }
+  if (!agentSourceDir) {
     warnings.push("agents/cleo-subagent/ not found in package, skipping agent definition install");
     return;
   }
@@ -63074,7 +64338,7 @@ async function initAgentDefinition(created, warnings) {
       }
     } catch {
     }
-    await symlink(agentSourceDir, globalAgentsDir, "dir");
+    await symlink(agentSourceDir, globalAgentsDir, DIR_SYMLINK_TYPE2);
     created.push("agent: cleo-subagent (symlinked)");
   } catch (_err) {
     try {
@@ -63133,17 +64397,29 @@ async function initCoreSkills(created, warnings) {
     const packageRoot = getPackageRoot();
     let ctSkillsRoot = null;
     try {
-      const bundledPath = join100(packageRoot, "packages", "skills");
-      if (existsSync100(join100(bundledPath, "skills.json"))) {
-        ctSkillsRoot = bundledPath;
-      } else {
-        const ctSkillsPath = join100(packageRoot, "node_modules", "@cleocode", "skills");
-        if (existsSync100(join100(ctSkillsPath, "skills.json"))) {
-          ctSkillsRoot = ctSkillsPath;
-        }
+      const { createRequire: createRequire6 } = await import("node:module");
+      const req = createRequire6(import.meta.url);
+      const skillsPkgMain = req.resolve("@cleocode/skills/package.json");
+      const skillsPkgRoot = dirname19(skillsPkgMain);
+      if (existsSync100(join100(skillsPkgRoot, "skills.json"))) {
+        ctSkillsRoot = skillsPkgRoot;
       }
     } catch {
     }
+    if (!ctSkillsRoot) {
+      try {
+        const bundledPath = join100(packageRoot, "packages", "skills");
+        if (existsSync100(join100(bundledPath, "skills.json"))) {
+          ctSkillsRoot = bundledPath;
+        } else {
+          const ctSkillsPath = join100(packageRoot, "node_modules", "@cleocode", "skills");
+          if (existsSync100(join100(ctSkillsPath, "skills.json"))) {
+            ctSkillsRoot = ctSkillsPath;
+          }
+        }
+      } catch {
+      }
+    }
     if (!ctSkillsRoot) {
       warnings.push("skills package not found, skipping core skill installation");
       return;
@@ -63435,7 +64711,6 @@ async function initProject(opts = {}) {
     warnings.push(`Contributor MCP setup: ${err instanceof Error ? err.message : String(err)}`);
   }
   await initAgentDefinition(created, warnings);
-  await initCoreSkills(created, warnings);
   await initNexusRegistration(projRoot, created, warnings);
   try {
     const { AdapterManager: AdapterManager2 } = await Promise.resolve().then(() => (init_adapters(), adapters_exports));
@@ -63522,6 +64797,7 @@ async function getVersion2(projectRoot) {
   }
   return { version: "0.0.0" };
 }
+var DIR_SYMLINK_TYPE2;
 var init_init = __esm({
   "packages/core/src/init.ts"() {
     "use strict";
@@ -63535,6 +64811,7 @@ var init_init = __esm({
     init_scaffold();
     init_schema_management();
     init_json2();
+    DIR_SYMLINK_TYPE2 = platform4() === "win32" ? "junction" : "dir";
   }
 });
 
@@ -64274,6 +65551,7 @@ async function bootstrapGlobalCleo(options) {
   await injectAgentsHub(ctx);
   await installMcpToProviders(ctx);
   await installSkillsGlobally(ctx);
+  await installAgentDefinitionGlobally(ctx);
   await installProviderAdapters(ctx, options?.packageRoot);
   return ctx;
 }
@@ -64324,12 +65602,16 @@ async function injectAgentsHub(ctx) {
       await mkdir17(globalAgentsDir, { recursive: true });
       if (existsSync103(globalAgentsMd)) {
         const content = await readFile19(globalAgentsMd, "utf8");
-        const stripped = content.replace(/\n?<!-- CLEO:START -->[\s\S]*?<!-- CLEO:END -->\n?/g, "");
+        const stripped = content.replace(
+          /\n?<!-- CLEO:START[^>]*-->[\s\S]*?<!-- CLEO:END -->\n?/g,
+          ""
+        );
         if (stripped !== content) {
           await writeFile12(globalAgentsMd, stripped, "utf8");
         }
       }
-      const action = await inject2(globalAgentsMd, "@~/.cleo/templates/CLEO-INJECTION.md");
+      const expectedContent = "@~/.cleo/templates/CLEO-INJECTION.md";
+      const action = await inject2(globalAgentsMd, expectedContent);
       ctx.created.push(`~/.agents/AGENTS.md (${action})`);
     } else {
       ctx.created.push("~/.agents/AGENTS.md (would create/update CAAMP block)");
@@ -64347,7 +65629,7 @@ async function injectAgentsHub(ctx) {
           if (existsSync103(instructFilePath)) {
             const fileContent = await readFile19(instructFilePath, "utf8");
             const stripped = fileContent.replace(
-              /\n?<!-- CLEO:START -->[\s\S]*?<!-- CLEO:END -->\n?/g,
+              /\n?<!-- CLEO:START[^>]*-->[\s\S]*?<!-- CLEO:END -->\n?/g,
               ""
             );
             if (stripped !== fileContent) {
@@ -64416,6 +65698,20 @@ async function installSkillsGlobally(ctx) {
     );
   }
 }
+async function installAgentDefinitionGlobally(ctx) {
+  try {
+    if (!ctx.isDryRun) {
+      const { initAgentDefinition: initAgentDefinition2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+      await initAgentDefinition2(ctx.created, ctx.warnings);
+    } else {
+      ctx.created.push("agent: cleo-subagent (would symlink)");
+    }
+  } catch (err) {
+    ctx.warnings.push(
+      `Agent definition install: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
 async function installProviderAdapters(ctx, packageRootOverride) {
   try {
     const { AdapterManager: AdapterManager2 } = await Promise.resolve().then(() => (init_adapters(), adapters_exports));
@@ -68415,13 +69711,13 @@ var init_parallel = __esm({
 // packages/core/src/orchestration/skill-ops.ts
 import { existsSync as existsSync107, readdirSync as readdirSync35, readFileSync as readFileSync79 } from "node:fs";
 import { join as join106 } from "node:path";
-import { getCanonicalSkillsDir as getCanonicalSkillsDir2 } from "@cleocode/caamp";
+import { getCanonicalSkillsDir as getCanonicalSkillsDir3 } from "@cleocode/caamp";
 function getSkillContent(skillName, projectRoot) {
   if (!skillName) {
     throw new CleoError(2 /* INVALID_INPUT */, "skill name is required");
   }
   const projectSkillDir = join106(projectRoot, ".cleo", "skills", skillName);
-  const canonicalSkillDir = join106(getCanonicalSkillsDir2(), skillName);
+  const canonicalSkillDir = join106(getCanonicalSkillsDir3(), skillName);
   const skillDir = existsSync107(projectSkillDir) ? projectSkillDir : canonicalSkillDir;
   if (!existsSync107(skillDir)) {
     throw new CleoError(
@@ -72492,7 +73788,7 @@ async function validateLayer2Semantic(context) {
   }
   if (context.domain === "session" && context.operation === "start") {
     const scope = context.params?.scope;
-    if (scope && !scope.match(/^(epic|task|global):/)) {
+    if (scope && scope !== "global" && !scope.match(/^(epic|task):/)) {
       violations.push({
         layer: 2 /* SEMANTIC */,
         severity: "error" /* ERROR */,
@@ -72500,7 +73796,7 @@ async function validateLayer2Semantic(context) {
         message: `Invalid session scope format: ${scope}`,
         field: "scope",
         constraint: "Must be epic:<id>, task:<id>, or global",
-        fix: "Use format: epic:T1234, task:T5678, or global"
+        fix: 'Provide scope as "global" or "epic:TXXX"'
       });
     }
   }
@@ -76604,7 +77900,9 @@ var init_hooks_engine = __esm({
 });
 
 // packages/cleo/src/cli/index.ts
-import { join as join118 } from "node:path";
+import { readFileSync as readFileSync97 } from "node:fs";
+import { dirname as dirname25, join as join118 } from "node:path";
+import { fileURLToPath as fileURLToPath7 } from "node:url";
 
 // node_modules/.pnpm/citty@0.2.1/node_modules/citty/dist/_chunks/libs/scule.mjs
 var NUMBER_CHAR_RE = /\d/;
@@ -82509,8 +83807,15 @@ async function taskList(projectRoot, params) {
       data: { tasks: tasks2, total: result.total, filtered: result.filtered },
       page: result.page
     };
-  } catch {
-    return engineError("E_NOT_INITIALIZED", "Task database not initialized");
+  } catch (err) {
+    const code = err?.code;
+    if (code === 4) return engineError("E_NOT_FOUND", err.message || "Task not found");
+    if (code === 2)
+      return engineError("E_INVALID_INPUT", err.message || "Invalid input");
+    return engineError(
+      "E_NOT_INITIALIZED",
+      err.message || "Task database not initialized"
+    );
   }
 }
 async function taskFind(projectRoot, query, limit, options) {
@@ -82537,8 +83842,15 @@ async function taskFind(projectRoot, query, limit, options) {
       parentId: r.parentId
     }));
     return { success: true, data: { results, total: results.length } };
-  } catch {
-    return engineError("E_NOT_INITIALIZED", "Task database not initialized");
+  } catch (err) {
+    const code = err?.code;
+    if (code === 4) return engineError("E_NOT_FOUND", err.message || "Task not found");
+    if (code === 2)
+      return engineError("E_INVALID_INPUT", err.message || "Invalid input");
+    return engineError(
+      "E_NOT_INITIALIZED",
+      err.message || "Task database not initialized"
+    );
   }
 }
 async function taskCreate(projectRoot, params) {
@@ -83469,54 +84781,42 @@ function routeByParam(params, paramName, routes, defaultRoute) {
 
 // packages/cleo/src/dispatch/domains/admin.ts
 var AdminHandler = class {
-  projectRoot;
-  constructor() {
-    this.projectRoot = getProjectRoot();
-  }
   // -----------------------------------------------------------------------
   // Query
   // -----------------------------------------------------------------------
   async query(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
         case "version": {
-          const result = await getVersion3(this.projectRoot);
+          const result = await getVersion3(projectRoot);
           return wrapResult(result, "query", "admin", operation, startTime);
         }
         case "health": {
           const mode = params?.mode;
           if (mode === "diagnose") {
-            const result2 = await systemDoctor(this.projectRoot);
+            const result2 = await systemDoctor(projectRoot);
             return wrapResult(result2, "query", "admin", operation, startTime);
           }
-          const result = systemHealth(
-            this.projectRoot,
-            params
-          );
+          const result = systemHealth(projectRoot, params);
           return wrapResult(result, "query", "admin", operation, startTime);
         }
         case "config.show": {
-          const result = await configGet(this.projectRoot, params?.key);
+          const result = await configGet(projectRoot, params?.key);
           return wrapResult(result, "query", "admin", operation, startTime);
         }
         case "stats": {
-          const result = await systemStats(
-            this.projectRoot,
-            params
-          );
+          const result = await systemStats(projectRoot, params);
           return wrapResult(result, "query", "admin", operation, startTime);
         }
         case "context": {
-          const result = systemContext(
-            this.projectRoot,
-            params
-          );
+          const result = systemContext(projectRoot, params);
           return wrapResult(result, "query", "admin", operation, startTime);
         }
         case "runtime": {
           const result = await systemRuntime(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "query", "admin", operation, startTime);
@@ -83611,12 +84911,12 @@ var AdminHandler = class {
         }
         case "dash": {
           const blockedTasksLimit = typeof params?.blockedTasksLimit === "number" ? params.blockedTasksLimit : void 0;
-          const result = await systemDash(this.projectRoot, { blockedTasksLimit });
+          const result = await systemDash(projectRoot, { blockedTasksLimit });
           return wrapResult(result, "query", "admin", operation, startTime);
         }
         case "log": {
           const result = await systemLog(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "query", "admin", operation, startTime);
@@ -83633,7 +84933,7 @@ var AdminHandler = class {
               startTime
             );
           }
-          const result = await systemSequence(this.projectRoot, {
+          const result = await systemSequence(projectRoot, {
             action
           });
           return wrapResult(result, "query", "admin", operation, startTime);
@@ -83651,7 +84951,7 @@ var AdminHandler = class {
         case "adr.find": {
           const query = params?.query;
           if (query) {
-            const result2 = await findAdrs(this.projectRoot, query, {
+            const result2 = await findAdrs(projectRoot, query, {
               topics: params?.topics,
               keywords: params?.keywords,
               status: params?.status
@@ -83663,7 +84963,7 @@ var AdminHandler = class {
             };
           }
           const { limit, offset } = getListParams(params);
-          const result = await listAdrs(this.projectRoot, {
+          const result = await listAdrs(projectRoot, {
             status: params?.status,
             since: params?.since,
             limit,
@@ -83688,7 +84988,7 @@ var AdminHandler = class {
               startTime
             );
           }
-          const adr = await showAdr(this.projectRoot, adrId);
+          const adr = await showAdr(projectRoot, adrId);
           if (!adr) {
             return errorResult(
               "query",
@@ -83727,7 +85027,7 @@ var AdminHandler = class {
                     since: params?.since,
                     until: params?.until
                   },
-                  this.projectRoot
+                  projectRoot
                 );
                 return {
                   _meta: dispatchMeta("query", "admin", operation, startTime),
@@ -83754,7 +85054,7 @@ var AdminHandler = class {
                     limit,
                     offset
                   },
-                  this.projectRoot
+                  projectRoot
                 );
                 return {
                   _meta: dispatchMeta("query", "admin", operation, startTime),
@@ -83779,7 +85079,7 @@ var AdminHandler = class {
                     startTime
                   );
                 }
-                const result = await showTokenUsage(tokenId, this.projectRoot);
+                const result = await showTokenUsage(tokenId, projectRoot);
                 if (!result) {
                   return errorResult(
                     "query",
@@ -83804,8 +85104,8 @@ var AdminHandler = class {
         case "export": {
           const scope = params?.scope;
           if (scope === "snapshot") {
-            const snapshot = await exportSnapshot(this.projectRoot);
-            const outputPath = params?.output ?? getDefaultSnapshotPath(this.projectRoot);
+            const snapshot = await exportSnapshot(projectRoot);
+            const outputPath = params?.output ?? getDefaultSnapshotPath(projectRoot);
             await writeSnapshot(snapshot, outputPath);
             return {
               _meta: dispatchMeta("query", "admin", operation, startTime),
@@ -83826,7 +85126,7 @@ var AdminHandler = class {
               filter: params?.filter,
               includeDeps: params?.includeDeps,
               dryRun: params?.dryRun,
-              cwd: this.projectRoot
+              cwd: projectRoot
             });
             return {
               _meta: dispatchMeta("query", "admin", operation, startTime),
@@ -83840,7 +85140,7 @@ var AdminHandler = class {
             status: params?.status,
             parent: params?.parent,
             phase: params?.phase,
-            cwd: this.projectRoot
+            cwd: projectRoot
           });
           return {
             _meta: dispatchMeta("query", "admin", operation, startTime),
@@ -83850,7 +85150,7 @@ var AdminHandler = class {
         }
         case "map": {
           const { mapCodebase: mapCodebase3 } = await Promise.resolve().then(() => (init_codebase_map_engine(), codebase_map_engine_exports));
-          const result = await mapCodebase3(this.projectRoot, {
+          const result = await mapCodebase3(projectRoot, {
             focus: params?.focus,
             storeToBrain: false
           });
@@ -83871,12 +85171,13 @@ var AdminHandler = class {
   // Mutate
   // -----------------------------------------------------------------------
   async mutate(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
         case "init": {
           const result = await initProject2(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "mutate", "admin", operation, startTime);
@@ -83885,10 +85186,10 @@ var AdminHandler = class {
         case "health": {
           const mode = params?.mode;
           if (mode === "diagnose") {
-            const result2 = await systemDoctor(this.projectRoot);
+            const result2 = await systemDoctor(projectRoot);
             return wrapResult(result2, "mutate", "admin", operation, startTime);
           }
-          const result = await systemFix(this.projectRoot);
+          const result = await systemFix(projectRoot);
           return wrapResult(result, "mutate", "admin", operation, startTime);
         }
         case "config.set": {
@@ -83903,7 +85204,7 @@ var AdminHandler = class {
               startTime
             );
           }
-          const result = await configSet(this.projectRoot, key, params?.value);
+          const result = await configSet(projectRoot, key, params?.value);
           return wrapResult(result, "mutate", "admin", operation, startTime);
         }
         // Merged: backup absorbs restore and backup.restore via action param (T5615)
@@ -83921,7 +85222,7 @@ var AdminHandler = class {
                 startTime
               );
             }
-            const result2 = systemRestore(this.projectRoot, {
+            const result2 = systemRestore(projectRoot, {
               backupId,
               force: params?.force
             });
@@ -83939,20 +85240,20 @@ var AdminHandler = class {
                 startTime
               );
             }
-            const result2 = await backupRestore(this.projectRoot, file2, {
+            const result2 = await backupRestore(projectRoot, file2, {
               dryRun: params?.dryRun
             });
             return wrapResult(result2, "mutate", "admin", operation, startTime);
           }
           const result = systemBackup(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "mutate", "admin", operation, startTime);
         }
         case "migrate": {
           const result = await systemMigrate(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "mutate", "admin", operation, startTime);
@@ -83969,7 +85270,7 @@ var AdminHandler = class {
               startTime
             );
           }
-          const result = await systemCleanup(this.projectRoot, {
+          const result = await systemCleanup(projectRoot, {
             target,
             olderThan: params?.olderThan,
             dryRun: params?.dryRun
@@ -84021,20 +85322,20 @@ var AdminHandler = class {
         }
         case "safestop": {
           const result = systemSafestop(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "mutate", "admin", operation, startTime);
         }
         case "inject.generate": {
-          const result = await systemInjectGenerate(this.projectRoot);
+          const result = await systemInjectGenerate(projectRoot);
           return wrapResult(result, "mutate", "admin", operation, startTime);
         }
         // adr.sync absorbs adr.validate via validate flag (T5615)
         case "adr.sync": {
           const validate = params?.validate;
           if (validate) {
-            const result2 = await validateAllAdrs(this.projectRoot);
+            const result2 = await validateAllAdrs(projectRoot);
             return {
               _meta: dispatchMeta("mutate", "admin", operation, startTime),
               success: result2.valid,
@@ -84047,7 +85348,7 @@ var AdminHandler = class {
               }
             };
           }
-          const result = await syncAdrsToDb(this.projectRoot);
+          const result = await syncAdrsToDb(projectRoot);
           return {
             _meta: dispatchMeta("mutate", "admin", operation, startTime),
             success: true,
@@ -84082,7 +85383,7 @@ var AdminHandler = class {
                 }
               };
             }
-            const result2 = await importSnapshot(snapshot, this.projectRoot);
+            const result2 = await importSnapshot(snapshot, projectRoot);
             return {
               _meta: dispatchMeta("mutate", "admin", operation, startTime),
               success: true,
@@ -84118,7 +85419,7 @@ var AdminHandler = class {
               onConflict: params?.onConflict,
               onMissingDep: params?.onMissingDep,
               force: params?.force,
-              cwd: this.projectRoot
+              cwd: projectRoot
             });
             return {
               _meta: dispatchMeta("mutate", "admin", operation, startTime),
@@ -84144,7 +85445,7 @@ var AdminHandler = class {
             onDuplicate: params?.onDuplicate,
             addLabel: params?.addLabel,
             dryRun: params?.dryRun,
-            cwd: this.projectRoot
+            cwd: projectRoot
           });
           return {
             _meta: dispatchMeta("mutate", "admin", operation, startTime),
@@ -84154,8 +85455,8 @@ var AdminHandler = class {
         }
         case "detect": {
           const { ensureProjectContext: ensureProjectContext2, ensureContributorMcp: ensureContributorMcp2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
-          const contextResult = await ensureProjectContext2(this.projectRoot, { force: true });
-          const mcpResult = await ensureContributorMcp2(this.projectRoot);
+          const contextResult = await ensureProjectContext2(projectRoot, { force: true });
+          const mcpResult = await ensureContributorMcp2(projectRoot);
           return wrapResult(
             {
               success: true,
@@ -84187,7 +85488,7 @@ var AdminHandler = class {
                   requestPayload: params?.requestPayload,
                   responsePayload: params?.responsePayload,
                   metadata: params?.metadata,
-                  cwd: this.projectRoot
+                  cwd: projectRoot
                 });
                 return {
                   _meta: dispatchMeta("mutate", "admin", operation, startTime),
@@ -84207,7 +85508,7 @@ var AdminHandler = class {
                     startTime
                   );
                 }
-                const result = await deleteTokenUsage(tokenId, this.projectRoot);
+                const result = await deleteTokenUsage(tokenId, projectRoot);
                 return {
                   _meta: dispatchMeta("mutate", "admin", operation, startTime),
                   success: true,
@@ -84230,7 +85531,7 @@ var AdminHandler = class {
                     since: params?.since,
                     until: params?.until
                   },
-                  this.projectRoot
+                  projectRoot
                 );
                 return {
                   _meta: dispatchMeta("mutate", "admin", operation, startTime),
@@ -84261,13 +85562,13 @@ var AdminHandler = class {
               taskId: params?.taskId,
               variant: params?.variant
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "mutate", "admin", operation, startTime);
         }
         case "map": {
           const { mapCodebase: mapCodebase3 } = await Promise.resolve().then(() => (init_codebase_map_engine(), codebase_map_engine_exports));
-          const result = await mapCodebase3(this.projectRoot, {
+          const result = await mapCodebase3(projectRoot, {
             focus: params?.focus,
             storeToBrain: true
           });
@@ -84348,14 +85649,11 @@ var AdminHandler = class {
 // packages/cleo/src/dispatch/domains/check.ts
 init_internal();
 var CheckHandler = class {
-  projectRoot;
-  constructor() {
-    this.projectRoot = getProjectRoot();
-  }
   // -----------------------------------------------------------------------
   // Query
   // -----------------------------------------------------------------------
   async query(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
@@ -84371,7 +85669,7 @@ var CheckHandler = class {
               startTime
             );
           }
-          const result = validateSchemaOp(type, params?.data, this.projectRoot);
+          const result = validateSchemaOp(type, params?.data, projectRoot);
           return wrapResult(result, "query", "check", operation, startTime);
         }
         case "task": {
@@ -84386,11 +85684,11 @@ var CheckHandler = class {
               startTime
             );
           }
-          const result = await validateTask2(taskId, this.projectRoot);
+          const result = await validateTask2(taskId, projectRoot);
           return wrapResult(result, "query", "check", operation, startTime);
         }
         case "manifest": {
-          const result = validateManifest(this.projectRoot);
+          const result = validateManifest(projectRoot);
           return wrapResult(result, "query", "check", operation, startTime);
         }
         case "output": {
@@ -84408,7 +85706,7 @@ var CheckHandler = class {
           const result = validateOutput(
             filePath,
             params?.taskId,
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "query", "check", operation, startTime);
         }
@@ -84416,23 +85714,23 @@ var CheckHandler = class {
           const detail = params?.detail;
           const limit = params?.limit;
           if (detail) {
-            const result2 = validateComplianceViolations(limit, this.projectRoot);
+            const result2 = validateComplianceViolations(limit, projectRoot);
             return wrapResult(result2, "query", "check", operation, startTime);
           }
-          const result = validateComplianceSummary(this.projectRoot);
+          const result = validateComplianceSummary(projectRoot);
           return wrapResult(result, "query", "check", operation, startTime);
         }
         case "test": {
           const format = params?.format;
           if (format === "coverage") {
-            const result2 = validateTestCoverage(this.projectRoot);
+            const result2 = validateTestCoverage(projectRoot);
             return wrapResult(result2, "query", "check", operation, startTime);
           }
-          const result = validateTestStatus(this.projectRoot);
+          const result = validateTestStatus(projectRoot);
           return wrapResult(result, "query", "check", operation, startTime);
         }
         case "coherence": {
-          const result = await validateCoherenceCheck(this.projectRoot);
+          const result = await validateCoherenceCheck(projectRoot);
           return wrapResult(result, "query", "check", operation, startTime);
         }
         case "protocol": {
@@ -84451,12 +85749,12 @@ var CheckHandler = class {
                   ...protocolParams,
                   votingMatrixFile: params?.votingMatrixFile
                 },
-                this.projectRoot
+                projectRoot
               );
               return wrapResult(result, "query", "check", operation, startTime);
             }
             case "contribution": {
-              const result = await validateProtocolContribution(protocolParams, this.projectRoot);
+              const result = await validateProtocolContribution(protocolParams, projectRoot);
               return wrapResult(result, "query", "check", operation, startTime);
             }
             case "decomposition": {
@@ -84465,12 +85763,12 @@ var CheckHandler = class {
                   ...protocolParams,
                   epicId: params?.epicId
                 },
-                this.projectRoot
+                projectRoot
               );
               return wrapResult(result, "query", "check", operation, startTime);
             }
             case "implementation": {
-              const result = await validateProtocolImplementation(protocolParams, this.projectRoot);
+              const result = await validateProtocolImplementation(protocolParams, projectRoot);
               return wrapResult(result, "query", "check", operation, startTime);
             }
             case "specification": {
@@ -84479,7 +85777,7 @@ var CheckHandler = class {
                   ...protocolParams,
                   specFile: params?.specFile
                 },
-                this.projectRoot
+                projectRoot
               );
               return wrapResult(result, "query", "check", operation, startTime);
             }
@@ -84495,7 +85793,7 @@ var CheckHandler = class {
                   startTime
                 );
               }
-              const result = await validateProtocol(taskId, protocolType, this.projectRoot);
+              const result = await validateProtocol(taskId, protocolType, projectRoot);
               return wrapResult(result, "query", "check", operation, startTime);
             }
           }
@@ -84512,11 +85810,11 @@ var CheckHandler = class {
               startTime
             );
           }
-          const result = await validateGateVerify({ taskId }, this.projectRoot);
+          const result = await validateGateVerify({ taskId }, projectRoot);
           return wrapResult(result, "query", "check", operation, startTime);
         }
         case "archive.stats": {
-          const result = await systemArchiveStats(this.projectRoot);
+          const result = await systemArchiveStats(projectRoot);
           return wrapResult(result, "query", "check", operation, startTime);
         }
         // T5405: WarpChain validation
@@ -84555,7 +85853,7 @@ var CheckHandler = class {
               startTime
             );
           }
-          const gradeResult = await gradeSession2(sessionId, this.projectRoot);
+          const gradeResult = await gradeSession2(sessionId, projectRoot);
           return wrapResult(
             { success: true, data: gradeResult },
             "query",
@@ -84568,7 +85866,7 @@ var CheckHandler = class {
           const { readGrades: readGrades2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
           const limit = typeof params?.limit === "number" ? params.limit : void 0;
           const offset = typeof params?.offset === "number" ? params.offset : void 0;
-          const allGrades = await readGrades2(void 0, this.projectRoot);
+          const allGrades = await readGrades2(void 0, projectRoot);
           const sessionId = params?.sessionId;
           const filteredGrades = sessionId ? allGrades.filter((g) => g.sessionId === sessionId) : allGrades;
           const page = paginate(filteredGrades, limit, offset);
@@ -84599,6 +85897,7 @@ var CheckHandler = class {
   // Mutate
   // -----------------------------------------------------------------------
   async mutate(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
@@ -84620,14 +85919,14 @@ var CheckHandler = class {
             result,
             params?.protocol,
             params?.violations,
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(engineResult, "mutate", "check", operation, startTime);
         }
         case "test.run": {
           const result = validateTestRun(
             params,
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "mutate", "check", operation, startTime);
         }
@@ -84635,7 +85934,7 @@ var CheckHandler = class {
           const { syncComplianceMetrics: syncComplianceMetrics2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
           const result = await syncComplianceMetrics2({
             force: params?.force,
-            cwd: this.projectRoot
+            cwd: projectRoot
           });
           return {
             _meta: dispatchMeta("mutate", "check", operation, startTime),
@@ -84663,7 +85962,7 @@ var CheckHandler = class {
             all: params?.all,
             reset: params?.reset
           };
-          const result = await validateGateVerify(gateParams, this.projectRoot);
+          const result = await validateGateVerify(gateParams, projectRoot);
           return wrapResult(result, "mutate", "check", operation, startTime);
         }
         default:
@@ -84706,14 +86005,11 @@ var CheckHandler = class {
 // packages/cleo/src/dispatch/domains/memory.ts
 init_src2();
 var MemoryHandler = class {
-  projectRoot;
-  constructor() {
-    this.projectRoot = getProjectRoot();
-  }
   // -----------------------------------------------------------------------
   // Query
   // -----------------------------------------------------------------------
   async query(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
@@ -84737,7 +86033,7 @@ var MemoryHandler = class {
               dateStart: params?.dateStart,
               dateEnd: params?.dateEnd
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "query", "memory", operation, startTime);
         }
@@ -84759,7 +86055,7 @@ var MemoryHandler = class {
               depthBefore: params?.depthBefore,
               depthAfter: params?.depthAfter
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "query", "memory", operation, startTime);
         }
@@ -84775,7 +86071,7 @@ var MemoryHandler = class {
               startTime
             );
           }
-          const result = await memoryFetch({ ids }, this.projectRoot);
+          const result = await memoryFetch({ ids }, projectRoot);
           return wrapResult(result, "query", "memory", operation, startTime);
         }
         case "decision.find": {
@@ -84785,7 +86081,7 @@ var MemoryHandler = class {
               taskId: params?.taskId,
               limit: params?.limit
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "query", "memory", operation, startTime);
         }
@@ -84798,7 +86094,7 @@ var MemoryHandler = class {
               minFrequency: params?.minFrequency,
               limit: params?.limit
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "query", "memory", operation, startTime);
         }
@@ -84811,7 +86107,7 @@ var MemoryHandler = class {
               applicableType: params?.applicableType,
               limit: params?.limit
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "query", "memory", operation, startTime);
         }
@@ -84827,7 +86123,7 @@ var MemoryHandler = class {
               startTime
             );
           }
-          const result = await memoryGraphShow({ nodeId }, this.projectRoot);
+          const result = await memoryGraphShow({ nodeId }, projectRoot);
           return wrapResult(result, "query", "memory", operation, startTime);
         }
         case "graph.neighbors": {
@@ -84844,7 +86140,7 @@ var MemoryHandler = class {
           }
           const result = await memoryGraphNeighbors(
             { nodeId, edgeType: params?.edgeType },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "query", "memory", operation, startTime);
         }
@@ -84860,7 +86156,7 @@ var MemoryHandler = class {
               startTime
             );
           }
-          const result = await memoryReasonWhy({ taskId }, this.projectRoot);
+          const result = await memoryReasonWhy({ taskId }, projectRoot);
           return wrapResult(result, "query", "memory", operation, startTime);
         }
         case "reason.similar": {
@@ -84877,7 +86173,7 @@ var MemoryHandler = class {
           }
           const result = await memoryReasonSimilar(
             { entryId, limit: params?.limit },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "query", "memory", operation, startTime);
         }
@@ -84901,7 +86197,7 @@ var MemoryHandler = class {
               graphWeight: params?.graphWeight,
               limit: params?.limit
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "query", "memory", operation, startTime);
         }
@@ -84921,6 +86217,7 @@ var MemoryHandler = class {
   // Mutate
   // -----------------------------------------------------------------------
   async mutate(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
@@ -84945,7 +86242,7 @@ var MemoryHandler = class {
               sourceSessionId: params?.sourceSessionId,
               sourceType: params?.sourceType
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "mutate", "memory", operation, startTime);
         }
@@ -84970,7 +86267,7 @@ var MemoryHandler = class {
               taskId: params?.taskId,
               sessionId: params?.sessionId
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "mutate", "memory", operation, startTime);
         }
@@ -84998,7 +86295,7 @@ var MemoryHandler = class {
               examples: params?.examples,
               successRate: params?.successRate
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "mutate", "memory", operation, startTime);
         }
@@ -85024,7 +86321,7 @@ var MemoryHandler = class {
               application: params?.application,
               applicableTypes: params?.applicableTypes
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "mutate", "memory", operation, startTime);
         }
@@ -85041,7 +86338,7 @@ var MemoryHandler = class {
               startTime
             );
           }
-          const result = await memoryLink({ taskId, entryId }, this.projectRoot);
+          const result = await memoryLink({ taskId, entryId }, projectRoot);
           return wrapResult(result, "mutate", "memory", operation, startTime);
         }
         case "graph.add": {
@@ -85056,7 +86353,7 @@ var MemoryHandler = class {
               edgeType: params?.edgeType,
               weight: params?.weight
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "mutate", "memory", operation, startTime);
         }
@@ -85068,7 +86365,7 @@ var MemoryHandler = class {
               toId: params?.toId,
               edgeType: params?.edgeType
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "mutate", "memory", operation, startTime);
         }
@@ -85357,14 +86654,11 @@ async function nexusTransferExecute(params) {
 
 // packages/cleo/src/dispatch/domains/nexus.ts
 var NexusHandler = class {
-  projectRoot;
-  constructor() {
-    this.projectRoot = getProjectRoot();
-  }
   // -----------------------------------------------------------------------
   // Query
   // -----------------------------------------------------------------------
   async query(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
@@ -85512,7 +86806,7 @@ var NexusHandler = class {
           return wrapResult(result, "query", "nexus", operation, startTime);
         }
         case "share.status": {
-          const result = await nexusShareStatus(this.projectRoot);
+          const result = await nexusShareStatus(projectRoot);
           return wrapResult(result, "query", "nexus", "share.status", startTime);
         }
         case "transfer.preview": {
@@ -85553,6 +86847,7 @@ var NexusHandler = class {
   // Mutate
   // -----------------------------------------------------------------------
   async mutate(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
@@ -85636,13 +86931,13 @@ var NexusHandler = class {
           return wrapResult(result, "mutate", "nexus", operation, startTime);
         }
         case "reconcile": {
-          const projectRoot = params?.projectRoot || process.cwd();
-          const result = await nexusReconcileProject(projectRoot);
+          const projectRoot2 = params?.projectRoot || process.cwd();
+          const result = await nexusReconcileProject(projectRoot2);
           return wrapResult(result, "mutate", "nexus", operation, startTime);
         }
         case "share.snapshot.export": {
           const outputPath = params?.outputPath;
-          const result = await nexusShareSnapshotExport(this.projectRoot, outputPath);
+          const result = await nexusShareSnapshotExport(projectRoot, outputPath);
           return wrapResult(result, "mutate", "nexus", "share.snapshot.export", startTime);
         }
         case "share.snapshot.import": {
@@ -85657,7 +86952,7 @@ var NexusHandler = class {
               startTime
             );
           }
-          const result = await nexusShareSnapshotImport(this.projectRoot, inputPath);
+          const result = await nexusShareSnapshotImport(projectRoot, inputPath);
           return wrapResult(result, "mutate", "nexus", "share.snapshot.import", startTime);
         }
         case "transfer": {
@@ -85734,20 +87029,17 @@ var NexusHandler = class {
 // packages/cleo/src/dispatch/domains/orchestrate.ts
 init_internal();
 var OrchestrateHandler = class {
-  projectRoot;
-  constructor() {
-    this.projectRoot = getProjectRoot();
-  }
   // -----------------------------------------------------------------------
   // DomainHandler interface
   // -----------------------------------------------------------------------
   async query(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
         case "status": {
           const epicId = params?.epicId;
-          const result = await orchestrateStatus(epicId, this.projectRoot);
+          const result = await orchestrateStatus(epicId, projectRoot);
           return wrapResult(result, "query", "orchestrate", operation, startTime);
         }
         case "next": {
@@ -85762,7 +87054,7 @@ var OrchestrateHandler = class {
               startTime
             );
           }
-          const result = await orchestrateNext(epicId, this.projectRoot);
+          const result = await orchestrateNext(epicId, projectRoot);
           return wrapResult(result, "query", "orchestrate", operation, startTime);
         }
         case "ready": {
@@ -85777,18 +87069,18 @@ var OrchestrateHandler = class {
               startTime
             );
           }
-          const result = await orchestrateReady(epicId, this.projectRoot);
+          const result = await orchestrateReady(epicId, projectRoot);
           return wrapResult(result, "query", "orchestrate", operation, startTime);
         }
         case "analyze": {
           const epicId = params?.epicId;
           const mode = params?.mode;
-          const result = await orchestrateAnalyze(epicId, this.projectRoot, mode);
+          const result = await orchestrateAnalyze(epicId, projectRoot, mode);
           return wrapResult(result, "query", "orchestrate", "analyze", startTime);
         }
         case "context": {
           const epicId = params?.epicId;
-          const result = await orchestrateContext(epicId, this.projectRoot);
+          const result = await orchestrateContext(epicId, projectRoot);
           return wrapResult(result, "query", "orchestrate", operation, startTime);
         }
         case "waves": {
@@ -85803,16 +87095,16 @@ var OrchestrateHandler = class {
               startTime
             );
           }
-          const result = await orchestrateWaves(epicId, this.projectRoot);
+          const result = await orchestrateWaves(epicId, projectRoot);
           return wrapResult(result, "query", "orchestrate", operation, startTime);
         }
         case "bootstrap": {
           const speed = params?.speed;
-          const result = await orchestrateBootstrap(this.projectRoot, { speed });
+          const result = await orchestrateBootstrap(projectRoot, { speed });
           return wrapResult(result, "query", "orchestrate", operation, startTime);
         }
         case "unblock.opportunities": {
-          const result = await orchestrateUnblockOpportunities(this.projectRoot);
+          const result = await orchestrateUnblockOpportunities(projectRoot);
           return wrapResult(result, "query", "orchestrate", operation, startTime);
         }
         case "tessera.list": {
@@ -85869,6 +87161,7 @@ var OrchestrateHandler = class {
     }
   }
   async mutate(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
@@ -85884,7 +87177,7 @@ var OrchestrateHandler = class {
               startTime
             );
           }
-          const result = await orchestrateStartup(epicId, this.projectRoot);
+          const result = await orchestrateStartup(epicId, projectRoot);
           return wrapResult(result, "mutate", "orchestrate", operation, startTime);
         }
         case "spawn": {
@@ -85901,7 +87194,7 @@ var OrchestrateHandler = class {
           }
           const protocolType = params?.protocolType;
           const tier = params?.tier;
-          const result = await orchestrateSpawn(taskId, protocolType, this.projectRoot, tier);
+          const result = await orchestrateSpawn(taskId, protocolType, projectRoot, tier);
           return wrapResult(result, "mutate", "orchestrate", operation, startTime);
         }
         case "handoff": {
@@ -85938,7 +87231,7 @@ var OrchestrateHandler = class {
               tier,
               idempotencyKey: params?.idempotencyKey
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "mutate", "orchestrate", operation, startTime);
         }
@@ -85961,7 +87254,7 @@ var OrchestrateHandler = class {
             taskId,
             adapterId,
             protocolType,
-            this.projectRoot,
+            projectRoot,
             tier
           );
           return wrapResult(result, "mutate", "orchestrate", operation, startTime);
@@ -85978,7 +87271,7 @@ var OrchestrateHandler = class {
               startTime
             );
           }
-          const result = await orchestrateValidate(taskId, this.projectRoot);
+          const result = await orchestrateValidate(taskId, projectRoot);
           return wrapResult(result, "mutate", "orchestrate", operation, startTime);
         }
         case "parallel": {
@@ -86006,7 +87299,7 @@ var OrchestrateHandler = class {
                   startTime
                 );
               }
-              const result = await orchestrateParallelStart(epicId, wave, this.projectRoot);
+              const result = await orchestrateParallelStart(epicId, wave, projectRoot);
               return wrapResult(result, "mutate", "orchestrate", "parallel", startTime);
             },
             end: async () => {
@@ -86032,7 +87325,7 @@ var OrchestrateHandler = class {
                   startTime
                 );
               }
-              const result = await orchestrateParallelEnd(epicId, wave, this.projectRoot);
+              const result = await orchestrateParallelEnd(epicId, wave, projectRoot);
               return wrapResult(result, "mutate", "orchestrate", "parallel", startTime);
             }
           });
@@ -86075,7 +87368,7 @@ var OrchestrateHandler = class {
           const instance = await instantiateTessera(
             template,
             { templateId, epicId, variables: { epicId, ...variables } },
-            this.projectRoot
+            projectRoot
           );
           return {
             _meta: dispatchMeta("mutate", "orchestrate", operation, startTime),
@@ -86131,9 +87424,8 @@ var OrchestrateHandler = class {
 init_internal();
 import { execFileSync as execFileSync13 } from "node:child_process";
 var PipelineHandler = class {
-  projectRoot;
-  constructor() {
-    this.projectRoot = getProjectRoot();
+  get projectRoot() {
+    return getProjectRoot();
   }
   // -----------------------------------------------------------------------
   // DomainHandler interface
@@ -87006,24 +88298,21 @@ function unbindSession() {
 
 // packages/cleo/src/dispatch/domains/session.ts
 var SessionHandler = class {
-  projectRoot;
-  constructor() {
-    this.projectRoot = getProjectRoot();
-  }
   // -----------------------------------------------------------------------
   // Query
   // -----------------------------------------------------------------------
   async query(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
         case "status": {
-          const result = await sessionStatus2(this.projectRoot);
+          const result = await sessionStatus2(projectRoot);
           return wrapResult(result, "query", "session", operation, startTime);
         }
         case "list": {
           const result = await sessionList(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "query", "session", operation, startTime);
@@ -87043,24 +88332,21 @@ var SessionHandler = class {
           }
           const include = params?.include;
           if (include === "debrief") {
-            const result2 = await sessionDebriefShow(this.projectRoot, sessionId);
+            const result2 = await sessionDebriefShow(projectRoot, sessionId);
             return wrapResult(result2, "query", "session", operation, startTime);
           }
-          const result = await sessionShow(this.projectRoot, sessionId);
+          const result = await sessionShow(projectRoot, sessionId);
           return wrapResult(result, "query", "session", operation, startTime);
         }
         case "decision.log": {
           const result = await sessionDecisionLog(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "query", "session", operation, startTime);
         }
         case "context.drift": {
-          const result = await sessionContextDrift(
-            this.projectRoot,
-            params
-          );
+          const result = await sessionContextDrift(projectRoot, params);
           return wrapResult(result, "query", "session", operation, startTime);
         }
         case "handoff.show": {
@@ -87073,11 +88359,11 @@ var SessionHandler = class {
               scopeFilter = { type: "epic", epicId: scope.replace("epic:", "") };
             }
           }
-          const result = await sessionHandoff(this.projectRoot, scopeFilter);
+          const result = await sessionHandoff(projectRoot, scopeFilter);
           return wrapResult(result, "query", "session", operation, startTime);
         }
         case "briefing.show": {
-          const result = await sessionBriefing(this.projectRoot, {
+          const result = await sessionBriefing(projectRoot, {
             maxNextTasks: params?.maxNextTasks,
             maxBugs: params?.maxBugs,
             maxBlocked: params?.maxBlocked,
@@ -87088,7 +88374,7 @@ var SessionHandler = class {
         }
         case "find": {
           const result = await sessionFind(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "query", "session", operation, startTime);
@@ -87108,6 +88394,7 @@ var SessionHandler = class {
   // Mutate
   // -----------------------------------------------------------------------
   async mutate(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
@@ -87123,7 +88410,7 @@ var SessionHandler = class {
               startTime
             );
           }
-          const result = await sessionStart(this.projectRoot, {
+          const result = await sessionStart(projectRoot, {
             scope,
             name: params?.name,
             autoStart: params?.autoStart,
@@ -87154,19 +88441,19 @@ var SessionHandler = class {
           return wrapResult(result, "mutate", "session", operation, startTime);
         }
         case "end": {
-          const endResult = await sessionEnd(this.projectRoot, params?.note);
+          const endResult = await sessionEnd(projectRoot, params?.note);
           if (endResult.success && endResult.data) {
             const sessionId = endResult.data.sessionId;
             if (sessionId) {
               let debriefResult = null;
               try {
-                debriefResult = await sessionComputeDebrief(this.projectRoot, sessionId, {
+                debriefResult = await sessionComputeDebrief(projectRoot, sessionId, {
                   note: params?.note,
                   nextAction: params?.nextAction
                 });
               } catch {
                 try {
-                  await sessionComputeHandoff(this.projectRoot, sessionId, {
+                  await sessionComputeHandoff(projectRoot, sessionId, {
                     note: params?.note,
                     nextAction: params?.nextAction
                   });
@@ -87176,7 +88463,7 @@ var SessionHandler = class {
               if (debriefResult?.success && debriefResult.data) {
                 try {
                   const { persistSessionMemory: persistSessionMemory2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
-                  await persistSessionMemory2(this.projectRoot, sessionId, debriefResult.data);
+                  await persistSessionMemory2(projectRoot, sessionId, debriefResult.data);
                 } catch {
                 }
               }
@@ -87197,7 +88484,7 @@ var SessionHandler = class {
               startTime
             );
           }
-          const result = await sessionResume(this.projectRoot, sessionId);
+          const result = await sessionResume(projectRoot, sessionId);
           return wrapResult(result, "mutate", "session", operation, startTime);
         }
         case "suspend": {
@@ -87213,21 +88500,18 @@ var SessionHandler = class {
             );
           }
           const result = await sessionSuspend(
-            this.projectRoot,
+            projectRoot,
             sessionId,
             params?.reason
           );
           return wrapResult(result, "mutate", "session", operation, startTime);
         }
         case "gc": {
-          const result = await sessionGc(
-            this.projectRoot,
-            params?.maxAgeDays
-          );
+          const result = await sessionGc(projectRoot, params?.maxAgeDays);
           return wrapResult(result, "mutate", "session", operation, startTime);
         }
         case "record.decision": {
-          const result = await sessionRecordDecision(this.projectRoot, {
+          const result = await sessionRecordDecision(projectRoot, {
             sessionId: params?.sessionId,
             taskId: params?.taskId,
             decision: params?.decision,
@@ -87237,7 +88521,7 @@ var SessionHandler = class {
           return wrapResult(result, "mutate", "session", operation, startTime);
         }
         case "record.assumption": {
-          const result = await sessionRecordAssumption(this.projectRoot, {
+          const result = await sessionRecordAssumption(projectRoot, {
             sessionId: params?.sessionId,
             taskId: params?.taskId,
             assumption: params?.assumption,
@@ -87378,14 +88662,11 @@ async function stickyPurge(projectRoot, id) {
 
 // packages/cleo/src/dispatch/domains/sticky.ts
 var StickyHandler = class {
-  projectRoot;
-  constructor() {
-    this.projectRoot = getProjectRoot();
-  }
   // -----------------------------------------------------------------------
   // Query
   // -----------------------------------------------------------------------
   async query(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
@@ -87395,13 +88676,13 @@ var StickyHandler = class {
             color: params?.color,
             priority: params?.priority
           };
-          const result = await stickyList(this.projectRoot, filters);
+          const result = await stickyList(projectRoot, filters);
           if (!result.success) {
             return wrapResult(result, "query", "sticky", operation, startTime);
           }
           const filteredStickies = result.data?.stickies ?? [];
           const hasFilter = filters.status !== void 0 || filters.color !== void 0 || filters.priority !== void 0;
-          const totalResult = hasFilter ? await stickyList(this.projectRoot, {}) : result;
+          const totalResult = hasFilter ? await stickyList(projectRoot, {}) : result;
           if (!totalResult.success) {
             return wrapResult(totalResult, "query", "sticky", operation, startTime);
           }
@@ -87431,7 +88712,7 @@ var StickyHandler = class {
               startTime
             );
           }
-          const result = await stickyShow(this.projectRoot, stickyId);
+          const result = await stickyShow(projectRoot, stickyId);
           return wrapResult(result, "query", "sticky", operation, startTime);
         }
         default:
@@ -87450,6 +88731,7 @@ var StickyHandler = class {
   // Mutate
   // -----------------------------------------------------------------------
   async mutate(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
@@ -87465,7 +88747,7 @@ var StickyHandler = class {
               startTime
             );
           }
-          const result = await stickyAdd(this.projectRoot, {
+          const result = await stickyAdd(projectRoot, {
             content,
             tags: params?.tags,
             color: params?.color,
@@ -87498,7 +88780,7 @@ var StickyHandler = class {
           }
           if (targetType === "task") {
             const result = await stickyConvertToTask(
-              this.projectRoot,
+              projectRoot,
               stickyId,
               params?.title
             );
@@ -87515,18 +88797,18 @@ var StickyHandler = class {
                 startTime
               );
             }
-            const result = await stickyConvertToTaskNote(this.projectRoot, stickyId, taskId);
+            const result = await stickyConvertToTaskNote(projectRoot, stickyId, taskId);
             return wrapResult(result, "mutate", "sticky", operation, startTime);
           } else if (targetType === "session_note") {
             const result = await stickyConvertToSessionNote(
-              this.projectRoot,
+              projectRoot,
               stickyId,
               params?.sessionId
             );
             return wrapResult(result, "mutate", "sticky", operation, startTime);
           } else {
             const result = await stickyConvertToMemory(
-              this.projectRoot,
+              projectRoot,
               stickyId,
               params?.memoryType
             );
@@ -87545,7 +88827,7 @@ var StickyHandler = class {
               startTime
             );
           }
-          const result = await stickyArchive(this.projectRoot, stickyId);
+          const result = await stickyArchive(projectRoot, stickyId);
           return wrapResult(result, "mutate", "sticky", operation, startTime);
         }
         case "purge": {
@@ -87560,7 +88842,7 @@ var StickyHandler = class {
               startTime
             );
           }
-          const result = await stickyPurge(this.projectRoot, stickyId);
+          const result = await stickyPurge(projectRoot, stickyId);
           return wrapResult(result, "mutate", "sticky", operation, startTime);
         }
         default:
@@ -87589,23 +88871,20 @@ var StickyHandler = class {
 // packages/cleo/src/dispatch/domains/tasks.ts
 init_src2();
 var TasksHandler = class {
-  projectRoot;
-  constructor() {
-    this.projectRoot = getProjectRoot();
-  }
   // -----------------------------------------------------------------------
   // Query
   // -----------------------------------------------------------------------
   async query(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
         case "show": {
-          const result = await taskShow(this.projectRoot, params.taskId);
+          const result = await taskShow(projectRoot, params.taskId);
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
         case "list": {
-          const result = await taskList(this.projectRoot, {
+          const result = await taskList(projectRoot, {
             parent: params?.parent,
             status: params?.status,
             priority: params?.priority,
@@ -87621,7 +88900,7 @@ var TasksHandler = class {
         }
         case "find": {
           const result = await taskFind(
-            this.projectRoot,
+            projectRoot,
             params?.query,
             params?.limit,
             {
@@ -87636,12 +88915,12 @@ var TasksHandler = class {
         }
         case "tree": {
           const taskId = params?.taskId;
-          const result = await taskTree(this.projectRoot, taskId);
+          const result = await taskTree(projectRoot, taskId);
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
         case "blockers": {
           const result = await taskBlockers(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "query", "tasks", operation, startTime);
@@ -87649,11 +88928,11 @@ var TasksHandler = class {
         case "depends": {
           const action = params?.action;
           if (action === "overview") {
-            const result2 = await taskDepsOverview(this.projectRoot);
+            const result2 = await taskDepsOverview(projectRoot);
             return wrapResult(result2, "query", "tasks", operation, startTime);
           }
           if (action === "cycles") {
-            const result2 = await taskDepsCycles(this.projectRoot);
+            const result2 = await taskDepsCycles(projectRoot);
             return wrapResult(result2, "query", "tasks", operation, startTime);
           }
           const taskId = params?.taskId;
@@ -87669,64 +88948,64 @@ var TasksHandler = class {
           }
           const direction = params?.direction;
           const tree = params?.tree;
-          const result = await taskDepends(this.projectRoot, taskId, direction, tree);
+          const result = await taskDepends(projectRoot, taskId, direction, tree);
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
         case "analyze": {
           const taskId = params?.taskId;
           const tierLimit = params?.tierLimit;
-          const result = await taskAnalyze(this.projectRoot, taskId, { tierLimit });
+          const result = await taskAnalyze(projectRoot, taskId, { tierLimit });
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
         case "next": {
           const result = await taskNext(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
         case "plan": {
-          const result = await taskPlan(this.projectRoot);
+          const result = await taskPlan(projectRoot);
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
         case "relates": {
           const taskId = params.taskId;
           if (params?.mode) {
-            const result2 = await taskRelatesFind(this.projectRoot, taskId, {
+            const result2 = await taskRelatesFind(projectRoot, taskId, {
               mode: params.mode,
               threshold: params?.threshold ? Number(params.threshold) : void 0
             });
             return wrapResult(result2, "query", "tasks", operation, startTime);
           }
-          const result = await taskRelates(this.projectRoot, taskId);
+          const result = await taskRelates(projectRoot, taskId);
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
         case "complexity.estimate": {
-          const result = await taskComplexityEstimate(this.projectRoot, {
+          const result = await taskComplexityEstimate(projectRoot, {
             taskId: params.taskId
           });
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
         case "current": {
-          const result = await taskCurrentGet(this.projectRoot);
+          const result = await taskCurrentGet(projectRoot);
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
         case "history": {
           const taskId = params?.taskId;
           if (taskId) {
-            const result2 = await taskHistory(this.projectRoot, taskId, params?.limit);
+            const result2 = await taskHistory(projectRoot, taskId, params?.limit);
             return wrapResult(result2, "query", "tasks", operation, startTime);
           }
-          const result = await taskWorkHistory2(this.projectRoot);
+          const result = await taskWorkHistory2(projectRoot);
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
         case "label.list": {
-          const result = await taskLabelList(this.projectRoot);
+          const result = await taskLabelList(projectRoot);
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
         case "sync.links": {
           const result = await taskSyncLinks(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "query", "tasks", operation, startTime);
@@ -87746,11 +89025,12 @@ var TasksHandler = class {
   // Mutate
   // -----------------------------------------------------------------------
   async mutate(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
         case "add": {
-          const result = await taskCreate(this.projectRoot, {
+          const result = await taskCreate(projectRoot, {
             title: params.title,
             description: params?.description ?? params.title,
             parent: params?.parent ?? params?.parentId,
@@ -87762,7 +89042,7 @@ var TasksHandler = class {
           return wrapResult(result, "mutate", "tasks", operation, startTime);
         }
         case "update": {
-          const result = await taskUpdate(this.projectRoot, params.taskId, {
+          const result = await taskUpdate(projectRoot, params.taskId, {
             title: params?.title,
             description: params?.description,
             status: params?.status,
@@ -87783,7 +89063,7 @@ var TasksHandler = class {
         }
         case "complete": {
           const result = await taskComplete(
-            this.projectRoot,
+            projectRoot,
             params.taskId,
             params?.notes
           );
@@ -87791,7 +89071,7 @@ var TasksHandler = class {
         }
         case "delete": {
           const result = await taskDelete(
-            this.projectRoot,
+            projectRoot,
             params.taskId,
             params?.force
           );
@@ -87799,7 +89079,7 @@ var TasksHandler = class {
         }
         case "archive": {
           const result = await taskArchive(
-            this.projectRoot,
+            projectRoot,
             params?.taskId,
             params?.before
           );
@@ -87809,20 +89089,20 @@ var TasksHandler = class {
           const taskId = params.taskId;
           const from = params?.from;
           if (from === "done") {
-            const result2 = await taskReopen(this.projectRoot, taskId, {
+            const result2 = await taskReopen(projectRoot, taskId, {
               status: params?.status,
               reason: params?.reason
             });
             return wrapResult(result2, "mutate", "tasks", operation, startTime);
           }
           if (from === "archived") {
-            const result2 = await taskUnarchive(this.projectRoot, taskId, {
+            const result2 = await taskUnarchive(projectRoot, taskId, {
               status: params?.status,
               preserveStatus: params?.preserveStatus
             });
             return wrapResult(result2, "mutate", "tasks", operation, startTime);
           }
-          const result = await taskRestore(this.projectRoot, taskId, {
+          const result = await taskRestore(projectRoot, taskId, {
             cascade: params?.cascade,
             notes: params?.notes
           });
@@ -87830,7 +89110,7 @@ var TasksHandler = class {
         }
         case "cancel": {
           const result = await taskCancel(
-            this.projectRoot,
+            projectRoot,
             params.taskId,
             params?.reason
           );
@@ -87838,7 +89118,7 @@ var TasksHandler = class {
         }
         case "reparent": {
           const result = await taskReparent(
-            this.projectRoot,
+            projectRoot,
             params.taskId,
             params?.newParentId ?? null
           );
@@ -87846,7 +89126,7 @@ var TasksHandler = class {
         }
         case "reorder": {
           const result = await taskReorder(
-            this.projectRoot,
+            projectRoot,
             params.taskId,
             params.position
           );
@@ -87865,7 +89145,7 @@ var TasksHandler = class {
             );
           }
           const result = await taskRelatesAdd(
-            this.projectRoot,
+            projectRoot,
             params.taskId,
             relatedId,
             params.type,
@@ -87874,15 +89154,15 @@ var TasksHandler = class {
           return wrapResult(result, "mutate", "tasks", operation, startTime);
         }
         case "start": {
-          const result = await taskStart(this.projectRoot, params.taskId);
+          const result = await taskStart(projectRoot, params.taskId);
           return wrapResult(result, "mutate", "tasks", operation, startTime);
         }
         case "stop": {
-          const result = await taskStop(this.projectRoot);
+          const result = await taskStop(projectRoot);
           return wrapResult(result, "mutate", "tasks", operation, startTime);
         }
         case "sync.reconcile": {
-          const result = await taskSyncReconcile(this.projectRoot, {
+          const result = await taskSyncReconcile(projectRoot, {
             providerId: params.providerId,
             externalTasks: params.externalTasks,
             dryRun: params?.dryRun,
@@ -87893,7 +89173,7 @@ var TasksHandler = class {
           return wrapResult(result, "mutate", "tasks", operation, startTime);
         }
         case "sync.links.remove": {
-          const result = await taskSyncLinksRemove(this.projectRoot, params.providerId);
+          const result = await taskSyncLinksRemove(projectRoot, params.providerId);
           return wrapResult(result, "mutate", "tasks", operation, startTime);
         }
         default:
@@ -87964,7 +89244,7 @@ import {
   discoverSkill as discoverSkill2,
   discoverSkills,
   getAllProviders as getAllProviders2,
-  getCanonicalSkillsDir as getCanonicalSkillsDir3,
+  getCanonicalSkillsDir as getCanonicalSkillsDir4,
   getInstalledProviders as getInstalledProviders3,
   getTrackedSkills,
   injectAll as injectAll2,
@@ -87981,7 +89261,7 @@ function toolsIssueDiagnostics() {
 }
 async function toolsSkillList(limit, offset) {
   try {
-    const skills = await discoverSkills(getCanonicalSkillsDir3());
+    const skills = await discoverSkills(getCanonicalSkillsDir4());
     const page = paginate(skills, limit, offset);
     return {
       success: true,
@@ -88000,7 +89280,7 @@ async function toolsSkillList(limit, offset) {
 }
 async function toolsSkillShow(name2) {
   try {
-    const skill = await discoverSkill2(`${getCanonicalSkillsDir3()}/${name2}`);
+    const skill = await discoverSkill2(`${getCanonicalSkillsDir4()}/${name2}`);
     if (!skill) {
       return engineError("E_NOT_FOUND", `Skill not found: ${name2}`);
     }
@@ -88012,7 +89292,7 @@ async function toolsSkillShow(name2) {
 async function toolsSkillFind(query) {
   try {
     const q = (query ?? "").toLowerCase();
-    const skills = await discoverSkills(getCanonicalSkillsDir3());
+    const skills = await discoverSkills(getCanonicalSkillsDir4());
     const filtered = q ? skills.filter(
       (s) => s.name.toLowerCase().includes(q) || s.metadata.description.toLowerCase().includes(q)
     ) : skills;
@@ -88036,13 +89316,13 @@ function toolsSkillDispatch(name2) {
 }
 async function toolsSkillVerify(name2) {
   try {
-    const installed = await discoverSkill2(`${getCanonicalSkillsDir3()}/${name2}`);
+    const installed = await discoverSkill2(`${getCanonicalSkillsDir4()}/${name2}`);
     const catalogEntry = catalog3.getSkill(name2);
     return engineSuccess({
       skill: name2,
       installed: !!installed,
       inCatalog: !!catalogEntry,
-      installPath: installed ? `${getCanonicalSkillsDir3()}/${name2}` : null
+      installPath: installed ? `${getCanonicalSkillsDir4()}/${name2}` : null
     });
   } catch (error40) {
     return engineError("E_INTERNAL", error40 instanceof Error ? error40.message : String(error40));
@@ -88447,9 +89727,8 @@ async function toolsAdapterDispose(projectRoot, id) {
 
 // packages/cleo/src/dispatch/domains/tools.ts
 var ToolsHandler = class {
-  projectRoot;
-  constructor() {
-    this.projectRoot = getProjectRoot();
+  get projectRoot() {
+    return getProjectRoot();
   }
   // -----------------------------------------------------------------------
   // DomainHandler interface
@@ -91144,8 +92423,8 @@ function getEnabledPlatforms(cwd) {
     return [];
   }
 }
-function getDefaultOutputPath(platform3) {
-  switch (platform3) {
+function getDefaultOutputPath(platform5) {
+  switch (platform5) {
     case "mintlify":
       return "docs/changelog/overview.mdx";
     case "docusaurus":
@@ -91167,8 +92446,8 @@ function getGitHubRepoSlug(cwd) {
     return "";
   }
 }
-function generateForPlatform(platform3, sourceContent, repoSlug, limit) {
-  switch (platform3) {
+function generateForPlatform(platform5, sourceContent, repoSlug, limit) {
+  switch (platform5) {
     case "mintlify":
       return generateMintlify(sourceContent, repoSlug, limit);
     case "docusaurus":
@@ -94454,7 +95733,7 @@ init_src();
 init_src2();
 init_renderers();
 import { execFileSync as execFileSync16, spawn as spawn2 } from "node:child_process";
-import { mkdir as mkdir18, readFile as readFile22, rm as rm2, stat as stat2, writeFile as writeFile13 } from "node:fs/promises";
+import { mkdir as mkdir18, readFile as readFile22, rm as rm3, stat as stat2, writeFile as writeFile13 } from "node:fs/promises";
 import { join as join117 } from "node:path";
 var DEFAULT_PORT = 3456;
 var DEFAULT_HOST = "127.0.0.1";
@@ -94560,7 +95839,7 @@ function registerWebCommand(program) {
           process.kill(serverProcess.pid);
         } catch {
         }
-        await rm2(pidFile, { force: true });
+        await rm3(pidFile, { force: true });
         throw new CleoError(1 /* GENERAL_ERROR */, "Server failed to start within 15 seconds");
       }
       cliOutput(
@@ -94585,7 +95864,7 @@ function registerWebCommand(program) {
       const { pidFile } = getWebPaths();
       const status = await getStatus();
       if (!status.running || !status.pid) {
-        await rm2(pidFile, { force: true });
+        await rm3(pidFile, { force: true });
         cliOutput({ running: false }, { command: "web", message: "Server is not running" });
         return;
       }
@@ -94603,7 +95882,7 @@ function registerWebCommand(program) {
         } catch {
         }
       }
-      await rm2(pidFile, { force: true });
+      await rm3(pidFile, { force: true });
       cliOutput({ stopped: true }, { command: "web", message: "CLEO Web UI stopped" });
     } catch (err) {
       if (err instanceof CleoError) {
@@ -94635,11 +95914,11 @@ function registerWebCommand(program) {
         );
       }
       const url2 = status.url;
-      const platform3 = process.platform;
+      const platform5 = process.platform;
       try {
-        if (platform3 === "linux") {
+        if (platform5 === "linux") {
           spawn2("xdg-open", [url2], { detached: true, stdio: "ignore" }).unref();
-        } else if (platform3 === "darwin") {
+        } else if (platform5 === "darwin") {
           spawn2("open", [url2], { detached: true, stdio: "ignore" }).unref();
         }
       } catch {
@@ -94656,7 +95935,12 @@ function registerWebCommand(program) {
 }
 
 // packages/cleo/src/cli/index.ts
-var CLI_VERSION = "2026.3.38";
+function getPackageVersion() {
+  const pkgPath = join118(dirname25(fileURLToPath7(import.meta.url)), "../../package.json");
+  const pkg = JSON.parse(readFileSync97(pkgPath, "utf-8"));
+  return pkg.version;
+}
+var CLI_VERSION = getPackageVersion();
 var rootShim = new ShimCommand();
 registerAddCommand(rootShim);
 registerListCommand(rootShim);