@cleocode/core 2026.4.0 → 2026.4.3

package/dist/index.js

@@ -3101,7 +3101,7 @@ var init_sql = __esm({
         return new SQL([new StringChunk(str)]);
       }
       _sql.raw = raw;
-      function join108(chunks, separator) {
+      function join107(chunks, separator) {
         const result = [];
         for (const [i, chunk] of chunks.entries()) {
           if (i > 0 && separator !== void 0) result.push(separator);
@@ -3109,7 +3109,7 @@ var init_sql = __esm({
         }
         return new SQL(result);
       }
-      _sql.join = join108;
+      _sql.join = join107;
       function identifier(value) {
         return new Name(value);
       }
@@ -7883,7 +7883,7 @@ var init_select2 = __esm({
           const baseTableName = this.tableName;
           const tableName = getTableLikeName(table);
           for (const item of extractUsedTable(table)) this.usedTables.add(item);
-          if (typeof tableName === "string" && this.config.joins?.some((join108) => join108.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+          if (typeof tableName === "string" && this.config.joins?.some((join107) => join107.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
           if (!this.isPartialSelect) {
             if (Object.keys(this.joinsNotNullableMap).length === 1 && typeof baseTableName === "string") this.config.fields = { [baseTableName]: this.config.fields };
             if (typeof tableName === "string" && !is(table, SQL)) {
@@ -9168,7 +9168,7 @@ var init_dialect = __esm({
           if (!joins2) return;
           const withEntries = Object.entries(joins2).filter(([_, v]) => v);
           if (!withEntries.length) return;
-          return sql.join(withEntries.map(([k, join108]) => {
+          return sql.join(withEntries.map(([k, join107]) => {
             const relation = tableConfig.relations[k];
             const isSingle2 = is(relation, One3);
             const targetTable = aliasedTable(relation.targetTable, `d${currentDepth + 1}`);
@@ -9179,7 +9179,7 @@ var init_dialect = __esm({
               table: targetTable,
               mode: isSingle2 ? "first" : "many",
               schema,
-              queryConfig: join108,
+              queryConfig: join107,
               tableConfig: schema[relation.targetTableName],
               relationWhere: filter,
               isNested: true,
@@ -9193,7 +9193,7 @@ var init_dialect = __esm({
               key: k,
               selection: innerQuery.selection,
               isArray: !isSingle2,
-              isOptional: (relation.optional ?? false) || join108 !== true && !!join108.where
+              isOptional: (relation.optional ?? false) || join107 !== true && !!join107.where
             });
             const jsonColumns = sql.join(innerQuery.selection.map((s) => {
               return sql`${sql.raw(this.escapeString(s.key))}, ${s.selection ? sql`${jsonb2}(${sql.identifier(s.key)})` : sql.identifier(s.key)}`;
@@ -9592,7 +9592,7 @@ var init_update = __esm({
       createJoin(joinType) {
         return ((table, on) => {
           const tableName = getTableLikeName(table);
-          if (typeof tableName === "string" && this.config.joins.some((join108) => join108.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+          if (typeof tableName === "string" && this.config.joins.some((join107) => join107.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
           if (typeof on === "function") {
             const from = this.config.from ? is(table, SQLiteTable) ? table[Table.Symbol.Columns] : is(table, Subquery) ? table._.selectedFields : is(table, SQLiteViewBase) ? table[ViewBaseConfig].selectedFields : void 0 : void 0;
             on = on(new Proxy(this.config.table[Table.Symbol.Columns], new SelectionProxyHandler({
@@ -10794,7 +10794,7 @@ function resolveProjectPath(relativePath, cwd) {
   if (isAbsolutePath(relativePath)) {
     return relativePath;
   }
-  if (relativePath.startsWith("~/") || relativePath === "~") {
+  if (relativePath.startsWith("~/") || relativePath.startsWith("~\\") || relativePath === "~") {
     return resolve2(homedir(), relativePath.slice(2));
   }
   return resolve2(getProjectRoot(cwd), relativePath);
@@ -10873,7 +10873,8 @@ function getCleoTemplatesTildePath() {
   const absPath = getCleoTemplatesDir();
   const home = homedir();
   if (absPath.startsWith(home)) {
-    return `~${absPath.slice(home.length)}`;
+    const relative11 = absPath.slice(home.length).replace(/\\/g, "/");
+    return `~${relative11}`;
   }
   return absPath;
 }
@@ -11322,7 +11323,7 @@ var init_tasks_schema = __esm({
     LIFECYCLE_EVIDENCE_TYPES = ["file", "url", "manifest"];
     TOKEN_USAGE_METHODS = ["otel", "provider_api", "tokenizer", "heuristic"];
     TOKEN_USAGE_CONFIDENCE = ["real", "high", "estimated", "coarse"];
-    TOKEN_USAGE_TRANSPORTS = ["cli", "mcp", "api", "agent", "unknown"];
+    TOKEN_USAGE_TRANSPORTS = ["cli", "api", "agent", "unknown"];
     TASK_RELATION_TYPES = [
       "related",
       "blocks",
@@ -12142,7 +12143,7 @@ function openNativeDatabase(path2, options) {
       if (finalMode !== "wal") {
         db.close();
         throw new Error(
-          `CRITICAL: Failed to set WAL journal mode after ${MAX_WAL_RETRIES} attempts. Database is in '${finalMode}' mode. Another process likely holds an EXCLUSIVE lock on ${path2}. Refusing to open \u2014 concurrent writes in DELETE mode cause data loss. Kill other cleo/MCP processes and retry. (T5173)`
+          `CRITICAL: Failed to set WAL journal mode after ${MAX_WAL_RETRIES} attempts. Database is in '${finalMode}' mode. Another process likely holds an EXCLUSIVE lock on ${path2}. Refusing to open \u2014 concurrent writes in DELETE mode cause data loss. Kill other cleo processes and retry. (T5173)`
         );
       }
     }
@@ -16786,7 +16787,7 @@ var init_architecture = __esm({
       hooks: "React hooks",
       composables: "Vue composables",
       cli: "CLI interface",
-      mcp: "MCP server layer",
+      mcp: "Protocol server layer (legacy)",
       dispatch: "Dispatch / routing layer",
       types: "Type definitions",
       schemas: "Schema definitions",
@@ -16819,7 +16820,7 @@ var init_architecture = __esm({
       mvc: ["models", "views", "controllers"],
       modular: ["modules"],
       "clean-architecture": ["domain", "application", "infrastructure"],
-      "dispatch-first": ["dispatch", "core", "mcp", "cli"],
+      "dispatch-first": ["dispatch", "core", "cli"],
       "component-based": ["components", "pages"]
     };
   }
@@ -19244,7 +19245,7 @@ async function queryAudit(options) {
       },
       metadata: {
         taskId: row.taskId !== "system" && row.taskId !== "unknown" ? row.taskId : void 0,
-        source: row.source ?? "mcp",
+        source: row.source ?? "cli",
         gateway: row.gateway
       },
       error: row.errorMessage ?? void 0
@@ -19410,7 +19411,7 @@ async function gradeSession(sessionId, cwd) {
   const helpCalls = sessionEntries.filter(
     (e) => e.domain === "admin" && e.operation === "help" || e.domain === "tools" && (e.operation === "skill.show" || e.operation === "skill.list") || e.domain === "skills" && (e.operation === "list" || e.operation === "show")
   );
-  const mcpQueryCalls = sessionEntries.filter((e) => e.metadata?.gateway === "query");
+  const queryCalls = sessionEntries.filter((e) => e.metadata?.gateway === "query");
   let disclosureScore = 0;
   if (helpCalls.length > 0) {
     disclosureScore += 10;
@@ -19420,11 +19421,11 @@ async function gradeSession(sessionId, cwd) {
   } else {
     result.flags.push("No admin.help or skill lookup calls (load ct-cleo for guidance)");
   }
-  if (mcpQueryCalls.length > 0) {
+  if (queryCalls.length > 0) {
     disclosureScore += 10;
-    result.dimensions.disclosureUse.evidence.push(`query (MCP) used ${mcpQueryCalls.length}x`);
+    result.dimensions.disclosureUse.evidence.push(`query gateway used ${queryCalls.length}x`);
   } else {
-    result.flags.push("No MCP query calls (prefer query over CLI for programmatic access)");
+    result.flags.push("No query gateway calls (use query operations for programmatic access)");
   }
   result.dimensions.disclosureUse.score = disclosureScore;
   result.totalScore = Object.values(result.dimensions).reduce((sum, d) => sum + d.score, 0);
@@ -19988,48 +19989,7 @@ var init_file_hooks = __esm({
   }
 });
 
-// packages/core/src/hooks/handlers/mcp-hooks.ts
-async function isBrainCaptureEnabled(projectRoot) {
-  const envOverride = process.env["CLEO_BRAIN_CAPTURE_MCP"];
-  if (envOverride !== void 0) {
-    return envOverride === "true";
-  }
-  try {
-    const { loadConfig: loadConfig3 } = await Promise.resolve().then(() => (init_config(), config_exports));
-    const config2 = await loadConfig3(projectRoot);
-    return config2.brain?.captureMcp ?? false;
-  } catch {
-    return false;
-  }
-}
-async function handlePromptSubmit(projectRoot, payload) {
-  if (!await isBrainCaptureEnabled(projectRoot)) return;
-  const { observeBrain: observeBrain2 } = await Promise.resolve().then(() => (init_brain_retrieval(), brain_retrieval_exports));
-  try {
-    await observeBrain2(projectRoot, {
-      text: `Prompt submitted: ${payload.gateway}:${payload.domain}.${payload.operation}${payload.source ? ` from ${payload.source}` : ""}`,
-      title: `Prompt: ${payload.domain}.${payload.operation}`,
-      type: "discovery",
-      sourceType: "agent"
-    });
-  } catch (err) {
-    if (!isMissingBrainSchemaError(err)) throw err;
-  }
-}
-async function handleResponseComplete(projectRoot, payload) {
-  if (!await isBrainCaptureEnabled(projectRoot)) return;
-  const { observeBrain: observeBrain2 } = await Promise.resolve().then(() => (init_brain_retrieval(), brain_retrieval_exports));
-  try {
-    await observeBrain2(projectRoot, {
-      text: `Response ${payload.success ? "success" : "failed"}: ${payload.gateway}:${payload.domain}.${payload.operation}${payload.durationMs != null ? ` (${payload.durationMs}ms)` : ""}${payload.errorCode ? ` error: ${payload.errorCode}` : ""}`,
-      title: `Response: ${payload.domain}.${payload.operation}`,
-      type: payload.success ? "discovery" : "change",
-      sourceType: "agent"
-    });
-  } catch (err) {
-    if (!isMissingBrainSchemaError(err)) throw err;
-  }
-}
+// packages/core/src/hooks/handlers/notification-hooks.ts
 async function handleSystemNotification(projectRoot, payload) {
   if (payload.filePath || payload.changeType) return;
   if (!payload.message) return;
@@ -20047,23 +20007,11 @@ async function handleSystemNotification(projectRoot, payload) {
     if (!isMissingBrainSchemaError(err)) throw err;
   }
 }
-var init_mcp_hooks = __esm({
-  "packages/core/src/hooks/handlers/mcp-hooks.ts"() {
+var init_notification_hooks = __esm({
+  "packages/core/src/hooks/handlers/notification-hooks.ts"() {
     "use strict";
     init_registry();
     init_handler_helpers();
-    hooks.register({
-      id: "brain-prompt-submit",
-      event: "PromptSubmit",
-      handler: handlePromptSubmit,
-      priority: 100
-    });
-    hooks.register({
-      id: "brain-response-complete",
-      event: "ResponseComplete",
-      handler: handleResponseComplete,
-      priority: 100
-    });
     hooks.register({
       id: "brain-system-notification",
       event: "Notification",
@@ -20276,7 +20224,7 @@ var init_handlers = __esm({
     init_task_hooks();
     init_error_hooks();
     init_file_hooks();
-    init_mcp_hooks();
+    init_notification_hooks();
     init_work_capture_hooks();
     init_agent_hooks();
     init_context_hooks();
@@ -20284,7 +20232,7 @@ var init_handlers = __esm({
     init_context_hooks();
     init_error_hooks();
     init_file_hooks();
-    init_mcp_hooks();
+    init_notification_hooks();
     init_session_hooks();
     init_task_hooks();
     init_work_capture_hooks();
@@ -22186,7 +22134,7 @@ async function endSession(options = {}, cwd, accessor) {
   session.endedAt = (/* @__PURE__ */ new Date()).toISOString();
   const duration3 = Math.floor((Date.now() - new Date(session.startedAt).getTime()) / 1e3);
   const { hooks: hooks2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
-  hooks2.dispatch("SessionEnd", cwd ?? process.cwd(), {
+  await hooks2.dispatch("SessionEnd", cwd ?? process.cwd(), {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     sessionId: session.id,
     duration: duration3,
@@ -22195,7 +22143,7 @@ async function endSession(options = {}, cwd, accessor) {
   }).catch(() => {
   });
   const { bridgeSessionToMemory: bridgeSessionToMemory2 } = await Promise.resolve().then(() => (init_session_memory_bridge(), session_memory_bridge_exports));
-  bridgeSessionToMemory2(cwd ?? process.cwd(), {
+  await bridgeSessionToMemory2(cwd ?? process.cwd(), {
     sessionId: session.id,
     scope: options.sessionId ? session.scope.type : session.scope.epicId ? `epic:${session.scope.epicId}` : session.scope.type,
     tasksCompleted: session.tasksCompleted || [],
@@ -22208,6 +22156,11 @@ async function endSession(options = {}, cwd, accessor) {
   }
   const acc = accessor ?? await getAccessor(cwd);
   await acc.upsertSingleSession(session);
+  try {
+    const { refreshMemoryBridge: refreshMemoryBridge2 } = await Promise.resolve().then(() => (init_memory_bridge(), memory_bridge_exports));
+    await refreshMemoryBridge2(cwd ?? process.cwd());
+  } catch {
+  }
   return session;
 }
 async function sessionStatus(cwd, accessor) {
@@ -23854,7 +23807,7 @@ function checkInjection2(projectRoot) {
     const missing = [];
     for (const ref of refs) {
       const rawPath = ref.slice(1).trim();
-      const resolvedPath = rawPath.startsWith("~/") ? join40(homedir2(), rawPath.slice(2)) : join40(projectRoot, rawPath);
+      const resolvedPath = rawPath.startsWith("~/") || rawPath.startsWith("~\\") ? join40(homedir2(), rawPath.slice(2)) : join40(projectRoot, rawPath);
       if (!existsSync37(resolvedPath)) {
         missing.push(rawPath);
       }
@@ -24021,7 +23974,7 @@ function getCleoVersion() {
 }
 function isCleoContributorProject(projectRoot) {
   const exists2 = (p) => existsSync38(join41(projectRoot, p));
-  if (!exists2("src/mcp") || !exists2("src/dispatch") || !exists2("src/core")) return false;
+  if (!exists2("src/dispatch") || !exists2("src/core")) return false;
   try {
     const pkg = JSON.parse(readFileSync24(join41(projectRoot, "package.json"), "utf-8"));
     return pkg.name === "@cleocode/cleo";
@@ -24183,46 +24136,10 @@ async function ensureProjectInfo(projectRoot, opts) {
   return { action: "created", path: projectInfoPath };
 }
 async function ensureContributorMcp(projectRoot) {
-  if (!isCleoContributorProject(projectRoot)) {
-    return {
-      action: "skipped",
-      path: join41(projectRoot, ".mcp.json"),
-      details: "Not a contributor project"
-    };
-  }
-  const mcpJsonPath = join41(projectRoot, ".mcp.json");
-  const mcpEntry = {
-    command: "node",
-    args: ["--disable-warning=ExperimentalWarning", join41(projectRoot, "dist", "mcp", "index.js")],
-    env: {}
-  };
-  let config2 = { mcpServers: {} };
-  if (existsSync38(mcpJsonPath)) {
-    try {
-      config2 = JSON.parse(readFileSync24(mcpJsonPath, "utf-8"));
-    } catch {
-    }
-  }
-  const servers = config2["mcpServers"] ?? {};
-  const existing = servers["cleo-dev"];
-  const existingArgs = existing?.["args"];
-  const targetArg = join41(projectRoot, "dist", "mcp", "index.js");
-  if (existing && existingArgs?.includes(targetArg)) {
-    return { action: "skipped", path: mcpJsonPath, details: "cleo-dev MCP entry already current" };
-  }
-  servers["cleo-dev"] = mcpEntry;
-  const removedProduction = "cleo" in servers;
-  delete servers["cleo"];
-  config2["mcpServers"] = servers;
-  await writeFile6(mcpJsonPath, JSON.stringify(config2, null, 2));
-  const details = [
-    `cleo-dev \u2192 node ${targetArg}`,
-    ...removedProduction ? ["removed production cleo entry (global-only per ADR-029)"] : []
-  ].join("; ");
   return {
-    action: existing ? "repaired" : "created",
-    path: mcpJsonPath,
-    details
+    action: "skipped",
+    path: projectRoot,
+    details: "Removed (Phase 2 production readiness)"
   };
 }
 async function ensureProjectContext(projectRoot, opts) {
@@ -24736,7 +24653,7 @@ function checkGlobalHome() {
       status: "failed",
       message: "Global ~/.cleo/ directory not found",
       details: { path: cleoHome, exists: false },
-      fix: "cleo init (or restart MCP server)"
+      fix: "cleo init"
     };
   }
   const missingDirs = REQUIRED_GLOBAL_SUBDIRS.filter((dir) => !existsSync38(join41(cleoHome, dir)));
@@ -24769,7 +24686,7 @@ function checkGlobalTemplates() {
       status: "failed",
       message: "CLEO-INJECTION.md template not found in global templates",
       details: { path: injectionPath, exists: false },
-      fix: "cleo init (or restart MCP server)"
+      fix: "cleo init"
     };
   }
   const xdgContent = readFileSync24(injectionPath, "utf-8");
@@ -24897,119 +24814,14 @@ backups/
   }
 });
 
-// packages/core/src/mcp/index.ts
-var mcp_exports = {};
-__export(mcp_exports, {
-  detectEnvMode: () => detectEnvMode,
-  generateMcpServerEntry: () => generateMcpServerEntry,
-  getMcpServerName: () => getMcpServerName
-});
-import { readFileSync as readFileSync26, realpathSync } from "node:fs";
-import { join as join46 } from "node:path";
-function getMcpServerName(env) {
-  if (env.channel === "dev") return "cleo-dev";
-  if (env.channel === "beta") return "cleo-beta";
-  return "cleo";
-}
-function detectEnvMode() {
-  const rawScriptPath = process.argv[1] ?? "";
-  let scriptPath;
-  try {
-    scriptPath = realpathSync(rawScriptPath).replace(/\\/g, "/");
-  } catch {
-    scriptPath = rawScriptPath.replace(/\\/g, "/");
-  }
-  const marker = "/node_modules/@cleocode/cleo/";
-  const markerIdx = scriptPath.indexOf(marker);
-  if (markerIdx >= 0) {
-    const pkgRoot = scriptPath.slice(0, markerIdx + marker.length);
-    let channel2 = "stable";
-    try {
-      const pkg = JSON.parse(readFileSync26(join46(pkgRoot, "package.json"), "utf-8"));
-      channel2 = (pkg.version ?? "").includes("-beta") ? "beta" : "stable";
-    } catch {
-      channel2 = "stable";
-    }
-    return { mode: "prod-npm", source: "npm", channel: channel2 };
-  }
-  const devVersionPath = join46(process.env["HOME"] ?? "", ".cleo-dev", "VERSION");
-  try {
-    const devContent = readFileSync26(devVersionPath, "utf-8");
-    const devKv = {};
-    const devLines = devContent.trim().split("\n");
-    for (let i = 1; i < devLines.length; i++) {
-      const eq13 = devLines[i].indexOf("=");
-      if (eq13 > 0) devKv[devLines[i].slice(0, eq13).trim()] = devLines[i].slice(eq13 + 1).trim();
-    }
-    if (devKv["mode"] === "dev-ts" && devKv["source"]) {
-      const devSource = devKv["source"].replace(/\\/g, "/");
-      if (scriptPath.startsWith(devSource) || scriptPath.includes(devSource)) {
-        return { mode: "dev-ts", source: devKv["source"], channel: "dev" };
-      }
-    }
-  } catch {
-  }
-  const versionPath = join46(getCleoHome(), "VERSION");
-  let content;
-  try {
-    content = readFileSync26(versionPath, "utf-8");
-  } catch {
-    return { mode: "unknown", source: null, channel: "unknown" };
-  }
-  const kvPairs = {};
-  const lines = content.trim().split("\n");
-  const installedVersion = lines[0]?.trim() ?? "";
-  for (let i = 1; i < lines.length; i++) {
-    const eqIdx = lines[i].indexOf("=");
-    if (eqIdx > 0) {
-      kvPairs[lines[i].slice(0, eqIdx).trim()] = lines[i].slice(eqIdx + 1).trim();
-    }
-  }
-  const rawMode = kvPairs["mode"] ?? "unknown";
-  const mode = rawMode === "dev-ts" ? "dev-ts" : rawMode === "prod-npm" ? "prod-npm" : "unknown";
-  const channel = mode === "dev-ts" ? "dev" : installedVersion.includes("-beta") ? "beta" : mode === "prod-npm" ? "stable" : "unknown";
-  return {
-    mode,
-    source: mode === "dev-ts" ? kvPairs["source"] ?? null : null,
-    channel
-  };
-}
-function generateMcpServerEntry(env) {
-  if (env.mode === "dev-ts" && env.source) {
-    return {
-      command: "node",
-      args: [join46(env.source, "dist", "mcp", "index.js")],
-      env: {}
-    };
-  }
-  if (env.channel === "beta") {
-    return {
-      command: "npx",
-      args: ["-y", "@cleocode/cleo@beta", "mcp"],
-      env: {}
-    };
-  }
-  return {
-    command: "npx",
-    args: ["-y", "@cleocode/cleo@latest", "mcp"],
-    env: {}
-  };
-}
-var init_mcp = __esm({
-  "packages/core/src/mcp/index.ts"() {
-    "use strict";
-    init_paths();
-  }
-});
-
 // packages/core/src/sessions/session-enforcement.ts
-import { existsSync as existsSync42, readFileSync as readFileSync27 } from "node:fs";
-import { join as join47 } from "node:path";
+import { existsSync as existsSync42, readFileSync as readFileSync26 } from "node:fs";
+import { join as join46 } from "node:path";
 function readConfigValueSync(path2, defaultValue, cwd) {
   try {
-    const configPath = join47(getCleoDir(cwd), "config.json");
+    const configPath = join46(getCleoDir(cwd), "config.json");
     if (!existsSync42(configPath)) return defaultValue;
-    const config2 = JSON.parse(readFileSync27(configPath, "utf-8"));
+    const config2 = JSON.parse(readFileSync26(configPath, "utf-8"));
     const keys = path2.split(".");
     let value = config2;
     for (const key of keys) {
@@ -25974,16 +25786,16 @@ import {
   existsSync as existsSync50,
   mkdirSync as mkdirSync12,
   readdirSync as readdirSync21,
-  readFileSync as readFileSync33,
+  readFileSync as readFileSync32,
   rmSync as rmSync2,
   statSync as statSync11,
   writeFileSync as writeFileSync5
 } from "node:fs";
-import { join as join55 } from "node:path";
+import { join as join54 } from "node:path";
 function detectLegacyAgentOutputs(projectRoot, cleoDir) {
-  const hasResearchOutputs = existsSync50(join55(projectRoot, "claudedocs", "research-outputs"));
-  const hasLegacyAgentOutputs = existsSync50(join55(projectRoot, "claudedocs", "agent-outputs"));
-  const hasCanonical = existsSync50(join55(cleoDir, "agent-outputs"));
+  const hasResearchOutputs = existsSync50(join54(projectRoot, "claudedocs", "research-outputs"));
+  const hasLegacyAgentOutputs = existsSync50(join54(projectRoot, "claudedocs", "agent-outputs"));
+  const hasCanonical = existsSync50(join54(cleoDir, "agent-outputs"));
   const legacyPaths = [];
   if (hasResearchOutputs) legacyPaths.push("claudedocs/research-outputs/");
   if (hasLegacyAgentOutputs) legacyPaths.push("claudedocs/agent-outputs/");
@@ -26006,7 +25818,7 @@ function migrateAgentOutputs(projectRoot, cleoDir) {
       summary: "No legacy output directories found"
     };
   }
-  const newDir = join55(cleoDir, "agent-outputs");
+  const newDir = join54(cleoDir, "agent-outputs");
   const hadCanonical = detection.hasCanonical;
   mkdirSync12(newDir, { recursive: true });
   let totalCopied = 0;
@@ -26014,11 +25826,11 @@ function migrateAgentOutputs(projectRoot, cleoDir) {
   const copiedFiles = /* @__PURE__ */ new Set();
   const legacySources = [
     {
-      path: join55(projectRoot, "claudedocs", "research-outputs"),
+      path: join54(projectRoot, "claudedocs", "research-outputs"),
       exists: detection.hasResearchOutputs
     },
     {
-      path: join55(projectRoot, "claudedocs", "agent-outputs"),
+      path: join54(projectRoot, "claudedocs", "agent-outputs"),
       exists: detection.hasLegacyAgentOutputs
     }
   ];
@@ -26045,11 +25857,11 @@ function copyDirContents(srcDir, dstDir, manifestLines, copiedFiles) {
   const entries = readdirSync21(srcDir);
   for (const entry of entries) {
     if (entry === "MANIFEST.jsonl") {
-      collectManifestLines(join55(srcDir, entry), manifestLines);
+      collectManifestLines(join54(srcDir, entry), manifestLines);
       continue;
     }
-    const srcPath = join55(srcDir, entry);
-    const dstPath = join55(dstDir, entry);
+    const srcPath = join54(srcDir, entry);
+    const dstPath = join54(dstDir, entry);
     try {
       const st = statSync11(srcPath);
       if (st.isDirectory()) {
@@ -26057,7 +25869,7 @@ function copyDirContents(srcDir, dstDir, manifestLines, copiedFiles) {
         for (const sf of readdirSync21(srcPath)) {
           if (!copiedFiles.has(sf)) {
             try {
-              copyFileSync5(join55(srcPath, sf), join55(dstPath, sf));
+              copyFileSync5(join54(srcPath, sf), join54(dstPath, sf));
               copiedFiles.add(sf);
               count2++;
             } catch {
@@ -26076,7 +25888,7 @@ function copyDirContents(srcDir, dstDir, manifestLines, copiedFiles) {
 }
 function collectManifestLines(manifestPath, out) {
   try {
-    const content = readFileSync33(manifestPath, "utf-8");
+    const content = readFileSync32(manifestPath, "utf-8");
     for (const line2 of content.split("\n")) {
       if (!line2.trim()) continue;
       let rewritten = line2;
@@ -26089,11 +25901,11 @@ function collectManifestLines(manifestPath, out) {
   }
 }
 function mergeManifests(newDir, hadCanonical, legacyLines) {
-  const manifestPath = join55(newDir, "MANIFEST.jsonl");
+  const manifestPath = join54(newDir, "MANIFEST.jsonl");
   const existingLines = [];
   if (hadCanonical && existsSync50(manifestPath)) {
     try {
-      const existing = readFileSync33(manifestPath, "utf-8");
+      const existing = readFileSync32(manifestPath, "utf-8");
       for (const line2 of existing.split("\n")) {
         if (line2.trim()) existingLines.push(line2);
       }
@@ -26125,10 +25937,10 @@ function mergeManifests(newDir, hadCanonical, legacyLines) {
   return finalLines.length;
 }
 function updateConfigPaths(cleoDir) {
-  const configPath = join55(cleoDir, "config.json");
+  const configPath = join54(cleoDir, "config.json");
   if (!existsSync50(configPath)) return;
   try {
-    const config2 = JSON.parse(readFileSync33(configPath, "utf-8"));
+    const config2 = JSON.parse(readFileSync32(configPath, "utf-8"));
     const currentDir = config2.agentOutputs?.directory ?? config2.agentOutputs ?? config2.research?.outputDir;
     if (currentDir && currentDir !== CANONICAL_DIR) {
       if (typeof config2.agentOutputs === "object") {
@@ -26151,19 +25963,19 @@ function removeLegacyDirs(projectRoot, detection) {
   const removed = [];
   if (detection.hasResearchOutputs) {
     try {
-      rmSync2(join55(projectRoot, "claudedocs", "research-outputs"), { recursive: true, force: true });
+      rmSync2(join54(projectRoot, "claudedocs", "research-outputs"), { recursive: true, force: true });
       removed.push("claudedocs/research-outputs/");
     } catch {
     }
   }
   if (detection.hasLegacyAgentOutputs) {
     try {
-      rmSync2(join55(projectRoot, "claudedocs", "agent-outputs"), { recursive: true, force: true });
+      rmSync2(join54(projectRoot, "claudedocs", "agent-outputs"), { recursive: true, force: true });
       removed.push("claudedocs/agent-outputs/");
     } catch {
     }
   }
-  const claudedocsDir = join55(projectRoot, "claudedocs");
+  const claudedocsDir = join54(projectRoot, "claudedocs");
   if (existsSync50(claudedocsDir)) {
     try {
       if (readdirSync21(claudedocsDir).length === 0) {
@@ -26193,8 +26005,8 @@ __export(migrate_json_to_sqlite_exports, {
   migrateJsonToSqlite: () => migrateJsonToSqlite
 });
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { existsSync as existsSync55, readFileSync as readFileSync38, renameSync as renameSync4 } from "node:fs";
-import { join as join61 } from "node:path";
+import { existsSync as existsSync55, readFileSync as readFileSync37, renameSync as renameSync4 } from "node:fs";
+import { join as join60 } from "node:path";
 import { sql as sql10 } from "drizzle-orm";
 async function migrateJsonToSqlite() {
   const jsonPath = getRegistryPath();
@@ -26202,7 +26014,7 @@ async function migrateJsonToSqlite() {
   const logger = getLogger("nexus");
   let raw;
   try {
-    raw = readFileSync38(jsonPath, "utf-8");
+    raw = readFileSync37(jsonPath, "utf-8");
   } catch {
     return 0;
   }
@@ -26226,9 +26038,9 @@ async function migrateJsonToSqlite() {
     if (!projectPath || !projectHash) continue;
     let projectId = randomUUID3();
     try {
-      const infoPath = join61(projectPath, ".cleo", "project-info.json");
+      const infoPath = join60(projectPath, ".cleo", "project-info.json");
       if (existsSync55(infoPath)) {
-        const info = JSON.parse(readFileSync38(infoPath, "utf-8"));
+        const info = JSON.parse(readFileSync37(infoPath, "utf-8"));
         if (typeof info["projectId"] === "string" && info["projectId"]) {
           projectId = info["projectId"];
         }
@@ -26298,15 +26110,15 @@ __export(registry_exports3, {
 });
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { mkdir as mkdir12 } from "node:fs/promises";
-import { basename as basename8, join as join62 } from "node:path";
+import { basename as basename8, join as join61 } from "node:path";
 function getNexusHome() {
-  return process.env["NEXUS_HOME"] ?? join62(getCleoHome(), "nexus");
+  return process.env["NEXUS_HOME"] ?? join61(getCleoHome(), "nexus");
 }
 function getNexusCacheDir() {
-  return process.env["NEXUS_CACHE_DIR"] ?? join62(getNexusHome(), "cache");
+  return process.env["NEXUS_CACHE_DIR"] ?? join61(getNexusHome(), "cache");
 }
 function getRegistryPath() {
-  return process.env["NEXUS_REGISTRY_FILE"] ?? join62(getCleoHome(), "projects-registry.json");
+  return process.env["NEXUS_REGISTRY_FILE"] ?? join61(getCleoHome(), "projects-registry.json");
 }
 function rowToProject(row) {
   let labels = [];
@@ -26423,10 +26235,10 @@ async function readProjectMeta(projectPath) {
 }
 async function readProjectId(projectPath) {
   try {
-    const { readFileSync: readFileSync80, existsSync: existsSync107 } = await import("node:fs");
-    const infoPath = join62(projectPath, ".cleo", "project-info.json");
+    const { readFileSync: readFileSync79, existsSync: existsSync107 } = await import("node:fs");
+    const infoPath = join61(projectPath, ".cleo", "project-info.json");
     if (!existsSync107(infoPath)) return "";
-    const data = JSON.parse(readFileSync80(infoPath, "utf-8"));
+    const data = JSON.parse(readFileSync79(infoPath, "utf-8"));
     return typeof data.projectId === "string" ? data.projectId : "";
   } catch {
     return "";
@@ -27090,6 +26902,208 @@ var init_complete = __esm({
   }
 });
 
+// packages/core/src/validation/validation-rules.ts
+var validation_rules_exports = {};
+__export(validation_rules_exports, {
+  hasErrors: () => hasErrors,
+  validateHierarchy: () => validateHierarchy,
+  validateIdUniqueness: () => validateIdUniqueness,
+  validateNewTask: () => validateNewTask,
+  validateNoDuplicateDescription: () => validateNoDuplicateDescription,
+  validateStatusTransition: () => validateStatusTransition,
+  validateTimestamps: () => validateTimestamps,
+  validateTitleDescription: () => validateTitleDescription
+});
+function validateTitleDescription(title, description) {
+  const violations = [];
+  if (!title || title.trim().length === 0) {
+    violations.push({
+      rule: "title-required",
+      field: "title",
+      message: "Title is required and cannot be empty",
+      severity: "error"
+    });
+  }
+  if (!description || description.trim().length === 0) {
+    violations.push({
+      rule: "description-required",
+      field: "description",
+      message: "Description is required and cannot be empty",
+      severity: "error"
+    });
+  }
+  if (title && description && title.trim().toLowerCase() === description.trim().toLowerCase()) {
+    violations.push({
+      rule: "title-description-different",
+      field: "description",
+      message: "Title and description must be different",
+      severity: "error"
+    });
+  }
+  return violations;
+}
+function validateTimestamps(task) {
+  const violations = [];
+  const now = /* @__PURE__ */ new Date();
+  const threshold = new Date(now.getTime() + 5 * 60 * 1e3);
+  const timestampFields = [
+    ["createdAt", task.createdAt],
+    ["updatedAt", task.updatedAt],
+    ["completedAt", task.completedAt],
+    ["cancelledAt", task.cancelledAt]
+  ];
+  for (const [field, value] of timestampFields) {
+    if (value) {
+      const date6 = new Date(value);
+      if (Number.isNaN(date6.getTime())) {
+        violations.push({
+          rule: "valid-timestamp",
+          field,
+          message: `Invalid timestamp format: ${value}`,
+          severity: "error"
+        });
+      } else if (date6 > threshold) {
+        violations.push({
+          rule: "no-future-timestamps",
+          field,
+          message: `Timestamp ${value} is in the future`,
+          severity: "error"
+        });
+      }
+    }
+  }
+  return violations;
+}
+function validateIdUniqueness(taskId, existingIds) {
+  if (existingIds.has(taskId)) {
+    return [
+      {
+        rule: "unique-id",
+        field: "id",
+        message: `Task ID '${taskId}' already exists`,
+        severity: "error"
+      }
+    ];
+  }
+  return [];
+}
+function validateNoDuplicateDescription(description, existingDescriptions, _excludeTaskId) {
+  const normalizedNew = description.trim().toLowerCase();
+  for (const existing of existingDescriptions) {
+    if (existing.trim().toLowerCase() === normalizedNew) {
+      return [
+        {
+          rule: "no-duplicate-description",
+          field: "description",
+          message: "A task with this exact description already exists",
+          severity: "warning"
+        }
+      ];
+    }
+  }
+  return [];
+}
+function validateHierarchy(parentId, tasks2, _taskType, limits) {
+  const violations = [];
+  if (!parentId) {
+    return violations;
+  }
+  const maxDepth = limits?.maxDepth ?? 3;
+  const maxSiblings = limits?.maxSiblings ?? 0;
+  const parent = tasks2.find((t) => t.id === parentId);
+  if (!parent) {
+    violations.push({
+      rule: "parent-exists",
+      field: "parentId",
+      message: `Parent task '${parentId}' not found`,
+      severity: "error"
+    });
+    return violations;
+  }
+  let depth = 1;
+  let current = parent;
+  while (current.parentId) {
+    depth++;
+    const nextParent = tasks2.find((t) => t.id === current.parentId);
+    if (!nextParent) break;
+    current = nextParent;
+  }
+  if (depth > maxDepth - 1) {
+    violations.push({
+      rule: "max-depth",
+      field: "parentId",
+      message: `Maximum hierarchy depth of ${maxDepth} exceeded (epic -> task -> subtask)`,
+      severity: "error"
+    });
+  }
+  const siblingCount = tasks2.filter((t) => t.parentId === parentId).length;
+  if (maxSiblings > 0 && siblingCount >= maxSiblings) {
+    violations.push({
+      rule: "max-siblings",
+      field: "parentId",
+      message: `Parent '${parentId}' already has ${siblingCount} children (max ${maxSiblings})`,
+      severity: "error"
+    });
+  }
+  return violations;
+}
+function validateStatusTransition(currentStatus, newStatus) {
+  const validTransitions = {
+    pending: ["active", "blocked", "done", "cancelled"],
+    active: ["pending", "blocked", "done", "cancelled"],
+    blocked: ["pending", "active", "done", "cancelled"],
+    done: ["pending", "active"],
+    // restore (alias: reopen)
+    cancelled: ["pending"]
+    // restore (alias: uncancel)
+  };
+  const allowed = validTransitions[currentStatus];
+  if (!allowed) {
+    return [
+      {
+        rule: "valid-status-transition",
+        field: "status",
+        message: `Unknown current status: '${currentStatus}'`,
+        severity: "error"
+      }
+    ];
+  }
+  if (!allowed.includes(newStatus)) {
+    return [
+      {
+        rule: "valid-status-transition",
+        field: "status",
+        message: `Cannot transition from '${currentStatus}' to '${newStatus}'. Valid: ${allowed.join(", ")}`,
+        severity: "error"
+      }
+    ];
+  }
+  return [];
+}
+function validateNewTask(task, existingIds, existingDescriptions, existingTasks, limits) {
+  const violations = [];
+  violations.push(...validateTitleDescription(task.title, task.description));
+  violations.push(...validateTimestamps(task));
+  if (task.id) {
+    violations.push(...validateIdUniqueness(task.id, existingIds));
+  }
+  if (task.description) {
+    violations.push(...validateNoDuplicateDescription(task.description, existingDescriptions));
+  }
+  if (task.parentId) {
+    violations.push(...validateHierarchy(task.parentId, existingTasks, task.type, limits));
+  }
+  return violations;
+}
+function hasErrors(violations) {
+  return violations.some((v) => v.severity === "error");
+}
+var init_validation_rules = __esm({
+  "packages/core/src/validation/validation-rules.ts"() {
+    "use strict";
+  }
+});
+
 // packages/core/src/tasks/update.ts
 var update_exports = {};
 __export(update_exports, {
@@ -27139,6 +27153,11 @@ async function updateTask(options, cwd, accessor) {
   }
   if (options.status !== void 0) {
     validateStatus(options.status);
+    const { validateStatusTransition: validateStatusTransition3 } = await Promise.resolve().then(() => (init_validation_rules(), validation_rules_exports));
+    const transitionViolations = validateStatusTransition3(task.status, options.status);
+    if (transitionViolations.length > 0) {
+      throw new CleoError(6 /* VALIDATION_ERROR */, transitionViolations[0].message);
+    }
     const oldStatus = task.status;
     task.status = options.status;
     changes.push("status");
@@ -27362,10 +27381,10 @@ var init_update2 = __esm({
 // packages/core/src/hooks.ts
 import { existsSync as existsSync86 } from "node:fs";
 import { chmod, copyFile as copyFile2, mkdir as mkdir14, readFile as readFile14 } from "node:fs/promises";
-import { join as join90 } from "node:path";
+import { join as join89 } from "node:path";
 async function ensureGitHooks(projectRoot, opts) {
-  const gitDir = join90(projectRoot, ".git");
-  const gitHooksDir = join90(gitDir, "hooks");
+  const gitDir = join89(projectRoot, ".git");
+  const gitHooksDir = join89(gitDir, "hooks");
   if (!existsSync86(gitDir)) {
     return {
       action: "skipped",
@@ -27374,7 +27393,7 @@ async function ensureGitHooks(projectRoot, opts) {
     };
   }
   const packageRoot = getPackageRoot();
-  const sourceDir = join90(packageRoot, "templates", "git-hooks");
+  const sourceDir = join89(packageRoot, "templates", "git-hooks");
   if (!existsSync86(sourceDir)) {
     return {
       action: "skipped",
@@ -27387,8 +27406,8 @@ async function ensureGitHooks(projectRoot, opts) {
   let installedCount = 0;
   const errors = [];
   for (const hook of MANAGED_HOOKS) {
-    const sourcePath = join90(sourceDir, hook);
-    const destPath = join90(gitHooksDir, hook);
+    const sourcePath = join89(sourceDir, hook);
+    const destPath = join89(gitHooksDir, hook);
     if (!existsSync86(sourcePath)) {
       continue;
     }
@@ -27426,13 +27445,13 @@ async function ensureGitHooks(projectRoot, opts) {
   };
 }
 async function checkGitHooks(projectRoot) {
-  const gitHooksDir = join90(projectRoot, ".git", "hooks");
+  const gitHooksDir = join89(projectRoot, ".git", "hooks");
   const packageRoot = getPackageRoot();
-  const sourceDir = join90(packageRoot, "templates", "git-hooks");
+  const sourceDir = join89(packageRoot, "templates", "git-hooks");
   const results = [];
   for (const hook of MANAGED_HOOKS) {
-    const sourcePath = join90(sourceDir, hook);
-    const installedPath = join90(gitHooksDir, hook);
+    const sourcePath = join89(sourceDir, hook);
+    const installedPath = join89(gitHooksDir, hook);
     const result = {
       hook,
       installed: false,
@@ -27485,10 +27504,10 @@ __export(init_exports, {
   isAutoInitEnabled: () => isAutoInitEnabled,
   updateDocs: () => updateDocs
 });
-import { existsSync as existsSync103, readdirSync as readdirSync35, readFileSync as readFileSync76 } from "node:fs";
+import { existsSync as existsSync103, readdirSync as readdirSync35, readFileSync as readFileSync75 } 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 dirname20, join as join104 } from "node:path";
+import { basename as basename17, dirname as dirname20, join as join103 } from "node:path";
 async function initAgentDefinition(created, warnings) {
   let agentSourceDir = null;
   try {
@@ -27496,7 +27515,7 @@ async function initAgentDefinition(created, warnings) {
     const req = createRequire7(import.meta.url);
     const agentsPkgMain = req.resolve("@cleocode/agents/package.json");
     const agentsPkgRoot = dirname20(agentsPkgMain);
-    const candidate = join104(agentsPkgRoot, "cleo-subagent");
+    const candidate = join103(agentsPkgRoot, "cleo-subagent");
     if (existsSync103(candidate)) {
       agentSourceDir = candidate;
     }
@@ -27504,7 +27523,7 @@ async function initAgentDefinition(created, warnings) {
   }
   if (!agentSourceDir) {
     const packageRoot = getPackageRoot();
-    const bundled = join104(packageRoot, "agents", "cleo-subagent");
+    const bundled = join103(packageRoot, "agents", "cleo-subagent");
     if (existsSync103(bundled)) {
       agentSourceDir = bundled;
     }
@@ -27513,7 +27532,7 @@ async function initAgentDefinition(created, warnings) {
     warnings.push("agents/cleo-subagent/ not found in package, skipping agent definition install");
     return;
   }
-  const globalAgentsDir = join104(getAgentsHome(), "agents", "cleo-subagent");
+  const globalAgentsDir = join103(getAgentsHome(), "agents", "cleo-subagent");
   await mkdir16(dirname20(globalAgentsDir), { recursive: true });
   try {
     try {
@@ -27537,7 +27556,7 @@ async function initAgentDefinition(created, warnings) {
       await mkdir16(globalAgentsDir, { recursive: true });
       const files = readdirSync35(agentSourceDir);
       for (const file2 of files) {
-        await copyFile3(join104(agentSourceDir, file2), join104(globalAgentsDir, file2));
+        await copyFile3(join103(agentSourceDir, file2), join103(globalAgentsDir, file2));
       }
       created.push("agent: cleo-subagent (copied)");
     } catch (copyErr) {
@@ -27547,37 +27566,7 @@ async function initAgentDefinition(created, warnings) {
     }
   }
 }
-async function initMcpServer(projectRoot, created, warnings) {
-  try {
-    const { detectEnvMode: detectEnvMode2, generateMcpServerEntry: generateMcpServerEntry2, getMcpServerName: getMcpServerName2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
-    const { getInstalledProviders: getInstalledProviders3, installMcpServerToAll } = await import("@cleocode/caamp");
-    const env = detectEnvMode2();
-    const serverEntry = generateMcpServerEntry2(env);
-    const serverName = getMcpServerName2(env);
-    const providers = getInstalledProviders3();
-    if (providers.length === 0) {
-      return;
-    }
-    const results = await installMcpServerToAll(
-      providers,
-      serverName,
-      serverEntry,
-      "global",
-      projectRoot
-    );
-    const successes = results.filter((r) => r.success);
-    const failures = results.filter((r) => !r.success);
-    if (successes.length > 0) {
-      created.push(`MCP server: ${successes.map((r) => r.provider.id).join(", ")}`);
-    }
-    for (const f of failures) {
-      if (f.error) {
-        warnings.push(`MCP install to ${f.provider.id}: ${f.error}`);
-      }
-    }
-  } catch (err) {
-    warnings.push(`MCP server install: ${err instanceof Error ? err.message : String(err)}`);
-  }
+async function initMcpServer(_projectRoot, _created, _warnings) {
 }
 async function initCoreSkills(created, warnings) {
   try {
@@ -27593,19 +27582,19 @@ async function initCoreSkills(created, warnings) {
       const req = createRequire7(import.meta.url);
       const skillsPkgMain = req.resolve("@cleocode/skills/package.json");
       const skillsPkgRoot = dirname20(skillsPkgMain);
-      if (existsSync103(join104(skillsPkgRoot, "skills.json"))) {
+      if (existsSync103(join103(skillsPkgRoot, "skills.json"))) {
         ctSkillsRoot = skillsPkgRoot;
       }
     } catch {
     }
     if (!ctSkillsRoot) {
       try {
-        const bundledPath = join104(packageRoot, "packages", "skills");
-        if (existsSync103(join104(bundledPath, "skills.json"))) {
+        const bundledPath = join103(packageRoot, "packages", "skills");
+        if (existsSync103(join103(bundledPath, "skills.json"))) {
           ctSkillsRoot = bundledPath;
         } else {
-          const ctSkillsPath = join104(packageRoot, "node_modules", "@cleocode", "skills");
-          if (existsSync103(join104(ctSkillsPath, "skills.json"))) {
+          const ctSkillsPath = join103(packageRoot, "node_modules", "@cleocode", "skills");
+          if (existsSync103(join103(ctSkillsPath, "skills.json"))) {
             ctSkillsRoot = ctSkillsPath;
           }
         }
@@ -27621,13 +27610,13 @@ async function initCoreSkills(created, warnings) {
     } catch {
       warnings.push("Failed to register skill library with CAAMP");
     }
-    const catalogPath = join104(ctSkillsRoot, "skills.json");
-    const catalog3 = JSON.parse(readFileSync76(catalogPath, "utf-8"));
+    const catalogPath = join103(ctSkillsRoot, "skills.json");
+    const catalog3 = JSON.parse(readFileSync75(catalogPath, "utf-8"));
     const skills = catalog3.skills ?? [];
     const coreSkills = skills.filter((s) => s.tier <= 2);
     const installed = [];
     for (const skill of coreSkills) {
-      const skillSourceDir = dirname20(join104(ctSkillsRoot, skill.path));
+      const skillSourceDir = dirname20(join103(ctSkillsRoot, skill.path));
       if (!existsSync103(skillSourceDir)) {
         continue;
       }
@@ -27671,38 +27660,38 @@ async function initNexusRegistration(projectRoot, created, warnings) {
   }
 }
 async function installGitHubTemplates(projectRoot, created, skipped) {
-  if (!existsSync103(join104(projectRoot, ".git"))) {
+  if (!existsSync103(join103(projectRoot, ".git"))) {
     return;
   }
-  const githubDir = join104(projectRoot, ".github");
-  const issueTemplateDir = join104(githubDir, "ISSUE_TEMPLATE");
+  const githubDir = join103(projectRoot, ".github");
+  const issueTemplateDir = join103(githubDir, "ISSUE_TEMPLATE");
   const packageRoot = getPackageRoot();
-  const templateSrcDir = join104(packageRoot, "templates", "github");
+  const templateSrcDir = join103(packageRoot, "templates", "github");
   if (!existsSync103(templateSrcDir)) {
     return;
   }
   await mkdir16(issueTemplateDir, { recursive: true });
-  const issueSrcDir = join104(templateSrcDir, "ISSUE_TEMPLATE");
+  const issueSrcDir = join103(templateSrcDir, "ISSUE_TEMPLATE");
   if (existsSync103(issueSrcDir)) {
     const issueFiles = readdirSync35(issueSrcDir);
     for (const file2 of issueFiles) {
-      const dest = join104(issueTemplateDir, file2);
+      const dest = join103(issueTemplateDir, file2);
       if (existsSync103(dest)) {
         skipped.push(`.github/ISSUE_TEMPLATE/${file2}`);
         continue;
       }
-      const content = readFileSync76(join104(issueSrcDir, file2), "utf-8");
+      const content = readFileSync75(join103(issueSrcDir, file2), "utf-8");
       await writeFile11(dest, content, "utf-8");
       created.push(`.github/ISSUE_TEMPLATE/${file2}`);
     }
   }
-  const prTemplateSrc = join104(templateSrcDir, "pull_request_template.md");
-  const prTemplateDest = join104(githubDir, "pull_request_template.md");
+  const prTemplateSrc = join103(templateSrcDir, "pull_request_template.md");
+  const prTemplateDest = join103(githubDir, "pull_request_template.md");
   if (existsSync103(prTemplateSrc)) {
     if (existsSync103(prTemplateDest)) {
       skipped.push(".github/pull_request_template.md");
     } else {
-      const content = readFileSync76(prTemplateSrc, "utf-8");
+      const content = readFileSync75(prTemplateSrc, "utf-8");
       await writeFile11(prTemplateDest, content, "utf-8");
       created.push(".github/pull_request_template.md");
     }
@@ -27733,7 +27722,7 @@ async function updateDocs() {
 async function initProject(opts = {}) {
   const cleoDir = getCleoDirAbsolute();
   const projRoot = getProjectRoot();
-  const alreadyInitialized = existsSync103(cleoDir) && (existsSync103(join104(cleoDir, "tasks.db")) || existsSync103(join104(cleoDir, "config.json")));
+  const alreadyInitialized = existsSync103(cleoDir) && (existsSync103(join103(cleoDir, "tasks.db")) || existsSync103(join103(cleoDir, "config.json")));
   if (alreadyInitialized && !opts.force) {
     throw new CleoError(
       1 /* GENERAL_ERROR */,
@@ -27757,7 +27746,7 @@ async function initProject(opts = {}) {
   }
   try {
     const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
-    await getDb3(join104(cleoDir, ".."));
+    await getDb3(join103(cleoDir, ".."));
     created.push("tasks.db");
   } catch (err) {
     created.push(`tasks.db (deferred: ${err instanceof Error ? err.message : String(err)})`);
@@ -27787,7 +27776,7 @@ async function initProject(opts = {}) {
       created.push(".gitignore");
     }
   } else {
-    const gitignorePath = join104(cleoDir, ".gitignore");
+    const gitignorePath = join103(cleoDir, ".gitignore");
     if (existsSync103(gitignorePath)) {
       skipped.push(".gitignore");
     } else {
@@ -27799,12 +27788,12 @@ async function initProject(opts = {}) {
       }
     }
   }
-  const legacySequencePath = join104(cleoDir, ".sequence");
+  const legacySequencePath = join103(cleoDir, ".sequence");
   try {
     await unlink4(legacySequencePath);
   } catch {
   }
-  const legacySequenceJsonPath = join104(cleoDir, ".sequence.json");
+  const legacySequenceJsonPath = join103(cleoDir, ".sequence.json");
   try {
     await unlink4(legacySequenceJsonPath);
   } catch {
@@ -27901,12 +27890,12 @@ async function initProject(opts = {}) {
   }
   try {
     const { ensureContributorMcp: ensureContributorMcp2 } = await Promise.resolve().then(() => (init_scaffold(), scaffold_exports));
-    const mcpResult = await ensureContributorMcp2(projRoot);
-    if (mcpResult.action !== "skipped") {
-      created.push(`contributor MCP: ${mcpResult.details ?? mcpResult.action}`);
+    const devResult = await ensureContributorMcp2(projRoot);
+    if (devResult.action !== "skipped") {
+      created.push(`contributor dev channel: ${devResult.details ?? devResult.action}`);
     }
   } catch (err) {
-    warnings.push(`Contributor MCP setup: ${err instanceof Error ? err.message : String(err)}`);
+    warnings.push(`Contributor dev channel: ${err instanceof Error ? err.message : String(err)}`);
   }
   await initAgentDefinition(created, warnings);
   await initNexusRegistration(projRoot, created, warnings);
@@ -27965,8 +27954,8 @@ function isAutoInitEnabled() {
 }
 async function ensureInitialized(projectRoot) {
   const root = projectRoot ?? getProjectRoot();
-  const cleoDir = join104(root, ".cleo");
-  const isInit = existsSync103(cleoDir) && (existsSync103(join104(cleoDir, "tasks.db")) || existsSync103(join104(cleoDir, "config.json")));
+  const cleoDir = join103(root, ".cleo");
+  const isInit = existsSync103(cleoDir) && (existsSync103(join103(cleoDir, "tasks.db")) || existsSync103(join103(cleoDir, "config.json")));
   if (isInit) {
     return { initialized: true };
   }
@@ -27978,7 +27967,7 @@ async function ensureInitialized(projectRoot) {
 }
 async function getVersion2(projectRoot) {
   const root = projectRoot ?? getProjectRoot();
-  const versionPaths = [join104(root, "VERSION"), join104(root, "..", "VERSION")];
+  const versionPaths = [join103(root, "VERSION"), join103(root, "..", "VERSION")];
   for (const versionPath of versionPaths) {
     try {
       const content = await readFile17(versionPath, "utf-8");
@@ -27989,7 +27978,7 @@ async function getVersion2(projectRoot) {
     } catch {
     }
   }
-  const pkg = await readJson(join104(root, "package.json"));
+  const pkg = await readJson(join103(root, "package.json"));
   if (pkg?.version) {
     return { version: pkg.version };
   }
@@ -29848,22 +29837,15 @@ async function recoverCrashedAgents(thresholdMs = 3e4, cwd) {
 var caamp_exports = {};
 __export(caamp_exports, {
   batchInstallWithRollback: () => batchInstallWithRollback,
-  caampBuildServerConfig: () => buildServerConfig,
   caampGenerateInjectionContent: () => generateInjectionContent,
   caampGetInstructionFiles: () => getInstructionFiles,
   caampResolveAlias: () => resolveAlias,
   checkProviderCapabilities: () => checkProviderCapabilities,
   checkProviderCapability: () => checkProviderCapability,
-  dualScopeConfigure: () => dualScopeConfigure,
   injectionCheck: () => injectionCheck,
   injectionCheckAll: () => injectionCheckAll,
   injectionUpdate: () => injectionUpdate,
   injectionUpdateAll: () => injectionUpdateAll,
-  mcpConfigPath: () => mcpConfigPath,
-  mcpInstall: () => mcpInstall,
-  mcpList: () => mcpList,
-  mcpListAll: () => mcpListAll,
-  mcpRemove: () => mcpRemove,
   providerCount: () => providerCount,
   providerDetect: () => providerDetect,
   providerGet: () => providerGet,
@@ -29874,10 +29856,8 @@ __export(caamp_exports, {
 
 // packages/core/src/caamp/adapter.ts
 import {
-  buildServerConfig,
   checkAllInjections,
   checkInjection,
-  configureProviderGlobalAndProject,
   detectAllProviders,
   generateInjectionContent,
   getAllProviders,
@@ -29889,12 +29869,7 @@ import {
   inject,
   injectAll,
   installBatchWithRollback,
-  installMcpServer,
-  listAllMcpServers,
-  listMcpServers,
-  removeMcpServer,
-  resolveAlias,
-  resolveConfigPath
+  resolveAlias
 } from "@cleocode/caamp";
 function providerList() {
   try {
@@ -29989,117 +29964,6 @@ function registryVersion() {
     };
   }
 }
-async function mcpList(providerId, scope, projectDir) {
-  try {
-    const provider = getProvider(providerId);
-    if (!provider) {
-      return {
-        success: false,
-        error: {
-          code: "E_CAAMP_PROVIDER_NOT_FOUND",
-          message: `Provider not found: ${providerId}`
-        }
-      };
-    }
-    const servers = await listMcpServers(provider, scope, projectDir);
-    return { success: true, data: { servers } };
-  } catch (err) {
-    return {
-      success: false,
-      error: {
-        code: "E_CAAMP_MCP_LIST",
-        message: err instanceof Error ? err.message : String(err)
-      }
-    };
-  }
-}
-async function mcpListAll(scope, projectDir) {
-  try {
-    const providers = getInstalledProviders();
-    const servers = await listAllMcpServers(providers, scope, projectDir);
-    return { success: true, data: { servers } };
-  } catch (err) {
-    return {
-      success: false,
-      error: {
-        code: "E_CAAMP_MCP_LIST_ALL",
-        message: err instanceof Error ? err.message : String(err)
-      }
-    };
-  }
-}
-async function mcpInstall(providerId, serverName, config2, scope, projectDir) {
-  try {
-    const provider = getProvider(providerId);
-    if (!provider) {
-      return {
-        success: false,
-        error: {
-          code: "E_CAAMP_PROVIDER_NOT_FOUND",
-          message: `Provider not found: ${providerId}`
-        }
-      };
-    }
-    const result = await installMcpServer(provider, serverName, config2, scope, projectDir);
-    return { success: true, data: result };
-  } catch (err) {
-    return {
-      success: false,
-      error: {
-        code: "E_CAAMP_MCP_INSTALL",
-        message: err instanceof Error ? err.message : String(err)
-      }
-    };
-  }
-}
-async function mcpRemove(providerId, serverName, scope, projectDir) {
-  try {
-    const provider = getProvider(providerId);
-    if (!provider) {
-      return {
-        success: false,
-        error: {
-          code: "E_CAAMP_PROVIDER_NOT_FOUND",
-          message: `Provider not found: ${providerId}`
-        }
-      };
-    }
-    const removed = await removeMcpServer(provider, serverName, scope, projectDir);
-    return { success: true, data: { removed } };
-  } catch (err) {
-    return {
-      success: false,
-      error: {
-        code: "E_CAAMP_MCP_REMOVE",
-        message: err instanceof Error ? err.message : String(err)
-      }
-    };
-  }
-}
-function mcpConfigPath(providerId, scope, projectDir) {
-  try {
-    const provider = getProvider(providerId);
-    if (!provider) {
-      return {
-        success: false,
-        error: {
-          code: "E_CAAMP_PROVIDER_NOT_FOUND",
-          message: `Provider not found: ${providerId}`
-        }
-      };
-    }
-    const path2 = resolveConfigPath(provider, scope, projectDir);
-    return { success: true, data: { path: path2 } };
-  } catch (err) {
-    return {
-      success: false,
-      error: {
-        code: "E_CAAMP_MCP_CONFIG_PATH",
-        message: err instanceof Error ? err.message : String(err)
-      }
-    };
-  }
-}
 async function injectionCheck(filePath, expectedContent) {
   try {
     const status = await checkInjection(filePath, expectedContent);
@@ -30176,30 +30040,6 @@ async function batchInstallWithRollback(options) {
     };
   }
 }
-async function dualScopeConfigure(providerId, options) {
-  try {
-    const provider = getProvider(providerId);
-    if (!provider) {
-      return {
-        success: false,
-        error: {
-          code: "E_CAAMP_PROVIDER_NOT_FOUND",
-          message: `Provider not found: ${providerId}`
-        }
-      };
-    }
-    const result = await configureProviderGlobalAndProject(provider, options);
-    return { success: true, data: result };
-  } catch (err) {
-    return {
-      success: false,
-      error: {
-        code: "E_CAAMP_DUAL_SCOPE_CONFIGURE",
-        message: err instanceof Error ? err.message : String(err)
-      }
-    };
-  }
-}
 
 // packages/core/src/caamp/capability-check.ts
 import { providerSupports, providerSupportsById } from "@cleocode/caamp";
@@ -30284,14 +30124,26 @@ import { existsSync as existsSync17, mkdtempSync, rmSync, writeFileSync as write
 import { tmpdir } from "node:os";
 import { join as join20, relative } from "node:path";
 function resolveTreeSitterBin() {
+  const ext = process.platform === "win32" ? ".exe" : "";
+  const binName = `tree-sitter${ext}`;
   const candidates = [
-    join20(process.cwd(), "packages", "core", "node_modules", ".bin", "tree-sitter"),
-    join20(process.cwd(), "node_modules", ".bin", "tree-sitter")
+    join20(process.cwd(), "packages", "core", "node_modules", ".bin", binName),
+    join20(process.cwd(), "node_modules", ".bin", binName),
+    // npm global install paths
+    join20(process.cwd(), "node_modules", "tree-sitter-cli", binName)
   ];
+  if (ext) {
+    candidates.push(
+      join20(process.cwd(), "packages", "core", "node_modules", ".bin", "tree-sitter"),
+      join20(process.cwd(), "node_modules", ".bin", "tree-sitter")
+    );
+  }
   for (const p of candidates) {
     if (existsSync17(p)) return p;
   }
-  throw new Error("tree-sitter CLI not found. Run: pnpm add -F @cleocode/core tree-sitter-cli");
+  throw new Error(
+    "tree-sitter CLI not found. Code analysis features (cleo code outline/search/unfold) require tree-sitter. Install with: npm install tree-sitter-cli"
+  );
 }
 var QUERY_PATTERNS = {
   // TypeScript / JavaScript
@@ -31153,6 +31005,10 @@ var ConduitClient = class {
       deliveredAt: (/* @__PURE__ */ new Date()).toISOString()
     };
   }
+  /** One-shot poll for new messages. Delegates to the transport's poll method. */
+  async poll(options) {
+    return this.transport.poll(options);
+  }
   /** Subscribe to incoming messages. Uses real-time transport when available, else polls. */
   onMessage(handler) {
     if (this.transport.subscribe) {
@@ -31254,11 +31110,10 @@ var HttpTransport = class {
     const messageId = data.data?.message?.id ?? data.data?.id ?? "unknown";
     return { messageId };
   }
-  /** Poll for new messages mentioning this agent. Returns empty array on HTTP error. */
+  /** Poll for new messages for this agent. Returns empty array on HTTP error. */
   async poll(options) {
     this.ensureConnected();
     const params = new URLSearchParams();
-    params.set("mentioned", this.state.agentId);
     if (options?.limit) params.set("limit", String(options.limit));
     if (options?.since) params.set("since", options.since);
     const response = await this.fetchWithFallback(`/messages/peek?${params}`, {
@@ -31806,14 +31661,16 @@ var SseTransport = class {
 
 // packages/core/src/conduit/factory.ts
 function resolveTransport(credential) {
+  const isCloudBacked = credential.apiBaseUrl && credential.apiBaseUrl !== "local" && credential.apiBaseUrl.startsWith("http");
+  if (isCloudBacked) {
+    if (credential.transportConfig.sseEndpoint) {
+      return new SseTransport();
+    }
+    return new HttpTransport();
+  }
   if (LocalTransport.isAvailable()) {
     return new LocalTransport();
   }
-  if (credential.transportConfig.wsUrl) {
-  }
-  if (credential.transportConfig.sseEndpoint) {
-    return new SseTransport();
-  }
   return new HttpTransport();
 }
 async function createConduit(registry2, agentId) {
@@ -31976,8 +31833,6 @@ __export(hooks_exports, {
   handleFileChange: () => handleFileChange,
   handlePostCompact: () => handlePostCompact,
   handlePreCompact: () => handlePreCompact,
-  handlePromptSubmit: () => handlePromptSubmit,
-  handleResponseComplete: () => handleResponseComplete,
   handleSessionEnd: () => handleSessionEnd,
   handleSessionStart: () => handleSessionStart,
   handleSubagentStart: () => handleSubagentStart,
@@ -46642,9 +46497,6 @@ async function listEpicsWithLifecycle(cwd) {
   }
 }
 
-// packages/core/src/index.ts
-init_mcp();
-
 // packages/core/src/memory/index.ts
 var memory_exports = {};
 __export(memory_exports, {
@@ -46713,8 +46565,8 @@ init_paths();
 init_atomic();
 init_json2();
 init_add();
-import { existsSync as existsSync44, readFileSync as readFileSync29 } from "node:fs";
-import { join as join49, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync44, readFileSync as readFileSync28 } from "node:fs";
+import { join as join48, resolve as resolve6 } from "node:path";
 
 // packages/core/src/memory/brain-lifecycle.ts
 init_brain_accessor();
@@ -46944,13 +46796,13 @@ init_brain_links();
 
 // packages/core/src/memory/brain-migration.ts
 init_brain_accessor();
-import { existsSync as existsSync43, readFileSync as readFileSync28 } from "node:fs";
-import { join as join48 } from "node:path";
+import { existsSync as existsSync43, readFileSync as readFileSync27 } from "node:fs";
+import { join as join47 } from "node:path";
 function readJsonlFile(filePath) {
   if (!existsSync43(filePath)) {
     return { entries: [], errors: [] };
   }
-  const content = readFileSync28(filePath, "utf-8").trim();
+  const content = readFileSync27(filePath, "utf-8").trim();
   if (!content) {
     return { entries: [], errors: [] };
   }
@@ -46975,7 +46827,7 @@ async function migrateBrainData(projectRoot) {
     duplicatesSkipped: 0,
     errors: []
   };
-  const patternsPath = join48(projectRoot, ".cleo", "memory", "patterns.jsonl");
+  const patternsPath = join47(projectRoot, ".cleo", "memory", "patterns.jsonl");
   const { entries: patterns, errors: patternErrors } = readJsonlFile(patternsPath);
   result.errors.push(...patternErrors);
   for (const p of patterns) {
@@ -47005,7 +46857,7 @@ async function migrateBrainData(projectRoot) {
       result.errors.push(`Pattern ${p.id}: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
-  const learningsPath = join48(projectRoot, ".cleo", "memory", "learnings.jsonl");
+  const learningsPath = join47(projectRoot, ".cleo", "memory", "learnings.jsonl");
   const { entries: learnings, errors: learningErrors } = readJsonlFile(learningsPath);
   result.errors.push(...learningErrors);
   for (const l of learnings) {
@@ -47057,7 +46909,7 @@ init_decisions2();
 init_learnings();
 init_patterns();
 function getResearchPath(cwd) {
-  return join49(getCleoDirAbsolute(cwd), "research.json");
+  return join48(getCleoDirAbsolute(cwd), "research.json");
 }
 function getManifestPath2(cwd) {
   return getManifestPath(cwd);
@@ -47278,7 +47130,7 @@ async function showManifestEntry(researchId, cwd) {
   try {
     const filePath = resolve6(root, entry.file);
     if (existsSync44(filePath)) {
-      fileContent = readFileSync29(filePath, "utf-8");
+      fileContent = readFileSync28(filePath, "utf-8");
     }
   } catch {
   }
@@ -47524,7 +47376,7 @@ async function readProtocolInjection(protocolType, params, cwd) {
   for (const loc of protocolLocations) {
     if (existsSync44(loc)) {
       try {
-        protocolContent = readFileSync29(loc, "utf-8");
+        protocolContent = readFileSync28(loc, "utf-8");
         protocolPath = loc.replace(root + "/", "");
         break;
       } catch {
@@ -47711,28 +47563,28 @@ __export(metrics_exports, {
 init_paths();
 import { appendFileSync as appendFileSync5, existsSync as existsSync47 } from "node:fs";
 import { mkdir as mkdir9 } from "node:fs/promises";
-import { join as join52 } from "node:path";
+import { join as join51 } from "node:path";
 
 // packages/core/src/metrics/common.ts
 init_paths();
-import { existsSync as existsSync45, readFileSync as readFileSync30 } from "node:fs";
+import { existsSync as existsSync45, readFileSync as readFileSync29 } from "node:fs";
 import { mkdir as mkdir7 } from "node:fs/promises";
-import { join as join50 } from "node:path";
+import { join as join49 } from "node:path";
 async function ensureMetricsDir(metricsDir) {
-  const dir = metricsDir ?? join50(getCleoDir(), "metrics");
+  const dir = metricsDir ?? join49(getCleoDir(), "metrics");
   if (!existsSync45(dir)) {
     await mkdir7(dir, { recursive: true });
   }
   return dir;
 }
 function getCompliancePath(metricsDir) {
-  return join50(metricsDir ?? join50(getCleoDir(), "metrics"), "COMPLIANCE.jsonl");
+  return join49(metricsDir ?? join49(getCleoDir(), "metrics"), "COMPLIANCE.jsonl");
 }
 function getViolationsPath(metricsDir) {
-  return join50(metricsDir ?? join50(getCleoDir(), "metrics"), "PROTOCOL_VIOLATIONS.jsonl");
+  return join49(metricsDir ?? join49(getCleoDir(), "metrics"), "PROTOCOL_VIOLATIONS.jsonl");
 }
 function getSessionsMetricsPath(metricsDir) {
-  return join50(metricsDir ?? join50(getCleoDir(), "metrics"), "SESSIONS.jsonl");
+  return join49(metricsDir ?? join49(getCleoDir(), "metrics"), "SESSIONS.jsonl");
 }
 function isoTimestamp() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
@@ -47742,7 +47594,7 @@ function isoDate() {
 }
 function readJsonlFile2(filePath) {
   if (!existsSync45(filePath)) return [];
-  const content = readFileSync30(filePath, "utf-8").trim();
+  const content = readFileSync29(filePath, "utf-8").trim();
   if (!content) return [];
   return content.split("\n").filter((line2) => line2.trim()).map((line2) => JSON.parse(line2));
 }
@@ -47763,14 +47615,14 @@ function getComplianceSummaryBase(compliancePath) {
 
 // packages/core/src/metrics/otel-integration.ts
 init_paths();
-import { appendFileSync as appendFileSync4, existsSync as existsSync46, readdirSync as readdirSync20, readFileSync as readFileSync31, statSync as statSync9 } from "node:fs";
+import { appendFileSync as appendFileSync4, existsSync as existsSync46, readdirSync as readdirSync20, readFileSync as readFileSync30, statSync as statSync9 } from "node:fs";
 import { mkdir as mkdir8 } from "node:fs/promises";
-import { join as join51 } from "node:path";
+import { join as join50 } from "node:path";
 function getOtelDir(cwd) {
-  return process.env.OTEL_METRICS_DIR ?? join51(getCleoDir(cwd), "metrics", "otel");
+  return process.env.OTEL_METRICS_DIR ?? join50(getCleoDir(cwd), "metrics", "otel");
 }
 function getTokenMetricsPath(cwd) {
-  return join51(getOtelDir(cwd), "token_metrics.jsonl");
+  return join50(getOtelDir(cwd), "token_metrics.jsonl");
 }
 function isOtelEnabled() {
   return process.env.CLAUDE_CODE_ENABLE_TELEMETRY === "1";
@@ -47801,7 +47653,7 @@ function getOtelSetupCommands(mode = "file", cwd) {
 function findLatestMetricsFile(cwd) {
   const otelDir = getOtelDir(cwd);
   if (!existsSync46(otelDir)) return null;
-  const files = readdirSync20(otelDir).filter((f) => f.endsWith(".json")).map((f) => join51(otelDir, f)).filter((f) => {
+  const files = readdirSync20(otelDir).filter((f) => f.endsWith(".json")).map((f) => join50(otelDir, f)).filter((f) => {
     try {
       return statSync9(f).isFile();
     } catch {
@@ -47814,7 +47666,7 @@ function parseTokenMetrics(inputFile, cwd) {
   const file2 = inputFile ?? findLatestMetricsFile(cwd);
   if (!file2 || !existsSync46(file2)) return [];
   try {
-    const raw = JSON.parse(readFileSync31(file2, "utf-8"));
+    const raw = JSON.parse(readFileSync30(file2, "utf-8"));
     if (raw.resourceMetrics) {
       const points = [];
       for (const rm3 of raw.resourceMetrics ?? []) {
@@ -47898,7 +47750,7 @@ async function recordSessionEnd(sessionId, cwd) {
   let deltaInput = 0;
   let deltaOutput = 0;
   if (existsSync46(metricsPath)) {
-    const lines = readFileSync31(metricsPath, "utf-8").trim().split("\n").filter(Boolean);
+    const lines = readFileSync30(metricsPath, "utf-8").trim().split("\n").filter(Boolean);
     const startLine = lines.reverse().find((l) => l.includes(`"session_id":"${sessionId}"`) && l.includes("session_start"));
     if (startLine) {
       const startData = JSON.parse(startLine);
@@ -47925,7 +47777,7 @@ function compareSessions(sessionA, sessionB, cwd) {
   if (!existsSync46(metricsPath)) {
     return { error: "One or both sessions not found" };
   }
-  const lines = readFileSync31(metricsPath, "utf-8").trim().split("\n").filter(Boolean);
+  const lines = readFileSync30(metricsPath, "utf-8").trim().split("\n").filter(Boolean);
   const findSessionEnd = (id) => {
     const line2 = lines.reverse().find((l) => l.includes(`"session_id":"${id}"`) && l.includes("session_end"));
     if (!line2) return 0;
@@ -47960,7 +47812,7 @@ function getTokenStats(cwd) {
   if (!existsSync46(metricsPath)) {
     return { error: "No token metrics recorded" };
   }
-  const lines = readFileSync31(metricsPath, "utf-8").trim().split("\n").filter(Boolean);
+  const lines = readFileSync30(metricsPath, "utf-8").trim().split("\n").filter(Boolean);
   const endEvents = lines.filter((l) => l.includes("session_end"));
   if (endEvents.length === 0) {
     return { sessions: 0, avg_tokens: 0, min_tokens: 0, max_tokens: 0 };
@@ -47987,10 +47839,10 @@ function getTokenStats(cwd) {
 // packages/core/src/metrics/ab-test.ts
 var currentTest = null;
 function getABMetricsDir(cwd) {
-  return process.env.AB_TEST_METRICS_DIR ?? join52(getCleoDir(cwd), "metrics", "ab-tests");
+  return process.env.AB_TEST_METRICS_DIR ?? join51(getCleoDir(cwd), "metrics", "ab-tests");
 }
 function getABMetricsFile(cwd) {
-  return join52(getABMetricsDir(cwd), "AB_TESTS.jsonl");
+  return join51(getABMetricsDir(cwd), "AB_TESTS.jsonl");
 }
 async function logABEvent(eventType, testName, variant, context, cwd) {
   const dir = getABMetricsDir(cwd);
@@ -48049,7 +47901,7 @@ async function endABTest(options = {}, cwd) {
     totalTokens = endTokenData.tokens.total - currentTest.startTokens;
     tokenSource = "otel";
   } else {
-    const tokenFile = join52(getCleoDir(cwd), "metrics", "TOKEN_USAGE.jsonl");
+    const tokenFile = join51(getCleoDir(cwd), "metrics", "TOKEN_USAGE.jsonl");
     if (existsSync47(tokenFile)) {
       const entries = readJsonlFile2(tokenFile);
       totalTokens = entries.filter((e) => e.session_id === currentTest.testName).reduce((sum, e) => sum + (e.estimated_tokens ?? 0), 0);
@@ -48214,15 +48066,15 @@ init_paths();
 import { execFileSync as execFileSync6 } from "node:child_process";
 import { appendFileSync as appendFileSync6, existsSync as existsSync48 } from "node:fs";
 import { mkdir as mkdir10 } from "node:fs/promises";
-import { basename as basename7, join as join53 } from "node:path";
+import { basename as basename7, join as join52 } from "node:path";
 function getProjectMetricsDir(cwd) {
-  return join53(getCleoDir(cwd), "metrics");
+  return join52(getCleoDir(cwd), "metrics");
 }
 function getGlobalMetricsDir() {
-  return join53(getCleoHome(), "metrics");
+  return join52(getCleoHome(), "metrics");
 }
 function getGlobalPath() {
-  return join53(getGlobalMetricsDir(), "GLOBAL.jsonl");
+  return join52(getGlobalMetricsDir(), "GLOBAL.jsonl");
 }
 function getProjectName() {
   try {
@@ -48237,7 +48089,7 @@ function getProjectName() {
   return basename7(process.cwd());
 }
 async function syncMetricsToGlobal(options = {}, cwd) {
-  const projectPath = getCompliancePath(join53(getCleoDir(cwd), "metrics"));
+  const projectPath = getCompliancePath(join52(getCleoDir(cwd), "metrics"));
   if (!existsSync48(projectPath)) {
     return { success: true, result: { synced: 0, skipped: 0, reason: "No project metrics file" } };
   }
@@ -48278,7 +48130,7 @@ async function syncMetricsToGlobal(options = {}, cwd) {
   };
 }
 function getProjectComplianceSummary(options = {}, cwd) {
-  const projectPath = getCompliancePath(join53(getCleoDir(cwd), "metrics"));
+  const projectPath = getCompliancePath(join52(getCleoDir(cwd), "metrics"));
   const projectName = getProjectName();
   if (!existsSync48(projectPath)) {
     return {
@@ -48377,7 +48229,7 @@ function computeComplianceSummary(entries, projectName) {
   };
 }
 function getComplianceTrend2(days = 7, options = {}, cwd) {
-  const metricsPath = options.global ? getGlobalPath() : getCompliancePath(join53(getCleoDir(cwd), "metrics"));
+  const metricsPath = options.global ? getGlobalPath() : getCompliancePath(join52(getCleoDir(cwd), "metrics"));
   if (!existsSync48(metricsPath)) {
     return { success: true, result: { days, dataPoints: [], trend: "no_data" } };
   }
@@ -48409,7 +48261,7 @@ function getComplianceTrend2(days = 7, options = {}, cwd) {
   return { success: true, result: { days, dataPoints, trend } };
 }
 function getSkillReliability2(options = {}, cwd) {
-  const metricsPath = options.global ? getGlobalPath() : getCompliancePath(join53(getCleoDir(cwd), "metrics"));
+  const metricsPath = options.global ? getGlobalPath() : getCompliancePath(join52(getCleoDir(cwd), "metrics"));
   if (!existsSync48(metricsPath)) {
     return {
       success: true,
@@ -48448,7 +48300,7 @@ function getSkillReliability2(options = {}, cwd) {
 async function logSessionMetrics(metricsJson, cwd) {
   const metricsDir = getProjectMetricsDir(cwd);
   await mkdir10(metricsDir, { recursive: true });
-  const sessionsPath = getSessionsMetricsPath(join53(getCleoDir(cwd), "metrics"));
+  const sessionsPath = getSessionsMetricsPath(join52(getCleoDir(cwd), "metrics"));
   try {
     appendFileSync6(sessionsPath, JSON.stringify(metricsJson) + "\n");
   } catch {
@@ -48464,7 +48316,7 @@ async function logSessionMetrics(metricsJson, cwd) {
   };
 }
 function getSessionMetricsSummary(options = {}, cwd) {
-  const sessionsPath = getSessionsMetricsPath(join53(getCleoDir(cwd), "metrics"));
+  const sessionsPath = getSessionsMetricsPath(join52(getCleoDir(cwd), "metrics"));
   if (!existsSync48(sessionsPath)) {
     return {
       success: true,
@@ -48586,12 +48438,12 @@ function isValidEnumValue(enumObj, value) {
 
 // packages/core/src/metrics/token-estimation.ts
 init_paths();
-import { existsSync as existsSync49, readFileSync as readFileSync32, statSync as statSync10 } from "node:fs";
+import { existsSync as existsSync49, readFileSync as readFileSync31, statSync as statSync10 } from "node:fs";
 import { appendFile as appendFile2, mkdir as mkdir11 } from "node:fs/promises";
-import { dirname as dirname12, join as join54 } from "node:path";
+import { dirname as dirname12, join as join53 } from "node:path";
 var currentSession = null;
 function getTokenFilePath(cwd) {
-  return join54(getCleoDir(cwd), "metrics", "TOKEN_USAGE.jsonl");
+  return join53(getCleoDir(cwd), "metrics", "TOKEN_USAGE.jsonl");
 }
 function isTrackingEnabled() {
   return (process.env.CLEO_TRACK_TOKENS ?? "1") === "1";
@@ -48759,7 +48611,7 @@ function getTokenSummary(days = 7, cwd) {
   const threshold = /* @__PURE__ */ new Date();
   threshold.setDate(threshold.getDate() - days);
   const thresholdStr = threshold.toISOString();
-  const entries = readFileSync32(tokenFile, "utf-8").trim().split("\n").filter(Boolean);
+  const entries = readFileSync31(tokenFile, "utf-8").trim().split("\n").filter(Boolean);
   let manifestTokens = 0;
   let fullFileTokens = 0;
   let skillTokens = 0;
@@ -48871,12 +48723,12 @@ init_agent_outputs();
 
 // packages/core/src/migration/checksum.ts
 import { createHash as createHash5 } from "node:crypto";
-import { readFileSync as readFileSync34 } from "node:fs";
+import { readFileSync as readFileSync33 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
 var _require5 = createRequire5(import.meta.url);
 var { DatabaseSync: DatabaseSync3 } = _require5("node:sqlite");
 async function computeChecksum(filePath) {
-  const content = readFileSync34(filePath);
+  const content = readFileSync33(filePath);
   return createHash5("sha256").update(content).digest("hex");
 }
 async function verifyBackup(sourcePath, backupPath) {
@@ -48925,11 +48777,11 @@ import {
   existsSync as existsSync51,
   mkdirSync as mkdirSync13,
   readdirSync as readdirSync22,
-  readFileSync as readFileSync35,
+  readFileSync as readFileSync34,
   statSync as statSync12,
   unlinkSync as unlinkSync3
 } from "node:fs";
-import { dirname as dirname13, join as join56, relative as relative8 } from "node:path";
+import { dirname as dirname13, join as join55, relative as relative8 } from "node:path";
 var MigrationLogger = class {
   logPath;
   entries = [];
@@ -48949,7 +48801,7 @@ var MigrationLogger = class {
       consoleOutput: config2.consoleOutput ?? false
     };
     const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    this.logPath = join56(cleoDir, "logs", `migration-${timestamp2}.jsonl`);
+    this.logPath = join55(cleoDir, "logs", `migration-${timestamp2}.jsonl`);
     const logsDir = dirname13(this.logPath);
     if (!existsSync51(logsDir)) {
       mkdirSync13(logsDir, { recursive: true });
@@ -49119,14 +48971,14 @@ var MigrationLogger = class {
    */
   cleanupOldLogs() {
     try {
-      const logsDir = join56(this.cleoDir, "logs");
+      const logsDir = join55(this.cleoDir, "logs");
       if (!existsSync51(logsDir)) {
         return;
       }
       const files = readdirSync22(logsDir).filter((f) => f.startsWith("migration-") && f.endsWith(".jsonl")).map((f) => ({
         name: f,
-        path: join56(logsDir, f),
-        mtime: statSync12(join56(logsDir, f)).mtime.getTime()
+        path: join55(logsDir, f),
+        mtime: statSync12(join55(logsDir, f)).mtime.getTime()
       })).sort((a, b) => b.mtime - a.mtime);
       const filesToRemove = files.slice(this.config.maxLogFiles);
       for (const file2 of filesToRemove) {
@@ -49204,7 +49056,7 @@ function createMigrationLogger(cleoDir, config2) {
   return new MigrationLogger(cleoDir, config2);
 }
 function readMigrationLog(logPath) {
-  const content = readFileSync35(logPath, "utf-8");
+  const content = readFileSync34(logPath, "utf-8");
   return content.split("\n").filter((line2) => line2.trim()).map((line2) => JSON.parse(line2));
 }
 function logFileExists(logPath) {
@@ -49217,14 +49069,14 @@ function logFileExists(logPath) {
 }
 function getLatestMigrationLog(cleoDir) {
   try {
-    const logsDir = join56(cleoDir, "logs");
+    const logsDir = join55(cleoDir, "logs");
     if (!existsSync51(logsDir)) {
       return null;
     }
     const files = readdirSync22(logsDir).filter((f) => f.startsWith("migration-") && f.endsWith(".jsonl")).map((f) => ({
       name: f,
-      path: join56(logsDir, f),
-      mtime: statSync12(join56(logsDir, f)).mtime.getTime()
+      path: join55(logsDir, f),
+      mtime: statSync12(join55(logsDir, f)).mtime.getTime()
     })).sort((a, b) => b.mtime - a.mtime);
     return files.length > 0 ? files[0].path : null;
   } catch {
@@ -49234,8 +49086,8 @@ function getLatestMigrationLog(cleoDir) {
 
 // packages/core/src/system/storage-preflight.ts
 init_paths();
-import { existsSync as existsSync52, readFileSync as readFileSync36, statSync as statSync13 } from "node:fs";
-import { join as join57 } from "node:path";
+import { existsSync as existsSync52, readFileSync as readFileSync35, statSync as statSync13 } from "node:fs";
+import { join as join56 } from "node:path";
 function checkStorageMigration(cwd) {
   const cleoDir = getCleoDirAbsolute(cwd);
   const details = {
@@ -49249,42 +49101,42 @@ function checkStorageMigration(cwd) {
     tasksDbSize: 0,
     configEngine: null
   };
-  const configPath = join57(cleoDir, "config.json");
+  const configPath = join56(cleoDir, "config.json");
   if (existsSync52(configPath)) {
     try {
-      const config2 = JSON.parse(readFileSync36(configPath, "utf-8"));
+      const config2 = JSON.parse(readFileSync35(configPath, "utf-8"));
       details.configEngine = config2?.storage?.engine ?? null;
     } catch {
     }
   }
-  const todoPath = join57(cleoDir, "todo.json");
+  const todoPath = join56(cleoDir, "todo.json");
   if (existsSync52(todoPath)) {
     details.todoJsonExists = true;
     try {
-      const data = JSON.parse(readFileSync36(todoPath, "utf-8"));
+      const data = JSON.parse(readFileSync35(todoPath, "utf-8"));
       details.todoJsonTaskCount = (data.tasks ?? []).length;
     } catch {
     }
   }
-  const archivePath = join57(cleoDir, "todo-archive.json");
+  const archivePath = join56(cleoDir, "todo-archive.json");
   if (existsSync52(archivePath)) {
     details.archiveJsonExists = true;
     try {
-      const data = JSON.parse(readFileSync36(archivePath, "utf-8"));
+      const data = JSON.parse(readFileSync35(archivePath, "utf-8"));
       details.archiveJsonTaskCount = (data.tasks ?? data.archivedTasks ?? []).length;
     } catch {
     }
   }
-  const sessionsPath = join57(cleoDir, "sessions.json");
+  const sessionsPath = join56(cleoDir, "sessions.json");
   if (existsSync52(sessionsPath)) {
     details.sessionsJsonExists = true;
     try {
-      const data = JSON.parse(readFileSync36(sessionsPath, "utf-8"));
+      const data = JSON.parse(readFileSync35(sessionsPath, "utf-8"));
       details.sessionsJsonCount = (data.sessions ?? []).length;
     } catch {
     }
   }
-  const dbPath = join57(cleoDir, "tasks.db");
+  const dbPath = join56(cleoDir, "tasks.db");
   if (existsSync52(dbPath)) {
     details.tasksDbExists = true;
     try {
@@ -49325,7 +49177,7 @@ function checkStorageMigration(cwd) {
 import { createHash as createHash6 } from "node:crypto";
 import { existsSync as existsSync53 } from "node:fs";
 import { readFile as readFile9, unlink as unlink3, writeFile as writeFile8 } from "node:fs/promises";
-import { join as join58 } from "node:path";
+import { join as join57 } from "node:path";
 var STATE_FILENAME = ".migration-state.json";
 async function computeFileChecksum(filePath) {
   try {
@@ -49347,7 +49199,7 @@ async function countRecords(filePath, key) {
 async function createMigrationState(cleoDir, sourceFiles) {
   const files = sourceFiles ?? {};
   if (!files.todoJson) {
-    const todoPath = join58(cleoDir, "todo.json");
+    const todoPath = join57(cleoDir, "todo.json");
     if (existsSync53(todoPath)) {
       files.todoJson = {
         path: todoPath,
@@ -49357,7 +49209,7 @@ async function createMigrationState(cleoDir, sourceFiles) {
     }
   }
   if (!files.sessionsJson) {
-    const sessionsPath = join58(cleoDir, "sessions.json");
+    const sessionsPath = join57(cleoDir, "sessions.json");
     if (existsSync53(sessionsPath)) {
       files.sessionsJson = {
         path: sessionsPath,
@@ -49367,7 +49219,7 @@ async function createMigrationState(cleoDir, sourceFiles) {
     }
   }
   if (!files.archiveJson) {
-    const archivePath = join58(cleoDir, "todo-archive.json");
+    const archivePath = join57(cleoDir, "todo-archive.json");
     if (existsSync53(archivePath)) {
       files.archiveJson = {
         path: archivePath,
@@ -49396,7 +49248,7 @@ async function createMigrationState(cleoDir, sourceFiles) {
   return state;
 }
 async function writeMigrationState(cleoDir, state) {
-  const statePath = join58(cleoDir, STATE_FILENAME);
+  const statePath = join57(cleoDir, STATE_FILENAME);
   const tempPath = `${statePath}.tmp`;
   await writeFile8(tempPath, JSON.stringify(state, null, 2));
   await writeFile8(statePath, await readFile9(tempPath));
@@ -49471,7 +49323,7 @@ async function addMigrationWarning(cleoDir, warning) {
 }
 async function loadMigrationState(cleoDir) {
   try {
-    const statePath = join58(cleoDir, STATE_FILENAME);
+    const statePath = join57(cleoDir, STATE_FILENAME);
     const content = await readFile9(statePath, "utf-8");
     return JSON.parse(content);
   } catch {
@@ -49513,7 +49365,7 @@ async function failMigration(cleoDir, error40) {
 }
 async function clearMigrationState(cleoDir) {
   try {
-    const statePath = join58(cleoDir, STATE_FILENAME);
+    const statePath = join57(cleoDir, STATE_FILENAME);
     await unlink3(statePath);
   } catch {
   }
@@ -49574,8 +49426,8 @@ async function verifySourceIntegrity(cleoDir) {
 }
 
 // packages/core/src/migration/validate.ts
-import { existsSync as existsSync54, readFileSync as readFileSync37, statSync as statSync14 } from "node:fs";
-import { join as join59 } from "node:path";
+import { existsSync as existsSync54, readFileSync as readFileSync36, statSync as statSync14 } from "node:fs";
+import { join as join58 } from "node:path";
 function parseJsonError(error40) {
   const message = String(error40);
   const lineMatch = message.match(/line\s+(\d+)/i);
@@ -49603,7 +49455,7 @@ function validateJsonFile(filePath, countExtractor) {
       result.error = "File is empty (0 bytes)";
       return result;
     }
-    const content = readFileSync37(filePath, "utf-8");
+    const content = readFileSync36(filePath, "utf-8");
     if (content.trim().length === 0) {
       result.error = "File contains only whitespace";
       return result;
@@ -49621,7 +49473,7 @@ function validateJsonFile(filePath, countExtractor) {
 }
 function validateSourceFiles(cleoDir) {
   const warnings = [];
-  const todoPath = join59(cleoDir, "todo.json");
+  const todoPath = join58(cleoDir, "todo.json");
   const todoJson = validateJsonFile(todoPath, (data) => {
     const record2 = data;
     return Array.isArray(record2.tasks) ? record2.tasks.length : 0;
@@ -49633,7 +49485,7 @@ function validateSourceFiles(cleoDir) {
     const location = todoJson.line ? ` at line ${todoJson.line}${todoJson.column ? `, column ${todoJson.column}` : ""}` : "";
     todoJson.error = `${todoJson.error}${location} in ${todoPath}`;
   }
-  const sessionsPath = join59(cleoDir, "sessions.json");
+  const sessionsPath = join58(cleoDir, "sessions.json");
   const sessionsJson = validateJsonFile(sessionsPath, (data) => {
     const record2 = data;
     return Array.isArray(record2.sessions) ? record2.sessions.length : 0;
@@ -49645,7 +49497,7 @@ function validateSourceFiles(cleoDir) {
     const location = sessionsJson.line ? ` at line ${sessionsJson.line}${sessionsJson.column ? `, column ${sessionsJson.column}` : ""}` : "";
     sessionsJson.error = `${sessionsJson.error}${location} in ${sessionsPath}`;
   }
-  const archivePath = join59(cleoDir, "todo-archive.json");
+  const archivePath = join58(cleoDir, "todo-archive.json");
   const archiveJson = validateJsonFile(archivePath, (data) => {
     const record2 = data;
     const tasks2 = Array.isArray(record2.tasks) ? record2.tasks : [];
@@ -49717,7 +49569,7 @@ Total tasks to migrate: ${result.totalTasks}`);
   return lines.join("\n");
 }
 function checkTaskCountMismatch(cleoDir, jsonTaskCount) {
-  const dbPath = join59(cleoDir, "tasks.db");
+  const dbPath = join58(cleoDir, "tasks.db");
   if (!existsSync54(dbPath)) {
     return null;
   }
@@ -49739,7 +49591,7 @@ init_src();
 init_errors3();
 init_paths();
 init_json2();
-import { join as join60 } from "node:path";
+import { join as join59 } from "node:path";
 var TARGET_VERSIONS = {
   todo: "2.10.0",
   config: "2.0.0",
@@ -49869,7 +49721,7 @@ async function getMigrationStatus(cwd) {
   } catch {
   }
   try {
-    const archivePath = join60(getCleoDirAbsolute(cwd), "todo-archive.json");
+    const archivePath = join59(getCleoDirAbsolute(cwd), "todo-archive.json");
     const archiveData = await readJson(archivePath);
     if (archiveData) {
       const current = detectVersion(archiveData);
@@ -49888,7 +49740,7 @@ async function runMigration(fileType, options = {}, cwd) {
   const filePaths = {
     todo: getTaskPath(cwd),
     config: getConfigPath(cwd),
-    archive: join60(getCleoDirAbsolute(cwd), "todo-archive.json")
+    archive: join59(getCleoDirAbsolute(cwd), "todo-archive.json")
   };
   const filePath = filePaths[fileType];
   if (!filePath) {
@@ -50085,8 +49937,8 @@ init_src();
 init_errors3();
 init_data_accessor();
 init_registry3();
-import { existsSync as existsSync56, readFileSync as readFileSync39 } from "node:fs";
-import { basename as basename9, join as join63 } from "node:path";
+import { existsSync as existsSync56, readFileSync as readFileSync38 } from "node:fs";
+import { basename as basename9, join as join62 } from "node:path";
 var TASK_ID_RE = /^T\d{3,}$/;
 var QUALIFIED_RE = /^([a-z0-9_-]+|\.|\*):T\d{3,}$/;
 function validateSyntax(query) {
@@ -50123,9 +49975,9 @@ function getCurrentProject() {
     return process.env["NEXUS_CURRENT_PROJECT"];
   }
   try {
-    const infoPath = join63(process.cwd(), ".cleo", "project-info.json");
+    const infoPath = join62(process.cwd(), ".cleo", "project-info.json");
     if (existsSync56(infoPath)) {
-      const data = JSON.parse(readFileSync39(infoPath, "utf-8"));
+      const data = JSON.parse(readFileSync38(infoPath, "utf-8"));
       if (typeof data.name === "string" && data.name.length > 0) {
         return data.name;
       }
@@ -50162,7 +50014,7 @@ async function resolveProjectPath2(projectName) {
   return project.path;
 }
 async function readProjectTasks(projectPath) {
-  const tasksDbPath = join63(projectPath, ".cleo", "tasks.db");
+  const tasksDbPath = join62(projectPath, ".cleo", "tasks.db");
   try {
     const accessor = await getAccessor(projectPath);
     const { tasks: tasks2 } = await accessor.queryTasks({});
@@ -50766,7 +50618,7 @@ init_paths();
 init_git_checkpoint();
 import { existsSync as existsSync57, readdirSync as readdirSync23, statSync as statSync15 } from "node:fs";
 import { readFile as readFile10, writeFile as writeFile9 } from "node:fs/promises";
-import { join as join64, relative as relative9 } from "node:path";
+import { join as join63, relative as relative9 } from "node:path";
 var GITIGNORE_START = "# CLEO:SHARING:START - Auto-managed by cleo sharing sync";
 var GITIGNORE_END = "# CLEO:SHARING:END";
 function matchesPattern(filePath, pattern) {
@@ -50794,7 +50646,7 @@ function collectCleoFiles(cleoDir) {
     const entries = readdirSync23(dir);
     for (const entry of entries) {
       if (entry === ".git") continue;
-      const fullPath = join64(dir, entry);
+      const fullPath = join63(dir, entry);
       const relPath = relative9(cleoDir, fullPath);
       try {
         const stat2 = statSync15(fullPath);
@@ -50893,7 +50745,7 @@ function generateGitignoreEntries(sharing) {
 async function syncGitignore(cwd) {
   const config2 = await loadConfig(cwd);
   const projectRoot = getProjectRoot(cwd);
-  const gitignorePath = join64(projectRoot, ".gitignore");
+  const gitignorePath = join63(projectRoot, ".gitignore");
   const entries = generateGitignoreEntries(config2.sharing);
   const managedSection = ["", GITIGNORE_START, ...entries, GITIGNORE_END, ""].join("\n");
   let content = "";
@@ -51642,8 +51494,8 @@ function parseLogLines(lines) {
 // packages/core/src/observability/log-reader.ts
 init_logger();
 init_paths();
-import { createReadStream, existsSync as existsSync58, readdirSync as readdirSync24, readFileSync as readFileSync40, statSync as statSync16 } from "node:fs";
-import { join as join65 } from "node:path";
+import { createReadStream, existsSync as existsSync58, readdirSync as readdirSync24, readFileSync as readFileSync39, statSync as statSync16 } from "node:fs";
+import { join as join64 } from "node:path";
 import { createInterface } from "node:readline";
 var CLEO_LOG_PATTERN = /^cleo\.(\d{4}-\d{2}-\d{2})\.(\d+)\.log$/;
 var MIGRATION_LOG_PATTERN = /^migration-.*\.jsonl$/;
@@ -51651,11 +51503,11 @@ function getProjectLogDir(cwd) {
   const runtimeDir = getLogDir();
   if (runtimeDir) return runtimeDir;
   const cleoDir = getCleoDirAbsolute(cwd);
-  const logsDir = join65(cleoDir, "logs");
+  const logsDir = join64(cleoDir, "logs");
   return existsSync58(logsDir) ? logsDir : null;
 }
 function getGlobalLogDir() {
-  return join65(getCleoHome(), "logs");
+  return join64(getCleoHome(), "logs");
 }
 function scanLogDir(dir, includeMigration) {
   if (!existsSync58(dir)) return [];
@@ -51670,7 +51522,7 @@ function scanLogDir(dir, includeMigration) {
     const cleoMatch = name2.match(CLEO_LOG_PATTERN);
     const isMigration = MIGRATION_LOG_PATTERN.test(name2);
     if (!cleoMatch && (!isMigration || !includeMigration)) continue;
-    const filePath = join65(dir, name2);
+    const filePath = join64(dir, name2);
     let stat2;
     try {
       stat2 = statSync16(filePath);
@@ -51714,7 +51566,7 @@ function discoverLogFiles(options, cwd) {
 function readLogFileLines(filePath) {
   let content;
   try {
-    content = readFileSync40(filePath, "utf-8");
+    content = readFileSync39(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -51981,14 +51833,14 @@ function analyzeDependencies(children, allTasks) {
 
 // packages/core/src/orchestration/context.ts
 init_paths();
-import { existsSync as existsSync59, readFileSync as readFileSync41 } from "node:fs";
+import { existsSync as existsSync59, readFileSync as readFileSync40 } from "node:fs";
 function countManifestEntries(projectRoot) {
   const manifestPath = getManifestPath(projectRoot);
   if (!existsSync59(manifestPath)) {
     return 0;
   }
   try {
-    const content = readFileSync41(manifestPath, "utf-8");
+    const content = readFileSync40(manifestPath, "utf-8");
     return content.split("\n").filter((l) => l.trim()).length;
   } catch {
     return 0;
@@ -52521,22 +52373,22 @@ __export(otel_exports, {
   getOtelSummary: () => getOtelSummary,
   getRealTokenUsage: () => getRealTokenUsage
 });
-import { copyFileSync as copyFileSync6, existsSync as existsSync60, readFileSync as readFileSync42, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join66 } from "node:path";
+import { copyFileSync as copyFileSync6, existsSync as existsSync60, readFileSync as readFileSync41, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join65 } from "node:path";
 function getProjectRoot2() {
   let dir = process.cwd();
   while (dir !== "/") {
-    if (existsSync60(join66(dir, ".cleo", "config.json"))) return dir;
-    dir = join66(dir, "..");
+    if (existsSync60(join65(dir, ".cleo", "config.json"))) return dir;
+    dir = join65(dir, "..");
   }
   return process.cwd();
 }
 function getTokenFilePath2() {
-  return join66(getProjectRoot2(), ".cleo", "metrics", "TOKEN_USAGE.jsonl");
+  return join65(getProjectRoot2(), ".cleo", "metrics", "TOKEN_USAGE.jsonl");
 }
 function readJsonlFile3(filePath) {
   if (!existsSync60(filePath)) return [];
-  const content = readFileSync42(filePath, "utf-8").trim();
+  const content = readFileSync41(filePath, "utf-8").trim();
   if (!content) return [];
   return content.split("\n").map((line2) => JSON.parse(line2));
 }
@@ -53397,7 +53249,7 @@ __export(release_exports, {
 
 // packages/core/src/release/artifacts.ts
 import { execFile as execFile4 } from "node:child_process";
-import { existsSync as existsSync61, readFileSync as readFileSync43 } from "node:fs";
+import { existsSync as existsSync61, readFileSync as readFileSync42 } from "node:fs";
 import { promisify as promisify4 } from "node:util";
 var execFileAsync4 = promisify4(execFile4);
 async function commandExists(cmd) {
@@ -53466,7 +53318,7 @@ var npmPackageHandler = {
       return { success: false, output: `package.json not found: ${packageFile}`, dryRun: false };
     }
     try {
-      const content = JSON.parse(readFileSync43(packageFile, "utf-8"));
+      const content = JSON.parse(readFileSync42(packageFile, "utf-8"));
       const requiredFields = ["name", "version", "description", "license"];
       const missing = requiredFields.filter((f) => !content[f]);
       if (missing.length > 0) {
@@ -53547,7 +53399,7 @@ var goModuleHandler = {
     if (!await commandExists("go")) {
       return { success: false, output: "go command not found", dryRun: false };
     }
-    const content = readFileSync43(packageFile, "utf-8");
+    const content = readFileSync42(packageFile, "utf-8");
     const moduleMatch = content.match(/^module\s+(\S+)/m);
     if (!moduleMatch) {
       return { success: false, output: "Module path not found in go.mod", dryRun: false };
@@ -53578,7 +53430,7 @@ var cargoCrateHandler = {
     if (!await commandExists("cargo")) {
       return { success: false, output: "cargo command not found", dryRun: false };
     }
-    const content = readFileSync43(packageFile, "utf-8");
+    const content = readFileSync42(packageFile, "utf-8");
     if (!content.includes("[package]")) {
       return { success: false, output: "[package] section not found in Cargo.toml", dryRun: false };
     }
@@ -53937,18 +53789,18 @@ function describeChannel(channel) {
 }
 
 // packages/core/src/release/ci.ts
-import { existsSync as existsSync64, mkdirSync as mkdirSync14, readFileSync as readFileSync45, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname14, join as join68 } from "node:path";
+import { existsSync as existsSync64, mkdirSync as mkdirSync14, readFileSync as readFileSync44, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname14, join as join67 } from "node:path";
 
 // packages/core/src/release/release-config.ts
 init_paths();
-import { existsSync as existsSync63, readFileSync as readFileSync44 } from "node:fs";
-import { join as join67 } from "node:path";
+import { existsSync as existsSync63, readFileSync as readFileSync43 } from "node:fs";
+import { join as join66 } from "node:path";
 function readConfigValueSync2(path2, defaultValue, cwd) {
   try {
-    const configPath = join67(getCleoDir(cwd), "config.json");
+    const configPath = join66(getCleoDir(cwd), "config.json");
     if (!existsSync63(configPath)) return defaultValue;
-    const config2 = JSON.parse(readFileSync44(configPath, "utf-8"));
+    const config2 = JSON.parse(readFileSync43(configPath, "utf-8"));
     const keys = path2.split(".");
     let value = config2;
     for (const key of keys) {
@@ -54110,9 +53962,9 @@ function getPlatformPath(platform5) {
 }
 function detectCIPlatform(projectDir) {
   const dir = projectDir ?? process.cwd();
-  if (existsSync64(join68(dir, ".github"))) return "github-actions";
-  if (existsSync64(join68(dir, ".gitlab-ci.yml"))) return "gitlab-ci";
-  if (existsSync64(join68(dir, ".circleci"))) return "circleci";
+  if (existsSync64(join67(dir, ".github"))) return "github-actions";
+  if (existsSync64(join67(dir, ".gitlab-ci.yml"))) return "gitlab-ci";
+  if (existsSync64(join67(dir, ".circleci"))) return "circleci";
   return null;
 }
 function generateGitHubActions(config2) {
@@ -54214,7 +54066,7 @@ function generateCIConfig(platform5, cwd) {
 }
 function writeCIConfig(platform5, options = {}) {
   const projectDir = options.projectDir ?? process.cwd();
-  const outputPath = join68(projectDir, getPlatformPath(platform5));
+  const outputPath = join67(projectDir, getPlatformPath(platform5));
   const content = generateCIConfig(platform5, projectDir);
   if (options.dryRun) {
     return { action: "would_write", path: outputPath, content };
@@ -54225,13 +54077,13 @@ function writeCIConfig(platform5, options = {}) {
 }
 function validateCIConfig(platform5, projectDir) {
   const dir = projectDir ?? process.cwd();
-  const configPath = join68(dir, getPlatformPath(platform5));
+  const configPath = join67(dir, getPlatformPath(platform5));
   if (!existsSync64(configPath)) {
     return { valid: false, exists: false, errors: ["Config file not found"] };
   }
   const errors = [];
   try {
-    const content = readFileSync45(configPath, "utf-8");
+    const content = readFileSync44(configPath, "utf-8");
     if (!content.trim()) errors.push("Config file is empty");
   } catch (err) {
     errors.push(`Cannot read config: ${String(err)}`);
@@ -54483,7 +54335,7 @@ function checkDoubleListing(releaseTaskIds, existingReleases) {
 import { execFileSync as execFileSync8 } from "node:child_process";
 import { existsSync as existsSync66, renameSync as renameSync5 } from "node:fs";
 import { readFile as readFile12 } from "node:fs/promises";
-import { join as join70 } from "node:path";
+import { join as join69 } from "node:path";
 import { and as and9, count, desc as desc4, eq as eq12 } from "drizzle-orm";
 init_paths();
 init_tasks_schema();
@@ -54492,13 +54344,13 @@ init_tasks_schema();
 init_src();
 init_errors3();
 init_paths();
-import { existsSync as existsSync65, readFileSync as readFileSync46, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join69 } from "node:path";
+import { existsSync as existsSync65, readFileSync as readFileSync45, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join68 } from "node:path";
 function readConfigValueSync3(path2, defaultValue, cwd) {
   try {
-    const configPath = join69(getCleoDir(cwd), "config.json");
+    const configPath = join68(getCleoDir(cwd), "config.json");
     if (!existsSync65(configPath)) return defaultValue;
-    const config2 = JSON.parse(readFileSync46(configPath, "utf-8"));
+    const config2 = JSON.parse(readFileSync45(configPath, "utf-8"));
     const keys = path2.split(".");
     let value = config2;
     for (const key of keys) {
@@ -54593,7 +54445,7 @@ function isVersionBumpConfigured(cwd) {
   return getVersionBumpConfig(cwd).length > 0;
 }
 function bumpFile(target, newVersion, projectRoot) {
-  const filePath = join69(projectRoot, target.file);
+  const filePath = join68(projectRoot, target.file);
   if (!existsSync65(filePath)) {
     return {
       file: target.file,
@@ -54603,7 +54455,7 @@ function bumpFile(target, newVersion, projectRoot) {
     };
   }
   try {
-    const content = readFileSync46(filePath, "utf-8");
+    const content = readFileSync45(filePath, "utf-8");
     let previousVersion;
     let newContent;
     switch (target.strategy) {
@@ -54974,7 +54826,7 @@ async function generateReleaseChangelog(version2, loadTasksFn, cwd) {
   }
   const changelog = sections.join("\n");
   await db.update(releaseManifests).set({ changelog }).where(eq12(releaseManifests.version, normalizedVersion)).run();
-  const changelogPath = join70(cwd ?? process.cwd(), "CHANGELOG.md");
+  const changelogPath = join69(cwd ?? process.cwd(), "CHANGELOG.md");
   let existingChangelogContent = "";
   try {
     existingChangelogContent = await readFile12(changelogPath, "utf8");
@@ -55130,10 +54982,10 @@ async function runReleaseGates(version2, loadTasksFn, cwd, opts) {
     message: incompleteTasks.length === 0 ? "All tasks completed" : `${incompleteTasks.length} tasks not completed: ${incompleteTasks.join(", ")}`
   });
   const projectRoot = cwd ?? getProjectRoot();
-  const monorepoDist = join70(projectRoot, "packages", "cleo", "dist", "cli", "index.js");
-  const rootDist = join70(projectRoot, "dist", "cli", "index.js");
+  const monorepoDist = join69(projectRoot, "packages", "cleo", "dist", "cli", "index.js");
+  const rootDist = join69(projectRoot, "dist", "cli", "index.js");
   const distExists = existsSync66(monorepoDist) || existsSync66(rootDist);
-  const isNodeProject = existsSync66(join70(projectRoot, "package.json"));
+  const isNodeProject = existsSync66(join69(projectRoot, "package.json"));
   if (isNodeProject) {
     gates.push({
       name: "build_artifact",
@@ -55280,7 +55132,7 @@ async function rollbackRelease(version2, reason, cwd) {
   };
 }
 async function readPushPolicy(cwd) {
-  const configPath = join70(getCleoDirAbsolute(cwd), "config.json");
+  const configPath = join69(getCleoDirAbsolute(cwd), "config.json");
   let config2;
   try {
     const raw = await readFile12(configPath, "utf-8");
@@ -55384,7 +55236,7 @@ async function markReleasePushed(version2, pushedAt, cwd, provenance) {
   }).where(eq12(releaseManifests.version, normalizedVersion)).run();
 }
 async function migrateReleasesJsonToSqlite(projectRoot) {
-  const releasesPath = join70(getCleoDirAbsolute(projectRoot), "releases.json");
+  const releasesPath = join69(getCleoDirAbsolute(projectRoot), "releases.json");
   if (!existsSync66(releasesPath)) {
     return { migrated: 0 };
   }
@@ -55706,22 +55558,22 @@ __export(roadmap_exports, {
   getRoadmap: () => getRoadmap
 });
 init_data_accessor();
-import { existsSync as existsSync67, readFileSync as readFileSync47 } from "node:fs";
-import { join as join71 } from "node:path";
+import { existsSync as existsSync67, readFileSync as readFileSync46 } from "node:fs";
+import { join as join70 } from "node:path";
 async function getRoadmap(opts, accessor) {
   const acc = accessor ?? await getAccessor(opts.cwd);
   const { tasks: tasks2 } = await acc.queryTasks({});
-  const versionPath = join71(opts.cwd ?? process.cwd(), "VERSION");
-  const currentVersion = existsSync67(versionPath) ? readFileSync47(versionPath, "utf-8").trim() : "unknown";
+  const versionPath = join70(opts.cwd ?? process.cwd(), "VERSION");
+  const currentVersion = existsSync67(versionPath) ? readFileSync46(versionPath, "utf-8").trim() : "unknown";
   const childParentIds = new Set(tasks2.filter((t) => t.parentId).map((t) => t.parentId));
   const epics = tasks2.filter((t) => childParentIds.has(t.id));
   const pending = epics.filter((e) => e.status !== "done");
   const completed = epics.filter((e) => e.status === "done");
   const releaseHistory = [];
   if (opts.includeHistory) {
-    const changelogPath = join71(opts.cwd ?? process.cwd(), "CHANGELOG.md");
+    const changelogPath = join70(opts.cwd ?? process.cwd(), "CHANGELOG.md");
     if (existsSync67(changelogPath)) {
-      const content = readFileSync47(changelogPath, "utf-8");
+      const content = readFileSync46(changelogPath, "utf-8");
       const versionRegex = /^##\s+\[?v?(\d+\.\d+\.\d+[^\]]*)\]?\s*[-(]?\s*(\d{4}-\d{2}-\d{2})?/gm;
       for (const match of content.matchAll(versionRegex)) {
         releaseHistory.push({
@@ -55767,9 +55619,9 @@ __export(routing_exports, {
 var CAPABILITY_MATRIX = [
   // === Tasks Domain ===
   // Query operations
-  { 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: "show", gateway: "query", mode: "native", preferredChannel: "cli" },
+  { domain: "tasks", operation: "list", gateway: "query", mode: "native", preferredChannel: "cli" },
+  { domain: "tasks", operation: "find", gateway: "query", mode: "native", preferredChannel: "cli" },
   {
     domain: "tasks",
     operation: "tree",
@@ -55798,8 +55650,8 @@ var CAPABILITY_MATRIX = [
     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: "next", gateway: "query", mode: "native", preferredChannel: "cli" },
+  { domain: "tasks", operation: "plan", gateway: "query", mode: "native", preferredChannel: "cli" },
   {
     domain: "tasks",
     operation: "relates",
@@ -55826,7 +55678,7 @@ var CAPABILITY_MATRIX = [
     operation: "current",
     gateway: "query",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "tasks",
@@ -55836,20 +55688,20 @@ var CAPABILITY_MATRIX = [
     preferredChannel: "either"
   },
   // Mutate operations
-  { domain: "tasks", operation: "add", gateway: "mutate", mode: "native", preferredChannel: "mcp" },
+  { domain: "tasks", operation: "add", gateway: "mutate", mode: "native", preferredChannel: "cli" },
   {
     domain: "tasks",
     operation: "update",
     gateway: "mutate",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "tasks",
     operation: "complete",
     gateway: "mutate",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "tasks",
@@ -55905,14 +55757,14 @@ var CAPABILITY_MATRIX = [
     operation: "start",
     gateway: "mutate",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "tasks",
     operation: "stop",
     gateway: "mutate",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   // Sync sub-domain (provider-agnostic task reconciliation)
   {
@@ -55943,7 +55795,7 @@ var CAPABILITY_MATRIX = [
     operation: "status",
     gateway: "query",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "session",
@@ -55978,14 +55830,14 @@ var CAPABILITY_MATRIX = [
     operation: "handoff.show",
     gateway: "query",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "session",
     operation: "briefing.show",
     gateway: "query",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "session",
@@ -56000,14 +55852,14 @@ var CAPABILITY_MATRIX = [
     operation: "start",
     gateway: "mutate",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "session",
     operation: "end",
     gateway: "mutate",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "session",
@@ -56095,7 +55947,7 @@ var CAPABILITY_MATRIX = [
     mode: "native",
     preferredChannel: "either"
   },
-  { domain: "admin", operation: "dash", gateway: "query", mode: "native", preferredChannel: "mcp" },
+  { domain: "admin", operation: "dash", gateway: "query", mode: "native", preferredChannel: "cli" },
   {
     domain: "admin",
     operation: "log",
@@ -56110,7 +55962,7 @@ var CAPABILITY_MATRIX = [
     mode: "native",
     preferredChannel: "either"
   },
-  { domain: "admin", operation: "help", gateway: "query", mode: "native", preferredChannel: "mcp" },
+  { domain: "admin", operation: "help", gateway: "query", mode: "native", preferredChannel: "cli" },
   {
     domain: "admin",
     operation: "token",
@@ -56139,7 +55991,7 @@ var CAPABILITY_MATRIX = [
     mode: "native",
     preferredChannel: "either"
   },
-  { domain: "admin", operation: "map", gateway: "query", mode: "native", preferredChannel: "mcp" },
+  { domain: "admin", operation: "map", gateway: "query", mode: "native", preferredChannel: "cli" },
   // Mutate operations
   {
     domain: "admin",
@@ -56302,7 +56154,7 @@ var CAPABILITY_MATRIX = [
     operation: "compliance.summary",
     gateway: "query",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "check",
@@ -56359,7 +56211,7 @@ var CAPABILITY_MATRIX = [
     operation: "compliance.record",
     gateway: "mutate",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "check",
@@ -56460,7 +56312,7 @@ var CAPABILITY_MATRIX = [
     operation: "spawn",
     gateway: "mutate",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "orchestrate",
@@ -56504,42 +56356,42 @@ var CAPABILITY_MATRIX = [
     operation: "find",
     gateway: "query",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "memory",
     operation: "timeline",
     gateway: "query",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "memory",
     operation: "fetch",
     gateway: "query",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "memory",
     operation: "decision.find",
     gateway: "query",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "memory",
     operation: "pattern.find",
     gateway: "query",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "memory",
     operation: "learning.find",
     gateway: "query",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "memory",
@@ -56582,28 +56434,28 @@ var CAPABILITY_MATRIX = [
     operation: "observe",
     gateway: "mutate",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "memory",
     operation: "decision.store",
     gateway: "mutate",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "memory",
     operation: "pattern.store",
     gateway: "mutate",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "memory",
     operation: "learning.store",
     gateway: "mutate",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "memory",
@@ -56633,14 +56485,14 @@ var CAPABILITY_MATRIX = [
     operation: "stage.validate",
     gateway: "query",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "pipeline",
     operation: "stage.status",
     gateway: "query",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "pipeline",
@@ -56864,21 +56716,21 @@ var CAPABILITY_MATRIX = [
     operation: "skill.list",
     gateway: "query",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "tools",
     operation: "skill.show",
     gateway: "query",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "tools",
     operation: "skill.find",
     gateway: "query",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "tools",
@@ -56949,14 +56801,14 @@ var CAPABILITY_MATRIX = [
     operation: "provider.list",
     gateway: "query",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "tools",
     operation: "provider.detect",
     gateway: "query",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "tools",
@@ -56992,14 +56844,14 @@ var CAPABILITY_MATRIX = [
     operation: "adapter.list",
     gateway: "query",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "tools",
     operation: "adapter.show",
     gateway: "query",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "tools",
@@ -57020,7 +56872,7 @@ var CAPABILITY_MATRIX = [
     operation: "adapter.activate",
     gateway: "mutate",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "tools",
@@ -57193,14 +57045,14 @@ var CAPABILITY_MATRIX = [
     operation: "list",
     gateway: "query",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "sticky",
     operation: "show",
     gateway: "query",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   // Mutate operations
   {
@@ -57208,7 +57060,7 @@ var CAPABILITY_MATRIX = [
     operation: "add",
     gateway: "mutate",
     mode: "native",
-    preferredChannel: "mcp"
+    preferredChannel: "cli"
   },
   {
     domain: "sticky",
@@ -57684,13 +57536,13 @@ import { catalog as catalog2 } from "@cleocode/caamp";
 
 // packages/core/src/skills/agents/config.ts
 init_paths();
-import { existsSync as existsSync69, readFileSync as readFileSync49 } from "node:fs";
-import { basename as basename11, join as join73 } from "node:path";
+import { existsSync as existsSync69, readFileSync as readFileSync48 } from "node:fs";
+import { basename as basename11, join as join72 } from "node:path";
 
 // packages/core/src/skills/discovery.ts
 init_paths();
-import { existsSync as existsSync68, readdirSync as readdirSync25, readFileSync as readFileSync48, statSync as statSync17 } from "node:fs";
-import { basename as basename10, join as join72 } from "node:path";
+import { existsSync as existsSync68, readdirSync as readdirSync25, readFileSync as readFileSync47, statSync as statSync17 } from "node:fs";
+import { basename as basename10, join as join71 } from "node:path";
 import {
   discoverSkill as caampDiscoverSkill,
   discoverSkills as caampDiscoverSkills,
@@ -57780,12 +57632,12 @@ var SKILL_NAME_MAP = {
 function getSkillSearchPaths(cwd) {
   const projectRoot = getProjectRoot(cwd);
   const cleoHome = getCleoHome();
-  const projectAgentsSkills = join72(getProjectAgentsDir(projectRoot), "skills");
+  const projectAgentsSkills = join71(getProjectAgentsDir(projectRoot), "skills");
   const paths = [
     { scope: "agent-skills", path: getCanonicalSkillsDir(), priority: 1 },
     { scope: "project-custom", path: projectAgentsSkills, priority: 2 }
   ];
-  const mpCacheDir = process.env["CLEO_SKILLS_MP_CACHE"] ?? join72(cleoHome, ".skills-cache");
+  const mpCacheDir = process.env["CLEO_SKILLS_MP_CACHE"] ?? join71(cleoHome, ".skills-cache");
   if (existsSync68(mpCacheDir)) {
     paths.push({ scope: "marketplace", path: mpCacheDir, priority: 4 });
   }
@@ -57796,7 +57648,7 @@ function getSkillsDir(cwd) {
   return getCanonicalSkillsDir();
 }
 function getSharedDir(cwd) {
-  return join72(getSkillsDir(cwd), "_shared");
+  return join71(getSkillsDir(cwd), "_shared");
 }
 function mapSkillName(input) {
   if (SKILL_NAME_MAP[input]) {
@@ -57879,11 +57731,11 @@ function parseFrontmatter3(content) {
   };
 }
 function discoverSkill(skillDir) {
-  const skillMdPath = join72(skillDir, "SKILL.md");
+  const skillMdPath = join71(skillDir, "SKILL.md");
   if (!existsSync68(skillMdPath)) {
     return null;
   }
-  const content = readFileSync48(skillMdPath, "utf-8");
+  const content = readFileSync47(skillMdPath, "utf-8");
   const frontmatter = parseFrontmatter3(content);
   const dirName = basename10(skillDir);
   return {
@@ -57904,7 +57756,7 @@ function discoverSkillsInDir(dir) {
     const entries = readdirSync25(dir);
     for (const entry of entries) {
       if (entry.startsWith(".") || entry.startsWith("_")) continue;
-      const entryPath = join72(dir, entry);
+      const entryPath = join71(dir, entry);
       try {
         if (statSync17(entryPath).isDirectory()) {
           const skill = discoverSkill(entryPath);
@@ -57938,14 +57790,14 @@ function findSkill(name2, cwd) {
   const { canonical } = mapSkillName(name2);
   const searchPaths = getSkillSearchPaths(cwd);
   for (const sp of searchPaths) {
-    const skillDir = join72(sp.path, canonical);
+    const skillDir = join71(sp.path, canonical);
     const skill = discoverSkill(skillDir);
     if (skill) return skill;
   }
   if (canonical.startsWith("ct-")) {
     const legacy = canonical.slice(3);
     for (const sp of searchPaths) {
-      const skillDir = join72(sp.path, legacy);
+      const skillDir = join71(sp.path, legacy);
       const skill = discoverSkill(skillDir);
       if (skill) return skill;
     }
@@ -57984,14 +57836,14 @@ function resolveTemplatePath(name2, cwd) {
 
 // packages/core/src/skills/agents/config.ts
 function getAgentsDir(cwd) {
-  return join73(getProjectRoot(cwd), "agents");
+  return join72(getProjectRoot(cwd), "agents");
 }
 function parseAgentConfig(agentDir) {
-  const agentMdPath = join73(agentDir, "AGENT.md");
+  const agentMdPath = join72(agentDir, "AGENT.md");
   if (!existsSync69(agentMdPath)) {
     return null;
   }
-  const content = readFileSync49(agentMdPath, "utf-8");
+  const content = readFileSync48(agentMdPath, "utf-8");
   const fm = parseFrontmatter3(content);
   return {
     name: fm.name || basename11(agentDir),
@@ -58003,7 +57855,7 @@ function parseAgentConfig(agentDir) {
 }
 function loadAgentConfig(agentName, cwd) {
   const agentsDir = getAgentsDir(cwd);
-  const agentDir = join73(agentsDir, agentName);
+  const agentDir = join72(agentsDir, agentName);
   return parseAgentConfig(agentDir);
 }
 function getSubagentConfig(cwd) {
@@ -58011,7 +57863,7 @@ function getSubagentConfig(cwd) {
 }
 function agentExists(agentName, cwd) {
   const agentsDir = getAgentsDir(cwd);
-  const agentMdPath = join73(agentsDir, agentName, "AGENT.md");
+  const agentMdPath = join72(agentsDir, agentName, "AGENT.md");
   return existsSync69(agentMdPath);
 }
 function extractBody(content) {
@@ -58035,7 +57887,7 @@ function extractBody(content) {
 init_paths();
 import { existsSync as existsSync70, mkdirSync as mkdirSync15, readdirSync as readdirSync26, readlinkSync, symlinkSync, unlinkSync as unlinkSync4 } from "node:fs";
 import { platform as platform2 } from "node:os";
-import { basename as basename12, join as join74 } from "node:path";
+import { basename as basename12, join as join73 } from "node:path";
 var DIR_SYMLINK_TYPE = platform2() === "win32" ? "junction" : "dir";
 function getAgentInstallDir() {
   return getClaudeAgentsDir();
@@ -58043,7 +57895,7 @@ function getAgentInstallDir() {
 function installAgent(agentDir) {
   const targetDir = getAgentInstallDir();
   const agentName = basename12(agentDir);
-  const targetPath = join74(targetDir, agentName);
+  const targetPath = join73(targetDir, agentName);
   if (!existsSync70(targetDir)) {
     mkdirSync15(targetDir, { recursive: true });
   }
@@ -58081,8 +57933,8 @@ function installAllAgents(cwd) {
   const entries = readdirSync26(agentsDir);
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const agentDir = join74(agentsDir, entry);
-    const agentMdPath = join74(agentDir, "AGENT.md");
+    const agentDir = join73(agentsDir, entry);
+    const agentMdPath = join73(agentDir, "AGENT.md");
     if (!existsSync70(agentMdPath)) continue;
     const result = installAgent(agentDir);
     results.push({
@@ -58095,7 +57947,7 @@ function installAllAgents(cwd) {
 }
 function uninstallAgent(agentName) {
   const targetDir = getAgentInstallDir();
-  const targetPath = join74(targetDir, agentName);
+  const targetPath = join73(targetDir, agentName);
   if (!existsSync70(targetPath)) {
     return false;
   }
@@ -58109,16 +57961,16 @@ function uninstallAgent(agentName) {
 
 // packages/core/src/skills/agents/registry.ts
 init_paths();
-import { existsSync as existsSync71, mkdirSync as mkdirSync16, readdirSync as readdirSync27, readFileSync as readFileSync50, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname15, join as join75 } from "node:path";
+import { existsSync as existsSync71, mkdirSync as mkdirSync16, readdirSync as readdirSync27, readFileSync as readFileSync49, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname15, join as join74 } from "node:path";
 function getRegistryPath2() {
-  return join75(getCleoHome(), "agent-registry.json");
+  return join74(getCleoHome(), "agent-registry.json");
 }
 function readRegistry2() {
   const registryPath = getRegistryPath2();
   if (existsSync71(registryPath)) {
     try {
-      const content = readFileSync50(registryPath, "utf-8");
+      const content = readFileSync49(registryPath, "utf-8");
       return JSON.parse(content);
     } catch {
     }
@@ -58181,7 +58033,7 @@ function syncRegistry(cwd) {
   const entries = readdirSync27(agentsDir);
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const agentDir = join75(agentsDir, entry);
+    const agentDir = join74(agentsDir, entry);
     try {
       const config2 = parseAgentConfig(agentDir);
       if (config2) {
@@ -58195,7 +58047,7 @@ function syncRegistry(cwd) {
     if (existingNames.has(name2)) {
       result.unchanged.push(name2);
     } else {
-      registerAgent2(name2, join75(agentsDir, name2), config2);
+      registerAgent2(name2, join74(agentsDir, name2), config2);
       result.added.push(name2);
     }
   }
@@ -58214,8 +58066,8 @@ import { catalog } from "@cleocode/caamp";
 
 // packages/core/src/skills/injection/token.ts
 init_paths();
-import { existsSync as existsSync72, readFileSync as readFileSync51 } from "node:fs";
-import { join as join76 } from "node:path";
+import { existsSync as existsSync72, readFileSync as readFileSync50 } from "node:fs";
+import { join as join75 } from "node:path";
 var REQUIRED_TOKENS = ["TASK_ID", "DATE", "TOPIC_SLUG"];
 var TOKEN_PATTERNS = {
   TASK_ID: /^T\d+$/,
@@ -58251,10 +58103,10 @@ var CLEO_DEFAULTS = {
 };
 function loadPlaceholders(cwd) {
   const projectRoot = getProjectRoot(cwd);
-  const path2 = join76(projectRoot, "skills", "_shared", "placeholders.json");
+  const path2 = join75(projectRoot, "skills", "_shared", "placeholders.json");
   if (!existsSync72(path2)) return null;
   try {
-    return JSON.parse(readFileSync51(path2, "utf-8"));
+    return JSON.parse(readFileSync50(path2, "utf-8"));
   } catch {
     return null;
   }
@@ -58343,7 +58195,7 @@ function loadAndInject(templatePath, values) {
   if (!existsSync72(templatePath)) {
     throw new Error(`Template not found: ${templatePath}`);
   }
-  const template = readFileSync51(templatePath, "utf-8");
+  const template = readFileSync50(templatePath, "utf-8");
   const content = injectTokens(template, values);
   const unresolvedTokens = hasUnresolvedTokens(content);
   return { content, unresolvedTokens };
@@ -58634,15 +58486,15 @@ ${promptParts.join("\n")}`;
 init_src();
 init_errors3();
 init_paths();
-import { existsSync as existsSync73, readFileSync as readFileSync52 } from "node:fs";
-import { join as join77 } from "node:path";
+import { existsSync as existsSync73, readFileSync as readFileSync51 } from "node:fs";
+import { join as join76 } from "node:path";
 function getProtocolBasePath(cwd) {
-  return join77(getProjectRoot(cwd), "skills", "_shared", "subagent-protocol-base.md");
+  return join76(getProjectRoot(cwd), "skills", "_shared", "subagent-protocol-base.md");
 }
 function loadProtocolBase(cwd) {
   const path2 = getProtocolBasePath(cwd);
   if (!existsSync73(path2)) return null;
-  return readFileSync52(path2, "utf-8");
+  return readFileSync51(path2, "utf-8");
 }
 async function buildTaskContext(taskId, cwd) {
   const { getAccessor: getAccessor2 } = await Promise.resolve().then(() => (init_data_accessor(), data_accessor_exports));
@@ -58784,7 +58636,7 @@ async function installSkill(skillName, projectDir) {
 // packages/core/src/skills/manifests/contribution.ts
 init_data_accessor();
 import { randomBytes as randomBytes11 } from "node:crypto";
-import { existsSync as existsSync74, readFileSync as readFileSync53 } from "node:fs";
+import { existsSync as existsSync74, readFileSync as readFileSync52 } from "node:fs";
 function generateContributionId(taskId) {
   const hash = randomBytes11(4).toString("hex");
   const date6 = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -58824,7 +58676,7 @@ function getContributionInjection(taskId, protocolPath, _cwd) {
   if (protocolPath && existsSync74(protocolPath)) {
     lines.push("### Protocol Details");
     lines.push("");
-    lines.push(readFileSync53(protocolPath, "utf-8"));
+    lines.push(readFileSync52(protocolPath, "utf-8"));
   }
   lines.push("---");
   return lines.join("\n");
@@ -58917,13 +58769,13 @@ function createContributionManifestEntry(taskId, contributionId, decisions) {
 init_src();
 init_errors3();
 init_paths();
-import { appendFileSync as appendFileSync8, existsSync as existsSync75, mkdirSync as mkdirSync17, readFileSync as readFileSync54, writeFileSync as writeFileSync10 } from "node:fs";
-import { join as join78 } from "node:path";
+import { appendFileSync as appendFileSync8, existsSync as existsSync75, mkdirSync as mkdirSync17, readFileSync as readFileSync53, writeFileSync as writeFileSync10 } from "node:fs";
+import { join as join77 } from "node:path";
 function ensureOutputs(cwd) {
   const outputDir = getAgentOutputsDir(cwd);
   const absOutputDir = getAgentOutputsAbsolute(cwd);
   const manifestPath = getManifestPath(cwd);
-  const archiveDir = join78(absOutputDir, "archive");
+  const archiveDir = join77(absOutputDir, "archive");
   const created = [];
   if (!existsSync75(absOutputDir)) {
     mkdirSync17(absOutputDir, { recursive: true });
@@ -58942,7 +58794,7 @@ function ensureOutputs(cwd) {
 function readManifest2(cwd) {
   const manifestPath = getManifestPath(cwd);
   if (!existsSync75(manifestPath)) return [];
-  const content = readFileSync54(manifestPath, "utf-8");
+  const content = readFileSync53(manifestPath, "utf-8");
   const entries = [];
   for (const line2 of content.split("\n")) {
     const trimmed = line2.trim();
@@ -59019,7 +58871,7 @@ function taskHasResearch(taskId, cwd) {
 function archiveEntry(entryId, cwd) {
   const manifestPath = getManifestPath(cwd);
   if (!existsSync75(manifestPath)) return false;
-  const content = readFileSync54(manifestPath, "utf-8");
+  const content = readFileSync53(manifestPath, "utf-8");
   const lines = content.split("\n");
   let found = false;
   const newLines = [];
@@ -59052,13 +58904,13 @@ function rotateManifest(maxEntries = 100, cwd) {
   if (entries.length <= maxEntries) return 0;
   const manifestPath = getManifestPath(cwd);
   const absOutputDir = getAgentOutputsAbsolute(cwd);
-  const archiveDir = join78(absOutputDir, "archive");
+  const archiveDir = join77(absOutputDir, "archive");
   const toKeep = entries.slice(-maxEntries);
   const toArchive = entries.slice(0, entries.length - maxEntries);
   if (!existsSync75(archiveDir)) {
     mkdirSync17(archiveDir, { recursive: true });
   }
-  const archivePath = join78(archiveDir, `MANIFEST-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.jsonl`);
+  const archivePath = join77(archiveDir, `MANIFEST-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.jsonl`);
   const archiveContent = toArchive.map((e) => JSON.stringify(e)).join("\n") + "\n";
   appendFileSync8(archivePath, archiveContent, "utf-8");
   const keepContent = toKeep.map((e) => JSON.stringify(e)).join("\n") + "\n";
@@ -59120,20 +58972,20 @@ function validateEntry(entry) {
 
 // packages/core/src/skills/manifests/resolver.ts
 init_paths();
-import { existsSync as existsSync76, mkdirSync as mkdirSync18, readFileSync as readFileSync55, writeFileSync as writeFileSync11 } from "node:fs";
-import { join as join79 } from "node:path";
+import { existsSync as existsSync76, mkdirSync as mkdirSync18, readFileSync as readFileSync54, writeFileSync as writeFileSync11 } from "node:fs";
+import { join as join78 } from "node:path";
 var DEFAULT_CACHE_TTL = 300;
 function getCacheDir() {
-  return process.env["CLEO_MANIFEST_CACHE_DIR"] ?? join79(getCleoHome(), "cache");
+  return process.env["CLEO_MANIFEST_CACHE_DIR"] ?? join78(getCleoHome(), "cache");
 }
 function getCachedManifestPath() {
-  return join79(getCacheDir(), "skills-manifest.json");
+  return join78(getCacheDir(), "skills-manifest.json");
 }
 function isCacheFresh(cachePath) {
   const path2 = cachePath ?? getCachedManifestPath();
   if (!existsSync76(path2)) return false;
   try {
-    const content = readFileSync55(path2, "utf-8");
+    const content = readFileSync54(path2, "utf-8");
     const manifest = JSON.parse(content);
     const ttl = manifest._meta?.ttlSeconds ?? DEFAULT_CACHE_TTL;
     const generatedAt = new Date(manifest._meta?.generatedAt ?? 0).getTime();
@@ -59156,13 +59008,13 @@ function resolveManifest(cwd) {
   const cachePath = getCachedManifestPath();
   if (isCacheFresh(cachePath)) {
     try {
-      return JSON.parse(readFileSync55(cachePath, "utf-8"));
+      return JSON.parse(readFileSync54(cachePath, "utf-8"));
     } catch {
     }
   }
   if (existsSync76(cachePath)) {
     try {
-      const content = readFileSync55(cachePath, "utf-8");
+      const content = readFileSync54(cachePath, "utf-8");
       if (content.trim()) {
         const staleManifest = JSON.parse(content);
         if (staleManifest.skills?.length > 0) {
@@ -59200,15 +59052,15 @@ function regenerateCache(cwd) {
 
 // packages/core/src/skills/marketplace.ts
 init_paths();
-import { existsSync as existsSync77, readFileSync as readFileSync56 } from "node:fs";
-import { join as join80 } from "node:path";
+import { existsSync as existsSync77, readFileSync as readFileSync55 } from "node:fs";
+import { join as join79 } from "node:path";
 import { searchSkills as caampSearchSkills, MarketplaceClient } from "@cleocode/caamp";
 function loadConfig2(cwd) {
   const projectRoot = getProjectRoot(cwd);
-  const configFile = join80(projectRoot, ".cleo", "skillsmp.json");
+  const configFile = join79(projectRoot, ".cleo", "skillsmp.json");
   if (!existsSync77(configFile)) return null;
   try {
-    const data = JSON.parse(readFileSync56(configFile, "utf-8"));
+    const data = JSON.parse(readFileSync55(configFile, "utf-8"));
     if (data.enabled !== true) return null;
     return {
       enabled: true,
@@ -59384,8 +59236,8 @@ async function spawnBatch(taskIds, templateName, cwd, tier) {
 // packages/core/src/skills/orchestrator/startup.ts
 init_paths();
 init_data_accessor();
-import { existsSync as existsSync78, readFileSync as readFileSync57 } from "node:fs";
-import { join as join81 } from "node:path";
+import { existsSync as existsSync78, readFileSync as readFileSync56 } from "node:fs";
+import { join as join80 } from "node:path";
 var DEFAULT_THRESHOLDS = { warning: 70, critical: 80 };
 function getThresholds(config2) {
   const orc = config2?.orchestrator?.contextThresholds;
@@ -59407,19 +59259,19 @@ function getContextState(sessionId, cwd) {
   };
   let stateFile = "";
   if (sessionId) {
-    stateFile = join81(cleoDirAbs, "sessions", sessionId, ".context-state.json");
+    stateFile = join80(cleoDirAbs, "sessions", sessionId, ".context-state.json");
     if (!existsSync78(stateFile)) {
-      stateFile = join81(cleoDirAbs, `.context-state-${sessionId}.json`);
+      stateFile = join80(cleoDirAbs, `.context-state-${sessionId}.json`);
     }
   }
   if (!stateFile || !existsSync78(stateFile)) {
-    stateFile = join81(cleoDirAbs, ".context-state.json");
+    stateFile = join80(cleoDirAbs, ".context-state.json");
   }
   if (!existsSync78(stateFile)) {
     return defaultState;
   }
   try {
-    const data = JSON.parse(readFileSync57(stateFile, "utf-8"));
+    const data = JSON.parse(readFileSync56(stateFile, "utf-8"));
     const cw = data.contextWindow ?? data;
     const timestamp2 = data.timestamp;
     const staleAfterMs = data.staleAfterMs ?? 5e3;
@@ -59727,8 +59579,8 @@ function priorityRank(priority) {
 init_src();
 init_paths();
 init_data_accessor();
-import { existsSync as existsSync79, readFileSync as readFileSync58 } from "node:fs";
-import { join as join82 } from "node:path";
+import { existsSync as existsSync79, readFileSync as readFileSync57 } from "node:fs";
+import { join as join81 } from "node:path";
 var KEY_FINDINGS_MIN = 3;
 var KEY_FINDINGS_MAX = 7;
 var MANIFEST_REQUIRED_FIELDS = [
@@ -59748,7 +59600,7 @@ function getManifestPath3(cwd) {
 function readManifestEntries(cwd) {
   const manifestPath = getManifestPath3(cwd);
   if (!existsSync79(manifestPath)) return [];
-  const content = readFileSync58(manifestPath, "utf-8");
+  const content = readFileSync57(manifestPath, "utf-8");
   const entries = [];
   for (const line2 of content.split("\n")) {
     const trimmed = line2.trim();
@@ -59809,7 +59661,7 @@ function validateSubagentOutput(researchId, cwd) {
   }
   if (entry.file) {
     const absOutputDir = getAgentOutputsAbsolute(cwd);
-    const filePath = join82(absOutputDir, entry.file);
+    const filePath = join81(absOutputDir, entry.file);
     if (!existsSync79(filePath)) {
       issues.push(`FILE_NOT_FOUND: Expected file at ${filePath}`);
     }
@@ -59821,7 +59673,7 @@ function validateManifestIntegrity(cwd) {
   if (!existsSync79(manifestPath)) {
     return { exists: false, passed: true, issues: [] };
   }
-  const content = readFileSync58(manifestPath, "utf-8");
+  const content = readFileSync57(manifestPath, "utf-8");
   const lines = content.split("\n").filter((l) => l.trim());
   const issues = [];
   let validEntries = 0;
@@ -59852,7 +59704,7 @@ function validateManifestIntegrity(cwd) {
     seenIds.add(entry.id);
     if (entry.file) {
       const absOutputDir = getAgentOutputsAbsolute(cwd);
-      const filePath = join82(absOutputDir, entry.file);
+      const filePath = join81(absOutputDir, entry.file);
       if (!existsSync79(filePath)) {
         issues.push(`LINE_${lineNum}_FILE_MISSING: ${entry.file} does not exist`);
       }
@@ -59926,7 +59778,7 @@ async function validateOrchestratorCompliance(epicId, cwd) {
   if (!existsSync79(manifestPath)) {
     warnings.push(`ORC-005_NO_MANIFEST: Manifest file not found at ${manifestPath}`);
   } else {
-    const content = readFileSync58(manifestPath, "utf-8").trim();
+    const content = readFileSync57(manifestPath, "utf-8").trim();
     if (!content) {
       warnings.push("ORC-005_EMPTY_MANIFEST: Manifest exists but has no entries");
     }
@@ -59962,22 +59814,22 @@ async function validateOrchestratorCompliance(epicId, cwd) {
 }
 
 // packages/core/src/skills/skill-paths.ts
-import { existsSync as existsSync80, lstatSync, readlinkSync as readlinkSync2, realpathSync as realpathSync2 } from "node:fs";
-import { delimiter, join as join83, resolve as resolve9 } from "node:path";
+import { existsSync as existsSync80, lstatSync, readlinkSync as readlinkSync2, realpathSync } from "node:fs";
+import { delimiter, join as join82, resolve as resolve9 } from "node:path";
 import { getCanonicalSkillsDir as getCanonicalSkillsDir2 } from "@cleocode/caamp";
 function getCaampCanonical() {
   return getCanonicalSkillsDir2();
 }
 function getProjectEmbedded(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  return join83(root, "skills");
+  return join82(root, "skills");
 }
 function getProjectRoot3(cwd) {
   return cwd ?? process.cwd();
 }
 function safeRealpath(path2) {
   try {
-    return realpathSync2(path2);
+    return realpathSync(path2);
   } catch {
     return path2;
   }
@@ -60020,8 +59872,8 @@ function getSkillSearchPaths2(projectRoot) {
 function resolveSkillPath(skillName, projectRoot) {
   const searchPaths = getSkillSearchPaths2(projectRoot);
   for (const { path: searchPath } of searchPaths) {
-    const candidate = join83(searchPath, skillName);
-    if (existsSync80(join83(candidate, "SKILL.md"))) {
+    const candidate = join82(searchPath, skillName);
+    if (existsSync80(join82(candidate, "SKILL.md"))) {
       return safeRealpath(candidate);
     }
   }
@@ -60030,13 +59882,13 @@ function resolveSkillPath(skillName, projectRoot) {
 function resolveProtocolPath(protocolName, projectRoot) {
   const searchPaths = getSkillSearchPaths2(projectRoot);
   for (const { path: searchPath } of searchPaths) {
-    const candidate = join83(searchPath, "_ct-skills-protocols", `${protocolName}.md`);
+    const candidate = join82(searchPath, "_ct-skills-protocols", `${protocolName}.md`);
     if (existsSync80(candidate)) {
       return safeRealpath(candidate);
     }
   }
   const root = getProjectRoot3(projectRoot);
-  const legacy = join83(root, "src", "protocols", `${protocolName}.md`);
+  const legacy = join82(root, "src", "protocols", `${protocolName}.md`);
   if (existsSync80(legacy)) {
     return safeRealpath(legacy);
   }
@@ -60045,11 +59897,11 @@ function resolveProtocolPath(protocolName, projectRoot) {
 function resolveSharedPath(resourceName, projectRoot) {
   const searchPaths = getSkillSearchPaths2(projectRoot);
   for (const { path: searchPath } of searchPaths) {
-    const candidate = join83(searchPath, "_ct-skills-shared", `${resourceName}.md`);
+    const candidate = join82(searchPath, "_ct-skills-shared", `${resourceName}.md`);
     if (existsSync80(candidate)) {
       return safeRealpath(candidate);
     }
-    const legacy = join83(searchPath, "_shared", `${resourceName}.md`);
+    const legacy = join82(searchPath, "_shared", `${resourceName}.md`);
     if (existsSync80(legacy)) {
       return safeRealpath(legacy);
     }
@@ -60075,7 +59927,7 @@ function getSkillSourceType(skillDir, projectRoot) {
     }
   } catch {
   }
-  if (normalizedDir.startsWith(resolve9(embeddedDir)) || normalizedDir.startsWith(join83(root, "skills"))) {
+  if (normalizedDir.startsWith(resolve9(embeddedDir)) || normalizedDir.startsWith(join82(root, "skills"))) {
     return "embedded";
   }
   if (normalizedDir.startsWith(caampDir)) {
@@ -60106,8 +59958,8 @@ function formatDateYMD(date6) {
 }
 
 // packages/core/src/skills/validation.ts
-import { existsSync as existsSync81, readFileSync as readFileSync59 } from "node:fs";
-import { basename as basename13, join as join84 } from "node:path";
+import { existsSync as existsSync81, readFileSync as readFileSync58 } from "node:fs";
+import { basename as basename13, join as join83 } from "node:path";
 var VALID_PROTOCOLS = /* @__PURE__ */ new Set([
   "research",
   "consensus",
@@ -60130,7 +59982,7 @@ function validateSkill(skillDir) {
     });
     return buildResult(dirName, skillDir, issues);
   }
-  const skillMdPath = join84(skillDir, "SKILL.md");
+  const skillMdPath = join83(skillDir, "SKILL.md");
   if (!existsSync81(skillMdPath)) {
     issues.push({
       severity: "error",
@@ -60140,7 +59992,7 @@ function validateSkill(skillDir) {
     });
     return buildResult(dirName, skillDir, issues);
   }
-  const content = readFileSync59(skillMdPath, "utf-8");
+  const content = readFileSync58(skillMdPath, "utf-8");
   const fm = parseFrontmatter3(content);
   validateFrontmatter(fm, issues, skillMdPath);
   if (!dirName.startsWith("ct-") && !dirName.startsWith("_")) {
@@ -60152,7 +60004,7 @@ function validateSkill(skillDir) {
   }
   const optionalFiles = ["README.md", "references"];
   for (const file2 of optionalFiles) {
-    const filePath = join84(skillDir, file2);
+    const filePath = join83(skillDir, file2);
     if (!existsSync81(filePath)) {
       issues.push({
         severity: "info",
@@ -60302,7 +60154,7 @@ init_data_accessor();
 import { createHash as createHash8 } from "node:crypto";
 import { existsSync as existsSync82 } from "node:fs";
 import { mkdir as mkdir13, readFile as readFile13, writeFile as writeFile10 } from "node:fs/promises";
-import { dirname as dirname16, join as join85 } from "node:path";
+import { dirname as dirname16, join as join84 } from "node:path";
 var SNAPSHOT_FORMAT_VERSION = "1.0.0";
 function toSnapshotTask(task) {
   return {
@@ -60378,7 +60230,7 @@ async function readSnapshot(inputPath) {
 function getDefaultSnapshotPath(cwd) {
   const cleoDir = getCleoDirAbsolute(cwd);
   const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  return join85(cleoDir, "snapshots", `snapshot-${timestamp2}.json`);
+  return join84(cleoDir, "snapshots", `snapshot-${timestamp2}.json`);
 }
 async function importSnapshot(snapshot, cwd) {
   const accessor = await getAccessor(cwd);
@@ -60606,8 +60458,8 @@ async function initializeSpawnAdapters(manifests) {
     if (!manifest.capabilities?.supportsSpawn) continue;
     if (spawnRegistry.hasAdapterForProvider(manifest.provider)) continue;
     try {
-      const { join: join108 } = await import("node:path");
-      const modulePath = join108(manifest.packagePath, manifest.entryPoint);
+      const { join: join107 } = await import("node:path");
+      const modulePath = join107(manifest.packagePath, manifest.entryPoint);
       const adapterModule = await import(modulePath);
       let SpawnProviderClass;
       for (const [exportName, exportValue] of Object.entries(adapterModule)) {
@@ -61844,14 +61696,14 @@ async function getArchiveStats(opts, accessor) {
 
 // packages/core/src/system/audit.ts
 init_data_accessor();
-import { existsSync as existsSync83, readFileSync as readFileSync60 } from "node:fs";
-import { join as join86 } from "node:path";
+import { existsSync as existsSync83, readFileSync as readFileSync59 } from "node:fs";
+import { join as join85 } from "node:path";
 async function auditData(projectRoot, opts) {
-  const cleoDir = join86(projectRoot, ".cleo");
+  const cleoDir = join85(projectRoot, ".cleo");
   const scope = opts?.scope ?? "all";
   const issues = [];
   if (scope === "all" || scope === "tasks") {
-    const tasksDbPath = join86(cleoDir, "tasks.db");
+    const tasksDbPath = join85(cleoDir, "tasks.db");
     if (existsSync83(tasksDbPath)) {
       try {
         const accessor = await getAccessor(projectRoot);
@@ -61914,10 +61766,10 @@ async function auditData(projectRoot, opts) {
     }
   }
   if (scope === "all" || scope === "sessions") {
-    const sessPath = join86(cleoDir, "sessions.json");
+    const sessPath = join85(cleoDir, "sessions.json");
     if (existsSync83(sessPath)) {
       try {
-        const data = JSON.parse(readFileSync60(sessPath, "utf-8"));
+        const data = JSON.parse(readFileSync59(sessPath, "utf-8"));
         const sessions2 = data.sessions ?? [];
         const sessionIds = /* @__PURE__ */ new Set();
         for (const s of sessions2) {
@@ -61949,10 +61801,10 @@ async function auditData(projectRoot, opts) {
     }
   }
   if (scope === "all") {
-    const seqPath = join86(cleoDir, ".sequence.json");
+    const seqPath = join85(cleoDir, ".sequence.json");
     if (existsSync83(seqPath)) {
       try {
-        const seq = JSON.parse(readFileSync60(seqPath, "utf-8"));
+        const seq = JSON.parse(readFileSync59(seqPath, "utf-8"));
         if (typeof seq.counter !== "number") {
           issues.push({
             severity: "error",
@@ -61983,32 +61835,32 @@ async function auditData(projectRoot, opts) {
 // packages/core/src/system/backup.ts
 init_src();
 init_errors3();
-import { existsSync as existsSync84, mkdirSync as mkdirSync19, readdirSync as readdirSync28, readFileSync as readFileSync61, writeFileSync as writeFileSync12 } from "node:fs";
-import { join as join87 } from "node:path";
+import { existsSync as existsSync84, mkdirSync as mkdirSync19, readdirSync as readdirSync28, readFileSync as readFileSync60, writeFileSync as writeFileSync12 } from "node:fs";
+import { join as join86 } from "node:path";
 function createBackup2(projectRoot, opts) {
-  const cleoDir = join87(projectRoot, ".cleo");
+  const cleoDir = join86(projectRoot, ".cleo");
   const btype = opts?.type || "snapshot";
   const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
   const backupId = `${btype}-${timestamp2.replace(/[:.]/g, "-")}`;
-  const backupDir = join87(cleoDir, "backups", btype);
+  const backupDir = join86(cleoDir, "backups", btype);
   if (!existsSync84(backupDir)) {
     mkdirSync19(backupDir, { recursive: true });
   }
   const filesToBackup = ["tasks.db", "brain.db", "config.json", "project-info.json"];
   const backedUp = [];
   for (const file2 of filesToBackup) {
-    const src = join87(cleoDir, file2);
+    const src = join86(cleoDir, file2);
     if (existsSync84(src)) {
-      const dest = join87(backupDir, `${file2}.${backupId}`);
+      const dest = join86(backupDir, `${file2}.${backupId}`);
       try {
-        const content = readFileSync61(src);
+        const content = readFileSync60(src);
         writeFileSync12(dest, content);
         backedUp.push(file2);
       } catch {
       }
     }
   }
-  const metaPath = join87(backupDir, `${backupId}.meta.json`);
+  const metaPath = join86(backupDir, `${backupId}.meta.json`);
   try {
     writeFileSync12(
       metaPath,
@@ -62033,15 +61885,15 @@ function restoreBackup(projectRoot, params) {
   if (!params.backupId) {
     throw new CleoError(2 /* INVALID_INPUT */, "backupId is required");
   }
-  const cleoDir = join87(projectRoot, ".cleo");
+  const cleoDir = join86(projectRoot, ".cleo");
   const backupTypes = ["snapshot", "safety", "migration"];
   let metaPath = null;
   let backupDir = null;
   for (const btype of backupTypes) {
-    const candidateMeta = join87(cleoDir, "backups", btype, `${params.backupId}.meta.json`);
+    const candidateMeta = join86(cleoDir, "backups", btype, `${params.backupId}.meta.json`);
     if (existsSync84(candidateMeta)) {
       metaPath = candidateMeta;
-      backupDir = join87(cleoDir, "backups", btype);
+      backupDir = join86(cleoDir, "backups", btype);
       break;
     }
   }
@@ -62050,17 +61902,17 @@ function restoreBackup(projectRoot, params) {
   }
   let meta;
   try {
-    meta = JSON.parse(readFileSync61(metaPath, "utf-8"));
+    meta = JSON.parse(readFileSync60(metaPath, "utf-8"));
   } catch {
     throw new CleoError(3 /* FILE_ERROR */, "Failed to read backup metadata");
   }
   const restored = [];
   for (const file2 of meta.files ?? []) {
-    const backupFile = join87(backupDir, `${file2}.${params.backupId}`);
+    const backupFile = join86(backupDir, `${file2}.${params.backupId}`);
     if (existsSync84(backupFile)) {
       try {
-        const content = readFileSync61(backupFile);
-        writeFileSync12(join87(cleoDir, file2), content);
+        const content = readFileSync60(backupFile);
+        writeFileSync12(join86(cleoDir, file2), content);
         restored.push(file2);
       } catch {
       }
@@ -62076,13 +61928,13 @@ function restoreBackup(projectRoot, params) {
 
 // packages/core/src/system/cleanup.ts
 init_src();
-import { existsSync as existsSync85, readdirSync as readdirSync29, readFileSync as readFileSync62, unlinkSync as unlinkSync5, writeFileSync as writeFileSync13 } from "node:fs";
-import { join as join89 } from "node:path";
+import { existsSync as existsSync85, readdirSync as readdirSync29, readFileSync as readFileSync61, unlinkSync as unlinkSync5, writeFileSync as writeFileSync13 } from "node:fs";
+import { join as join88 } from "node:path";
 
 // packages/core/src/audit-prune.ts
 init_logger();
 import { createWriteStream, mkdirSync as mkdirSync20 } from "node:fs";
-import { join as join88 } from "node:path";
+import { join as join87 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createGzip } from "node:zlib";
@@ -62094,7 +61946,7 @@ async function pruneAuditLog(cleoDir, config2) {
       return { rowsArchived: 0, rowsDeleted: 0 };
     }
     const cutoff = new Date(Date.now() - config2.auditRetentionDays * 864e5).toISOString();
-    const projectRoot = join88(cleoDir, "..");
+    const projectRoot = join87(cleoDir, "..");
     const { getDb: getDb3 } = await Promise.resolve().then(() => (init_sqlite2(), sqlite_exports));
     const { auditLog: auditLog2 } = await Promise.resolve().then(() => (init_tasks_schema(), tasks_schema_exports));
     const { lt: lt3 } = await import("drizzle-orm");
@@ -62108,10 +61960,10 @@ async function pruneAuditLog(cleoDir, config2) {
     let rowsArchived = 0;
     if (config2.archiveBeforePrune) {
       try {
-        const archiveDir = join88(cleoDir, "backups", "logs");
+        const archiveDir = join87(cleoDir, "backups", "logs");
         mkdirSync20(archiveDir, { recursive: true });
         const dateStamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-        archivePath = join88(archiveDir, `audit-${dateStamp}.jsonl.gz`);
+        archivePath = join87(archiveDir, `audit-${dateStamp}.jsonl.gz`);
         const lines = oldRows.map((row) => JSON.stringify(row));
         const jsonlContent = lines.join("\n") + "\n";
         const gzip = createGzip();
@@ -62154,7 +62006,7 @@ async function cleanupSystem(projectRoot, params) {
       "target is required (sessions|backups|logs|archive)"
     );
   }
-  const cleoDir = join89(projectRoot, ".cleo");
+  const cleoDir = join88(projectRoot, ".cleo");
   const dryRun = params.dryRun ?? false;
   const items = [];
   let prunedRows;
@@ -62162,10 +62014,10 @@ async function cleanupSystem(projectRoot, params) {
   let archivePath;
   switch (params.target) {
     case "sessions": {
-      const sessPath = join89(cleoDir, "sessions.json");
+      const sessPath = join88(cleoDir, "sessions.json");
       if (existsSync85(sessPath)) {
         try {
-          const data = JSON.parse(readFileSync62(sessPath, "utf-8"));
+          const data = JSON.parse(readFileSync61(sessPath, "utf-8"));
           const sessions2 = data.sessions ?? [];
           const stale = sessions2.filter(
             (s) => {
@@ -62191,16 +62043,16 @@ async function cleanupSystem(projectRoot, params) {
       break;
     }
     case "backups": {
-      const backupBaseDir = join89(cleoDir, "backups");
+      const backupBaseDir = join88(cleoDir, "backups");
       if (existsSync85(backupBaseDir)) {
         for (const typeDir of readdirSync29(backupBaseDir)) {
-          const fullDir = join89(backupBaseDir, typeDir);
+          const fullDir = join88(backupBaseDir, typeDir);
           try {
             for (const file2 of readdirSync29(fullDir)) {
               if (file2.endsWith(".meta.json")) {
-                const metaFilePath = join89(fullDir, file2);
+                const metaFilePath = join88(fullDir, file2);
                 try {
-                  const meta = JSON.parse(readFileSync62(metaFilePath, "utf-8"));
+                  const meta = JSON.parse(readFileSync61(metaFilePath, "utf-8"));
                   if (params.olderThan && meta.timestamp < params.olderThan) {
                     items.push(file2.replace(".meta.json", ""));
                     if (!dryRun) {
@@ -62208,7 +62060,7 @@ async function cleanupSystem(projectRoot, params) {
                       for (const bf of readdirSync29(fullDir)) {
                         if (bf.includes(meta.backupId)) {
                           try {
-                            unlinkSync5(join89(fullDir, bf));
+                            unlinkSync5(join88(fullDir, bf));
                           } catch {
                           }
                         }
@@ -62240,7 +62092,7 @@ async function cleanupSystem(projectRoot, params) {
             items.push(file2);
             if (!dryRun) {
               try {
-                unlinkSync5(join89(cleoDir, file2));
+                unlinkSync5(join88(cleoDir, file2));
               } catch {
               }
             }
@@ -62268,9 +62120,9 @@ init_hooks();
 init_injection();
 init_paths();
 import { execFile as execFile6, execFileSync as execFileSync11 } from "node:child_process";
-import { existsSync as existsSync89, readFileSync as readFileSync65, statSync as statSync19 } from "node:fs";
+import { existsSync as existsSync89, readFileSync as readFileSync64, statSync as statSync19 } from "node:fs";
 import { createRequire as createRequire6 } from "node:module";
-import { join as join93 } from "node:path";
+import { join as join92 } from "node:path";
 import { promisify as promisify6 } from "node:util";
 
 // packages/core/src/platform.ts
@@ -62292,30 +62144,30 @@ import {
   existsSync as existsSync87,
   mkdirSync as mkdirSync21,
   readdirSync as readdirSync30,
-  readFileSync as readFileSync63,
+  readFileSync as readFileSync62,
   renameSync as renameSync6,
   unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync14
 } from "node:fs";
-import { basename as basename14, dirname as dirname17, join as join91 } from "node:path";
+import { basename as basename14, dirname as dirname17, join as join90 } from "node:path";
 import * as lockfile2 from "proper-lockfile";
 var MAX_BACKUPS = 10;
 function rotateBackup(filePath) {
   const dir = dirname17(filePath);
   const name2 = basename14(filePath);
-  const backupDir = join91(dir, ".backups");
+  const backupDir = join90(dir, ".backups");
   if (!existsSync87(backupDir)) {
     mkdirSync21(backupDir, { recursive: true });
   }
   for (let i = MAX_BACKUPS; i >= 1; i--) {
-    const current = join91(backupDir, `${name2}.${i}`);
+    const current = join90(backupDir, `${name2}.${i}`);
     if (i === MAX_BACKUPS) {
       try {
         unlinkSync6(current);
       } catch {
       }
     } else {
-      const next = join91(backupDir, `${name2}.${i + 1}`);
+      const next = join90(backupDir, `${name2}.${i + 1}`);
       try {
         if (existsSync87(current)) renameSync6(current, next);
       } catch {
@@ -62323,14 +62175,14 @@ function rotateBackup(filePath) {
     }
   }
   try {
-    const content = readFileSync63(filePath, "utf-8");
-    writeFileSync14(join91(backupDir, `${name2}.1`), content, "utf-8");
+    const content = readFileSync62(filePath, "utf-8");
+    writeFileSync14(join90(backupDir, `${name2}.1`), content, "utf-8");
   } catch {
   }
 }
 function writeJsonFileAtomic(filePath, data, indent = 2) {
   const dir = dirname17(filePath);
-  const tempPath = join91(dir, `.${basename14(filePath)}.${randomBytes12(6).toString("hex")}.tmp`);
+  const tempPath = join90(dir, `.${basename14(filePath)}.${randomBytes12(6).toString("hex")}.tmp`);
   const content = JSON.stringify(data, null, indent) + "\n";
   writeFileSync14(tempPath, content, "utf-8");
   try {
@@ -62347,7 +62199,7 @@ function writeJsonFileAtomic(filePath, data, indent = 2) {
   }
 }
 function getDataPath(projectRoot, filename) {
-  return join91(projectRoot, ".cleo", filename);
+  return join90(projectRoot, ".cleo", filename);
 }
 
 // packages/core/src/platform.ts
@@ -62469,9 +62321,9 @@ init_data_accessor();
 
 // packages/core/src/validation/doctor/checks.ts
 import { execFileSync as execFileSync10 } from "node:child_process";
-import { accessSync as accessSync2, constants as constants2, existsSync as existsSync88, readFileSync as readFileSync64, statSync as statSync18 } from "node:fs";
+import { accessSync as accessSync2, constants as constants2, existsSync as existsSync88, readFileSync as readFileSync63, statSync as statSync18 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { join as join92 } from "node:path";
+import { join as join91 } from "node:path";
 
 // packages/core/src/constants.ts
 var CORE_PROTECTED_FILES = [
@@ -62499,7 +62351,7 @@ function checkCliInstallation(cleoHome = getCleoHome()) {
 }
 var VERSION_REGEX = /^\d+\.\d+\.\d+$/;
 function checkCliVersion(cleoHome = getCleoHome()) {
-  const versionFile = join92(cleoHome, "VERSION");
+  const versionFile = join91(cleoHome, "VERSION");
   if (!existsSync88(versionFile)) {
     return {
       id: "cli_version",
@@ -62510,7 +62362,7 @@ function checkCliVersion(cleoHome = getCleoHome()) {
       fix: "Run install.sh to reinstall CLEO"
     };
   }
-  const version2 = readFileSync64(versionFile, "utf-8").trim().split("\n")[0].trim();
+  const version2 = readFileSync63(versionFile, "utf-8").trim().split("\n")[0].trim();
   const valid = VERSION_REGEX.test(version2);
   return {
     id: "cli_version",
@@ -62522,7 +62374,7 @@ function checkCliVersion(cleoHome = getCleoHome()) {
   };
 }
 function checkDocsAccessibility(cleoHome = getCleoHome()) {
-  const docsFile = join92(cleoHome, "templates", "CLEO-INJECTION.md");
+  const docsFile = join91(cleoHome, "templates", "CLEO-INJECTION.md");
   if (!existsSync88(docsFile)) {
     return {
       id: "docs_accessibility",
@@ -62556,7 +62408,7 @@ function checkDocsAccessibility(cleoHome = getCleoHome()) {
   };
 }
 function checkAtReferenceResolution(cleoHome = getCleoHome()) {
-  const docsFile = join92(cleoHome, "templates", "CLEO-INJECTION.md");
+  const docsFile = join91(cleoHome, "templates", "CLEO-INJECTION.md");
   const reference = "@~/.cleo/templates/CLEO-INJECTION.md";
   if (!existsSync88(docsFile)) {
     return {
@@ -62570,7 +62422,7 @@ function checkAtReferenceResolution(cleoHome = getCleoHome()) {
   }
   try {
     accessSync2(docsFile, constants2.R_OK);
-    const content = readFileSync64(docsFile, "utf-8");
+    const content = readFileSync63(docsFile, "utf-8");
     const firstLine = content.split("\n")[0] ?? "";
     if (!firstLine) {
       return {
@@ -62604,7 +62456,7 @@ function checkAtReferenceResolution(cleoHome = getCleoHome()) {
 }
 function checkAgentsMdHub(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const agentsMdPath = join92(root, "AGENTS.md");
+  const agentsMdPath = join91(root, "AGENTS.md");
   if (!existsSync88(agentsMdPath)) {
     return {
       id: "agents_md_hub",
@@ -62617,7 +62469,7 @@ function checkAgentsMdHub(projectRoot) {
   }
   let content;
   try {
-    content = readFileSync64(agentsMdPath, "utf-8");
+    content = readFileSync63(agentsMdPath, "utf-8");
   } catch {
     return {
       id: "agents_md_hub",
@@ -62649,7 +62501,7 @@ function checkAgentsMdHub(projectRoot) {
 }
 function checkRootGitignore(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const gitignorePath = join92(root, ".gitignore");
+  const gitignorePath = join91(root, ".gitignore");
   if (!existsSync88(gitignorePath)) {
     return {
       id: "root_gitignore",
@@ -62662,7 +62514,7 @@ function checkRootGitignore(projectRoot) {
   }
   let content;
   try {
-    content = readFileSync64(gitignorePath, "utf-8");
+    content = readFileSync63(gitignorePath, "utf-8");
   } catch {
     return {
       id: "root_gitignore",
@@ -62700,7 +62552,7 @@ function checkRootGitignore(projectRoot) {
 }
 function checkCleoGitignore(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const gitignorePath = join92(root, ".cleo", ".gitignore");
+  const gitignorePath = join91(root, ".cleo", ".gitignore");
   if (!existsSync88(gitignorePath)) {
     return {
       id: "cleo_gitignore",
@@ -62713,7 +62565,7 @@ function checkCleoGitignore(projectRoot) {
   }
   let installedContent;
   try {
-    installedContent = readFileSync64(gitignorePath, "utf-8");
+    installedContent = readFileSync63(gitignorePath, "utf-8");
   } catch {
     return {
       id: "cleo_gitignore",
@@ -62730,12 +62582,12 @@ function checkCleoGitignore(projectRoot) {
   } catch {
     try {
       const templatePaths = [
-        join92(root, "templates", "cleo-gitignore"),
-        join92(getCleoHome(), "templates", "cleo-gitignore")
+        join91(root, "templates", "cleo-gitignore"),
+        join91(getCleoHome(), "templates", "cleo-gitignore")
       ];
       for (const tp of templatePaths) {
         if (existsSync88(tp)) {
-          templateContent = readFileSync64(tp, "utf-8");
+          templateContent = readFileSync63(tp, "utf-8");
           break;
         }
       }
@@ -62768,10 +62620,10 @@ function checkCleoGitignore(projectRoot) {
   };
 }
 function detectStorageEngine(projectRoot) {
-  const configPath = join92(projectRoot, ".cleo", "config.json");
+  const configPath = join91(projectRoot, ".cleo", "config.json");
   if (existsSync88(configPath)) {
     try {
-      const config2 = JSON.parse(readFileSync64(configPath, "utf-8"));
+      const config2 = JSON.parse(readFileSync63(configPath, "utf-8"));
       if (typeof config2.storageEngine === "string" && config2.storageEngine) {
         return config2.storageEngine;
       }
@@ -62782,7 +62634,7 @@ function detectStorageEngine(projectRoot) {
 }
 function checkVitalFilesTracked(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const gitDir = join92(root, ".git");
+  const gitDir = join91(root, ".git");
   if (!existsSync88(gitDir)) {
     return {
       id: "vital_files_tracked",
@@ -62797,7 +62649,7 @@ function checkVitalFilesTracked(projectRoot) {
   const vitalFiles = CORE_PROTECTED_FILES.map((f) => `.cleo/${f}`);
   const untracked = [];
   for (const file2 of vitalFiles) {
-    const fullPath = join92(root, file2);
+    const fullPath = join91(root, file2);
     if (!existsSync88(fullPath)) continue;
     try {
       execFileSync10("git", ["ls-files", "--error-unmatch", file2], {
@@ -62829,7 +62681,7 @@ function checkVitalFilesTracked(projectRoot) {
 }
 function checkCoreFilesNotIgnored(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const gitDir = join92(root, ".git");
+  const gitDir = join91(root, ".git");
   if (!existsSync88(gitDir)) {
     return {
       id: "core_files_not_ignored",
@@ -62843,7 +62695,7 @@ function checkCoreFilesNotIgnored(projectRoot) {
   const ignoredFiles = [];
   for (const file2 of CORE_PROTECTED_FILES) {
     const relPath = `.cleo/${file2}`;
-    const fullPath = join92(root, relPath);
+    const fullPath = join91(root, relPath);
     if (!existsSync88(fullPath)) continue;
     try {
       execFileSync10("git", ["check-ignore", "-q", relPath], {
@@ -62875,7 +62727,7 @@ function checkCoreFilesNotIgnored(projectRoot) {
 }
 function checkSqliteNotTracked(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const gitDir = join92(root, ".git");
+  const gitDir = join91(root, ".git");
   if (!existsSync88(gitDir)) {
     return {
       id: "sqlite_not_tracked",
@@ -62887,7 +62739,7 @@ function checkSqliteNotTracked(projectRoot) {
     };
   }
   const sqliteFile = ".cleo/tasks.db";
-  const fullPath = join92(root, sqliteFile);
+  const fullPath = join91(root, sqliteFile);
   if (!existsSync88(fullPath)) {
     return {
       id: "sqlite_not_tracked",
@@ -62924,7 +62776,7 @@ function checkSqliteNotTracked(projectRoot) {
 }
 function checkLegacyAgentOutputs(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const cleoDir = join92(root, ".cleo");
+  const cleoDir = join91(root, ".cleo");
   const detection = detectLegacyAgentOutputs(root, cleoDir);
   if (detection.hasLegacy) {
     return {
@@ -62950,11 +62802,11 @@ function checkCaampMarkerIntegrity(projectRoot) {
   const files = ["CLAUDE.md", "AGENTS.md"];
   const issues = [];
   for (const file2 of files) {
-    const filePath = join92(root, file2);
+    const filePath = join91(root, file2);
     if (!existsSync88(filePath)) continue;
     let content;
     try {
-      content = readFileSync64(filePath, "utf-8");
+      content = readFileSync63(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -62988,7 +62840,7 @@ function checkCaampMarkerIntegrity(projectRoot) {
 }
 function checkAtReferenceTargetExists(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const agentsPath = join92(root, "AGENTS.md");
+  const agentsPath = join91(root, "AGENTS.md");
   if (!existsSync88(agentsPath)) {
     return {
       id: "at_reference_targets",
@@ -63001,7 +62853,7 @@ function checkAtReferenceTargetExists(projectRoot) {
   }
   let content;
   try {
-    content = readFileSync64(agentsPath, "utf-8");
+    content = readFileSync63(agentsPath, "utf-8");
   } catch {
     return {
       id: "at_reference_targets",
@@ -63028,7 +62880,7 @@ function checkAtReferenceTargetExists(projectRoot) {
   const missing = [];
   for (const ref of refs) {
     const rawPath = ref.slice(1).trim();
-    const resolvedPath = rawPath.startsWith("~/") ? join92(homedir4(), rawPath.slice(2)) : join92(root, rawPath);
+    const resolvedPath = rawPath.startsWith("~/") ? join91(homedir4(), rawPath.slice(2)) : join91(root, rawPath);
     if (!existsSync88(resolvedPath)) {
       missing.push(rawPath);
     }
@@ -63055,8 +62907,8 @@ function checkAtReferenceTargetExists(projectRoot) {
 function checkTemplateFreshness(projectRoot, cleoHome) {
   const root = projectRoot ?? process.cwd();
   const home = cleoHome ?? getCleoHome();
-  const sourcePath = join92(root, "templates", "CLEO-INJECTION.md");
-  const deployedPath = join92(home, "templates", "CLEO-INJECTION.md");
+  const sourcePath = join91(root, "templates", "CLEO-INJECTION.md");
+  const deployedPath = join91(home, "templates", "CLEO-INJECTION.md");
   if (!existsSync88(sourcePath)) {
     return {
       id: "template_freshness",
@@ -63077,8 +62929,8 @@ function checkTemplateFreshness(projectRoot, cleoHome) {
       fix: "cp templates/CLEO-INJECTION.md ~/.cleo/templates/CLEO-INJECTION.md"
     };
   }
-  const sourceContent = readFileSync64(sourcePath, "utf-8");
-  const deployedContent = readFileSync64(deployedPath, "utf-8");
+  const sourceContent = readFileSync63(sourcePath, "utf-8");
+  const deployedContent = readFileSync63(deployedPath, "utf-8");
   if (sourceContent !== deployedContent) {
     return {
       id: "template_freshness",
@@ -63100,7 +62952,7 @@ function checkTemplateFreshness(projectRoot, cleoHome) {
 }
 function checkTierMarkersPresent(cleoHome) {
   const home = cleoHome ?? getCleoHome();
-  const templatePath = join92(home, "templates", "CLEO-INJECTION.md");
+  const templatePath = join91(home, "templates", "CLEO-INJECTION.md");
   if (!existsSync88(templatePath)) {
     return {
       id: "tier_markers_present",
@@ -63111,7 +62963,7 @@ function checkTierMarkersPresent(cleoHome) {
       fix: "Run install.sh to reinstall CLEO"
     };
   }
-  const content = readFileSync64(templatePath, "utf-8");
+  const content = readFileSync63(templatePath, "utf-8");
   const expectedTiers = ["minimal", "standard", "orchestrator"];
   const missing = [];
   const unclosed = [];
@@ -63222,7 +63074,7 @@ function checkGlobalSchemaHealth(_projectRoot) {
 }
 function checkNoLocalSchemas(projectRoot) {
   const root = projectRoot ?? process.cwd();
-  const localSchemasDir = join92(root, ".cleo", "schemas");
+  const localSchemasDir = join91(root, ".cleo", "schemas");
   if (!existsSync88(localSchemasDir)) {
     return {
       id: "no_local_schemas",
@@ -63287,13 +63139,13 @@ var databaseSyncCtor = (() => {
 })();
 var STALE_JSON_FILES = ["todo.json", "sessions.json", "todo-archive.json"];
 function resolveStructuredLogPath(cleoDir) {
-  const defaultPath = join93(cleoDir, "logs", "cleo.log");
-  const configPath = join93(cleoDir, "config.json");
+  const defaultPath = join92(cleoDir, "logs", "cleo.log");
+  const configPath = join92(cleoDir, "config.json");
   if (!existsSync89(configPath)) return defaultPath;
   try {
-    const config2 = JSON.parse(readFileSync65(configPath, "utf-8"));
+    const config2 = JSON.parse(readFileSync64(configPath, "utf-8"));
     if (!config2.logging?.filePath) return defaultPath;
-    return join93(cleoDir, config2.logging.filePath);
+    return join92(cleoDir, config2.logging.filePath);
   } catch {
     return defaultPath;
   }
@@ -63335,14 +63187,14 @@ function checkAuditLogAvailability(dbPath) {
   }
 }
 async function getSystemHealth(projectRoot, opts) {
-  const cleoDir = join93(projectRoot, ".cleo");
+  const cleoDir = join92(projectRoot, ".cleo");
   const checks = [];
   if (existsSync89(cleoDir)) {
     checks.push({ name: "cleo_dir", status: "pass", message: ".cleo directory exists" });
   } else {
     checks.push({ name: "cleo_dir", status: "fail", message: ".cleo directory not found" });
   }
-  const dbPath = join93(cleoDir, "tasks.db");
+  const dbPath = join92(cleoDir, "tasks.db");
   if (existsSync89(dbPath)) {
     try {
       const dbSize = statSync19(dbPath).size;
@@ -63364,7 +63216,7 @@ async function getSystemHealth(projectRoot, opts) {
   if (existsSync89(dbPath)) {
     checks.push(checkAuditLogAvailability(dbPath));
   }
-  const sdDbPath = join93(cleoDir, "signaldock.db");
+  const sdDbPath = join92(cleoDir, "signaldock.db");
   if (existsSync89(sdDbPath)) {
     try {
       const { DatabaseSync: SdDb } = _require6("node:sqlite");
@@ -63402,10 +63254,10 @@ async function getSystemHealth(projectRoot, opts) {
       message: "signaldock.db not found. Run: cleo init"
     });
   }
-  const configPath = join93(cleoDir, "config.json");
+  const configPath = join92(cleoDir, "config.json");
   if (existsSync89(configPath)) {
     try {
-      JSON.parse(readFileSync65(configPath, "utf-8"));
+      JSON.parse(readFileSync64(configPath, "utf-8"));
       checks.push({ name: "config_json", status: "pass", message: "config.json is valid JSON" });
     } catch {
       checks.push({
@@ -63418,7 +63270,7 @@ async function getSystemHealth(projectRoot, opts) {
     checks.push({ name: "config_json", status: "warn", message: "config.json not found" });
   }
   if (existsSync89(dbPath)) {
-    const staleFiles = STALE_JSON_FILES.filter((f) => existsSync89(join93(cleoDir, f)));
+    const staleFiles = STALE_JSON_FILES.filter((f) => existsSync89(join92(cleoDir, f)));
     if (staleFiles.length > 0) {
       checks.push({
         name: "stale_json",
@@ -63442,7 +63294,7 @@ async function getSystemHealth(projectRoot, opts) {
         message: `structured log not found: ${logPath}`
       });
     }
-    const backupDir = join93(cleoDir, ".backups");
+    const backupDir = join92(cleoDir, ".backups");
     if (existsSync89(backupDir)) {
       checks.push({ name: "backups_dir", status: "pass", message: ".backups directory exists" });
     } else {
@@ -63455,9 +63307,9 @@ async function getSystemHealth(projectRoot, opts) {
   }
   let version2 = "unknown";
   try {
-    const pkgPath = join93(projectRoot, "package.json");
+    const pkgPath = join92(projectRoot, "package.json");
     if (existsSync89(pkgPath)) {
-      const pkg = JSON.parse(readFileSync65(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync64(pkgPath, "utf-8"));
       version2 = pkg.version || "unknown";
     }
   } catch {
@@ -63491,8 +63343,8 @@ async function getSystemDiagnostics(projectRoot, opts) {
       details: preflight.summary
     });
   }
-  const cleoDir = join93(projectRoot, ".cleo");
-  const dbPath = join93(cleoDir, "tasks.db");
+  const cleoDir = join92(projectRoot, ".cleo");
+  const dbPath = join92(cleoDir, "tasks.db");
   if (existsSync89(dbPath)) {
     try {
       const accessor = await getAccessor(projectRoot);
@@ -63632,14 +63484,14 @@ function mapSchemaCheckResult(sr) {
   };
 }
 function checkContributorChannel(projectRoot) {
-  const configPath = join93(projectRoot, ".cleo", "config.json");
+  const configPath = join92(projectRoot, ".cleo", "config.json");
   if (!existsSync89(configPath)) {
     return { check: "contributor_channel", status: "ok", message: "Not a contributor project" };
   }
   let isContributor = false;
   let devCli = "cleo-dev";
   try {
-    const config2 = JSON.parse(readFileSync65(configPath, "utf-8"));
+    const config2 = JSON.parse(readFileSync64(configPath, "utf-8"));
     isContributor = config2.contributor?.isContributorProject === true;
     devCli = config2.contributor?.devCli ?? "cleo-dev";
   } catch {
@@ -63649,7 +63501,7 @@ function checkContributorChannel(projectRoot) {
     return { check: "contributor_channel", status: "ok", message: "Not a contributor project" };
   }
   const pathDirs = (process.env["PATH"] ?? "").split(":").filter(Boolean);
-  const devCliOnPath = pathDirs.some((dir) => existsSync89(join93(dir, devCli)));
+  const devCliOnPath = pathDirs.some((dir) => existsSync89(join92(dir, devCli)));
   if (!devCliOnPath) {
     return {
       check: "contributor_channel",
@@ -63682,14 +63534,14 @@ async function coreDoctorReport(projectRoot) {
     status: gitPath ? "ok" : "warning",
     message: gitPath ? `git found: ${gitPath}` : "git not found (optional, needed for version control features)"
   });
-  const cleoDir = join93(projectRoot, ".cleo");
+  const cleoDir = join92(projectRoot, ".cleo");
   const dirExists = existsSync89(cleoDir);
   checks.push({
     check: "project_dir",
     status: dirExists ? "ok" : "error",
     message: dirExists ? `Project dir: ${cleoDir}` : `Project dir not found: ${cleoDir}. Run: cleo init`
   });
-  const dbPath = join93(cleoDir, "tasks.db");
+  const dbPath = join92(cleoDir, "tasks.db");
   const dbExists2 = existsSync89(dbPath);
   const dbSize = await fileSize(dbPath);
   checks.push({
@@ -63739,14 +63591,14 @@ async function coreDoctorReport(projectRoot) {
     } catch {
     }
   }
-  const configPath = join93(cleoDir, "config.json");
+  const configPath = join92(cleoDir, "config.json");
   const configExists = existsSync89(configPath);
   checks.push({
     check: "config_file",
     status: configExists ? "ok" : "warning",
     message: configExists ? "config.json present" : "config.json not found (using defaults)"
   });
-  const staleJsonFiles = STALE_JSON_FILES.filter((f) => existsSync89(join93(cleoDir, f)));
+  const staleJsonFiles = STALE_JSON_FILES.filter((f) => existsSync89(join92(cleoDir, f)));
   if (dbExists2 && staleJsonFiles.length > 0) {
     checks.push({
       check: "stale_json",
@@ -63762,10 +63614,10 @@ async function coreDoctorReport(projectRoot) {
     status: logExists ? "ok" : "warning",
     message: logExists ? `structured log present: ${logPath}` : `structured log not found: ${logPath}`
   });
-  const rootGitignorePath = join93(projectRoot, ".gitignore");
+  const rootGitignorePath = join92(projectRoot, ".gitignore");
   if (existsSync89(rootGitignorePath)) {
     try {
-      const gitignoreContent = readFileSync65(rootGitignorePath, "utf-8");
+      const gitignoreContent = readFileSync64(rootGitignorePath, "utf-8");
       const blockingLines = gitignoreContent.split("\n").filter((line2) => {
         const trimmed = line2.trim();
         if (trimmed.startsWith("#") || trimmed === "") return false;
@@ -63784,7 +63636,7 @@ async function coreDoctorReport(projectRoot) {
   checks.push(mapCheckResult(checkVitalFilesTracked(projectRoot)));
   checks.push(mapCheckResult(checkCoreFilesNotIgnored(projectRoot)));
   checks.push(mapCheckResult(checkLegacyAgentOutputs(projectRoot)));
-  const cleoGitHeadExists = existsSync89(join93(cleoDir, ".git", "HEAD"));
+  const cleoGitHeadExists = existsSync89(join92(cleoDir, ".git", "HEAD"));
   checks.push({
     check: "cleo_git_repo",
     status: cleoGitHeadExists ? "ok" : "warning",
@@ -63800,15 +63652,15 @@ async function coreDoctorReport(projectRoot) {
   checks.push(mapCheckResult(checkProjectContext(projectRoot)));
   checks.push(mapCheckResult(checkInjection2(projectRoot)));
   checks.push(checkContributorChannel(projectRoot));
-  const agentDefPath = join93(getAgentsHome(), "agents", "cleo-subagent");
+  const agentDefPath = join92(getAgentsHome(), "agents", "cleo-subagent");
   checks.push({
     check: "agent_definition",
     status: existsSync89(agentDefPath) ? "ok" : "warning",
     message: existsSync89(agentDefPath) ? "cleo-subagent agent definition installed" : "cleo-subagent not found \u2014 run: cleo init",
     ...existsSync89(agentDefPath) ? {} : { fix: "cleo init" }
   });
-  const gitDir = join93(projectRoot, ".git");
-  const gitHubTemplatesDir = join93(projectRoot, ".github", "ISSUE_TEMPLATE");
+  const gitDir = join92(projectRoot, ".git");
+  const gitHubTemplatesDir = join92(projectRoot, ".github", "ISSUE_TEMPLATE");
   if (existsSync89(gitDir)) {
     checks.push({
       check: "github_templates",
@@ -63842,14 +63694,14 @@ async function coreDoctorReport(projectRoot) {
 
 // packages/core/src/system/inject-generate.ts
 init_data_accessor();
-import { existsSync as existsSync90, readFileSync as readFileSync66 } from "node:fs";
-import { join as join94 } from "node:path";
+import { existsSync as existsSync90, readFileSync as readFileSync65 } from "node:fs";
+import { join as join93 } from "node:path";
 async function generateInjection(projectRoot, accessor) {
   let version2 = "unknown";
   try {
-    const pkgPath = join94(projectRoot, "package.json");
+    const pkgPath = join93(projectRoot, "package.json");
     if (existsSync90(pkgPath)) {
-      const pkg = JSON.parse(readFileSync66(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync65(pkgPath, "utf-8"));
       version2 = pkg.version || "unknown";
     }
   } catch {
@@ -63896,7 +63748,7 @@ function buildMviMarkdown(state) {
   const focusLine = state.focusTask ? `| Focus | \`${state.focusTask}\` |` : "| Focus | none |";
   return `## CLEO Task Management (MVI)
 
-> **Bootstrap**: Call \`orchestrate.bootstrap\` with \`speed=fast\` at session start.
+> **Bootstrap**: Run \`cleo session status\` then \`cleo dash\` at session start.
 
 | Key | Value |
 |-----|-------|
@@ -63909,40 +63761,40 @@ ${focusLine}
 
 | Command | Description |
 |---------|-------------|
-| \`ct find "query"\` | Fuzzy search tasks (minimal context) |
-| \`ct show T1234\` | Full task details |
-| \`ct add "Title" --desc "..."\` | Create task |
-| \`ct done <id>\` | Complete task |
-| \`ct start <id>\` | Start working on task |
-| \`ct current\` | Show current task |
-| \`ct next\` | Suggest next task |
-| \`ct session list\` | List sessions |
-| \`ct session start --scope epic:T### --auto-start --name "..."\` | Start session |
-| \`ct session end --note "..."\` | End session |
-| \`ct dash\` | Project overview |
-| \`ct context\` | Context window usage |
+| \`cleo find "query"\` | Fuzzy search tasks (minimal context) |
+| \`cleo show T1234\` | Full task details |
+| \`cleo add "Title" -d "..."\` | Create task |
+| \`cleo done <id>\` | Complete task |
+| \`cleo start <id>\` | Start working on task |
+| \`cleo current\` | Show current task |
+| \`cleo next\` | Suggest next task |
+| \`cleo session list\` | List sessions |
+| \`cleo session start --scope epic:T### --auto-start --name "..."\` | Start session |
+| \`cleo session end --note "..."\` | End session |
+| \`cleo dash\` | Project overview |
+| \`cleo context\` | Context window usage |
 
 ### Session Protocol
 
-1. **START**: \`ct session list\` then \`ct session resume <id>\` or \`ct session start --scope epic:T### --auto-start --name "Work"\`
-2. **WORK**: \`ct current\` / \`ct next\` / \`ct complete <id>\` / \`ct start <id>\`
-3. **END**: \`ct complete <id>\` then \`ct session end --note "Progress"\`
+1. **START**: \`cleo session list\` then \`cleo session resume <id>\` or \`cleo session start --scope epic:T### --auto-start --name "Work"\`
+2. **WORK**: \`cleo current\` / \`cleo next\` / \`cleo complete <id>\` / \`cleo start <id>\`
+3. **END**: \`cleo complete <id>\` then \`cleo session end --note "Progress"\`
 
 ### Error Handling
 
 | Exit | Code | Fix |
 |:----:|------|-----|
-| 4 | \`E_NOT_FOUND\` | Use \`ct find\` or \`ct list\` to verify |
+| 4 | \`E_NOT_FOUND\` | Use \`cleo find\` or \`cleo list\` to verify |
 | 6 | \`E_VALIDATION\` | Check field lengths, escape \`$\` as \`\\$\` |
-| 10 | \`E_PARENT_NOT_FOUND\` | Verify with \`ct exists <parent-id>\` |
+| 10 | \`E_PARENT_NOT_FOUND\` | Verify with \`cleo exists <parent-id>\` |
 | 11 | \`E_DEPTH_EXCEEDED\` | Exceeds configured hierarchy.maxDepth (default: 3) |
 | 12 | \`E_SIBLING_LIMIT\` | Exceeds configured maxSiblings (default: unlimited) |
 
-**After EVERY command**: Check exit code (\`0\` = success), check \`"success"\` in JSON output, execute \`error.fix\` if provided.
+**After EVERY command**: Check exit code (\`0\` = success), check \`"success"\` in JSON output.
 
 ### Detailed Guidance
 
-For full protocol details, load the **ct-cleo** skill: \`query({ domain: "skills", operation: "show", params: { name: "ct-cleo" }})\`
+For full protocol details, load the **ct-cleo** skill.
 `;
 }
 
@@ -63977,10 +63829,10 @@ async function getLabels(cwd, accessor) {
 }
 
 // packages/core/src/system/metrics.ts
-import { existsSync as existsSync91, readFileSync as readFileSync67 } from "node:fs";
-import { join as join95 } from "node:path";
+import { existsSync as existsSync91, readFileSync as readFileSync66 } from "node:fs";
+import { join as join94 } from "node:path";
 async function getSystemMetrics(projectRoot, opts, accessor) {
-  const cleoDir = join95(projectRoot, ".cleo");
+  const cleoDir = join94(projectRoot, ".cleo");
   let complianceEntries = readComplianceJsonl(projectRoot);
   if (opts?.since) {
     complianceEntries = complianceEntries.filter((e) => e.timestamp >= opts.since);
@@ -64007,9 +63859,9 @@ async function getSystemMetrics(projectRoot, opts, accessor) {
       sessionsActive = sessions2.filter((s) => s.status === "active").length;
       sessionsCompleted = sessions2.filter((s) => s.status === "ended").length;
     } else {
-      const sessionsPath = join95(cleoDir, "sessions.json");
+      const sessionsPath = join94(cleoDir, "sessions.json");
       if (existsSync91(sessionsPath)) {
-        const sessionsData = JSON.parse(readFileSync67(sessionsPath, "utf-8"));
+        const sessionsData = JSON.parse(readFileSync66(sessionsPath, "utf-8"));
         const sessions2 = sessionsData.sessions ?? [];
         sessionsTotal = sessions2.length;
         sessionsActive = sessions2.filter((s) => s.status === "active").length;
@@ -64032,9 +63884,9 @@ init_src();
 init_errors3();
 init_data_accessor();
 import { existsSync as existsSync92 } from "node:fs";
-import { join as join96 } from "node:path";
+import { join as join95 } from "node:path";
 async function getMigrationStatus2(projectRoot, opts) {
-  const taskPath = join96(projectRoot, ".cleo", "tasks.db");
+  const taskPath = join95(projectRoot, ".cleo", "tasks.db");
   let currentVersion = "unknown";
   if (existsSync92(taskPath)) {
     try {
@@ -64066,7 +63918,7 @@ init_paths();
 import { execFile as execFile7 } from "node:child_process";
 import { existsSync as existsSync93 } from "node:fs";
 import { readFile as readFile15 } from "node:fs/promises";
-import { basename as basename15, join as join97 } from "node:path";
+import { basename as basename15, join as join96 } from "node:path";
 import { promisify as promisify7 } from "node:util";
 function normalizeChannel(value) {
   if (!value) return null;
@@ -64091,15 +63943,15 @@ function detectFromDataRoot(dataRoot) {
 function getExpectedNaming(channel) {
   switch (channel) {
     case "dev":
-      return { cli: "cleo-dev", mcp: "cleo-dev mcp", server: "cleo-dev" };
+      return { cli: "cleo-dev", mcp: "cli", server: "cleo-dev" };
     case "beta":
-      return { cli: "cleo-beta", mcp: "cleo-beta mcp", server: "cleo-beta" };
+      return { cli: "cleo-beta", mcp: "cli", server: "cleo-beta" };
     default:
-      return { cli: "cleo", mcp: "cleo mcp", server: "cleo" };
+      return { cli: "cleo", mcp: "cli", server: "cleo" };
   }
 }
 async function parseVersionFile(dataRoot) {
-  const versionPath = join97(dataRoot, "VERSION");
+  const versionPath = join96(dataRoot, "VERSION");
   if (!existsSync93(versionPath)) return null;
   let content;
   try {
@@ -64129,9 +63981,9 @@ async function parseVersionFile(dataRoot) {
 async function getPackageInfo(sourceDir) {
   const candidates = [];
   if (sourceDir && sourceDir !== "unknown" && sourceDir !== "npm") {
-    candidates.push(join97(sourceDir, "package.json"));
+    candidates.push(join96(sourceDir, "package.json"));
   }
-  candidates.push(join97(process.cwd(), "package.json"));
+  candidates.push(join96(process.cwd(), "package.json"));
   for (const candidate of candidates) {
     try {
       const raw = await readFile15(candidate, "utf-8");
@@ -64210,17 +64062,17 @@ async function getRuntimeDiagnostics(options) {
 init_src();
 init_errors3();
 init_data_accessor();
-import { existsSync as existsSync94, readFileSync as readFileSync68, writeFileSync as writeFileSync15 } from "node:fs";
-import { join as join98 } from "node:path";
+import { existsSync as existsSync94, readFileSync as readFileSync67, writeFileSync as writeFileSync15 } from "node:fs";
+import { join as join97 } from "node:path";
 function safestop(projectRoot, opts) {
   const dryRun = opts?.dryRun ?? false;
   const reason = opts?.reason ?? "Manual safestop";
   let sessionEnded = false;
   if (!dryRun && !opts?.noSessionEnd) {
-    const sessPath = join98(projectRoot, ".cleo", "sessions.json");
+    const sessPath = join97(projectRoot, ".cleo", "sessions.json");
     if (existsSync94(sessPath)) {
       try {
-        const data = JSON.parse(readFileSync68(sessPath, "utf-8"));
+        const data = JSON.parse(readFileSync67(sessPath, "utf-8"));
         const sessions2 = data.sessions ?? [];
         let changed = false;
         for (const s of sessions2) {
@@ -64245,7 +64097,7 @@ async function uncancelTask(projectRoot, params) {
   if (!params.taskId) {
     throw new CleoError(2 /* INVALID_INPUT */, "taskId is required");
   }
-  const taskDbPath = join98(projectRoot, ".cleo", "tasks.db");
+  const taskDbPath = join97(projectRoot, ".cleo", "tasks.db");
   if (!existsSync94(taskDbPath)) {
     throw new CleoError(8 /* CONFIG_ERROR */, "No tasks.db found");
   }
@@ -64757,8 +64609,8 @@ __export(templates_exports, {
 });
 
 // packages/core/src/templates/parser.ts
-import { existsSync as existsSync95, readdirSync as readdirSync31, readFileSync as readFileSync69 } from "fs";
-import { join as join99 } from "path";
+import { existsSync as existsSync95, readdirSync as readdirSync31, readFileSync as readFileSync68 } from "fs";
+import { join as join98 } from "path";
 import { parse as parseYaml } from "yaml";
 var SUFFIX_PATTERNS = ["_report", "_request", "_question"];
 function deriveSubcommand(filename) {
@@ -64773,8 +64625,8 @@ function deriveSubcommand(filename) {
   return firstWord.toLowerCase();
 }
 function parseTemplateFile2(templateDir, filename) {
-  const filePath = join99(templateDir, filename);
-  const raw = readFileSync69(filePath, "utf-8");
+  const filePath = join98(templateDir, filename);
+  const raw = readFileSync68(filePath, "utf-8");
   const parsed = parseYaml(raw);
   const name2 = typeof parsed.name === "string" ? parsed.name : filename;
   const titlePrefix = typeof parsed.title === "string" ? parsed.title : "";
@@ -64823,7 +64675,7 @@ function parseTemplateFile2(templateDir, filename) {
   };
 }
 function parseIssueTemplates2(projectRoot) {
-  const templateDir = join99(projectRoot, ".github", "ISSUE_TEMPLATE");
+  const templateDir = join98(projectRoot, ".github", "ISSUE_TEMPLATE");
   if (!existsSync95(templateDir)) {
     return {
       success: false,
@@ -64971,9 +64823,9 @@ __export(ui_exports, {
 });
 
 // packages/core/src/ui/aliases.ts
-import { existsSync as existsSync96, readFileSync as readFileSync70, writeFileSync as writeFileSync16 } from "node:fs";
+import { existsSync as existsSync96, readFileSync as readFileSync69, writeFileSync as writeFileSync16 } from "node:fs";
 import { homedir as homedir5, platform as platform3 } from "node:os";
-import { join as join100 } from "node:path";
+import { join as join99 } from "node:path";
 var MARKER_START = "# CLEO-CLAUDE-ALIASES:START";
 var MARKER_END = "# CLEO-CLAUDE-ALIASES:END";
 var ALIASES_VERSION = "1.0.0";
@@ -64995,16 +64847,16 @@ function getRcFilePath(shell) {
   const sh = shell ?? getCurrentShell();
   switch (sh) {
     case "bash":
-      return join100(home, ".bashrc");
+      return join99(home, ".bashrc");
     case "zsh":
-      return join100(home, ".zshrc");
+      return join99(home, ".zshrc");
     case "powershell":
-      return join100(home, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1");
+      return join99(home, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1");
     case "cmd":
       return "";
     // CMD doesn't have a standard RC
     default:
-      return join100(home, ".bashrc");
+      return join99(home, ".bashrc");
   }
 }
 function detectAvailableShells() {
@@ -65043,12 +64895,12 @@ function generatePowershellAliases(cleoPath) {
 }
 function hasAliasBlock(filePath) {
   if (!existsSync96(filePath)) return false;
-  const content = readFileSync70(filePath, "utf-8");
+  const content = readFileSync69(filePath, "utf-8");
   return content.includes(MARKER_START) && content.includes(MARKER_END);
 }
 function getInstalledVersion(filePath) {
   if (!existsSync96(filePath)) return null;
-  const content = readFileSync70(filePath, "utf-8");
+  const content = readFileSync69(filePath, "utf-8");
   const match = content.match(/CLEO CLI aliases \(v([^)]+)\)/);
   return match?.[1] ?? null;
 }
@@ -65058,7 +64910,7 @@ function injectAliases(filePath, shell = "bash", cleoPath) {
     writeFileSync16(filePath, content + "\n", "utf-8");
     return { action: "created", version: ALIASES_VERSION };
   }
-  const existing = readFileSync70(filePath, "utf-8");
+  const existing = readFileSync69(filePath, "utf-8");
   if (hasAliasBlock(filePath)) {
     const startIdx = existing.indexOf(MARKER_START);
     const endIdx = existing.indexOf(MARKER_END) + MARKER_END.length;
@@ -65071,7 +64923,7 @@ function injectAliases(filePath, shell = "bash", cleoPath) {
 }
 function removeAliases(filePath) {
   if (!existsSync96(filePath) || !hasAliasBlock(filePath)) return false;
-  const existing = readFileSync70(filePath, "utf-8");
+  const existing = readFileSync69(filePath, "utf-8");
   const startIdx = existing.indexOf(MARKER_START);
   const endIdx = existing.indexOf(MARKER_END) + MARKER_END.length;
   const before = existing.slice(0, startIdx).replace(/\n+$/, "\n");
@@ -65093,7 +64945,7 @@ function checkAliasesStatus(shell) {
 
 // packages/core/src/ui/changelog.ts
 init_data_accessor();
-import { appendFileSync as appendFileSync9, existsSync as existsSync97, readFileSync as readFileSync71, writeFileSync as writeFileSync17 } from "node:fs";
+import { appendFileSync as appendFileSync9, existsSync as existsSync97, readFileSync as readFileSync70, writeFileSync as writeFileSync17 } from "node:fs";
 var LABEL_CATEGORIES = {
   feature: "Features",
   feat: "Features",
@@ -65203,7 +65055,7 @@ function appendToChangelog(filePath, newContent) {
 ${newContent}`, "utf-8");
     return;
   }
-  const existing = readFileSync71(filePath, "utf-8");
+  const existing = readFileSync70(filePath, "utf-8");
   const headerMatch = existing.match(/^# .+\n/m);
   if (headerMatch) {
     const insertPos = (headerMatch.index ?? 0) + headerMatch[0].length;
@@ -65243,13 +65095,13 @@ ${markdown}`);
 }
 
 // packages/core/src/ui/command-registry.ts
-import { existsSync as existsSync98, readdirSync as readdirSync32, readFileSync as readFileSync72 } from "node:fs";
-import { basename as basename16, join as join101 } from "node:path";
+import { existsSync as existsSync98, readdirSync as readdirSync32, readFileSync as readFileSync71 } from "node:fs";
+import { basename as basename16, join as join100 } from "node:path";
 var CLEO_HEADER_START = "###CLEO";
 var CLEO_HEADER_END = "###END";
 function parseCommandHeader(scriptPath) {
   if (!existsSync98(scriptPath)) return null;
-  const content = readFileSync72(scriptPath, "utf-8");
+  const content = readFileSync71(scriptPath, "utf-8");
   const lines = content.split("\n");
   let inHeader = false;
   const headerLines = [];
@@ -65330,7 +65182,7 @@ function scanAllCommands(scriptsDir) {
   if (!existsSync98(scriptsDir)) return registry2;
   for (const file2 of readdirSync32(scriptsDir)) {
     if (!file2.endsWith(".sh") && !file2.endsWith(".ts")) continue;
-    const meta = parseCommandHeader(join101(scriptsDir, file2));
+    const meta = parseCommandHeader(join100(scriptsDir, file2));
     if (meta) {
       registry2.set(meta.command, meta);
     }
@@ -65621,7 +65473,7 @@ __export(validation_exports, {
   validatePhaseTimestamps: () => validatePhaseTimestamps,
   validateSessionNote: () => validateSessionNote,
   validateSingleActivePhase: () => validateSingleActivePhase,
-  validateStatusTransition: () => validateStatusTransition,
+  validateStatusTransition: () => validateStatusTransition2,
   validateTask: () => validateTask,
   validateTitle: () => validateTitle2
 });
@@ -66270,8 +66122,8 @@ function calculateOrchestrationOverhead(orchestratorTokens, totalSubagentTokens,
 }
 
 // packages/core/src/validation/docs-sync.ts
-import { existsSync as existsSync99, readdirSync as readdirSync33, readFileSync as readFileSync73 } from "node:fs";
-import { join as join102 } from "node:path";
+import { existsSync as existsSync99, readdirSync as readdirSync33, readFileSync as readFileSync72 } from "node:fs";
+import { join as join101 } from "node:path";
 function getScriptCommands(scriptsDir) {
   if (!existsSync99(scriptsDir)) return [];
   try {
@@ -66283,7 +66135,7 @@ function getScriptCommands(scriptsDir) {
 function getIndexScripts(indexPath) {
   if (!existsSync99(indexPath)) return [];
   try {
-    const content = readFileSync73(indexPath, "utf-8");
+    const content = readFileSync72(indexPath, "utf-8");
     const index2 = JSON.parse(content);
     return index2.commands.map((cmd) => cmd.script ?? "").filter((s) => s).map((s) => s.replace(/\.sh$/, "")).sort();
   } catch {
@@ -66293,7 +66145,7 @@ function getIndexScripts(indexPath) {
 function getIndexCommands(indexPath) {
   if (!existsSync99(indexPath)) return [];
   try {
-    const content = readFileSync73(indexPath, "utf-8");
+    const content = readFileSync72(indexPath, "utf-8");
     const index2 = JSON.parse(content);
     return index2.commands.map((cmd) => cmd.name).sort();
   } catch {
@@ -66330,8 +66182,8 @@ function checkWrapperSync(wrapperPath, indexPath) {
   if (!existsSync99(wrapperPath) || !existsSync99(indexPath)) return [];
   const issues = [];
   try {
-    const wrapperContent = readFileSync73(wrapperPath, "utf-8");
-    const indexContent = readFileSync73(indexPath, "utf-8");
+    const wrapperContent = readFileSync72(wrapperPath, "utf-8");
+    const indexContent = readFileSync72(indexPath, "utf-8");
     const index2 = JSON.parse(indexContent);
     const match = wrapperContent.match(/_get_all_commands\(\)\s*\{[^}]*echo\s+"([^"]+)"/);
     const wrapperCmds = new Set(match ? match[1].split(/\s+/).filter(Boolean) : []);
@@ -66364,16 +66216,16 @@ var CRITICAL_COMMANDS = [
 ];
 function detectDrift(mode = "full", projectRoot = ".") {
   const issues = [];
-  const scriptsDir = join102(projectRoot, "scripts");
-  const indexPath = join102(projectRoot, "docs/commands/COMMANDS-INDEX.json");
+  const scriptsDir = join101(projectRoot, "scripts");
+  const indexPath = join101(projectRoot, "docs/commands/COMMANDS-INDEX.json");
   issues.push(...checkCommandsSync(scriptsDir, indexPath));
-  const wrapperPath = join102(projectRoot, "installer/lib/link.sh");
+  const wrapperPath = join101(projectRoot, "installer/lib/link.sh");
   issues.push(...checkWrapperSync(wrapperPath, indexPath));
   if (mode === "full") {
-    const readmePath = join102(projectRoot, "README.md");
+    const readmePath = join101(projectRoot, "README.md");
     if (existsSync99(readmePath)) {
       try {
-        const readme = readFileSync73(readmePath, "utf-8");
+        const readme = readFileSync72(readmePath, "utf-8");
         const readmeCmds = new Set(
           (readme.match(/cleo [a-z-]+/g) ?? []).map((m) => m.replace("cleo ", ""))
         );
@@ -66391,9 +66243,9 @@ function detectDrift(mode = "full", projectRoot = ".") {
       }
     }
   }
-  const hasErrors = issues.some((i) => i.severity === "error");
+  const hasErrors2 = issues.some((i) => i.severity === "error");
   const hasWarnings = issues.some((i) => i.severity === "warning");
-  const exitCode = hasErrors ? 2 : hasWarnings ? 1 : 0;
+  const exitCode = hasErrors2 ? 2 : hasWarnings ? 1 : 0;
   return { mode, issues, exitCode };
 }
 function shouldRunDriftDetection(enabled = true, autoCheck = false, command, criticalCommands = []) {
@@ -66407,14 +66259,14 @@ function shouldRunDriftDetection(enabled = true, autoCheck = false, command, cri
 // packages/core/src/validation/doctor/project-cache.ts
 init_paths();
 import { createHash as createHash10 } from "node:crypto";
-import { existsSync as existsSync100, mkdirSync as mkdirSync22, readFileSync as readFileSync74, unlinkSync as unlinkSync7, writeFileSync as writeFileSync18 } from "node:fs";
-import { dirname as dirname18, join as join103 } from "node:path";
+import { existsSync as existsSync100, mkdirSync as mkdirSync22, readFileSync as readFileSync73, unlinkSync as unlinkSync7, writeFileSync as writeFileSync18 } from "node:fs";
+import { dirname as dirname18, join as join102 } from "node:path";
 var CACHE_VERSION = "1.0.0";
 var CACHE_TTL_SECONDS = 300;
 var CACHE_FILE2 = "doctor-project-cache.json";
 function getCacheFilePath(cleoHome) {
   const home = cleoHome ?? getCleoHome();
-  return join103(home, CACHE_FILE2);
+  return join102(home, CACHE_FILE2);
 }
 function initCacheFile(cacheFile) {
   const cache = {
@@ -66432,7 +66284,7 @@ function initCacheFile(cacheFile) {
 function loadCache(cacheFile) {
   if (!existsSync100(cacheFile)) return null;
   try {
-    const content = readFileSync74(cacheFile, "utf-8");
+    const content = readFileSync73(cacheFile, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -66441,7 +66293,7 @@ function loadCache(cacheFile) {
 function getFileHash(filePath) {
   if (!existsSync100(filePath)) return "";
   try {
-    const content = readFileSync74(filePath);
+    const content = readFileSync73(filePath);
     return createHash10("sha256").update(content).digest("hex");
   } catch {
     return "";
@@ -66458,8 +66310,8 @@ function getCachedValidation(projectHash, projectPath, cacheFile) {
   const now = Date.now();
   const age = (now - lastValidated) / 1e3;
   if (age > (entry.ttl || CACHE_TTL_SECONDS)) return null;
-  const currentTasksDbHash = getFileHash(join103(projectPath, ".cleo", "tasks.db"));
-  const currentConfigHash = getFileHash(join103(projectPath, ".cleo", "config.json"));
+  const currentTasksDbHash = getFileHash(join102(projectPath, ".cleo", "tasks.db"));
+  const currentConfigHash = getFileHash(join102(projectPath, ".cleo", "config.json"));
   if (currentTasksDbHash !== (entry.fileHashes["tasks.db"] ?? "")) return null;
   if (currentConfigHash !== (entry.fileHashes["config.json"] ?? "")) return null;
   return entry;
@@ -66470,8 +66322,8 @@ function cacheValidationResult(projectHash, projectPath, validationStatus, issue
   if (!cache) {
     cache = initCacheFile(cachePath);
   }
-  const tasksDbHash = getFileHash(join103(projectPath, ".cleo", "tasks.db"));
-  const configHash = getFileHash(join103(projectPath, ".cleo", "config.json"));
+  const tasksDbHash = getFileHash(join102(projectPath, ".cleo", "tasks.db"));
+  const configHash = getFileHash(join102(projectPath, ".cleo", "config.json"));
   const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
   cache.projects[projectHash] = {
     path: projectPath,
@@ -66889,7 +66741,7 @@ var STATUS_TRANSITIONS = {
   cancelled: ["pending"],
   archived: []
 };
-function validateStatusTransition(oldStatus, newStatus) {
+function validateStatusTransition2(oldStatus, newStatus) {
   if (oldStatus === newStatus) {
     return { valid: true, errors: [], warnings: [] };
   }
@@ -67653,7 +67505,7 @@ async function validateAndLog(taskId, manifestPath = DEFAULT_MANIFEST_PATH, comp
 
 // packages/core/src/validation/protocol-common.ts
 init_src();
-import { existsSync as existsSync102, readdirSync as readdirSync34, readFileSync as readFileSync75 } from "node:fs";
+import { existsSync as existsSync102, readdirSync as readdirSync34, readFileSync as readFileSync74 } from "node:fs";
 function checkOutputFileExists(taskId, expectedDir, pattern) {
   if (!existsSync102(expectedDir)) return false;
   const filePattern = pattern ?? `${taskId}`;
@@ -67667,7 +67519,7 @@ function checkOutputFileExists(taskId, expectedDir, pattern) {
 function checkDocumentationSections(filePath, sections) {
   if (!existsSync102(filePath)) return false;
   try {
-    const content = readFileSync75(filePath, "utf-8");
+    const content = readFileSync74(filePath, "utf-8");
     return sections.every((section) => {
       const regex = new RegExp(`^#+ .*${escapeRegex3(section)}`, "m");
       return regex.test(content);
@@ -67762,7 +67614,7 @@ function checkLinkedTasksPresent(entry, requiredIds) {
 function checkProvenanceTags(filePath, taskId) {
   if (!existsSync102(filePath)) return false;
   try {
-    const content = readFileSync75(filePath, "utf-8");
+    const content = readFileSync74(filePath, "utf-8");
     if (taskId) {
       return content.includes(`@task ${taskId}`);
     }
@@ -68424,13 +68276,13 @@ import { randomUUID as randomUUID7 } from "node:crypto";
 
 // packages/core/src/sessions/context-alert.ts
 init_paths();
-import { existsSync as existsSync104, readFileSync as readFileSync77, writeFileSync as writeFileSync19 } from "node:fs";
-import { join as join105 } from "node:path";
+import { existsSync as existsSync104, readFileSync as readFileSync76, writeFileSync as writeFileSync19 } from "node:fs";
+import { join as join104 } from "node:path";
 function getCurrentSessionId(cwd) {
   if (process.env.CLEO_SESSION) return process.env.CLEO_SESSION;
-  const sessionFile = join105(getCleoDir(cwd), ".current-session");
+  const sessionFile = join104(getCleoDir(cwd), ".current-session");
   if (existsSync104(sessionFile)) {
-    return readFileSync77(sessionFile, "utf-8").trim() || null;
+    return readFileSync76(sessionFile, "utf-8").trim() || null;
   }
   return null;
 }
@@ -68522,13 +68374,13 @@ init_paths();
 
 // packages/core/src/project-info.ts
 init_paths();
-import { existsSync as existsSync105, readFileSync as readFileSync78, writeFileSync as writeFileSync20 } from "node:fs";
+import { existsSync as existsSync105, readFileSync as readFileSync77, writeFileSync as writeFileSync20 } from "node:fs";
 import { readFile as readFile18 } from "node:fs/promises";
-import { join as join106 } from "node:path";
+import { join as join105 } from "node:path";
 async function getProjectInfo(cwd) {
   const projectRoot = cwd ?? process.cwd();
   const cleoDir = getCleoDirAbsolute(projectRoot);
-  const infoPath = join106(cleoDir, "project-info.json");
+  const infoPath = join105(cleoDir, "project-info.json");
   const raw = await readFile18(infoPath, "utf-8");
   const data = JSON.parse(raw);
   if (typeof data.projectHash !== "string" || data.projectHash.length === 0) {
@@ -68546,10 +68398,10 @@ async function getProjectInfo(cwd) {
 function getProjectInfoSync(cwd) {
   const projectRoot = cwd ?? process.cwd();
   const cleoDir = getCleoDirAbsolute(projectRoot);
-  const infoPath = join106(cleoDir, "project-info.json");
+  const infoPath = join105(cleoDir, "project-info.json");
   if (!existsSync105(infoPath)) return null;
   try {
-    const raw = readFileSync78(infoPath, "utf-8");
+    const raw = readFileSync77(infoPath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data.projectHash !== "string" || data.projectHash.length === 0) {
       return null;
@@ -68568,9 +68420,9 @@ function getProjectInfoSync(cwd) {
 }
 function updateProjectName(cwd, name2) {
   const cleoDir = getCleoDirAbsolute(cwd);
-  const infoPath = join106(cleoDir, "project-info.json");
+  const infoPath = join105(cleoDir, "project-info.json");
   if (!existsSync105(infoPath)) return;
-  const data = JSON.parse(readFileSync78(infoPath, "utf-8"));
+  const data = JSON.parse(readFileSync77(infoPath, "utf-8"));
   data.projectName = name2;
   data.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
   writeFileSync20(infoPath, `${JSON.stringify(data, null, 2)}
@@ -68584,10 +68436,10 @@ init_adapters();
 // packages/core/src/bootstrap.ts
 init_paths();
 init_scaffold();
-import { existsSync as existsSync106, readFileSync as readFileSync79 } from "node:fs";
+import { existsSync as existsSync106, readFileSync as readFileSync78 } from "node:fs";
 import { mkdir as mkdir17, readFile as readFile19, writeFile as writeFile12 } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
-import { join as join107 } from "node:path";
+import { join as join106 } from "node:path";
 async function bootstrapGlobalCleo(options) {
   const ctx = {
     created: [],
@@ -68600,7 +68452,6 @@ async function bootstrapGlobalCleo(options) {
   }
   await ensureGlobalTemplatesBootstrap(ctx, options?.packageRoot);
   await injectAgentsHub(ctx);
-  await installMcpToProviders(ctx);
   await installSkillsGlobally(ctx);
   await installAgentDefinitionGlobally(ctx);
   await installProviderAdapters(ctx, options?.packageRoot);
@@ -68622,9 +68473,9 @@ async function ensureGlobalTemplatesBootstrap(ctx, packageRootOverride) {
   let templateContent = null;
   try {
     const pkgRoot = packageRootOverride ?? getPackageRoot();
-    const templatePath = join107(pkgRoot, "templates", "CLEO-INJECTION.md");
+    const templatePath = join106(pkgRoot, "templates", "CLEO-INJECTION.md");
     if (existsSync106(templatePath)) {
-      templateContent = readFileSync79(templatePath, "utf-8");
+      templateContent = readFileSync78(templatePath, "utf-8");
     }
   } catch {
   }
@@ -68641,15 +68492,15 @@ async function ensureGlobalTemplatesBootstrap(ctx, packageRootOverride) {
     ctx.warnings.push("Could not refresh CLEO-INJECTION.md template");
     return;
   }
-  const xdgDest = join107(globalTemplatesDir, "CLEO-INJECTION.md");
+  const xdgDest = join106(globalTemplatesDir, "CLEO-INJECTION.md");
   const xdgWritten = await writeTemplateTo(templateContent, xdgDest, ctx.isDryRun);
   ctx.created.push(
     `${getCleoTemplatesTildePath()}/CLEO-INJECTION.md (${xdgWritten ? "refreshed" : "would refresh"})`
   );
   const home = homedir6();
-  const legacyTemplatesDir = join107(home, ".cleo", "templates");
-  if (legacyTemplatesDir !== globalTemplatesDir && existsSync106(join107(home, ".cleo"))) {
-    const legacyDest = join107(legacyTemplatesDir, "CLEO-INJECTION.md");
+  const legacyTemplatesDir = join106(home, ".cleo", "templates");
+  if (legacyTemplatesDir !== globalTemplatesDir && existsSync106(join106(home, ".cleo"))) {
+    const legacyDest = join106(legacyTemplatesDir, "CLEO-INJECTION.md");
     const legacyWritten = await writeTemplateTo(templateContent, legacyDest, ctx.isDryRun);
     if (legacyWritten) {
       ctx.created.push("~/.cleo/templates/CLEO-INJECTION.md (legacy sync)");
@@ -68668,7 +68519,7 @@ function sanitizeCaampFile(content) {
 }
 async function injectAgentsHub(ctx) {
   const globalAgentsDir = getAgentsHome();
-  const globalAgentsMd = join107(globalAgentsDir, "AGENTS.md");
+  const globalAgentsMd = join106(globalAgentsDir, "AGENTS.md");
   try {
     const { inject: inject2, getInstalledProviders: getInstalledProviders3, injectAll: injectAll2, buildInjectionContent } = await import("@cleocode/caamp");
     if (!ctx.isDryRun) {
@@ -68708,7 +68559,7 @@ async function injectAgentsHub(ctx) {
       });
       if (!ctx.isDryRun) {
         for (const provider of providers) {
-          const instructFilePath = join107(provider.pathGlobal, provider.instructFile);
+          const instructFilePath = join106(provider.pathGlobal, provider.instructFile);
           if (existsSync106(instructFilePath)) {
             const fileContent = await readFile19(instructFilePath, "utf8");
             const stripped = fileContent.replace(
@@ -68727,7 +68578,7 @@ async function injectAgentsHub(ctx) {
         }
       } else {
         for (const p of providers) {
-          const displayPath = join107(p.pathGlobal, p.instructFile).replace(homedir6(), "~");
+          const displayPath = join106(p.pathGlobal, p.instructFile).replace(homedir6(), "~");
           ctx.created.push(`${displayPath} (would update CAAMP block)`);
         }
       }
@@ -68736,37 +68587,6 @@ async function injectAgentsHub(ctx) {
     ctx.warnings.push(`CAAMP injection: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-async function installMcpToProviders(ctx) {
-  try {
-    const { detectEnvMode: detectEnvMode2, generateMcpServerEntry: generateMcpServerEntry2, getMcpServerName: getMcpServerName2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
-    const { getInstalledProviders: getInstalledProviders3, installMcpServerToAll } = await import("@cleocode/caamp");
-    const env = detectEnvMode2();
-    const serverEntry = generateMcpServerEntry2(env);
-    const serverName = getMcpServerName2(env);
-    const providers = getInstalledProviders3();
-    if (providers.length > 0) {
-      if (!ctx.isDryRun) {
-        const results = await installMcpServerToAll(
-          providers,
-          serverName,
-          serverEntry,
-          "global",
-          homedir6()
-        );
-        const successes = results.filter((r) => r.success);
-        if (successes.length > 0) {
-          ctx.created.push(
-            `MCP configs: ${successes.map((r) => r.provider.id).join(", ")}`
-          );
-        }
-      } else {
-        ctx.created.push("MCP configs (would update)");
-      }
-    }
-  } catch {
-    ctx.warnings.push("MCP config update skipped (non-critical)");
-  }
-}
 async function installSkillsGlobally(ctx) {
   try {
     if (!ctx.isDryRun) {
@@ -68832,8 +68652,8 @@ async function installProviderAdapters(ctx, packageRootOverride) {
 async function verifyBootstrapHealth(ctx) {
   if (ctx.isDryRun) return;
   try {
-    const xdgTemplatePath = join107(getCleoTemplatesDir(), "CLEO-INJECTION.md");
-    const agentsMd = join107(getAgentsHome(), "AGENTS.md");
+    const xdgTemplatePath = join106(getCleoTemplatesDir(), "CLEO-INJECTION.md");
+    const agentsMd = join106(getAgentsHome(), "AGENTS.md");
     if (!existsSync106(xdgTemplatePath)) {
       ctx.warnings.push("Health: XDG template missing after bootstrap");
       return;
@@ -68841,7 +68661,7 @@ async function verifyBootstrapHealth(ctx) {
     const xdgContent = await readFile19(xdgTemplatePath, "utf8");
     const xdgVersion = xdgContent.match(/^Version:\s*(.+)$/m)?.[1]?.trim();
     const home = homedir6();
-    const legacyTemplatePath = join107(home, ".cleo", "templates", "CLEO-INJECTION.md");
+    const legacyTemplatePath = join106(home, ".cleo", "templates", "CLEO-INJECTION.md");
     if (existsSync106(legacyTemplatePath)) {
       const legacyContent = await readFile19(legacyTemplatePath, "utf8");
       const legacyVersion = legacyContent.match(/^Version:\s*(.+)$/m)?.[1]?.trim();
@@ -69394,7 +69214,6 @@ export {
   conduit_exports as conduit,
   context_exports as context,
   hooks_exports as coreHooks,
-  mcp_exports as coreMcp,
   createDataAccessor,
   createErrorResult,
   createPage,