@corbat-tech/coco 2.24.1 → 2.25.0

package/dist/cli/index.js

@@ -81,6 +81,33 @@ var init_version = __esm({
     VERSION = findPackageJson().version;
   }
 });
+
+// src/config/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  CocoConfigSchema: () => CocoConfigSchema,
+  GitHubConfigSchema: () => GitHubConfigSchema,
+  IntegrationsConfigSchema: () => IntegrationsConfigSchema,
+  MCPConfigSchema: () => MCPConfigSchema,
+  MCPServerConfigEntrySchema: () => MCPServerConfigEntrySchema,
+  PersistenceConfigSchema: () => PersistenceConfigSchema,
+  ProjectConfigSchema: () => ProjectConfigSchema,
+  ProviderConfigSchema: () => ProviderConfigSchema,
+  QualityConfigSchema: () => QualityConfigSchema,
+  ShipConfigSchema: () => ShipConfigSchema,
+  SkillsConfigSchema: () => SkillsConfigSchema,
+  StackConfigSchema: () => StackConfigSchema,
+  ToolsConfigSchema: () => ToolsConfigSchema,
+  createDefaultConfigObject: () => createDefaultConfigObject,
+  validateConfig: () => validateConfig
+});
+function validateConfig(config) {
+  const result = CocoConfigSchema.safeParse(config);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, error: result.error };
+}
 function createDefaultConfigObject(projectName, language = "typescript") {
   return {
     project: {
@@ -200,7 +227,15 @@ var init_schema = __esm({
       enabled: z.boolean().default(true),
       configFile: z.string().optional(),
       // Path to external MCP config file
-      servers: z.array(MCPServerConfigEntrySchema).default([])
+      servers: z.array(MCPServerConfigEntrySchema).default([]),
+      /** Default timeout for MCP requests in milliseconds */
+      defaultTimeout: z.number().min(1e3).default(6e4).optional(),
+      /** Auto-discover MCP servers from well-known locations */
+      autoDiscover: z.boolean().default(true).optional(),
+      /** Log level for MCP operations */
+      logLevel: z.enum(["debug", "info", "warn", "error"]).default("info").optional(),
+      /** Path to custom servers directory */
+      customServersPath: z.string().optional()
     });
     ToolsConfigSchema = z.object({
       webSearch: z.object({
@@ -243,8 +278,12 @@ var init_schema = __esm({
       enabled: z.boolean().default(true),
       /** Override global skills directory */
       globalDir: z.string().optional(),
+      /** Override global skills directories (preferred over globalDir) */
+      globalDirs: z.array(z.string()).optional(),
       /** Override project skills directory */
       projectDir: z.string().optional(),
+      /** Override project skills directories (preferred over projectDir) */
+      projectDirs: z.array(z.string()).optional(),
       /** Auto-activate skills based on user messages */
       autoActivate: z.boolean().default(true),
       /** Maximum concurrent active markdown skills */
@@ -445,7 +484,7 @@ var init_errors = __esm({
     };
   }
 });
-var COCO_HOME, CONFIG_PATHS;
+var COCO_HOME, CONFIG_PATHS, LEGACY_PATHS;
 var init_paths = __esm({
   "src/config/paths.ts"() {
     COCO_HOME = join(homedir(), ".coco");
@@ -475,12 +514,16 @@ var init_paths = __esm({
       /** Search index directory: ~/.coco/search-index/ */
       searchIndex: join(COCO_HOME, "search-index"),
       /** Global skills directory: ~/.coco/skills/ */
-      skills: join(COCO_HOME, "skills")
+      skills: join(COCO_HOME, "skills"),
+      /** MCP server registry: ~/.coco/mcp.json */
+      mcpRegistry: join(COCO_HOME, "mcp.json")
     };
-    ({
+    LEGACY_PATHS = {
       /** Old config location */
-      oldConfig: join(homedir(), ".config", "corbat-coco")
-    });
+      oldConfig: join(homedir(), ".config", "corbat-coco"),
+      /** Old MCP config directory (pre-unification) */
+      oldMcpDir: join(homedir(), ".config", "coco", "mcp")
+    };
   }
 });
 
@@ -658,8 +701,8 @@ async function configExists(configPath, scope = "any") {
   }
   return false;
 }
-function getConfigValue(config, path58) {
-  const keys = path58.split(".");
+function getConfigValue(config, path59) {
+  const keys = path59.split(".");
   let current = config;
   for (const key of keys) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -4650,7 +4693,9 @@ var init_openai = __esm({
                   break;
                 case "response.completed":
                   {
+                    const emittedCallIds = /* @__PURE__ */ new Set();
                     for (const toolCall of toolCallAssembler.finalizeAll(this.name)) {
+                      if (toolCall.id) emittedCallIds.add(toolCall.id);
                       yield {
                         type: "tool_use_end",
                         toolCall: {
@@ -4660,9 +4705,20 @@ var init_openai = __esm({
                         }
                       };
                     }
-                    const hasToolCalls = event.response.output.some(
-                      (i) => i.type === "function_call"
-                    );
+                    const outputItems = event.response?.output ?? [];
+                    for (const item of outputItems) {
+                      if (item.type !== "function_call" || !item.call_id || !item.name) continue;
+                      if (emittedCallIds.has(item.call_id)) continue;
+                      yield {
+                        type: "tool_use_end",
+                        toolCall: {
+                          id: item.call_id,
+                          name: item.name,
+                          input: parseToolCallArguments(item.arguments ?? "{}", this.name)
+                        }
+                      };
+                    }
+                    const hasToolCalls = outputItems.some((i) => i.type === "function_call");
                     yield {
                       type: "done",
                       stopReason: hasToolCalls ? "tool_use" : "end_turn"
@@ -5277,6 +5333,8 @@ var init_codex = __esm({
         const decoder = new TextDecoder();
         let buffer = "";
         const toolCallAssembler = new ResponsesToolCallAssembler();
+        const emittedToolCallIds = /* @__PURE__ */ new Set();
+        const emittedToolCallSignatures = /* @__PURE__ */ new Set();
         let lastActivityTime = Date.now();
         const timeoutController = new AbortController();
         const timeoutInterval = setInterval(() => {
@@ -5339,6 +5397,9 @@ var init_codex = __esm({
                     this.name
                   );
                   if (toolCall) {
+                    if (toolCall.id) emittedToolCallIds.add(toolCall.id);
+                    const signature = `${toolCall.name}:${JSON.stringify(toolCall.input ?? {})}`;
+                    emittedToolCallSignatures.add(signature);
                     yield {
                       type: "tool_use_end",
                       toolCall: {
@@ -5352,6 +5413,9 @@ var init_codex = __esm({
                 }
                 case "response.completed": {
                   for (const toolCall of toolCallAssembler.finalizeAll(this.name)) {
+                    if (toolCall.id) emittedToolCallIds.add(toolCall.id);
+                    const signature = `${toolCall.name}:${JSON.stringify(toolCall.input ?? {})}`;
+                    emittedToolCallSignatures.add(signature);
                     yield {
                       type: "tool_use_end",
                       toolCall: {
@@ -5361,8 +5425,26 @@ var init_codex = __esm({
                       }
                     };
                   }
-                  const resp = event.response;
-                  const output = resp?.output ?? [];
+                  const responsePayload = event.response;
+                  const output = responsePayload?.output ?? [];
+                  for (const item of output) {
+                    if (item.type !== "function_call" || !item.call_id || !item.name) continue;
+                    const parsedInput = parseToolCallArguments(item.arguments ?? "{}", this.name);
+                    const signature = `${item.name}:${JSON.stringify(parsedInput ?? {})}`;
+                    if (emittedToolCallIds.has(item.call_id) || emittedToolCallSignatures.has(signature)) {
+                      continue;
+                    }
+                    emittedToolCallIds.add(item.call_id);
+                    emittedToolCallSignatures.add(signature);
+                    yield {
+                      type: "tool_use_end",
+                      toolCall: {
+                        id: item.call_id,
+                        name: item.name,
+                        input: parsedInput
+                      }
+                    };
+                  }
                   const hasToolCalls = output.some((i) => i.type === "function_call");
                   yield {
                     type: "done",
@@ -6953,6 +7035,9 @@ var init_errors2 = __esm({
     };
   }
 });
+function getDefaultRegistryPath() {
+  return CONFIG_PATHS.mcpRegistry;
+}
 function validateServerConfig(config) {
   if (!config || typeof config !== "object") {
     throw new MCPError(-32602 /* INVALID_PARAMS */, "Server config must be an object");
@@ -7003,9 +7088,6 @@ function validateServerConfig(config) {
     }
   }
 }
-function getDefaultRegistryPath() {
-  return join(DEFAULT_MCP_CONFIG_DIR, DEFAULT_REGISTRY_FILE);
-}
 function parseRegistry(json2) {
   try {
     const parsed = JSON.parse(json2);
@@ -7020,13 +7102,82 @@ function parseRegistry(json2) {
 function serializeRegistry(servers) {
   return JSON.stringify({ servers, version: "1.0" }, null, 2);
 }
-var DEFAULT_MCP_CONFIG_DIR, DEFAULT_REGISTRY_FILE;
+async function migrateMCPData(opts) {
+  const oldDir = LEGACY_PATHS.oldMcpDir;
+  const newRegistry = CONFIG_PATHS.mcpRegistry;
+  const newConfig = CONFIG_PATHS.config;
+  try {
+    await migrateRegistry(oldDir, newRegistry);
+    await migrateGlobalConfig(oldDir, newConfig);
+  } catch (error) {
+    getLogger().warn(
+      `[MCP] Migration failed unexpectedly: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function migrateRegistry(oldDir, newRegistry) {
+  const oldFile = join(oldDir, "registry.json");
+  if (await fileExists(newRegistry)) return;
+  if (!await fileExists(oldFile)) return;
+  try {
+    const content = await readFile(oldFile, "utf-8");
+    const servers = parseRegistry(content);
+    await mkdir(dirname(newRegistry), { recursive: true });
+    await writeFile(newRegistry, serializeRegistry(servers), "utf-8");
+    getLogger().info(
+      `[MCP] Migrated registry from ${oldFile} to ${newRegistry}. The old file can be safely deleted.`
+    );
+  } catch (error) {
+    getLogger().warn(
+      `[MCP] Could not migrate registry: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function migrateGlobalConfig(oldDir, newConfigPath) {
+  const oldFile = join(oldDir, "config.json");
+  if (!await fileExists(oldFile)) return;
+  try {
+    const oldContent = await readFile(oldFile, "utf-8");
+    const oldMcpConfig = JSON.parse(oldContent);
+    let cocoConfig = {};
+    if (await fileExists(newConfigPath)) {
+      const existing = await readFile(newConfigPath, "utf-8");
+      cocoConfig = JSON.parse(existing);
+    }
+    const existingMcp = cocoConfig.mcp ?? {};
+    const fieldsToMigrate = ["defaultTimeout", "autoDiscover", "logLevel", "customServersPath"];
+    let didMerge = false;
+    for (const field of fieldsToMigrate) {
+      if (oldMcpConfig[field] !== void 0 && existingMcp[field] === void 0) {
+        existingMcp[field] = oldMcpConfig[field];
+        didMerge = true;
+      }
+    }
+    if (!didMerge) return;
+    cocoConfig.mcp = existingMcp;
+    await mkdir(dirname(newConfigPath), { recursive: true });
+    await writeFile(newConfigPath, JSON.stringify(cocoConfig, null, 2), "utf-8");
+    getLogger().info(`[MCP] Migrated global MCP settings from ${oldFile} into ${newConfigPath}.`);
+  } catch (error) {
+    getLogger().warn(
+      `[MCP] Could not migrate global MCP config: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function fileExists(path59) {
+  try {
+    await access(path59);
+    return true;
+  } catch {
+    return false;
+  }
+}
 var init_config = __esm({
   "src/mcp/config.ts"() {
+    init_paths();
     init_types();
     init_errors2();
-    DEFAULT_MCP_CONFIG_DIR = join(homedir(), ".config", "coco", "mcp");
-    DEFAULT_REGISTRY_FILE = "registry.json";
+    init_logger();
   }
 });
 
@@ -7124,6 +7275,9 @@ var init_registry = __esm({
        * Load registry from disk
        */
       async load() {
+        if (this.registryPath === getDefaultRegistryPath()) {
+          await migrateMCPData();
+        }
         try {
           await access(this.registryPath);
           const content = await readFile(this.registryPath, "utf-8");
@@ -7143,8 +7297,8 @@ var init_registry = __esm({
       /**
        * Ensure directory exists
        */
-      async ensureDir(path58) {
-        await mkdir(dirname(path58), { recursive: true });
+      async ensureDir(path59) {
+        await mkdir(dirname(path59), { recursive: true });
       }
     };
   }
@@ -7378,8 +7532,8 @@ async function loadSkillFromDirectory(skillDir, scope) {
   if (await isMarkdownSkill(skillDir)) {
     return loadMarkdownMetadata(skillDir, scope);
   }
-  const hasTs = await fileExists(path37__default.join(skillDir, "index.ts"));
-  const hasJs = await fileExists(path37__default.join(skillDir, "index.js"));
+  const hasTs = await fileExists2(path37__default.join(skillDir, "index.ts"));
+  const hasJs = await fileExists2(path37__default.join(skillDir, "index.js"));
   if (hasTs || hasJs) {
     return null;
   }
@@ -7397,7 +7551,7 @@ async function loadFullSkill(metadata) {
   );
   return null;
 }
-async function fileExists(filePath) {
+async function fileExists2(filePath) {
   try {
     await fs34__default.access(filePath);
     return true;
@@ -7412,19 +7566,48 @@ var init_loader2 = __esm({
     init_typescript_loader();
   }
 });
+function parseDiscoveryOptions(options) {
+  return typeof options === "string" ? { globalDir: options } : options ?? {};
+}
+function normalizeDirectories(dirs, relativeBaseDir) {
+  const seen = /* @__PURE__ */ new Set();
+  const normalized = [];
+  const home = homedir();
+  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);
+    if (seen.has(resolved)) continue;
+    seen.add(resolved);
+    normalized.push(resolved);
+  }
+  return normalized;
+}
+function resolveDiscoveryDirs(projectPath, options) {
+  const opts = parseDiscoveryOptions(options);
+  const globalDirs = normalizeDirectories(
+    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)),
+    projectPath
+  );
+  return { globalDirs, projectDirs };
+}
 async function discoverAllSkills(projectPath, builtinSkills = [], options) {
-  const opts = typeof options === "string" ? { globalDir: options } : options ?? {};
   const allSkills = /* @__PURE__ */ new Map();
+  const { globalDirs, projectDirs } = resolveDiscoveryDirs(projectPath, options);
   for (const skill of builtinSkills) {
     const meta = nativeSkillToMetadata(skill, "builtin");
     allSkills.set(meta.id, meta);
   }
-  const resolvedGlobalDir = opts.globalDir ?? GLOBAL_SKILLS_DIR;
-  const globalSkills = await scanSkillsDirectory(resolvedGlobalDir, "global");
-  for (const meta of globalSkills) {
-    applyWithPriority(allSkills, meta);
+  for (const dir of globalDirs) {
+    const globalSkills = await scanSkillsDirectory(dir, "global");
+    for (const meta of globalSkills) {
+      applyWithPriority(allSkills, meta);
+    }
   }
-  const projectDirs = opts.projectDir ? [opts.projectDir] : PROJECT_SKILLS_DIRNAMES.map((d) => path37__default.join(projectPath, d));
   for (const dir of projectDirs) {
     const projectSkills = await scanSkillsDirectory(dir, "project");
     for (const meta of projectSkills) {
@@ -7490,11 +7673,11 @@ async function scanNestedSkills(dir, scope, depth) {
 }
 function applyWithPriority(map, meta) {
   const existing = map.get(meta.id);
-  if (!existing || SCOPE_PRIORITY[meta.scope] > SCOPE_PRIORITY[existing.scope]) {
+  if (!existing || SCOPE_PRIORITY[meta.scope] >= SCOPE_PRIORITY[existing.scope]) {
     map.set(meta.id, meta);
   }
 }
-var GLOBAL_SKILLS_DIR, PROJECT_SKILLS_DIRNAMES, MAX_NESTING_DEPTH;
+var GLOBAL_SKILLS_DIRS, PROJECT_SKILLS_DIRNAMES, MAX_NESTING_DEPTH;
 var init_discovery = __esm({
   "src/skills/discovery.ts"() {
     init_types2();
@@ -7502,14 +7685,31 @@ var init_discovery = __esm({
     init_typescript_loader();
     init_paths();
     init_logger();
-    GLOBAL_SKILLS_DIR = path37__default.join(COCO_HOME, "skills");
+    GLOBAL_SKILLS_DIRS = [
+      path37__default.join(homedir(), ".codex", "skills"),
+      // Codex CLI legacy compat
+      path37__default.join(homedir(), ".gemini", "skills"),
+      // Gemini CLI compat
+      path37__default.join(homedir(), ".opencode", "skills"),
+      // OpenCode compat
+      path37__default.join(homedir(), ".claude", "skills"),
+      // Claude Code compat
+      path37__default.join(homedir(), ".agents", "skills"),
+      // shared cross-agent standard
+      path37__default.join(COCO_HOME, "skills")
+      // Coco native global directory (authoritative for Coco)
+    ];
     PROJECT_SKILLS_DIRNAMES = [
       ".claude/skills",
-      // Claude compat — read for migration/interop (lowest project priority)
-      ".agents/skills",
-      // Shared cross-agent standard (medium priority)
-      ".coco/skills"
-      // Coco native — authoritative (highest project priority)
+      // Claude Code compat — read for migration/interop
+      ".codex/skills",
+      // Codex CLI (OpenAI) compat
+      ".gemini/skills",
+      // Gemini CLI (Google) compat
+      ".opencode/skills",
+      // OpenCode compat
+      ".agents/skills"
+      // Native — cross-agent standard, authoritative (highest priority)
     ];
     MAX_NESTING_DEPTH = 1;
   }
@@ -7811,7 +8011,9 @@ var init_registry2 = __esm({
         }
         const discoveryOptions = {
           globalDir: globalDir ?? this._config.globalDir,
-          projectDir: this._config.projectDir
+          globalDirs: this._config.globalDirs,
+          projectDir: this._config.projectDir,
+          projectDirs: this._config.projectDirs
         };
         const discovered = await discoverAllSkills(projectPath, builtinSkills, discoveryOptions);
         const disabledSet = new Set(this._config.disabled ?? []);
@@ -8032,6 +8234,7 @@ __export(skills_exports, {
   nativeSkillToLoaded: () => nativeSkillToLoaded,
   nativeSkillToMetadata: () => nativeSkillToMetadata,
   resolveCategory: () => resolveCategory,
+  resolveDiscoveryDirs: () => resolveDiscoveryDirs,
   scanSkillsDirectory: () => scanSkillsDirectory,
   stem: () => stem,
   tokenize: () => tokenize
@@ -8732,9 +8935,9 @@ function createEmptyMemoryContext() {
     errors: []
   };
 }
-function createMissingMemoryFile(path58, level) {
+function createMissingMemoryFile(path59, level) {
   return {
-    path: path58,
+    path: path59,
     level,
     content: "",
     sections: [],
@@ -9339,7 +9542,8 @@ async function createDefaultReplConfig() {
     agent: {
       systemPrompt: COCO_SYSTEM_PROMPT,
       maxToolIterations: 25,
-      confirmDestructive: true
+      confirmDestructive: true,
+      enableAutoSwitchProvider: false
     }
   };
 }
@@ -10179,8 +10383,8 @@ __export(trust_store_exports, {
   saveTrustStore: () => saveTrustStore,
   updateLastAccessed: () => updateLastAccessed
 });
-async function ensureDir(path58) {
-  await mkdir(dirname(path58), { recursive: true });
+async function ensureDir(path59) {
+  await mkdir(dirname(path59), { recursive: true });
 }
 async function loadTrustStore(storePath = TRUST_STORE_PATH) {
   try {
@@ -10265,8 +10469,8 @@ function canPerformOperation(store, projectPath, operation) {
   };
   return permissions[level]?.includes(operation) ?? false;
 }
-function normalizePath(path58) {
-  return join(path58);
+function normalizePath(path59) {
+  return join(path59);
 }
 function createTrustStore(storePath = TRUST_STORE_PATH) {
   let store = null;
@@ -10622,12 +10826,12 @@ function humanizeError(message, toolName) {
     return msg;
   }
   if (/ENOENT/i.test(msg)) {
-    const path58 = extractQuotedPath(msg);
-    return path58 ? `File or directory not found: ${path58}` : "File or directory not found";
+    const path59 = extractQuotedPath(msg);
+    return path59 ? `File or directory not found: ${path59}` : "File or directory not found";
   }
   if (/EACCES/i.test(msg)) {
-    const path58 = extractQuotedPath(msg);
-    return path58 ? `Permission denied: ${path58}` : "Permission denied \u2014 check file permissions";
+    const path59 = extractQuotedPath(msg);
+    return path59 ? `Permission denied: ${path59}` : "Permission denied \u2014 check file permissions";
   }
   if (/EISDIR/i.test(msg)) {
     return "Expected a file but found a directory at the specified path";
@@ -10899,7 +11103,7 @@ var MAX_CONSECUTIVE_ERRORS, _safetyNetInstalled;
 var init_error_resilience = __esm({
   "src/cli/repl/error-resilience.ts"() {
     init_errors();
-    MAX_CONSECUTIVE_ERRORS = 2;
+    MAX_CONSECUTIVE_ERRORS = 5;
     _safetyNetInstalled = false;
   }
 });
@@ -11100,7 +11304,7 @@ Suggestion: ${error.suggestion}`;
     };
   }
 });
-async function fileExists2(filePath) {
+async function fileExists3(filePath) {
   try {
     await fs34__default.access(filePath);
     return true;
@@ -11561,9 +11765,9 @@ var init_diff_renderer = __esm({
     getTerminalWidth = () => process.stdout.columns || 80;
   }
 });
-async function fileExists3(path58) {
+async function fileExists4(path59) {
   try {
-    await access(path58);
+    await access(path59);
     return true;
   } catch {
     return false;
@@ -11578,7 +11782,7 @@ async function dirHasFiles(dir) {
   }
 }
 async function detectMaturity(cwd) {
-  const hasPackageJson = await fileExists3(join(cwd, "package.json"));
+  const hasPackageJson = await fileExists4(join(cwd, "package.json"));
   if (!hasPackageJson) {
     const otherManifests = [
       "go.mod",
@@ -11591,7 +11795,7 @@ async function detectMaturity(cwd) {
     ];
     let hasAnyManifest = false;
     for (const m of otherManifests) {
-      if (await fileExists3(join(cwd, m))) {
+      if (await fileExists4(join(cwd, m))) {
         hasAnyManifest = true;
         break;
       }
@@ -11632,7 +11836,7 @@ async function detectMaturity(cwd) {
     cwd,
     ignore: ["node_modules/**", "dist/**", "build/**"]
   });
-  const hasCI = await fileExists3(join(cwd, ".github/workflows")) && await dirHasFiles(join(cwd, ".github/workflows"));
+  const hasCI = await fileExists4(join(cwd, ".github/workflows")) && await dirHasFiles(join(cwd, ".github/workflows"));
   const lintConfigs = [
     ".eslintrc.js",
     ".eslintrc.json",
@@ -11645,7 +11849,7 @@ async function detectMaturity(cwd) {
   ];
   let hasLintConfig = false;
   for (const config of lintConfigs) {
-    if (await fileExists3(join(cwd, config))) {
+    if (await fileExists4(join(cwd, config))) {
       hasLintConfig = true;
       break;
     }
@@ -15943,16 +16147,16 @@ var init_evaluator = __esm({
        * Find source files in project, adapting to the detected language stack.
        */
       async findSourceFiles() {
-        const { access: access16 } = await import('fs/promises');
+        const { access: access17 } = await import('fs/promises');
         const { join: join26 } = await import('path');
         let isJava = false;
         try {
-          await access16(join26(this.projectPath, "pom.xml"));
+          await access17(join26(this.projectPath, "pom.xml"));
           isJava = true;
         } catch {
           for (const f of ["build.gradle", "build.gradle.kts"]) {
             try {
-              await access16(join26(this.projectPath, f));
+              await access17(join26(this.projectPath, f));
               isJava = true;
               break;
             } catch {
@@ -16444,7 +16648,7 @@ async function checkTestCoverage(diff, cwd) {
     );
     if (!hasTestChange) {
       const ext = src.path.match(/\.(ts|tsx|js|jsx)$/)?.[0] ?? ".ts";
-      const testExists = await fileExists2(path37__default.join(cwd, `${baseName}.test${ext}`)) || await fileExists2(path37__default.join(cwd, `${baseName}.spec${ext}`));
+      const testExists = await fileExists3(path37__default.join(cwd, `${baseName}.test${ext}`)) || await fileExists3(path37__default.join(cwd, `${baseName}.spec${ext}`));
       if (testExists) {
         if (src.additions >= TEST_COVERAGE_LARGE_CHANGE_THRESHOLD) {
           findings.push({
@@ -18126,7 +18330,7 @@ var init_github = __esm({
 async function detectVersionFile(cwd) {
   for (const { file, stack, field } of VERSION_FILES) {
     const fullPath = path37__default.join(cwd, file);
-    if (await fileExists2(fullPath)) {
+    if (await fileExists3(fullPath)) {
       const version = await readVersionFromFile(fullPath, stack, field);
       if (version) {
         return { path: file, stack, currentVersion: version, field };
@@ -18231,7 +18435,7 @@ var init_version_detector = __esm({
 async function detectChangelog(cwd) {
   for (const name of CHANGELOG_NAMES) {
     const fullPath = path37__default.join(cwd, name);
-    if (await fileExists2(fullPath)) {
+    if (await fileExists3(fullPath)) {
       const content = await readFile(fullPath, "utf-8");
       const format = detectFormat(content);
       return { path: name, format };
@@ -18313,11 +18517,11 @@ var init_changelog = __esm({
   }
 });
 async function detectStack(cwd) {
-  if (await fileExists2(path37__default.join(cwd, "package.json"))) return "node";
-  if (await fileExists2(path37__default.join(cwd, "Cargo.toml"))) return "rust";
-  if (await fileExists2(path37__default.join(cwd, "pyproject.toml"))) return "python";
-  if (await fileExists2(path37__default.join(cwd, "go.mod"))) return "go";
-  if (await fileExists2(path37__default.join(cwd, "pom.xml"))) return "java";
+  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";
   return "unknown";
 }
 async function detectPackageManager(cwd, stack) {
@@ -18325,16 +18529,16 @@ async function detectPackageManager(cwd, stack) {
   if (stack === "python") return "pip";
   if (stack === "go") return "go";
   if (stack === "node") {
-    if (await fileExists2(path37__default.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-    if (await fileExists2(path37__default.join(cwd, "yarn.lock"))) return "yarn";
-    if (await fileExists2(path37__default.join(cwd, "bun.lockb"))) return "bun";
+    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";
     return "npm";
   }
   return null;
 }
 async function detectCI(cwd) {
   const ghDir = path37__default.join(cwd, ".github", "workflows");
-  if (await fileExists2(ghDir)) {
+  if (await fileExists3(ghDir)) {
     let workflowFiles = [];
     let hasCodeQL = false;
     let hasLinting = false;
@@ -18357,7 +18561,7 @@ async function detectCI(cwd) {
     }
     return { type: "github-actions", workflowFiles, hasCodeQL, hasLinting };
   }
-  if (await fileExists2(path37__default.join(cwd, ".gitlab-ci.yml"))) {
+  if (await fileExists3(path37__default.join(cwd, ".gitlab-ci.yml"))) {
     return {
       type: "gitlab-ci",
       workflowFiles: [".gitlab-ci.yml"],
@@ -18365,7 +18569,7 @@ async function detectCI(cwd) {
       hasLinting: false
     };
   }
-  if (await fileExists2(path37__default.join(cwd, ".circleci"))) {
+  if (await fileExists3(path37__default.join(cwd, ".circleci"))) {
     return { type: "circle-ci", workflowFiles: [], hasCodeQL: false, hasLinting: false };
   }
   return { type: "none", workflowFiles: [], hasCodeQL: false, hasLinting: false };
@@ -21639,13 +21843,13 @@ __export(stack_detector_exports, {
   detectProjectStack: () => detectProjectStack
 });
 async function detectStack2(cwd) {
-  if (await fileExists2(path37__default.join(cwd, "package.json"))) return "node";
-  if (await fileExists2(path37__default.join(cwd, "Cargo.toml"))) return "rust";
-  if (await fileExists2(path37__default.join(cwd, "pyproject.toml"))) return "python";
-  if (await fileExists2(path37__default.join(cwd, "go.mod"))) return "go";
-  if (await fileExists2(path37__default.join(cwd, "pom.xml"))) return "java";
-  if (await fileExists2(path37__default.join(cwd, "build.gradle"))) return "java";
-  if (await fileExists2(path37__default.join(cwd, "build.gradle.kts"))) return "java";
+  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";
   return "unknown";
 }
 async function detectPackageManager3(cwd, stack) {
@@ -21653,17 +21857,17 @@ async function detectPackageManager3(cwd, stack) {
   if (stack === "python") return "pip";
   if (stack === "go") return "go";
   if (stack === "java") {
-    if (await fileExists2(path37__default.join(cwd, "build.gradle")) || await fileExists2(path37__default.join(cwd, "build.gradle.kts"))) {
+    if (await fileExists3(path37__default.join(cwd, "build.gradle")) || await fileExists3(path37__default.join(cwd, "build.gradle.kts"))) {
       return "gradle";
     }
-    if (await fileExists2(path37__default.join(cwd, "pom.xml"))) {
+    if (await fileExists3(path37__default.join(cwd, "pom.xml"))) {
       return "maven";
     }
   }
   if (stack === "node") {
-    if (await fileExists2(path37__default.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-    if (await fileExists2(path37__default.join(cwd, "yarn.lock"))) return "yarn";
-    if (await fileExists2(path37__default.join(cwd, "bun.lockb"))) return "bun";
+    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";
     return "npm";
   }
   return null;
@@ -21701,7 +21905,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 fileExists2(path37__default.join(cwd, "tsconfig.json"))) {
+    if (allDeps.typescript || await fileExists3(path37__default.join(cwd, "tsconfig.json"))) {
       languages.push("TypeScript");
     }
     return {
@@ -21802,7 +22006,7 @@ async function detectProjectStack(cwd) {
     testingFrameworks = parsed.testingFrameworks;
     languages = parsed.languages;
   } else if (stack === "java") {
-    const isGradle = await fileExists2(path37__default.join(cwd, "build.gradle")) || await fileExists2(path37__default.join(cwd, "build.gradle.kts"));
+    const isGradle = await fileExists3(path37__default.join(cwd, "build.gradle")) || await fileExists3(path37__default.join(cwd, "build.gradle.kts"));
     const parsed = isGradle ? { dependencies: {}, frameworks: [], buildTools: ["gradle"], testingFrameworks: ["JUnit"] } : await parsePomXml(cwd);
     dependencies = parsed.dependencies;
     frameworks = parsed.frameworks;
@@ -22088,6 +22292,251 @@ var init_tools = __esm({
   }
 });
 
+// src/mcp/config-loader.ts
+var config_loader_exports = {};
+__export(config_loader_exports, {
+  loadMCPConfigFile: () => loadMCPConfigFile,
+  loadMCPServersFromCOCOConfig: () => loadMCPServersFromCOCOConfig,
+  loadProjectMCPFile: () => loadProjectMCPFile,
+  mergeMCPConfigs: () => mergeMCPConfigs
+});
+function expandEnvVar(value) {
+  return value.replace(/\$\{([^}]+)\}/g, (match, name) => process.env[name] ?? match);
+}
+function expandEnvObject(env2) {
+  const result = {};
+  for (const [k, v] of Object.entries(env2)) {
+    result[k] = expandEnvVar(v);
+  }
+  return result;
+}
+function expandHeaders(headers) {
+  const result = {};
+  for (const [k, v] of Object.entries(headers)) {
+    result[k] = expandEnvVar(v);
+  }
+  return result;
+}
+function convertStandardEntry(name, entry) {
+  if (entry.command) {
+    return {
+      name,
+      transport: "stdio",
+      enabled: entry.enabled ?? true,
+      stdio: {
+        command: entry.command,
+        args: entry.args,
+        env: entry.env ? expandEnvObject(entry.env) : void 0
+      }
+    };
+  }
+  if (entry.url) {
+    const headers = entry.headers ? expandHeaders(entry.headers) : void 0;
+    const authHeader = headers?.["Authorization"] ?? headers?.["authorization"];
+    let auth;
+    if (authHeader) {
+      if (authHeader.startsWith("Bearer ")) {
+        auth = { type: "bearer", token: authHeader.slice(7) };
+      } else {
+        auth = { type: "apikey", token: authHeader };
+      }
+    }
+    return {
+      name,
+      transport: "http",
+      enabled: entry.enabled ?? true,
+      http: {
+        url: entry.url,
+        ...headers && Object.keys(headers).length > 0 ? { headers } : {},
+        ...auth ? { auth } : {}
+      }
+    };
+  }
+  throw new Error(`Server "${name}" must have either "command" (stdio) or "url" (http) defined`);
+}
+async function loadMCPConfigFile(configPath) {
+  try {
+    await access(configPath);
+  } catch {
+    throw new MCPError(-32003 /* CONNECTION_ERROR */, `Config file not found: ${configPath}`);
+  }
+  let content;
+  try {
+    content = await readFile(configPath, "utf-8");
+  } catch (error) {
+    throw new MCPError(
+      -32003 /* CONNECTION_ERROR */,
+      `Failed to read config file: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    throw new MCPError(-32700 /* PARSE_ERROR */, "Invalid JSON in config file");
+  }
+  const obj = parsed;
+  if (obj.mcpServers && typeof obj.mcpServers === "object" && !Array.isArray(obj.mcpServers)) {
+    return loadStandardFormat(obj, configPath);
+  }
+  if (obj.servers && Array.isArray(obj.servers)) {
+    return loadCocoFormat(obj, configPath);
+  }
+  throw new MCPError(
+    -32602 /* INVALID_PARAMS */,
+    'Config file must have either a "mcpServers" object (standard) or a "servers" array (Coco format)'
+  );
+}
+function loadStandardFormat(config, configPath) {
+  const validServers = [];
+  const errors = [];
+  for (const [name, entry] of Object.entries(config.mcpServers)) {
+    if (name.startsWith("_")) continue;
+    try {
+      const converted = convertStandardEntry(name, entry);
+      validateServerConfig(converted);
+      validServers.push(converted);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      errors.push(`Server '${name}': ${message}`);
+    }
+  }
+  if (errors.length > 0) {
+    getLogger().warn(`[MCP] Some servers in ${configPath} failed to load: ${errors.join("; ")}`);
+  }
+  return validServers;
+}
+async function loadProjectMCPFile(projectPath) {
+  const mcpJsonPath = path37__default.join(projectPath, ".mcp.json");
+  try {
+    await access(mcpJsonPath);
+  } catch {
+    return [];
+  }
+  try {
+    return await loadMCPConfigFile(mcpJsonPath);
+  } catch (error) {
+    getLogger().warn(
+      `[MCP] Failed to load .mcp.json: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return [];
+  }
+}
+function loadCocoFormat(config, configPath) {
+  const validServers = [];
+  const errors = [];
+  for (const server of config.servers) {
+    try {
+      const converted = convertCocoServerEntry(server);
+      validateServerConfig(converted);
+      validServers.push(converted);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      errors.push(`Server '${server.name || "unknown"}': ${message}`);
+    }
+  }
+  if (errors.length > 0) {
+    getLogger().warn(`[MCP] Some servers in ${configPath} failed to load: ${errors.join("; ")}`);
+  }
+  return validServers;
+}
+function convertCocoServerEntry(server) {
+  const base = {
+    name: server.name,
+    description: server.description,
+    transport: server.transport,
+    enabled: server.enabled ?? true,
+    metadata: server.metadata
+  };
+  if (server.transport === "stdio" && server.stdio) {
+    return {
+      ...base,
+      stdio: {
+        command: server.stdio.command,
+        args: server.stdio.args,
+        env: server.stdio.env ? expandEnvObject(server.stdio.env) : void 0,
+        cwd: server.stdio.cwd
+      }
+    };
+  }
+  if (server.transport === "http" && server.http) {
+    return {
+      ...base,
+      http: {
+        url: server.http.url,
+        ...server.http.headers ? { headers: expandHeaders(server.http.headers) } : {},
+        ...server.http.auth ? { auth: server.http.auth } : {},
+        ...server.http.timeout !== void 0 ? { timeout: server.http.timeout } : {}
+      }
+    };
+  }
+  throw new Error(`Missing configuration for transport: ${server.transport}`);
+}
+function mergeMCPConfigs(base, ...overrides) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const server of base) {
+    merged.set(server.name, server);
+  }
+  for (const override of overrides) {
+    for (const server of override) {
+      const existing = merged.get(server.name);
+      if (existing) {
+        merged.set(server.name, { ...existing, ...server });
+      } else {
+        merged.set(server.name, server);
+      }
+    }
+  }
+  return Array.from(merged.values());
+}
+async function loadMCPServersFromCOCOConfig(configPath) {
+  const { loadConfig: loadConfig3 } = await Promise.resolve().then(() => (init_loader(), loader_exports));
+  const { MCPServerConfigEntrySchema: MCPServerConfigEntrySchema2 } = await Promise.resolve().then(() => (init_schema(), schema_exports));
+  const config = await loadConfig3(configPath);
+  if (!config.mcp?.servers || config.mcp.servers.length === 0) {
+    return [];
+  }
+  const servers = [];
+  for (const entry of config.mcp.servers) {
+    try {
+      const parsed = MCPServerConfigEntrySchema2.parse(entry);
+      const serverConfig = {
+        name: parsed.name,
+        description: parsed.description,
+        transport: parsed.transport,
+        enabled: parsed.enabled,
+        ...parsed.transport === "stdio" && parsed.command && {
+          stdio: {
+            command: parsed.command,
+            args: parsed.args,
+            env: parsed.env ? expandEnvObject(parsed.env) : void 0
+          }
+        },
+        ...parsed.transport === "http" && parsed.url && {
+          http: {
+            url: parsed.url,
+            auth: parsed.auth
+          }
+        }
+      };
+      validateServerConfig(serverConfig);
+      servers.push(serverConfig);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      getLogger().warn(`[MCP] Failed to load server '${entry.name}': ${message}`);
+    }
+  }
+  return servers;
+}
+var init_config_loader = __esm({
+  "src/mcp/config-loader.ts"() {
+    init_config();
+    init_types();
+    init_errors2();
+    init_logger();
+  }
+});
+
 // src/cli/repl/hooks/types.ts
 function isHookEvent(value) {
   return typeof value === "string" && HOOK_EVENTS.includes(value);
@@ -23415,8 +23864,8 @@ Generated by Corbat-Coco v0.1.0
 
 // 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 (path58, options) => {
-    await runInit(path58, 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 (path59, options) => {
+    await runInit(path59, options);
   });
 }
 async function runInit(projectPath, options) {
@@ -23495,18 +23944,18 @@ async function gatherProjectInfo() {
     language
   };
 }
-function getDefaultProjectInfo(path58) {
-  const name = path58 === "." ? "my-project" : path58.split("/").pop() || "my-project";
+function getDefaultProjectInfo(path59) {
+  const name = path59 === "." ? "my-project" : path59.split("/").pop() || "my-project";
   return {
     name,
     description: "",
     language: "typescript"
   };
 }
-async function checkExistingProject(path58) {
+async function checkExistingProject(path59) {
   try {
     const fs55 = await import('fs/promises');
-    await fs55.access(`${path58}/.coco`);
+    await fs55.access(`${path59}/.coco`);
     return true;
   } catch {
     return false;
@@ -27007,20 +27456,20 @@ async function createCliPhaseContext(projectPath, _onUserInput) {
     },
     tools: {
       file: {
-        async read(path58) {
+        async read(path59) {
           const fs55 = await import('fs/promises');
-          return fs55.readFile(path58, "utf-8");
+          return fs55.readFile(path59, "utf-8");
         },
-        async write(path58, content) {
+        async write(path59, content) {
           const fs55 = await import('fs/promises');
           const nodePath = await import('path');
-          await fs55.mkdir(nodePath.dirname(path58), { recursive: true });
-          await fs55.writeFile(path58, content, "utf-8");
+          await fs55.mkdir(nodePath.dirname(path59), { recursive: true });
+          await fs55.writeFile(path59, content, "utf-8");
         },
-        async exists(path58) {
+        async exists(path59) {
           const fs55 = await import('fs/promises');
           try {
-            await fs55.access(path58);
+            await fs55.access(path59);
             return true;
           } catch {
             return false;
@@ -27376,10 +27825,10 @@ function getPhaseStatusForPhase(phase) {
 }
 async function loadProjectState(cwd, config) {
   const fs55 = await import('fs/promises');
-  const path58 = await import('path');
-  const statePath = path58.join(cwd, ".coco", "state.json");
-  const backlogPath = path58.join(cwd, ".coco", "planning", "backlog.json");
-  const checkpointDir = path58.join(cwd, ".coco", "checkpoints");
+  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");
   let currentPhase = "idle";
   let metrics;
   let sprint;
@@ -28781,8 +29230,8 @@ async function saveConfig2(config) {
   await fs55.mkdir(dir, { recursive: true });
   await fs55.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2));
 }
-function getNestedValue(obj, path58) {
-  const keys = path58.split(".");
+function getNestedValue(obj, path59) {
+  const keys = path59.split(".");
   let current = obj;
   for (const key of keys) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -28792,8 +29241,8 @@ function getNestedValue(obj, path58) {
   }
   return current;
 }
-function setNestedValue(obj, path58, value) {
-  const keys = path58.split(".");
+function setNestedValue(obj, path59, value) {
+  const keys = path59.split(".");
   let current = obj;
   for (let i = 0; i < keys.length - 1; i++) {
     const key = keys[i];
@@ -29068,6 +29517,21 @@ async function runDisableServer(name) {
 init_skills();
 init_skills2();
 init_paths();
+async function loadSkillsSettings() {
+  try {
+    const { loadConfig: loadConfig3 } = await Promise.resolve().then(() => (init_loader(), loader_exports));
+    const config = await loadConfig3();
+    return {
+      globalDir: config.skills?.globalDir,
+      globalDirs: config.skills?.globalDirs,
+      projectDir: config.skills?.projectDir,
+      projectDirs: config.skills?.projectDirs,
+      disabled: config.skills?.disabled ?? []
+    };
+  } catch {
+    return {};
+  }
+}
 function registerSkillsCommand(program2) {
   const skillsCommand = program2.command("skills").description("Manage agent skills (SKILL.md and native)");
   skillsCommand.command("list").description("List all discovered skills").option("-s, --scope <scope>", "Filter by scope (builtin|global|project)").option("-k, --kind <kind>", "Filter by kind (markdown|native)").action(runList);
@@ -29075,6 +29539,16 @@ function registerSkillsCommand(program2) {
   skillsCommand.command("remove").description("Remove an installed skill").argument("<name>", "Skill name to remove").option("-g, --global", "Remove from global directory").option("-y, --yes", "Skip confirmation").action(runRemove);
   skillsCommand.command("info").description("Show details about a skill").argument("<name>", "Skill name").action(runInfo);
   skillsCommand.command("create").description("Create a new skill from template").argument("<name>", "Skill name").option("-g, --global", "Create in global directory").action(runCreate);
+  skillsCommand.command("doctor").description("Explain skill discovery paths, conflicts, and winners").action(runDoctor);
+}
+async function loadSkillsDiscoveryOptions() {
+  const settings = await loadSkillsSettings();
+  return {
+    globalDir: settings.globalDir,
+    globalDirs: settings.globalDirs,
+    projectDir: settings.projectDir,
+    projectDirs: settings.projectDirs
+  };
 }
 async function runList(options) {
   p26.intro(chalk.magenta("Skills"));
@@ -29082,7 +29556,8 @@ async function runList(options) {
   let allSkills;
   try {
     const builtins = getBuiltinSkillsForDiscovery();
-    allSkills = await discoverAllSkills(projectPath, builtins);
+    const discoveryOptions = await loadSkillsDiscoveryOptions();
+    allSkills = await discoverAllSkills(projectPath, builtins, discoveryOptions);
   } catch (error) {
     p26.log.error(
       `Failed to discover skills: ${error instanceof Error ? error.message : String(error)}`
@@ -29110,8 +29585,8 @@ async function runList(options) {
   }
   const scopeLabels = {
     builtin: "Builtin",
-    global: `Global (${CONFIG_PATHS.skills})`,
-    project: `Project (${projectPath}/.coco/skills/)`
+    global: `Global (multi-dir, default includes ${CONFIG_PATHS.skills})`,
+    project: `Project (.agents/skills/, .claude/skills/, ...)`
   };
   for (const [scope, skills] of byScope) {
     const label = scopeLabels[scope] ?? scope;
@@ -29133,7 +29608,7 @@ 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(), ".coco", "skills");
+    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);
@@ -29163,13 +29638,14 @@ async function runAdd(source, options) {
       spinner18.stop("Skill installed successfully");
     } catch (error) {
       spinner18.stop("Installation failed");
-      const stderr = error?.stderr?.toString()?.trim();
+      const spawnError = error;
+      const stderr = spawnError.stderr?.toString().trim();
       const msg = stderr || (error instanceof Error ? error.message : String(error));
       p26.log.error(`Failed to install skill: ${msg}`);
-      p26.log.info("Try installing manually: git clone the repo into .coco/skills/");
+      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(), ".coco", "skills");
+    const targetDir = options.global ? CONFIG_PATHS.skills : path37__default.join(process.cwd(), ".agents", "skills");
     await fs34__default.mkdir(targetDir, { recursive: true });
     const skillName = source.split("/").pop()?.replace(".git", "") ?? "skill";
     const skillDir = path37__default.join(targetDir, skillName);
@@ -29184,7 +29660,8 @@ async function runAdd(source, options) {
       spinner18.stop(`Skill cloned to ${skillDir}`);
     } catch (error) {
       spinner18.stop("Clone failed");
-      const stderr = error?.stderr?.toString()?.trim();
+      const spawnError = error;
+      const stderr = spawnError.stderr?.toString().trim();
       const msg = stderr || (error instanceof Error ? error.message : String(error));
       p26.log.error(`Failed to clone skill: ${msg}`);
     }
@@ -29197,8 +29674,13 @@ 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(), ".coco", "skills");
-  const skillPath = path37__default.join(targetDir, name);
+  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)) {
+    p26.log.error(`Invalid skill name: "${name}"`);
+    p26.outro("");
+    return;
+  }
   try {
     await fs34__default.access(skillPath);
   } catch {
@@ -29226,7 +29708,8 @@ async function runInfo(name) {
   let allSkills;
   try {
     const builtins = getBuiltinSkillsForDiscovery();
-    allSkills = await discoverAllSkills(projectPath, builtins);
+    const discoveryOptions = await loadSkillsDiscoveryOptions();
+    allSkills = await discoverAllSkills(projectPath, builtins, discoveryOptions);
   } catch (error) {
     p26.log.error(
       `Failed to discover skills: ${error instanceof Error ? error.message : String(error)}`
@@ -29277,7 +29760,7 @@ 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(), ".coco", "skills");
+  const targetDir = options.global ? CONFIG_PATHS.skills : path37__default.join(process.cwd(), ".agents", "skills");
   const skillDir = path37__default.join(targetDir, name);
   try {
     await fs34__default.access(skillDir);
@@ -29337,6 +29820,98 @@ when this skill is activated (automatically via matching or manually via /${name
   p26.log.info(`Edit ${path37__default.join(skillDir, "SKILL.md")} to add instructions.`);
   p26.outro("");
 }
+function registerWinner(winners, candidate, candidateScanOrder, scanOrderById) {
+  const existing = winners.get(candidate.id);
+  const existingOrder = scanOrderById.get(candidate.id) ?? -1;
+  const scopePriority = { builtin: 1, global: 2, project: 3 };
+  if (!existing || scopePriority[candidate.scope] > scopePriority[existing.scope] || scopePriority[candidate.scope] === scopePriority[existing.scope] && candidateScanOrder >= existingOrder) {
+    winners.set(candidate.id, candidate);
+    scanOrderById.set(candidate.id, candidateScanOrder);
+  }
+}
+async function runDoctor() {
+  p26.intro(chalk.magenta("Skills Doctor"));
+  const projectPath = process.cwd();
+  const settings = await loadSkillsSettings();
+  const discoveryOptions = {
+    globalDir: settings.globalDir,
+    globalDirs: settings.globalDirs,
+    projectDir: settings.projectDir,
+    projectDirs: settings.projectDirs
+  };
+  const disabled = new Set(settings.disabled ?? []);
+  const builtins = getBuiltinSkillsForDiscovery();
+  const { globalDirs, projectDirs } = resolveDiscoveryDirs(projectPath, discoveryOptions);
+  p26.log.step("Discovery paths (scan order, later wins within same scope)");
+  console.log(chalk.dim("  Global:"));
+  for (const dir of globalDirs) {
+    console.log(chalk.dim(`    - ${dir}`));
+  }
+  console.log(chalk.dim("  Project:"));
+  for (const dir of projectDirs) {
+    console.log(chalk.dim(`    - ${dir}`));
+  }
+  console.log();
+  const winners = /* @__PURE__ */ new Map();
+  const winnerScanOrderById = /* @__PURE__ */ new Map();
+  const candidatesById = /* @__PURE__ */ new Map();
+  let scanOrder = 0;
+  for (const skill of builtins) {
+    const meta = nativeSkillToMetadata(skill, "builtin");
+    meta.path = "<builtin>";
+    registerWinner(winners, meta, scanOrder, winnerScanOrderById);
+    candidatesById.set(meta.id, [meta]);
+    scanOrder += 1;
+  }
+  for (const dir of globalDirs) {
+    const metas = await scanSkillsDirectory(dir, "global");
+    const names = metas.map((m) => m.name).sort().join(", ");
+    p26.log.info(`Global ${dir}: ${metas.length} skills${names ? ` (${names})` : ""}`);
+    for (const meta of metas) {
+      registerWinner(winners, meta, scanOrder, winnerScanOrderById);
+      const list = candidatesById.get(meta.id) ?? [];
+      list.push(meta);
+      candidatesById.set(meta.id, list);
+      scanOrder += 1;
+    }
+  }
+  for (const dir of projectDirs) {
+    const metas = await scanSkillsDirectory(dir, "project");
+    const names = metas.map((m) => m.name).sort().join(", ");
+    p26.log.info(`Project ${dir}: ${metas.length} skills${names ? ` (${names})` : ""}`);
+    for (const meta of metas) {
+      registerWinner(winners, meta, scanOrder, winnerScanOrderById);
+      const list = candidatesById.get(meta.id) ?? [];
+      list.push(meta);
+      candidatesById.set(meta.id, list);
+      scanOrder += 1;
+    }
+  }
+  const conflicts = Array.from(candidatesById.entries()).filter(([, list]) => list.length > 1).sort(([a], [b]) => a.localeCompare(b));
+  const activeWinners = Array.from(winners.values()).filter((meta) => !disabled.has(meta.id));
+  console.log();
+  p26.log.step(`Final active skills: ${activeWinners.length}`);
+  if (disabled.size > 0) {
+    p26.log.info(`Disabled by config: ${Array.from(disabled).sort().join(", ")}`);
+  }
+  if (conflicts.length === 0) {
+    p26.log.success("No naming conflicts detected.");
+    p26.outro("");
+    return;
+  }
+  p26.log.step(`Conflicts detected: ${conflicts.length}`);
+  for (const [id, list] of conflicts) {
+    const winner = winners.get(id);
+    if (!winner) continue;
+    const disabledTag = disabled.has(winner.id) ? chalk.yellow(" [DISABLED]") : "";
+    console.log(`  ${chalk.bold(id)} -> winner: ${winner.path} [${winner.scope}]${disabledTag}`);
+    for (const candidate of list) {
+      const marker = candidate.path === winner.path ? chalk.green("WIN") : chalk.dim("LOSE");
+      console.log(`    - ${marker} ${candidate.path} [${candidate.scope}]`);
+    }
+  }
+  p26.outro("");
+}
 
 // src/cli/commands/check.ts
 init_evaluator();
@@ -29699,9 +30274,9 @@ function registerCheckCommand(program2) {
 // src/swarm/spec-parser.ts
 async function parseSwarmSpec(filePath) {
   const fs55 = await import('fs/promises');
-  const path58 = await import('path');
+  const path59 = await import('path');
   const rawContent = await fs55.readFile(filePath, "utf-8");
-  const ext = path58.extname(filePath).toLowerCase();
+  const ext = path59.extname(filePath).toLowerCase();
   if (ext === ".yaml" || ext === ".yml") {
     return parseYamlSpec(rawContent);
   }
@@ -30031,8 +30606,8 @@ var DEFAULT_AGENT_CONFIG = {
 };
 async function loadAgentConfig(projectPath) {
   const fs55 = await import('fs/promises');
-  const path58 = await import('path');
-  const configPath = path58.join(projectPath, ".coco", "swarm", "agents.json");
+  const path59 = await import('path');
+  const configPath = path59.join(projectPath, ".coco", "swarm", "agents.json");
   try {
     const raw = await fs55.readFile(configPath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -30223,16 +30798,16 @@ async function createBoard(projectPath, spec) {
 }
 async function loadBoard(projectPath) {
   const fs55 = await import('fs/promises');
-  const path58 = await import('path');
-  const boardPath = path58.join(projectPath, ".coco", "swarm", "task-board.json");
+  const path59 = await import('path');
+  const boardPath = path59.join(projectPath, ".coco", "swarm", "task-board.json");
   const raw = await fs55.readFile(boardPath, "utf-8");
   return JSON.parse(raw);
 }
 async function saveBoard(projectPath, board) {
   const fs55 = await import('fs/promises');
-  const path58 = await import('path');
-  const boardDir = path58.join(projectPath, ".coco", "swarm");
-  const boardPath = path58.join(boardDir, "task-board.json");
+  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");
 }
@@ -30400,9 +30975,9 @@ async function defaultPromptHandler(q) {
 }
 async function writeAssumptionsFile(projectPath, projectName, questions, assumptions) {
   const fs55 = await import('fs/promises');
-  const path58 = await import('path');
-  const swarmDir = path58.join(projectPath, ".coco", "swarm");
-  const assumptionsPath = path58.join(swarmDir, "assumptions.md");
+  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 now = (/* @__PURE__ */ new Date()).toISOString();
   const content = [
@@ -30426,9 +31001,9 @@ async function writeAssumptionsFile(projectPath, projectName, questions, assumpt
 // src/swarm/events.ts
 async function appendSwarmEvent(projectPath, event) {
   const fs55 = await import('fs/promises');
-  const path58 = await import('path');
-  const eventsDir = path58.join(projectPath, ".coco", "swarm");
-  const eventsFile = path58.join(eventsDir, "events.jsonl");
+  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");
 }
@@ -30439,9 +31014,9 @@ function createEventId() {
 // src/swarm/knowledge.ts
 async function appendKnowledge(projectPath, entry) {
   const fs55 = await import('fs/promises');
-  const path58 = await import('path');
-  const knowledgeDir = path58.join(projectPath, ".coco", "swarm");
-  const knowledgeFile = path58.join(knowledgeDir, "knowledge.jsonl");
+  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");
 }
@@ -30748,10 +31323,10 @@ async function runSwarmLifecycle(options) {
 async function stageInit(ctx) {
   const { projectPath, spec } = ctx.options;
   const fs55 = await import('fs/promises');
-  const path58 = await import('path');
-  await fs55.mkdir(path58.join(projectPath, ".coco", "swarm"), { recursive: true });
+  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 = path58.join(projectPath, ".coco", "swarm", "spec-summary.json");
+  const specSummaryPath = path59.join(projectPath, ".coco", "swarm", "spec-summary.json");
   const specSummary = {
     projectName: spec.projectName,
     description: spec.description,
@@ -30823,8 +31398,8 @@ async function stagePlan(ctx) {
   ]);
   await createBoard(projectPath, spec);
   const fs55 = await import('fs/promises');
-  const path58 = await import('path');
-  const planPath = path58.join(projectPath, ".coco", "swarm", "plan.json");
+  const path59 = await import('path');
+  const planPath = path59.join(projectPath, ".coco", "swarm", "plan.json");
   await fs55.writeFile(
     planPath,
     JSON.stringify({ pm: pmResult, architect: archResult, bestPractices: bpResult }, null, 2),
@@ -31041,7 +31616,7 @@ async function stageIntegrate(ctx) {
 async function stageOutput(ctx) {
   const { projectPath, outputPath } = ctx.options;
   const fs55 = await import('fs/promises');
-  const path58 = await import('path');
+  const path59 = await import('path');
   const board = await loadBoard(projectPath);
   const featureResults = Array.from(ctx.featureResults.values());
   const summary = {
@@ -31056,7 +31631,7 @@ async function stageOutput(ctx) {
     globalScore: computeGlobalScore(featureResults)
   };
   await fs55.mkdir(outputPath, { recursive: true });
-  const summaryPath = path58.join(outputPath, "swarm-summary.json");
+  const summaryPath = path59.join(outputPath, "swarm-summary.json");
   await fs55.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}`);
@@ -31403,8 +31978,8 @@ var SwarmOrchestrator = class {
       noQuestions = false,
       onProgress
     } = options;
-    const path58 = await import('path');
-    const projectPath = path58.dirname(path58.resolve(specFile));
+    const path59 = await import('path');
+    const projectPath = path59.dirname(path59.resolve(specFile));
     onProgress?.("init", `Parsing spec file: ${specFile}`);
     const spec = await parseSwarmSpec(specFile);
     onProgress?.("init", `Initializing provider: ${providerType}`);
@@ -31415,7 +31990,7 @@ var SwarmOrchestrator = class {
     await runSwarmLifecycle({
       spec,
       projectPath,
-      outputPath: path58.resolve(outputPath),
+      outputPath: path59.resolve(outputPath),
       provider,
       agentConfig,
       minScore,
@@ -33092,7 +33667,13 @@ async function ensureConfiguredV2(config) {
       try {
         const recommended = getRecommendedModel(prov.id);
         const model = recommended?.id || prov.models[0]?.id || "";
-        const providerId = prov.id === "openai" && hasOpenAIOAuthTokens && !process.env[prov.envVar] ? "codex" : prov.id;
+        let providerId = prov.id;
+        if (prov.id === "openai" && hasOpenAIOAuthTokens && !process.env[prov.envVar]) {
+          const tokenResult = await getOrRefreshOAuthToken("openai");
+          if (!tokenResult) continue;
+          process.env["OPENAI_CODEX_TOKEN"] = tokenResult.accessToken;
+          providerId = "codex";
+        }
         const provider = await createProvider(providerId, { model });
         if (await provider.isAvailable()) {
           return {
@@ -34330,8 +34911,8 @@ async function listTrustedProjects2(trustStore) {
   p26.log.message("");
   for (const project of projects) {
     const level = project.approvalLevel.toUpperCase().padEnd(5);
-    const path58 = project.path.length > 50 ? "..." + project.path.slice(-47) : project.path;
-    p26.log.message(`  [${level}] ${path58}`);
+    const path59 = project.path.length > 50 ? "..." + project.path.slice(-47) : project.path;
+    p26.log.message(`  [${level}] ${path59}`);
     p26.log.message(`      Last accessed: ${new Date(project.lastAccessed).toLocaleString()}`);
   }
   p26.log.message("");
@@ -35562,8 +36143,8 @@ function displayRewindResult(result) {
     const fileName = filePath.split("/").pop() ?? filePath;
     console.log(`${chalk.green(String.fromCodePoint(10003))} Restored: ${fileName}`);
   }
-  for (const { path: path58, error } of result.filesFailed) {
-    const fileName = path58.split("/").pop() ?? path58;
+  for (const { path: path59, error } of result.filesFailed) {
+    const fileName = path59.split("/").pop() ?? path59;
     console.log(`${chalk.red(String.fromCodePoint(10007))} Failed: ${fileName} (${error})`);
   }
   if (result.conversationRestored) {
@@ -48250,8 +48831,8 @@ function formatToolSummary(toolName, input) {
     case "grep":
     case "search_files": {
       const pattern = String(input.pattern || "");
-      const path58 = input.path ? ` in ${input.path}` : "";
-      return `"${pattern}"${path58}`;
+      const path59 = input.path ? ` in ${input.path}` : "";
+      return `"${pattern}"${path59}`;
     }
     case "bash_exec": {
       const cmd = String(input.command || "");
@@ -48272,8 +48853,8 @@ function formatToolSummary(toolName, input) {
 function formatUrl(url) {
   try {
     const u = new URL(url);
-    const path58 = u.pathname.replace(/\/$/, "");
-    const display = path58 ? `${u.hostname} \u203A ${path58.slice(1)}` : u.hostname;
+    const path59 = u.pathname.replace(/\/$/, "");
+    const display = path59 ? `${u.hostname} \u203A ${path59.slice(1)}` : u.hostname;
     const max = Math.max(getTerminalWidth2() - 20, 50);
     return display.length > max ? display.slice(0, max - 1) + "\u2026" : display;
   } catch {
@@ -50334,6 +50915,7 @@ var ParallelToolExecutor = class {
     if (signal?.aborted) {
       return { executed: null, skipped: true, reason: "Operation cancelled" };
     }
+    let hookWarning = null;
     if (hookRegistry && hookExecutor) {
       const preContext = {
         event: "PreToolUse",
@@ -50343,7 +50925,23 @@ var ParallelToolExecutor = class {
         projectPath: projectPath ?? process.cwd(),
         timestamp: /* @__PURE__ */ new Date()
       };
-      const preResult = await hookExecutor.executeHooks(hookRegistry, preContext);
+      let preResult;
+      try {
+        preResult = await hookExecutor.executeHooks(hookRegistry, preContext);
+      } catch (error) {
+        if (isAbortError(error, signal)) {
+          return { executed: null, skipped: true, reason: "Operation cancelled" };
+        }
+        const msg = error instanceof Error ? error.message : String(error);
+        hookWarning = `PreToolUse hook failed: ${msg}`;
+        preResult = {
+          event: "PreToolUse",
+          results: [],
+          allSucceeded: false,
+          shouldContinue: true,
+          duration: 0
+        };
+      }
       onHookExecuted?.("PreToolUse", preResult);
       if (!preResult.shouldContinue) {
         return {
@@ -50361,9 +50959,27 @@ var ParallelToolExecutor = class {
     }
     onToolStart?.(toolCall, index, total);
     const startTime = performance.now();
-    const result = await registry.execute(toolCall.name, toolCall.input, { signal });
+    let result;
+    try {
+      result = await registry.execute(toolCall.name, toolCall.input, { signal });
+    } catch (error) {
+      if (isAbortError(error, signal)) {
+        return { executed: null, skipped: true, reason: "Operation cancelled" };
+      }
+      const msg = error instanceof Error ? error.message : String(error);
+      result = {
+        success: false,
+        error: `Unexpected error in ${toolCall.name}: ${msg}`,
+        duration: 0
+      };
+    }
     const duration = performance.now() - startTime;
-    const output = result.success ? JSON.stringify(result.data, null, 2) : result.error ?? "Unknown error";
+    const outputParts = [];
+    if (hookWarning) outputParts.push(hookWarning);
+    outputParts.push(
+      result.success ? JSON.stringify(result.data, null, 2) : result.error ?? "Unknown error"
+    );
+    const output = outputParts.filter(Boolean).join("\n");
     const executedCall = {
       id: toolCall.id,
       name: toolCall.name,
@@ -50391,8 +51007,25 @@ var ParallelToolExecutor = class {
         projectPath: projectPath ?? process.cwd(),
         timestamp: /* @__PURE__ */ new Date()
       };
-      const postResult = await hookExecutor.executeHooks(hookRegistry, postContext);
-      onHookExecuted?.("PostToolUse", postResult);
+      try {
+        const postResult = await hookExecutor.executeHooks(hookRegistry, postContext);
+        onHookExecuted?.("PostToolUse", postResult);
+      } catch (error) {
+        if (isAbortError(error, signal)) {
+          return { executed: null, skipped: true, reason: "Operation cancelled" };
+        }
+        const msg = error instanceof Error ? error.message : String(error);
+        const warningResult = {
+          event: "PostToolUse",
+          results: [],
+          allSucceeded: false,
+          shouldContinue: true,
+          duration: 0
+        };
+        onHookExecuted?.("PostToolUse", warningResult);
+        executedCall.result.output = `${executedCall.result.output}
+PostToolUse hook failed: ${msg}`;
+      }
     }
     onToolEnd?.(executedCall);
     return { executed: executedCall, skipped: false };
@@ -50493,9 +51126,20 @@ async function executeAgentTurn(session, userMessage, provider, toolRegistry, op
   const allTools = toolRegistry.getToolDefinitionsForLLM();
   const tools = session.planMode ? filterReadOnlyTools(allTools) : allTools;
   let iteration = 0;
-  const maxIterations = session.config.agent.maxToolIterations;
+  let maxIterations = session.config.agent.maxToolIterations;
+  const HARD_MAX_ITERATIONS = 100;
+  const MAX_AUTO_ITERATION_EXTENSIONS = 2;
+  const AUTO_ITERATION_EXTENSION_SIZE = Math.max(
+    5,
+    Math.ceil(session.config.agent.maxToolIterations * 0.4)
+  );
+  let autoIterationExtensionsUsed = 0;
   const toolErrorCounts = /* @__PURE__ */ new Map();
   const MAX_CONSECUTIVE_TOOL_ERRORS = 3;
+  const MAX_NO_TOOL_RECOVERY_ATTEMPTS = 3;
+  let noToolRecoveryAttempts = 0;
+  let lastSuccessIterationSignature = "";
+  let repeatedSuccessIterationCount = 0;
   const ITERATION_LIMIT_WARNING_RATIO = 0.75;
   const ITERATION_LIMIT_SUMMARY_PROMPT = `[System: You have now used all allowed iterations and tool calls are no longer available. Write your final response immediately: (1) briefly state what was completed, (2) describe what still needs to be done, (3) give specific next steps so the user can continue. Be concise and direct.]`;
   const INLINE_RESULT_MAX_CHARS = 8e3;
@@ -50510,6 +51154,38 @@ async function executeAgentTurn(session, userMessage, provider, toolRegistry, op
 [... ${omitted.toLocaleString()} characters omitted \u2014 use read_file with offset/limit to retrieve more of '${toolName}' output ...]
 ${tail}`;
   }
+  function shouldRecoverNoToolTurn(stopReason, content) {
+    const trimmed = content.trim();
+    if (stopReason === "tool_use") {
+      return {
+        recover: true,
+        reason: "The previous response indicated tool use, but no tool calls were received. Re-emit the tool call(s) now."
+      };
+    }
+    if (stopReason === "max_tokens" && trimmed.length === 0) {
+      return {
+        recover: true,
+        reason: "The previous response was cut off before producing any usable output. Continue immediately."
+      };
+    }
+    const planningOnly = trimmed.length > 0 && trimmed.length < 320 && /^(voy a|ahora voy|i('| )?ll|i will|let me|starting|preparing|activating|continuo|contin[uú]o|de acuerdo[, ]+voy)\b/i.test(
+      trimmed
+    );
+    if (planningOnly) {
+      return {
+        recover: true,
+        reason: "Do not only describe the next step. Execute it now with concrete tool calls."
+      };
+    }
+    return { recover: false, reason: "" };
+  }
+  function shouldAutoExtendIterationBudget(latestExecuted, latestToolResults, isInErrorLoop) {
+    if (isInErrorLoop) return false;
+    if (latestExecuted.length === 0) return false;
+    if (latestToolResults.length === 0) return false;
+    if (repeatedSuccessIterationCount >= 2) return false;
+    return latestExecuted.some((c) => c.result.success);
+  }
   while (iteration < maxIterations) {
     iteration++;
     const isLastIteration = iteration === maxIterations;
@@ -50655,9 +51331,24 @@ ${tail}`;
         });
         continue;
       }
+      const noToolRecovery = shouldRecoverNoToolTurn(lastStopReason, responseContent);
+      if (noToolRecovery.recover && noToolRecoveryAttempts < MAX_NO_TOOL_RECOVERY_ATTEMPTS && iteration < maxIterations) {
+        noToolRecoveryAttempts++;
+        addMessage(session, {
+          role: "assistant",
+          content: responseContent || "[No output returned in previous step.]"
+        });
+        addMessage(session, {
+          role: "user",
+          content: `[System: ${noToolRecovery.reason}]`
+        });
+        continue;
+      }
+      noToolRecoveryAttempts = 0;
       addMessage(session, { role: "assistant", content: responseContent });
       break;
     }
+    noToolRecoveryAttempts = 0;
     const response = {
       content: responseContent,
       toolCalls: collectedToolCalls
@@ -50665,6 +51356,7 @@ ${tail}`;
     const toolResults = [];
     const toolUses = [];
     let turnAborted = false;
+    let currentIterationExecuted = [];
     const totalTools = response.toolCalls.length;
     const confirmedTools = [];
     const declinedTools = /* @__PURE__ */ new Map();
@@ -50749,6 +51441,7 @@ ${tail}`;
       });
       for (const executed of parallelResult.executed) {
         executedTools.push(executed);
+        currentIterationExecuted.push(executed);
         if (executed.name === "manage_permissions" && executed.result.success) {
           const action = executed.input.action;
           const patterns = executed.input.patterns;
@@ -50876,11 +51569,24 @@ ${tail}`;
         }
       }
     }
+    if (currentIterationExecuted.length > 0 && currentIterationExecuted.every((c) => c.result.success)) {
+      const iterationSignature = currentIterationExecuted.map((c) => `${c.name}:${JSON.stringify(c.input)}`).join("|");
+      if (iterationSignature === lastSuccessIterationSignature) {
+        repeatedSuccessIterationCount++;
+      } else {
+        lastSuccessIterationSignature = iterationSignature;
+        repeatedSuccessIterationCount = 0;
+      }
+    } else {
+      lastSuccessIterationSignature = "";
+      repeatedSuccessIterationCount = 0;
+    }
+    const canAutoExtendNow = isLastIteration && toolResults.length > 0 && autoIterationExtensionsUsed < MAX_AUTO_ITERATION_EXTENSIONS && maxIterations < HARD_MAX_ITERATIONS && shouldAutoExtendIterationBudget(executedTools, toolResults, stuckInErrorLoop);
     if (toolResults.length > 0) {
       const warningThreshold = Math.ceil(maxIterations * ITERATION_LIMIT_WARNING_RATIO);
       const lastIdx = toolResults.length - 1;
       const last = toolResults[lastIdx];
-      if (isLastIteration && !stuckInErrorLoop) {
+      if (isLastIteration && !stuckInErrorLoop && !canAutoExtendNow) {
         toolResults[lastIdx] = {
           ...last,
           content: typeof last.content === "string" ? last.content + `
@@ -50942,6 +51648,16 @@ ${ITERATION_LIMIT_SUMMARY_PROMPT}` : ITERATION_LIMIT_SUMMARY_PROMPT
       }
       break;
     }
+    if (canAutoExtendNow) {
+      autoIterationExtensionsUsed++;
+      const oldMax = maxIterations;
+      maxIterations = Math.min(maxIterations + AUTO_ITERATION_EXTENSION_SIZE, HARD_MAX_ITERATIONS);
+      addMessage(session, {
+        role: "user",
+        content: `[System: Iteration budget auto-extended from ${oldMax} to ${maxIterations} because progress is being made. Continue execution and prioritize completing the remaining critical work.]`
+      });
+      continue;
+    }
     if (isLastIteration && toolResults.length > 0) {
       let summaryThinkingEnded = false;
       options.onThinkingStart?.();
@@ -51606,7 +52322,7 @@ async function startRepl(options = {}) {
   }
   initializeContextManager(session, provider);
   const { createLLMClassifier: createLLMClassifier2 } = await Promise.resolve().then(() => (init_llm_classifier(), llm_classifier_exports));
-  const llmClassifier = createLLMClassifier2(provider);
+  let llmClassifier = createLLMClassifier2(provider);
   const { detectProjectStack: detectProjectStack2 } = await Promise.resolve().then(() => (init_stack_detector(), stack_detector_exports));
   const [projectContext] = await Promise.all([
     detectProjectStack2(projectPath),
@@ -51658,7 +52374,13 @@ async function startRepl(options = {}) {
     const { registerMCPTools: registerMCPTools2 } = await Promise.resolve().then(() => (init_tools(), tools_exports));
     const mcpRegistry = new MCPRegistryImpl2();
     await mcpRegistry.load();
-    const enabledServers = mcpRegistry.listEnabledServers();
+    const registryServers = mcpRegistry.listEnabledServers();
+    const { loadProjectMCPFile: loadProjectMCPFile2, mergeMCPConfigs: mergeMCPConfigs2 } = await Promise.resolve().then(() => (init_config_loader(), config_loader_exports));
+    const projectServers = await loadProjectMCPFile2(process.cwd());
+    const enabledServers = mergeMCPConfigs2(
+      registryServers,
+      projectServers.filter((s) => s.enabled !== false)
+    );
     if (enabledServers.length > 0) {
       mcpManager = getMCPServerManager2();
       let connections;
@@ -51748,6 +52470,127 @@ async function startRepl(options = {}) {
   let warned75 = false;
   let warned90 = false;
   let consecutiveErrors = 0;
+  const AUTO_SWITCH_THRESHOLD = 2;
+  const autoSwitchHistory = /* @__PURE__ */ new Set();
+  const enableAutoSwitchProvider = session.config.agent.enableAutoSwitchProvider === true;
+  const buildReplayMessage = (message) => {
+    if (typeof message === "string") {
+      const trimmed = message.trim();
+      return trimmed.length > 0 ? message : null;
+    }
+    const textParts = [];
+    let imageCount = 0;
+    for (const block of message) {
+      if (block.type === "text" && typeof block.text === "string" && block.text.trim().length > 0) {
+        textParts.push(block.text.trim());
+      } else if (block.type === "image") {
+        imageCount++;
+      }
+    }
+    const text13 = textParts.join("\n\n").trim();
+    if (text13.length > 0) {
+      if (imageCount > 0) {
+        return `${text13}
+
+[System: The original request included ${imageCount} image(s). Use the image context already provided in this conversation.]`;
+      }
+      return text13;
+    }
+    if (imageCount > 0) {
+      return `[System: Retry the previous image-based user request (${imageCount} image(s)). Use the existing image context in the conversation and do not repeat the same failed action.]`;
+    }
+    return null;
+  };
+  const showRecoveryAlternatives = () => {
+    console.log(chalk.yellow("   Choose how to continue:"));
+    console.log(chalk.dim("   1. /provider  \u2192 switch provider"));
+    console.log(chalk.dim("   2. /model     \u2192 switch model"));
+    console.log(chalk.dim("   3. Retry with a narrower scope/task"));
+    console.log(chalk.dim("   4. If needed, share constraints so Coco can adapt strategy"));
+    if (!enableAutoSwitchProvider) {
+      console.log(chalk.dim("   5. (Optional) enable `agent.enableAutoSwitchProvider` in config"));
+    }
+  };
+  const getAutoSwitchCandidates = (current) => {
+    const ordered = [];
+    const push = (p45) => {
+      if (p45 !== current && !ordered.includes(p45)) ordered.push(p45);
+    };
+    if (current === "openai") {
+      push("codex");
+      push("kimi");
+      push("openrouter");
+    } else if (current === "codex") {
+      push("openai");
+      push("openrouter");
+      push("anthropic");
+    } else if (current === "anthropic") {
+      push("openai");
+      push("codex");
+      push("gemini");
+    } else if (current === "gemini") {
+      push("openai");
+      push("codex");
+      push("anthropic");
+    } else if (current === "kimi") {
+      push("openai");
+      push("codex");
+      push("openrouter");
+    }
+    const genericOrder = [
+      "codex",
+      "openai",
+      "anthropic",
+      "gemini",
+      "kimi",
+      "openrouter",
+      "deepseek",
+      "groq",
+      "mistral",
+      "together",
+      "qwen",
+      "lmstudio",
+      "ollama"
+    ];
+    for (const p45 of genericOrder) push(p45);
+    return ordered;
+  };
+  const attemptAutoProviderSwitch = async (reason, originalMessage) => {
+    if (!originalMessage) return false;
+    const currentType = session.config.provider.type;
+    const candidates = getAutoSwitchCandidates(currentType);
+    for (const candidate of candidates) {
+      const edge = `${currentType}->${candidate}`;
+      if (autoSwitchHistory.has(edge)) continue;
+      try {
+        const nextInternalId = getInternalProviderId(candidate);
+        const nextProvider = await createProvider(nextInternalId, {
+          maxTokens: session.config.provider.maxTokens
+        });
+        const ok = await nextProvider.isAvailable();
+        if (!ok) {
+          autoSwitchHistory.add(edge);
+          continue;
+        }
+        provider = nextProvider;
+        session.config.provider.type = candidate;
+        session.config.provider.model = getDefaultModel(candidate);
+        setAgentProvider(provider);
+        initializeContextManager(session, provider);
+        llmClassifier = createLLMClassifier2(provider);
+        autoSwitchHistory.add(edge);
+        console.log(
+          chalk.cyan(
+            `   \u21BA Auto-switched provider: ${currentType} \u2192 ${candidate} (${reason.slice(0, 80)})`
+          )
+        );
+        return true;
+      } catch {
+        autoSwitchHistory.add(edge);
+      }
+    }
+    return false;
+  };
   while (true) {
     let autoInput = null;
     if (pendingQueuedMessages.length > 0) {
@@ -51867,6 +52710,7 @@ ${imagePrompts}`.trim() : imagePrompts;
       agentMessage = input ?? "";
     }
     const originalUserMessage = typeof agentMessage === "string" ? agentMessage : null;
+    const replayUserMessage = buildReplayMessage(agentMessage);
     if (session.skillRegistry && session.skillRegistry.config.autoActivate !== false && typeof agentMessage === "string" && agentMessage.length > 0) {
       const matches = session.skillRegistry.findRelevantSkills(agentMessage, 3, 0.4);
       const mdMatches = matches.filter((m) => m.skill.kind === "markdown");
@@ -52141,12 +52985,12 @@ ${imagePrompts}`.trim() : imagePrompts;
           "\n\n## The user interrupted and modified the task:",
           `- ${modParts}`,
           toolSummary,
-          `Apply the user's modification to the original task: "${originalUserMessage || ""}"`
+          `Apply the user's modification to the original task: "${replayUserMessage || ""}"`
         ].join("\n");
         pendingInterruptionContext = ctx;
         pendingModificationPreview = modParts;
-        if (originalUserMessage) {
-          pendingQueuedMessages = [originalUserMessage, ...turnQueuedMessages];
+        if (replayUserMessage) {
+          pendingQueuedMessages = [replayUserMessage, ...turnQueuedMessages];
         } else {
           pendingQueuedMessages = turnQueuedMessages;
         }
@@ -52181,27 +53025,35 @@ ${imagePrompts}`.trim() : imagePrompts;
       }
       if (result.error) {
         session.messages.length = preCallMessageLength;
-        if (originalUserMessage !== null && consecutiveErrors < MAX_CONSECUTIVE_ERRORS && !isNonRetryableProviderError(new Error(result.error))) {
+        if (replayUserMessage !== null && consecutiveErrors < MAX_CONSECUTIVE_ERRORS && !isNonRetryableProviderError(new Error(result.error))) {
           consecutiveErrors++;
           const humanized = humanizeProviderError(new Error(result.error));
           renderError(humanized);
+          let switched = false;
+          if (enableAutoSwitchProvider && consecutiveErrors >= AUTO_SWITCH_THRESHOLD) {
+            switched = await attemptAutoProviderSwitch(humanized, replayUserMessage);
+          } else if (!enableAutoSwitchProvider && consecutiveErrors >= AUTO_SWITCH_THRESHOLD) {
+            console.log(
+              chalk.dim(
+                "   Tip: repeated provider errors detected. Use /provider, or enable `agent.enableAutoSwitchProvider`."
+              )
+            );
+          }
           console.log(
             chalk.dim(
               `   \u21BB Retrying automatically (attempt ${consecutiveErrors}/${MAX_CONSECUTIVE_ERRORS})\u2026`
             )
           );
-          const recoveryPrefix = `[System: The previous attempt failed with: "${humanized}". Please try a different approach, tool, or method to complete the task. Do NOT repeat the exact same action that caused the error.]
+          const recoveryPrefix = (switched ? `[System: Provider auto-switched to "${session.config.provider.type}" after repeated failures. Adapt your strategy to this provider and continue.]
+
+` : "") + `[System: The previous attempt failed with: "${humanized}". Please try a different approach, tool, or method to complete the task. Do NOT repeat the exact same action that caused the error.]
 
 `;
-          pendingQueuedMessages = [recoveryPrefix + originalUserMessage];
+          pendingQueuedMessages = [recoveryPrefix + replayUserMessage];
         } else {
           renderError(result.error);
-          console.log(
-            chalk.dim("   Recovery failed or error is non-retryable. Returning to prompt.")
-          );
-          console.log(
-            chalk.dim("   Tip: Try /provider or /model to switch, then rephrase and retry.")
-          );
+          console.log(chalk.dim("   Automatic recovery stopped for this turn."));
+          showRecoveryAlternatives();
           consecutiveErrors = 0;
         }
         console.log();
@@ -52365,39 +53217,55 @@ ${imagePrompts}`.trim() : imagePrompts;
         console.log(chalk.dim("   \u2022 Check your subscription status and billing"));
         console.log(chalk.dim("   \u2022 Try a different provider: /provider"));
         console.log(chalk.dim("   \u2022 Switch to a different model: /model"));
+        if (!enableAutoSwitchProvider) {
+          console.log(
+            chalk.dim("   \u2022 Optional: enable `agent.enableAutoSwitchProvider` for auto-failover")
+          );
+        }
+        showRecoveryAlternatives();
         console.log();
         continue;
       }
-      if (originalUserMessage !== null && consecutiveErrors < MAX_CONSECUTIVE_ERRORS && !isNonRetryableProviderError(error)) {
+      if (replayUserMessage !== null && consecutiveErrors < MAX_CONSECUTIVE_ERRORS && !isNonRetryableProviderError(error)) {
         consecutiveErrors++;
         session.messages.length = preCallMessageLength;
         const humanized = humanizeProviderError(error);
         renderError(humanized);
+        let switched = false;
+        if (enableAutoSwitchProvider && consecutiveErrors >= AUTO_SWITCH_THRESHOLD) {
+          switched = await attemptAutoProviderSwitch(humanized, replayUserMessage);
+        } else if (!enableAutoSwitchProvider && consecutiveErrors >= AUTO_SWITCH_THRESHOLD) {
+          console.log(
+            chalk.dim(
+              "   Tip: repeated provider errors detected. Use /provider, or enable `agent.enableAutoSwitchProvider`."
+            )
+          );
+        }
         console.log(
           chalk.dim(
             `   \u21BB Retrying automatically (attempt ${consecutiveErrors}/${MAX_CONSECUTIVE_ERRORS})\u2026`
           )
         );
-        const recoveryPrefix = `[System: The previous attempt failed with the following error: "${humanized}". Please try a different approach, tool, or method to complete the task. Do NOT repeat the exact same action that caused the error.]
+        const recoveryPrefix = (switched ? `[System: Provider auto-switched to "${session.config.provider.type}" after repeated failures. Adapt your strategy to this provider and continue.]
+
+` : "") + `[System: The previous attempt failed with the following error: "${humanized}". Please try a different approach, tool, or method to complete the task. Do NOT repeat the exact same action that caused the error.]
 
 `;
-        pendingQueuedMessages = [recoveryPrefix + originalUserMessage];
+        pendingQueuedMessages = [recoveryPrefix + replayUserMessage];
         continue;
       }
       if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
         consecutiveErrors = 0;
         session.messages.length = preCallMessageLength;
         renderError(errorMsg);
-        console.log(chalk.dim("   Recovery failed after multiple attempts. Returning to prompt."));
-        console.log(
-          chalk.dim("   Tip: Try /provider or /model to switch, then rephrase and retry.")
-        );
+        console.log(chalk.dim("   Recovery exhausted after multiple attempts."));
+        showRecoveryAlternatives();
         continue;
       }
       session.messages.length = preCallMessageLength;
       consecutiveErrors = 0;
       renderError(errorMsg);
-      console.log(chalk.dim("   Tip: Try /provider or /model to switch, then rephrase and retry."));
+      showRecoveryAlternatives();
     } finally {
       clearSpinner();
       if (originalSystemPrompt !== void 0) {