@corbat-tech/coco 2.25.0 → 2.25.2

package/dist/cli/index.js

@@ -1,17 +1,17 @@
 #!/usr/bin/env node
 import * as fs5 from 'fs';
 import fs5__default, { accessSync, readFileSync, constants } from 'fs';
-import * as path37 from 'path';
-import path37__default, { join, dirname, resolve, basename } from 'path';
+import * as path38 from 'path';
+import path38__default, { join, dirname, resolve, basename } from 'path';
 import { URL as URL$1, fileURLToPath } from 'url';
 import { z } from 'zod';
 import * as os4 from 'os';
 import os4__default, { homedir } from 'os';
-import * as fs34 from 'fs/promises';
-import fs34__default, { mkdir, writeFile, readFile, access, readdir, rm } from 'fs/promises';
+import * as fs35 from 'fs/promises';
+import fs35__default, { mkdir, writeFile, readFile, access, readdir, rm } from 'fs/promises';
 import JSON5 from 'json5';
 import * as crypto from 'crypto';
-import { randomUUID } from 'crypto';
+import { randomUUID, randomBytes, createHash } from 'crypto';
 import * as http from 'http';
 import * as p26 from '@clack/prompts';
 import chalk from 'chalk';
@@ -556,7 +556,7 @@ async function loadConfig(configPath) {
 async function loadConfigFile(configPath, options = {}) {
   const { strict = true } = options;
   try {
-    const content = await fs34__default.readFile(configPath, "utf-8");
+    const content = await fs35__default.readFile(configPath, "utf-8");
     const parsed = JSON5.parse(content);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
       if (!strict) {
@@ -612,7 +612,7 @@ function deepMergeConfig(base, override) {
   };
 }
 function getProjectConfigPath() {
-  return path37__default.join(process.cwd(), ".coco", "config.json");
+  return path38__default.join(process.cwd(), ".coco", "config.json");
 }
 async function saveConfig(config, configPath, global = false) {
   const result = CocoConfigSchema.safeParse(config);
@@ -627,10 +627,10 @@ async function saveConfig(config, configPath, global = false) {
     });
   }
   const resolvedPath = configPath || (global ? CONFIG_PATHS.config : getProjectConfigPath());
-  const dir = path37__default.dirname(resolvedPath);
-  await fs34__default.mkdir(dir, { recursive: true });
+  const dir = path38__default.dirname(resolvedPath);
+  await fs35__default.mkdir(dir, { recursive: true });
   const content = JSON.stringify(result.data, null, 2);
-  await fs34__default.writeFile(resolvedPath, content, "utf-8");
+  await fs35__default.writeFile(resolvedPath, content, "utf-8");
 }
 function createDefaultConfig(projectName, language = "typescript") {
   return createDefaultConfigObject(projectName, language);
@@ -639,20 +639,20 @@ async function findConfigPath(cwd) {
   const envPath = process.env["COCO_CONFIG_PATH"];
   if (envPath) {
     try {
-      await fs34__default.access(envPath);
+      await fs35__default.access(envPath);
       return envPath;
     } catch {
     }
   }
   const basePath = cwd || process.cwd();
-  const projectConfigPath = path37__default.join(basePath, ".coco", "config.json");
+  const projectConfigPath = path38__default.join(basePath, ".coco", "config.json");
   try {
-    await fs34__default.access(projectConfigPath);
+    await fs35__default.access(projectConfigPath);
     return projectConfigPath;
   } catch {
   }
   try {
-    await fs34__default.access(CONFIG_PATHS.config);
+    await fs35__default.access(CONFIG_PATHS.config);
     return CONFIG_PATHS.config;
   } catch {
     return void 0;
@@ -661,14 +661,14 @@ async function findConfigPath(cwd) {
 async function findAllConfigPaths(cwd) {
   const result = {};
   try {
-    await fs34__default.access(CONFIG_PATHS.config);
+    await fs35__default.access(CONFIG_PATHS.config);
     result.global = CONFIG_PATHS.config;
   } catch {
   }
   const basePath = cwd || process.cwd();
-  const projectConfigPath = path37__default.join(basePath, ".coco", "config.json");
+  const projectConfigPath = path38__default.join(basePath, ".coco", "config.json");
   try {
-    await fs34__default.access(projectConfigPath);
+    await fs35__default.access(projectConfigPath);
     result.project = projectConfigPath;
   } catch {
   }
@@ -677,7 +677,7 @@ async function findAllConfigPaths(cwd) {
 async function configExists(configPath, scope = "any") {
   if (configPath) {
     try {
-      await fs34__default.access(configPath);
+      await fs35__default.access(configPath);
       return true;
     } catch {
       return false;
@@ -685,7 +685,7 @@ async function configExists(configPath, scope = "any") {
   }
   if (scope === "project" || scope === "any") {
     try {
-      await fs34__default.access(getProjectConfigPath());
+      await fs35__default.access(getProjectConfigPath());
       return true;
     } catch {
       if (scope === "project") return false;
@@ -693,7 +693,7 @@ async function configExists(configPath, scope = "any") {
   }
   if (scope === "global" || scope === "any") {
     try {
-      await fs34__default.access(CONFIG_PATHS.config);
+      await fs35__default.access(CONFIG_PATHS.config);
       return true;
     } catch {
       return false;
@@ -701,8 +701,8 @@ async function configExists(configPath, scope = "any") {
   }
   return false;
 }
-function getConfigValue(config, path59) {
-  const keys = path59.split(".");
+function getConfigValue(config, path60) {
+  const keys = path60.split(".");
   let current = config;
   for (const key of keys) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -879,18 +879,18 @@ async function refreshAccessToken(provider, refreshToken) {
 }
 function getTokenStoragePath(provider) {
   const home = process.env.HOME || process.env.USERPROFILE || "";
-  return path37.join(home, ".coco", "tokens", `${provider}.json`);
+  return path38.join(home, ".coco", "tokens", `${provider}.json`);
 }
 async function saveTokens(provider, tokens) {
   const filePath = getTokenStoragePath(provider);
-  const dir = path37.dirname(filePath);
-  await fs34.mkdir(dir, { recursive: true, mode: 448 });
-  await fs34.writeFile(filePath, JSON.stringify(tokens, null, 2), { mode: 384 });
+  const dir = path38.dirname(filePath);
+  await fs35.mkdir(dir, { recursive: true, mode: 448 });
+  await fs35.writeFile(filePath, JSON.stringify(tokens, null, 2), { mode: 384 });
 }
 async function loadTokens(provider) {
   const filePath = getTokenStoragePath(provider);
   try {
-    const content = await fs34.readFile(filePath, "utf-8");
+    const content = await fs35.readFile(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -899,7 +899,7 @@ async function loadTokens(provider) {
 async function deleteTokens(provider) {
   const filePath = getTokenStoragePath(provider);
   try {
-    await fs34.unlink(filePath);
+    await fs35.unlink(filePath);
   } catch {
   }
 }
@@ -1009,16 +1009,16 @@ var init_oauth = __esm({
   }
 });
 function generateCodeVerifier(length = 64) {
-  const randomBytes2 = crypto.randomBytes(length);
-  return base64UrlEncode(randomBytes2);
+  const randomBytes3 = crypto.randomBytes(length);
+  return base64UrlEncode(randomBytes3);
 }
 function generateCodeChallenge(codeVerifier) {
   const hash = crypto.createHash("sha256").update(codeVerifier).digest();
   return base64UrlEncode(hash);
 }
 function generateState(length = 32) {
-  const randomBytes2 = crypto.randomBytes(length);
-  return base64UrlEncode(randomBytes2);
+  const randomBytes3 = crypto.randomBytes(length);
+  return base64UrlEncode(randomBytes3);
 }
 function base64UrlEncode(buffer) {
   return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
@@ -1479,17 +1479,17 @@ function getCopilotBaseUrl(accountType) {
 }
 function getCopilotCredentialsPath() {
   const home = process.env.HOME || process.env.USERPROFILE || "";
-  return path37.join(home, ".coco", "tokens", "copilot.json");
+  return path38.join(home, ".coco", "tokens", "copilot.json");
 }
 async function saveCopilotCredentials(creds) {
   const filePath = getCopilotCredentialsPath();
-  const dir = path37.dirname(filePath);
-  await fs34.mkdir(dir, { recursive: true, mode: 448 });
-  await fs34.writeFile(filePath, JSON.stringify(creds, null, 2), { mode: 384 });
+  const dir = path38.dirname(filePath);
+  await fs35.mkdir(dir, { recursive: true, mode: 448 });
+  await fs35.writeFile(filePath, JSON.stringify(creds, null, 2), { mode: 384 });
 }
 async function loadCopilotCredentials() {
   try {
-    const content = await fs34.readFile(getCopilotCredentialsPath(), "utf-8");
+    const content = await fs35.readFile(getCopilotCredentialsPath(), "utf-8");
     const parsed = CopilotCredentialsSchema.safeParse(JSON.parse(content));
     return parsed.success ? parsed.data : null;
   } catch {
@@ -1498,7 +1498,7 @@ async function loadCopilotCredentials() {
 }
 async function deleteCopilotCredentials() {
   try {
-    await fs34.unlink(getCopilotCredentialsPath());
+    await fs35.unlink(getCopilotCredentialsPath());
   } catch {
   }
 }
@@ -2239,7 +2239,7 @@ function getADCPath() {
   if (process.env.GOOGLE_APPLICATION_CREDENTIALS) {
     return process.env.GOOGLE_APPLICATION_CREDENTIALS;
   }
-  return path37.join(home, ".config", "gcloud", "application_default_credentials.json");
+  return path38.join(home, ".config", "gcloud", "application_default_credentials.json");
 }
 async function isGcloudInstalled() {
   try {
@@ -2252,7 +2252,7 @@ async function isGcloudInstalled() {
 async function hasADCCredentials() {
   const adcPath = getADCPath();
   try {
-    await fs34.access(adcPath);
+    await fs35.access(adcPath);
     return true;
   } catch {
     return false;
@@ -2395,7 +2395,7 @@ function loadGlobalCocoEnv() {
   try {
     const home = process.env.HOME || process.env.USERPROFILE || "";
     if (!home) return;
-    const globalEnvPath = path37.join(home, ".coco", ".env");
+    const globalEnvPath = path38.join(home, ".coco", ".env");
     const content = fs5.readFileSync(globalEnvPath, "utf-8");
     for (const line of content.split("\n")) {
       const trimmed = line.trim();
@@ -2633,7 +2633,7 @@ async function updateEnvProvider(provider) {
   try {
     const home = process.env.HOME || process.env.USERPROFILE || "";
     if (!home) return;
-    const envPath = path37.join(home, ".coco", ".env");
+    const envPath = path38.join(home, ".coco", ".env");
     let content;
     try {
       content = await fs5.promises.readFile(envPath, "utf-8");
@@ -2660,7 +2660,7 @@ async function removeEnvProvider() {
   try {
     const home = process.env.HOME || process.env.USERPROFILE || "";
     if (!home) return;
-    const envPath = path37.join(home, ".coco", ".env");
+    const envPath = path38.join(home, ".coco", ".env");
     let content;
     try {
       content = await fs5.promises.readFile(envPath, "utf-8");
@@ -2679,7 +2679,7 @@ async function migrateOldPreferences() {
   try {
     const home = process.env.HOME || process.env.USERPROFILE || "";
     if (!home) return;
-    const oldPrefsPath = path37.join(home, ".coco", "preferences.json");
+    const oldPrefsPath = path38.join(home, ".coco", "preferences.json");
     let oldPrefs = null;
     try {
       const content = await fs5.promises.readFile(oldPrefsPath, "utf-8");
@@ -2855,7 +2855,7 @@ function levelToNumber(level) {
 }
 function createLogger(config = {}) {
   const finalConfig = { ...DEFAULT_CONFIG, ...config };
-  const logger = new Logger({
+  const logger2 = new Logger({
     name: finalConfig.name,
     minLevel: levelToNumber(finalConfig.level),
     prettyLogTemplate: finalConfig.prettyPrint ? "{{yyyy}}-{{mm}}-{{dd}} {{hh}}:{{MM}}:{{ss}} {{logLevelName}} [{{name}}] " : void 0,
@@ -2863,16 +2863,16 @@ function createLogger(config = {}) {
     stylePrettyLogs: finalConfig.prettyPrint
   });
   if (finalConfig.logToFile && finalConfig.logDir) {
-    setupFileLogging(logger, finalConfig.logDir, finalConfig.name);
+    setupFileLogging(logger2, finalConfig.logDir, finalConfig.name);
   }
-  return logger;
+  return logger2;
 }
-function setupFileLogging(logger, logDir, name) {
+function setupFileLogging(logger2, logDir, name) {
   if (!fs5__default.existsSync(logDir)) {
     fs5__default.mkdirSync(logDir, { recursive: true });
   }
-  const logFile = path37__default.join(logDir, `${name}.log`);
-  logger.attachTransport((logObj) => {
+  const logFile = path38__default.join(logDir, `${name}.log`);
+  logger2.attachTransport((logObj) => {
     const line = JSON.stringify(logObj) + "\n";
     fs5__default.appendFileSync(logFile, line);
   });
@@ -2886,34 +2886,34 @@ function getLogger() {
   }
   return globalLogger;
 }
-function setLogger(logger) {
-  globalLogger = logger;
+function setLogger(logger2) {
+  globalLogger = logger2;
 }
 function initializeLogging(projectPath, level = "info") {
-  const logDir = path37__default.join(projectPath, ".coco", "logs");
-  const logger = createLogger({
+  const logDir = path38__default.join(projectPath, ".coco", "logs");
+  const logger2 = createLogger({
     name: "coco",
     level,
     prettyPrint: process.stdout.isTTY ?? true,
     logToFile: true,
     logDir
   });
-  setLogger(logger);
-  return logger;
+  setLogger(logger2);
+  return logger2;
 }
-function logEvent(logger, event, data = {}) {
-  logger.info({ event, ...data });
+function logEvent(logger2, event, data = {}) {
+  logger2.info({ event, ...data });
 }
-async function logTiming(logger, operation, fn) {
+async function logTiming(logger2, operation, fn) {
   const start = performance.now();
   try {
     const result = await fn();
     const duration = performance.now() - start;
-    logger.debug({ operation, durationMs: duration.toFixed(2), status: "success" });
+    logger2.debug({ operation, durationMs: duration.toFixed(2), status: "success" });
     return result;
   } catch (error) {
     const duration = performance.now() - start;
-    logger.error({ operation, durationMs: duration.toFixed(2), status: "error", error });
+    logger2.error({ operation, durationMs: duration.toFixed(2), status: "error", error });
     throw error;
   }
 }
@@ -7164,9 +7164,9 @@ async function migrateGlobalConfig(oldDir, newConfigPath) {
     );
   }
 }
-async function fileExists(path59) {
+async function fileExists(path60) {
   try {
-    await access(path59);
+    await access(path60);
     return true;
   } catch {
     return false;
@@ -7297,8 +7297,8 @@ var init_registry = __esm({
       /**
        * Ensure directory exists
        */
-      async ensureDir(path59) {
-        await mkdir(dirname(path59), { recursive: true });
+      async ensureDir(path60) {
+        await mkdir(dirname(path60), { recursive: true });
       }
     };
   }
@@ -7373,7 +7373,7 @@ __export(markdown_loader_exports, {
 });
 async function isMarkdownSkill(skillDir) {
   try {
-    await fs34__default.access(path37__default.join(skillDir, SKILL_FILENAME));
+    await fs35__default.access(path38__default.join(skillDir, SKILL_FILENAME));
     return true;
   } catch {
     return false;
@@ -7381,16 +7381,16 @@ async function isMarkdownSkill(skillDir) {
 }
 async function loadMarkdownMetadata(skillDir, scope) {
   try {
-    const skillPath = path37__default.join(skillDir, SKILL_FILENAME);
-    const raw = await fs34__default.readFile(skillPath, "utf-8");
+    const skillPath = path38__default.join(skillDir, SKILL_FILENAME);
+    const raw = await fs35__default.readFile(skillPath, "utf-8");
     const { data } = matter(raw);
     const parsed = SkillFrontmatterSchema.safeParse(data);
     if (!parsed.success) {
       return null;
     }
     const fm = parsed.data;
-    const dirName = path37__default.basename(skillDir);
-    const parentDir = path37__default.basename(path37__default.dirname(skillDir));
+    const dirName = path38__default.basename(skillDir);
+    const parentDir = path38__default.basename(path38__default.dirname(skillDir));
     const namespace = isNamespaceDirectory(parentDir) ? parentDir : void 0;
     const baseId = toKebabCase(fm.name || dirName);
     const fullId = namespace ? `${namespace}/${baseId}` : baseId;
@@ -7420,8 +7420,8 @@ async function loadMarkdownMetadata(skillDir, scope) {
       context: fm.context
     };
   } catch (error) {
-    const logger = getLogger();
-    logger.warn(
+    const logger2 = getLogger();
+    logger2.warn(
       `[Skills] Failed to load metadata from ${skillDir}:`,
       error instanceof Error ? error.message : error
     );
@@ -7430,8 +7430,8 @@ async function loadMarkdownMetadata(skillDir, scope) {
 }
 async function loadMarkdownContent(skillDir) {
   try {
-    const skillPath = path37__default.join(skillDir, SKILL_FILENAME);
-    const raw = await fs34__default.readFile(skillPath, "utf-8");
+    const skillPath = path38__default.join(skillDir, SKILL_FILENAME);
+    const raw = await fs35__default.readFile(skillPath, "utf-8");
     const { content } = matter(raw);
     const references = await listSubdirectory(skillDir, "references");
     const scripts = await listSubdirectory(skillDir, "scripts");
@@ -7443,8 +7443,8 @@ async function loadMarkdownContent(skillDir) {
       templates
     };
   } catch (error) {
-    const logger = getLogger();
-    logger.warn(
+    const logger2 = getLogger();
+    logger2.warn(
       `[Skills] Failed to load content from ${skillDir}:`,
       error instanceof Error ? error.message : error
     );
@@ -7453,9 +7453,9 @@ async function loadMarkdownContent(skillDir) {
 }
 async function listSubdirectory(skillDir, subdir) {
   try {
-    const dir = path37__default.join(skillDir, subdir);
-    const entries = await fs34__default.readdir(dir, { withFileTypes: true });
-    return entries.filter((e) => e.isFile()).map((e) => path37__default.join(dir, e.name));
+    const dir = path38__default.join(skillDir, subdir);
+    const entries = await fs35__default.readdir(dir, { withFileTypes: true });
+    return entries.filter((e) => e.isFile()).map((e) => path38__default.join(dir, e.name));
   } catch {
     return [];
   }
@@ -7532,8 +7532,8 @@ async function loadSkillFromDirectory(skillDir, scope) {
   if (await isMarkdownSkill(skillDir)) {
     return loadMarkdownMetadata(skillDir, scope);
   }
-  const hasTs = await fileExists2(path37__default.join(skillDir, "index.ts"));
-  const hasJs = await fileExists2(path37__default.join(skillDir, "index.js"));
+  const hasTs = await fileExists2(path38__default.join(skillDir, "index.ts"));
+  const hasJs = await fileExists2(path38__default.join(skillDir, "index.js"));
   if (hasTs || hasJs) {
     return null;
   }
@@ -7553,7 +7553,7 @@ async function loadFullSkill(metadata) {
 }
 async function fileExists2(filePath) {
   try {
-    await fs34__default.access(filePath);
+    await fs35__default.access(filePath);
     return true;
   } catch {
     return false;
@@ -7576,8 +7576,8 @@ function normalizeDirectories(dirs, relativeBaseDir) {
   for (const dir of dirs) {
     const trimmed = dir.trim();
     if (!trimmed) continue;
-    const expanded = trimmed === "~" ? home : trimmed.startsWith("~/") ? path37__default.join(home, trimmed.slice(2)) : trimmed;
-    const resolved = path37__default.isAbsolute(expanded) ? path37__default.resolve(expanded) : path37__default.resolve(relativeBaseDir ?? process.cwd(), expanded);
+    const expanded = trimmed === "~" ? home : trimmed.startsWith("~/") ? path38__default.join(home, trimmed.slice(2)) : trimmed;
+    const resolved = path38__default.isAbsolute(expanded) ? path38__default.resolve(expanded) : path38__default.resolve(relativeBaseDir ?? process.cwd(), expanded);
     if (seen.has(resolved)) continue;
     seen.add(resolved);
     normalized.push(resolved);
@@ -7590,7 +7590,7 @@ function resolveDiscoveryDirs(projectPath, options) {
     opts.globalDirs && opts.globalDirs.length > 0 ? opts.globalDirs : opts.globalDir ? [opts.globalDir] : GLOBAL_SKILLS_DIRS
   );
   const projectDirs = normalizeDirectories(
-    opts.projectDirs && opts.projectDirs.length > 0 ? opts.projectDirs : opts.projectDir ? [opts.projectDir] : PROJECT_SKILLS_DIRNAMES.map((d) => path37__default.join(projectPath, d)),
+    opts.projectDirs && opts.projectDirs.length > 0 ? opts.projectDirs : opts.projectDir ? [opts.projectDir] : PROJECT_SKILLS_DIRNAMES.map((d) => path38__default.join(projectPath, d)),
     projectPath
   );
   return { globalDirs, projectDirs };
@@ -7618,13 +7618,13 @@ async function discoverAllSkills(projectPath, builtinSkills = [], options) {
 }
 async function scanSkillsDirectory(dir, scope) {
   try {
-    const entries = await fs34__default.readdir(dir, { withFileTypes: true });
+    const entries = await fs35__default.readdir(dir, { withFileTypes: true });
     const skillDirs = entries.filter((e) => e.isDirectory() && !e.isSymbolicLink());
     const results = [];
     for (const entry of skillDirs) {
-      const entryPath = path37__default.join(dir, entry.name);
+      const entryPath = path38__default.join(dir, entry.name);
       try {
-        const stat2 = await fs34__default.lstat(entryPath);
+        const stat2 = await fs35__default.lstat(entryPath);
         if (stat2.isSymbolicLink()) continue;
       } catch {
         continue;
@@ -7640,8 +7640,8 @@ async function scanSkillsDirectory(dir, scope) {
     return results.filter((meta) => meta !== null);
   } catch (error) {
     if (error.code !== "ENOENT") {
-      const logger = getLogger();
-      logger.warn(
+      const logger2 = getLogger();
+      logger2.warn(
         `[Skills] Failed to scan directory ${dir}:`,
         error instanceof Error ? error.message : error
       );
@@ -7652,13 +7652,13 @@ async function scanSkillsDirectory(dir, scope) {
 async function scanNestedSkills(dir, scope, depth) {
   if (depth >= MAX_NESTING_DEPTH) return [];
   try {
-    const subEntries = await fs34__default.readdir(dir, { withFileTypes: true });
+    const subEntries = await fs35__default.readdir(dir, { withFileTypes: true });
     const subDirs = subEntries.filter((e) => e.isDirectory() && !e.isSymbolicLink());
     const results = await Promise.all(
       subDirs.map(async (sub) => {
-        const subPath = path37__default.join(dir, sub.name);
+        const subPath = path38__default.join(dir, sub.name);
         try {
-          const stat2 = await fs34__default.lstat(subPath);
+          const stat2 = await fs35__default.lstat(subPath);
           if (stat2.isSymbolicLink()) return null;
         } catch {
           return null;
@@ -7686,17 +7686,17 @@ var init_discovery = __esm({
     init_paths();
     init_logger();
     GLOBAL_SKILLS_DIRS = [
-      path37__default.join(homedir(), ".codex", "skills"),
+      path38__default.join(homedir(), ".codex", "skills"),
       // Codex CLI legacy compat
-      path37__default.join(homedir(), ".gemini", "skills"),
+      path38__default.join(homedir(), ".gemini", "skills"),
       // Gemini CLI compat
-      path37__default.join(homedir(), ".opencode", "skills"),
+      path38__default.join(homedir(), ".opencode", "skills"),
       // OpenCode compat
-      path37__default.join(homedir(), ".claude", "skills"),
+      path38__default.join(homedir(), ".claude", "skills"),
       // Claude Code compat
-      path37__default.join(homedir(), ".agents", "skills"),
+      path38__default.join(homedir(), ".agents", "skills"),
       // shared cross-agent standard
-      path37__default.join(COCO_HOME, "skills")
+      path38__default.join(COCO_HOME, "skills")
       // Coco native global directory (authoritative for Coco)
     ];
     PROJECT_SKILLS_DIRNAMES = [
@@ -8935,9 +8935,9 @@ function createEmptyMemoryContext() {
     errors: []
   };
 }
-function createMissingMemoryFile(path59, level) {
+function createMissingMemoryFile(path60, level) {
   return {
-    path: path59,
+    path: path60,
     level,
     content: "",
     sections: [],
@@ -9080,11 +9080,11 @@ var init_loader3 = __esm({
       async loadFile(filePath, level) {
         const resolvedPath = this.resolvePath(filePath);
         try {
-          const stat2 = await fs34.stat(resolvedPath);
-          const rawContent = await fs34.readFile(resolvedPath, "utf-8");
+          const stat2 = await fs35.stat(resolvedPath);
+          const rawContent = await fs35.readFile(resolvedPath, "utf-8");
           const { content, imports } = await this.resolveImports(
             rawContent,
-            path37.dirname(resolvedPath),
+            path38.dirname(resolvedPath),
             0
           );
           const sections = this.parseSections(content);
@@ -9111,16 +9111,16 @@ var init_loader3 = __esm({
         if (this.config.includeUserLevel) {
           const userDir = this.resolvePath(USER_CONFIG_DIR);
           for (const pattern of this.config.filePatterns) {
-            const userPath = path37.join(userDir, pattern);
+            const userPath = path38.join(userDir, pattern);
             if (await this.fileExists(userPath)) {
               result.user = userPath;
               break;
             }
           }
         }
-        const absoluteProjectPath = path37.resolve(projectPath);
+        const absoluteProjectPath = path38.resolve(projectPath);
         for (const pattern of this.config.filePatterns) {
-          const projectFilePath = path37.join(absoluteProjectPath, pattern);
+          const projectFilePath = path38.join(absoluteProjectPath, pattern);
           if (await this.fileExists(projectFilePath)) {
             result.project = projectFilePath;
             break;
@@ -9128,14 +9128,14 @@ var init_loader3 = __esm({
         }
         const cwd = currentDir ?? process.cwd();
         if (cwd.startsWith(absoluteProjectPath) && cwd !== absoluteProjectPath) {
-          const relativePath = path37.relative(absoluteProjectPath, cwd);
-          const parts = relativePath.split(path37.sep);
+          const relativePath = path38.relative(absoluteProjectPath, cwd);
+          const parts = relativePath.split(path38.sep);
           const dirFiles = [];
           let currentDir2 = absoluteProjectPath;
           for (const part of parts) {
-            currentDir2 = path37.join(currentDir2, part);
+            currentDir2 = path38.join(currentDir2, part);
             for (const pattern of this.config.filePatterns) {
-              const dirFilePath = path37.join(currentDir2, pattern);
+              const dirFilePath = path38.join(currentDir2, pattern);
               if (await this.fileExists(dirFilePath)) {
                 dirFiles.push(dirFilePath);
                 break;
@@ -9149,7 +9149,7 @@ var init_loader3 = __esm({
         for (const pattern of this.config.filePatterns) {
           const baseName = pattern.replace(/\.md$/, "");
           const localFileName = `${baseName}${LOCAL_SUFFIX}`;
-          const localPath = path37.join(absoluteProjectPath, localFileName);
+          const localPath = path38.join(absoluteProjectPath, localFileName);
           if (await this.fileExists(localPath)) {
             result.local = localPath;
             break;
@@ -9200,10 +9200,10 @@ var init_loader3 = __esm({
             };
             try {
               if (await this.fileExists(resolvedPath)) {
-                const importedContent = await fs34.readFile(resolvedPath, "utf-8");
+                const importedContent = await fs35.readFile(resolvedPath, "utf-8");
                 const nestedResult = await this.resolveImports(
                   importedContent,
-                  path37.dirname(resolvedPath),
+                  path38.dirname(resolvedPath),
                   depth + 1
                 );
                 processedLines.push(`<!-- Imported from: ${importPath} -->`);
@@ -9244,7 +9244,7 @@ var init_loader3 = __esm({
         const parts = [];
         for (const file of files) {
           if (file.exists && file.content.trim()) {
-            const label = file.level === "directory" ? `directory level (${path37.dirname(file.path)}/${path37.basename(file.path)})` : `${file.level} level (${path37.basename(file.path)})`;
+            const label = file.level === "directory" ? `directory level (${path38.dirname(file.path)}/${path38.basename(file.path)})` : `${file.level} level (${path38.basename(file.path)})`;
             parts.push(`<!-- Memory: ${label} -->`);
             parts.push(file.content);
             parts.push("");
@@ -9307,9 +9307,9 @@ var init_loader3 = __esm({
        */
       resolvePath(filePath) {
         if (filePath.startsWith("~")) {
-          return path37.join(os4.homedir(), filePath.slice(1));
+          return path38.join(os4.homedir(), filePath.slice(1));
         }
-        return path37.resolve(filePath);
+        return path38.resolve(filePath);
       }
       /**
        * Resolve an import path relative to a base directory.
@@ -9324,22 +9324,22 @@ var init_loader3 = __esm({
       resolveImportPath(importPath, basePath) {
         let resolved;
         if (importPath.startsWith("~")) {
-          resolved = path37.join(os4.homedir(), importPath.slice(1));
+          resolved = path38.join(os4.homedir(), importPath.slice(1));
           const userConfigDir = this.resolvePath(USER_CONFIG_DIR);
-          if (!resolved.startsWith(userConfigDir + path37.sep) && resolved !== userConfigDir) {
+          if (!resolved.startsWith(userConfigDir + path38.sep) && resolved !== userConfigDir) {
             throw new Error(`Import path escapes user config directory: @${importPath}`);
           }
           return resolved;
         }
-        if (path37.isAbsolute(importPath)) {
-          resolved = path37.resolve(importPath);
-          if (!resolved.startsWith(basePath + path37.sep) && resolved !== basePath) {
+        if (path38.isAbsolute(importPath)) {
+          resolved = path38.resolve(importPath);
+          if (!resolved.startsWith(basePath + path38.sep) && resolved !== basePath) {
             throw new Error(`Import path escapes project directory: @${importPath}`);
           }
           return resolved;
         }
-        resolved = path37.resolve(basePath, importPath);
-        if (!resolved.startsWith(basePath + path37.sep) && resolved !== basePath) {
+        resolved = path38.resolve(basePath, importPath);
+        if (!resolved.startsWith(basePath + path38.sep) && resolved !== basePath) {
           throw new Error(`Import path escapes project directory: @${importPath}`);
         }
         return resolved;
@@ -9351,7 +9351,7 @@ var init_loader3 = __esm({
        */
       async fileExists(filePath) {
         try {
-          await fs34.access(filePath);
+          await fs35.access(filePath);
           return true;
         } catch {
           return false;
@@ -9719,7 +9719,7 @@ function clearSession(session) {
 }
 async function loadTrustSettings() {
   try {
-    const content = await fs34__default.readFile(TRUST_SETTINGS_FILE, "utf-8");
+    const content = await fs35__default.readFile(TRUST_SETTINGS_FILE, "utf-8");
     const raw = JSON.parse(content);
     return {
       globalTrusted: raw.globalTrusted ?? [],
@@ -9738,9 +9738,9 @@ async function loadTrustSettings() {
 }
 async function saveTrustSettings(settings) {
   try {
-    await fs34__default.mkdir(TRUST_SETTINGS_DIR, { recursive: true });
+    await fs35__default.mkdir(TRUST_SETTINGS_DIR, { recursive: true });
     settings.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    await fs34__default.writeFile(TRUST_SETTINGS_FILE, JSON.stringify(settings, null, 2), "utf-8");
+    await fs35__default.writeFile(TRUST_SETTINGS_FILE, JSON.stringify(settings, null, 2), "utf-8");
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
     console.warn(`[Trust] Failed to save trust settings: ${msg}`);
@@ -9927,7 +9927,7 @@ var init_session = __esm({
     init_manager();
     init_compactor();
     MAX_SKILL_INSTRUCTIONS_CHARS = 16e3;
-    TRUST_SETTINGS_DIR = path37__default.dirname(CONFIG_PATHS.trustedTools);
+    TRUST_SETTINGS_DIR = path38__default.dirname(CONFIG_PATHS.trustedTools);
     TRUST_SETTINGS_FILE = CONFIG_PATHS.trustedTools;
     CATEGORY_LABELS = {
       file: "File Operations",
@@ -10210,13 +10210,13 @@ var init_types4 = __esm({
   }
 });
 function getStatePath(projectPath) {
-  return path37.join(projectPath, ".coco", "state.json");
+  return path38.join(projectPath, ".coco", "state.json");
 }
 function createStateManager() {
   async function load(projectPath) {
     const statePath = getStatePath(projectPath);
     try {
-      const content = await fs34.readFile(statePath, "utf-8");
+      const content = await fs35.readFile(statePath, "utf-8");
       const file = JSON.parse(content);
       if (file.version !== STATE_VERSION) {
         console.warn(`State version mismatch: ${file.version} vs ${STATE_VERSION}`);
@@ -10235,7 +10235,7 @@ function createStateManager() {
   }
   async function save(state) {
     const statePath = getStatePath(state.path);
-    await fs34.mkdir(path37.dirname(statePath), { recursive: true });
+    await fs35.mkdir(path38.dirname(statePath), { recursive: true });
     const file = {
       version: STATE_VERSION,
       state: {
@@ -10243,19 +10243,19 @@ function createStateManager() {
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       }
     };
-    await fs34.writeFile(statePath, JSON.stringify(file, null, 2), "utf-8");
+    await fs35.writeFile(statePath, JSON.stringify(file, null, 2), "utf-8");
   }
   async function clear(projectPath) {
     const statePath = getStatePath(projectPath);
     try {
-      await fs34.unlink(statePath);
+      await fs35.unlink(statePath);
     } catch {
     }
   }
   async function exists(projectPath) {
     const statePath = getStatePath(projectPath);
     try {
-      await fs34.access(statePath);
+      await fs35.access(statePath);
       return true;
     } catch {
       return false;
@@ -10383,8 +10383,8 @@ __export(trust_store_exports, {
   saveTrustStore: () => saveTrustStore,
   updateLastAccessed: () => updateLastAccessed
 });
-async function ensureDir(path59) {
-  await mkdir(dirname(path59), { recursive: true });
+async function ensureDir(path60) {
+  await mkdir(dirname(path60), { recursive: true });
 }
 async function loadTrustStore(storePath = TRUST_STORE_PATH) {
   try {
@@ -10408,8 +10408,8 @@ async function saveTrustStore(store, storePath = TRUST_STORE_PATH) {
     await ensureDir(storePath);
     await writeFile(storePath, JSON.stringify(store, null, 2), "utf-8");
   } catch (error) {
-    const logger = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger();
-    logger.warn(
+    const logger2 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger();
+    logger2.warn(
       `[TrustStore] Failed to save: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -10469,8 +10469,8 @@ function canPerformOperation(store, projectPath, operation) {
   };
   return permissions[level]?.includes(operation) ?? false;
 }
-function normalizePath(path59) {
-  return join(path59);
+function normalizePath(path60) {
+  return join(path60);
 }
 function createTrustStore(storePath = TRUST_STORE_PATH) {
   let store = null;
@@ -10826,12 +10826,12 @@ function humanizeError(message, toolName) {
     return msg;
   }
   if (/ENOENT/i.test(msg)) {
-    const path59 = extractQuotedPath(msg);
-    return path59 ? `File or directory not found: ${path59}` : "File or directory not found";
+    const path60 = extractQuotedPath(msg);
+    return path60 ? `File or directory not found: ${path60}` : "File or directory not found";
   }
   if (/EACCES/i.test(msg)) {
-    const path59 = extractQuotedPath(msg);
-    return path59 ? `Permission denied: ${path59}` : "Permission denied \u2014 check file permissions";
+    const path60 = extractQuotedPath(msg);
+    return path60 ? `Permission denied: ${path60}` : "Permission denied \u2014 check file permissions";
   }
   if (/EISDIR/i.test(msg)) {
     return "Expected a file but found a directory at the specified path";
@@ -11306,7 +11306,7 @@ Suggestion: ${error.suggestion}`;
 });
 async function fileExists3(filePath) {
   try {
-    await fs34__default.access(filePath);
+    await fs35__default.access(filePath);
     return true;
   } catch {
     return false;
@@ -11765,9 +11765,9 @@ var init_diff_renderer = __esm({
     getTerminalWidth = () => process.stdout.columns || 80;
   }
 });
-async function fileExists4(path59) {
+async function fileExists4(path60) {
   try {
-    await access(path59);
+    await access(path60);
     return true;
   } catch {
     return false;
@@ -11857,7 +11857,7 @@ async function detectMaturity(cwd) {
   if (!hasLintConfig && hasPackageJson) {
     try {
       const pkgRaw = await import('fs/promises').then(
-        (fs55) => fs55.readFile(join(cwd, "package.json"), "utf-8")
+        (fs56) => fs56.readFile(join(cwd, "package.json"), "utf-8")
       );
       const pkg = JSON.parse(pkgRaw);
       if (pkg.scripts?.lint || pkg.scripts?.["lint:fix"]) {
@@ -12879,7 +12879,7 @@ var init_build_verifier = __esm({
       async verifyTypes() {
         const startTime = Date.now();
         try {
-          const hasTsConfig = await this.fileExists(path37.join(this.projectPath, "tsconfig.json"));
+          const hasTsConfig = await this.fileExists(path38.join(this.projectPath, "tsconfig.json"));
           if (!hasTsConfig) {
             return {
               success: true,
@@ -12929,19 +12929,19 @@ var init_build_verifier = __esm({
        * Checks Maven, Gradle, and Node.js in that order.
        */
       async detectBuildCommand() {
-        if (await this.fileExists(path37.join(this.projectPath, "pom.xml"))) {
-          const wrapper = path37.join(this.projectPath, "mvnw");
+        if (await this.fileExists(path38.join(this.projectPath, "pom.xml"))) {
+          const wrapper = path38.join(this.projectPath, "mvnw");
           return await this.fileExists(wrapper) ? "./mvnw compile -B -q" : "mvn compile -B -q";
         }
         for (const f of ["build.gradle", "build.gradle.kts"]) {
-          if (await this.fileExists(path37.join(this.projectPath, f))) {
-            const wrapper = path37.join(this.projectPath, "gradlew");
+          if (await this.fileExists(path38.join(this.projectPath, f))) {
+            const wrapper = path38.join(this.projectPath, "gradlew");
             return await this.fileExists(wrapper) ? "./gradlew classes -q" : "gradle classes -q";
           }
         }
         try {
-          const packageJsonPath = path37.join(this.projectPath, "package.json");
-          const content = await fs34.readFile(packageJsonPath, "utf-8");
+          const packageJsonPath = path38.join(this.projectPath, "package.json");
+          const content = await fs35.readFile(packageJsonPath, "utf-8");
           const packageJson = JSON.parse(content);
           if (packageJson.scripts?.build) {
             return "npm run build";
@@ -13016,7 +13016,7 @@ var init_build_verifier = __esm({
        */
       async fileExists(filePath) {
         try {
-          await fs34.access(filePath);
+          await fs35.access(filePath);
           return true;
         } catch {
           return false;
@@ -14675,9 +14675,9 @@ function detectProjectLanguage(files) {
   return { language: dominant, confidence, evidence };
 }
 function getFileExtension(filePath) {
-  const base = path37.basename(filePath);
+  const base = path38.basename(filePath);
   if (base.endsWith(".d.ts")) return ".d.ts";
-  return path37.extname(filePath).toLowerCase();
+  return path38.extname(filePath).toLowerCase();
 }
 function buildEvidence(dominant, counts, totalSourceFiles, files) {
   const evidence = [];
@@ -14685,7 +14685,7 @@ function buildEvidence(dominant, counts, totalSourceFiles, files) {
   evidence.push(`${dominantCount} of ${totalSourceFiles} source files are ${dominant}`);
   const configFiles = ["tsconfig.json", "pom.xml", "build.gradle", "Cargo.toml", "go.mod"];
   for (const cfg of configFiles) {
-    if (files.some((f) => path37.basename(f) === cfg)) {
+    if (files.some((f) => path38.basename(f) === cfg)) {
       evidence.push(`Found ${cfg}`);
     }
   }
@@ -16180,20 +16180,20 @@ var init_evaluator = __esm({
 });
 async function detectLinter2(cwd) {
   try {
-    await fs34__default.access(path37__default.join(cwd, "pom.xml"));
+    await fs35__default.access(path38__default.join(cwd, "pom.xml"));
     return "maven-checkstyle";
   } catch {
   }
   for (const f of ["build.gradle", "build.gradle.kts"]) {
     try {
-      await fs34__default.access(path37__default.join(cwd, f));
+      await fs35__default.access(path38__default.join(cwd, f));
       return "gradle-checkstyle";
     } catch {
     }
   }
   try {
-    const pkgPath = path37__default.join(cwd, "package.json");
-    const pkgContent = await fs34__default.readFile(pkgPath, "utf-8");
+    const pkgPath = path38__default.join(cwd, "package.json");
+    const pkgContent = await fs35__default.readFile(pkgPath, "utf-8");
     const pkg = JSON.parse(pkgContent);
     const deps = {
       ...pkg.dependencies,
@@ -16209,7 +16209,7 @@ async function detectLinter2(cwd) {
 }
 async function mavenExec(cwd) {
   try {
-    await fs34__default.access(path37__default.join(cwd, "mvnw"));
+    await fs35__default.access(path38__default.join(cwd, "mvnw"));
     return "./mvnw";
   } catch {
     return "mvn";
@@ -16217,7 +16217,7 @@ async function mavenExec(cwd) {
 }
 async function gradleExec(cwd) {
   try {
-    await fs34__default.access(path37__default.join(cwd, "gradlew"));
+    await fs35__default.access(path38__default.join(cwd, "gradlew"));
     return "./gradlew";
   } catch {
     return "gradle";
@@ -16286,14 +16286,14 @@ async function findSourceFiles(cwd) {
   const { glob: glob17 } = await import('glob');
   let isJava = false;
   try {
-    await fs34__default.access(path37__default.join(cwd, "pom.xml"));
+    await fs35__default.access(path38__default.join(cwd, "pom.xml"));
     isJava = true;
   } catch {
   }
   if (!isJava) {
     for (const f of ["build.gradle", "build.gradle.kts"]) {
       try {
-        await fs34__default.access(path37__default.join(cwd, f));
+        await fs35__default.access(path38__default.join(cwd, f));
         isJava = true;
         break;
       } catch {
@@ -16501,7 +16501,7 @@ Examples:
           let totalFunctions = 0;
           let complexFunctions = 0;
           for (const file of targetFiles) {
-            const content = await fs34__default.readFile(file, "utf-8");
+            const content = await fs35__default.readFile(file, "utf-8");
             const fileComplexity = analyzeFileComplexity(content, file);
             fileResults.push(fileComplexity);
             totalComplexity += fileComplexity.complexity;
@@ -16648,7 +16648,7 @@ async function checkTestCoverage(diff, cwd) {
     );
     if (!hasTestChange) {
       const ext = src.path.match(/\.(ts|tsx|js|jsx)$/)?.[0] ?? ".ts";
-      const testExists = await fileExists3(path37__default.join(cwd, `${baseName}.test${ext}`)) || await fileExists3(path37__default.join(cwd, `${baseName}.spec${ext}`));
+      const testExists = await fileExists3(path38__default.join(cwd, `${baseName}.test${ext}`)) || await fileExists3(path38__default.join(cwd, `${baseName}.spec${ext}`));
       if (testExists) {
         if (src.additions >= TEST_COVERAGE_LARGE_CHANGE_THRESHOLD) {
           findings.push({
@@ -18329,7 +18329,7 @@ var init_github = __esm({
 });
 async function detectVersionFile(cwd) {
   for (const { file, stack, field } of VERSION_FILES) {
-    const fullPath = path37__default.join(cwd, file);
+    const fullPath = path38__default.join(cwd, file);
     if (await fileExists3(fullPath)) {
       const version = await readVersionFromFile(fullPath, stack, field);
       if (version) {
@@ -18375,7 +18375,7 @@ function bumpVersion(current, bump) {
   }
 }
 async function writeVersion(cwd, versionFile, newVersion) {
-  const fullPath = path37__default.join(cwd, versionFile.path);
+  const fullPath = path38__default.join(cwd, versionFile.path);
   const content = await readFile(fullPath, "utf-8");
   let updated;
   switch (versionFile.stack) {
@@ -18434,7 +18434,7 @@ var init_version_detector = __esm({
 });
 async function detectChangelog(cwd) {
   for (const name of CHANGELOG_NAMES) {
-    const fullPath = path37__default.join(cwd, name);
+    const fullPath = path38__default.join(cwd, name);
     if (await fileExists3(fullPath)) {
       const content = await readFile(fullPath, "utf-8");
       const format = detectFormat(content);
@@ -18456,7 +18456,7 @@ function detectFormat(content) {
   return "custom";
 }
 async function insertChangelogEntry(cwd, changelog, version, entries, date) {
-  const fullPath = path37__default.join(cwd, changelog.path);
+  const fullPath = path38__default.join(cwd, changelog.path);
   const content = await readFile(fullPath, "utf-8");
   const dateStr = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const entry = buildEntry(changelog.format, version, entries, dateStr);
@@ -18517,11 +18517,11 @@ var init_changelog = __esm({
   }
 });
 async function detectStack(cwd) {
-  if (await fileExists3(path37__default.join(cwd, "package.json"))) return "node";
-  if (await fileExists3(path37__default.join(cwd, "Cargo.toml"))) return "rust";
-  if (await fileExists3(path37__default.join(cwd, "pyproject.toml"))) return "python";
-  if (await fileExists3(path37__default.join(cwd, "go.mod"))) return "go";
-  if (await fileExists3(path37__default.join(cwd, "pom.xml"))) return "java";
+  if (await fileExists3(path38__default.join(cwd, "package.json"))) return "node";
+  if (await fileExists3(path38__default.join(cwd, "Cargo.toml"))) return "rust";
+  if (await fileExists3(path38__default.join(cwd, "pyproject.toml"))) return "python";
+  if (await fileExists3(path38__default.join(cwd, "go.mod"))) return "go";
+  if (await fileExists3(path38__default.join(cwd, "pom.xml"))) return "java";
   return "unknown";
 }
 async function detectPackageManager(cwd, stack) {
@@ -18529,15 +18529,15 @@ async function detectPackageManager(cwd, stack) {
   if (stack === "python") return "pip";
   if (stack === "go") return "go";
   if (stack === "node") {
-    if (await fileExists3(path37__default.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-    if (await fileExists3(path37__default.join(cwd, "yarn.lock"))) return "yarn";
-    if (await fileExists3(path37__default.join(cwd, "bun.lockb"))) return "bun";
+    if (await fileExists3(path38__default.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+    if (await fileExists3(path38__default.join(cwd, "yarn.lock"))) return "yarn";
+    if (await fileExists3(path38__default.join(cwd, "bun.lockb"))) return "bun";
     return "npm";
   }
   return null;
 }
 async function detectCI(cwd) {
-  const ghDir = path37__default.join(cwd, ".github", "workflows");
+  const ghDir = path38__default.join(cwd, ".github", "workflows");
   if (await fileExists3(ghDir)) {
     let workflowFiles = [];
     let hasCodeQL = false;
@@ -18561,7 +18561,7 @@ async function detectCI(cwd) {
     }
     return { type: "github-actions", workflowFiles, hasCodeQL, hasLinting };
   }
-  if (await fileExists3(path37__default.join(cwd, ".gitlab-ci.yml"))) {
+  if (await fileExists3(path38__default.join(cwd, ".gitlab-ci.yml"))) {
     return {
       type: "gitlab-ci",
       workflowFiles: [".gitlab-ci.yml"],
@@ -18569,7 +18569,7 @@ async function detectCI(cwd) {
       hasLinting: false
     };
   }
-  if (await fileExists3(path37__default.join(cwd, ".circleci"))) {
+  if (await fileExists3(path38__default.join(cwd, ".circleci"))) {
     return { type: "circle-ci", workflowFiles: [], hasCodeQL: false, hasLinting: false };
   }
   return { type: "none", workflowFiles: [], hasCodeQL: false, hasLinting: false };
@@ -19940,8 +19940,8 @@ function hasNullByte(str) {
 }
 function isBlockedPath(absolute) {
   for (const blocked of BLOCKED_PATHS) {
-    const normalizedBlocked = path37__default.normalize(blocked);
-    if (absolute === normalizedBlocked || absolute.startsWith(normalizedBlocked + path37__default.sep)) {
+    const normalizedBlocked = path38__default.normalize(blocked);
+    if (absolute === normalizedBlocked || absolute.startsWith(normalizedBlocked + path38__default.sep)) {
       return blocked;
     }
   }
@@ -19959,7 +19959,7 @@ function getInterpreter(ext) {
 }
 async function isExecutable(filePath) {
   try {
-    await fs34__default.access(filePath, fs34__default.constants.X_OK);
+    await fs35__default.access(filePath, fs35__default.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -20035,7 +20035,7 @@ Examples:
           throw new ToolError("Invalid file path", { tool: "open_file" });
         }
         const workDir = cwd ?? process.cwd();
-        const absolute = path37__default.isAbsolute(filePath) ? path37__default.normalize(filePath) : path37__default.resolve(workDir, filePath);
+        const absolute = path38__default.isAbsolute(filePath) ? path38__default.normalize(filePath) : path38__default.resolve(workDir, filePath);
         const blockedBy = isBlockedPath(absolute);
         if (blockedBy) {
           throw new ToolError(`Access to system path '${blockedBy}' is not allowed`, {
@@ -20043,7 +20043,7 @@ Examples:
           });
         }
         try {
-          await fs34__default.access(absolute);
+          await fs35__default.access(absolute);
         } catch {
           throw new ToolError(`File not found: ${absolute}`, { tool: "open_file" });
         }
@@ -20058,14 +20058,14 @@ Examples:
           };
         }
         if (isBlockedExecFile(absolute)) {
-          throw new ToolError(`Execution of sensitive file is blocked: ${path37__default.basename(absolute)}`, {
+          throw new ToolError(`Execution of sensitive file is blocked: ${path38__default.basename(absolute)}`, {
             tool: "open_file"
           });
         }
         if (args.length > 0 && hasDangerousArgs(args)) {
           throw new ToolError("Arguments contain dangerous patterns", { tool: "open_file" });
         }
-        const ext = path37__default.extname(absolute);
+        const ext = path38__default.extname(absolute);
         const interpreter = getInterpreter(ext);
         const executable = await isExecutable(absolute);
         let command;
@@ -20078,7 +20078,7 @@ Examples:
           cmdArgs = [...args];
         } else {
           throw new ToolError(
-            `Cannot execute '${path37__default.basename(absolute)}': no known interpreter for '${ext || "(no extension)"}' and file is not executable`,
+            `Cannot execute '${path38__default.basename(absolute)}': no known interpreter for '${ext || "(no extension)"}' and file is not executable`,
             { tool: "open_file" }
           );
         }
@@ -20250,10 +20250,10 @@ function getAllowedPaths() {
   return [...sessionAllowedPaths];
 }
 function isWithinAllowedPath(absolutePath, operation) {
-  const normalizedTarget = path37__default.normalize(absolutePath);
+  const normalizedTarget = path38__default.normalize(absolutePath);
   for (const entry of sessionAllowedPaths) {
-    const normalizedAllowed = path37__default.normalize(entry.path);
-    if (normalizedTarget === normalizedAllowed || normalizedTarget.startsWith(normalizedAllowed + path37__default.sep)) {
+    const normalizedAllowed = path38__default.normalize(entry.path);
+    if (normalizedTarget === normalizedAllowed || normalizedTarget.startsWith(normalizedAllowed + path38__default.sep)) {
       if (operation === "read") return true;
       if (entry.level === "write") return true;
     }
@@ -20261,8 +20261,8 @@ function isWithinAllowedPath(absolutePath, operation) {
   return false;
 }
 function addAllowedPathToSession(dirPath, level) {
-  const absolute = path37__default.resolve(dirPath);
-  if (sessionAllowedPaths.some((e) => path37__default.normalize(e.path) === path37__default.normalize(absolute))) {
+  const absolute = path38__default.resolve(dirPath);
+  if (sessionAllowedPaths.some((e) => path38__default.normalize(e.path) === path38__default.normalize(absolute))) {
     return;
   }
   sessionAllowedPaths.push({
@@ -20272,14 +20272,14 @@ function addAllowedPathToSession(dirPath, level) {
   });
 }
 function removeAllowedPathFromSession(dirPath) {
-  const absolute = path37__default.resolve(dirPath);
-  const normalized = path37__default.normalize(absolute);
+  const absolute = path38__default.resolve(dirPath);
+  const normalized = path38__default.normalize(absolute);
   const before = sessionAllowedPaths.length;
-  sessionAllowedPaths = sessionAllowedPaths.filter((e) => path37__default.normalize(e.path) !== normalized);
+  sessionAllowedPaths = sessionAllowedPaths.filter((e) => path38__default.normalize(e.path) !== normalized);
   return sessionAllowedPaths.length < before;
 }
 async function loadAllowedPaths(projectPath) {
-  currentProjectPath = path37__default.resolve(projectPath);
+  currentProjectPath = path38__default.resolve(projectPath);
   const store = await loadStore();
   const entries = store.projects[currentProjectPath] ?? [];
   for (const entry of entries) {
@@ -20288,14 +20288,14 @@ async function loadAllowedPaths(projectPath) {
 }
 async function persistAllowedPath(dirPath, level) {
   if (!currentProjectPath) return;
-  const absolute = path37__default.resolve(dirPath);
+  const absolute = path38__default.resolve(dirPath);
   const store = await loadStore();
   if (!store.projects[currentProjectPath]) {
     store.projects[currentProjectPath] = [];
   }
   const entries = store.projects[currentProjectPath];
-  const normalized = path37__default.normalize(absolute);
-  if (entries.some((e) => path37__default.normalize(e.path) === normalized)) {
+  const normalized = path38__default.normalize(absolute);
+  if (entries.some((e) => path38__default.normalize(e.path) === normalized)) {
     return;
   }
   entries.push({
@@ -20307,13 +20307,13 @@ async function persistAllowedPath(dirPath, level) {
 }
 async function removePersistedAllowedPath(dirPath) {
   if (!currentProjectPath) return false;
-  const absolute = path37__default.resolve(dirPath);
-  const normalized = path37__default.normalize(absolute);
+  const absolute = path38__default.resolve(dirPath);
+  const normalized = path38__default.normalize(absolute);
   const store = await loadStore();
   const entries = store.projects[currentProjectPath];
   if (!entries) return false;
   const before = entries.length;
-  store.projects[currentProjectPath] = entries.filter((e) => path37__default.normalize(e.path) !== normalized);
+  store.projects[currentProjectPath] = entries.filter((e) => path38__default.normalize(e.path) !== normalized);
   if (store.projects[currentProjectPath].length < before) {
     await saveStore(store);
     return true;
@@ -20322,7 +20322,7 @@ async function removePersistedAllowedPath(dirPath) {
 }
 async function loadStore() {
   try {
-    const content = await fs34__default.readFile(STORE_FILE, "utf-8");
+    const content = await fs35__default.readFile(STORE_FILE, "utf-8");
     return { ...DEFAULT_STORE, ...JSON.parse(content) };
   } catch {
     return { ...DEFAULT_STORE };
@@ -20330,8 +20330,8 @@ async function loadStore() {
 }
 async function saveStore(store) {
   try {
-    await fs34__default.mkdir(path37__default.dirname(STORE_FILE), { recursive: true });
-    await fs34__default.writeFile(STORE_FILE, JSON.stringify(store, null, 2), "utf-8");
+    await fs35__default.mkdir(path38__default.dirname(STORE_FILE), { recursive: true });
+    await fs35__default.writeFile(STORE_FILE, JSON.stringify(store, null, 2), "utf-8");
   } catch {
   }
 }
@@ -20339,7 +20339,7 @@ var STORE_FILE, DEFAULT_STORE, sessionAllowedPaths, currentProjectPath;
 var init_allowed_paths = __esm({
   "src/tools/allowed-paths.ts"() {
     init_paths();
-    STORE_FILE = path37__default.join(CONFIG_PATHS.home, "allowed-paths.json");
+    STORE_FILE = path38__default.join(CONFIG_PATHS.home, "allowed-paths.json");
     DEFAULT_STORE = {
       version: 1,
       projects: {}
@@ -20395,7 +20395,7 @@ function shouldAutoApprove(command, cwd) {
 }
 async function loadFullAccessPreference() {
   try {
-    const content = await fs34__default.readFile(CONFIG_PATHS.config, "utf-8");
+    const content = await fs35__default.readFile(CONFIG_PATHS.config, "utf-8");
     const config = JSON.parse(content);
     if (typeof config.fullAccessMode === "boolean") {
       fullAccessEnabled = config.fullAccessMode;
@@ -20409,12 +20409,12 @@ async function saveFullAccessPreference(enabled) {
   try {
     let config = {};
     try {
-      const content = await fs34__default.readFile(CONFIG_PATHS.config, "utf-8");
+      const content = await fs35__default.readFile(CONFIG_PATHS.config, "utf-8");
       config = JSON.parse(content);
     } catch {
     }
     config.fullAccessMode = enabled;
-    await fs34__default.writeFile(CONFIG_PATHS.config, JSON.stringify(config, null, 2) + "\n");
+    await fs35__default.writeFile(CONFIG_PATHS.config, JSON.stringify(config, null, 2) + "\n");
   } catch {
   }
 }
@@ -20822,12 +20822,384 @@ var init_stdio = __esm({
     };
   }
 });
+function getResourceKey(resourceUrl) {
+  const resource = canonicalizeResourceUrl(resourceUrl);
+  return resource.toLowerCase();
+}
+function canonicalizeResourceUrl(resourceUrl) {
+  const parsed = new URL(resourceUrl);
+  parsed.search = "";
+  parsed.hash = "";
+  if (parsed.pathname === "/") {
+    return `${parsed.protocol}//${parsed.host}`;
+  }
+  parsed.pathname = parsed.pathname.replace(/\/+$/, "");
+  return parsed.toString();
+}
+async function loadStore2() {
+  try {
+    const content = await fs35__default.readFile(TOKEN_STORE_PATH, "utf-8");
+    const parsed = JSON.parse(content);
+    return {
+      tokens: parsed.tokens ?? {},
+      clients: parsed.clients ?? {}
+    };
+  } catch {
+    return { tokens: {}, clients: {} };
+  }
+}
+async function saveStore2(store) {
+  await fs35__default.mkdir(path38__default.dirname(TOKEN_STORE_PATH), { recursive: true });
+  await fs35__default.writeFile(TOKEN_STORE_PATH, JSON.stringify(store, null, 2), {
+    encoding: "utf-8",
+    mode: 384
+  });
+}
+function isTokenExpired2(token) {
+  if (!token.expiresAt) return false;
+  return Date.now() >= token.expiresAt - 3e4;
+}
+async function getStoredMcpOAuthToken(resourceUrl) {
+  const store = await loadStore2();
+  const token = store.tokens[getResourceKey(resourceUrl)];
+  if (!token) return void 0;
+  if (isTokenExpired2(token)) return void 0;
+  return token.accessToken;
+}
+function createCodeVerifier() {
+  return randomBytes(32).toString("base64url");
+}
+function createCodeChallenge(verifier) {
+  return createHash("sha256").update(verifier).digest("base64url");
+}
+function createState() {
+  return randomBytes(16).toString("hex");
+}
+async function openBrowser2(url) {
+  let safeUrl;
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+      return false;
+    }
+    safeUrl = parsed.toString();
+  } catch {
+    return false;
+  }
+  const isWSL2 = process.platform === "linux" && (process.env["WSL_DISTRO_NAME"] !== void 0 || process.env["WSL_INTEROP"] !== void 0 || process.env["TERM_PROGRAM"]?.toLowerCase().includes("wsl") === true);
+  const commands2 = [];
+  if (process.platform === "darwin") {
+    commands2.push(
+      { cmd: "open", args: [safeUrl] },
+      { cmd: "open", args: ["-a", "Safari", safeUrl] },
+      { cmd: "open", args: ["-a", "Google Chrome", safeUrl] }
+    );
+  } else if (process.platform === "win32") {
+    commands2.push({ cmd: "rundll32", args: ["url.dll,FileProtocolHandler", safeUrl] });
+  } else if (isWSL2) {
+    commands2.push(
+      { cmd: "cmd.exe", args: ["/c", "start", "", safeUrl] },
+      { cmd: "powershell.exe", args: ["-Command", `Start-Process '${safeUrl}'`] },
+      { cmd: "wslview", args: [safeUrl] }
+    );
+  } else {
+    commands2.push(
+      { cmd: "xdg-open", args: [safeUrl] },
+      { cmd: "sensible-browser", args: [safeUrl] },
+      { cmd: "x-www-browser", args: [safeUrl] },
+      { cmd: "gnome-open", args: [safeUrl] },
+      { cmd: "firefox", args: [safeUrl] },
+      { cmd: "chromium-browser", args: [safeUrl] },
+      { cmd: "google-chrome", args: [safeUrl] }
+    );
+  }
+  for (const { cmd, args } of commands2) {
+    try {
+      await execFileAsync2(cmd, args);
+      return true;
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+function maskUrlForLogs(rawUrl) {
+  try {
+    const url = new URL(rawUrl);
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+  } catch {
+    return "[invalid-url]";
+  }
+}
+function parseResourceMetadataUrl(wwwAuthenticateHeader) {
+  if (!wwwAuthenticateHeader) return void 0;
+  const match = wwwAuthenticateHeader.match(/resource_metadata="([^"]+)"/i);
+  return match?.[1];
+}
+function createProtectedMetadataCandidates(resourceUrl, headerUrl) {
+  const candidates = [];
+  if (headerUrl) {
+    candidates.push(headerUrl);
+  }
+  const resource = new URL(resourceUrl);
+  const origin = `${resource.protocol}//${resource.host}`;
+  const pathPart = resource.pathname.replace(/\/+$/, "");
+  candidates.push(`${origin}/.well-known/oauth-protected-resource`);
+  if (pathPart && pathPart !== "/") {
+    candidates.push(`${origin}/.well-known/oauth-protected-resource${pathPart}`);
+    candidates.push(`${origin}/.well-known/oauth-protected-resource/${pathPart.replace(/^\//, "")}`);
+  }
+  return Array.from(new Set(candidates));
+}
+async function fetchJson(url) {
+  const res = await fetch(url, { method: "GET", headers: { Accept: "application/json" } });
+  if (!res.ok) {
+    throw new Error(`HTTP ${res.status} while fetching ${url}`);
+  }
+  return await res.json();
+}
+function buildAuthorizationMetadataCandidates(issuer) {
+  const parsed = new URL(issuer);
+  const base = `${parsed.protocol}//${parsed.host}`;
+  const issuerPath = parsed.pathname === "/" ? "" : parsed.pathname.replace(/\/+$/, "");
+  const candidates = [
+    `${base}/.well-known/oauth-authorization-server${issuerPath}`,
+    `${base}/.well-known/oauth-authorization-server`,
+    `${base}/.well-known/openid-configuration${issuerPath}`,
+    `${base}/.well-known/openid-configuration`
+  ];
+  return Array.from(new Set(candidates));
+}
+async function discoverProtectedResourceMetadata(resourceUrl, wwwAuthenticateHeader) {
+  const headerUrl = parseResourceMetadataUrl(wwwAuthenticateHeader);
+  const candidates = createProtectedMetadataCandidates(resourceUrl, headerUrl);
+  for (const candidate of candidates) {
+    try {
+      const metadata = await fetchJson(candidate);
+      if (Array.isArray(metadata.authorization_servers) && metadata.authorization_servers.length > 0) {
+        return metadata;
+      }
+    } catch {
+    }
+  }
+  throw new Error("Could not discover OAuth protected resource metadata for MCP server");
+}
+async function discoverAuthorizationServerMetadata(authorizationServer) {
+  const candidates = buildAuthorizationMetadataCandidates(authorizationServer);
+  for (const candidate of candidates) {
+    try {
+      const metadata = await fetchJson(candidate);
+      if (metadata.authorization_endpoint && metadata.token_endpoint) {
+        return metadata;
+      }
+    } catch {
+    }
+  }
+  throw new Error("Could not discover OAuth authorization server metadata");
+}
+async function ensureClientId(authorizationMetadata, authorizationServer, redirectUri) {
+  const store = await loadStore2();
+  const clientKey = `${authorizationServer}|${redirectUri}`;
+  const existing = store.clients[clientKey]?.clientId;
+  if (existing) return existing;
+  const registrationEndpoint = authorizationMetadata.registration_endpoint;
+  if (!registrationEndpoint) {
+    throw new Error(
+      "Authorization server does not expose dynamic client registration; configure a static OAuth client ID for this MCP server."
+    );
+  }
+  const registrationPayload = {
+    client_name: "corbat-coco-mcp",
+    redirect_uris: [redirectUri],
+    grant_types: ["authorization_code", "refresh_token"],
+    response_types: ["code"],
+    token_endpoint_auth_method: "none"
+  };
+  const response = await fetch(registrationEndpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    },
+    body: JSON.stringify(registrationPayload)
+  });
+  if (!response.ok) {
+    throw new Error(`Dynamic client registration failed: HTTP ${response.status}`);
+  }
+  const data = await response.json();
+  const clientId = data.client_id;
+  if (!clientId) {
+    throw new Error("Dynamic client registration did not return client_id");
+  }
+  store.clients[clientKey] = { clientId };
+  await saveStore2(store);
+  return clientId;
+}
+async function refreshAccessToken2(params) {
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    client_id: params.clientId,
+    refresh_token: params.refreshToken,
+    resource: params.resource
+  });
+  const response = await fetch(params.tokenEndpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Accept: "application/json"
+    },
+    body: body.toString()
+  });
+  if (!response.ok) {
+    throw new Error(`Refresh token exchange failed: HTTP ${response.status}`);
+  }
+  const tokenResponse = await response.json();
+  if (!tokenResponse.access_token) {
+    throw new Error("Refresh token response missing access_token");
+  }
+  return tokenResponse;
+}
+async function exchangeCodeForToken(tokenEndpoint, clientId, code, codeVerifier, redirectUri, resource) {
+  const body = new URLSearchParams({
+    grant_type: "authorization_code",
+    code,
+    client_id: clientId,
+    redirect_uri: redirectUri,
+    code_verifier: codeVerifier,
+    resource
+  });
+  const response = await fetch(tokenEndpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Accept: "application/json"
+    },
+    body: body.toString()
+  });
+  if (!response.ok) {
+    throw new Error(`Token exchange failed: HTTP ${response.status}`);
+  }
+  const tokenResponse = await response.json();
+  if (!tokenResponse.access_token) {
+    throw new Error("Token exchange response missing access_token");
+  }
+  return tokenResponse;
+}
+async function persistToken(resourceUrl, token, metadata) {
+  const store = await loadStore2();
+  const expiresAt = typeof token.expires_in === "number" ? Date.now() + Math.max(0, token.expires_in) * 1e3 : void 0;
+  store.tokens[getResourceKey(resourceUrl)] = {
+    accessToken: token.access_token,
+    tokenType: token.token_type,
+    refreshToken: token.refresh_token,
+    authorizationServer: metadata?.authorizationServer,
+    clientId: metadata?.clientId,
+    resource: canonicalizeResourceUrl(resourceUrl),
+    ...expiresAt ? { expiresAt } : {}
+  };
+  await saveStore2(store);
+}
+async function authenticateMcpOAuth(params) {
+  const resource = canonicalizeResourceUrl(params.resourceUrl);
+  const store = await loadStore2();
+  const stored = store.tokens[getResourceKey(resource)];
+  if (stored && !isTokenExpired2(stored)) {
+    return stored.accessToken;
+  }
+  if (!process.stdout.isTTY) {
+    throw new Error(
+      `MCP server '${params.serverName}' requires interactive OAuth in a TTY session. Run Coco in a terminal, or use mcp-remote (e.g. npx -y mcp-remote@latest ${resource}) for IDE bridge workflows.`
+    );
+  }
+  const protectedMetadata = await discoverProtectedResourceMetadata(
+    resource,
+    params.wwwAuthenticateHeader
+  );
+  const authorizationServer = protectedMetadata.authorization_servers?.[0];
+  if (!authorizationServer) {
+    throw new Error("Protected resource metadata does not include authorization_servers");
+  }
+  const authorizationMetadata = await discoverAuthorizationServerMetadata(authorizationServer);
+  if (stored && isTokenExpired2(stored) && stored.refreshToken && stored.clientId) {
+    try {
+      const refreshed = await refreshAccessToken2({
+        tokenEndpoint: authorizationMetadata.token_endpoint,
+        clientId: stored.clientId,
+        refreshToken: stored.refreshToken,
+        resource
+      });
+      await persistToken(resource, refreshed, {
+        authorizationServer,
+        clientId: stored.clientId
+      });
+      return refreshed.access_token;
+    } catch {
+    }
+  }
+  const codeVerifier = createCodeVerifier();
+  const codeChallenge = createCodeChallenge(codeVerifier);
+  const state = createState();
+  const { port, resultPromise } = await createCallbackServer(
+    state,
+    OAUTH_TIMEOUT_MS,
+    OAUTH_CALLBACK_PORT
+  );
+  const redirectUri = `http://localhost:${port}/auth/callback`;
+  const clientId = await ensureClientId(authorizationMetadata, authorizationServer, redirectUri);
+  const authUrl = new URL(authorizationMetadata.authorization_endpoint);
+  authUrl.searchParams.set("response_type", "code");
+  authUrl.searchParams.set("client_id", clientId);
+  authUrl.searchParams.set("redirect_uri", redirectUri);
+  authUrl.searchParams.set("state", state);
+  authUrl.searchParams.set("code_challenge", codeChallenge);
+  authUrl.searchParams.set("code_challenge_method", "S256");
+  authUrl.searchParams.set("resource", resource);
+  if (authorizationMetadata.scopes_supported?.includes("offline_access")) {
+    authUrl.searchParams.set("scope", "offline_access");
+  }
+  const opened = await openBrowser2(authUrl.toString());
+  if (!opened) {
+    logger.warn(`[MCP OAuth] Could not open browser automatically for '${params.serverName}'`);
+    logger.warn(`[MCP OAuth] Manual auth URL base: ${maskUrlForLogs(authUrl.toString())}`);
+    console.log(`[MCP OAuth] Open this URL manually: ${authUrl.toString()}`);
+  } else {
+    logger.info(
+      `[MCP OAuth] Opened browser for '${params.serverName}'. Complete login to continue.`
+    );
+  }
+  const callback = await resultPromise;
+  const token = await exchangeCodeForToken(
+    authorizationMetadata.token_endpoint,
+    clientId,
+    callback.code,
+    codeVerifier,
+    redirectUri,
+    resource
+  );
+  await persistToken(resource, token, { authorizationServer, clientId });
+  return token.access_token;
+}
+var execFileAsync2, TOKEN_STORE_PATH, OAUTH_TIMEOUT_MS, logger;
+var init_oauth2 = __esm({
+  "src/mcp/oauth.ts"() {
+    init_callback_server();
+    init_paths();
+    init_logger();
+    execFileAsync2 = promisify(execFile);
+    TOKEN_STORE_PATH = path38__default.join(CONFIG_PATHS.tokens, "mcp-oauth.json");
+    OAUTH_TIMEOUT_MS = 5 * 60 * 1e3;
+    logger = getLogger();
+  }
+});
 
 // src/mcp/transport/http.ts
 var HTTPTransport;
 var init_http = __esm({
   "src/mcp/transport/http.ts"() {
     init_errors2();
+    init_oauth2();
     init_errors2();
     HTTPTransport = class {
       constructor(config) {
@@ -20845,10 +21217,15 @@ var init_http = __esm({
       connected = false;
       abortController = null;
       pendingRequests = /* @__PURE__ */ new Map();
+      oauthToken;
+      oauthInFlight = null;
       /**
        * Get authentication token
        */
       getAuthToken() {
+        if (this.oauthToken) {
+          return this.oauthToken;
+        }
         if (!this.config.auth) return void 0;
         if (this.config.auth.token) {
           return this.config.auth.token;
@@ -20867,22 +21244,64 @@ var init_http = __esm({
           Accept: "application/json",
           ...this.config.headers
         };
+        if (this.oauthToken) {
+          headers["Authorization"] = `Bearer ${this.oauthToken}`;
+          return headers;
+        }
         const token = this.getAuthToken();
         if (token && this.config.auth) {
-          switch (this.config.auth.type) {
-            case "bearer":
-              headers["Authorization"] = `Bearer ${token}`;
-              break;
-            case "apikey":
-              headers[this.config.auth.headerName || "X-API-Key"] = token;
-              break;
-            case "oauth":
-              headers["Authorization"] = `Bearer ${token}`;
-              break;
+          if (this.config.auth.type === "apikey") {
+            headers[this.config.auth.headerName || "X-API-Key"] = token;
+          } else {
+            headers["Authorization"] = `Bearer ${token}`;
           }
         }
         return headers;
       }
+      shouldAttemptOAuth() {
+        if (this.config.auth?.type === "apikey") {
+          return false;
+        }
+        if (this.config.auth?.type === "bearer") {
+          return !this.getAuthToken();
+        }
+        return true;
+      }
+      async ensureOAuthToken(wwwAuthenticateHeader) {
+        if (this.oauthToken) {
+          return this.oauthToken;
+        }
+        if (this.oauthInFlight) {
+          return this.oauthInFlight;
+        }
+        const serverName = this.config.name ?? this.config.url;
+        this.oauthInFlight = authenticateMcpOAuth({
+          serverName,
+          resourceUrl: this.config.url,
+          wwwAuthenticateHeader
+        }).then((token) => {
+          this.oauthToken = token;
+          return token;
+        }).finally(() => {
+          this.oauthInFlight = null;
+        });
+        return this.oauthInFlight;
+      }
+      async sendRequestWithOAuthRetry(method, body, signal) {
+        const doFetch = async () => fetch(this.config.url, {
+          method,
+          headers: this.buildHeaders(),
+          ...body ? { body } : {},
+          signal
+        });
+        let response = await doFetch();
+        if (response.status !== 401 || !this.shouldAttemptOAuth()) {
+          return response;
+        }
+        await this.ensureOAuthToken(response.headers.get("www-authenticate"));
+        response = await doFetch();
+        return response;
+      }
       /**
        * Connect to the HTTP transport
        */
@@ -20897,11 +21316,14 @@ var init_http = __esm({
         }
         try {
           this.abortController = new AbortController();
-          const response = await fetch(this.config.url, {
-            method: "GET",
-            headers: this.buildHeaders(),
-            signal: this.abortController.signal
-          });
+          if (this.shouldAttemptOAuth()) {
+            this.oauthToken = await getStoredMcpOAuthToken(this.config.url);
+          }
+          const response = await this.sendRequestWithOAuthRetry(
+            "GET",
+            void 0,
+            this.abortController.signal
+          );
           if (!response.ok && response.status !== 404) {
             throw new Error(`HTTP ${response.status}: ${response.statusText}`);
           }
@@ -20933,12 +21355,11 @@ var init_http = __esm({
             const timeoutId = setTimeout(() => {
               abortController.abort();
             }, this.config.timeout);
-            const response = await fetch(this.config.url, {
-              method: "POST",
-              headers: this.buildHeaders(),
-              body: JSON.stringify(message),
-              signal: abortController.signal
-            });
+            const response = await this.sendRequestWithOAuthRetry(
+              "POST",
+              JSON.stringify(message),
+              abortController.signal
+            );
             clearTimeout(timeoutId);
             if (!response.ok) {
               throw new MCPTransportError(`HTTP error ${response.status}: ${response.statusText}`);
@@ -21314,6 +21735,7 @@ var init_lifecycle = __esm({
               throw new MCPConnectionError(`Server '${config.name}' requires http.url`);
             }
             return new HTTPTransport({
+              name: config.name,
               url: config.http.url,
               headers: config.http.headers,
               auth: config.http.auth
@@ -21530,7 +21952,7 @@ function shouldFullPowerApprove(command) {
 }
 async function loadFullPowerRiskPreference() {
   try {
-    const content = await fs34__default.readFile(CONFIG_PATHS.config, "utf-8");
+    const content = await fs35__default.readFile(CONFIG_PATHS.config, "utf-8");
     const config = JSON.parse(content);
     if (typeof config.fullPowerRiskMode === "boolean") {
       fullPowerRiskEnabled = config.fullPowerRiskMode;
@@ -21544,12 +21966,12 @@ async function saveFullPowerRiskPreference(enabled) {
   try {
     let config = {};
     try {
-      const content = await fs34__default.readFile(CONFIG_PATHS.config, "utf-8");
+      const content = await fs35__default.readFile(CONFIG_PATHS.config, "utf-8");
       config = JSON.parse(content);
     } catch {
     }
     config.fullPowerRiskMode = enabled;
-    await fs34__default.writeFile(CONFIG_PATHS.config, JSON.stringify(config, null, 2) + "\n");
+    await fs35__default.writeFile(CONFIG_PATHS.config, JSON.stringify(config, null, 2) + "\n");
   } catch {
   }
 }
@@ -21601,7 +22023,7 @@ __export(allow_path_prompt_exports, {
   promptAllowPath: () => promptAllowPath
 });
 async function promptAllowPath(dirPath) {
-  const absolute = path37__default.resolve(dirPath);
+  const absolute = path38__default.resolve(dirPath);
   console.log();
   console.log(chalk.yellow("  \u26A0 Access denied \u2014 path is outside the project directory"));
   console.log(chalk.dim(`  \u{1F4C1} ${absolute}`));
@@ -21843,13 +22265,13 @@ __export(stack_detector_exports, {
   detectProjectStack: () => detectProjectStack
 });
 async function detectStack2(cwd) {
-  if (await fileExists3(path37__default.join(cwd, "package.json"))) return "node";
-  if (await fileExists3(path37__default.join(cwd, "Cargo.toml"))) return "rust";
-  if (await fileExists3(path37__default.join(cwd, "pyproject.toml"))) return "python";
-  if (await fileExists3(path37__default.join(cwd, "go.mod"))) return "go";
-  if (await fileExists3(path37__default.join(cwd, "pom.xml"))) return "java";
-  if (await fileExists3(path37__default.join(cwd, "build.gradle"))) return "java";
-  if (await fileExists3(path37__default.join(cwd, "build.gradle.kts"))) return "java";
+  if (await fileExists3(path38__default.join(cwd, "package.json"))) return "node";
+  if (await fileExists3(path38__default.join(cwd, "Cargo.toml"))) return "rust";
+  if (await fileExists3(path38__default.join(cwd, "pyproject.toml"))) return "python";
+  if (await fileExists3(path38__default.join(cwd, "go.mod"))) return "go";
+  if (await fileExists3(path38__default.join(cwd, "pom.xml"))) return "java";
+  if (await fileExists3(path38__default.join(cwd, "build.gradle"))) return "java";
+  if (await fileExists3(path38__default.join(cwd, "build.gradle.kts"))) return "java";
   return "unknown";
 }
 async function detectPackageManager3(cwd, stack) {
@@ -21857,25 +22279,25 @@ async function detectPackageManager3(cwd, stack) {
   if (stack === "python") return "pip";
   if (stack === "go") return "go";
   if (stack === "java") {
-    if (await fileExists3(path37__default.join(cwd, "build.gradle")) || await fileExists3(path37__default.join(cwd, "build.gradle.kts"))) {
+    if (await fileExists3(path38__default.join(cwd, "build.gradle")) || await fileExists3(path38__default.join(cwd, "build.gradle.kts"))) {
       return "gradle";
     }
-    if (await fileExists3(path37__default.join(cwd, "pom.xml"))) {
+    if (await fileExists3(path38__default.join(cwd, "pom.xml"))) {
       return "maven";
     }
   }
   if (stack === "node") {
-    if (await fileExists3(path37__default.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-    if (await fileExists3(path37__default.join(cwd, "yarn.lock"))) return "yarn";
-    if (await fileExists3(path37__default.join(cwd, "bun.lockb"))) return "bun";
+    if (await fileExists3(path38__default.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+    if (await fileExists3(path38__default.join(cwd, "yarn.lock"))) return "yarn";
+    if (await fileExists3(path38__default.join(cwd, "bun.lockb"))) return "bun";
     return "npm";
   }
   return null;
 }
 async function parsePackageJson(cwd) {
-  const packageJsonPath = path37__default.join(cwd, "package.json");
+  const packageJsonPath = path38__default.join(cwd, "package.json");
   try {
-    const content = await fs34__default.readFile(packageJsonPath, "utf-8");
+    const content = await fs35__default.readFile(packageJsonPath, "utf-8");
     const pkg = JSON.parse(content);
     const allDeps = {
       ...pkg.dependencies,
@@ -21905,7 +22327,7 @@ async function parsePackageJson(cwd) {
     if (allDeps["@playwright/test"]) testingFrameworks.push("playwright");
     if (allDeps.cypress) testingFrameworks.push("cypress");
     const languages = ["JavaScript"];
-    if (allDeps.typescript || await fileExists3(path37__default.join(cwd, "tsconfig.json"))) {
+    if (allDeps.typescript || await fileExists3(path38__default.join(cwd, "tsconfig.json"))) {
       languages.push("TypeScript");
     }
     return {
@@ -21926,9 +22348,9 @@ async function parsePackageJson(cwd) {
   }
 }
 async function parsePomXml(cwd) {
-  const pomPath = path37__default.join(cwd, "pom.xml");
+  const pomPath = path38__default.join(cwd, "pom.xml");
   try {
-    const content = await fs34__default.readFile(pomPath, "utf-8");
+    const content = await fs35__default.readFile(pomPath, "utf-8");
     const dependencies = {};
     const frameworks = [];
     const buildTools2 = ["maven"];
@@ -21963,9 +22385,9 @@ async function parsePomXml(cwd) {
   }
 }
 async function parsePyprojectToml(cwd) {
-  const pyprojectPath = path37__default.join(cwd, "pyproject.toml");
+  const pyprojectPath = path38__default.join(cwd, "pyproject.toml");
   try {
-    const content = await fs34__default.readFile(pyprojectPath, "utf-8");
+    const content = await fs35__default.readFile(pyprojectPath, "utf-8");
     const dependencies = {};
     const frameworks = [];
     const buildTools2 = ["pip"];
@@ -22006,7 +22428,7 @@ async function detectProjectStack(cwd) {
     testingFrameworks = parsed.testingFrameworks;
     languages = parsed.languages;
   } else if (stack === "java") {
-    const isGradle = await fileExists3(path37__default.join(cwd, "build.gradle")) || await fileExists3(path37__default.join(cwd, "build.gradle.kts"));
+    const isGradle = await fileExists3(path38__default.join(cwd, "build.gradle")) || await fileExists3(path38__default.join(cwd, "build.gradle.kts"));
     const parsed = isGradle ? { dependencies: {}, frameworks: [], buildTools: ["gradle"], testingFrameworks: ["JUnit"] } : await parsePomXml(cwd);
     dependencies = parsed.dependencies;
     frameworks = parsed.frameworks;
@@ -22407,7 +22829,7 @@ function loadStandardFormat(config, configPath) {
   return validServers;
 }
 async function loadProjectMCPFile(projectPath) {
-  const mcpJsonPath = path37__default.join(projectPath, ".mcp.json");
+  const mcpJsonPath = path38__default.join(projectPath, ".mcp.json");
   try {
     await access(mcpJsonPath);
   } catch {
@@ -23719,26 +24141,26 @@ init_version();
 // src/orchestrator/project.ts
 init_env();
 async function createProjectStructure(projectPath, info) {
-  const cocoPath = path37__default.join(projectPath, ".coco");
+  const cocoPath = path38__default.join(projectPath, ".coco");
   const directories = [
     cocoPath,
-    path37__default.join(cocoPath, "state"),
-    path37__default.join(cocoPath, "checkpoints"),
-    path37__default.join(cocoPath, "logs"),
-    path37__default.join(cocoPath, "discovery"),
-    path37__default.join(cocoPath, "spec"),
-    path37__default.join(cocoPath, "architecture"),
-    path37__default.join(cocoPath, "architecture", "adrs"),
-    path37__default.join(cocoPath, "architecture", "diagrams"),
-    path37__default.join(cocoPath, "planning"),
-    path37__default.join(cocoPath, "planning", "epics"),
-    path37__default.join(cocoPath, "execution"),
-    path37__default.join(cocoPath, "versions"),
-    path37__default.join(cocoPath, "reviews"),
-    path37__default.join(cocoPath, "delivery")
+    path38__default.join(cocoPath, "state"),
+    path38__default.join(cocoPath, "checkpoints"),
+    path38__default.join(cocoPath, "logs"),
+    path38__default.join(cocoPath, "discovery"),
+    path38__default.join(cocoPath, "spec"),
+    path38__default.join(cocoPath, "architecture"),
+    path38__default.join(cocoPath, "architecture", "adrs"),
+    path38__default.join(cocoPath, "architecture", "diagrams"),
+    path38__default.join(cocoPath, "planning"),
+    path38__default.join(cocoPath, "planning", "epics"),
+    path38__default.join(cocoPath, "execution"),
+    path38__default.join(cocoPath, "versions"),
+    path38__default.join(cocoPath, "reviews"),
+    path38__default.join(cocoPath, "delivery")
   ];
   for (const dir of directories) {
-    await fs34__default.mkdir(dir, { recursive: true });
+    await fs35__default.mkdir(dir, { recursive: true });
   }
   await createInitialConfig(cocoPath, info);
   await createProjectState(cocoPath, info);
@@ -23773,7 +24195,7 @@ async function createInitialConfig(cocoPath, info) {
       maxCheckpoints: 50
     }
   };
-  await fs34__default.writeFile(path37__default.join(cocoPath, "config.json"), JSON.stringify(config, null, 2), "utf-8");
+  await fs35__default.writeFile(path38__default.join(cocoPath, "config.json"), JSON.stringify(config, null, 2), "utf-8");
 }
 async function createProjectState(cocoPath, info) {
   const state = {
@@ -23790,8 +24212,8 @@ async function createProjectState(cocoPath, info) {
     qualityHistory: [],
     lastCheckpoint: null
   };
-  await fs34__default.writeFile(
-    path37__default.join(cocoPath, "state", "project.json"),
+  await fs35__default.writeFile(
+    path38__default.join(cocoPath, "state", "project.json"),
     JSON.stringify(state, null, 2),
     "utf-8"
   );
@@ -23812,7 +24234,7 @@ checkpoints/
 state/session.json
 state/lock.json
 `;
-  await fs34__default.writeFile(path37__default.join(cocoPath, ".gitignore"), content, "utf-8");
+  await fs35__default.writeFile(path38__default.join(cocoPath, ".gitignore"), content, "utf-8");
 }
 async function createReadme(cocoPath, info) {
   const content = `# Corbat-Coco Project: ${info.name}
@@ -23859,13 +24281,13 @@ Edit \`config.json\` to customize:
 ---
 Generated by Corbat-Coco v0.1.0
 `;
-  await fs34__default.writeFile(path37__default.join(cocoPath, "README.md"), content, "utf-8");
+  await fs35__default.writeFile(path38__default.join(cocoPath, "README.md"), content, "utf-8");
 }
 
 // src/cli/commands/init.ts
 function registerInitCommand(program2) {
-  program2.command("init").description("Initialize a new Corbat-Coco project").argument("[path]", "Project directory path", ".").option("-t, --template <template>", "Project template to use").option("-y, --yes", "Skip prompts and use defaults").option("--skip-discovery", "Skip the discovery phase (use existing spec)").action(async (path59, options) => {
-    await runInit(path59, options);
+  program2.command("init").description("Initialize a new Corbat-Coco project").argument("[path]", "Project directory path", ".").option("-t, --template <template>", "Project template to use").option("-y, --yes", "Skip prompts and use defaults").option("--skip-discovery", "Skip the discovery phase (use existing spec)").action(async (path60, options) => {
+    await runInit(path60, options);
   });
 }
 async function runInit(projectPath, options) {
@@ -23944,18 +24366,18 @@ async function gatherProjectInfo() {
     language
   };
 }
-function getDefaultProjectInfo(path59) {
-  const name = path59 === "." ? "my-project" : path59.split("/").pop() || "my-project";
+function getDefaultProjectInfo(path60) {
+  const name = path60 === "." ? "my-project" : path60.split("/").pop() || "my-project";
   return {
     name,
     description: "",
     language: "typescript"
   };
 }
-async function checkExistingProject(path59) {
+async function checkExistingProject(path60) {
   try {
-    const fs55 = await import('fs/promises');
-    await fs55.access(`${path59}/.coco`);
+    const fs56 = await import('fs/promises');
+    await fs56.access(`${path60}/.coco`);
     return true;
   } catch {
     return false;
@@ -25163,13 +25585,13 @@ function createSpecificationGenerator(llm, config) {
 // src/phases/converge/persistence.ts
 init_errors();
 function getPersistencePaths(projectPath) {
-  const baseDir = path37__default.join(projectPath, ".coco", "spec");
+  const baseDir = path38__default.join(projectPath, ".coco", "spec");
   return {
     baseDir,
-    sessionFile: path37__default.join(baseDir, "discovery-session.json"),
-    specFile: path37__default.join(baseDir, "spec.md"),
-    conversationLog: path37__default.join(baseDir, "conversation.jsonl"),
-    checkpointFile: path37__default.join(baseDir, "checkpoint.json")
+    sessionFile: path38__default.join(baseDir, "discovery-session.json"),
+    specFile: path38__default.join(baseDir, "spec.md"),
+    conversationLog: path38__default.join(baseDir, "conversation.jsonl"),
+    checkpointFile: path38__default.join(baseDir, "checkpoint.json")
   };
 }
 var SessionPersistence = class {
@@ -25182,7 +25604,7 @@ var SessionPersistence = class {
    */
   async ensureDir() {
     try {
-      await fs34__default.mkdir(this.paths.baseDir, { recursive: true });
+      await fs35__default.mkdir(this.paths.baseDir, { recursive: true });
     } catch {
       throw new FileSystemError(`Failed to create persistence directory: ${this.paths.baseDir}`, {
         path: this.paths.baseDir,
@@ -25197,7 +25619,7 @@ var SessionPersistence = class {
     await this.ensureDir();
     try {
       const data = JSON.stringify(session, null, 2);
-      await fs34__default.writeFile(this.paths.sessionFile, data, "utf-8");
+      await fs35__default.writeFile(this.paths.sessionFile, data, "utf-8");
     } catch {
       throw new FileSystemError("Failed to save discovery session", {
         path: this.paths.sessionFile,
@@ -25210,7 +25632,7 @@ var SessionPersistence = class {
    */
   async loadSession() {
     try {
-      const data = await fs34__default.readFile(this.paths.sessionFile, "utf-8");
+      const data = await fs35__default.readFile(this.paths.sessionFile, "utf-8");
       const parsed = JSON.parse(data);
       parsed.startedAt = new Date(parsed.startedAt);
       parsed.updatedAt = new Date(parsed.updatedAt);
@@ -25236,7 +25658,7 @@ var SessionPersistence = class {
    */
   async hasSession() {
     try {
-      await fs34__default.access(this.paths.sessionFile);
+      await fs35__default.access(this.paths.sessionFile);
       return true;
     } catch {
       return false;
@@ -25247,7 +25669,7 @@ var SessionPersistence = class {
    */
   async deleteSession() {
     try {
-      await fs34__default.unlink(this.paths.sessionFile);
+      await fs35__default.unlink(this.paths.sessionFile);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw new FileSystemError("Failed to delete discovery session", {
@@ -25263,7 +25685,7 @@ var SessionPersistence = class {
   async saveSpecification(content) {
     await this.ensureDir();
     try {
-      await fs34__default.writeFile(this.paths.specFile, content, "utf-8");
+      await fs35__default.writeFile(this.paths.specFile, content, "utf-8");
     } catch {
       throw new FileSystemError("Failed to save specification", {
         path: this.paths.specFile,
@@ -25276,7 +25698,7 @@ var SessionPersistence = class {
    */
   async loadSpecification() {
     try {
-      return await fs34__default.readFile(this.paths.specFile, "utf-8");
+      return await fs35__default.readFile(this.paths.specFile, "utf-8");
     } catch {
       return null;
     }
@@ -25292,7 +25714,7 @@ var SessionPersistence = class {
       content
     };
     try {
-      await fs34__default.appendFile(this.paths.conversationLog, JSON.stringify(entry) + "\n", "utf-8");
+      await fs35__default.appendFile(this.paths.conversationLog, JSON.stringify(entry) + "\n", "utf-8");
     } catch {
       throw new FileSystemError("Failed to append to conversation log", {
         path: this.paths.conversationLog,
@@ -25305,7 +25727,7 @@ var SessionPersistence = class {
    */
   async loadConversationLog() {
     try {
-      const data = await fs34__default.readFile(this.paths.conversationLog, "utf-8");
+      const data = await fs35__default.readFile(this.paths.conversationLog, "utf-8");
       const lines = data.trim().split("\n");
       return lines.filter((line) => line.trim()).map((line) => JSON.parse(line));
     } catch {
@@ -25319,7 +25741,7 @@ var SessionPersistence = class {
     await this.ensureDir();
     try {
       const data = JSON.stringify(checkpoint, null, 2);
-      await fs34__default.writeFile(this.paths.checkpointFile, data, "utf-8");
+      await fs35__default.writeFile(this.paths.checkpointFile, data, "utf-8");
     } catch {
       throw new FileSystemError("Failed to save checkpoint", {
         path: this.paths.checkpointFile,
@@ -25332,7 +25754,7 @@ var SessionPersistence = class {
    */
   async loadCheckpoint() {
     try {
-      const data = await fs34__default.readFile(this.paths.checkpointFile, "utf-8");
+      const data = await fs35__default.readFile(this.paths.checkpointFile, "utf-8");
       const parsed = JSON.parse(data);
       parsed.timestamp = new Date(parsed.timestamp);
       return parsed;
@@ -25345,7 +25767,7 @@ var SessionPersistence = class {
    */
   async clearAll() {
     try {
-      await fs34__default.rm(this.paths.baseDir, { recursive: true, force: true });
+      await fs35__default.rm(this.paths.baseDir, { recursive: true, force: true });
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw new FileSystemError("Failed to clear persistence data", {
@@ -27273,8 +27695,8 @@ var OrchestrateExecutor = class {
   }
   async loadSpecification(projectPath) {
     try {
-      const jsonPath = path37__default.join(projectPath, ".coco", "spec", "spec.json");
-      const jsonContent = await fs34__default.readFile(jsonPath, "utf-8");
+      const jsonPath = path38__default.join(projectPath, ".coco", "spec", "spec.json");
+      const jsonContent = await fs35__default.readFile(jsonPath, "utf-8");
       return JSON.parse(jsonContent);
     } catch {
       return this.createMinimalSpec(projectPath);
@@ -27285,7 +27707,7 @@ var OrchestrateExecutor = class {
       version: "1.0.0",
       generatedAt: /* @__PURE__ */ new Date(),
       overview: {
-        name: path37__default.basename(projectPath),
+        name: path38__default.basename(projectPath),
         description: "Project specification",
         goals: [],
         targetUsers: ["developers"],
@@ -27312,53 +27734,53 @@ var OrchestrateExecutor = class {
     };
   }
   async saveArchitecture(projectPath, architecture) {
-    const dir = path37__default.join(projectPath, ".coco", "architecture");
-    await fs34__default.mkdir(dir, { recursive: true });
-    const mdPath = path37__default.join(dir, "ARCHITECTURE.md");
-    await fs34__default.writeFile(mdPath, generateArchitectureMarkdown(architecture), "utf-8");
-    const jsonPath = path37__default.join(dir, "architecture.json");
-    await fs34__default.writeFile(jsonPath, JSON.stringify(architecture, null, 2), "utf-8");
+    const dir = path38__default.join(projectPath, ".coco", "architecture");
+    await fs35__default.mkdir(dir, { recursive: true });
+    const mdPath = path38__default.join(dir, "ARCHITECTURE.md");
+    await fs35__default.writeFile(mdPath, generateArchitectureMarkdown(architecture), "utf-8");
+    const jsonPath = path38__default.join(dir, "architecture.json");
+    await fs35__default.writeFile(jsonPath, JSON.stringify(architecture, null, 2), "utf-8");
     return mdPath;
   }
   async saveADRs(projectPath, adrs) {
-    const dir = path37__default.join(projectPath, ".coco", "architecture", "adrs");
-    await fs34__default.mkdir(dir, { recursive: true });
+    const dir = path38__default.join(projectPath, ".coco", "architecture", "adrs");
+    await fs35__default.mkdir(dir, { recursive: true });
     const paths = [];
-    const indexPath = path37__default.join(dir, "README.md");
-    await fs34__default.writeFile(indexPath, generateADRIndexMarkdown(adrs), "utf-8");
+    const indexPath = path38__default.join(dir, "README.md");
+    await fs35__default.writeFile(indexPath, generateADRIndexMarkdown(adrs), "utf-8");
     paths.push(indexPath);
     for (const adr of adrs) {
       const filename = getADRFilename(adr);
-      const adrPath = path37__default.join(dir, filename);
-      await fs34__default.writeFile(adrPath, generateADRMarkdown(adr), "utf-8");
+      const adrPath = path38__default.join(dir, filename);
+      await fs35__default.writeFile(adrPath, generateADRMarkdown(adr), "utf-8");
       paths.push(adrPath);
     }
     return paths;
   }
   async saveBacklog(projectPath, backlogResult) {
-    const dir = path37__default.join(projectPath, ".coco", "planning");
-    await fs34__default.mkdir(dir, { recursive: true });
-    const mdPath = path37__default.join(dir, "BACKLOG.md");
-    await fs34__default.writeFile(mdPath, generateBacklogMarkdown(backlogResult.backlog), "utf-8");
-    const jsonPath = path37__default.join(dir, "backlog.json");
-    await fs34__default.writeFile(jsonPath, JSON.stringify(backlogResult, null, 2), "utf-8");
+    const dir = path38__default.join(projectPath, ".coco", "planning");
+    await fs35__default.mkdir(dir, { recursive: true });
+    const mdPath = path38__default.join(dir, "BACKLOG.md");
+    await fs35__default.writeFile(mdPath, generateBacklogMarkdown(backlogResult.backlog), "utf-8");
+    const jsonPath = path38__default.join(dir, "backlog.json");
+    await fs35__default.writeFile(jsonPath, JSON.stringify(backlogResult, null, 2), "utf-8");
     return mdPath;
   }
   async saveSprint(projectPath, sprint, backlogResult) {
-    const dir = path37__default.join(projectPath, ".coco", "planning", "sprints");
-    await fs34__default.mkdir(dir, { recursive: true });
+    const dir = path38__default.join(projectPath, ".coco", "planning", "sprints");
+    await fs35__default.mkdir(dir, { recursive: true });
     const filename = `${sprint.id}.md`;
-    const sprintPath = path37__default.join(dir, filename);
-    await fs34__default.writeFile(sprintPath, generateSprintMarkdown(sprint, backlogResult.backlog), "utf-8");
-    const jsonPath = path37__default.join(dir, `${sprint.id}.json`);
-    await fs34__default.writeFile(jsonPath, JSON.stringify(sprint, null, 2), "utf-8");
+    const sprintPath = path38__default.join(dir, filename);
+    await fs35__default.writeFile(sprintPath, generateSprintMarkdown(sprint, backlogResult.backlog), "utf-8");
+    const jsonPath = path38__default.join(dir, `${sprint.id}.json`);
+    await fs35__default.writeFile(jsonPath, JSON.stringify(sprint, null, 2), "utf-8");
     return sprintPath;
   }
   async saveDiagram(projectPath, id, mermaid) {
-    const dir = path37__default.join(projectPath, ".coco", "architecture", "diagrams");
-    await fs34__default.mkdir(dir, { recursive: true });
-    const diagramPath = path37__default.join(dir, `${id}.mmd`);
-    await fs34__default.writeFile(diagramPath, mermaid, "utf-8");
+    const dir = path38__default.join(projectPath, ".coco", "architecture", "diagrams");
+    await fs35__default.mkdir(dir, { recursive: true });
+    const diagramPath = path38__default.join(dir, `${id}.mmd`);
+    await fs35__default.writeFile(diagramPath, mermaid, "utf-8");
     return diagramPath;
   }
 };
@@ -27456,20 +27878,20 @@ async function createCliPhaseContext(projectPath, _onUserInput) {
     },
     tools: {
       file: {
-        async read(path59) {
-          const fs55 = await import('fs/promises');
-          return fs55.readFile(path59, "utf-8");
+        async read(path60) {
+          const fs56 = await import('fs/promises');
+          return fs56.readFile(path60, "utf-8");
         },
-        async write(path59, content) {
-          const fs55 = await import('fs/promises');
+        async write(path60, content) {
+          const fs56 = await import('fs/promises');
           const nodePath = await import('path');
-          await fs55.mkdir(nodePath.dirname(path59), { recursive: true });
-          await fs55.writeFile(path59, content, "utf-8");
+          await fs56.mkdir(nodePath.dirname(path60), { recursive: true });
+          await fs56.writeFile(path60, content, "utf-8");
         },
-        async exists(path59) {
-          const fs55 = await import('fs/promises');
+        async exists(path60) {
+          const fs56 = await import('fs/promises');
           try {
-            await fs55.access(path59);
+            await fs56.access(path60);
             return true;
           } catch {
             return false;
@@ -27708,16 +28130,16 @@ async function loadTasks(_options) {
   ];
 }
 async function checkProjectState() {
-  const fs55 = await import('fs/promises');
+  const fs56 = await import('fs/promises');
   let hasProject = false;
   let hasPlan = false;
   try {
-    await fs55.access(".coco");
+    await fs56.access(".coco");
     hasProject = true;
   } catch {
   }
   try {
-    await fs55.access(".coco/planning/backlog.json");
+    await fs56.access(".coco/planning/backlog.json");
     hasPlan = true;
   } catch {
   }
@@ -27824,24 +28246,24 @@ function getPhaseStatusForPhase(phase) {
   return "in_progress";
 }
 async function loadProjectState(cwd, config) {
-  const fs55 = await import('fs/promises');
-  const path59 = await import('path');
-  const statePath = path59.join(cwd, ".coco", "state.json");
-  const backlogPath = path59.join(cwd, ".coco", "planning", "backlog.json");
-  const checkpointDir = path59.join(cwd, ".coco", "checkpoints");
+  const fs56 = await import('fs/promises');
+  const path60 = await import('path');
+  const statePath = path60.join(cwd, ".coco", "state.json");
+  const backlogPath = path60.join(cwd, ".coco", "planning", "backlog.json");
+  const checkpointDir = path60.join(cwd, ".coco", "checkpoints");
   let currentPhase = "idle";
   let metrics;
   let sprint;
   let checkpoints = [];
   try {
-    const stateContent = await fs55.readFile(statePath, "utf-8");
+    const stateContent = await fs56.readFile(statePath, "utf-8");
     const stateData = JSON.parse(stateContent);
     currentPhase = stateData.currentPhase || "idle";
     metrics = stateData.metrics;
   } catch {
   }
   try {
-    const backlogContent = await fs55.readFile(backlogPath, "utf-8");
+    const backlogContent = await fs56.readFile(backlogPath, "utf-8");
     const backlogData = JSON.parse(backlogContent);
     if (backlogData.currentSprint) {
       const tasks = backlogData.tasks || [];
@@ -27863,7 +28285,7 @@ async function loadProjectState(cwd, config) {
   } catch {
   }
   try {
-    const files = await fs55.readdir(checkpointDir);
+    const files = await fs56.readdir(checkpointDir);
     checkpoints = files.filter((f) => f.endsWith(".json")).sort().reverse();
   } catch {
   }
@@ -27999,8 +28421,8 @@ async function restoreFromCheckpoint(_checkpoint) {
 }
 async function checkProjectExists() {
   try {
-    const fs55 = await import('fs/promises');
-    await fs55.access(".coco");
+    const fs56 = await import('fs/promises');
+    await fs56.access(".coco");
     return true;
   } catch {
     return false;
@@ -29215,9 +29637,9 @@ var DEFAULT_CONFIG2 = {
   }
 };
 async function loadConfig2() {
-  const fs55 = await import('fs/promises');
+  const fs56 = await import('fs/promises');
   try {
-    const raw = await fs55.readFile(CONFIG_PATH, "utf-8");
+    const raw = await fs56.readFile(CONFIG_PATH, "utf-8");
     const parsed = JSON.parse(raw);
     return { ...DEFAULT_CONFIG2, ...parsed };
   } catch {
@@ -29225,13 +29647,13 @@ async function loadConfig2() {
   }
 }
 async function saveConfig2(config) {
-  const fs55 = await import('fs/promises');
+  const fs56 = await import('fs/promises');
   const dir = join(CONFIG_PATH, "..");
-  await fs55.mkdir(dir, { recursive: true });
-  await fs55.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2));
+  await fs56.mkdir(dir, { recursive: true });
+  await fs56.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2));
 }
-function getNestedValue(obj, path59) {
-  const keys = path59.split(".");
+function getNestedValue(obj, path60) {
+  const keys = path60.split(".");
   let current = obj;
   for (const key of keys) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -29241,8 +29663,8 @@ function getNestedValue(obj, path59) {
   }
   return current;
 }
-function setNestedValue(obj, path59, value) {
-  const keys = path59.split(".");
+function setNestedValue(obj, path60, value) {
+  const keys = path60.split(".");
   let current = obj;
   for (let i = 0; i < keys.length - 1; i++) {
     const key = keys[i];
@@ -29608,13 +30030,13 @@ async function runAdd(source, options) {
   const isGithubShorthand = source.includes("/") && !isGitUrl;
   const isLocalPath = source.startsWith(".") || source.startsWith("/");
   if (isLocalPath) {
-    const targetDir = options.global ? CONFIG_PATHS.skills : path37__default.join(process.cwd(), ".agents", "skills");
-    const sourcePath = path37__default.resolve(source);
-    const skillName = path37__default.basename(sourcePath);
-    const destPath = path37__default.join(targetDir, skillName);
+    const targetDir = options.global ? CONFIG_PATHS.skills : path38__default.join(process.cwd(), ".agents", "skills");
+    const sourcePath = path38__default.resolve(source);
+    const skillName = path38__default.basename(sourcePath);
+    const destPath = path38__default.join(targetDir, skillName);
     try {
-      await fs34__default.mkdir(targetDir, { recursive: true });
-      await fs34__default.cp(sourcePath, destPath, { recursive: true });
+      await fs35__default.mkdir(targetDir, { recursive: true });
+      await fs35__default.cp(sourcePath, destPath, { recursive: true });
       p26.log.success(`Installed "${skillName}" to ${destPath}`);
     } catch (error) {
       p26.log.error(
@@ -29645,10 +30067,10 @@ async function runAdd(source, options) {
       p26.log.info("Try installing manually: git clone the repo into .agents/skills/");
     }
   } else if (isGitUrl) {
-    const targetDir = options.global ? CONFIG_PATHS.skills : path37__default.join(process.cwd(), ".agents", "skills");
-    await fs34__default.mkdir(targetDir, { recursive: true });
+    const targetDir = options.global ? CONFIG_PATHS.skills : path38__default.join(process.cwd(), ".agents", "skills");
+    await fs35__default.mkdir(targetDir, { recursive: true });
     const skillName = source.split("/").pop()?.replace(".git", "") ?? "skill";
-    const skillDir = path37__default.join(targetDir, skillName);
+    const skillDir = path38__default.join(targetDir, skillName);
     const spinner18 = p26.spinner();
     spinner18.start(`Cloning ${source}...`);
     try {
@@ -29674,15 +30096,15 @@ async function runAdd(source, options) {
 }
 async function runRemove(name, options) {
   p26.intro(chalk.magenta("Remove Skill"));
-  const targetDir = options.global ? CONFIG_PATHS.skills : path37__default.join(process.cwd(), ".agents", "skills");
-  const skillPath = path37__default.resolve(targetDir, name);
-  if (!skillPath.startsWith(path37__default.resolve(targetDir) + path37__default.sep)) {
+  const targetDir = options.global ? CONFIG_PATHS.skills : path38__default.join(process.cwd(), ".agents", "skills");
+  const skillPath = path38__default.resolve(targetDir, name);
+  if (!skillPath.startsWith(path38__default.resolve(targetDir) + path38__default.sep)) {
     p26.log.error(`Invalid skill name: "${name}"`);
     p26.outro("");
     return;
   }
   try {
-    await fs34__default.access(skillPath);
+    await fs35__default.access(skillPath);
   } catch {
     p26.log.error(`Skill "${name}" not found at ${skillPath}`);
     p26.outro("");
@@ -29698,7 +30120,7 @@ async function runRemove(name, options) {
       return;
     }
   }
-  await fs34__default.rm(skillPath, { recursive: true });
+  await fs35__default.rm(skillPath, { recursive: true });
   p26.log.success(`Removed "${name}"`);
   p26.outro("");
 }
@@ -29760,10 +30182,10 @@ async function runInfo(name) {
 }
 async function runCreate(name, options) {
   p26.intro(chalk.magenta("Create Skill"));
-  const targetDir = options.global ? CONFIG_PATHS.skills : path37__default.join(process.cwd(), ".agents", "skills");
-  const skillDir = path37__default.join(targetDir, name);
+  const targetDir = options.global ? CONFIG_PATHS.skills : path38__default.join(process.cwd(), ".agents", "skills");
+  const skillDir = path38__default.join(targetDir, name);
   try {
-    await fs34__default.access(skillDir);
+    await fs35__default.access(skillDir);
     p26.log.error(`Skill "${name}" already exists at ${skillDir}`);
     p26.outro("");
     return;
@@ -29792,7 +30214,7 @@ async function runCreate(name, options) {
     p26.outro("Cancelled.");
     return;
   }
-  await fs34__default.mkdir(skillDir, { recursive: true });
+  await fs35__default.mkdir(skillDir, { recursive: true });
   const skillMd = `---
 name: "${name}"
 description: "${description}"
@@ -29814,10 +30236,10 @@ when this skill is activated (automatically via matching or manually via /${name
 2. Include examples when helpful
 3. Keep instructions under 500 lines
 `;
-  await fs34__default.writeFile(path37__default.join(skillDir, "SKILL.md"), skillMd, "utf-8");
-  await fs34__default.mkdir(path37__default.join(skillDir, "references"), { recursive: true });
+  await fs35__default.writeFile(path38__default.join(skillDir, "SKILL.md"), skillMd, "utf-8");
+  await fs35__default.mkdir(path38__default.join(skillDir, "references"), { recursive: true });
   p26.log.success(`Created skill at ${skillDir}`);
-  p26.log.info(`Edit ${path37__default.join(skillDir, "SKILL.md")} to add instructions.`);
+  p26.log.info(`Edit ${path38__default.join(skillDir, "SKILL.md")} to add instructions.`);
   p26.outro("");
 }
 function registerWinner(winners, candidate, candidateScanOrder, scanOrderById) {
@@ -30273,10 +30695,10 @@ function registerCheckCommand(program2) {
 
 // src/swarm/spec-parser.ts
 async function parseSwarmSpec(filePath) {
-  const fs55 = await import('fs/promises');
-  const path59 = await import('path');
-  const rawContent = await fs55.readFile(filePath, "utf-8");
-  const ext = path59.extname(filePath).toLowerCase();
+  const fs56 = await import('fs/promises');
+  const path60 = await import('path');
+  const rawContent = await fs56.readFile(filePath, "utf-8");
+  const ext = path60.extname(filePath).toLowerCase();
   if (ext === ".yaml" || ext === ".yml") {
     return parseYamlSpec(rawContent);
   }
@@ -30605,11 +31027,11 @@ var DEFAULT_AGENT_CONFIG = {
   integrator: { maxTurns: 20, temperature: 0.2 }
 };
 async function loadAgentConfig(projectPath) {
-  const fs55 = await import('fs/promises');
-  const path59 = await import('path');
-  const configPath = path59.join(projectPath, ".coco", "swarm", "agents.json");
+  const fs56 = await import('fs/promises');
+  const path60 = await import('path');
+  const configPath = path60.join(projectPath, ".coco", "swarm", "agents.json");
   try {
-    const raw = await fs55.readFile(configPath, "utf-8");
+    const raw = await fs56.readFile(configPath, "utf-8");
     const parsed = JSON.parse(raw);
     const merged = { ...DEFAULT_AGENT_CONFIG };
     for (const role of Object.keys(DEFAULT_AGENT_CONFIG)) {
@@ -30797,19 +31219,19 @@ async function createBoard(projectPath, spec) {
   return board;
 }
 async function loadBoard(projectPath) {
-  const fs55 = await import('fs/promises');
-  const path59 = await import('path');
-  const boardPath = path59.join(projectPath, ".coco", "swarm", "task-board.json");
-  const raw = await fs55.readFile(boardPath, "utf-8");
+  const fs56 = await import('fs/promises');
+  const path60 = await import('path');
+  const boardPath = path60.join(projectPath, ".coco", "swarm", "task-board.json");
+  const raw = await fs56.readFile(boardPath, "utf-8");
   return JSON.parse(raw);
 }
 async function saveBoard(projectPath, board) {
-  const fs55 = await import('fs/promises');
-  const path59 = await import('path');
-  const boardDir = path59.join(projectPath, ".coco", "swarm");
-  const boardPath = path59.join(boardDir, "task-board.json");
-  await fs55.mkdir(boardDir, { recursive: true });
-  await fs55.writeFile(boardPath, JSON.stringify(board, null, 2), "utf-8");
+  const fs56 = await import('fs/promises');
+  const path60 = await import('path');
+  const boardDir = path60.join(projectPath, ".coco", "swarm");
+  const boardPath = path60.join(boardDir, "task-board.json");
+  await fs56.mkdir(boardDir, { recursive: true });
+  await fs56.writeFile(boardPath, JSON.stringify(board, null, 2), "utf-8");
 }
 function markTaskInProgress(board, taskId, role) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -30974,11 +31396,11 @@ async function defaultPromptHandler(q) {
   }
 }
 async function writeAssumptionsFile(projectPath, projectName, questions, assumptions) {
-  const fs55 = await import('fs/promises');
-  const path59 = await import('path');
-  const swarmDir = path59.join(projectPath, ".coco", "swarm");
-  const assumptionsPath = path59.join(swarmDir, "assumptions.md");
-  await fs55.mkdir(swarmDir, { recursive: true });
+  const fs56 = await import('fs/promises');
+  const path60 = await import('path');
+  const swarmDir = path60.join(projectPath, ".coco", "swarm");
+  const assumptionsPath = path60.join(swarmDir, "assumptions.md");
+  await fs56.mkdir(swarmDir, { recursive: true });
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const content = [
     `# Swarm Assumptions \u2014 ${projectName}`,
@@ -30994,18 +31416,18 @@ async function writeAssumptionsFile(projectPath, projectName, questions, assumpt
     assumptions.length > 0 ? assumptions.join("\n\n") : `_(none)_`,
     ``
   ].join("\n");
-  await fs55.writeFile(assumptionsPath, content, "utf-8");
+  await fs56.writeFile(assumptionsPath, content, "utf-8");
   return assumptionsPath;
 }
 
 // src/swarm/events.ts
 async function appendSwarmEvent(projectPath, event) {
-  const fs55 = await import('fs/promises');
-  const path59 = await import('path');
-  const eventsDir = path59.join(projectPath, ".coco", "swarm");
-  const eventsFile = path59.join(eventsDir, "events.jsonl");
-  await fs55.mkdir(eventsDir, { recursive: true });
-  await fs55.appendFile(eventsFile, JSON.stringify(event) + "\n", "utf-8");
+  const fs56 = await import('fs/promises');
+  const path60 = await import('path');
+  const eventsDir = path60.join(projectPath, ".coco", "swarm");
+  const eventsFile = path60.join(eventsDir, "events.jsonl");
+  await fs56.mkdir(eventsDir, { recursive: true });
+  await fs56.appendFile(eventsFile, JSON.stringify(event) + "\n", "utf-8");
 }
 function createEventId() {
   return `evt-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
@@ -31013,12 +31435,12 @@ function createEventId() {
 
 // src/swarm/knowledge.ts
 async function appendKnowledge(projectPath, entry) {
-  const fs55 = await import('fs/promises');
-  const path59 = await import('path');
-  const knowledgeDir = path59.join(projectPath, ".coco", "swarm");
-  const knowledgeFile = path59.join(knowledgeDir, "knowledge.jsonl");
-  await fs55.mkdir(knowledgeDir, { recursive: true });
-  await fs55.appendFile(knowledgeFile, JSON.stringify(entry) + "\n", "utf-8");
+  const fs56 = await import('fs/promises');
+  const path60 = await import('path');
+  const knowledgeDir = path60.join(projectPath, ".coco", "swarm");
+  const knowledgeFile = path60.join(knowledgeDir, "knowledge.jsonl");
+  await fs56.mkdir(knowledgeDir, { recursive: true });
+  await fs56.appendFile(knowledgeFile, JSON.stringify(entry) + "\n", "utf-8");
 }
 
 // src/swarm/agents/prompts.ts
@@ -31322,11 +31744,11 @@ async function runSwarmLifecycle(options) {
 }
 async function stageInit(ctx) {
   const { projectPath, spec } = ctx.options;
-  const fs55 = await import('fs/promises');
-  const path59 = await import('path');
-  await fs55.mkdir(path59.join(projectPath, ".coco", "swarm"), { recursive: true });
-  await fs55.mkdir(ctx.options.outputPath, { recursive: true });
-  const specSummaryPath = path59.join(projectPath, ".coco", "swarm", "spec-summary.json");
+  const fs56 = await import('fs/promises');
+  const path60 = await import('path');
+  await fs56.mkdir(path60.join(projectPath, ".coco", "swarm"), { recursive: true });
+  await fs56.mkdir(ctx.options.outputPath, { recursive: true });
+  const specSummaryPath = path60.join(projectPath, ".coco", "swarm", "spec-summary.json");
   const specSummary = {
     projectName: spec.projectName,
     description: spec.description,
@@ -31340,7 +31762,7 @@ async function stageInit(ctx) {
     })),
     qualityConfig: spec.qualityConfig
   };
-  await fs55.writeFile(specSummaryPath, JSON.stringify(specSummary, null, 2), "utf-8");
+  await fs56.writeFile(specSummaryPath, JSON.stringify(specSummary, null, 2), "utf-8");
   await emitEvent(projectPath, {
     agentRole: "pm",
     agentTurn: 0,
@@ -31397,10 +31819,10 @@ async function stagePlan(ctx) {
     })
   ]);
   await createBoard(projectPath, spec);
-  const fs55 = await import('fs/promises');
-  const path59 = await import('path');
-  const planPath = path59.join(projectPath, ".coco", "swarm", "plan.json");
-  await fs55.writeFile(
+  const fs56 = await import('fs/promises');
+  const path60 = await import('path');
+  const planPath = path60.join(projectPath, ".coco", "swarm", "plan.json");
+  await fs56.writeFile(
     planPath,
     JSON.stringify({ pm: pmResult, architect: archResult, bestPractices: bpResult }, null, 2),
     "utf-8"
@@ -31615,8 +32037,8 @@ async function stageIntegrate(ctx) {
 }
 async function stageOutput(ctx) {
   const { projectPath, outputPath } = ctx.options;
-  const fs55 = await import('fs/promises');
-  const path59 = await import('path');
+  const fs56 = await import('fs/promises');
+  const path60 = await import('path');
   const board = await loadBoard(projectPath);
   const featureResults = Array.from(ctx.featureResults.values());
   const summary = {
@@ -31630,9 +32052,9 @@ async function stageOutput(ctx) {
     },
     globalScore: computeGlobalScore(featureResults)
   };
-  await fs55.mkdir(outputPath, { recursive: true });
-  const summaryPath = path59.join(outputPath, "swarm-summary.json");
-  await fs55.writeFile(summaryPath, JSON.stringify(summary, null, 2), "utf-8");
+  await fs56.mkdir(outputPath, { recursive: true });
+  const summaryPath = path60.join(outputPath, "swarm-summary.json");
+  await fs56.writeFile(summaryPath, JSON.stringify(summary, null, 2), "utf-8");
   const passed = summary.globalScore >= ctx.options.minScore;
   await emitGate(projectPath, "global-score", passed, `Global score: ${summary.globalScore}`);
   await emitEvent(projectPath, {
@@ -31978,8 +32400,8 @@ var SwarmOrchestrator = class {
       noQuestions = false,
       onProgress
     } = options;
-    const path59 = await import('path');
-    const projectPath = path59.dirname(path59.resolve(specFile));
+    const path60 = await import('path');
+    const projectPath = path60.dirname(path60.resolve(specFile));
     onProgress?.("init", `Parsing spec file: ${specFile}`);
     const spec = await parseSwarmSpec(specFile);
     onProgress?.("init", `Initializing provider: ${providerType}`);
@@ -31990,7 +32412,7 @@ var SwarmOrchestrator = class {
     await runSwarmLifecycle({
       spec,
       projectPath,
-      outputPath: path59.resolve(outputPath),
+      outputPath: path60.resolve(outputPath),
       provider,
       agentConfig,
       minScore,
@@ -32828,8 +33250,8 @@ async function setupGcloudADC(provider) {
     console.log(chalk.dim("   (Complete the sign-in in your browser, then return here)"));
     console.log();
     const { exec: exec3 } = await import('child_process');
-    const { promisify: promisify5 } = await import('util');
-    const execAsync3 = promisify5(exec3);
+    const { promisify: promisify6 } = await import('util');
+    const execAsync3 = promisify6(exec3);
     try {
       await execAsync3("gcloud auth application-default login", {
         timeout: 12e4
@@ -33514,15 +33936,15 @@ async function saveConfiguration(result) {
 }
 async function saveEnvVars(filePath, vars, createDir = false) {
   if (createDir) {
-    const dir = path37.dirname(filePath);
+    const dir = path38.dirname(filePath);
     try {
-      await fs34.mkdir(dir, { recursive: true, mode: 448 });
+      await fs35.mkdir(dir, { recursive: true, mode: 448 });
     } catch {
     }
   }
   let existingVars = {};
   try {
-    const content = await fs34.readFile(filePath, "utf-8");
+    const content = await fs35.readFile(filePath, "utf-8");
     for (const line of content.split("\n")) {
       const trimmed = line.trim();
       if (trimmed && !trimmed.startsWith("#")) {
@@ -33545,7 +33967,7 @@ async function saveEnvVars(filePath, vars, createDir = false) {
   for (const [key, value] of Object.entries(allVars)) {
     lines.push(`${key}=${value}`);
   }
-  await fs34.writeFile(filePath, lines.join("\n") + "\n", { mode: 384 });
+  await fs35.writeFile(filePath, lines.join("\n") + "\n", { mode: 384 });
 }
 async function handleLocalProviderUnavailable(providerType, config) {
   const cfg = LOCAL_PROVIDER_CONFIG[providerType];
@@ -33635,6 +34057,7 @@ async function ensureConfiguredV2(config) {
   const preferredHasCopilotCreds = preferredProviderDef?.id === "copilot" && isProviderConfigured();
   const preferredIsConfigured = preferredIsLocal || preferredHasApiKey || preferredHasOpenAIOAuth || preferredHasCopilotCreds;
   let preferredWasConfiguredButUnavailable = false;
+  let preferredUnavailableWasLocal = false;
   if (preferredProviderDef && preferredIsConfigured) {
     try {
       const preferredInternalProviderId = preferredProviderDef.id === "openai" && preferredHasOpenAIOAuth ? "codex" : preferredProviderDef.id;
@@ -33654,8 +34077,9 @@ async function ensureConfiguredV2(config) {
       if (retryResult !== null) return retryResult;
     }
     preferredWasConfiguredButUnavailable = true;
+    preferredUnavailableWasLocal = preferredIsLocal;
   }
-  if (!preferredWasConfiguredButUnavailable) {
+  if (!preferredWasConfiguredButUnavailable || !preferredUnavailableWasLocal) {
     const configuredProviders = providers.filter((p45) => {
       if (p45.id === "copilot") return isProviderConfigured();
       if (p45.id === "openai") {
@@ -33676,6 +34100,7 @@ async function ensureConfiguredV2(config) {
         }
         const provider = await createProvider(providerId, { model });
         if (await provider.isAvailable()) {
+          await saveProviderPreference(prov.id, model);
           return {
             ...config,
             provider: {
@@ -33690,7 +34115,7 @@ async function ensureConfiguredV2(config) {
       }
     }
   }
-  if (config.provider.type !== "openai" && config.provider.type !== "codex" && hasOpenAIOAuthTokens && !preferredWasConfiguredButUnavailable) {
+  if (config.provider.type !== "openai" && config.provider.type !== "codex" && hasOpenAIOAuthTokens && (!preferredWasConfiguredButUnavailable || !preferredUnavailableWasLocal)) {
     try {
       const tokenResult = await getOrRefreshOAuthToken("openai");
       if (tokenResult) {
@@ -34174,8 +34599,8 @@ async function setupGcloudADCForProvider(_provider) {
     return false;
   }
   const { exec: exec3 } = await import('child_process');
-  const { promisify: promisify5 } = await import('util');
-  const execAsync3 = promisify5(exec3);
+  const { promisify: promisify6 } = await import('util');
+  const execAsync3 = promisify6(exec3);
   try {
     await execAsync3("gcloud auth application-default login", { timeout: 12e4 });
     const token = await getADCAccessToken();
@@ -34911,8 +35336,8 @@ async function listTrustedProjects2(trustStore) {
   p26.log.message("");
   for (const project of projects) {
     const level = project.approvalLevel.toUpperCase().padEnd(5);
-    const path59 = project.path.length > 50 ? "..." + project.path.slice(-47) : project.path;
-    p26.log.message(`  [${level}] ${path59}`);
+    const path60 = project.path.length > 50 ? "..." + project.path.slice(-47) : project.path;
+    p26.log.message(`  [${level}] ${path60}`);
     p26.log.message(`      Last accessed: ${new Date(project.lastAccessed).toLocaleString()}`);
   }
   p26.log.message("");
@@ -35082,8 +35507,8 @@ var buildCommand = {
 };
 async function loadBacklog(projectPath) {
   try {
-    const backlogPath = path37.join(projectPath, ".coco", "planning", "backlog.json");
-    const content = await fs34.readFile(backlogPath, "utf-8");
+    const backlogPath = path38.join(projectPath, ".coco", "planning", "backlog.json");
+    const content = await fs35.readFile(backlogPath, "utf-8");
     const data = JSON.parse(content);
     return data.backlog;
   } catch {
@@ -35092,25 +35517,25 @@ async function loadBacklog(projectPath) {
 }
 async function loadSprint(projectPath, sprintId) {
   try {
-    const sprintsDir = path37.join(projectPath, ".coco", "planning", "sprints");
-    const files = await fs34.readdir(sprintsDir);
+    const sprintsDir = path38.join(projectPath, ".coco", "planning", "sprints");
+    const files = await fs35.readdir(sprintsDir);
     const jsonFiles = files.filter((f) => f.endsWith(".json"));
     if (jsonFiles.length === 0) return null;
     const targetFile = sprintId ? jsonFiles.find((f) => f.includes(sprintId)) : jsonFiles[0];
     if (!targetFile) return null;
-    const sprintPath = path37.join(sprintsDir, targetFile);
-    const content = await fs34.readFile(sprintPath, "utf-8");
+    const sprintPath = path38.join(sprintsDir, targetFile);
+    const content = await fs35.readFile(sprintPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 async function saveBacklog(projectPath, backlog) {
-  const backlogPath = path37.join(projectPath, ".coco", "planning", "backlog.json");
-  const content = await fs34.readFile(backlogPath, "utf-8");
+  const backlogPath = path38.join(projectPath, ".coco", "planning", "backlog.json");
+  const content = await fs35.readFile(backlogPath, "utf-8");
   const data = JSON.parse(content);
   data.backlog = backlog;
-  await fs34.writeFile(backlogPath, JSON.stringify(data, null, 2), "utf-8");
+  await fs35.writeFile(backlogPath, JSON.stringify(data, null, 2), "utf-8");
 }
 function getStatusEmoji(status) {
   const emojis = {
@@ -35816,7 +36241,7 @@ function getLevelName(level) {
 function displayMemoryFile(file) {
   const { emoji, color } = getLevelStyle(file.level);
   const levelName = getLevelName(file.level);
-  const fileName = path37__default.basename(file.path);
+  const fileName = path38__default.basename(file.path);
   console.log();
   console.log(
     `${emoji} ${color.bold(levelName)} ${chalk.dim(`(${fileName})`)} ${chalk.dim(file.path)}`
@@ -35911,7 +36336,7 @@ var memoryCommand = {
           )
         );
         for (const f of reloaded) {
-          const fileName = path37__default.basename(f.path);
+          const fileName = path38__default.basename(f.path);
           console.log(chalk.dim(`  ${fileName} (${formatSize(f.content?.length ?? 0)})`));
         }
       } else {
@@ -36053,7 +36478,7 @@ async function getCheckpoint(session, checkpointId) {
   return store.checkpoints.find((cp) => cp.id === checkpointId) ?? null;
 }
 async function restoreFiles(checkpoint, excludeFiles) {
-  const fs55 = await import('fs/promises');
+  const fs56 = await import('fs/promises');
   const restored = [];
   const failed = [];
   for (const fileCheckpoint of checkpoint.files) {
@@ -36061,7 +36486,7 @@ async function restoreFiles(checkpoint, excludeFiles) {
       continue;
     }
     try {
-      await fs55.writeFile(fileCheckpoint.filePath, fileCheckpoint.originalContent, "utf-8");
+      await fs56.writeFile(fileCheckpoint.filePath, fileCheckpoint.originalContent, "utf-8");
       restored.push(fileCheckpoint.filePath);
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
@@ -36143,8 +36568,8 @@ function displayRewindResult(result) {
     const fileName = filePath.split("/").pop() ?? filePath;
     console.log(`${chalk.green(String.fromCodePoint(10003))} Restored: ${fileName}`);
   }
-  for (const { path: path59, error } of result.filesFailed) {
-    const fileName = path59.split("/").pop() ?? path59;
+  for (const { path: path60, error } of result.filesFailed) {
+    const fileName = path60.split("/").pop() ?? path60;
     console.log(`${chalk.red(String.fromCodePoint(10007))} Failed: ${fileName} (${error})`);
   }
   if (result.conversationRestored) {
@@ -36782,8 +37207,8 @@ var NPM_REGISTRY_URL = "https://registry.npmjs.org/@corbat-tech/coco/latest";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 5e3;
 var STARTUP_TIMEOUT_MS = 5500;
-var CACHE_DIR = path37__default.join(os4__default.homedir(), ".coco");
-var CACHE_FILE = path37__default.join(CACHE_DIR, "version-check-cache.json");
+var CACHE_DIR = path38__default.join(os4__default.homedir(), ".coco");
+var CACHE_FILE = path38__default.join(CACHE_DIR, "version-check-cache.json");
 function compareVersions(a, b) {
   const partsA = a.replace(/^v/, "").split(".").map((p45) => Number(p45.replace(/-.*$/, "")));
   const partsB = b.replace(/^v/, "").split(".").map((p45) => Number(p45.replace(/-.*$/, "")));
@@ -37125,7 +37550,7 @@ async function readClipboardImage() {
   return null;
 }
 async function readClipboardImageMacOS() {
-  const tmpFile = path37.join(os4.tmpdir(), `coco-clipboard-${Date.now()}.png`);
+  const tmpFile = path38.join(os4.tmpdir(), `coco-clipboard-${Date.now()}.png`);
   try {
     const script = `
 set theFile to POSIX file "${tmpFile}"
@@ -37148,7 +37573,7 @@ end try
     if (!result.startsWith("ok")) {
       return null;
     }
-    const buffer = await fs34.readFile(tmpFile);
+    const buffer = await fs35.readFile(tmpFile);
     return {
       data: buffer.toString("base64"),
       media_type: "image/png"
@@ -37157,7 +37582,7 @@ end try
     return null;
   } finally {
     try {
-      await fs34.unlink(tmpFile);
+      await fs35.unlink(tmpFile);
     } catch {
     }
   }
@@ -37187,7 +37612,7 @@ async function readClipboardImageLinux() {
   }
 }
 async function readClipboardImageWindows() {
-  const tmpFile = path37.join(os4.tmpdir(), `coco-clipboard-${Date.now()}.png`);
+  const tmpFile = path38.join(os4.tmpdir(), `coco-clipboard-${Date.now()}.png`);
   try {
     const escapedPath = tmpFile.replace(/'/g, "''");
     const script = `
@@ -37205,7 +37630,7 @@ if ($img -ne $null) {
       timeout: 1e4
     }).trim();
     if (result !== "ok") return null;
-    const buffer = await fs34.readFile(tmpFile);
+    const buffer = await fs35.readFile(tmpFile);
     return {
       data: buffer.toString("base64"),
       media_type: "image/png"
@@ -37214,7 +37639,7 @@ if ($img -ne $null) {
     return null;
   } finally {
     try {
-      await fs34.unlink(tmpFile);
+      await fs35.unlink(tmpFile);
     } catch {
     }
   }
@@ -37312,9 +37737,9 @@ var allowPathCommand = {
   }
 };
 async function addPath(dirPath, session) {
-  const absolute = path37__default.resolve(dirPath);
+  const absolute = path38__default.resolve(dirPath);
   try {
-    const stat2 = await fs34__default.stat(absolute);
+    const stat2 = await fs35__default.stat(absolute);
     if (!stat2.isDirectory()) {
       p26.log.error(`Not a directory: ${absolute}`);
       return;
@@ -37324,19 +37749,19 @@ async function addPath(dirPath, session) {
     return;
   }
   for (const blocked of BLOCKED_SYSTEM_PATHS) {
-    const normalizedBlocked = path37__default.normalize(blocked);
-    if (absolute === normalizedBlocked || absolute.startsWith(normalizedBlocked + path37__default.sep)) {
+    const normalizedBlocked = path38__default.normalize(blocked);
+    if (absolute === normalizedBlocked || absolute.startsWith(normalizedBlocked + path38__default.sep)) {
       p26.log.error(`System path '${blocked}' cannot be allowed`);
       return;
     }
   }
-  const normalizedCwd = path37__default.normalize(session.projectPath);
-  if (absolute === normalizedCwd || absolute.startsWith(normalizedCwd + path37__default.sep)) {
+  const normalizedCwd = path38__default.normalize(session.projectPath);
+  if (absolute === normalizedCwd || absolute.startsWith(normalizedCwd + path38__default.sep)) {
     p26.log.info("That path is already within the project directory");
     return;
   }
   const existing = getAllowedPaths();
-  if (existing.some((e) => path37__default.normalize(e.path) === path37__default.normalize(absolute))) {
+  if (existing.some((e) => path38__default.normalize(e.path) === path38__default.normalize(absolute))) {
     p26.log.info(`Already allowed: ${absolute}`);
     return;
   }
@@ -37407,7 +37832,7 @@ async function revokePath(dirPath, _session) {
     }
     dirPath = selected;
   }
-  const absolute = path37__default.resolve(dirPath);
+  const absolute = path38__default.resolve(dirPath);
   const removed = removeAllowedPathFromSession(absolute);
   await removePersistedAllowedPath(absolute);
   if (removed) {
@@ -37760,11 +38185,12 @@ var RECOMMENDED_DENY = [
 ];
 async function loadPermissionPreferences() {
   try {
-    const content = await fs34__default.readFile(CONFIG_PATHS.config, "utf-8");
+    const content = await fs35__default.readFile(CONFIG_PATHS.config, "utf-8");
     const config = JSON.parse(content);
     return {
       recommendedAllowlistApplied: config.recommendedAllowlistApplied,
-      recommendedAllowlistDismissed: config.recommendedAllowlistDismissed
+      recommendedAllowlistDismissed: config.recommendedAllowlistDismissed,
+      recommendedAllowlistPrompted: config.recommendedAllowlistPrompted
     };
   } catch {
     return {};
@@ -37774,34 +38200,28 @@ async function savePermissionPreference(key, value) {
   try {
     let config = {};
     try {
-      const content = await fs34__default.readFile(CONFIG_PATHS.config, "utf-8");
+      const content = await fs35__default.readFile(CONFIG_PATHS.config, "utf-8");
       config = JSON.parse(content);
     } catch {
     }
     config[key] = value;
-    await fs34__default.mkdir(path37__default.dirname(CONFIG_PATHS.config), { recursive: true });
-    await fs34__default.writeFile(CONFIG_PATHS.config, JSON.stringify(config, null, 2), "utf-8");
+    await fs35__default.mkdir(path38__default.dirname(CONFIG_PATHS.config), { recursive: true });
+    await fs35__default.writeFile(CONFIG_PATHS.config, JSON.stringify(config, null, 2), "utf-8");
   } catch {
   }
 }
 async function shouldShowPermissionSuggestion() {
   const prefs = await loadPermissionPreferences();
-  if (prefs.recommendedAllowlistDismissed) {
+  if (prefs.recommendedAllowlistPrompted) {
     return false;
   }
-  if (!prefs.recommendedAllowlistApplied) {
-    return true;
+  if (prefs.recommendedAllowlistDismissed) {
+    return false;
   }
-  try {
-    const content = await fs34__default.readFile(CONFIG_PATHS.trustedTools, "utf-8");
-    const settings = JSON.parse(content);
-    if (!settings.globalTrusted || settings.globalTrusted.length === 0) {
-      return true;
-    }
-  } catch {
-    return true;
+  if (prefs.recommendedAllowlistApplied) {
+    return false;
   }
-  return false;
+  return true;
 }
 async function applyRecommendedPermissions() {
   for (const tool of [...RECOMMENDED_GLOBAL, ...RECOMMENDED_PROJECT]) {
@@ -37810,6 +38230,7 @@ async function applyRecommendedPermissions() {
   await savePermissionPreference("recommendedAllowlistApplied", true);
 }
 async function showPermissionSuggestion() {
+  await savePermissionPreference("recommendedAllowlistPrompted", true);
   console.log();
   console.log(chalk.magenta.bold("  \u{1F4CB} Recommended Permissions"));
   console.log();
@@ -38029,7 +38450,7 @@ async function resetPermissions(session) {
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   try {
-    await fs34__default.writeFile(CONFIG_PATHS.trustedTools, JSON.stringify(emptySettings, null, 2), "utf-8");
+    await fs35__default.writeFile(CONFIG_PATHS.trustedTools, JSON.stringify(emptySettings, null, 2), "utf-8");
   } catch {
   }
   await savePermissionPreference("recommendedAllowlistApplied", false);
@@ -38111,7 +38532,7 @@ function formatQualityResult(result) {
 }
 async function loadQualityLoopPreference() {
   try {
-    const content = await fs34__default.readFile(CONFIG_PATHS.config, "utf-8");
+    const content = await fs35__default.readFile(CONFIG_PATHS.config, "utf-8");
     const config = JSON.parse(content);
     const value = config.qualityLoop ?? config.cocoMode;
     if (typeof value === "boolean") {
@@ -38126,12 +38547,12 @@ async function saveQualityLoopPreference(enabled) {
   try {
     let config = {};
     try {
-      const content = await fs34__default.readFile(CONFIG_PATHS.config, "utf-8");
+      const content = await fs35__default.readFile(CONFIG_PATHS.config, "utf-8");
       config = JSON.parse(content);
     } catch {
     }
     config.qualityLoop = enabled;
-    await fs34__default.writeFile(CONFIG_PATHS.config, JSON.stringify(config, null, 2) + "\n");
+    await fs35__default.writeFile(CONFIG_PATHS.config, JSON.stringify(config, null, 2) + "\n");
   } catch {
   }
 }
@@ -38977,9 +39398,9 @@ Response format (JSON only, no prose):
       cancel5("Build cancelled.");
     }
   }
-  const cocoDir = path37__default.join(outputPath, ".coco");
-  await fs34__default.mkdir(cocoDir, { recursive: true });
-  await fs34__default.writeFile(path37__default.join(cocoDir, "backlog.json"), JSON.stringify(spec, null, 2), "utf-8");
+  const cocoDir = path38__default.join(outputPath, ".coco");
+  await fs35__default.mkdir(cocoDir, { recursive: true });
+  await fs35__default.writeFile(path38__default.join(cocoDir, "backlog.json"), JSON.stringify(spec, null, 2), "utf-8");
   p26.outro("  Spec saved \u2014 starting sprints");
   return spec;
 }
@@ -39529,20 +39950,20 @@ init_errors();
 init_subprocess_registry();
 async function detectTestFramework2(cwd) {
   try {
-    await fs34__default.access(path37__default.join(cwd, "pom.xml"));
+    await fs35__default.access(path38__default.join(cwd, "pom.xml"));
     return "maven";
   } catch {
   }
   for (const gradleFile of ["build.gradle", "build.gradle.kts"]) {
     try {
-      await fs34__default.access(path37__default.join(cwd, gradleFile));
+      await fs35__default.access(path38__default.join(cwd, gradleFile));
       return "gradle";
     } catch {
     }
   }
   try {
-    const pkgPath = path37__default.join(cwd, "package.json");
-    const pkgContent = await fs34__default.readFile(pkgPath, "utf-8");
+    const pkgPath = path38__default.join(cwd, "package.json");
+    const pkgContent = await fs35__default.readFile(pkgPath, "utf-8");
     const pkg = JSON.parse(pkgContent);
     const deps = {
       ...pkg.dependencies,
@@ -39558,16 +39979,16 @@ async function detectTestFramework2(cwd) {
   }
 }
 function toMavenTestFilter(pattern) {
-  const base = path37__default.basename(pattern).replace(/\.java$/, "");
+  const base = path38__default.basename(pattern).replace(/\.java$/, "");
   return base;
 }
 function toGradleTestFilter(pattern) {
-  const base = path37__default.basename(pattern).replace(/\.java$/, "");
+  const base = path38__default.basename(pattern).replace(/\.java$/, "");
   return `*${base}`;
 }
 async function mavenExecutable(cwd) {
   try {
-    await fs34__default.access(path37__default.join(cwd, "mvnw"));
+    await fs35__default.access(path38__default.join(cwd, "mvnw"));
     return "./mvnw";
   } catch {
     return "mvn";
@@ -39575,7 +39996,7 @@ async function mavenExecutable(cwd) {
 }
 async function gradleExecutable(cwd) {
   try {
-    await fs34__default.access(path37__default.join(cwd, "gradlew"));
+    await fs35__default.access(path38__default.join(cwd, "gradlew"));
     return "./gradlew";
   } catch {
     return "gradle";
@@ -39816,18 +40237,18 @@ Examples:
     const projectDir = cwd ?? process.cwd();
     try {
       const coverageLocations = [
-        path37__default.join(projectDir, "coverage", "coverage-summary.json"),
-        path37__default.join(projectDir, "coverage", "coverage-final.json"),
-        path37__default.join(projectDir, ".nyc_output", "coverage-summary.json"),
+        path38__default.join(projectDir, "coverage", "coverage-summary.json"),
+        path38__default.join(projectDir, "coverage", "coverage-final.json"),
+        path38__default.join(projectDir, ".nyc_output", "coverage-summary.json"),
         // Maven JaCoCo
-        path37__default.join(projectDir, "target", "site", "jacoco", "jacoco.csv"),
-        path37__default.join(projectDir, "target", "site", "jacoco-ut", "jacoco.csv"),
+        path38__default.join(projectDir, "target", "site", "jacoco", "jacoco.csv"),
+        path38__default.join(projectDir, "target", "site", "jacoco-ut", "jacoco.csv"),
         // Gradle JaCoCo
-        path37__default.join(projectDir, "build", "reports", "jacoco", "test", "jacocoTestReport.csv")
+        path38__default.join(projectDir, "build", "reports", "jacoco", "test", "jacocoTestReport.csv")
       ];
       for (const location of coverageLocations) {
         try {
-          const content = await fs34__default.readFile(location, "utf-8");
+          const content = await fs35__default.readFile(location, "utf-8");
           if (location.endsWith(".csv")) {
             const result = parseJacocoCsvCoverage(content);
             if (result) {
@@ -39936,7 +40357,7 @@ async function findFileRecursive(rootDir, target, options = {}) {
   const results = [];
   const startTime = Date.now();
   const isTimedOut = () => Date.now() - startTime > opts.timeoutMs;
-  const queue = [[path37__default.resolve(rootDir), 0]];
+  const queue = [[path38__default.resolve(rootDir), 0]];
   const visited = /* @__PURE__ */ new Set();
   while (queue.length > 0 && results.length < opts.maxResults) {
     if (isTimedOut()) break;
@@ -39945,11 +40366,11 @@ async function findFileRecursive(rootDir, target, options = {}) {
     visited.add(currentDir);
     if (depth > opts.maxDepth) continue;
     try {
-      const entries = await fs34__default.readdir(currentDir, { withFileTypes: true });
+      const entries = await fs35__default.readdir(currentDir, { withFileTypes: true });
       for (const entry of entries) {
         if (isTimedOut()) break;
         const entryName = entry.name;
-        const entryPath = path37__default.join(currentDir, entryName);
+        const entryPath = path38__default.join(currentDir, entryName);
         if (!opts.includeHidden && entryName.startsWith(".")) continue;
         if (entry.isDirectory() && opts.excludeDirs.has(entryName)) continue;
         const isMatch = opts.type === "file" && entry.isFile() || opts.type === "directory" && entry.isDirectory() || opts.type === "both";
@@ -39983,19 +40404,19 @@ async function suggestSimilarFilesDeep(missingPath, rootDir = process.cwd(), opt
   if (fastResults.length > 0) {
     return fastResults;
   }
-  const absPath = path37__default.resolve(missingPath);
-  const target = path37__default.basename(absPath);
+  const absPath = path38__default.resolve(missingPath);
+  const target = path38__default.basename(absPath);
   return findFileRecursive(rootDir, target, options);
 }
 async function suggestSimilarDirsDeep(missingPath, rootDir = process.cwd(), options) {
-  const absPath = path37__default.resolve(missingPath);
-  const target = path37__default.basename(absPath);
-  const parentDir = path37__default.dirname(absPath);
+  const absPath = path38__default.resolve(missingPath);
+  const target = path38__default.basename(absPath);
+  const parentDir = path38__default.dirname(absPath);
   try {
-    const entries = await fs34__default.readdir(parentDir, { withFileTypes: true });
+    const entries = await fs35__default.readdir(parentDir, { withFileTypes: true });
     const dirs = entries.filter((e) => e.isDirectory());
     const scored = dirs.map((d) => ({
-      path: path37__default.join(parentDir, d.name),
+      path: path38__default.join(parentDir, d.name),
       distance: levenshtein(target.toLowerCase(), d.name.toLowerCase())
     })).filter((s) => s.distance <= Math.max(target.length * 0.6, 3)).sort((a, b) => a.distance - b.distance).slice(0, options?.maxResults ?? MAX_SUGGESTIONS);
     if (scored.length > 0) {
@@ -40006,15 +40427,15 @@ async function suggestSimilarDirsDeep(missingPath, rootDir = process.cwd(), opti
   return findFileRecursive(rootDir, target, { ...options, type: "directory" });
 }
 async function suggestSimilarFiles(missingPath, options) {
-  const absPath = path37__default.resolve(missingPath);
-  const dir = path37__default.dirname(absPath);
-  const target = path37__default.basename(absPath);
+  const absPath = path38__default.resolve(missingPath);
+  const dir = path38__default.dirname(absPath);
+  const target = path38__default.basename(absPath);
   const maxResults = options?.maxResults;
   try {
-    const entries = await fs34__default.readdir(dir);
+    const entries = await fs35__default.readdir(dir);
     const limited = entries.slice(0, MAX_DIR_ENTRIES);
     const scored = limited.map((name) => ({
-      path: path37__default.join(dir, name),
+      path: path38__default.join(dir, name),
       distance: levenshtein(target.toLowerCase(), name.toLowerCase())
     })).filter((s) => s.distance <= Math.max(target.length * 0.6, 3)).sort((a, b) => a.distance - b.distance);
     return scored.slice(0, maxResults);
@@ -40026,7 +40447,7 @@ function formatSuggestions(suggestions, baseDir) {
   if (suggestions.length === 0) return "";
   const base = baseDir ?? process.cwd();
   const lines = suggestions.map((s) => {
-    const rel = path37__default.relative(base, s.path);
+    const rel = path38__default.relative(base, s.path);
     return `  - ${rel}`;
   });
   return `
@@ -40060,7 +40481,7 @@ function hasNullByte2(str) {
 }
 function normalizePath2(filePath) {
   let normalized = filePath.replace(/\0/g, "");
-  normalized = path37__default.normalize(normalized);
+  normalized = path38__default.normalize(normalized);
   return normalized;
 }
 function isPathAllowed(filePath, operation) {
@@ -40068,31 +40489,31 @@ function isPathAllowed(filePath, operation) {
     return { allowed: false, reason: "Path contains invalid characters" };
   }
   const normalized = normalizePath2(filePath);
-  const absolute = path37__default.resolve(normalized);
+  const absolute = path38__default.resolve(normalized);
   const cwd = process.cwd();
   for (const blocked of BLOCKED_PATHS2) {
-    const normalizedBlocked = path37__default.normalize(blocked);
-    if (absolute === normalizedBlocked || absolute.startsWith(normalizedBlocked + path37__default.sep)) {
+    const normalizedBlocked = path38__default.normalize(blocked);
+    if (absolute === normalizedBlocked || absolute.startsWith(normalizedBlocked + path38__default.sep)) {
       return { allowed: false, reason: `Access to system path '${blocked}' is not allowed` };
     }
   }
   const home = process.env.HOME;
   if (home) {
-    const normalizedHome = path37__default.normalize(home);
-    const normalizedCwd = path37__default.normalize(cwd);
+    const normalizedHome = path38__default.normalize(home);
+    const normalizedCwd = path38__default.normalize(cwd);
     if (absolute.startsWith(normalizedHome) && !absolute.startsWith(normalizedCwd)) {
       if (isWithinAllowedPath(absolute, operation)) ; else if (operation === "read") {
         const allowedHomeReads = [".gitconfig", ".zshrc", ".bashrc"];
-        const basename4 = path37__default.basename(absolute);
+        const basename4 = path38__default.basename(absolute);
         if (!allowedHomeReads.includes(basename4)) {
-          const targetDir = path37__default.dirname(absolute);
+          const targetDir = path38__default.dirname(absolute);
           return {
             allowed: false,
             reason: `Reading files outside project directory is not allowed. Use /allow-path ${targetDir} to grant access.`
           };
         }
       } else {
-        const targetDir = path37__default.dirname(absolute);
+        const targetDir = path38__default.dirname(absolute);
         return {
           allowed: false,
           reason: `${operation} operations outside project directory are not allowed. Use /allow-path ${targetDir} to grant access.`
@@ -40101,7 +40522,7 @@ function isPathAllowed(filePath, operation) {
     }
   }
   if (operation === "write" || operation === "delete") {
-    const basename4 = path37__default.basename(absolute);
+    const basename4 = path38__default.basename(absolute);
     for (const pattern of SENSITIVE_PATTERNS) {
       if (pattern.test(basename4)) {
         return {
@@ -40124,17 +40545,17 @@ function isENOENT(error) {
   return error.code === "ENOENT";
 }
 async function enrichENOENT(filePath, operation) {
-  const absPath = path37__default.resolve(filePath);
+  const absPath = path38__default.resolve(filePath);
   const suggestions = await suggestSimilarFilesDeep(absPath, process.cwd());
-  const hint = formatSuggestions(suggestions, path37__default.dirname(absPath));
+  const hint = formatSuggestions(suggestions, path38__default.dirname(absPath));
   const action = operation === "read" ? "Use glob or list_dir to find the correct path." : "Check that the parent directory exists.";
   return `File not found: ${filePath}${hint}
 ${action}`;
 }
 async function enrichDirENOENT(dirPath) {
-  const absPath = path37__default.resolve(dirPath);
+  const absPath = path38__default.resolve(dirPath);
   const suggestions = await suggestSimilarDirsDeep(absPath, process.cwd());
-  const hint = formatSuggestions(suggestions, path37__default.dirname(absPath));
+  const hint = formatSuggestions(suggestions, path38__default.dirname(absPath));
   return `Directory not found: ${dirPath}${hint}
 Use list_dir or glob to find the correct path.`;
 }
@@ -40155,13 +40576,13 @@ Examples:
   async execute({ path: filePath, encoding, maxSize }) {
     validatePath(filePath, "read");
     try {
-      const absolutePath = path37__default.resolve(filePath);
-      const stats = await fs34__default.stat(absolutePath);
+      const absolutePath = path38__default.resolve(filePath);
+      const stats = await fs35__default.stat(absolutePath);
       const maxBytes = maxSize ?? DEFAULT_MAX_FILE_SIZE;
       let truncated = false;
       let content;
       if (stats.size > maxBytes) {
-        const handle = await fs34__default.open(absolutePath, "r");
+        const handle = await fs35__default.open(absolutePath, "r");
         try {
           const buffer = Buffer.alloc(maxBytes);
           await handle.read(buffer, 0, maxBytes, 0);
@@ -40171,7 +40592,7 @@ Examples:
           await handle.close();
         }
       } else {
-        content = await fs34__default.readFile(absolutePath, encoding);
+        content = await fs35__default.readFile(absolutePath, encoding);
       }
       return {
         content,
@@ -40214,10 +40635,10 @@ Examples:
   async execute({ path: filePath, content, createDirs, dryRun }) {
     validatePath(filePath, "write");
     try {
-      const absolutePath = path37__default.resolve(filePath);
+      const absolutePath = path38__default.resolve(filePath);
       let wouldCreate = false;
       try {
-        await fs34__default.access(absolutePath);
+        await fs35__default.access(absolutePath);
       } catch {
         wouldCreate = true;
       }
@@ -40230,10 +40651,10 @@ Examples:
         };
       }
       if (createDirs) {
-        await fs34__default.mkdir(path37__default.dirname(absolutePath), { recursive: true });
+        await fs35__default.mkdir(path38__default.dirname(absolutePath), { recursive: true });
       }
-      await fs34__default.writeFile(absolutePath, content, "utf-8");
-      const stats = await fs34__default.stat(absolutePath);
+      await fs35__default.writeFile(absolutePath, content, "utf-8");
+      const stats = await fs35__default.stat(absolutePath);
       return {
         path: absolutePath,
         size: stats.size,
@@ -40276,8 +40697,8 @@ Examples:
   async execute({ path: filePath, oldText, newText, all, dryRun }) {
     validatePath(filePath, "write");
     try {
-      const absolutePath = path37__default.resolve(filePath);
-      let content = await fs34__default.readFile(absolutePath, "utf-8");
+      const absolutePath = path38__default.resolve(filePath);
+      let content = await fs35__default.readFile(absolutePath, "utf-8");
       let replacements = 0;
       if (all) {
         const regex = new RegExp(escapeRegex(oldText), "g");
@@ -40326,7 +40747,7 @@ Hint: Use read_file first to verify the exact content.`
           preview
         };
       }
-      await fs34__default.writeFile(absolutePath, content, "utf-8");
+      await fs35__default.writeFile(absolutePath, content, "utf-8");
       return {
         path: absolutePath,
         replacements,
@@ -40397,8 +40818,8 @@ Examples:
   }),
   async execute({ path: filePath }) {
     try {
-      const absolutePath = path37__default.resolve(filePath);
-      const stats = await fs34__default.stat(absolutePath);
+      const absolutePath = path38__default.resolve(filePath);
+      const stats = await fs35__default.stat(absolutePath);
       return {
         exists: true,
         isFile: stats.isFile(),
@@ -40428,12 +40849,12 @@ Examples:
   }),
   async execute({ path: dirPath, recursive }) {
     try {
-      const absolutePath = path37__default.resolve(dirPath);
+      const absolutePath = path38__default.resolve(dirPath);
       const entries = [];
       async function listDir(dir, prefix = "") {
-        const items = await fs34__default.readdir(dir, { withFileTypes: true });
+        const items = await fs35__default.readdir(dir, { withFileTypes: true });
         for (const item of items) {
-          const fullPath = path37__default.join(dir, item.name);
+          const fullPath = path38__default.join(dir, item.name);
           const relativePath = prefix ? `${prefix}/${item.name}` : item.name;
           if (item.isDirectory()) {
             entries.push({ name: relativePath, type: "directory" });
@@ -40441,7 +40862,7 @@ Examples:
               await listDir(fullPath, relativePath);
             }
           } else if (item.isFile()) {
-            const stats = await fs34__default.stat(fullPath);
+            const stats = await fs35__default.stat(fullPath);
             entries.push({ name: relativePath, type: "file", size: stats.size });
           }
         }
@@ -40488,23 +40909,23 @@ Examples:
     }
     validatePath(filePath, "delete");
     try {
-      const absolutePath = path37__default.resolve(filePath);
-      const stats = await fs34__default.stat(absolutePath);
+      const absolutePath = path38__default.resolve(filePath);
+      const stats = await fs35__default.stat(absolutePath);
       if (stats.isDirectory()) {
         if (!recursive) {
           throw new ToolError("Cannot delete directory without recursive: true", {
             tool: "delete_file"
           });
         }
-        await fs34__default.rm(absolutePath, { recursive: true });
+        await fs35__default.rm(absolutePath, { recursive: true });
       } else {
-        await fs34__default.unlink(absolutePath);
+        await fs35__default.unlink(absolutePath);
       }
       return { deleted: true, path: absolutePath };
     } catch (error) {
       if (error instanceof ToolError) throw error;
       if (error.code === "ENOENT") {
-        return { deleted: false, path: path37__default.resolve(filePath) };
+        return { deleted: false, path: path38__default.resolve(filePath) };
       }
       throw new FileSystemError(`Failed to delete: ${filePath}`, {
         path: filePath,
@@ -40532,11 +40953,11 @@ Examples:
     validatePath(source, "read");
     validatePath(destination, "write");
     try {
-      const srcPath = path37__default.resolve(source);
-      const destPath = path37__default.resolve(destination);
+      const srcPath = path38__default.resolve(source);
+      const destPath = path38__default.resolve(destination);
       if (!overwrite) {
         try {
-          await fs34__default.access(destPath);
+          await fs35__default.access(destPath);
           throw new ToolError(
             `Destination already exists: ${destination}. Use overwrite: true to replace.`,
             {
@@ -40549,9 +40970,9 @@ Examples:
           }
         }
       }
-      await fs34__default.mkdir(path37__default.dirname(destPath), { recursive: true });
-      await fs34__default.copyFile(srcPath, destPath);
-      const stats = await fs34__default.stat(destPath);
+      await fs35__default.mkdir(path38__default.dirname(destPath), { recursive: true });
+      await fs35__default.copyFile(srcPath, destPath);
+      const stats = await fs35__default.stat(destPath);
       return {
         source: srcPath,
         destination: destPath,
@@ -40593,11 +41014,11 @@ Examples:
     validatePath(source, "delete");
     validatePath(destination, "write");
     try {
-      const srcPath = path37__default.resolve(source);
-      const destPath = path37__default.resolve(destination);
+      const srcPath = path38__default.resolve(source);
+      const destPath = path38__default.resolve(destination);
       if (!overwrite) {
         try {
-          await fs34__default.access(destPath);
+          await fs35__default.access(destPath);
           throw new ToolError(
             `Destination already exists: ${destination}. Use overwrite: true to replace.`,
             {
@@ -40610,8 +41031,8 @@ Examples:
           }
         }
       }
-      await fs34__default.mkdir(path37__default.dirname(destPath), { recursive: true });
-      await fs34__default.rename(srcPath, destPath);
+      await fs35__default.mkdir(path38__default.dirname(destPath), { recursive: true });
+      await fs35__default.rename(srcPath, destPath);
       return {
         source: srcPath,
         destination: destPath
@@ -40680,15 +41101,15 @@ Examples:
   }),
   async execute({ path: dirPath, depth, showHidden, dirsOnly }) {
     try {
-      const absolutePath = path37__default.resolve(dirPath ?? ".");
+      const absolutePath = path38__default.resolve(dirPath ?? ".");
       let totalFiles = 0;
       let totalDirs = 0;
-      const lines = [path37__default.basename(absolutePath) + "/"];
+      const lines = [path38__default.basename(absolutePath) + "/"];
       let truncated = false;
       async function buildTree(dir, prefix, currentDepth) {
         if (currentDepth > (depth ?? 4)) return;
         if (lines.length >= MAX_TREE_LINES) return;
-        let items = await fs34__default.readdir(dir, { withFileTypes: true });
+        let items = await fs35__default.readdir(dir, { withFileTypes: true });
         items = items.filter((item) => !TREE_IGNORED_DIRS.has(item.name));
         if (!showHidden) {
           items = items.filter((item) => !item.name.startsWith("."));
@@ -40713,7 +41134,7 @@ Examples:
           if (item.isDirectory()) {
             totalDirs++;
             lines.push(`${prefix}${connector}${item.name}/`);
-            await buildTree(path37__default.join(dir, item.name), prefix + childPrefix, currentDepth + 1);
+            await buildTree(path38__default.join(dir, item.name), prefix + childPrefix, currentDepth + 1);
           } else {
             totalFiles++;
             lines.push(`${prefix}${connector}${item.name}`);
@@ -41981,7 +42402,7 @@ Examples:
     caseSensitive,
     wholeWord
   }) {
-    const targetPath = searchPath ? path37__default.resolve(searchPath) : process.cwd();
+    const targetPath = searchPath ? path38__default.resolve(searchPath) : process.cwd();
     const matches = [];
     let filesSearched = 0;
     const filesWithMatches = /* @__PURE__ */ new Set();
@@ -42003,7 +42424,7 @@ Examples:
           tool: "grep"
         });
       }
-      const stats = await fs34__default.stat(targetPath);
+      const stats = await fs35__default.stat(targetPath);
       let filesToSearch;
       if (stats.isFile()) {
         filesToSearch = [targetPath];
@@ -42025,7 +42446,7 @@ Examples:
         }
         filesSearched++;
         try {
-          const content = await fs34__default.readFile(file, "utf-8");
+          const content = await fs35__default.readFile(file, "utf-8");
           const lines = content.split("\n");
           let fileHasMatch = false;
           for (let i = 0; i < lines.length; i++) {
@@ -42048,7 +42469,7 @@ Examples:
                 contextAfter.push(lines[j] ?? "");
               }
               matches.push({
-                file: path37__default.relative(process.cwd(), file),
+                file: path38__default.relative(process.cwd(), file),
                 line: i + 1,
                 column: match.index + 1,
                 content: line,
@@ -42099,8 +42520,8 @@ Examples:
   }),
   async execute({ file, pattern, caseSensitive }) {
     try {
-      const absolutePath = path37__default.resolve(file);
-      const content = await fs34__default.readFile(absolutePath, "utf-8");
+      const absolutePath = path38__default.resolve(file);
+      const content = await fs35__default.readFile(absolutePath, "utf-8");
       const lines = content.split("\n");
       const matches = [];
       const flags = caseSensitive ? "" : "i";
@@ -42118,7 +42539,7 @@ Examples:
     } catch (error) {
       if (error.code === "ENOENT") {
         const suggestions = await suggestSimilarFilesDeep(file, process.cwd());
-        const hint = formatSuggestions(suggestions, path37__default.dirname(file));
+        const hint = formatSuggestions(suggestions, path38__default.dirname(file));
         throw new ToolError(`File not found: ${file}${hint}
 Use glob to find the correct path.`, {
           tool: "find_in_file"
@@ -42309,7 +42730,7 @@ async function detectPackageManager2(cwd) {
   ];
   for (const { file, pm } of lockfiles) {
     try {
-      await fs34__default.access(path37__default.join(cwd, file));
+      await fs35__default.access(path38__default.join(cwd, file));
       return pm;
     } catch {
     }
@@ -42582,7 +43003,7 @@ ${message}
     });
     try {
       try {
-        await fs34__default.access(path37__default.join(projectDir, "Makefile"));
+        await fs35__default.access(path38__default.join(projectDir, "Makefile"));
       } catch {
         throw new ToolError("No Makefile found in directory", { tool: "make" });
       }
@@ -42752,7 +43173,7 @@ ${message}
 });
 async function resolveMaven(cwd) {
   try {
-    await fs34__default.access(path37__default.join(cwd, "mvnw"));
+    await fs35__default.access(path38__default.join(cwd, "mvnw"));
     return "./mvnw";
   } catch {
     return "mvn";
@@ -42760,7 +43181,7 @@ async function resolveMaven(cwd) {
 }
 async function resolveGradle(cwd) {
   try {
-    await fs34__default.access(path37__default.join(cwd, "gradlew"));
+    await fs35__default.access(path38__default.join(cwd, "gradlew"));
     return "./gradlew";
   } catch {
     return "gradle";
@@ -43627,8 +44048,8 @@ init_review();
 // src/tools/codebase-map.ts
 init_registry4();
 init_errors();
-var fs37 = await import('fs/promises');
-var path40 = await import('path');
+var fs38 = await import('fs/promises');
+var path41 = await import('path');
 var { glob: glob14 } = await import('glob');
 var DEFAULT_MAX_FILES = 200;
 var LANGUAGE_EXTENSIONS = {
@@ -43654,7 +44075,7 @@ var DEFAULT_EXCLUDES = [
   "**/*.d.ts"
 ];
 function detectLanguage3(filePath) {
-  const ext = path40.extname(filePath).toLowerCase();
+  const ext = path41.extname(filePath).toLowerCase();
   for (const [lang, extensions] of Object.entries(LANGUAGE_EXTENSIONS)) {
     if (extensions.includes(ext)) return lang;
   }
@@ -44063,9 +44484,9 @@ Examples:
   }),
   async execute({ path: rootPath, include, exclude, languages, maxFiles, depth }) {
     const startTime = performance.now();
-    const absPath = path40.resolve(rootPath);
+    const absPath = path41.resolve(rootPath);
     try {
-      const stat2 = await fs37.stat(absPath);
+      const stat2 = await fs38.stat(absPath);
       if (!stat2.isDirectory()) {
         throw new ToolError(`Path is not a directory: ${absPath}`, {
           tool: "codebase_map"
@@ -44102,14 +44523,14 @@ Examples:
     let totalDefinitions = 0;
     let exportedSymbols = 0;
     for (const file of limitedFiles) {
-      const fullPath = path40.join(absPath, file);
+      const fullPath = path41.join(absPath, file);
       const language = detectLanguage3(file);
       if (!language) continue;
       if (languages && !languages.includes(language)) {
         continue;
       }
       try {
-        const content = await fs37.readFile(fullPath, "utf-8");
+        const content = await fs38.readFile(fullPath, "utf-8");
         const lineCount = content.split("\n").length;
         const parsed = parseFile(content, language);
         const definitions = depth === "overview" ? parsed.definitions.filter((d) => d.exported) : parsed.definitions;
@@ -44146,23 +44567,23 @@ var codebaseMapTools = [codebaseMapTool];
 init_registry4();
 init_errors();
 init_paths();
-var fs38 = await import('fs/promises');
-var path41 = await import('path');
+var fs39 = await import('fs/promises');
+var path42 = await import('path');
 var crypto2 = await import('crypto');
-var GLOBAL_MEMORIES_DIR = path41.join(COCO_HOME, "memories");
+var GLOBAL_MEMORIES_DIR = path42.join(COCO_HOME, "memories");
 var PROJECT_MEMORIES_DIR = ".coco/memories";
 var DEFAULT_MAX_MEMORIES = 1e3;
 async function ensureDir2(dirPath) {
-  await fs38.mkdir(dirPath, { recursive: true });
+  await fs39.mkdir(dirPath, { recursive: true });
 }
 function getMemoriesDir(scope) {
   return scope === "global" ? GLOBAL_MEMORIES_DIR : PROJECT_MEMORIES_DIR;
 }
 async function loadIndex(scope) {
   const dir = getMemoriesDir(scope);
-  const indexPath = path41.join(dir, "index.json");
+  const indexPath = path42.join(dir, "index.json");
   try {
-    const content = await fs38.readFile(indexPath, "utf-8");
+    const content = await fs39.readFile(indexPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return [];
@@ -44171,14 +44592,14 @@ async function loadIndex(scope) {
 async function saveIndex(scope, index) {
   const dir = getMemoriesDir(scope);
   await ensureDir2(dir);
-  const indexPath = path41.join(dir, "index.json");
-  await fs38.writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
+  const indexPath = path42.join(dir, "index.json");
+  await fs39.writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
 }
 async function loadMemory(scope, id) {
   const dir = getMemoriesDir(scope);
-  const memPath = path41.join(dir, `${id}.json`);
+  const memPath = path42.join(dir, `${id}.json`);
   try {
-    const content = await fs38.readFile(memPath, "utf-8");
+    const content = await fs39.readFile(memPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -44187,8 +44608,8 @@ async function loadMemory(scope, id) {
 async function saveMemory(scope, memory) {
   const dir = getMemoriesDir(scope);
   await ensureDir2(dir);
-  const memPath = path41.join(dir, `${memory.id}.json`);
-  await fs38.writeFile(memPath, JSON.stringify(memory, null, 2), "utf-8");
+  const memPath = path42.join(dir, `${memory.id}.json`);
+  await fs39.writeFile(memPath, JSON.stringify(memory, null, 2), "utf-8");
 }
 var createMemoryTool = defineTool({
   name: "create_memory",
@@ -44344,17 +44765,17 @@ var memoryTools = [createMemoryTool, recallMemoryTool, listMemoriesTool];
 // src/tools/checkpoint.ts
 init_registry4();
 init_errors();
-var fs39 = await import('fs/promises');
+var fs40 = await import('fs/promises');
 var crypto3 = await import('crypto');
 var CHECKPOINT_FILE = ".coco/checkpoints.json";
 var DEFAULT_MAX_CHECKPOINTS = 50;
 var STASH_PREFIX = "coco-cp";
 async function ensureCocoDir() {
-  await fs39.mkdir(".coco", { recursive: true });
+  await fs40.mkdir(".coco", { recursive: true });
 }
 async function loadCheckpoints() {
   try {
-    const content = await fs39.readFile(CHECKPOINT_FILE, "utf-8");
+    const content = await fs40.readFile(CHECKPOINT_FILE, "utf-8");
     return JSON.parse(content);
   } catch {
     return [];
@@ -44362,7 +44783,7 @@ async function loadCheckpoints() {
 }
 async function saveCheckpoints(checkpoints) {
   await ensureCocoDir();
-  await fs39.writeFile(CHECKPOINT_FILE, JSON.stringify(checkpoints, null, 2), "utf-8");
+  await fs40.writeFile(CHECKPOINT_FILE, JSON.stringify(checkpoints, null, 2), "utf-8");
 }
 async function execGit(args) {
   const { execaCommand } = await import('execa');
@@ -44527,8 +44948,8 @@ var checkpointTools = [createCheckpointTool, restoreCheckpointTool, listCheckpoi
 
 // src/tools/semantic-search.ts
 init_registry4();
-var fs40 = await import('fs/promises');
-var path42 = await import('path');
+var fs41 = await import('fs/promises');
+var path43 = await import('path');
 var { glob: glob15 } = await import('glob');
 var INDEX_DIR = ".coco/search-index";
 var DEFAULT_CHUNK_SIZE = 20;
@@ -44656,20 +45077,20 @@ async function getEmbedding(text13) {
 }
 async function loadIndex2(indexDir) {
   try {
-    const indexPath = path42.join(indexDir, "index.json");
-    const content = await fs40.readFile(indexPath, "utf-8");
+    const indexPath = path43.join(indexDir, "index.json");
+    const content = await fs41.readFile(indexPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 async function saveIndex2(indexDir, index) {
-  await fs40.mkdir(indexDir, { recursive: true });
-  const indexPath = path42.join(indexDir, "index.json");
-  await fs40.writeFile(indexPath, JSON.stringify(index), "utf-8");
+  await fs41.mkdir(indexDir, { recursive: true });
+  const indexPath = path43.join(indexDir, "index.json");
+  await fs41.writeFile(indexPath, JSON.stringify(index), "utf-8");
 }
 function isBinary(filePath) {
-  return BINARY_EXTENSIONS.has(path42.extname(filePath).toLowerCase());
+  return BINARY_EXTENSIONS.has(path43.extname(filePath).toLowerCase());
 }
 var semanticSearchTool = defineTool({
   name: "semantic_search",
@@ -44694,8 +45115,8 @@ Examples:
     const effectivePath = rootPath ?? ".";
     const effectiveMaxResults = maxResults ?? 10;
     const effectiveThreshold = threshold ?? 0.3;
-    const absPath = path42.resolve(effectivePath);
-    const indexDir = path42.join(absPath, INDEX_DIR);
+    const absPath = path43.resolve(effectivePath);
+    const indexDir = path43.join(absPath, INDEX_DIR);
     let index = reindex ? null : await loadIndex2(indexDir);
     let warnings = [];
     if (!index) {
@@ -44711,10 +45132,10 @@ Examples:
       let indexSaveWarning = "";
       for (const file of files) {
         if (isBinary(file)) continue;
-        const fullPath = path42.join(absPath, file);
+        const fullPath = path43.join(absPath, file);
         try {
-          const stat2 = await fs40.stat(fullPath);
-          const content = await fs40.readFile(fullPath, "utf-8");
+          const stat2 = await fs41.stat(fullPath);
+          const content = await fs41.readFile(fullPath, "utf-8");
           if (content.length > 1e5) continue;
           const fileChunks = chunkContent(content, DEFAULT_CHUNK_SIZE);
           for (const chunk of fileChunks) {
@@ -44794,8 +45215,8 @@ var semanticSearchTools = [semanticSearchTool];
 // src/tools/diagram.ts
 init_registry4();
 init_errors();
-var fs41 = await import('fs/promises');
-var path43 = await import('path');
+var fs42 = await import('fs/promises');
+var path44 = await import('path');
 var { glob: glob16 } = await import('glob');
 async function parseClassRelationships(rootPath, include) {
   const pattern = include ?? "**/*.{ts,tsx,js,jsx}";
@@ -44808,7 +45229,7 @@ async function parseClassRelationships(rootPath, include) {
   const interfaces = [];
   for (const file of files.slice(0, 100)) {
     try {
-      const content = await fs41.readFile(path43.join(rootPath, file), "utf-8");
+      const content = await fs42.readFile(path44.join(rootPath, file), "utf-8");
       const lines = content.split("\n");
       for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
@@ -44927,14 +45348,14 @@ async function generateClassDiagram(rootPath, include) {
   };
 }
 async function generateArchitectureDiagram(rootPath) {
-  const entries = await fs41.readdir(rootPath, { withFileTypes: true });
+  const entries = await fs42.readdir(rootPath, { withFileTypes: true });
   const dirs = entries.filter(
     (e) => e.isDirectory() && !e.name.startsWith(".") && !["node_modules", "dist", "build", "coverage", "__pycache__", "target"].includes(e.name)
   );
   const lines = ["graph TD"];
   let nodeCount = 0;
   let edgeCount = 0;
-  const rootName = path43.basename(rootPath);
+  const rootName = path44.basename(rootPath);
   lines.push(`  ROOT["${rootName}"]`);
   nodeCount++;
   for (const dir of dirs) {
@@ -44944,7 +45365,7 @@ async function generateArchitectureDiagram(rootPath) {
     nodeCount++;
     edgeCount++;
     try {
-      const subEntries = await fs41.readdir(path43.join(rootPath, dir.name), {
+      const subEntries = await fs42.readdir(path44.join(rootPath, dir.name), {
         withFileTypes: true
       });
       const subDirs = subEntries.filter(
@@ -45067,7 +45488,7 @@ Examples:
         tool: "generate_diagram"
       });
     }
-    const absPath = rootPath ? path43.resolve(rootPath) : process.cwd();
+    const absPath = rootPath ? path44.resolve(rootPath) : process.cwd();
     switch (type) {
       case "class":
         return generateClassDiagram(absPath, include);
@@ -45132,8 +45553,8 @@ var diagramTools = [generateDiagramTool];
 // src/tools/pdf.ts
 init_registry4();
 init_errors();
-var fs42 = await import('fs/promises');
-var path44 = await import('path');
+var fs43 = await import('fs/promises');
+var path45 = await import('path');
 var DEFAULT_MAX_PAGES = 20;
 var MAX_FILE_SIZE = 50 * 1024 * 1024;
 function parsePageRange(rangeStr, totalPages) {
@@ -45168,9 +45589,9 @@ Examples:
   }),
   async execute({ path: filePath, pages, maxPages }) {
     const startTime = performance.now();
-    const absPath = path44.resolve(filePath);
+    const absPath = path45.resolve(filePath);
     try {
-      const stat2 = await fs42.stat(absPath);
+      const stat2 = await fs43.stat(absPath);
       if (!stat2.isFile()) {
         throw new ToolError(`Path is not a file: ${absPath}`, {
           tool: "read_pdf"
@@ -45201,7 +45622,7 @@ Examples:
     }
     try {
       const pdfParse = await import('pdf-parse');
-      const dataBuffer = await fs42.readFile(absPath);
+      const dataBuffer = await fs43.readFile(absPath);
       const pdfData = await pdfParse.default(dataBuffer, {
         max: maxPages
       });
@@ -45252,8 +45673,8 @@ var pdfTools = [readPdfTool];
 // src/tools/image.ts
 init_registry4();
 init_errors();
-var fs43 = await import('fs/promises');
-var path45 = await import('path');
+var fs44 = await import('fs/promises');
+var path46 = await import('path');
 var SUPPORTED_FORMATS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"]);
 var MAX_IMAGE_SIZE = 20 * 1024 * 1024;
 var MIME_TYPES = {
@@ -45281,15 +45702,15 @@ Examples:
   async execute({ path: filePath, prompt, provider }) {
     const startTime = performance.now();
     const effectivePrompt = prompt ?? "Describe this image in detail. If it's code or a UI, identify the key elements.";
-    const absPath = path45.resolve(filePath);
+    const absPath = path46.resolve(filePath);
     const cwd = process.cwd();
-    if (!absPath.startsWith(cwd + path45.sep) && absPath !== cwd) {
+    if (!absPath.startsWith(cwd + path46.sep) && absPath !== cwd) {
       throw new ToolError(
         `Path traversal denied: '${filePath}' resolves outside the project directory`,
         { tool: "read_image" }
       );
     }
-    const ext = path45.extname(absPath).toLowerCase();
+    const ext = path46.extname(absPath).toLowerCase();
     if (!SUPPORTED_FORMATS.has(ext)) {
       throw new ToolError(
         `Unsupported image format '${ext}'. Supported: ${Array.from(SUPPORTED_FORMATS).join(", ")}`,
@@ -45297,7 +45718,7 @@ Examples:
       );
     }
     try {
-      const stat2 = await fs43.stat(absPath);
+      const stat2 = await fs44.stat(absPath);
       if (!stat2.isFile()) {
         throw new ToolError(`Path is not a file: ${absPath}`, {
           tool: "read_image"
@@ -45318,7 +45739,7 @@ Examples:
       if (error instanceof ToolError) throw error;
       throw error;
     }
-    const imageBuffer = await fs43.readFile(absPath);
+    const imageBuffer = await fs44.readFile(absPath);
     const base64 = imageBuffer.toString("base64");
     const mimeType = MIME_TYPES[ext] ?? "image/png";
     const selectedProvider = provider ?? "anthropic";
@@ -45440,7 +45861,7 @@ var imageTools = [readImageTool];
 // src/tools/database.ts
 init_registry4();
 init_errors();
-var path46 = await import('path');
+var path47 = await import('path');
 var DANGEROUS_PATTERNS = [
   /\bDROP\s+(?:TABLE|DATABASE|INDEX|VIEW)\b/i,
   /\bTRUNCATE\b/i,
@@ -45471,7 +45892,7 @@ Examples:
   async execute({ database, query, params, readonly: isReadonlyParam }) {
     const isReadonly = isReadonlyParam ?? true;
     const startTime = performance.now();
-    const absPath = path46.resolve(database);
+    const absPath = path47.resolve(database);
     if (isReadonly && isDangerousSql(query)) {
       throw new ToolError(
         "Write operations (INSERT, UPDATE, DELETE, DROP, ALTER, TRUNCATE, CREATE) are blocked in readonly mode. Set readonly: false to allow writes.",
@@ -45554,7 +45975,7 @@ Examples:
   }),
   async execute({ database, table }) {
     const startTime = performance.now();
-    const absPath = path46.resolve(database);
+    const absPath = path47.resolve(database);
     try {
       const { default: Database } = await import('better-sqlite3');
       const db = new Database(absPath, { readonly: true, fileMustExist: true });
@@ -45737,14 +46158,14 @@ var astValidatorTools = [validateCodeTool, findMissingImportsTool];
 
 // src/tools/code-analyzer.ts
 init_registry4();
-var fs44 = await import('fs/promises');
-var path47 = await import('path');
+var fs45 = await import('fs/promises');
+var path48 = await import('path');
 var AnalyzeFileSchema = z.object({
   filePath: z.string().describe("Path to file to analyze"),
   includeAst: z.boolean().default(false).describe("Include AST in result")
 });
 async function analyzeFile(filePath, includeAst = false) {
-  const content = await fs44.readFile(filePath, "utf-8");
+  const content = await fs45.readFile(filePath, "utf-8");
   const lines = content.split("\n").length;
   const functions = [];
   const classes = [];
@@ -45848,10 +46269,10 @@ async function analyzeDirectory(dirPath) {
     try {
       const analysis = await analyzeFile(file, false);
       totalLines += analysis.lines;
-      const ext = path47.extname(file);
+      const ext = path48.extname(file);
       filesByType[ext] = (filesByType[ext] || 0) + 1;
       fileStats.push({
-        file: path47.relative(dirPath, file),
+        file: path48.relative(dirPath, file),
         lines: analysis.lines,
         complexity: analysis.complexity.cyclomatic
       });
@@ -46222,13 +46643,13 @@ var agentCoordinatorTools = [createAgentPlanTool, delegateTaskTool, aggregateRes
 
 // src/tools/smart-suggestions.ts
 init_registry4();
-var fs45 = await import('fs/promises');
+var fs46 = await import('fs/promises');
 var SuggestImprovementsSchema = z.object({
   filePath: z.string().describe("File to analyze for improvement suggestions"),
   context: z.string().optional().describe("Additional context about the code")
 });
 async function analyzeAndSuggest(filePath, _context) {
-  const content = await fs45.readFile(filePath, "utf-8");
+  const content = await fs46.readFile(filePath, "utf-8");
   const lines = content.split("\n");
   const suggestions = [];
   for (let i = 0; i < lines.length; i++) {
@@ -46320,7 +46741,7 @@ async function analyzeAndSuggest(filePath, _context) {
     if (filePath.endsWith(".ts") && !filePath.includes("test") && !filePath.includes(".d.ts") && line.includes("export ")) {
       const testPath = filePath.replace(".ts", ".test.ts");
       try {
-        await fs45.access(testPath);
+        await fs46.access(testPath);
       } catch {
         suggestions.push({
           type: "testing",
@@ -46377,7 +46798,7 @@ var calculateCodeScoreTool = defineTool({
   async execute(input) {
     const { filePath } = input;
     const suggestions = await analyzeAndSuggest(filePath);
-    const content = await fs45.readFile(filePath, "utf-8");
+    const content = await fs46.readFile(filePath, "utf-8");
     const lines = content.split("\n");
     const nonEmptyLines = lines.filter((l) => l.trim()).length;
     let score = 100;
@@ -46414,8 +46835,8 @@ var smartSuggestionsTools = [suggestImprovementsTool, calculateCodeScoreTool];
 
 // src/tools/context-enhancer.ts
 init_registry4();
-var fs46 = await import('fs/promises');
-var path48 = await import('path');
+var fs47 = await import('fs/promises');
+var path49 = await import('path');
 var ContextMemoryStore = class {
   items = /* @__PURE__ */ new Map();
   learnings = /* @__PURE__ */ new Map();
@@ -46427,7 +46848,7 @@ var ContextMemoryStore = class {
   }
   async load() {
     try {
-      const content = await fs46.readFile(this.storePath, "utf-8");
+      const content = await fs47.readFile(this.storePath, "utf-8");
       const data = JSON.parse(content);
       this.items = new Map(Object.entries(data.items || {}));
       this.learnings = new Map(Object.entries(data.learnings || {}));
@@ -46435,15 +46856,15 @@ var ContextMemoryStore = class {
     }
   }
   async save() {
-    const dir = path48.dirname(this.storePath);
-    await fs46.mkdir(dir, { recursive: true });
+    const dir = path49.dirname(this.storePath);
+    await fs47.mkdir(dir, { recursive: true });
     const data = {
       sessionId: this.sessionId,
       items: Object.fromEntries(this.items),
       learnings: Object.fromEntries(this.learnings),
       savedAt: Date.now()
     };
-    await fs46.writeFile(this.storePath, JSON.stringify(data, null, 2));
+    await fs47.writeFile(this.storePath, JSON.stringify(data, null, 2));
   }
   addContext(id, item) {
     this.items.set(id, item);
@@ -46611,11 +47032,11 @@ var contextEnhancerTools = [
 
 // src/tools/skill-enhancer.ts
 init_registry4();
-var fs47 = await import('fs/promises');
-var path49 = await import('path');
+var fs48 = await import('fs/promises');
+var path50 = await import('path');
 async function discoverSkills(skillsDir) {
   try {
-    const files = await fs47.readdir(skillsDir);
+    const files = await fs48.readdir(skillsDir);
     return files.filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
   } catch {
     return [];
@@ -46623,12 +47044,12 @@ async function discoverSkills(skillsDir) {
 }
 async function loadSkillMetadata(skillPath) {
   try {
-    const content = await fs47.readFile(skillPath, "utf-8");
+    const content = await fs48.readFile(skillPath, "utf-8");
     const nameMatch = content.match(/@name\s+(\S+)/);
     const descMatch = content.match(/@description\s+(.+)/);
     const versionMatch = content.match(/@version\s+(\S+)/);
     return {
-      name: nameMatch?.[1] || path49.basename(skillPath, path49.extname(skillPath)),
+      name: nameMatch?.[1] || path50.basename(skillPath, path50.extname(skillPath)),
       description: descMatch?.[1] || "No description",
       version: versionMatch?.[1] || "1.0.0",
       dependencies: []
@@ -46672,7 +47093,7 @@ var discoverSkillsTool = defineTool({
     const { skillsDir } = input;
     const skills = await discoverSkills(skillsDir);
     const metadata = await Promise.all(
-      skills.map((s) => loadSkillMetadata(path49.join(skillsDir, s)))
+      skills.map((s) => loadSkillMetadata(path50.join(skillsDir, s)))
     );
     return {
       skillsDir,
@@ -46843,7 +47264,7 @@ Examples:
     reason: z.string().optional().describe("Why access is needed (shown to user for context)")
   }),
   async execute({ path: dirPath, reason }) {
-    const absolute = path37__default.resolve(dirPath);
+    const absolute = path38__default.resolve(dirPath);
     if (isWithinAllowedPath(absolute, "read")) {
       return {
         authorized: true,
@@ -46852,8 +47273,8 @@ Examples:
       };
     }
     for (const blocked of BLOCKED_SYSTEM_PATHS2) {
-      const normalizedBlocked = path37__default.normalize(blocked);
-      if (absolute === normalizedBlocked || absolute.startsWith(normalizedBlocked + path37__default.sep)) {
+      const normalizedBlocked = path38__default.normalize(blocked);
+      if (absolute === normalizedBlocked || absolute.startsWith(normalizedBlocked + path38__default.sep)) {
         return {
           authorized: false,
           path: absolute,
@@ -46862,7 +47283,7 @@ Examples:
       }
     }
     const cwd = process.cwd();
-    if (absolute === path37__default.normalize(cwd) || absolute.startsWith(path37__default.normalize(cwd) + path37__default.sep)) {
+    if (absolute === path38__default.normalize(cwd) || absolute.startsWith(path38__default.normalize(cwd) + path38__default.sep)) {
       return {
         authorized: true,
         path: absolute,
@@ -46870,7 +47291,7 @@ Examples:
       };
     }
     try {
-      const stat2 = await fs34__default.stat(absolute);
+      const stat2 = await fs35__default.stat(absolute);
       if (!stat2.isDirectory()) {
         return {
           authorized: false,
@@ -46886,7 +47307,7 @@ Examples:
       };
     }
     const existing = getAllowedPaths();
-    if (existing.some((e) => path37__default.normalize(e.path) === path37__default.normalize(absolute))) {
+    if (existing.some((e) => path38__default.normalize(e.path) === path38__default.normalize(absolute))) {
       return {
         authorized: true,
         path: absolute,
@@ -46971,9 +47392,9 @@ async function runSprints(options) {
     Object.entries(AGENT_ROLES).map(([role, def]) => [role, { ...def, maxTurns: 20 }])
   );
   const coordinator = createAgentCoordinator(executor, agentDefsMap);
-  await fs34__default.mkdir(spec.outputPath, { recursive: true });
-  const sprintsDir = path37__default.join(spec.outputPath, ".coco", "sprints");
-  await fs34__default.mkdir(sprintsDir, { recursive: true });
+  await fs35__default.mkdir(spec.outputPath, { recursive: true });
+  const sprintsDir = path38__default.join(spec.outputPath, ".coco", "sprints");
+  await fs35__default.mkdir(sprintsDir, { recursive: true });
   for (const sprint of spec.sprints) {
     onProgress(`Starting ${sprint.id}: ${sprint.name}`);
     const sprintStart = Date.now();
@@ -47226,8 +47647,8 @@ Assess: overall architecture, consistency, error handling, and production readin
   };
 }
 async function saveSprintResult(sprintsDir, result) {
-  const filePath = path37__default.join(sprintsDir, `${result.sprintId}.json`);
-  await fs34__default.writeFile(filePath, JSON.stringify(result, null, 2), "utf-8");
+  const filePath = path38__default.join(sprintsDir, `${result.sprintId}.json`);
+  await fs35__default.writeFile(filePath, JSON.stringify(result, null, 2), "utf-8");
 }
 
 // src/cli/repl/commands/build-app.ts
@@ -47252,9 +47673,9 @@ function parseArgs6(args) {
   return { description, specFile, outputDir, skipConfirmation };
 }
 function isWithinRoot(resolvedPath, rootDir) {
-  const normalRoot = path37__default.normalize(rootDir) + path37__default.sep;
-  const normalPath = path37__default.normalize(resolvedPath);
-  return normalPath === path37__default.normalize(rootDir) || normalPath.startsWith(normalRoot);
+  const normalRoot = path38__default.normalize(rootDir) + path38__default.sep;
+  const normalPath = path38__default.normalize(resolvedPath);
+  return normalPath === path38__default.normalize(rootDir) || normalPath.startsWith(normalRoot);
 }
 var buildAppCommand = {
   name: "build-app",
@@ -47277,20 +47698,20 @@ var buildAppCommand = {
     }
     let initialDescription = parsed.description;
     if (parsed.specFile) {
-      const specPath = path37__default.resolve(session.projectPath, parsed.specFile);
+      const specPath = path38__default.resolve(session.projectPath, parsed.specFile);
       if (!isWithinRoot(specPath, session.projectPath)) {
         p26.log.error(`--spec path must be within the project directory: ${specPath}`);
         return false;
       }
       try {
-        initialDescription = await fs34__default.readFile(specPath, "utf-8");
+        initialDescription = await fs35__default.readFile(specPath, "utf-8");
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         p26.log.error(`Error reading spec file: ${msg}`);
         return false;
       }
     }
-    const outputPath = parsed.outputDir ? path37__default.resolve(session.projectPath, parsed.outputDir) : path37__default.join(session.projectPath, "build-app-output");
+    const outputPath = parsed.outputDir ? path38__default.resolve(session.projectPath, parsed.outputDir) : path38__default.join(session.projectPath, "build-app-output");
     if (parsed.outputDir && !isWithinRoot(outputPath, session.projectPath)) {
       p26.log.error(`--output path must be within the project directory: ${outputPath}`);
       return false;
@@ -47454,7 +47875,7 @@ function buildProgressBar(pct) {
 
 // src/cli/repl/worktree/manager.ts
 init_logger();
-var execFileAsync2 = promisify(execFile);
+var execFileAsync3 = promisify(execFile);
 var WORKTREES_DIR = ".worktrees";
 var WorktreeManager = class {
   worktrees = /* @__PURE__ */ new Map();
@@ -47474,7 +47895,7 @@ var WorktreeManager = class {
     const id = randomUUID();
     const branchPrefix = options.branchPrefix ?? "coco-agent";
     const branchName = `${branchPrefix}/${name}-${id.slice(0, 8)}`;
-    const worktreePath = path37__default.join(this.projectRoot, WORKTREES_DIR, `${name}-${id.slice(0, 8)}`);
+    const worktreePath = path38__default.join(this.projectRoot, WORKTREES_DIR, `${name}-${id.slice(0, 8)}`);
     const worktree = {
       id,
       name,
@@ -47485,7 +47906,7 @@ var WorktreeManager = class {
     };
     this.worktrees.set(id, worktree);
     try {
-      await fs34__default.mkdir(path37__default.join(this.projectRoot, WORKTREES_DIR), { recursive: true });
+      await fs35__default.mkdir(path38__default.join(this.projectRoot, WORKTREES_DIR), { recursive: true });
       const baseBranch = options.baseBranch ?? "HEAD";
       await this.git(["worktree", "add", "-b", branchName, worktreePath, baseBranch]);
       worktree.status = "active";
@@ -47678,7 +48099,7 @@ var WorktreeManager = class {
     try {
       await this.git(["push", "-u", "origin", worktree.branch]);
       const title = options.message ?? `Agent: ${worktree.name}`;
-      const { stdout } = await execFileAsync2(
+      const { stdout } = await execFileAsync3(
         "gh",
         [
           "pr",
@@ -47704,10 +48125,10 @@ var WorktreeManager = class {
   }
   // ── Helpers ──────────────────────────────────────────────────────
   async git(args) {
-    return execFileAsync2("git", args, { cwd: this.projectRoot });
+    return execFileAsync3("git", args, { cwd: this.projectRoot });
   }
   async gitIn(cwd, args) {
-    return execFileAsync2("git", args, { cwd });
+    return execFileAsync3("git", args, { cwd });
   }
   async countChangedFiles(branch) {
     try {
@@ -47732,7 +48153,7 @@ var DEFAULT_CONFIG5 = {
 };
 async function runBestOfN(projectRoot, executor, config, callbacks = {}) {
   const cfg = { ...DEFAULT_CONFIG5, ...config };
-  const logger = getLogger();
+  const logger2 = getLogger();
   const startTime = Date.now();
   if (cfg.attempts < 2) {
     return {
@@ -47755,7 +48176,7 @@ async function runBestOfN(projectRoot, executor, config, callbacks = {}) {
   const worktreeManager = new WorktreeManager(projectRoot);
   const attempts = [];
   try {
-    logger.info(`Best-of-N: Creating ${cfg.attempts} worktrees...`);
+    logger2.info(`Best-of-N: Creating ${cfg.attempts} worktrees...`);
     const worktrees = await Promise.all(
       Array.from(
         { length: cfg.attempts },
@@ -47779,7 +48200,7 @@ async function runBestOfN(projectRoot, executor, config, callbacks = {}) {
         durationMs: 0
       });
     }
-    logger.info(`Best-of-N: Running ${cfg.attempts} parallel attempts...`);
+    logger2.info(`Best-of-N: Running ${cfg.attempts} parallel attempts...`);
     await Promise.all(
       attempts.map(async (attempt) => {
         const attemptStart = Date.now();
@@ -47833,7 +48254,7 @@ async function runBestOfN(projectRoot, executor, config, callbacks = {}) {
         attempt.status = "discarded";
       }
     }
-    logger.info(`Best-of-N: Winner is attempt #${winner.index} with score ${winner.score}`);
+    logger2.info(`Best-of-N: Winner is attempt #${winner.index} with score ${winner.score}`);
     for (const attempt of attempts) {
       if (attempt.id !== winner.id) {
         try {
@@ -47848,7 +48269,7 @@ async function runBestOfN(projectRoot, executor, config, callbacks = {}) {
         message: `Best-of-N winner (attempt #${winner.index}, score: ${winner.score})`
       });
       if (!mergeResult.success) {
-        logger.warn(`Best-of-N: Auto-merge failed: ${mergeResult.error}`);
+        logger2.warn(`Best-of-N: Auto-merge failed: ${mergeResult.error}`);
       }
     }
     return {
@@ -48831,8 +49252,8 @@ function formatToolSummary(toolName, input) {
     case "grep":
     case "search_files": {
       const pattern = String(input.pattern || "");
-      const path59 = input.path ? ` in ${input.path}` : "";
-      return `"${pattern}"${path59}`;
+      const path60 = input.path ? ` in ${input.path}` : "";
+      return `"${pattern}"${path60}`;
     }
     case "bash_exec": {
       const cmd = String(input.command || "");
@@ -48853,8 +49274,8 @@ function formatToolSummary(toolName, input) {
 function formatUrl(url) {
   try {
     const u = new URL(url);
-    const path59 = u.pathname.replace(/\/$/, "");
-    const display = path59 ? `${u.hostname} \u203A ${path59.slice(1)}` : u.hostname;
+    const path60 = u.pathname.replace(/\/$/, "");
+    const display = path60 ? `${u.hostname} \u203A ${path60.slice(1)}` : u.hostname;
     const max = Math.max(getTerminalWidth2() - 20, 50);
     return display.length > max ? display.slice(0, max - 1) + "\u2026" : display;
   } catch {
@@ -49084,7 +49505,7 @@ function getAllCommands() {
 }
 
 // src/cli/repl/input/handler.ts
-var HISTORY_FILE = path37.join(os4.homedir(), ".coco", "history");
+var HISTORY_FILE = path38.join(os4.homedir(), ".coco", "history");
 async function handleOptionC(copyFn = copyToClipboard, getLastBlockFn = getLastBlock) {
   const block = getLastBlockFn();
   if (!block) return null;
@@ -49105,7 +49526,7 @@ function loadHistory() {
 }
 function saveHistory(history) {
   try {
-    const dir = path37.dirname(HISTORY_FILE);
+    const dir = path38.dirname(HISTORY_FILE);
     if (!fs5.existsSync(dir)) {
       fs5.mkdirSync(dir, { recursive: true });
     }
@@ -50459,7 +50880,7 @@ function formatDiffPreview(toolCall) {
 }
 async function checkFileExists(filePath) {
   try {
-    await fs34__default.access(filePath);
+    await fs35__default.access(filePath);
     return true;
   } catch {
     return false;
@@ -52256,7 +52677,7 @@ function formatContextUsage(percent) {
 }
 function formatStatusBar(projectPath, config, gitCtx, contextUsagePercent) {
   const parts = [];
-  const projectName = path37__default.basename(projectPath);
+  const projectName = path38__default.basename(projectPath);
   parts.push(chalk.dim("\u{1F4C1} ") + chalk.magenta(projectName));
   const providerName = config.provider.type;
   const modelName = config.provider.model || "default";
@@ -52361,13 +52782,13 @@ async function startRepl(options = {}) {
     }
     await session.skillRegistry.discoverAndRegister(projectPath, getBuiltinSkillsForDiscovery2());
   } catch (skillError) {
-    const logger2 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger();
-    logger2.warn(
+    const logger3 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger();
+    logger3.warn(
       `[Skills] Failed to initialize skills: ${skillError instanceof Error ? skillError.message : String(skillError)}`
     );
   }
   let mcpManager = null;
-  const logger = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger();
+  const logger2 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger();
   try {
     const { getMCPServerManager: getMCPServerManager2 } = await Promise.resolve().then(() => (init_lifecycle(), lifecycle_exports));
     const { MCPRegistryImpl: MCPRegistryImpl2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
@@ -52387,7 +52808,7 @@ async function startRepl(options = {}) {
       try {
         connections = await mcpManager.startAll(enabledServers);
       } catch (startError) {
-        logger.warn(
+        logger2.warn(
           `[MCP] Failed to start servers: ${startError instanceof Error ? startError.message : String(startError)}`
         );
         try {
@@ -52401,18 +52822,18 @@ async function startRepl(options = {}) {
         try {
           await registerMCPTools2(toolRegistry, connection.name, connection.client);
         } catch (toolError) {
-          logger.warn(
+          logger2.warn(
             `[MCP] Failed to register tools for server '${connection.name}': ${toolError instanceof Error ? toolError.message : String(toolError)}`
           );
         }
       }
       const activeCount = connections.size;
       if (activeCount > 0) {
-        logger.info(`[MCP] ${activeCount} MCP server(s) active`);
+        logger2.info(`[MCP] ${activeCount} MCP server(s) active`);
       }
     }
   } catch (mcpError) {
-    logger.warn(
+    logger2.warn(
       `[MCP] Initialization failed: ${mcpError instanceof Error ? mcpError.message : String(mcpError)}`
     );
   }
@@ -52426,12 +52847,12 @@ async function startRepl(options = {}) {
     if (registry.size > 0) {
       hookRegistry = registry;
       hookExecutor = createHookExecutor2();
-      logger.info(`[Hooks] Loaded ${registry.size} hook(s) from ${hooksConfigPath}`);
+      logger2.info(`[Hooks] Loaded ${registry.size} hook(s) from ${hooksConfigPath}`);
     }
   } catch (hookError) {
     const msg = hookError instanceof Error ? hookError.message : String(hookError);
     if (!msg.includes("ENOENT")) {
-      logger.warn(`[Hooks] Failed to load hooks: ${msg}`);
+      logger2.warn(`[Hooks] Failed to load hooks: ${msg}`);
     }
   }
   const inputHandler = createInputHandler();