@cleocode/cleo 2026.3.10 → 2026.3.12

package/dist/mcp/index.js

@@ -15696,9 +15696,9 @@ async function systemLog(projectRoot, filters) {
 }
 async function queryAuditLogSqlite(projectRoot, filters) {
   try {
-    const { join: join57 } = await import("node:path");
+    const { join: join56 } = await import("node:path");
     const { existsSync: existsSync54 } = await import("node:fs");
-    const dbPath = join57(projectRoot, ".cleo", "tasks.db");
+    const dbPath = join56(projectRoot, ".cleo", "tasks.db");
     if (!existsSync54(dbPath)) return null;
     const { getDb: getDb2 } = await Promise.resolve().then(() => (init_sqlite(), sqlite_exports));
     const { auditLog: auditLog2 } = await Promise.resolve().then(() => (init_schema(), schema_exports));
@@ -16159,77 +16159,6 @@ var init_config_engine = __esm({
   }
 });
 
-// src/core/mcp/index.ts
-var mcp_exports = {};
-__export(mcp_exports, {
-  detectEnvMode: () => detectEnvMode,
-  generateMcpServerEntry: () => generateMcpServerEntry,
-  getMcpServerName: () => getMcpServerName
-});
-import { readFileSync as readFileSync20 } from "node:fs";
-import { join as join30 } from "node:path";
-import { homedir as homedir6 } from "node:os";
-function getMcpServerName(env) {
-  if (env.channel === "dev") return "cleo-dev";
-  if (env.channel === "beta") return "cleo-beta";
-  return "cleo";
-}
-function detectEnvMode() {
-  const versionPath = join30(
-    process.env["CLEO_HOME"] ?? join30(homedir6(), ".cleo"),
-    "VERSION"
-  );
-  let content;
-  try {
-    content = readFileSync20(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: [join30(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({
-  "src/core/mcp/index.ts"() {
-    "use strict";
-  }
-});
-
 // src/core/nexus/registry.ts
 var registry_exports = {};
 __export(registry_exports, {
@@ -16253,17 +16182,17 @@ __export(registry_exports, {
   readRegistryRequired: () => readRegistryRequired
 });
 import { createHash as createHash6 } from "node:crypto";
-import { join as join31 } from "node:path";
+import { join as join30 } from "node:path";
 import { mkdir as mkdir7, access as access2, readFile as readFile6 } from "node:fs/promises";
 import { z } from "zod";
 function getNexusHome() {
-  return process.env["NEXUS_HOME"] ?? join31(getCleoHome(), "nexus");
+  return process.env["NEXUS_HOME"] ?? join30(getCleoHome(), "nexus");
 }
 function getNexusCacheDir() {
-  return process.env["NEXUS_CACHE_DIR"] ?? join31(getNexusHome(), "cache");
+  return process.env["NEXUS_CACHE_DIR"] ?? join30(getNexusHome(), "cache");
 }
 function getRegistryPath() {
-  return process.env["NEXUS_REGISTRY_FILE"] ?? join31(getCleoHome(), "projects-registry.json");
+  return process.env["NEXUS_REGISTRY_FILE"] ?? join30(getCleoHome(), "projects-registry.json");
 }
 function generateProjectHash2(projectPath) {
   const hash = createHash6("sha256").update(projectPath).digest("hex");
@@ -16305,7 +16234,7 @@ async function nexusInit() {
 }
 async function isCleoProject(projectPath) {
   try {
-    await access2(join31(projectPath, ".cleo", "todo.json"));
+    await access2(join30(projectPath, ".cleo", "todo.json"));
     return true;
   } catch {
     return false;
@@ -16315,9 +16244,9 @@ async function readProjectMeta(projectPath) {
   try {
     let raw;
     try {
-      raw = await readFile6(join31(projectPath, ".cleo", "tasks.json"), "utf-8");
+      raw = await readFile6(join30(projectPath, ".cleo", "tasks.json"), "utf-8");
     } catch {
-      raw = await readFile6(join31(projectPath, ".cleo", "todo.json"), "utf-8");
+      raw = await readFile6(join30(projectPath, ".cleo", "todo.json"), "utf-8");
     }
     const data = JSON.parse(raw);
     const tasks2 = data.tasks ?? [];
@@ -16500,18 +16429,18 @@ var init_registry2 = __esm({
 
 // src/core/init.ts
 import { mkdir as mkdir8, copyFile as copyFile3, symlink, lstat, unlink as unlink3 } from "node:fs/promises";
-import { existsSync as existsSync29, readFileSync as readFileSync21, readdirSync as readdirSync8 } from "node:fs";
-import { join as join32, dirname as dirname8, basename as basename6 } from "node:path";
+import { existsSync as existsSync29, readFileSync as readFileSync20, readdirSync as readdirSync8 } from "node:fs";
+import { join as join31, dirname as dirname8, basename as basename6 } from "node:path";
 import { readFile as readFile7 } from "node:fs/promises";
-import { homedir as homedir7 } from "node:os";
+import { homedir as homedir6 } from "node:os";
 async function initAgentDefinition(created, warnings) {
   const packageRoot = getPackageRoot();
-  const agentSourceDir = join32(packageRoot, "agents", "cleo-subagent");
+  const agentSourceDir = join31(packageRoot, "agents", "cleo-subagent");
   if (!existsSync29(agentSourceDir)) {
     warnings.push("agents/cleo-subagent/ not found in package, skipping agent definition install");
     return;
   }
-  const globalAgentsDir = join32(homedir7(), ".agents", "agents", "cleo-subagent");
+  const globalAgentsDir = join31(homedir6(), ".agents", "agents", "cleo-subagent");
   await mkdir8(dirname8(globalAgentsDir), { recursive: true });
   try {
     try {
@@ -16528,7 +16457,7 @@ async function initAgentDefinition(created, warnings) {
       await mkdir8(globalAgentsDir, { recursive: true });
       const files = readdirSync8(agentSourceDir);
       for (const file of files) {
-        await copyFile3(join32(agentSourceDir, file), join32(globalAgentsDir, file));
+        await copyFile3(join31(agentSourceDir, file), join31(globalAgentsDir, file));
       }
       created.push("agent: cleo-subagent (copied)");
     } catch (copyErr) {
@@ -16536,41 +16465,6 @@ 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: getInstalledProviders2,
-      installMcpServerToAll
-    } = await import("@cleocode/caamp");
-    const env = detectEnvMode2();
-    const serverEntry = generateMcpServerEntry2(env);
-    const serverName = getMcpServerName2(env);
-    const providers = getInstalledProviders2();
-    if (providers.length === 0) {
-      return;
-    }
-    const results = await installMcpServerToAll(
-      providers,
-      serverName,
-      serverEntry,
-      "project",
-      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 initCoreSkills(created, warnings) {
   try {
     const { getInstalledProviders: getInstalledProviders2, installSkill: installSkill2, registerSkillLibraryFromPath } = await import("@cleocode/caamp");
@@ -16581,12 +16475,12 @@ async function initCoreSkills(created, warnings) {
     const packageRoot = getPackageRoot();
     let ctSkillsRoot = null;
     try {
-      const bundledPath = join32(packageRoot, "packages", "ct-skills");
-      if (existsSync29(join32(bundledPath, "skills.json"))) {
+      const bundledPath = join31(packageRoot, "packages", "ct-skills");
+      if (existsSync29(join31(bundledPath, "skills.json"))) {
         ctSkillsRoot = bundledPath;
       } else {
-        const ctSkillsPath = join32(packageRoot, "node_modules", "@cleocode", "ct-skills");
-        if (existsSync29(join32(ctSkillsPath, "skills.json"))) {
+        const ctSkillsPath = join31(packageRoot, "node_modules", "@cleocode", "ct-skills");
+        if (existsSync29(join31(ctSkillsPath, "skills.json"))) {
           ctSkillsRoot = ctSkillsPath;
         }
       }
@@ -16601,13 +16495,13 @@ async function initCoreSkills(created, warnings) {
     } catch {
       warnings.push("Failed to register skill library with CAAMP");
     }
-    const catalogPath = join32(ctSkillsRoot, "skills.json");
-    const catalog2 = JSON.parse(readFileSync21(catalogPath, "utf-8"));
+    const catalogPath = join31(ctSkillsRoot, "skills.json");
+    const catalog2 = JSON.parse(readFileSync20(catalogPath, "utf-8"));
     const skills = catalog2.skills ?? [];
     const coreSkills = skills.filter((s) => s.tier <= 2);
     const installed = [];
     for (const skill of coreSkills) {
-      const skillSourceDir = dirname8(join32(ctSkillsRoot, skill.path));
+      const skillSourceDir = dirname8(join31(ctSkillsRoot, skill.path));
       if (!existsSync29(skillSourceDir)) {
         continue;
       }
@@ -16684,7 +16578,7 @@ async function initProject(opts = {}) {
   }
   try {
     const { getDb: getDb2 } = await Promise.resolve().then(() => (init_sqlite(), sqlite_exports));
-    await getDb2(join32(cleoDir, ".."));
+    await getDb2(join31(cleoDir, ".."));
     created.push("tasks.db");
   } catch (err) {
     created.push(`tasks.db (deferred: ${err instanceof Error ? err.message : String(err)})`);
@@ -16697,7 +16591,7 @@ async function initProject(opts = {}) {
       created.push(".gitignore");
     }
   } else {
-    const gitignorePath = join32(cleoDir, ".gitignore");
+    const gitignorePath = join31(cleoDir, ".gitignore");
     if (existsSync29(gitignorePath)) {
       skipped.push(".gitignore");
     } else {
@@ -16709,12 +16603,12 @@ async function initProject(opts = {}) {
       }
     }
   }
-  const legacySequencePath = join32(cleoDir, ".sequence");
+  const legacySequencePath = join31(cleoDir, ".sequence");
   try {
     await unlink3(legacySequencePath);
   } catch {
   }
-  const legacySequenceJsonPath = join32(cleoDir, ".sequence.json");
+  const legacySequenceJsonPath = join31(cleoDir, ".sequence.json");
   try {
     await unlink3(legacySequenceJsonPath);
   } catch {
@@ -16781,7 +16675,6 @@ async function initProject(opts = {}) {
     warnings.push(`CAAMP injection: ${err instanceof Error ? err.message : String(err)}`);
   }
   await initAgentDefinition(created, warnings);
-  await initMcpServer(projRoot, created, warnings);
   await initCoreSkills(created, warnings);
   await initNexusRegistration(projRoot, projectName, created, warnings);
   const rootGitignoreResult = await removeCleoFromRootGitignore(projRoot);
@@ -16809,8 +16702,8 @@ async function initProject(opts = {}) {
 async function getVersion(projectRoot) {
   const root = projectRoot ?? getProjectRoot();
   const versionPaths = [
-    join32(root, "VERSION"),
-    join32(root, "..", "VERSION")
+    join31(root, "VERSION"),
+    join31(root, "..", "VERSION")
   ];
   for (const versionPath of versionPaths) {
     try {
@@ -16822,7 +16715,7 @@ async function getVersion(projectRoot) {
     } catch {
     }
   }
-  const pkg = await readJson(join32(root, "package.json"));
+  const pkg = await readJson(join31(root, "package.json"));
   if (pkg?.version) {
     return { version: pkg.version };
   }
@@ -16881,7 +16774,7 @@ var init_init_engine = __esm({
 });
 
 // src/core/lifecycle/rcasd-paths.ts
-import { join as join33 } from "node:path";
+import { join as join32 } from "node:path";
 import { existsSync as existsSync30, mkdirSync as mkdirSync10, readdirSync as readdirSync9 } from "node:fs";
 function normalizeEpicId(dirName) {
   const match = dirName.match(EPIC_ID_PATTERN);
@@ -16889,11 +16782,11 @@ function normalizeEpicId(dirName) {
 }
 function getEpicDir(epicId, cwd) {
   const normalized = normalizeEpicId(epicId);
-  return join33(getCleoDirAbsolute(cwd), DEFAULT_DIR, normalized);
+  return join32(getCleoDirAbsolute(cwd), DEFAULT_DIR, normalized);
 }
 function getStagePath(epicId, stage, cwd) {
   const subdir = STAGE_SUBDIRS[stage] ?? stage;
-  return join33(getEpicDir(epicId, cwd), subdir);
+  return join32(getEpicDir(epicId, cwd), subdir);
 }
 function ensureStagePath(epicId, stage, cwd) {
   const path = getStagePath(epicId, stage, cwd);
@@ -17268,7 +17161,7 @@ var init_stages = __esm({
 // src/core/lifecycle/stage-artifacts.ts
 import { existsSync as existsSync31 } from "node:fs";
 import { readFile as readFile8, writeFile as writeFile5 } from "node:fs/promises";
-import { dirname as dirname9, join as join34, relative } from "node:path";
+import { dirname as dirname9, join as join33, relative } from "node:path";
 function stageSlug(stage) {
   return stage.replace(/_/g, "-");
 }
@@ -17309,7 +17202,7 @@ function buildRelatedLinks(epicId, stage, absolutePath, cwd) {
   const artifactDir = dirname9(absolutePath);
   for (const prereq of prereqs) {
     const prereqDir = getStagePath(epicId, prereq, cwd);
-    const prereqFile = join34(prereqDir, `${epicId}-${stageSlug(prereq)}.md`);
+    const prereqFile = join33(prereqDir, `${epicId}-${stageSlug(prereq)}.md`);
     if (!existsSync31(prereqFile)) {
       continue;
     }
@@ -17323,7 +17216,7 @@ function buildRelatedLinks(epicId, stage, absolutePath, cwd) {
 async function ensureStageArtifact(epicId, stage, cwd) {
   const stageDir = ensureStagePath(epicId, stage, cwd);
   const fileName = `${epicId}-${stageSlug(stage)}.md`;
-  const absolutePath = join34(stageDir, fileName);
+  const absolutePath = join33(stageDir, fileName);
   const outputFile = toWorkspaceRelative(absolutePath, cwd);
   const currentContent = existsSync31(absolutePath) ? await readFile8(absolutePath, "utf-8") : buildDefaultBody(epicId, stage);
   const related = buildRelatedLinks(epicId, stage, absolutePath, cwd);
@@ -17400,8 +17293,8 @@ var init_evidence = __esm({
 });
 
 // src/core/adrs/parse.ts
-import { readFileSync as readFileSync22 } from "node:fs";
-import { join as join35 } from "node:path";
+import { readFileSync as readFileSync21 } from "node:fs";
+import { join as join34 } from "node:path";
 function extractAdrId(filename) {
   const match = filename.match(/^(ADR-\d+)/);
   return match ? match[1] : filename.replace(".md", "");
@@ -17423,8 +17316,8 @@ function extractTitle(content) {
   return match ? match[1].trim() : "Untitled";
 }
 function parseAdrFile(filePath, projectRoot) {
-  const absolutePath = filePath.startsWith("/") ? filePath : join35(projectRoot, filePath);
-  const content = readFileSync22(absolutePath, "utf-8");
+  const absolutePath = filePath.startsWith("/") ? filePath : join34(projectRoot, filePath);
+  const content = readFileSync21(absolutePath, "utf-8");
   const filename = filePath.split("/").pop();
   return {
     id: extractAdrId(filename),
@@ -17440,8 +17333,8 @@ var init_parse = __esm({
 });
 
 // src/core/adrs/sync.ts
-import { readFileSync as readFileSync23, readdirSync as readdirSync10, writeFileSync as writeFileSync6, existsSync as existsSync32 } from "node:fs";
-import { join as join36 } from "node:path";
+import { readFileSync as readFileSync22, readdirSync as readdirSync10, writeFileSync as writeFileSync6, existsSync as existsSync32 } from "node:fs";
+import { join as join35 } from "node:path";
 import { eq as eq9 } from "drizzle-orm";
 function extractAdrIdFromRef(ref) {
   const m = ref.match(/^(ADR-\d+)/);
@@ -17454,7 +17347,7 @@ function collectAdrFiles(dir) {
   const results = [];
   for (const entry of readdirSync10(dir, { withFileTypes: true })) {
     if (entry.isDirectory()) {
-      const sub = join36(dir, entry.name);
+      const sub = join35(dir, entry.name);
       for (const f of readdirSync10(sub)) {
         if (f.endsWith(".md") && /^ADR-\d+/.test(f)) {
           results.push({ file: f, relPath: `${entry.name}/${f}` });
@@ -17467,7 +17360,7 @@ function collectAdrFiles(dir) {
   return results.sort((a, b) => a.file.localeCompare(b.file));
 }
 async function syncAdrsToDb(projectRoot) {
-  const adrsDir = join36(projectRoot, ".cleo", "adrs");
+  const adrsDir = join35(projectRoot, ".cleo", "adrs");
   const result = { inserted: 0, updated: 0, skipped: 0, errors: [] };
   if (!existsSync32(adrsDir)) {
     return result;
@@ -17479,11 +17372,11 @@ async function syncAdrsToDb(projectRoot) {
   const manifestEntries2 = [];
   for (const { file, relPath } of activeFiles) {
     try {
-      const filePath = join36(adrsDir, relPath);
+      const filePath = join35(adrsDir, relPath);
       const record = parseAdrFile(filePath, projectRoot);
       const fm = record.frontmatter;
       const dbRelPath = `.cleo/adrs/${relPath}`;
-      const content = readFileSync23(filePath, "utf-8");
+      const content = readFileSync22(filePath, "utf-8");
       const supersedesId = fm.Supersedes ? extractAdrIdFromRef(fm.Supersedes) : null;
       const supersededById = fm["Superseded By"] ? extractAdrIdFromRef(fm["Superseded By"]) : null;
       const amendsId = fm.Amends ? extractAdrIdFromRef(fm.Amends) : null;
@@ -17525,7 +17418,7 @@ async function syncAdrsToDb(projectRoot) {
   }
   for (const { relPath } of allFiles) {
     try {
-      const filePath = join36(adrsDir, relPath);
+      const filePath = join35(adrsDir, relPath);
       const record = parseAdrFile(filePath, projectRoot);
       const fm = record.frontmatter;
       const entry = {
@@ -17553,7 +17446,7 @@ async function syncAdrsToDb(projectRoot) {
     }
   }
   writeFileSync6(
-    join36(adrsDir, "MANIFEST.jsonl"),
+    join35(adrsDir, "MANIFEST.jsonl"),
     manifestEntries2.map((e) => JSON.stringify(e)).join("\n") + "\n",
     "utf-8"
   );
@@ -17569,8 +17462,8 @@ var init_sync = __esm({
 });
 
 // src/core/adrs/link-pipeline.ts
-import { readdirSync as readdirSync11, readFileSync as readFileSync24, existsSync as existsSync33 } from "node:fs";
-import { join as join37 } from "node:path";
+import { readdirSync as readdirSync11, readFileSync as readFileSync23, existsSync as existsSync33 } from "node:fs";
+import { join as join36 } from "node:path";
 import { eq as eq10, and as and3 } from "drizzle-orm";
 function parseTaskIds2(raw) {
   if (!raw) return [];
@@ -17580,7 +17473,7 @@ function findAdrsForTask(adrsDir, taskId) {
   if (!existsSync33(adrsDir)) return [];
   return readdirSync11(adrsDir).filter((f) => f.endsWith(".md") && /^ADR-\d+/.test(f)).filter((file) => {
     try {
-      const content = readFileSync24(join37(adrsDir, file), "utf-8");
+      const content = readFileSync23(join36(adrsDir, file), "utf-8");
       const relatedTasksMatch = content.match(/^\*\*Related Tasks\*\*:\s*(.+)$/m);
       if (!relatedTasksMatch) return false;
       const taskIds = parseTaskIds2(relatedTasksMatch[1]);
@@ -17588,7 +17481,7 @@ function findAdrsForTask(adrsDir, taskId) {
     } catch {
       return false;
     }
-  }).map((f) => join37(adrsDir, f));
+  }).map((f) => join36(adrsDir, f));
 }
 async function linkPipelineAdr(projectRoot, taskId) {
   const result = {
@@ -17597,7 +17490,7 @@ async function linkPipelineAdr(projectRoot, taskId) {
     skipped: 0,
     errors: []
   };
-  const adrsDir = join37(projectRoot, ".cleo", "adrs");
+  const adrsDir = join36(projectRoot, ".cleo", "adrs");
   const matchingFiles = findAdrsForTask(adrsDir, taskId);
   if (matchingFiles.length === 0) {
     return result;
@@ -17609,7 +17502,7 @@ async function linkPipelineAdr(projectRoot, taskId) {
     try {
       const record = parseAdrFile(filePath, projectRoot);
       const fm = record.frontmatter;
-      const content = readFileSync24(filePath, "utf-8");
+      const content = readFileSync23(filePath, "utf-8");
       const relativePath = `.cleo/adrs/${filename}`;
       const existing = await db.select({ id: architectureDecisions.id }).from(architectureDecisions).where(eq10(architectureDecisions.id, record.id)).all();
       const rowBase = {
@@ -18375,7 +18268,7 @@ var init_validation_schemas = __esm({
 // src/core/validation/schema-validator.ts
 import AjvModule2 from "ajv";
 import addFormatsModule2 from "ajv-formats";
-import { readFileSync as readFileSync25 } from "fs";
+import { readFileSync as readFileSync24 } from "fs";
 function createAjv() {
   const ajv = new Ajv2({
     allErrors: true,
@@ -18404,7 +18297,7 @@ function getValidator(schemaType) {
     return null;
   }
   try {
-    const schemaContent = readFileSync25(schemaPath, "utf-8");
+    const schemaContent = readFileSync24(schemaPath, "utf-8");
     const schema = JSON.parse(schemaContent);
     const ajv = getAjv2();
     const validate = ajv.compile(schema);
@@ -18602,12 +18495,12 @@ var init_repair = __esm({
 });
 
 // src/core/validation/validate-ops.ts
-import { readFileSync as readFileSync26, existsSync as existsSync34, appendFileSync as appendFileSync3, mkdirSync as mkdirSync11 } from "node:fs";
+import { readFileSync as readFileSync25, existsSync as existsSync34, appendFileSync as appendFileSync3, mkdirSync as mkdirSync11 } from "node:fs";
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { join as join38, dirname as dirname10, resolve as resolve6 } from "node:path";
+import { join as join37, dirname as dirname10, resolve as resolve6 } from "node:path";
 function readJsonFile2(filePath) {
   try {
-    const raw = readFileSync26(filePath, "utf-8");
+    const raw = readFileSync25(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -18622,7 +18515,7 @@ async function coreValidateSchema(type, data, projectRoot) {
     throw new Error(`Unknown schema type: ${type}. Valid types: ${validTypes.join(", ")}`);
   }
   if (type === "config") {
-    const filePath = join38(projectRoot, ".cleo", "config.json");
+    const filePath = join37(projectRoot, ".cleo", "config.json");
     if (!existsSync34(filePath)) {
       throw new Error("File not found: .cleo/config.json");
     }
@@ -18770,7 +18663,7 @@ function coreValidateManifest(projectRoot) {
       message: "No manifest file found"
     };
   }
-  const content = readFileSync26(manifestPath, "utf-8");
+  const content = readFileSync25(manifestPath, "utf-8");
   const lines = content.split("\n").filter((l) => l.trim());
   let validCount = 0;
   let invalidCount = 0;
@@ -18814,7 +18707,7 @@ function coreValidateOutput(filePath, taskId, projectRoot) {
   if (!existsSync34(fullPath)) {
     throw new Error(`Output file not found: ${filePath}`);
   }
-  const content = readFileSync26(fullPath, "utf-8");
+  const content = readFileSync25(fullPath, "utf-8");
   const issues = [];
   if (!content.includes("# ")) {
     issues.push({ code: "O_MISSING_TITLE", message: "Output file should have a markdown title", severity: "warning" });
@@ -18834,11 +18727,11 @@ function coreValidateOutput(filePath, taskId, projectRoot) {
   };
 }
 function parseComplianceEntries(projectRoot) {
-  const compliancePath = join38(projectRoot, ".cleo", "metrics", "COMPLIANCE.jsonl");
+  const compliancePath = join37(projectRoot, ".cleo", "metrics", "COMPLIANCE.jsonl");
   if (!existsSync34(compliancePath)) {
     return [];
   }
-  const content = readFileSync26(compliancePath, "utf-8");
+  const content = readFileSync25(compliancePath, "utf-8");
   const entries = [];
   for (const line of content.split("\n")) {
     const trimmed = line.trim();
@@ -18898,7 +18791,7 @@ function coreComplianceRecord(taskId, result, protocol, violations, projectRoot)
   if (!validResults.includes(result)) {
     throw new Error(`Invalid result: ${result}. Valid: ${validResults.join(", ")}`);
   }
-  const compliancePath = join38(projectRoot, ".cleo", "metrics", "COMPLIANCE.jsonl");
+  const compliancePath = join37(projectRoot, ".cleo", "metrics", "COMPLIANCE.jsonl");
   const dir = dirname10(compliancePath);
   if (!existsSync34(dir)) {
     mkdirSync11(dir, { recursive: true });
@@ -18920,8 +18813,8 @@ function coreComplianceRecord(taskId, result, protocol, violations, projectRoot)
   };
 }
 function coreTestStatus(projectRoot) {
-  const testDir = join38(projectRoot, "tests");
-  const mcpTestDir = join38(projectRoot, "src", "mcp", "__tests__");
+  const testDir = join37(projectRoot, "tests");
+  const mcpTestDir = join37(projectRoot, "src", "mcp", "__tests__");
   const hasBatsTests = existsSync34(testDir);
   const hasMcpTests = existsSync34(mcpTestDir);
   return {
@@ -19065,8 +18958,8 @@ async function coreCoherenceCheck(projectRoot) {
   };
 }
 function coreTestRun(params, projectRoot) {
-  const hasVitest = existsSync34(join38(projectRoot, "node_modules", ".bin", "vitest"));
-  const hasBats = existsSync34(join38(projectRoot, "tests"));
+  const hasVitest = existsSync34(join37(projectRoot, "node_modules", ".bin", "vitest"));
+  const hasBats = existsSync34(join37(projectRoot, "tests"));
   if (!hasVitest && !hasBats) {
     return {
       ran: false,
@@ -19112,7 +19005,7 @@ function coreTestRun(params, projectRoot) {
   }
 }
 function coreTestCoverage(projectRoot) {
-  const coveragePath = join38(projectRoot, "coverage", "coverage-summary.json");
+  const coveragePath = join37(projectRoot, "coverage", "coverage-summary.json");
   if (!existsSync34(coveragePath)) {
     return {
       available: false,
@@ -19800,16 +19693,16 @@ var init_unblock = __esm({
 });
 
 // src/core/orchestration/parallel.ts
-import { readFileSync as readFileSync27, writeFileSync as writeFileSync7, existsSync as existsSync35, mkdirSync as mkdirSync12 } from "node:fs";
-import { join as join39, dirname as dirname11 } from "node:path";
+import { readFileSync as readFileSync26, writeFileSync as writeFileSync7, existsSync as existsSync35, mkdirSync as mkdirSync12 } from "node:fs";
+import { join as join38, dirname as dirname11 } from "node:path";
 function getParallelStatePath(projectRoot) {
-  return join39(projectRoot, ".cleo", "parallel-state.json");
+  return join38(projectRoot, ".cleo", "parallel-state.json");
 }
 function readParallelState(projectRoot) {
   const statePath = getParallelStatePath(projectRoot);
   if (!existsSync35(statePath)) return { active: false };
   try {
-    return JSON.parse(readFileSync27(statePath, "utf-8"));
+    return JSON.parse(readFileSync26(statePath, "utf-8"));
   } catch {
     return { active: false };
   }
@@ -19971,8 +19864,8 @@ var init_validate_spawn = __esm({
 });
 
 // src/core/orchestration/bootstrap.ts
-import { readFileSync as readFileSync28, existsSync as existsSync36 } from "node:fs";
-import { join as join40 } from "node:path";
+import { readFileSync as readFileSync27, existsSync as existsSync36 } from "node:fs";
+import { join as join39 } from "node:path";
 async function buildBrainState(projectRoot, opts, accessor) {
   const speed = opts?.speed || "fast";
   const brain = {
@@ -19985,7 +19878,7 @@ async function buildBrainState(projectRoot, opts, accessor) {
   try {
     const sessionsPath = getSessionsPath(projectRoot);
     if (existsSync36(sessionsPath)) {
-      const sessionsData = JSON.parse(readFileSync28(sessionsPath, "utf-8"));
+      const sessionsData = JSON.parse(readFileSync27(sessionsPath, "utf-8"));
       const activeSession = (sessionsData.sessions ?? []).find(
         (s) => s.status === "active"
       );
@@ -20040,9 +19933,9 @@ async function buildBrainState(projectRoot, opts, accessor) {
       blockedBy: b.depends || []
     }));
     try {
-      const decisionLogPath = join40(projectRoot, ".cleo", "decision-log.jsonl");
+      const decisionLogPath = join39(projectRoot, ".cleo", "decision-log.jsonl");
       if (existsSync36(decisionLogPath)) {
-        const content = readFileSync28(decisionLogPath, "utf-8").trim();
+        const content = readFileSync27(decisionLogPath, "utf-8").trim();
         if (content) {
           const entries = content.split("\n").filter((l) => l.trim()).map((l) => {
             try {
@@ -20062,9 +19955,9 @@ async function buildBrainState(projectRoot, opts, accessor) {
     } catch {
     }
     try {
-      const contextStatePath = join40(projectRoot, ".cleo", ".context-state.json");
+      const contextStatePath = join39(projectRoot, ".cleo", ".context-state.json");
       if (existsSync36(contextStatePath)) {
-        const state = JSON.parse(readFileSync28(contextStatePath, "utf-8"));
+        const state = JSON.parse(readFileSync27(contextStatePath, "utf-8"));
         const percentage = state.contextWindow?.percentage ?? 0;
         const factors = [];
         if (percentage > 80) factors.push("high_context_usage");
@@ -20085,7 +19978,7 @@ var init_bootstrap = __esm({
 });
 
 // src/dispatch/engines/orchestrate-engine.ts
-import { readFileSync as readFileSync29, existsSync as existsSync37 } from "node:fs";
+import { readFileSync as readFileSync28, existsSync as existsSync37 } from "node:fs";
 async function loadTasks(projectRoot) {
   const root = projectRoot || resolveProjectRoot();
   try {
@@ -20303,7 +20196,7 @@ async function orchestrateContext(epicId, projectRoot) {
     let manifestEntries2 = 0;
     if (existsSync37(manifestPath)) {
       try {
-        const content = readFileSync29(manifestPath, "utf-8");
+        const content = readFileSync28(manifestPath, "utf-8");
         manifestEntries2 = content.split("\n").filter((l) => l.trim()).length;
       } catch {
       }
@@ -20560,17 +20453,17 @@ var init_brain_migration = __esm({
 
 // src/core/memory/patterns.ts
 import { randomBytes as randomBytes7 } from "node:crypto";
-import { readFileSync as readFileSync30, writeFileSync as writeFileSync8, appendFileSync as appendFileSync4, mkdirSync as mkdirSync13, existsSync as existsSync38 } from "node:fs";
-import { join as join41 } from "node:path";
+import { readFileSync as readFileSync29, writeFileSync as writeFileSync8, appendFileSync as appendFileSync4, mkdirSync as mkdirSync13, existsSync as existsSync38 } from "node:fs";
+import { join as join40 } from "node:path";
 function getMemoryDir(projectRoot) {
-  const memDir = join41(projectRoot, ".cleo", "memory");
+  const memDir = join40(projectRoot, ".cleo", "memory");
   if (!existsSync38(memDir)) {
     mkdirSync13(memDir, { recursive: true });
   }
   return memDir;
 }
 function getPatternsPath(projectRoot) {
-  return join41(getMemoryDir(projectRoot), "patterns.jsonl");
+  return join40(getMemoryDir(projectRoot), "patterns.jsonl");
 }
 function generatePatternId() {
   return `P${randomBytes7(4).toString("hex")}`;
@@ -20578,7 +20471,7 @@ function generatePatternId() {
 function readPatterns(projectRoot) {
   const path = getPatternsPath(projectRoot);
   if (!existsSync38(path)) return [];
-  const content = readFileSync30(path, "utf-8").trim();
+  const content = readFileSync29(path, "utf-8").trim();
   if (!content) return [];
   const entries = [];
   for (const line of content.split("\n")) {
@@ -20692,17 +20585,17 @@ var init_patterns = __esm({
 
 // src/core/memory/learnings.ts
 import { randomBytes as randomBytes8 } from "node:crypto";
-import { readFileSync as readFileSync31, writeFileSync as writeFileSync9, appendFileSync as appendFileSync5, mkdirSync as mkdirSync14, existsSync as existsSync39 } from "node:fs";
-import { join as join42 } from "node:path";
+import { readFileSync as readFileSync30, writeFileSync as writeFileSync9, appendFileSync as appendFileSync5, mkdirSync as mkdirSync14, existsSync as existsSync39 } from "node:fs";
+import { join as join41 } from "node:path";
 function getMemoryDir2(projectRoot) {
-  const memDir = join42(projectRoot, ".cleo", "memory");
+  const memDir = join41(projectRoot, ".cleo", "memory");
   if (!existsSync39(memDir)) {
     mkdirSync14(memDir, { recursive: true });
   }
   return memDir;
 }
 function getLearningsPath(projectRoot) {
-  return join42(getMemoryDir2(projectRoot), "learnings.jsonl");
+  return join41(getMemoryDir2(projectRoot), "learnings.jsonl");
 }
 function generateLearningId() {
   return `L${randomBytes8(4).toString("hex")}`;
@@ -20710,7 +20603,7 @@ function generateLearningId() {
 function readLearnings(projectRoot) {
   const path = getLearningsPath(projectRoot);
   if (!existsSync39(path)) return [];
-  const content = readFileSync31(path, "utf-8").trim();
+  const content = readFileSync30(path, "utf-8").trim();
   if (!content) return [];
   const entries = [];
   for (const line of content.split("\n")) {
@@ -20871,7 +20764,7 @@ var init_memory = __esm({
 });
 
 // src/core/memory/engine-compat.ts
-import { readFileSync as readFileSync32, writeFileSync as writeFileSync10, appendFileSync as appendFileSync6, existsSync as existsSync40, mkdirSync as mkdirSync15 } from "node:fs";
+import { readFileSync as readFileSync31, writeFileSync as writeFileSync10, appendFileSync as appendFileSync6, existsSync as existsSync40, mkdirSync as mkdirSync15 } from "node:fs";
 import { resolve as resolve7, dirname as dirname12 } from "node:path";
 function getManifestPath2(projectRoot) {
   return getManifestPath(projectRoot);
@@ -20882,7 +20775,7 @@ function resolveRoot(projectRoot) {
 function readManifestEntries(projectRoot) {
   const manifestPath = getManifestPath2(projectRoot);
   try {
-    const content = readFileSync32(manifestPath, "utf-8");
+    const content = readFileSync31(manifestPath, "utf-8");
     const entries = [];
     const lines = content.split("\n");
     for (const line of lines) {
@@ -20919,7 +20812,7 @@ function memoryShow(researchId, projectRoot) {
   try {
     const filePath = resolve7(root, entry.file);
     if (existsSync40(filePath)) {
-      fileContent = readFileSync32(filePath, "utf-8");
+      fileContent = readFileSync31(filePath, "utf-8");
     }
   } catch {
   }
@@ -21186,7 +21079,7 @@ function memoryInject(protocolType, params, projectRoot) {
   for (const loc of protocolLocations) {
     if (existsSync40(loc)) {
       try {
-        protocolContent = readFileSync32(loc, "utf-8");
+        protocolContent = readFileSync31(loc, "utf-8");
         protocolPath = loc.replace(root + "/", "");
         break;
       } catch {
@@ -21334,9 +21227,9 @@ var init_engine_compat = __esm({
 // src/core/release/release-manifest.ts
 import { existsSync as existsSync41, mkdirSync as mkdirSync16 } from "node:fs";
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { dirname as dirname13, join as join43 } from "node:path";
+import { dirname as dirname13, join as join42 } from "node:path";
 function getReleasesPath(cwd) {
-  return join43(getCleoDirAbsolute(cwd), "releases.json");
+  return join42(getCleoDirAbsolute(cwd), "releases.json");
 }
 async function readReleases(cwd) {
   const data = await readJson(getReleasesPath(cwd));
@@ -21613,7 +21506,7 @@ async function rollbackRelease(version, reason, cwd) {
   };
 }
 async function readPushPolicy(cwd) {
-  const configPath = join43(getCleoDirAbsolute(cwd), "config.json");
+  const configPath = join42(getCleoDirAbsolute(cwd), "config.json");
   const config = await readJson(configPath);
   if (!config) return void 0;
   const release2 = config.release;
@@ -21843,8 +21736,8 @@ var init_release_engine = __esm({
 });
 
 // src/dispatch/engines/template-parser.ts
-import { readFileSync as readFileSync33, readdirSync as readdirSync12, existsSync as existsSync42 } from "fs";
-import { join as join44 } from "path";
+import { readFileSync as readFileSync32, readdirSync as readdirSync12, existsSync as existsSync42 } from "fs";
+import { join as join43 } from "path";
 import { parse as parseYaml } from "yaml";
 function deriveSubcommand(filename) {
   let stem = filename.replace(/\.ya?ml$/i, "");
@@ -21858,8 +21751,8 @@ function deriveSubcommand(filename) {
   return firstWord.toLowerCase();
 }
 function parseTemplateFile(templateDir, filename) {
-  const filePath = join44(templateDir, filename);
-  const raw = readFileSync33(filePath, "utf-8");
+  const filePath = join43(templateDir, filename);
+  const raw = readFileSync32(filePath, "utf-8");
   const parsed = parseYaml(raw);
   const name = typeof parsed.name === "string" ? parsed.name : filename;
   const titlePrefix = typeof parsed.title === "string" ? parsed.title : "";
@@ -21908,7 +21801,7 @@ function parseTemplateFile(templateDir, filename) {
   };
 }
 function parseIssueTemplates(projectRoot) {
-  const templateDir = join44(projectRoot, ".github", "ISSUE_TEMPLATE");
+  const templateDir = join43(projectRoot, ".github", "ISSUE_TEMPLATE");
   if (!existsSync42(templateDir)) {
     return engineError("E_NOT_FOUND", `Issue template directory not found: ${templateDir}`);
   }
@@ -22961,12 +22854,12 @@ var init_check = __esm({
 });
 
 // src/core/adrs/validate.ts
-import { readFileSync as readFileSync34, readdirSync as readdirSync13, existsSync as existsSync43 } from "node:fs";
-import { join as join45 } from "node:path";
+import { readFileSync as readFileSync33, readdirSync as readdirSync13, existsSync as existsSync43 } from "node:fs";
+import { join as join44 } from "node:path";
 import AjvModule3 from "ajv";
 async function validateAllAdrs(projectRoot) {
-  const adrsDir = join45(projectRoot, ".cleo", "adrs");
-  const schemaPath = join45(projectRoot, "schemas", "adr-frontmatter.schema.json");
+  const adrsDir = join44(projectRoot, ".cleo", "adrs");
+  const schemaPath = join44(projectRoot, "schemas", "adr-frontmatter.schema.json");
   if (!existsSync43(schemaPath)) {
     return {
       valid: false,
@@ -22977,10 +22870,10 @@ async function validateAllAdrs(projectRoot) {
   if (!existsSync43(adrsDir)) {
     return { valid: true, errors: [], checked: 0 };
   }
-  const schema = JSON.parse(readFileSync34(schemaPath, "utf-8"));
+  const schema = JSON.parse(readFileSync33(schemaPath, "utf-8"));
   const ajv = new Ajv3({ allErrors: true });
   const validate = ajv.compile(schema);
-  const files = readdirSync13(adrsDir).filter((f) => f.endsWith(".md") && f.startsWith("ADR-")).map((f) => join45(adrsDir, f));
+  const files = readdirSync13(adrsDir).filter((f) => f.endsWith(".md") && f.startsWith("ADR-")).map((f) => join44(adrsDir, f));
   const errors = [];
   for (const filePath of files) {
     const record = parseAdrFile(filePath, projectRoot);
@@ -23008,14 +22901,14 @@ var init_validate = __esm({
 
 // src/core/adrs/list.ts
 import { readdirSync as readdirSync14, existsSync as existsSync44 } from "node:fs";
-import { join as join46 } from "node:path";
+import { join as join45 } from "node:path";
 async function listAdrs(projectRoot, opts) {
-  const adrsDir = join46(projectRoot, ".cleo", "adrs");
+  const adrsDir = join45(projectRoot, ".cleo", "adrs");
   if (!existsSync44(adrsDir)) {
     return { adrs: [], total: 0 };
   }
   const files = readdirSync14(adrsDir).filter((f) => f.endsWith(".md") && f.startsWith("ADR-")).sort();
-  const records = files.map((f) => parseAdrFile(join46(adrsDir, f), projectRoot));
+  const records = files.map((f) => parseAdrFile(join45(adrsDir, f), projectRoot));
   const filtered = records.filter((r) => {
     if (opts?.status && r.frontmatter.Status !== opts.status) return false;
     if (opts?.since && r.frontmatter.Date < opts.since) return false;
@@ -23041,13 +22934,13 @@ var init_list2 = __esm({
 
 // src/core/adrs/show.ts
 import { existsSync as existsSync45, readdirSync as readdirSync15 } from "node:fs";
-import { join as join47 } from "node:path";
+import { join as join46 } from "node:path";
 async function showAdr(projectRoot, adrId) {
-  const adrsDir = join47(projectRoot, ".cleo", "adrs");
+  const adrsDir = join46(projectRoot, ".cleo", "adrs");
   if (!existsSync45(adrsDir)) return null;
   const files = readdirSync15(adrsDir).filter((f) => f.startsWith(adrId) && f.endsWith(".md"));
   if (files.length === 0) return null;
-  const filePath = join47(adrsDir, files[0]);
+  const filePath = join46(adrsDir, files[0]);
   return parseAdrFile(filePath, projectRoot);
 }
 var init_show2 = __esm({
@@ -23059,7 +22952,7 @@ var init_show2 = __esm({
 
 // src/core/adrs/find.ts
 import { readdirSync as readdirSync16, existsSync as existsSync46 } from "node:fs";
-import { join as join48 } from "node:path";
+import { join as join47 } from "node:path";
 function normalise(s) {
   return s.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
 }
@@ -23076,7 +22969,7 @@ function matchedTerms(target, terms) {
   return terms.filter((term) => t.includes(term));
 }
 async function findAdrs(projectRoot, query, opts) {
-  const adrsDir = join48(projectRoot, ".cleo", "adrs");
+  const adrsDir = join47(projectRoot, ".cleo", "adrs");
   if (!existsSync46(adrsDir)) {
     return { adrs: [], query, total: 0 };
   }
@@ -23086,7 +22979,7 @@ async function findAdrs(projectRoot, query, opts) {
   const filterKeywords = opts?.keywords ? parseTags(opts.keywords) : null;
   const results = [];
   for (const file of files) {
-    const record = parseAdrFile(join48(adrsDir, file), projectRoot);
+    const record = parseAdrFile(join47(adrsDir, file), projectRoot);
     const fm = record.frontmatter;
     if (opts?.status && fm.Status !== opts.status) continue;
     if (filterTopics && filterTopics.length > 0) {
@@ -23709,13 +23602,13 @@ var init_field_context = __esm({
 });
 
 // src/core/sessions/context-alert.ts
-import { existsSync as existsSync47, readFileSync as readFileSync35, writeFileSync as writeFileSync11 } from "node:fs";
-import { join as join49 } from "node:path";
+import { existsSync as existsSync47, readFileSync as readFileSync34, writeFileSync as writeFileSync11 } from "node:fs";
+import { join as join48 } from "node:path";
 function getCurrentSessionId(cwd) {
   if (process.env.CLEO_SESSION) return process.env.CLEO_SESSION;
-  const sessionFile = join49(getCleoDir(cwd), ".current-session");
+  const sessionFile = join48(getCleoDir(cwd), ".current-session");
   if (existsSync47(sessionFile)) {
-    return readFileSync35(sessionFile, "utf-8").trim() || null;
+    return readFileSync34(sessionFile, "utf-8").trim() || null;
   }
   return null;
 }
@@ -25116,7 +25009,7 @@ __export(session_grade_exports, {
   gradeSession: () => gradeSession,
   readGrades: () => readGrades
 });
-import { join as join50 } from "node:path";
+import { join as join49 } from "node:path";
 import { existsSync as existsSync48 } from "node:fs";
 import { readFile as readFile9, appendFile, mkdir as mkdir9 } from "node:fs/promises";
 async function gradeSession(sessionId, cwd) {
@@ -25297,9 +25190,9 @@ function detectDuplicateCreates(entries) {
 async function appendGradeResult(result, cwd) {
   try {
     const cleoDir = getCleoDirAbsolute(cwd);
-    const metricsDir = join50(cleoDir, "metrics");
+    const metricsDir = join49(cleoDir, "metrics");
     await mkdir9(metricsDir, { recursive: true });
-    const gradesPath = join50(metricsDir, "GRADES.jsonl");
+    const gradesPath = join49(metricsDir, "GRADES.jsonl");
     const line = JSON.stringify({ ...result, evaluator: "auto" }) + "\n";
     await appendFile(gradesPath, line, "utf8");
   } catch {
@@ -25308,7 +25201,7 @@ async function appendGradeResult(result, cwd) {
 async function readGrades(sessionId, cwd) {
   try {
     const cleoDir = getCleoDirAbsolute(cwd);
-    const gradesPath = join50(cleoDir, "metrics", "GRADES.jsonl");
+    const gradesPath = join49(cleoDir, "metrics", "GRADES.jsonl");
     if (!existsSync48(gradesPath)) return [];
     const content = await readFile9(gradesPath, "utf8");
     const results = content.split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
@@ -26831,8 +26724,8 @@ var init_diagnostics = __esm({
 });
 
 // src/core/issue/template-parser.ts
-import { existsSync as existsSync49, readFileSync as readFileSync36, readdirSync as readdirSync17, writeFileSync as writeFileSync12 } from "node:fs";
-import { join as join51, basename as basename8 } from "node:path";
+import { existsSync as existsSync49, readFileSync as readFileSync35, readdirSync as readdirSync17, writeFileSync as writeFileSync12 } from "node:fs";
+import { join as join50, basename as basename8 } from "node:path";
 function extractYamlField(content, field) {
   const regex = new RegExp(`^${field}:\\s*["']?(.+?)["']?\\s*$`, "m");
   const match = content.match(regex);
@@ -26866,7 +26759,7 @@ function extractYamlArray(content, field) {
 function parseTemplateFile2(filePath) {
   if (!existsSync49(filePath)) return null;
   try {
-    const content = readFileSync36(filePath, "utf-8");
+    const content = readFileSync35(filePath, "utf-8");
     const fileName = basename8(filePath);
     const stem = fileName.replace(/\.ya?ml$/, "");
     const name = extractYamlField(content, "name");
@@ -26882,12 +26775,12 @@ function parseTemplateFile2(filePath) {
 }
 function parseIssueTemplates2(projectDir) {
   const dir = projectDir ?? getProjectRoot();
-  const templateDir = join51(dir, TEMPLATE_DIR);
+  const templateDir = join50(dir, TEMPLATE_DIR);
   if (!existsSync49(templateDir)) return [];
   const templates = [];
   for (const file of readdirSync17(templateDir)) {
     if (!file.endsWith(".yml") && !file.endsWith(".yaml")) continue;
-    const template = parseTemplateFile2(join51(templateDir, file));
+    const template = parseTemplateFile2(join50(templateDir, file));
     if (template) templates.push(template);
   }
   return templates;
@@ -26896,10 +26789,10 @@ function getTemplateConfig(cwd) {
   const projectDir = cwd ?? getProjectRoot();
   const liveTemplates = parseIssueTemplates2(projectDir);
   if (liveTemplates.length > 0) return liveTemplates;
-  const cachePath = join51(getCleoDir(cwd), CACHE_FILE);
+  const cachePath = join50(getCleoDir(cwd), CACHE_FILE);
   if (existsSync49(cachePath)) {
     try {
-      const cached = JSON.parse(readFileSync36(cachePath, "utf-8"));
+      const cached = JSON.parse(readFileSync35(cachePath, "utf-8"));
       if (cached.templates?.length > 0) return cached.templates;
     } catch {
     }
@@ -27729,8 +27622,8 @@ var init_tools = __esm({
 });
 
 // src/core/nexus/query.ts
-import { join as join52, basename as basename9 } from "node:path";
-import { existsSync as existsSync50, readFileSync as readFileSync37 } from "node:fs";
+import { join as join51, basename as basename9 } from "node:path";
+import { existsSync as existsSync50, readFileSync as readFileSync36 } from "node:fs";
 import { readFile as readFile10, access as access3 } from "node:fs/promises";
 import { z as z3 } from "zod";
 function validateSyntax(query) {
@@ -27767,9 +27660,9 @@ function getCurrentProject() {
     return process.env["NEXUS_CURRENT_PROJECT"];
   }
   try {
-    const infoPath = join52(process.cwd(), ".cleo", "project-info.json");
+    const infoPath = join51(process.cwd(), ".cleo", "project-info.json");
     if (existsSync50(infoPath)) {
-      const data = JSON.parse(readFileSync37(infoPath, "utf-8"));
+      const data = JSON.parse(readFileSync36(infoPath, "utf-8"));
       if (typeof data.name === "string" && data.name.length > 0) {
         return data.name;
       }
@@ -27784,12 +27677,12 @@ async function resolveProjectPath(projectName) {
   }
   if (projectName === ".") {
     try {
-      await access3(join52(process.cwd(), ".cleo", "tasks.json"));
+      await access3(join51(process.cwd(), ".cleo", "tasks.json"));
       return process.cwd();
     } catch {
     }
     try {
-      await access3(join52(process.cwd(), ".cleo", "todo.json"));
+      await access3(join51(process.cwd(), ".cleo", "todo.json"));
       return process.cwd();
     } catch {
       throw new CleoError(
@@ -27809,8 +27702,8 @@ async function resolveProjectPath(projectName) {
   return project.path;
 }
 async function readProjectTasks(projectPath) {
-  const tasksPath = join52(projectPath, ".cleo", "tasks.json");
-  const legacyPath = join52(projectPath, ".cleo", "todo.json");
+  const tasksPath = join51(projectPath, ".cleo", "tasks.json");
+  const legacyPath = join51(projectPath, ".cleo", "todo.json");
   try {
     let raw;
     try {
@@ -27940,7 +27833,7 @@ var init_permissions = __esm({
 });
 
 // src/core/nexus/deps.ts
-import { join as join53 } from "node:path";
+import { join as join52 } from "node:path";
 import { readFile as readFile11 } from "node:fs/promises";
 import { createHash as createHash7 } from "node:crypto";
 import { z as z5 } from "zod";
@@ -27948,9 +27841,9 @@ async function readProjectTasks2(projectPath) {
   try {
     let raw;
     try {
-      raw = await readFile11(join53(projectPath, ".cleo", "tasks.json"), "utf-8");
+      raw = await readFile11(join52(projectPath, ".cleo", "tasks.json"), "utf-8");
     } catch {
-      raw = await readFile11(join53(projectPath, ".cleo", "todo.json"), "utf-8");
+      raw = await readFile11(join52(projectPath, ".cleo", "todo.json"), "utf-8");
     }
     const data = JSON.parse(raw);
     return data.tasks ?? [];
@@ -27964,9 +27857,9 @@ async function computeGlobalChecksum(registry) {
     try {
       let content;
       try {
-        content = await readFile11(join53(project.path, ".cleo", "tasks.json"), "utf-8");
+        content = await readFile11(join52(project.path, ".cleo", "tasks.json"), "utf-8");
       } catch {
-        content = await readFile11(join53(project.path, ".cleo", "todo.json"), "utf-8");
+        content = await readFile11(join52(project.path, ".cleo", "todo.json"), "utf-8");
       }
       hash.update(content);
     } catch {
@@ -28336,7 +28229,7 @@ var init_nexus = __esm({
 // src/core/sharing/index.ts
 import { readFile as readFile12, writeFile as writeFile6 } from "node:fs/promises";
 import { existsSync as existsSync51, readdirSync as readdirSync18, statSync as statSync9 } from "node:fs";
-import { join as join54, relative as relative4 } from "node:path";
+import { join as join53, relative as relative4 } from "node:path";
 function matchesPattern(filePath, pattern) {
   const normalizedPath = filePath.replace(/^\/+|\/+$/g, "");
   const normalizedPattern = pattern.replace(/^\/+|\/+$/g, "");
@@ -28361,7 +28254,7 @@ function collectCleoFiles(cleoDir) {
     const entries = readdirSync18(dir);
     for (const entry of entries) {
       if (entry === ".git") continue;
-      const fullPath = join54(dir, entry);
+      const fullPath = join53(dir, entry);
       const relPath = relative4(cleoDir, fullPath);
       try {
         const stat2 = statSync9(fullPath);
@@ -28421,7 +28314,7 @@ function generateGitignoreEntries(sharing) {
 async function syncGitignore(cwd) {
   const config = await loadConfig2(cwd);
   const projectRoot = getProjectRoot(cwd);
-  const gitignorePath = join54(projectRoot, ".gitignore");
+  const gitignorePath = join53(projectRoot, ".gitignore");
   const entries = generateGitignoreEntries(config.sharing);
   const managedSection = [
     "",
@@ -28465,7 +28358,7 @@ var init_sharing = __esm({
 import { createHash as createHash8 } from "node:crypto";
 import { readFile as readFile13, writeFile as writeFile7, mkdir as mkdir10 } from "node:fs/promises";
 import { existsSync as existsSync52 } from "node:fs";
-import { join as join55, dirname as dirname14 } from "node:path";
+import { join as join54, dirname as dirname14 } from "node:path";
 function toSnapshotTask(task) {
   return {
     id: task.id,
@@ -28534,7 +28427,7 @@ async function readSnapshot(inputPath) {
 function getDefaultSnapshotPath(cwd) {
   const cleoDir = getCleoDirAbsolute(cwd);
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  return join55(cleoDir, "snapshots", `snapshot-${timestamp}.json`);
+  return join54(cleoDir, "snapshots", `snapshot-${timestamp}.json`);
 }
 async function importSnapshot(snapshot, cwd) {
   const accessor = await getAccessor(cwd);
@@ -29048,7 +28941,7 @@ __export(global_bootstrap_exports, {
   ensureGlobalBootstrap: () => ensureGlobalBootstrap
 });
 import { existsSync as existsSync53, mkdirSync as mkdirSync17, writeFileSync as writeFileSync13 } from "node:fs";
-import { join as join56 } from "node:path";
+import { join as join55 } from "node:path";
 function ensureGlobalBootstrap() {
   const details = [];
   const cleoHome = getCleoHome();
@@ -29060,14 +28953,14 @@ function ensureGlobalBootstrap() {
   if (schemaResult.installed > 0 || schemaResult.updated > 0) {
     details.push(`schemas installed=${schemaResult.installed} updated=${schemaResult.updated}`);
   }
-  const templatesDir = join56(cleoHome, "templates");
+  const templatesDir = join55(cleoHome, "templates");
   if (!existsSync53(templatesDir)) {
     mkdirSync17(templatesDir, { recursive: true });
     details.push("created templates dir");
   }
   const injectionTemplate = getInjectionTemplateContent();
   if (injectionTemplate) {
-    const injectionPath = join56(templatesDir, "CLEO-INJECTION.md");
+    const injectionPath = join55(templatesDir, "CLEO-INJECTION.md");
     if (!existsSync53(injectionPath)) {
       writeFileSync13(injectionPath, injectionTemplate, "utf-8");
       details.push("installed CLEO-INJECTION.md");