@cleocode/cleo 2026.3.26 → 2026.3.27

package/dist/cli/index.js

@@ -10904,10 +10904,10 @@ async function readProjectMeta(projectPath) {
 }
 async function readProjectId(projectPath) {
   try {
-    const { readFileSync: readFileSync57, existsSync: existsSync74 } = await import("node:fs");
+    const { readFileSync: readFileSync58, existsSync: existsSync75 } = await import("node:fs");
     const infoPath = join32(projectPath, ".cleo", "project-info.json");
-    if (!existsSync74(infoPath)) return "";
-    const data = JSON.parse(readFileSync57(infoPath, "utf-8"));
+    if (!existsSync75(infoPath)) return "";
+    const data = JSON.parse(readFileSync58(infoPath, "utf-8"));
     return typeof data.projectId === "string" ? data.projectId : "";
   } catch {
     return "";
@@ -19068,6 +19068,90 @@ var init_session_store = __esm({
   }
 });
 
+// src/core/install/claude-plugin.ts
+var claude_plugin_exports = {};
+__export(claude_plugin_exports, {
+  installClaudePlugin: () => installClaudePlugin
+});
+import { cpSync, existsSync as existsSync67, mkdirSync as mkdirSync17, readFileSync as readFileSync50, writeFileSync as writeFileSync11 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname18, join as join68, resolve as resolve9 } from "node:path";
+import { fileURLToPath as fileURLToPath6 } from "node:url";
+async function installClaudePlugin(opts) {
+  const { dryRun = false } = opts;
+  const created = [];
+  const warnings = [];
+  const home = homedir4();
+  const claudeHome = join68(home, ".claude");
+  const settingsPath = join68(claudeHome, "settings.json");
+  const thisFile = fileURLToPath6(import.meta.url);
+  const packageRoot = resolve9(dirname18(thisFile), "..", "..", "..");
+  const pluginSrc = join68(packageRoot, ".claude-plugin");
+  if (!existsSync67(pluginSrc)) {
+    warnings.push("CLEO Claude plugin source not found \u2014 skipping plugin install");
+    return { created, warnings };
+  }
+  let pluginVersion = "0.0.0";
+  try {
+    const pluginJson = JSON.parse(readFileSync50(join68(pluginSrc, "plugin.json"), "utf-8"));
+    pluginVersion = pluginJson.version ?? "0.0.0";
+  } catch {
+  }
+  const cacheDir = join68(claudeHome, "plugins", "cache", PLUGIN_CACHE_NAME, PLUGIN_PACKAGE_NAME, pluginVersion);
+  const cacheDirDisplay = cacheDir.replace(home, "~");
+  if (!dryRun) {
+    try {
+      mkdirSync17(cacheDir, { recursive: true });
+      cpSync(pluginSrc, cacheDir, { recursive: true });
+      created.push(`${cacheDirDisplay} (CLEO Claude plugin installed)`);
+    } catch (err) {
+      warnings.push(`Plugin cache copy failed: ${err instanceof Error ? err.message : String(err)}`);
+      return { created, warnings };
+    }
+  } else {
+    created.push(`${cacheDirDisplay} (would install CLEO Claude plugin)`);
+  }
+  if (!dryRun) {
+    try {
+      let settings = {};
+      if (existsSync67(settingsPath)) {
+        try {
+          settings = JSON.parse(readFileSync50(settingsPath, "utf-8"));
+        } catch {
+        }
+      }
+      const enabledPlugins = settings["enabledPlugins"] ?? {};
+      if (enabledPlugins["claude-mem@thedotmack"] === true) {
+        enabledPlugins["claude-mem@thedotmack"] = false;
+        created.push("~/.claude/settings.json (disabled claude-mem@thedotmack)");
+      }
+      const pluginKey = `${PLUGIN_PACKAGE_NAME}@${PLUGIN_CACHE_NAME}`;
+      if (!enabledPlugins[pluginKey]) {
+        enabledPlugins[pluginKey] = true;
+        created.push(`~/.claude/settings.json (enabled ${pluginKey})`);
+      }
+      settings["enabledPlugins"] = enabledPlugins;
+      mkdirSync17(claudeHome, { recursive: true });
+      writeFileSync11(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    } catch (err) {
+      warnings.push(
+        `settings.json update failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  } else {
+    created.push(`~/.claude/settings.json (would enable ${PLUGIN_PACKAGE_NAME}@${PLUGIN_CACHE_NAME})`);
+  }
+  return { created, warnings };
+}
+var PLUGIN_CACHE_NAME, PLUGIN_PACKAGE_NAME;
+var init_claude_plugin = __esm({
+  "src/core/install/claude-plugin.ts"() {
+    "use strict";
+    PLUGIN_CACHE_NAME = "cleocode";
+    PLUGIN_PACKAGE_NAME = "cleo";
+  }
+});
+
 // src/store/provider.ts
 var init_provider = __esm({
   "src/store/provider.ts"() {
@@ -19089,19 +19173,19 @@ import {
   accessSync as accessSync2,
   appendFileSync as appendFileSync5,
   constants as constants2,
-  existsSync as existsSync70,
-  mkdirSync as mkdirSync17,
+  existsSync as existsSync71,
+  mkdirSync as mkdirSync18,
   readdirSync as readdirSync19,
-  readFileSync as readFileSync52,
+  readFileSync as readFileSync53,
   statSync as statSync10,
   unlinkSync as unlinkSync5
 } from "node:fs";
-import { dirname as dirname19, join as join70, relative as relative6 } from "node:path";
+import { dirname as dirname20, join as join71, relative as relative6 } from "node:path";
 function createMigrationLogger(cleoDir, config) {
   return new MigrationLogger(cleoDir, config);
 }
 function readMigrationLog(logPath) {
-  const content = readFileSync52(logPath, "utf-8");
+  const content = readFileSync53(logPath, "utf-8");
   return content.split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
 }
 function logFileExists(logPath) {
@@ -19114,14 +19198,14 @@ function logFileExists(logPath) {
 }
 function getLatestMigrationLog(cleoDir) {
   try {
-    const logsDir = join70(cleoDir, "logs");
-    if (!existsSync70(logsDir)) {
+    const logsDir = join71(cleoDir, "logs");
+    if (!existsSync71(logsDir)) {
       return null;
     }
     const files = readdirSync19(logsDir).filter((f) => f.startsWith("migration-") && f.endsWith(".jsonl")).map((f) => ({
       name: f,
-      path: join70(logsDir, f),
-      mtime: statSync10(join70(logsDir, f)).mtime.getTime()
+      path: join71(logsDir, f),
+      mtime: statSync10(join71(logsDir, f)).mtime.getTime()
     })).sort((a, b) => b.mtime - a.mtime);
     return files.length > 0 ? files[0].path : null;
   } catch {
@@ -19151,10 +19235,10 @@ var init_logger2 = __esm({
           consoleOutput: config.consoleOutput ?? false
         };
         const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-        this.logPath = join70(cleoDir, "logs", `migration-${timestamp}.jsonl`);
-        const logsDir = dirname19(this.logPath);
-        if (!existsSync70(logsDir)) {
-          mkdirSync17(logsDir, { recursive: true });
+        this.logPath = join71(cleoDir, "logs", `migration-${timestamp}.jsonl`);
+        const logsDir = dirname20(this.logPath);
+        if (!existsSync71(logsDir)) {
+          mkdirSync18(logsDir, { recursive: true });
         }
         this.startTime = Date.now();
         this.cleanupOldLogs();
@@ -19242,7 +19326,7 @@ var init_logger2 = __esm({
           sourcePath: relative6(this.cleoDir, sourcePath),
           ...additionalData
         };
-        if (existsSync70(sourcePath)) {
+        if (existsSync71(sourcePath)) {
           try {
             const stats2 = statSync10(sourcePath);
             data.sourceSize = stats2.size;
@@ -19252,7 +19336,7 @@ var init_logger2 = __esm({
         }
         if (targetPath) {
           data.targetPath = relative6(this.cleoDir, targetPath);
-          if (existsSync70(targetPath)) {
+          if (existsSync71(targetPath)) {
             try {
               const stats2 = statSync10(targetPath);
               data.targetSize = stats2.size;
@@ -19321,14 +19405,14 @@ var init_logger2 = __esm({
        */
       cleanupOldLogs() {
         try {
-          const logsDir = join70(this.cleoDir, "logs");
-          if (!existsSync70(logsDir)) {
+          const logsDir = join71(this.cleoDir, "logs");
+          if (!existsSync71(logsDir)) {
             return;
           }
           const files = readdirSync19(logsDir).filter((f) => f.startsWith("migration-") && f.endsWith(".jsonl")).map((f) => ({
             name: f,
-            path: join70(logsDir, f),
-            mtime: statSync10(join70(logsDir, f)).mtime.getTime()
+            path: join71(logsDir, f),
+            mtime: statSync10(join71(logsDir, f)).mtime.getTime()
           })).sort((a, b) => b.mtime - a.mtime);
           const filesToRemove = files.slice(this.config.maxLogFiles);
           for (const file of filesToRemove) {
@@ -19424,9 +19508,9 @@ __export(state_exports, {
   verifySourceIntegrity: () => verifySourceIntegrity
 });
 import { createHash as createHash9 } from "node:crypto";
-import { existsSync as existsSync71 } from "node:fs";
+import { existsSync as existsSync72 } from "node:fs";
 import { readFile as readFile18, unlink as unlink5, writeFile as writeFile12 } from "node:fs/promises";
-import { join as join71 } from "node:path";
+import { join as join72 } from "node:path";
 async function computeFileChecksum(filePath) {
   try {
     const content = await readFile18(filePath);
@@ -19447,8 +19531,8 @@ async function countRecords(filePath, key) {
 async function createMigrationState(cleoDir, sourceFiles) {
   const files = sourceFiles ?? {};
   if (!files.todoJson) {
-    const todoPath = join71(cleoDir, "todo.json");
-    if (existsSync71(todoPath)) {
+    const todoPath = join72(cleoDir, "todo.json");
+    if (existsSync72(todoPath)) {
       files.todoJson = {
         path: todoPath,
         checksum: await computeFileChecksum(todoPath),
@@ -19457,8 +19541,8 @@ async function createMigrationState(cleoDir, sourceFiles) {
     }
   }
   if (!files.sessionsJson) {
-    const sessionsPath = join71(cleoDir, "sessions.json");
-    if (existsSync71(sessionsPath)) {
+    const sessionsPath = join72(cleoDir, "sessions.json");
+    if (existsSync72(sessionsPath)) {
       files.sessionsJson = {
         path: sessionsPath,
         checksum: await computeFileChecksum(sessionsPath),
@@ -19467,8 +19551,8 @@ async function createMigrationState(cleoDir, sourceFiles) {
     }
   }
   if (!files.archiveJson) {
-    const archivePath = join71(cleoDir, "todo-archive.json");
-    if (existsSync71(archivePath)) {
+    const archivePath = join72(cleoDir, "todo-archive.json");
+    if (existsSync72(archivePath)) {
       files.archiveJson = {
         path: archivePath,
         checksum: await computeFileChecksum(archivePath),
@@ -19496,7 +19580,7 @@ async function createMigrationState(cleoDir, sourceFiles) {
   return state;
 }
 async function writeMigrationState(cleoDir, state) {
-  const statePath = join71(cleoDir, STATE_FILENAME);
+  const statePath = join72(cleoDir, STATE_FILENAME);
   const tempPath = `${statePath}.tmp`;
   await writeFile12(tempPath, JSON.stringify(state, null, 2));
   await writeFile12(statePath, await readFile18(tempPath));
@@ -19571,7 +19655,7 @@ async function addMigrationWarning(cleoDir, warning) {
 }
 async function loadMigrationState(cleoDir) {
   try {
-    const statePath = join71(cleoDir, STATE_FILENAME);
+    const statePath = join72(cleoDir, STATE_FILENAME);
     const content = await readFile18(statePath, "utf-8");
     return JSON.parse(content);
   } catch {
@@ -19613,7 +19697,7 @@ async function failMigration(cleoDir, error) {
 }
 async function clearMigrationState(cleoDir) {
   try {
-    const statePath = join71(cleoDir, STATE_FILENAME);
+    const statePath = join72(cleoDir, STATE_FILENAME);
     await unlink5(statePath);
   } catch {
   }
@@ -19657,7 +19741,7 @@ async function verifySourceIntegrity(cleoDir) {
   const missing = [];
   for (const [key, fileInfo] of Object.entries(state.sourceFiles)) {
     if (!fileInfo) continue;
-    if (!existsSync71(fileInfo.path)) {
+    if (!existsSync72(fileInfo.path)) {
       missing.push(key);
       continue;
     }
@@ -19688,8 +19772,8 @@ __export(migration_sqlite_exports, {
   migrateJsonToSqlite: () => migrateJsonToSqlite2,
   migrateJsonToSqliteAtomic: () => migrateJsonToSqliteAtomic
 });
-import { existsSync as existsSync72, mkdirSync as mkdirSync18, readFileSync as readFileSync53 } from "node:fs";
-import { dirname as dirname20, join as join72 } from "node:path";
+import { existsSync as existsSync73, mkdirSync as mkdirSync19, readFileSync as readFileSync54 } from "node:fs";
+import { dirname as dirname21, join as join73 } from "node:path";
 import { drizzle as drizzle4 } from "drizzle-orm/sqlite-proxy";
 import { migrate as migrate4 } from "drizzle-orm/sqlite-proxy/migrator";
 function topoSortTasks(tasks2) {
@@ -19726,26 +19810,26 @@ function countJsonRecords(cleoDir) {
   let tasks2 = 0;
   let archived = 0;
   let sessions2 = 0;
-  const todoPath = join72(cleoDir, "todo.json");
-  if (existsSync72(todoPath)) {
+  const todoPath = join73(cleoDir, "todo.json");
+  if (existsSync73(todoPath)) {
     try {
-      const data = JSON.parse(readFileSync53(todoPath, "utf-8"));
+      const data = JSON.parse(readFileSync54(todoPath, "utf-8"));
       tasks2 = (data.tasks ?? []).length;
     } catch {
     }
   }
-  const archivePath = join72(cleoDir, "todo-archive.json");
-  if (existsSync72(archivePath)) {
+  const archivePath = join73(cleoDir, "todo-archive.json");
+  if (existsSync73(archivePath)) {
     try {
-      const data = JSON.parse(readFileSync53(archivePath, "utf-8"));
+      const data = JSON.parse(readFileSync54(archivePath, "utf-8"));
       archived = (data.tasks ?? data.archivedTasks ?? []).length;
     } catch {
     }
   }
-  const sessionsPath = join72(cleoDir, "sessions.json");
-  if (existsSync72(sessionsPath)) {
+  const sessionsPath = join73(cleoDir, "sessions.json");
+  if (existsSync73(sessionsPath)) {
     try {
-      const data = JSON.parse(readFileSync53(sessionsPath, "utf-8"));
+      const data = JSON.parse(readFileSync54(sessionsPath, "utf-8"));
       sessions2 = (data.sessions ?? []).length;
     } catch {
     }
@@ -19769,7 +19853,7 @@ async function migrateJsonToSqliteAtomic(cwd, tempDbPath, logger) {
   closeDb2();
   try {
     logger?.info("import", "init", "Initializing node:sqlite for migration");
-    mkdirSync18(dirname20(tempDbPath), { recursive: true });
+    mkdirSync19(dirname21(tempDbPath), { recursive: true });
     const nativeDb = openNativeDatabase(tempDbPath, { enableWal: true });
     const drizzleCallback = createDrizzleCallback(nativeDb);
     const batchCallback = createBatchCallback(nativeDb);
@@ -19826,13 +19910,13 @@ async function migrateJsonToSqliteAtomic(cwd, tempDbPath, logger) {
   }
 }
 async function runMigrationDataImport(db, cleoDir, result, logger) {
-  const todoPath = join72(cleoDir, "todo.json");
-  if (existsSync72(todoPath)) {
+  const todoPath = join73(cleoDir, "todo.json");
+  if (existsSync73(todoPath)) {
     try {
       logger?.info("import", "read-todo", "Reading todo.json", {
         path: todoPath.replace(cleoDir, ".")
       });
-      const todoData = JSON.parse(readFileSync53(todoPath, "utf-8"));
+      const todoData = JSON.parse(readFileSync54(todoPath, "utf-8"));
       const tasks2 = topoSortTasks(todoData.tasks ?? []);
       const totalTasks = tasks2.length;
       logger?.info("import", "tasks-start", `Starting import of ${totalTasks} tasks`, {
@@ -19906,13 +19990,13 @@ async function runMigrationDataImport(db, cleoDir, result, logger) {
     result.warnings.push("todo.json not found, skipping task import");
     logger?.warn("import", "todo-missing", "todo.json not found, skipping task import");
   }
-  const archivePath = join72(cleoDir, "todo-archive.json");
-  if (existsSync72(archivePath)) {
+  const archivePath = join73(cleoDir, "todo-archive.json");
+  if (existsSync73(archivePath)) {
     try {
       logger?.info("import", "read-archive", "Reading todo-archive.json", {
         path: archivePath.replace(cleoDir, ".")
       });
-      const archiveData = JSON.parse(readFileSync53(archivePath, "utf-8"));
+      const archiveData = JSON.parse(readFileSync54(archivePath, "utf-8"));
       const archivedTasks = topoSortTasks(archiveData.tasks ?? archiveData.archivedTasks ?? []);
       const totalArchived = archivedTasks.length;
       logger?.info(
@@ -19975,13 +20059,13 @@ async function runMigrationDataImport(db, cleoDir, result, logger) {
       logger?.error("import", "parse-archive", errorMsg);
     }
   }
-  const sessionsPath = join72(cleoDir, "sessions.json");
-  if (existsSync72(sessionsPath)) {
+  const sessionsPath = join73(cleoDir, "sessions.json");
+  if (existsSync73(sessionsPath)) {
     try {
       logger?.info("import", "read-sessions", "Reading sessions.json", {
         path: sessionsPath.replace(cleoDir, ".")
       });
-      const sessionsData = JSON.parse(readFileSync53(sessionsPath, "utf-8"));
+      const sessionsData = JSON.parse(readFileSync54(sessionsPath, "utf-8"));
       const sessions2 = sessionsData.sessions ?? [];
       const totalSessions = sessions2.length;
       logger?.info("import", "sessions-start", `Starting import of ${totalSessions} sessions`, {
@@ -20108,10 +20192,10 @@ async function migrateJsonToSqlite2(cwd, options) {
     return result;
   }
   const db = await getDb(cwd);
-  const todoPath = join72(cleoDir, "todo.json");
-  if (existsSync72(todoPath)) {
+  const todoPath = join73(cleoDir, "todo.json");
+  if (existsSync73(todoPath)) {
     try {
-      const todoData = JSON.parse(readFileSync53(todoPath, "utf-8"));
+      const todoData = JSON.parse(readFileSync54(todoPath, "utf-8"));
       const tasks2 = topoSortTasks(todoData.tasks ?? []);
       for (const task of tasks2) {
         try {
@@ -20160,10 +20244,10 @@ async function migrateJsonToSqlite2(cwd, options) {
   } else {
     result.warnings.push("todo.json not found, skipping task import");
   }
-  const archivePath = join72(cleoDir, "todo-archive.json");
-  if (existsSync72(archivePath)) {
+  const archivePath = join73(cleoDir, "todo-archive.json");
+  if (existsSync73(archivePath)) {
     try {
-      const archiveData = JSON.parse(readFileSync53(archivePath, "utf-8"));
+      const archiveData = JSON.parse(readFileSync54(archivePath, "utf-8"));
       const archivedTasks = topoSortTasks(archiveData.tasks ?? archiveData.archivedTasks ?? []);
       for (const task of archivedTasks) {
         try {
@@ -20198,10 +20282,10 @@ async function migrateJsonToSqlite2(cwd, options) {
       result.errors.push(`Failed to parse todo-archive.json: ${String(err)}`);
     }
   }
-  const sessionsPath = join72(cleoDir, "sessions.json");
-  if (existsSync72(sessionsPath)) {
+  const sessionsPath = join73(cleoDir, "sessions.json");
+  if (existsSync73(sessionsPath)) {
     try {
-      const sessionsData = JSON.parse(readFileSync53(sessionsPath, "utf-8"));
+      const sessionsData = JSON.parse(readFileSync54(sessionsPath, "utf-8"));
       const sessions2 = sessionsData.sessions ?? [];
       for (const session of sessions2) {
         try {
@@ -20269,8 +20353,8 @@ init_config();
 init_platform();
 init_storage_preflight();
 import { Command, Help } from "commander";
-import { readFileSync as readFileSync56 } from "node:fs";
-import { join as join77 } from "node:path";
+import { readFileSync as readFileSync57 } from "node:fs";
+import { join as join78 } from "node:path";
 
 // src/dispatch/adapters/cli.ts
 init_renderers();
@@ -31775,10 +31859,10 @@ async function systemLog(projectRoot, filters) {
 }
 async function queryAuditLogSqlite(projectRoot, filters) {
   try {
-    const { join: join78 } = await import("node:path");
-    const { existsSync: existsSync74 } = await import("node:fs");
-    const dbPath = join78(projectRoot, ".cleo", "tasks.db");
-    if (!existsSync74(dbPath)) {
+    const { join: join79 } = await import("node:path");
+    const { existsSync: existsSync75 } = await import("node:fs");
+    const dbPath = join79(projectRoot, ".cleo", "tasks.db");
+    if (!existsSync75(dbPath)) {
       const offset = filters?.offset ?? 0;
       const limit = filters?.limit ?? 20;
       return {
@@ -44545,11 +44629,11 @@ function registerInjectCommand(program2) {
 // src/cli/commands/install-global.ts
 init_paths();
 init_renderers();
-import { existsSync as existsSync67, readFileSync as readFileSync50 } from "node:fs";
+import { existsSync as existsSync68, readFileSync as readFileSync51 } from "node:fs";
 import { mkdir as mkdir12, readFile as readFile17, writeFile as writeFile11 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname18, join as join68, resolve as resolve9 } from "node:path";
-import { fileURLToPath as fileURLToPath6 } from "node:url";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname19, join as join69, resolve as resolve10 } from "node:path";
+import { fileURLToPath as fileURLToPath7 } from "node:url";
 function registerInstallGlobalCommand(program2) {
   program2.command("install-global").description("Refresh global CLEO setup: provider files, MCP configs, templates").option("--dry-run", "Preview changes without applying").action(async (opts) => {
     const isDryRun = !!opts["dryRun"];
@@ -44557,17 +44641,17 @@ function registerInstallGlobalCommand(program2) {
     const warnings = [];
     try {
       const cleoHome = getCleoHome();
-      const globalTemplatesDir = join68(cleoHome, "templates");
+      const globalTemplatesDir = join69(cleoHome, "templates");
       if (!isDryRun) {
         await mkdir12(globalTemplatesDir, { recursive: true });
       }
       try {
-        const thisFile = fileURLToPath6(import.meta.url);
-        const packageRoot = resolve9(dirname18(thisFile), "..", "..", "..");
-        const templatePath = join68(packageRoot, "templates", "CLEO-INJECTION.md");
-        if (existsSync67(templatePath)) {
-          const content = readFileSync50(templatePath, "utf-8");
-          const globalPath = join68(globalTemplatesDir, "CLEO-INJECTION.md");
+        const thisFile = fileURLToPath7(import.meta.url);
+        const packageRoot = resolve10(dirname19(thisFile), "..", "..", "..");
+        const templatePath = join69(packageRoot, "templates", "CLEO-INJECTION.md");
+        if (existsSync68(templatePath)) {
+          const content = readFileSync51(templatePath, "utf-8");
+          const globalPath = join69(globalTemplatesDir, "CLEO-INJECTION.md");
           if (!isDryRun) {
             await writeFile11(globalPath, content);
           }
@@ -44579,12 +44663,12 @@ function registerInstallGlobalCommand(program2) {
         warnings.push("Could not refresh CLEO-INJECTION.md template");
       }
       const globalAgentsDir = getAgentsHome();
-      const globalAgentsMd = join68(globalAgentsDir, "AGENTS.md");
+      const globalAgentsMd = join69(globalAgentsDir, "AGENTS.md");
       try {
         const { inject, getInstalledProviders: getInstalledProviders3, injectAll: injectAll2, buildInjectionContent: buildInjectionContent2 } = await import("@cleocode/caamp");
         if (!isDryRun) {
           await mkdir12(globalAgentsDir, { recursive: true });
-          if (existsSync67(globalAgentsMd)) {
+          if (existsSync68(globalAgentsMd)) {
             const content = await readFile17(globalAgentsMd, "utf8");
             const stripped = content.replace(
               /\n?<!-- CLEO:START -->[\s\S]*?<!-- CLEO:END -->\n?/g,
@@ -44608,8 +44692,8 @@ function registerInstallGlobalCommand(program2) {
           });
           if (!isDryRun) {
             for (const provider of providers) {
-              const instructFilePath = join68(provider.pathGlobal, provider.instructFile);
-              if (existsSync67(instructFilePath)) {
+              const instructFilePath = join69(provider.pathGlobal, provider.instructFile);
+              if (existsSync68(instructFilePath)) {
                 const fileContent = await readFile17(instructFilePath, "utf8");
                 const stripped = fileContent.replace(
                   /\n?<!-- CLEO:START -->[\s\S]*?<!-- CLEO:END -->\n?/g,
@@ -44620,14 +44704,14 @@ function registerInstallGlobalCommand(program2) {
                 }
               }
             }
-            const results = await injectAll2(providers, homedir4(), "global", injectionContent);
+            const results = await injectAll2(providers, homedir5(), "global", injectionContent);
             for (const [filePath, action] of results) {
-              const displayPath = filePath.replace(homedir4(), "~");
+              const displayPath = filePath.replace(homedir5(), "~");
               created.push(`${displayPath} (${action})`);
             }
           } else {
             for (const p of providers) {
-              const displayPath = join68(p.pathGlobal, p.instructFile).replace(homedir4(), "~");
+              const displayPath = join69(p.pathGlobal, p.instructFile).replace(homedir5(), "~");
               created.push(`${displayPath} (would update CAAMP block)`);
             }
           }
@@ -44649,7 +44733,7 @@ function registerInstallGlobalCommand(program2) {
               serverName,
               serverEntry,
               "global",
-              homedir4()
+              homedir5()
             );
             const successes = results.filter((r) => r.success);
             if (successes.length > 0) {
@@ -44674,6 +44758,16 @@ function registerInstallGlobalCommand(program2) {
           `Core skills installation failed: ${err instanceof Error ? err.message : String(err)}`
         );
       }
+      try {
+        const { installClaudePlugin: installClaudePlugin2 } = await Promise.resolve().then(() => (init_claude_plugin(), claude_plugin_exports));
+        const pluginResult = await installClaudePlugin2({ dryRun: isDryRun });
+        created.push(...pluginResult.created);
+        warnings.push(...pluginResult.warnings);
+      } catch (err) {
+        warnings.push(
+          `Claude plugin install skipped: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
       cliOutput(
         {
           success: true,
@@ -44699,7 +44793,7 @@ import { execFileSync as execFileSync12 } from "node:child_process";
 // src/config/build-config.ts
 var BUILD_CONFIG = {
   "name": "@cleocode/cleo",
-  "version": "2026.3.26",
+  "version": "2026.3.27",
   "description": "CLEO V2 - TypeScript task management CLI for AI coding agents",
   "repository": {
     "owner": "kryptobaseddev",
@@ -44708,7 +44802,7 @@ var BUILD_CONFIG = {
     "url": "https://github.com/kryptobaseddev/cleo.git",
     "issuesUrl": "https://github.com/kryptobaseddev/cleo/issues"
   },
-  "buildDate": "2026-03-09T06:01:59.186Z",
+  "buildDate": "2026-03-09T06:31:53.689Z",
   "templates": {
     "issueTemplatesDir": "templates/issue-templates"
   }
@@ -45167,7 +45261,7 @@ function registerMemoryBrainCommand(program2) {
 init_brain_sqlite();
 init_paths();
 init_brain_search();
-import { existsSync as existsSync68 } from "node:fs";
+import { existsSync as existsSync69 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
 var _require5 = createRequire5(import.meta.url);
 var { DatabaseSync: DatabaseSync3 } = _require5("node:sqlite");
@@ -45211,7 +45305,7 @@ async function migrateClaudeMem(projectRoot, options = {}) {
     errors: [],
     dryRun
   };
-  if (!existsSync68(sourcePath)) {
+  if (!existsSync69(sourcePath)) {
     throw new Error(
       `claude-mem database not found at: ${sourcePath}
 Expected location: ~/.claude-mem/claude-mem.db
@@ -45649,22 +45743,22 @@ function registerOrchestrateCommand(program2) {
 init_errors();
 
 // src/core/otel/index.ts
-import { copyFileSync as copyFileSync4, existsSync as existsSync69, readFileSync as readFileSync51, writeFileSync as writeFileSync11 } from "node:fs";
-import { join as join69 } from "node:path";
+import { copyFileSync as copyFileSync4, existsSync as existsSync70, readFileSync as readFileSync52, writeFileSync as writeFileSync12 } from "node:fs";
+import { join as join70 } from "node:path";
 function getProjectRoot2() {
   let dir = process.cwd();
   while (dir !== "/") {
-    if (existsSync69(join69(dir, ".cleo", "config.json"))) return dir;
-    dir = join69(dir, "..");
+    if (existsSync70(join70(dir, ".cleo", "config.json"))) return dir;
+    dir = join70(dir, "..");
   }
   return process.cwd();
 }
 function getTokenFilePath() {
-  return join69(getProjectRoot2(), ".cleo", "metrics", "TOKEN_USAGE.jsonl");
+  return join70(getProjectRoot2(), ".cleo", "metrics", "TOKEN_USAGE.jsonl");
 }
 function readJsonlFile(filePath) {
-  if (!existsSync69(filePath)) return [];
-  const content = readFileSync51(filePath, "utf-8").trim();
+  if (!existsSync70(filePath)) return [];
+  const content = readFileSync52(filePath, "utf-8").trim();
   if (!content) return [];
   return content.split("\n").map((line) => JSON.parse(line));
 }
@@ -45746,10 +45840,10 @@ async function getRealTokenUsage(_opts) {
 }
 async function clearOtelData() {
   const tokenFile = getTokenFilePath();
-  if (existsSync69(tokenFile)) {
+  if (existsSync70(tokenFile)) {
     const backup = `${tokenFile}.backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
     copyFileSync4(tokenFile, backup);
-    writeFileSync11(tokenFile, "");
+    writeFileSync12(tokenFile, "");
     return { message: "Token tracking cleared", backup };
   }
   return { message: "No token file to clear" };
@@ -46056,11 +46150,11 @@ init_output();
 init_git_checkpoint();
 init_paths();
 import { execFile as execFile6 } from "node:child_process";
-import { resolve as resolve10 } from "node:path";
+import { resolve as resolve11 } from "node:path";
 import { promisify as promisify8 } from "node:util";
 var execFileAsync4 = promisify8(execFile6);
 async function cleoGitExec(args, cleoDir) {
-  const abs = resolve10(cleoDir);
+  const abs = resolve11(cleoDir);
   const result = await execFileAsync4("git", args, {
     cwd: abs,
     env: makeCleoGitEnv(cleoDir),
@@ -46825,7 +46919,7 @@ function registerSafestopCommand(program2) {
 // src/cli/commands/self-update.ts
 import { execFile as execFile7 } from "node:child_process";
 import { readFile as readFile19 } from "node:fs/promises";
-import { join as join74 } from "node:path";
+import { join as join75 } from "node:path";
 import * as readline from "node:readline";
 import { promisify as promisify9 } from "node:util";
 init_errors();
@@ -46836,13 +46930,13 @@ init_storage_preflight();
 // src/core/upgrade.ts
 import {
   copyFileSync as copyFileSync5,
-  existsSync as existsSync73,
-  mkdirSync as mkdirSync19,
+  existsSync as existsSync74,
+  mkdirSync as mkdirSync20,
   readdirSync as readdirSync20,
-  readFileSync as readFileSync54,
-  writeFileSync as writeFileSync12
+  readFileSync as readFileSync55,
+  writeFileSync as writeFileSync13
 } from "node:fs";
-import { join as join73 } from "node:path";
+import { join as join74 } from "node:path";
 
 // src/store/index.ts
 init_atomic();
@@ -46888,8 +46982,8 @@ async function runUpgrade(options = {}) {
     };
   }
   const cleoDir = getCleoDirAbsolute(options.cwd);
-  const dbPath = join73(cleoDir, "tasks.db");
-  const dbExists2 = existsSync73(dbPath);
+  const dbPath = join74(cleoDir, "tasks.db");
+  const dbExists2 = existsSync74(dbPath);
   const legacyRecordCount = preflight.details.todoJsonTaskCount + preflight.details.archiveJsonTaskCount + preflight.details.sessionsJsonCount;
   const needsMigration = !dbExists2 && legacyRecordCount > 0;
   const needsCleanup = dbExists2 && preflight.migrationNeeded;
@@ -46905,7 +46999,7 @@ async function runUpgrade(options = {}) {
       let migrationLock = null;
       try {
         const cleoDir2 = getCleoDirAbsolute(options.cwd);
-        const dbPath2 = join73(cleoDir2, "tasks.db");
+        const dbPath2 = join74(cleoDir2, "tasks.db");
         try {
           migrationLock = await acquireLock(dbPath2, { stale: 3e4, retries: 0 });
         } catch {
@@ -46930,28 +47024,28 @@ async function runUpgrade(options = {}) {
         } = await Promise.resolve().then(() => (init_state(), state_exports));
         const logger = new MigrationLogger2(cleoDir2);
         await createMigrationState2(cleoDir2, {
-          todoJson: { path: join73(cleoDir2, "todo.json"), checksum: "" },
-          sessionsJson: { path: join73(cleoDir2, "sessions.json"), checksum: "" },
-          archiveJson: { path: join73(cleoDir2, "todo-archive.json"), checksum: "" }
+          todoJson: { path: join74(cleoDir2, "todo.json"), checksum: "" },
+          sessionsJson: { path: join74(cleoDir2, "sessions.json"), checksum: "" },
+          archiveJson: { path: join74(cleoDir2, "todo-archive.json"), checksum: "" }
         });
         await updateMigrationPhase2(cleoDir2, "backup");
         logger.info("init", "start", "Migration state initialized");
-        const dbBackupPath = join73(
+        const dbBackupPath = join74(
           cleoDir2,
           "backups",
           "safety",
           `tasks.db.pre-migration.${Date.now()}`
         );
-        const dbTempPath = join73(cleoDir2, "tasks.db.migrating");
-        if (existsSync73(dbPath2)) {
-          const backupDir = join73(cleoDir2, "backups", "safety");
-          if (!existsSync73(backupDir)) {
-            mkdirSync19(backupDir, { recursive: true });
+        const dbTempPath = join74(cleoDir2, "tasks.db.migrating");
+        if (existsSync74(dbPath2)) {
+          const backupDir = join74(cleoDir2, "backups", "safety");
+          if (!existsSync74(backupDir)) {
+            mkdirSync20(backupDir, { recursive: true });
           }
           copyFileSync5(dbPath2, dbBackupPath);
           const { createHash: createHash10 } = await import("node:crypto");
-          const origChecksum = createHash10("sha256").update(readFileSync54(dbPath2)).digest("hex");
-          const backupChecksum = createHash10("sha256").update(readFileSync54(dbBackupPath)).digest("hex");
+          const origChecksum = createHash10("sha256").update(readFileSync55(dbPath2)).digest("hex");
+          const backupChecksum = createHash10("sha256").update(readFileSync55(dbBackupPath)).digest("hex");
           if (origChecksum !== backupChecksum) {
             throw new Error(
               `Backup verification failed: checksum mismatch. Aborting migration to prevent data loss.`
@@ -46968,14 +47062,14 @@ async function runUpgrade(options = {}) {
             checksum: origChecksum
           });
         }
-        if (existsSync73(dbTempPath)) {
+        if (existsSync74(dbTempPath)) {
           const { unlinkSync: unlinkSync6 } = await import("node:fs");
           unlinkSync6(dbTempPath);
         }
-        const configPath = join73(cleoDir2, "config.json");
+        const configPath = join74(cleoDir2, "config.json");
         let configBackup = null;
-        if (existsSync73(configPath)) {
-          configBackup = readFileSync54(configPath, "utf-8");
+        if (existsSync74(configPath)) {
+          configBackup = readFileSync55(configPath, "utf-8");
         }
         const { resetDbState: resetDbState2 } = await Promise.resolve().then(() => (init_sqlite(), sqlite_exports));
         resetDbState2();
@@ -47003,10 +47097,10 @@ async function runUpgrade(options = {}) {
         resetDbState2();
         if (result.success) {
           const totalImported = result.tasksImported + result.archivedImported;
-          if (totalImported === 0 && existsSync73(dbBackupPath)) {
+          if (totalImported === 0 && existsSync74(dbBackupPath)) {
             copyFileSync5(dbBackupPath, dbPath2);
             if (configBackup) {
-              writeFileSync12(configPath, configBackup);
+              writeFileSync13(configPath, configBackup);
             }
             actions.push({
               action: "storage_migration",
@@ -47017,9 +47111,9 @@ async function runUpgrade(options = {}) {
             errors.push("Migration imported 0 tasks \u2014 restored from backup to prevent data loss");
           } else {
             let config = {};
-            if (existsSync73(configPath)) {
+            if (existsSync74(configPath)) {
               try {
-                config = JSON.parse(readFileSync54(configPath, "utf-8"));
+                config = JSON.parse(readFileSync55(configPath, "utf-8"));
               } catch {
               }
             }
@@ -47027,7 +47121,7 @@ async function runUpgrade(options = {}) {
               config.storage = {};
             }
             config.storage.engine = "sqlite";
-            writeFileSync12(configPath, JSON.stringify(config, null, 2));
+            writeFileSync13(configPath, JSON.stringify(config, null, 2));
             actions.push({
               action: "storage_migration",
               status: "applied",
@@ -47045,11 +47139,11 @@ async function runUpgrade(options = {}) {
             logger.info("complete", "finish", "Migration completed successfully");
           }
         } else {
-          if (existsSync73(dbBackupPath)) {
+          if (existsSync74(dbBackupPath)) {
             copyFileSync5(dbBackupPath, dbPath2);
           }
           if (configBackup) {
-            writeFileSync12(configPath, configBackup);
+            writeFileSync13(configPath, configBackup);
           }
           await updateMigrationPhase2(cleoDir2, "failed");
           for (const error of result.errors) {
@@ -47068,12 +47162,12 @@ async function runUpgrade(options = {}) {
       } catch (err) {
         try {
           const cleoDir2 = getCleoDirAbsolute(options.cwd);
-          const dbPath2 = join73(cleoDir2, "tasks.db");
-          const safetyDir = join73(cleoDir2, "backups", "safety");
-          if (existsSync73(safetyDir)) {
+          const dbPath2 = join74(cleoDir2, "tasks.db");
+          const safetyDir = join74(cleoDir2, "backups", "safety");
+          if (existsSync74(safetyDir)) {
             const backups = readdirSync20(safetyDir).filter((f) => f.startsWith("tasks.db.pre-migration.")).sort().reverse();
-            if (backups.length > 0 && !existsSync73(dbPath2)) {
-              copyFileSync5(join73(safetyDir, backups[0]), dbPath2);
+            if (backups.length > 0 && !existsSync74(dbPath2)) {
+              copyFileSync5(join74(safetyDir, backups[0]), dbPath2);
             }
           }
         } catch {
@@ -47108,7 +47202,7 @@ async function runUpgrade(options = {}) {
       details: preflight.summary
     });
   }
-  if (existsSync73(dbPath)) {
+  if (existsSync74(dbPath)) {
     try {
       const { runAllRepairs: runAllRepairs2 } = await Promise.resolve().then(() => (init_repair(), repair_exports));
       const repairActions = await runAllRepairs2(options.cwd, isDryRun);
@@ -47118,9 +47212,9 @@ async function runUpgrade(options = {}) {
     } catch {
     }
   }
-  if (existsSync73(dbPath)) {
+  if (existsSync74(dbPath)) {
     const legacySequenceFiles = [".sequence", ".sequence.json"].filter(
-      (f) => existsSync73(join73(cleoDir, f))
+      (f) => existsSync74(join74(cleoDir, f))
     );
     if (legacySequenceFiles.length > 0) {
       if (isDryRun) {
@@ -47156,7 +47250,7 @@ async function runUpgrade(options = {}) {
       ".sequence",
       ".sequence.json"
     ];
-    const foundStale = staleJsonFiles.filter((f) => existsSync73(join73(cleoDir, f)));
+    const foundStale = staleJsonFiles.filter((f) => existsSync74(join74(cleoDir, f)));
     if (foundStale.length > 0) {
       if (isDryRun) {
         actions.push({
@@ -47166,15 +47260,15 @@ async function runUpgrade(options = {}) {
         });
       } else {
         try {
-          const backupDir = join73(cleoDir, ".backups", `legacy-json-${Date.now()}`);
-          mkdirSync19(backupDir, { recursive: true });
+          const backupDir = join74(cleoDir, ".backups", `legacy-json-${Date.now()}`);
+          mkdirSync20(backupDir, { recursive: true });
           for (const f of foundStale) {
-            const src = join73(cleoDir, f);
-            copyFileSync5(src, join73(backupDir, f));
+            const src = join74(cleoDir, f);
+            copyFileSync5(src, join74(backupDir, f));
           }
           const { unlinkSync: unlinkSync6 } = await import("node:fs");
           for (const f of foundStale) {
-            unlinkSync6(join73(cleoDir, f));
+            unlinkSync6(join74(cleoDir, f));
           }
           actions.push({
             action: "stale_json_cleanup",
@@ -47194,7 +47288,7 @@ async function runUpgrade(options = {}) {
   if (options.includeGlobal) {
     try {
       const globalDir = getCleoHome();
-      const globalPreflight = checkStorageMigration(join73(globalDir, ".."));
+      const globalPreflight = checkStorageMigration(join74(globalDir, ".."));
       if (globalPreflight.migrationNeeded) {
         actions.push({
           action: "global_storage_check",
@@ -47215,8 +47309,8 @@ async function runUpgrade(options = {}) {
   try {
     const projectRoot = getProjectRoot(options.cwd);
     if (isDryRun) {
-      const gitignorePath = join73(cleoDir, ".gitignore");
-      if (!existsSync73(gitignorePath)) {
+      const gitignorePath = join74(cleoDir, ".gitignore");
+      if (!existsSync74(gitignorePath)) {
         actions.push({
           action: "gitignore_integrity",
           status: "preview",
@@ -47267,8 +47361,8 @@ async function runUpgrade(options = {}) {
   try {
     const projectRootForContext = getProjectRoot(options.cwd);
     if (isDryRun) {
-      const contextPath = join73(cleoDir, "project-context.json");
-      if (!existsSync73(contextPath)) {
+      const contextPath = join74(cleoDir, "project-context.json");
+      if (!existsSync74(contextPath)) {
         actions.push({
           action: "project_context_detection",
           status: "preview",
@@ -47276,7 +47370,7 @@ async function runUpgrade(options = {}) {
         });
       } else {
         try {
-          const context = JSON.parse(readFileSync54(contextPath, "utf-8"));
+          const context = JSON.parse(readFileSync55(contextPath, "utf-8"));
           if (context.detectedAt) {
             const daysSince = (Date.now() - new Date(context.detectedAt).getTime()) / (1e3 * 60 * 60 * 24);
             if (daysSince > 30) {
@@ -47505,7 +47599,7 @@ var GITHUB_REPO = BUILD_CONFIG.repository.fullName;
 async function getCurrentVersion() {
   const cleoHome = getCleoHome();
   try {
-    const content = await readFile19(join74(cleoHome, "VERSION"), "utf-8");
+    const content = await readFile19(join75(cleoHome, "VERSION"), "utf-8");
     return (content.split("\n")[0] ?? "unknown").trim();
   } catch {
     return "unknown";
@@ -47559,7 +47653,7 @@ async function writeRuntimeVersionMetadata(mode, source, version) {
   ];
   await import("node:fs/promises").then(
     ({ writeFile: writeFile14, mkdir: mkdir14 }) => mkdir14(cleoHome, { recursive: true }).then(
-      () => writeFile14(join74(cleoHome, "VERSION"), `${lines.join("\n")}
+      () => writeFile14(join75(cleoHome, "VERSION"), `${lines.join("\n")}
 `, "utf-8")
     )
   );
@@ -47752,11 +47846,11 @@ async function runPostUpdateDiagnostics(opts) {
         input: process.stdin,
         output: process.stdout
       });
-      shouldMigrate = await new Promise((resolve11) => {
+      shouldMigrate = await new Promise((resolve12) => {
         rl.question("  Do you want to run the upgrade now? [Y/n] ", (answer) => {
           rl.close();
           const clean = answer.trim().toLowerCase();
-          resolve11(clean === "" || clean === "y" || clean === "yes");
+          resolve12(clean === "" || clean === "y" || clean === "yes");
         });
       });
     }
@@ -48507,12 +48601,12 @@ function registerTestingCommand(program2) {
 }
 
 // src/cli/commands/token.ts
-import { readFileSync as readFileSync55 } from "node:fs";
+import { readFileSync as readFileSync56 } from "node:fs";
 init_renderers();
 function readPayload(opts, textKey, fileKey) {
   const text5 = opts[textKey];
   const file = opts[fileKey];
-  if (file) return readFileSync55(file, "utf-8");
+  if (file) return readFileSync56(file, "utf-8");
   return text5;
 }
 function registerTokenCommand(program2) {
@@ -48745,15 +48839,15 @@ init_exit_codes();
 init_renderers();
 import { execFileSync as execFileSync13, spawn as spawn2 } from "node:child_process";
 import { mkdir as mkdir13, readFile as readFile20, rm as rm4, stat as stat4, writeFile as writeFile13 } from "node:fs/promises";
-import { join as join75 } from "node:path";
+import { join as join76 } from "node:path";
 var DEFAULT_PORT = 3456;
 var DEFAULT_HOST = "127.0.0.1";
 function getWebPaths() {
   const cleoHome = getCleoHome();
   return {
-    pidFile: join75(cleoHome, "web-server.pid"),
-    configFile: join75(cleoHome, "web-server.json"),
-    logFile: join75(cleoHome, "logs", "web-server.log")
+    pidFile: join76(cleoHome, "web-server.pid"),
+    configFile: join76(cleoHome, "web-server.json"),
+    logFile: join76(cleoHome, "logs", "web-server.log")
   };
 }
 function isProcessRunning(pid) {
@@ -48800,8 +48894,8 @@ function registerWebCommand(program2) {
         );
       }
       const projectRoot = process.env["CLEO_ROOT"] ?? process.cwd();
-      const distMcpDir = join75(projectRoot, "dist", "mcp");
-      await mkdir13(join75(getCleoHome(), "logs"), { recursive: true });
+      const distMcpDir = join76(projectRoot, "dist", "mcp");
+      await mkdir13(join76(getCleoHome(), "logs"), { recursive: true });
       await writeFile13(
         configFile,
         JSON.stringify({
@@ -48810,7 +48904,7 @@ function registerWebCommand(program2) {
           startedAt: (/* @__PURE__ */ new Date()).toISOString()
         })
       );
-      const webIndexPath = join75(distMcpDir, "index.js");
+      const webIndexPath = join76(distMcpDir, "index.js");
       try {
         await stat4(webIndexPath);
       } catch {
@@ -48843,7 +48937,7 @@ function registerWebCommand(program2) {
           }
         } catch {
         }
-        await new Promise((resolve11) => setTimeout(resolve11, 500));
+        await new Promise((resolve12) => setTimeout(resolve12, 500));
       }
       if (!started) {
         try {
@@ -48885,7 +48979,7 @@ function registerWebCommand(program2) {
       }
       for (let i = 0; i < 10; i++) {
         if (!isProcessRunning(status.pid)) break;
-        await new Promise((resolve11) => setTimeout(resolve11, 500));
+        await new Promise((resolve12) => setTimeout(resolve12, 500));
       }
       if (isProcessRunning(status.pid)) {
         try {
@@ -48952,10 +49046,10 @@ init_format_context();
 // src/cli/logger-bootstrap.ts
 init_logger();
 init_project_info();
-import { join as join76 } from "node:path";
+import { join as join77 } from "node:path";
 function initCliLogger(cwd, loggingConfig) {
   const projectInfo = getProjectInfoSync(cwd);
-  initLogger(join76(cwd, ".cleo"), loggingConfig, projectInfo?.projectHash);
+  initLogger(join77(cwd, ".cleo"), loggingConfig, projectInfo?.projectHash);
 }
 
 // src/cli/middleware/output-format.ts
@@ -49166,8 +49260,8 @@ Upgrade options:
 }
 function getPackageVersion() {
   try {
-    const moduleRoot = join77(import.meta.dirname ?? "", "..", "..");
-    const pkg = JSON.parse(readFileSync56(join77(moduleRoot, "package.json"), "utf-8"));
+    const moduleRoot = join78(import.meta.dirname ?? "", "..", "..");
+    const pkg = JSON.parse(readFileSync57(join78(moduleRoot, "package.json"), "utf-8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -49279,7 +49373,7 @@ program.hook("preAction", async () => {
     const config = await loadConfig();
     initCliLogger(process.cwd(), config.logging);
     const { pruneAuditLog: pruneAuditLog2 } = await Promise.resolve().then(() => (init_audit_prune(), audit_prune_exports));
-    pruneAuditLog2(join77(process.cwd(), ".cleo"), config.logging).catch(() => {
+    pruneAuditLog2(join78(process.cwd(), ".cleo"), config.logging).catch(() => {
     });
   } catch {
   }
@@ -49319,7 +49413,7 @@ program.hook("preAction", (thisCommand) => {
   }
 });
 if (process.argv[2] === "mcp") {
-  const mcpPath = join77(import.meta.dirname ?? "", "..", "mcp", "index.js");
+  const mcpPath = join78(import.meta.dirname ?? "", "..", "mcp", "index.js");
   const { spawn: spawn3 } = await import("node:child_process");
   const child = spawn3(process.execPath, ["--disable-warning=ExperimentalWarning", mcpPath], {
     stdio: "inherit"