npm - @corbat-tech/coco - Versions diffs - 2.25.0 → 2.25.1 - Mend

@corbat-tech/coco 2.25.0 → 2.25.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/cli/index.js CHANGED Viewed

@@ -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,360 @@ 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;
+  }
+  try {
+    if (process.platform === "darwin") {
+      await execFileAsync2("open", [safeUrl]);
+    } else if (process.platform === "win32") {
+      await execFileAsync2("rundll32", ["url.dll,FileProtocolHandler", safeUrl]);
+    } else {
+      await execFileAsync2("xdg-open", [safeUrl]);
+    }
+    return true;
+  } catch {
+    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 to authenticate.`
+    );
+  }
+  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 +21193,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 +21220,61 @@ 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" || this.config.auth?.type === "bearer") {
+          return false;
+        }
+        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 +21289,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 +21328,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 +21708,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 +21925,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 +21939,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 +21996,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 +22238,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 +22252,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 +22300,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 +22321,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 +22358,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 +22401,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 +22802,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 +24114,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 +24168,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 +24185,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 +24207,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 +24254,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 +24339,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 +25558,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 +25577,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 +25592,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 +25605,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 +25631,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 +25642,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 +25658,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 +25671,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 +25687,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 +25700,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 +25714,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 +25727,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 +25740,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 +27668,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 +27680,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 +27707,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 +27851,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 +28103,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 +28219,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 +28258,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 +28394,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 +29610,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 +29620,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 +29636,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 +30003,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 +30040,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 +30069,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 +30093,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 +30155,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 +30187,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 +30209,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 +30668,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 +31000,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 +31192,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 +31369,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 +31389,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 +31408,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 +31717,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 +31735,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 +31792,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 +32010,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 +32025,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 +32373,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 +32385,7 @@ var SwarmOrchestrator = class {
     await runSwarmLifecycle({
       spec,
       projectPath,
-      outputPath: path59.resolve(outputPath),
+      outputPath: path60.resolve(outputPath),
       provider,
       agentConfig,
       minScore,
@@ -32828,8 +33223,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 +33909,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 +33940,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 +34030,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 +34050,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 +34073,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 +34088,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 +34572,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 +35309,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 +35480,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 +35490,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 +36214,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 +36309,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 +36451,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 +36459,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 +36541,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 +37180,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 +37523,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 +37546,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 +37555,7 @@ end try
     return null;
   } finally {
     try {
-      await fs34.unlink(tmpFile);
+      await fs35.unlink(tmpFile);
     } catch {
     }
   }
@@ -37187,7 +37585,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 +37603,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 +37612,7 @@ if ($img -ne $null) {
     return null;
   } finally {
     try {
-      await fs34.unlink(tmpFile);
+      await fs35.unlink(tmpFile);
     } catch {
     }
   }
@@ -37312,9 +37710,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 +37722,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 +37805,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 +38158,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 +38173,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 +38203,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 +38423,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 +38505,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 +38520,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 +39371,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 +39923,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 +39952,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 +39969,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 +40210,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 +40330,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 +40339,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 +40377,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 +40400,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 +40420,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 +40454,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 +40462,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 +40495,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 +40518,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 +40549,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 +40565,7 @@ Examples:
           await handle.close();
         }
       } else {
-        content = await fs34__default.readFile(absolutePath, encoding);
+        content = await fs35__default.readFile(absolutePath, encoding);
       }
       return {
         content,
@@ -40214,10 +40608,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 +40624,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 +40670,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 +40720,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 +40791,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 +40822,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 +40835,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 +40882,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 +40926,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 +40943,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 +40987,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 +41004,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 +41074,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 +41107,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 +42375,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 +42397,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 +42419,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 +42442,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 +42493,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 +42512,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 +42703,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 +42976,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 +43146,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 +43154,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 +44021,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 +44048,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 +44457,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 +44496,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 +44540,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 +44565,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 +44581,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 +44738,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 +44756,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 +44921,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 +45050,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 +45088,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 +45105,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 +45188,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 +45202,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 +45321,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 +45338,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 +45461,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 +45526,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 +45562,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 +45595,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 +45646,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 +45675,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 +45691,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 +45712,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 +45834,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 +45865,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 +45948,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 +46131,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 +46242,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 +46616,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 +46714,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 +46771,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 +46808,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 +46821,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 +46829,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 +47005,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 +47017,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 +47066,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 +47237,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 +47246,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 +47256,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 +47264,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 +47280,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 +47365,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 +47620,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 +47646,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 +47671,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 +47848,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 +47868,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 +47879,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 +48072,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 +48098,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 +48126,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 +48149,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 +48173,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 +48227,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 +48242,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 +49225,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 +49247,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 +49478,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 +49499,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 +50853,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 +52650,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 +52755,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 +52781,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 +52795,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 +52820,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();