@corbat-tech/coco 2.18.0 → 2.20.0

package/dist/index.js

@@ -1,27 +1,27 @@
-import { homedir } from 'os';
+import * as fs16 from 'fs/promises';
+import fs16__default, { readFile, access, readdir } from 'fs/promises';
 import * as path17 from 'path';
 import path17__default, { dirname, join, basename, resolve } from 'path';
+import { randomUUID } from 'crypto';
+import 'http';
+import { fileURLToPath } from 'url';
 import * as fs4 from 'fs';
 import fs4__default, { readFileSync, constants } from 'fs';
-import * as fs16 from 'fs/promises';
-import fs16__default, { readFile, access, readdir } from 'fs/promises';
-import chalk4 from 'chalk';
+import { z } from 'zod';
 import * as p4 from '@clack/prompts';
-import { fileURLToPath } from 'url';
-import { randomUUID } from 'crypto';
+import chalk5 from 'chalk';
+import { exec, execSync, execFile } from 'child_process';
+import { promisify } from 'util';
+import { homedir } from 'os';
+import JSON5 from 'json5';
 import { execa } from 'execa';
 import { parse } from '@typescript-eslint/typescript-estree';
 import { glob } from 'glob';
-import { exec, execFile, execSync } from 'child_process';
-import { promisify } from 'util';
-import { z } from 'zod';
 import { Logger } from 'tslog';
 import Anthropic from '@anthropic-ai/sdk';
 import { jsonrepair } from 'jsonrepair';
 import OpenAI from 'openai';
-import 'http';
 import { GoogleGenerativeAI, FunctionCallingMode } from '@google/generative-ai';
-import JSON5 from 'json5';
 import 'events';
 import 'minimatch';
 import { simpleGit } from 'simple-git';
@@ -50,6 +50,665 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+
+// src/utils/errors.ts
+function isCocoError(error) {
+  return error instanceof CocoError;
+}
+var CocoError, FileSystemError, ProviderError, ConfigError, PhaseError, TaskError, ToolError, TimeoutError;
+var init_errors = __esm({
+  "src/utils/errors.ts"() {
+    CocoError = class _CocoError extends Error {
+      code;
+      context;
+      recoverable;
+      suggestion;
+      constructor(message, options) {
+        super(message, { cause: options.cause });
+        this.name = "CocoError";
+        this.code = options.code;
+        this.context = options.context ?? {};
+        this.recoverable = options.recoverable ?? false;
+        this.suggestion = options.suggestion;
+        Error.captureStackTrace(this, _CocoError);
+      }
+      /**
+       * Convert to JSON for logging
+       */
+      toJSON() {
+        return {
+          name: this.name,
+          code: this.code,
+          message: this.message,
+          context: this.context,
+          recoverable: this.recoverable,
+          suggestion: this.suggestion,
+          stack: this.stack,
+          cause: this.cause instanceof Error ? this.cause.message : this.cause
+        };
+      }
+    };
+    FileSystemError = class extends CocoError {
+      constructor(message, options) {
+        super(message, {
+          code: "FILESYSTEM_ERROR",
+          context: { path: options.path, operation: options.operation },
+          recoverable: false,
+          suggestion: `Check that the path exists and you have permissions: ${options.path}`,
+          cause: options.cause
+        });
+        this.name = "FileSystemError";
+      }
+    };
+    ProviderError = class extends CocoError {
+      provider;
+      statusCode;
+      constructor(message, options) {
+        super(message, {
+          code: "PROVIDER_ERROR",
+          context: { provider: options.provider, statusCode: options.statusCode },
+          recoverable: options.retryable ?? false,
+          suggestion: options.retryable ? "The request can be retried" : "Check your API key and provider configuration",
+          cause: options.cause
+        });
+        this.name = "ProviderError";
+        this.provider = options.provider;
+        this.statusCode = options.statusCode;
+      }
+    };
+    ConfigError = class extends CocoError {
+      issues;
+      constructor(message, options = {}) {
+        super(message, {
+          code: "CONFIG_ERROR",
+          context: { configPath: options.configPath, issues: options.issues },
+          recoverable: true,
+          suggestion: "Check your .coco/config.json for errors",
+          cause: options.cause
+        });
+        this.name = "ConfigError";
+        this.issues = options.issues ?? [];
+      }
+      /**
+       * Format issues as a readable string
+       */
+      formatIssues() {
+        if (this.issues.length === 0) return "";
+        return this.issues.map((i) => `  - ${i.path}: ${i.message}`).join("\n");
+      }
+    };
+    PhaseError = class extends CocoError {
+      phase;
+      constructor(message, options) {
+        super(message, {
+          code: "PHASE_ERROR",
+          context: { phase: options.phase },
+          recoverable: options.recoverable ?? true,
+          suggestion: `Phase '${options.phase}' failed. Try 'coco resume' to continue.`,
+          cause: options.cause
+        });
+        this.name = "PhaseError";
+        this.phase = options.phase;
+      }
+    };
+    TaskError = class extends CocoError {
+      taskId;
+      iteration;
+      constructor(message, options) {
+        super(message, {
+          code: "TASK_ERROR",
+          context: { taskId: options.taskId, iteration: options.iteration },
+          recoverable: options.recoverable ?? true,
+          suggestion: "The task can be retried from the last checkpoint",
+          cause: options.cause
+        });
+        this.name = "TaskError";
+        this.taskId = options.taskId;
+        this.iteration = options.iteration;
+      }
+    };
+    ToolError = class extends CocoError {
+      tool;
+      constructor(message, options) {
+        super(message, {
+          code: "TOOL_ERROR",
+          context: { tool: options.tool },
+          recoverable: true,
+          suggestion: `Tool '${options.tool}' failed. Check the logs for details.`,
+          cause: options.cause
+        });
+        this.name = "ToolError";
+        this.tool = options.tool;
+      }
+    };
+    TimeoutError = class extends CocoError {
+      timeoutMs;
+      operation;
+      constructor(message, options) {
+        super(message, {
+          code: "TIMEOUT_ERROR",
+          context: { timeoutMs: options.timeoutMs, operation: options.operation },
+          recoverable: true,
+          suggestion: "Try increasing the timeout or simplifying the operation"
+        });
+        this.name = "TimeoutError";
+        this.timeoutMs = options.timeoutMs;
+        this.operation = options.operation;
+      }
+    };
+  }
+});
+async function refreshAccessToken(provider, refreshToken) {
+  const config = OAUTH_CONFIGS[provider];
+  if (!config) {
+    throw new Error(`OAuth not supported for provider: ${provider}`);
+  }
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    client_id: config.clientId,
+    refresh_token: refreshToken
+  });
+  const response = await fetch(config.tokenEndpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: body.toString()
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Token refresh failed: ${error}`);
+  }
+  const data = await response.json();
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token || refreshToken,
+    expiresAt: data.expires_in ? Date.now() + data.expires_in * 1e3 : void 0,
+    tokenType: data.token_type
+  };
+}
+function getTokenStoragePath(provider) {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  return path17.join(home, ".coco", "tokens", `${provider}.json`);
+}
+async function saveTokens(provider, tokens) {
+  const filePath = getTokenStoragePath(provider);
+  const dir = path17.dirname(filePath);
+  await fs16.mkdir(dir, { recursive: true, mode: 448 });
+  await fs16.writeFile(filePath, JSON.stringify(tokens, null, 2), { mode: 384 });
+}
+async function loadTokens(provider) {
+  const filePath = getTokenStoragePath(provider);
+  try {
+    const content = await fs16.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function deleteTokens(provider) {
+  const filePath = getTokenStoragePath(provider);
+  try {
+    await fs16.unlink(filePath);
+  } catch {
+  }
+}
+function isTokenExpired(tokens) {
+  if (!tokens.expiresAt) return false;
+  return Date.now() >= tokens.expiresAt - 5 * 60 * 1e3;
+}
+async function getValidAccessToken(provider) {
+  const config = OAUTH_CONFIGS[provider];
+  if (!config) return null;
+  const tokens = await loadTokens(provider);
+  if (!tokens) return null;
+  if (isTokenExpired(tokens)) {
+    if (tokens.refreshToken) {
+      try {
+        const newTokens = await refreshAccessToken(provider, tokens.refreshToken);
+        await saveTokens(provider, newTokens);
+        return { accessToken: newTokens.accessToken, isNew: true };
+      } catch {
+        await deleteTokens(provider);
+        return null;
+      }
+    }
+    await deleteTokens(provider);
+    return null;
+  }
+  return { accessToken: tokens.accessToken, isNew: false };
+}
+var OAUTH_CONFIGS;
+var init_oauth = __esm({
+  "src/auth/oauth.ts"() {
+    OAUTH_CONFIGS = {
+      /**
+       * OpenAI OAuth (ChatGPT Plus/Pro subscriptions)
+       * Uses the official Codex client ID (same as OpenCode, Codex CLI, etc.)
+       */
+      openai: {
+        provider: "openai",
+        clientId: "app_EMoamEEZ73f0CkXaXp7hrann",
+        authorizationEndpoint: "https://auth.openai.com/oauth/authorize",
+        tokenEndpoint: "https://auth.openai.com/oauth/token",
+        deviceAuthEndpoint: "https://auth.openai.com/oauth/device/code",
+        verificationUri: "https://chatgpt.com/codex/device",
+        scopes: ["openid", "profile", "email", "offline_access"],
+        extraAuthParams: {
+          id_token_add_organizations: "true",
+          codex_cli_simplified_flow: "true",
+          originator: "opencode"
+        }
+      }
+      // NOTE: Gemini OAuth removed - Google's client ID is restricted to official apps
+      // Use API Key (https://aistudio.google.com/apikey) or gcloud ADC instead
+    };
+  }
+});
+var init_pkce = __esm({
+  "src/auth/pkce.ts"() {
+  }
+});
+var init_callback_server = __esm({
+  "src/auth/callback-server.ts"() {
+  }
+});
+function detectWSL() {
+  if (process.env.WSL_DISTRO_NAME || process.env.WSLENV) return true;
+  try {
+    return /microsoft/i.test(readFileSync("/proc/version", "utf-8"));
+  } catch {
+    return false;
+  }
+}
+var isWSL;
+var init_platform = __esm({
+  "src/utils/platform.ts"() {
+    isWSL = detectWSL();
+  }
+});
+async function exchangeForCopilotToken(githubToken) {
+  const response = await fetch(COPILOT_TOKEN_URL, {
+    method: "GET",
+    headers: {
+      Authorization: `token ${githubToken}`,
+      Accept: "application/json",
+      "User-Agent": "Corbat-Coco/1.0"
+    }
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    if (response.status === 401) {
+      throw new CopilotAuthError(
+        "GitHub token is invalid or expired. Please re-authenticate with /provider copilot.",
+        true
+      );
+    }
+    if (response.status === 403) {
+      throw new CopilotAuthError(
+        "GitHub Copilot is not enabled for this account.\n   Please ensure you have an active Copilot subscription:\n   https://github.com/settings/copilot",
+        true
+      );
+    }
+    throw new Error(`Copilot token exchange failed: ${response.status} - ${error}`);
+  }
+  return await response.json();
+}
+function getCopilotBaseUrl(accountType) {
+  if (accountType && accountType in COPILOT_BASE_URLS) {
+    return COPILOT_BASE_URLS[accountType];
+  }
+  return DEFAULT_COPILOT_BASE_URL;
+}
+function getCopilotCredentialsPath() {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  return path17.join(home, ".coco", "tokens", "copilot.json");
+}
+async function saveCopilotCredentials(creds) {
+  const filePath = getCopilotCredentialsPath();
+  const dir = path17.dirname(filePath);
+  await fs16.mkdir(dir, { recursive: true, mode: 448 });
+  await fs16.writeFile(filePath, JSON.stringify(creds, null, 2), { mode: 384 });
+}
+async function loadCopilotCredentials() {
+  try {
+    const content = await fs16.readFile(getCopilotCredentialsPath(), "utf-8");
+    const parsed = CopilotCredentialsSchema.safeParse(JSON.parse(content));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+async function deleteCopilotCredentials() {
+  try {
+    await fs16.unlink(getCopilotCredentialsPath());
+  } catch {
+  }
+}
+function isCopilotTokenExpired(creds) {
+  if (!creds.copilotToken || !creds.copilotTokenExpiresAt) return true;
+  return Date.now() >= creds.copilotTokenExpiresAt - REFRESH_BUFFER_MS;
+}
+async function getValidCopilotToken() {
+  const creds = await loadCopilotCredentials();
+  if (!creds) return null;
+  const envToken = process.env["GITHUB_TOKEN"] || process.env["GH_TOKEN"];
+  const githubToken = envToken || creds.githubToken;
+  if (!isCopilotTokenExpired(creds) && creds.copilotToken) {
+    return {
+      token: creds.copilotToken,
+      baseUrl: getCopilotBaseUrl(creds.accountType),
+      isNew: false
+    };
+  }
+  try {
+    const copilotToken = await exchangeForCopilotToken(githubToken);
+    const updatedCreds = {
+      ...creds,
+      githubToken: creds.githubToken,
+      copilotToken: copilotToken.token,
+      copilotTokenExpiresAt: copilotToken.expires_at * 1e3,
+      accountType: copilotToken.annotations?.copilot_plan ?? creds.accountType
+    };
+    await saveCopilotCredentials(updatedCreds);
+    return {
+      token: copilotToken.token,
+      baseUrl: getCopilotBaseUrl(updatedCreds.accountType),
+      isNew: true
+    };
+  } catch (error) {
+    if (error instanceof CopilotAuthError && error.permanent) {
+      await deleteCopilotCredentials();
+      return null;
+    }
+    throw error;
+  }
+}
+var COPILOT_TOKEN_URL, COPILOT_BASE_URLS, DEFAULT_COPILOT_BASE_URL, REFRESH_BUFFER_MS, CopilotAuthError, CopilotCredentialsSchema;
+var init_copilot = __esm({
+  "src/auth/copilot.ts"() {
+    COPILOT_TOKEN_URL = "https://api.github.com/copilot_internal/v2/token";
+    COPILOT_BASE_URLS = {
+      individual: "https://api.githubcopilot.com",
+      business: "https://api.business.githubcopilot.com",
+      enterprise: "https://api.enterprise.githubcopilot.com"
+    };
+    DEFAULT_COPILOT_BASE_URL = "https://api.githubcopilot.com";
+    REFRESH_BUFFER_MS = 6e4;
+    CopilotAuthError = class extends Error {
+      constructor(message, permanent) {
+        super(message);
+        this.permanent = permanent;
+        this.name = "CopilotAuthError";
+      }
+    };
+    CopilotCredentialsSchema = z.object({
+      githubToken: z.string().min(1),
+      copilotToken: z.string().optional(),
+      copilotTokenExpiresAt: z.number().optional(),
+      accountType: z.string().optional()
+    });
+  }
+});
+var init_flow = __esm({
+  "src/auth/flow.ts"() {
+    init_oauth();
+    init_pkce();
+    init_callback_server();
+    init_platform();
+    init_copilot();
+    promisify(execFile);
+  }
+});
+async function getADCAccessToken() {
+  try {
+    const { stdout } = await execAsync2("gcloud auth application-default print-access-token", {
+      timeout: 1e4
+    });
+    const accessToken = stdout.trim();
+    if (!accessToken) return null;
+    const expiresAt = Date.now() + 55 * 60 * 1e3;
+    return {
+      accessToken,
+      expiresAt
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("not logged in") || message.includes("no application default credentials")) {
+      return null;
+    }
+    return null;
+  }
+}
+async function getCachedADCToken() {
+  if (cachedToken && cachedToken.expiresAt && Date.now() < cachedToken.expiresAt) {
+    return cachedToken;
+  }
+  cachedToken = await getADCAccessToken();
+  return cachedToken;
+}
+var execAsync2, cachedToken;
+var init_gcloud = __esm({
+  "src/auth/gcloud.ts"() {
+    execAsync2 = promisify(exec);
+    cachedToken = null;
+  }
+});
+
+// src/auth/index.ts
+var init_auth = __esm({
+  "src/auth/index.ts"() {
+    init_oauth();
+    init_pkce();
+    init_callback_server();
+    init_flow();
+    init_copilot();
+    init_gcloud();
+  }
+});
+function createDefaultConfigObject(projectName, language = "typescript") {
+  return {
+    project: {
+      name: projectName,
+      version: "0.1.0"
+    },
+    provider: {
+      type: "anthropic",
+      model: "claude-sonnet-4-6",
+      maxTokens: 8192,
+      temperature: 0,
+      timeout: 12e4
+    },
+    quality: {
+      minScore: 85,
+      minCoverage: 80,
+      maxIterations: 10,
+      minIterations: 2,
+      convergenceThreshold: 2,
+      securityThreshold: 100
+    },
+    persistence: {
+      checkpointInterval: 3e5,
+      maxCheckpoints: 50,
+      retentionDays: 7,
+      compressOldCheckpoints: true
+    },
+    stack: {
+      language
+    }
+  };
+}
+var ProviderConfigSchema, QualityConfigSchema, PersistenceConfigSchema, StackConfigSchema, ProjectConfigSchema2, GitHubConfigSchema, IntegrationsConfigSchema, MCPServerConfigEntrySchema, MCPConfigSchema, ToolsConfigSchema, ShipConfigSchema, SkillsConfigSchema, CocoConfigSchema;
+var init_schema = __esm({
+  "src/config/schema.ts"() {
+    ProviderConfigSchema = z.object({
+      type: z.enum([
+        "anthropic",
+        "openai",
+        "codex",
+        "copilot",
+        "gemini",
+        "kimi",
+        "kimi-code",
+        "lmstudio",
+        "ollama",
+        "groq",
+        "openrouter",
+        "mistral",
+        "deepseek",
+        "together",
+        "huggingface",
+        "qwen"
+      ]).default("anthropic"),
+      apiKey: z.string().optional(),
+      model: z.string().default("claude-sonnet-4-6"),
+      maxTokens: z.number().min(1).max(2e5).default(8192),
+      temperature: z.number().min(0).max(2).default(0),
+      timeout: z.number().min(1e3).default(12e4)
+    });
+    QualityConfigSchema = z.object({
+      minScore: z.number().min(0).max(100).default(85),
+      minCoverage: z.number().min(0).max(100).default(80),
+      maxIterations: z.number().min(1).max(20).default(10),
+      minIterations: z.number().min(1).max(10).default(2),
+      convergenceThreshold: z.number().min(0).max(10).default(2),
+      securityThreshold: z.number().min(0).max(100).default(100)
+    }).refine((data) => data.minIterations <= data.maxIterations, {
+      message: "minIterations must be <= maxIterations",
+      path: ["minIterations"]
+    });
+    PersistenceConfigSchema = z.object({
+      checkpointInterval: z.number().min(6e4).default(3e5),
+      // 5 min default
+      maxCheckpoints: z.number().min(1).max(100).default(50),
+      retentionDays: z.number().min(1).max(365).default(7),
+      compressOldCheckpoints: z.boolean().default(true)
+    });
+    StackConfigSchema = z.object({
+      language: z.enum(["typescript", "python", "go", "rust", "java"]),
+      framework: z.string().optional(),
+      profile: z.string().optional()
+      // Custom profile path
+    });
+    ProjectConfigSchema2 = z.object({
+      name: z.string().min(1),
+      version: z.string().default("0.1.0"),
+      description: z.string().optional()
+    });
+    GitHubConfigSchema = z.object({
+      enabled: z.boolean().default(false),
+      token: z.string().optional(),
+      repo: z.string().optional(),
+      createPRs: z.boolean().default(true),
+      createIssues: z.boolean().default(true)
+    });
+    IntegrationsConfigSchema = z.object({
+      github: GitHubConfigSchema.optional()
+    });
+    MCPServerConfigEntrySchema = z.object({
+      name: z.string(),
+      transport: z.enum(["stdio", "http", "sse"]),
+      command: z.string().optional(),
+      args: z.array(z.string()).optional(),
+      url: z.string().optional(),
+      env: z.record(z.string(), z.string()).optional(),
+      auth: z.object({
+        type: z.enum(["oauth", "bearer", "apikey"]),
+        token: z.string().optional(),
+        tokenEnv: z.string().optional(),
+        headerName: z.string().optional()
+      }).optional(),
+      enabled: z.boolean().default(true),
+      description: z.string().optional()
+    });
+    MCPConfigSchema = z.object({
+      enabled: z.boolean().default(true),
+      configFile: z.string().optional(),
+      // Path to external MCP config file
+      servers: z.array(MCPServerConfigEntrySchema).default([])
+    });
+    ToolsConfigSchema = z.object({
+      webSearch: z.object({
+        engine: z.enum(["duckduckgo", "brave", "serpapi"]).default("duckduckgo"),
+        apiKey: z.string().optional(),
+        maxResults: z.number().min(1).max(20).default(5)
+      }).optional(),
+      memory: z.object({
+        maxMemories: z.number().min(1).max(1e4).default(1e3),
+        scope: z.enum(["global", "project", "both"]).default("project")
+      }).optional(),
+      checkpoint: z.object({
+        maxCheckpoints: z.number().min(1).max(200).default(50),
+        useGitStash: z.boolean().default(true)
+      }).optional(),
+      semanticSearch: z.object({
+        model: z.string().default("all-MiniLM-L6-v2"),
+        chunkSize: z.number().min(5).max(100).default(20),
+        threshold: z.number().min(0).max(1).default(0.3)
+      }).optional()
+    });
+    ShipConfigSchema = z.object({
+      /** Default base branch for PRs */
+      defaultBaseBranch: z.string().default("main"),
+      /** Auto-detect version bump from commit history */
+      autoDetectBump: z.boolean().default(true),
+      /** Use squash merge for PRs */
+      squashMerge: z.boolean().default(true),
+      /** Delete feature branch after merge */
+      deleteBranchAfterMerge: z.boolean().default(true),
+      /** Create PRs as draft by default */
+      draftPr: z.boolean().default(false),
+      /** CI check timeout in ms (default 10 minutes) */
+      ciCheckTimeoutMs: z.number().default(6e5),
+      /** CI check poll interval in ms (default 15 seconds) */
+      ciCheckPollMs: z.number().default(15e3)
+    });
+    SkillsConfigSchema = z.object({
+      /** Enable/disable skills system */
+      enabled: z.boolean().default(true),
+      /** Override global skills directory */
+      globalDir: z.string().optional(),
+      /** Override project skills directory */
+      projectDir: z.string().optional(),
+      /** Auto-activate skills based on user messages */
+      autoActivate: z.boolean().default(true),
+      /** Maximum concurrent active markdown skills */
+      maxActiveSkills: z.number().min(1).max(10).default(3),
+      /** List of skill IDs to disable */
+      disabled: z.array(z.string()).default([])
+    });
+    CocoConfigSchema = z.object({
+      project: ProjectConfigSchema2,
+      provider: ProviderConfigSchema.default({
+        type: "anthropic",
+        model: "claude-sonnet-4-6",
+        maxTokens: 8192,
+        temperature: 0,
+        timeout: 12e4
+      }),
+      quality: QualityConfigSchema.default({
+        minScore: 85,
+        minCoverage: 80,
+        maxIterations: 10,
+        minIterations: 2,
+        convergenceThreshold: 2,
+        securityThreshold: 100
+      }),
+      persistence: PersistenceConfigSchema.default({
+        checkpointInterval: 3e5,
+        maxCheckpoints: 50,
+        retentionDays: 7,
+        compressOldCheckpoints: true
+      }),
+      stack: StackConfigSchema.optional(),
+      integrations: IntegrationsConfigSchema.optional(),
+      mcp: MCPConfigSchema.optional(),
+      tools: ToolsConfigSchema.optional(),
+      ship: ShipConfigSchema.optional(),
+      skills: SkillsConfigSchema.optional()
+    });
+  }
+});
 var COCO_HOME, CONFIG_PATHS;
 var init_paths = __esm({
   "src/config/paths.ts"() {
@@ -88,6 +747,135 @@ var init_paths = __esm({
     });
   }
 });
+async function loadConfig(configPath) {
+  let config = createDefaultConfig("my-project");
+  const globalConfig = await loadConfigFile(CONFIG_PATHS.config, { strict: false });
+  if (globalConfig) {
+    config = deepMergeConfig(config, globalConfig);
+  }
+  const projectConfigPath = configPath || getProjectConfigPath2();
+  const projectConfig = await loadConfigFile(projectConfigPath);
+  if (projectConfig) {
+    config = deepMergeConfig(config, projectConfig);
+  }
+  return config;
+}
+async function loadConfigFile(configPath, options = {}) {
+  const { strict = true } = options;
+  try {
+    const content = await fs16__default.readFile(configPath, "utf-8");
+    const parsed = JSON5.parse(content);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      if (!strict) {
+        return null;
+      }
+      throw new ConfigError("Invalid configuration: expected an object", {
+        configPath
+      });
+    }
+    const result = CocoConfigSchema.partial().safeParse(parsed);
+    if (!result.success && strict) {
+      const issues = result.error.issues.map((i) => ({
+        path: i.path.join("."),
+        message: i.message
+      }));
+      throw new ConfigError("Invalid configuration", {
+        issues,
+        configPath
+      });
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof ConfigError) {
+      throw error;
+    }
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw new ConfigError("Failed to load configuration", {
+      configPath,
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+}
+function deepMergeConfig(base, override) {
+  return {
+    ...base,
+    ...override,
+    project: { ...base.project, ...override.project },
+    provider: { ...base.provider, ...override.provider },
+    quality: { ...base.quality, ...override.quality },
+    persistence: { ...base.persistence, ...override.persistence },
+    // Merge optional sections only if present in either base or override
+    ...base.stack || override.stack ? { stack: { ...base.stack, ...override.stack } } : {},
+    ...base.integrations || override.integrations ? {
+      integrations: {
+        ...base.integrations,
+        ...override.integrations
+      }
+    } : {},
+    ...base.mcp || override.mcp ? { mcp: { ...base.mcp, ...override.mcp } } : {},
+    ...base.tools || override.tools ? { tools: { ...base.tools, ...override.tools } } : {}
+  };
+}
+function getProjectConfigPath2() {
+  return path17__default.join(process.cwd(), ".coco", "config.json");
+}
+async function saveConfig(config, configPath, global = false) {
+  const result = CocoConfigSchema.safeParse(config);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => ({
+      path: i.path.join("."),
+      message: i.message
+    }));
+    throw new ConfigError("Cannot save invalid configuration", {
+      issues,
+      configPath: configPath || getProjectConfigPath2()
+    });
+  }
+  const resolvedPath = configPath || (global ? CONFIG_PATHS.config : getProjectConfigPath2());
+  const dir = path17__default.dirname(resolvedPath);
+  await fs16__default.mkdir(dir, { recursive: true });
+  const content = JSON.stringify(result.data, null, 2);
+  await fs16__default.writeFile(resolvedPath, content, "utf-8");
+}
+function createDefaultConfig(projectName, language = "typescript") {
+  return createDefaultConfigObject(projectName, language);
+}
+async function configExists(configPath, scope = "any") {
+  if (configPath) {
+    try {
+      await fs16__default.access(configPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  if (scope === "project" || scope === "any") {
+    try {
+      await fs16__default.access(getProjectConfigPath2());
+      return true;
+    } catch {
+      if (scope === "project") return false;
+    }
+  }
+  if (scope === "global" || scope === "any") {
+    try {
+      await fs16__default.access(CONFIG_PATHS.config);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+var init_loader = __esm({
+  "src/config/loader.ts"() {
+    init_schema();
+    init_errors();
+    init_paths();
+  }
+});
 function loadGlobalCocoEnv() {
   try {
     const home = process.env.HOME || process.env.USERPROFILE || "";
@@ -199,40 +987,40 @@ function getDefaultModel(provider) {
     case "lmstudio":
       return process.env["LMSTUDIO_MODEL"] ?? "local-model";
     case "ollama":
-      return process.env["OLLAMA_MODEL"] ?? "llama3.1";
+      return process.env["OLLAMA_MODEL"] ?? "llama3.2";
     case "codex":
-      return process.env["CODEX_MODEL"] ?? "gpt-5.4-codex";
+      return process.env["CODEX_MODEL"] ?? "codex-mini-latest";
     case "copilot":
-      return process.env["COPILOT_MODEL"] ?? "claude-sonnet-4.6";
+      return process.env["COPILOT_MODEL"] ?? "gpt-4o-copilot";
     case "groq":
       return process.env["GROQ_MODEL"] ?? "llama-3.3-70b-versatile";
     case "openrouter":
-      return process.env["OPENROUTER_MODEL"] ?? "anthropic/claude-opus-4-6";
+      return process.env["OPENROUTER_MODEL"] ?? "anthropic/claude-3.5-sonnet";
     case "mistral":
-      return process.env["MISTRAL_MODEL"] ?? "codestral-latest";
+      return process.env["MISTRAL_MODEL"] ?? "mistral-large-latest";
     case "deepseek":
-      return process.env["DEEPSEEK_MODEL"] ?? "deepseek-coder";
+      return process.env["DEEPSEEK_MODEL"] ?? "deepseek-chat";
     case "together":
-      return process.env["TOGETHER_MODEL"] ?? "Qwen/Qwen2.5-Coder-32B-Instruct";
+      return process.env["TOGETHER_MODEL"] ?? "meta-llama/Llama-3.3-70B-Instruct-Turbo";
     case "huggingface":
-      return process.env["HF_MODEL"] ?? "Qwen/Qwen2.5-Coder-32B-Instruct";
+      return process.env["HF_MODEL"] ?? "meta-llama/Llama-3.1-70B-Instruct";
     case "qwen":
-      return process.env["QWEN_MODEL"] ?? "qwen-coder-plus";
+      return process.env["QWEN_MODEL"] ?? "qwen-max";
     default:
-      return "gpt-5.4-codex";
+      return "claude-sonnet-4-6";
   }
 }
 function getDefaultProvider() {
-  const provider = process.env["COCO_PROVIDER"]?.toLowerCase();
-  if (provider && VALID_PROVIDERS.includes(provider)) {
-    return provider;
+  const envProvider = process.env["COCO_PROVIDER"]?.toLowerCase();
+  if (envProvider && VALID_PROVIDERS.includes(envProvider)) {
+    return envProvider;
   }
   return "anthropic";
 }
 var VALID_PROVIDERS;
 var init_env = __esm({
   "src/config/env.ts"() {
-    init_paths();
+    init_loader();
     loadGlobalCocoEnv();
     VALID_PROVIDERS = [
       "anthropic",
@@ -406,8 +1194,8 @@ __export(allow_path_prompt_exports, {
 async function promptAllowPath(dirPath) {
   const absolute = path17__default.resolve(dirPath);
   console.log();
-  console.log(chalk4.yellow("  \u26A0 Access denied \u2014 path is outside the project directory"));
-  console.log(chalk4.dim(`  \u{1F4C1} ${absolute}`));
+  console.log(chalk5.yellow("  \u26A0 Access denied \u2014 path is outside the project directory"));
+  console.log(chalk5.dim(`  \u{1F4C1} ${absolute}`));
   console.log();
   const action = await p4.select({
     message: "Grant access to this directory?",
@@ -430,7 +1218,7 @@ async function promptAllowPath(dirPath) {
   }
   const levelLabel = level === "write" ? "write" : "read-only";
   const persistLabel = persist ? " (remembered)" : "";
-  console.log(chalk4.green(`  \u2713 Access granted: ${levelLabel}${persistLabel}`));
+  console.log(chalk5.green(`  \u2713 Access granted: ${levelLabel}${persistLabel}`));
   return true;
 }
 var init_allow_path_prompt = __esm({
@@ -694,148 +1482,8 @@ function fillPrompt(template, variables) {
   return result;
 }
 
-// src/utils/errors.ts
-var CocoError = class _CocoError extends Error {
-  code;
-  context;
-  recoverable;
-  suggestion;
-  constructor(message, options) {
-    super(message, { cause: options.cause });
-    this.name = "CocoError";
-    this.code = options.code;
-    this.context = options.context ?? {};
-    this.recoverable = options.recoverable ?? false;
-    this.suggestion = options.suggestion;
-    Error.captureStackTrace(this, _CocoError);
-  }
-  /**
-   * Convert to JSON for logging
-   */
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      context: this.context,
-      recoverable: this.recoverable,
-      suggestion: this.suggestion,
-      stack: this.stack,
-      cause: this.cause instanceof Error ? this.cause.message : this.cause
-    };
-  }
-};
-var FileSystemError = class extends CocoError {
-  constructor(message, options) {
-    super(message, {
-      code: "FILESYSTEM_ERROR",
-      context: { path: options.path, operation: options.operation },
-      recoverable: false,
-      suggestion: `Check that the path exists and you have permissions: ${options.path}`,
-      cause: options.cause
-    });
-    this.name = "FileSystemError";
-  }
-};
-var ProviderError = class extends CocoError {
-  provider;
-  statusCode;
-  constructor(message, options) {
-    super(message, {
-      code: "PROVIDER_ERROR",
-      context: { provider: options.provider, statusCode: options.statusCode },
-      recoverable: options.retryable ?? false,
-      suggestion: options.retryable ? "The request can be retried" : "Check your API key and provider configuration",
-      cause: options.cause
-    });
-    this.name = "ProviderError";
-    this.provider = options.provider;
-    this.statusCode = options.statusCode;
-  }
-};
-var ConfigError = class extends CocoError {
-  issues;
-  constructor(message, options = {}) {
-    super(message, {
-      code: "CONFIG_ERROR",
-      context: { configPath: options.configPath, issues: options.issues },
-      recoverable: true,
-      suggestion: "Check your .coco/config.json for errors",
-      cause: options.cause
-    });
-    this.name = "ConfigError";
-    this.issues = options.issues ?? [];
-  }
-  /**
-   * Format issues as a readable string
-   */
-  formatIssues() {
-    if (this.issues.length === 0) return "";
-    return this.issues.map((i) => `  - ${i.path}: ${i.message}`).join("\n");
-  }
-};
-var PhaseError = class extends CocoError {
-  phase;
-  constructor(message, options) {
-    super(message, {
-      code: "PHASE_ERROR",
-      context: { phase: options.phase },
-      recoverable: options.recoverable ?? true,
-      suggestion: `Phase '${options.phase}' failed. Try 'coco resume' to continue.`,
-      cause: options.cause
-    });
-    this.name = "PhaseError";
-    this.phase = options.phase;
-  }
-};
-var TaskError = class extends CocoError {
-  taskId;
-  iteration;
-  constructor(message, options) {
-    super(message, {
-      code: "TASK_ERROR",
-      context: { taskId: options.taskId, iteration: options.iteration },
-      recoverable: options.recoverable ?? true,
-      suggestion: "The task can be retried from the last checkpoint",
-      cause: options.cause
-    });
-    this.name = "TaskError";
-    this.taskId = options.taskId;
-    this.iteration = options.iteration;
-  }
-};
-var ToolError = class extends CocoError {
-  tool;
-  constructor(message, options) {
-    super(message, {
-      code: "TOOL_ERROR",
-      context: { tool: options.tool },
-      recoverable: true,
-      suggestion: `Tool '${options.tool}' failed. Check the logs for details.`,
-      cause: options.cause
-    });
-    this.name = "ToolError";
-    this.tool = options.tool;
-  }
-};
-var TimeoutError = class extends CocoError {
-  timeoutMs;
-  operation;
-  constructor(message, options) {
-    super(message, {
-      code: "TIMEOUT_ERROR",
-      context: { timeoutMs: options.timeoutMs, operation: options.operation },
-      recoverable: true,
-      suggestion: "Try increasing the timeout or simplifying the operation"
-    });
-    this.name = "TimeoutError";
-    this.timeoutMs = options.timeoutMs;
-    this.operation = options.operation;
-  }
-};
-function isCocoError(error) {
-  return error instanceof CocoError;
-}
+// src/phases/converge/discovery.ts
+init_errors();
 function normalizeComplexity(value) {
   const normalized = value?.toLowerCase();
   if (normalized === "simple") return "simple";
@@ -1281,6 +1929,9 @@ function createDiscoveryEngine(llm, config) {
   return new DiscoveryEngine(llm, config);
 }
 
+// src/phases/converge/specification.ts
+init_errors();
+
 // src/phases/converge/specification-types.ts
 var DEFAULT_SPEC_CONFIG = {
   includeDiagrams: true,
@@ -1784,6 +2435,9 @@ ${parsed.dataFlow}
 function createSpecificationGenerator(llm, config) {
   return new SpecificationGenerator(llm, config);
 }
+
+// src/phases/converge/persistence.ts
+init_errors();
 function getPersistencePaths(projectPath) {
   const baseDir = path17__default.join(projectPath, ".coco", "spec");
   return {
@@ -2066,6 +2720,7 @@ function createSessionManager(projectPath) {
 }
 
 // src/phases/converge/executor.ts
+init_errors();
 var DEFAULT_CONVERGE_CONFIG = {
   maxQuestionRounds: 3,
   maxQuestionsPerRound: 3,
@@ -2756,6 +3411,9 @@ function fillPrompt2(template, variables) {
   }
   return result;
 }
+
+// src/phases/orchestrate/architecture.ts
+init_errors();
 function parseOverview(data) {
   return {
     pattern: data?.pattern || "layered",
@@ -3094,6 +3752,7 @@ var ArchitectureGenerator = class {
 function createArchitectureGenerator(llm, config) {
   return new ArchitectureGenerator(llm, config);
 }
+init_errors();
 var ADRGenerator = class {
   llm;
   config;
@@ -3279,6 +3938,7 @@ function slugify(str) {
 function createADRGenerator(llm, config) {
   return new ADRGenerator(llm, config);
 }
+init_errors();
 var BacklogGenerator = class {
   llm;
   config;
@@ -8296,6 +8956,9 @@ function buildFeedbackSection(feedback, issues) {
   }
   return section;
 }
+
+// src/phases/complete/generator.ts
+init_errors();
 var DEFAULT_CONFIG = {
   name: "coco",
   level: "info",
@@ -8492,6 +9155,21 @@ function humanizeError(message, toolName) {
   return msg;
 }
 
+// src/tools/registry.ts
+init_errors();
+
+// src/cli/repl/error-resilience.ts
+init_errors();
+function isAbortError(error, signal) {
+  if (signal?.aborted) return true;
+  if (!(error instanceof Error)) return false;
+  if (error.name === "AbortError") return true;
+  if (error.name === "APIUserAbortError") return true;
+  if (error.message === "Request was aborted.") return true;
+  if (error.message.endsWith("Request was aborted.")) return true;
+  return false;
+}
+
 // src/tools/registry.ts
 var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
@@ -8604,6 +9282,8 @@ var ToolRegistry = class {
           errorMessage += `
 Suggestion: ${error.suggestion}`;
         }
+      } else if (isAbortError(error, options?.signal)) {
+        errorMessage = "Operation cancelled by user or provider";
       } else {
         const rawMessage = error instanceof Error ? error.message : String(error);
         errorMessage = humanizeError(rawMessage, name);
@@ -9653,6 +10333,9 @@ function createTaskIterator(llm, config, projectPath) {
   return new TaskIterator(llm, config, projectPath);
 }
 
+// src/phases/complete/executor.ts
+init_errors();
+
 // src/phases/complete/llm-adapter.ts
 function createLLMAdapter2(context) {
   const llmContext = context.llm;
@@ -11770,7 +12453,11 @@ function createOutputExecutor(config) {
   return new OutputExecutor(config);
 }
 
+// src/providers/anthropic.ts
+init_errors();
+
 // src/providers/retry.ts
+init_errors();
 var DEFAULT_RETRY_CONFIG = {
   maxRetries: 3,
   initialDelayMs: 1e3,
@@ -12310,7 +12997,14 @@ var AnthropicProvider = class {
    */
   handleError(error) {
     if (error instanceof Anthropic.APIError) {
-      const retryable = error.status === 429 || error.status >= 500;
+      const msg = error.message.toLowerCase();
+      let retryable = error.status === 429 || error.status >= 500;
+      if (msg.includes("usage limit") || msg.includes("quota") || msg.includes("billing") || msg.includes("insufficient funds")) {
+        retryable = false;
+      }
+      if (error.status === 401 || error.status === 403) {
+        retryable = false;
+      }
       throw new ProviderError(error.message, {
         provider: this.id,
         statusCode: error.status,
@@ -12318,9 +13012,17 @@ var AnthropicProvider = class {
         cause: error
       });
     }
-    throw new ProviderError(error instanceof Error ? error.message : String(error), {
-      provider: this.id,
-      cause: error instanceof Error ? error : void 0
+    if (error instanceof Error) {
+      const msg = error.message.toLowerCase();
+      const isQuotaError = msg.includes("usage limit") || msg.includes("quota") || msg.includes("billing");
+      throw new ProviderError(error.message, {
+        provider: this.id,
+        retryable: !isQuotaError,
+        cause: error
+      });
+    }
+    throw new ProviderError(String(error), {
+      provider: this.id
     });
   }
 };
@@ -12346,6 +13048,9 @@ function createKimiCodeProvider(config) {
   }
   return provider;
 }
+
+// src/providers/openai.ts
+init_errors();
 var DEFAULT_MODEL2 = "gpt-5.4-codex";
 var CONTEXT_WINDOWS2 = {
   // OpenAI models
@@ -12356,11 +13061,13 @@ var CONTEXT_WINDOWS2 = {
   "gpt-3.5-turbo": 16385,
   o1: 2e5,
   "o1-mini": 128e3,
+  o3: 2e5,
   "o3-mini": 2e5,
   "o4-mini": 2e5,
   // GPT-4.1 series (Feb 2026)
   "gpt-4.1": 1048576,
   "gpt-4.1-mini": 1048576,
+  "gpt-4.1-nano": 1048576,
   // GPT-5 series (2025-2026)
   "gpt-5": 4e5,
   "gpt-5.2": 4e5,
@@ -12434,7 +13141,9 @@ var MODELS_WITHOUT_TEMPERATURE = [
   "o1",
   "o1-mini",
   "o1-preview",
+  "o3",
   "o3-mini",
+  "o4-mini",
   "kimi-k2.5",
   "kimi-k2-0324",
   "kimi-latest"
@@ -12452,7 +13161,7 @@ var LOCAL_MODEL_PATTERNS = [
 ];
 var MODELS_WITH_THINKING_MODE = ["kimi-k2.5", "kimi-k2-0324", "kimi-latest"];
 function needsResponsesApi(model) {
-  return model.includes("codex") || model.startsWith("gpt-5") || model.startsWith("o4-") || model.startsWith("o3-");
+  return model.includes("codex") || model.startsWith("gpt-5") || model.startsWith("o4-") || model === "o3";
 }
 function needsMaxCompletionTokens(model) {
   return model.startsWith("o1") || model.startsWith("o3") || model.startsWith("o4") || model.startsWith("gpt-4o") || model.startsWith("gpt-4.1") || model.startsWith("gpt-5") || model.startsWith("chatgpt-4o");
@@ -13127,7 +13836,14 @@ var OpenAIProvider = class {
    */
   handleError(error) {
     if (error instanceof OpenAI.APIError) {
-      const retryable = error.status === 429 || (error.status ?? 0) >= 500;
+      const msg = error.message.toLowerCase();
+      let retryable = error.status === 429 || (error.status ?? 0) >= 500;
+      if (msg.includes("exceeded your current quota") || msg.includes("insufficient_quota") || msg.includes("billing") || msg.includes("usage limit") || msg.includes("you have exceeded")) {
+        retryable = false;
+      }
+      if (error.status === 401 || error.status === 403) {
+        retryable = false;
+      }
       throw new ProviderError(error.message, {
         provider: this.id,
         statusCode: error.status,
@@ -13135,9 +13851,17 @@ var OpenAIProvider = class {
         cause: error
       });
     }
-    throw new ProviderError(error instanceof Error ? error.message : String(error), {
-      provider: this.id,
-      cause: error instanceof Error ? error : void 0
+    if (error instanceof Error) {
+      const msg = error.message.toLowerCase();
+      const isQuotaError = msg.includes("exceeded your current quota") || msg.includes("insufficient_quota") || msg.includes("usage limit") || msg.includes("you have exceeded");
+      throw new ProviderError(error.message, {
+        provider: this.id,
+        retryable: !isQuotaError,
+        cause: error
+      });
+    }
+    throw new ProviderError(String(error), {
+      provider: this.id
     });
   }
   // --- Responses API support (GPT-5+, Codex, o3, o4 models) ---
@@ -13512,281 +14236,22 @@ var OpenAIProvider = class {
 };
 function createKimiProvider(config) {
   const provider = new OpenAIProvider("kimi", "Kimi (Moonshot)");
-  const kimiConfig = {
-    ...config,
-    baseUrl: config?.baseUrl ?? process.env["KIMI_BASE_URL"] ?? "https://api.moonshot.ai/v1",
-    apiKey: config?.apiKey ?? process.env["KIMI_API_KEY"] ?? process.env["MOONSHOT_API_KEY"],
-    model: config?.model ?? "kimi-k2.5"
-  };
-  if (kimiConfig.apiKey) {
-    provider.initialize(kimiConfig).catch(() => {
-    });
-  }
-  return provider;
-}
-var OAUTH_CONFIGS = {
-  /**
-   * OpenAI OAuth (ChatGPT Plus/Pro subscriptions)
-   * Uses the official Codex client ID (same as OpenCode, Codex CLI, etc.)
-   */
-  openai: {
-    provider: "openai",
-    clientId: "app_EMoamEEZ73f0CkXaXp7hrann",
-    authorizationEndpoint: "https://auth.openai.com/oauth/authorize",
-    tokenEndpoint: "https://auth.openai.com/oauth/token",
-    deviceAuthEndpoint: "https://auth.openai.com/oauth/device/code",
-    verificationUri: "https://chatgpt.com/codex/device",
-    scopes: ["openid", "profile", "email", "offline_access"],
-    extraAuthParams: {
-      id_token_add_organizations: "true",
-      codex_cli_simplified_flow: "true",
-      originator: "opencode"
-    }
-  }
-  // NOTE: Gemini OAuth removed - Google's client ID is restricted to official apps
-  // Use API Key (https://aistudio.google.com/apikey) or gcloud ADC instead
-};
-async function refreshAccessToken(provider, refreshToken) {
-  const config = OAUTH_CONFIGS[provider];
-  if (!config) {
-    throw new Error(`OAuth not supported for provider: ${provider}`);
-  }
-  const body = new URLSearchParams({
-    grant_type: "refresh_token",
-    client_id: config.clientId,
-    refresh_token: refreshToken
-  });
-  const response = await fetch(config.tokenEndpoint, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded"
-    },
-    body: body.toString()
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(`Token refresh failed: ${error}`);
-  }
-  const data = await response.json();
-  return {
-    accessToken: data.access_token,
-    refreshToken: data.refresh_token || refreshToken,
-    expiresAt: data.expires_in ? Date.now() + data.expires_in * 1e3 : void 0,
-    tokenType: data.token_type
-  };
-}
-function getTokenStoragePath(provider) {
-  const home = process.env.HOME || process.env.USERPROFILE || "";
-  return path17.join(home, ".coco", "tokens", `${provider}.json`);
-}
-async function saveTokens(provider, tokens) {
-  const filePath = getTokenStoragePath(provider);
-  const dir = path17.dirname(filePath);
-  await fs16.mkdir(dir, { recursive: true, mode: 448 });
-  await fs16.writeFile(filePath, JSON.stringify(tokens, null, 2), { mode: 384 });
-}
-async function loadTokens(provider) {
-  const filePath = getTokenStoragePath(provider);
-  try {
-    const content = await fs16.readFile(filePath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-async function deleteTokens(provider) {
-  const filePath = getTokenStoragePath(provider);
-  try {
-    await fs16.unlink(filePath);
-  } catch {
-  }
-}
-function isTokenExpired(tokens) {
-  if (!tokens.expiresAt) return false;
-  return Date.now() >= tokens.expiresAt - 5 * 60 * 1e3;
-}
-async function getValidAccessToken(provider) {
-  const config = OAUTH_CONFIGS[provider];
-  if (!config) return null;
-  const tokens = await loadTokens(provider);
-  if (!tokens) return null;
-  if (isTokenExpired(tokens)) {
-    if (tokens.refreshToken) {
-      try {
-        const newTokens = await refreshAccessToken(provider, tokens.refreshToken);
-        await saveTokens(provider, newTokens);
-        return { accessToken: newTokens.accessToken, isNew: true };
-      } catch {
-        await deleteTokens(provider);
-        return null;
-      }
-    }
-    await deleteTokens(provider);
-    return null;
-  }
-  return { accessToken: tokens.accessToken, isNew: false };
-}
-function detectWSL() {
-  if (process.env.WSL_DISTRO_NAME || process.env.WSLENV) return true;
-  try {
-    return /microsoft/i.test(readFileSync("/proc/version", "utf-8"));
-  } catch {
-    return false;
-  }
-}
-var isWSL = detectWSL();
-var COPILOT_TOKEN_URL = "https://api.github.com/copilot_internal/v2/token";
-var COPILOT_BASE_URLS = {
-  individual: "https://api.githubcopilot.com",
-  business: "https://api.business.githubcopilot.com",
-  enterprise: "https://api.enterprise.githubcopilot.com"
-};
-var DEFAULT_COPILOT_BASE_URL = "https://api.githubcopilot.com";
-var REFRESH_BUFFER_MS = 6e4;
-var CopilotAuthError = class extends Error {
-  constructor(message, permanent) {
-    super(message);
-    this.permanent = permanent;
-    this.name = "CopilotAuthError";
-  }
-};
-async function exchangeForCopilotToken(githubToken) {
-  const response = await fetch(COPILOT_TOKEN_URL, {
-    method: "GET",
-    headers: {
-      Authorization: `token ${githubToken}`,
-      Accept: "application/json",
-      "User-Agent": "Corbat-Coco/1.0"
-    }
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    if (response.status === 401) {
-      throw new CopilotAuthError(
-        "GitHub token is invalid or expired. Please re-authenticate with /provider copilot.",
-        true
-      );
-    }
-    if (response.status === 403) {
-      throw new CopilotAuthError(
-        "GitHub Copilot is not enabled for this account.\n   Please ensure you have an active Copilot subscription:\n   https://github.com/settings/copilot",
-        true
-      );
-    }
-    throw new Error(`Copilot token exchange failed: ${response.status} - ${error}`);
-  }
-  return await response.json();
-}
-function getCopilotBaseUrl(accountType) {
-  if (accountType && accountType in COPILOT_BASE_URLS) {
-    return COPILOT_BASE_URLS[accountType];
-  }
-  return DEFAULT_COPILOT_BASE_URL;
-}
-function getCopilotCredentialsPath() {
-  const home = process.env.HOME || process.env.USERPROFILE || "";
-  return path17.join(home, ".coco", "tokens", "copilot.json");
-}
-async function saveCopilotCredentials(creds) {
-  const filePath = getCopilotCredentialsPath();
-  const dir = path17.dirname(filePath);
-  await fs16.mkdir(dir, { recursive: true, mode: 448 });
-  await fs16.writeFile(filePath, JSON.stringify(creds, null, 2), { mode: 384 });
-}
-var CopilotCredentialsSchema = z.object({
-  githubToken: z.string().min(1),
-  copilotToken: z.string().optional(),
-  copilotTokenExpiresAt: z.number().optional(),
-  accountType: z.string().optional()
-});
-async function loadCopilotCredentials() {
-  try {
-    const content = await fs16.readFile(getCopilotCredentialsPath(), "utf-8");
-    const parsed = CopilotCredentialsSchema.safeParse(JSON.parse(content));
-    return parsed.success ? parsed.data : null;
-  } catch {
-    return null;
-  }
-}
-async function deleteCopilotCredentials() {
-  try {
-    await fs16.unlink(getCopilotCredentialsPath());
-  } catch {
-  }
-}
-function isCopilotTokenExpired(creds) {
-  if (!creds.copilotToken || !creds.copilotTokenExpiresAt) return true;
-  return Date.now() >= creds.copilotTokenExpiresAt - REFRESH_BUFFER_MS;
-}
-async function getValidCopilotToken() {
-  const creds = await loadCopilotCredentials();
-  if (!creds) return null;
-  const envToken = process.env["GITHUB_TOKEN"] || process.env["GH_TOKEN"];
-  const githubToken = envToken || creds.githubToken;
-  if (!isCopilotTokenExpired(creds) && creds.copilotToken) {
-    return {
-      token: creds.copilotToken,
-      baseUrl: getCopilotBaseUrl(creds.accountType),
-      isNew: false
-    };
-  }
-  try {
-    const copilotToken = await exchangeForCopilotToken(githubToken);
-    const updatedCreds = {
-      ...creds,
-      githubToken: creds.githubToken,
-      copilotToken: copilotToken.token,
-      copilotTokenExpiresAt: copilotToken.expires_at * 1e3,
-      accountType: copilotToken.annotations?.copilot_plan ?? creds.accountType
-    };
-    await saveCopilotCredentials(updatedCreds);
-    return {
-      token: copilotToken.token,
-      baseUrl: getCopilotBaseUrl(updatedCreds.accountType),
-      isNew: true
-    };
-  } catch (error) {
-    if (error instanceof CopilotAuthError && error.permanent) {
-      await deleteCopilotCredentials();
-      return null;
-    }
-    throw error;
-  }
-}
-
-// src/auth/flow.ts
-promisify(execFile);
-var execAsync2 = promisify(exec);
-async function getADCAccessToken() {
-  try {
-    const { stdout } = await execAsync2("gcloud auth application-default print-access-token", {
-      timeout: 1e4
-    });
-    const accessToken = stdout.trim();
-    if (!accessToken) return null;
-    const expiresAt = Date.now() + 55 * 60 * 1e3;
-    return {
-      accessToken,
-      expiresAt
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (message.includes("not logged in") || message.includes("no application default credentials")) {
-      return null;
-    }
-    return null;
-  }
-}
-var cachedToken = null;
-async function getCachedADCToken() {
-  if (cachedToken && cachedToken.expiresAt && Date.now() < cachedToken.expiresAt) {
-    return cachedToken;
+  const kimiConfig = {
+    ...config,
+    baseUrl: config?.baseUrl ?? process.env["KIMI_BASE_URL"] ?? "https://api.moonshot.ai/v1",
+    apiKey: config?.apiKey ?? process.env["KIMI_API_KEY"] ?? process.env["MOONSHOT_API_KEY"],
+    model: config?.model ?? "kimi-k2.5"
+  };
+  if (kimiConfig.apiKey) {
+    provider.initialize(kimiConfig).catch(() => {
+    });
   }
-  cachedToken = await getADCAccessToken();
-  return cachedToken;
+  return provider;
 }
 
 // src/providers/codex.ts
+init_errors();
+init_auth();
 var CODEX_API_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
 var DEFAULT_MODEL3 = "gpt-5.4-codex";
 var CONTEXT_WINDOWS3 = {
@@ -14012,7 +14477,7 @@ var CodexProvider = class {
       model,
       input,
       instructions: instructions ?? "You are a helpful coding assistant.",
-      max_output_tokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
+      max_tokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
       temperature: options?.temperature ?? this.config.temperature ?? 0,
       store: false,
       stream: true
@@ -14383,6 +14848,10 @@ var CodexProvider = class {
     }
   }
 };
+
+// src/providers/copilot.ts
+init_errors();
+init_copilot();
 var CONTEXT_WINDOWS4 = {
   // Claude models — Copilot API caps these at 168 000 (not 200 000 like Anthropic direct)
   "claude-sonnet-4.6": 168e3,
@@ -14524,6 +14993,10 @@ var CopilotProvider = class extends OpenAIProvider {
     }
   }
 };
+
+// src/providers/gemini.ts
+init_errors();
+init_gcloud();
 var DEFAULT_MODEL5 = "gemini-3.1-pro-preview";
 var CONTEXT_WINDOWS5 = {
   // Gemini 3.1 series (latest)
@@ -14979,7 +15452,14 @@ var GeminiProvider = class {
    */
   handleError(error) {
     const message = error instanceof Error ? error.message : String(error);
-    const retryable = message.includes("429") || message.includes("500");
+    const msg = message.toLowerCase();
+    let retryable = message.includes("429") || message.includes("500");
+    if (msg.includes("quota") || msg.includes("billing") || msg.includes("usage limit") || msg.includes("insufficient quota")) {
+      retryable = false;
+    }
+    if (message.includes("401") || message.includes("403")) {
+      retryable = false;
+    }
     throw new ProviderError(message, {
       provider: this.id,
       retryable,
@@ -14987,6 +15467,16 @@ var GeminiProvider = class {
     });
   }
 };
+
+// src/providers/circuit-breaker.ts
+init_errors();
+
+// src/providers/fallback.ts
+init_errors();
+
+// src/providers/index.ts
+init_copilot();
+init_errors();
 init_env();
 async function createProvider(type, config = {}) {
   let provider;
@@ -15550,331 +16040,18 @@ function calculateProgress(state) {
 function generateId() {
   return `proj_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 9)}`;
 }
-var ProviderConfigSchema = z.object({
-  type: z.enum([
-    "anthropic",
-    "openai",
-    "codex",
-    "gemini",
-    "kimi",
-    "kimi-code",
-    "lmstudio",
-    "ollama",
-    "groq",
-    "openrouter",
-    "mistral",
-    "deepseek",
-    "together",
-    "huggingface"
-  ]).default("anthropic"),
-  apiKey: z.string().optional(),
-  model: z.string().default("claude-sonnet-4-20250514"),
-  maxTokens: z.number().min(1).max(2e5).default(8192),
-  temperature: z.number().min(0).max(2).default(0),
-  timeout: z.number().min(1e3).default(12e4)
-});
-var QualityConfigSchema = z.object({
-  minScore: z.number().min(0).max(100).default(85),
-  minCoverage: z.number().min(0).max(100).default(80),
-  maxIterations: z.number().min(1).max(20).default(10),
-  minIterations: z.number().min(1).max(10).default(2),
-  convergenceThreshold: z.number().min(0).max(10).default(2),
-  securityThreshold: z.number().min(0).max(100).default(100)
-}).refine((data) => data.minIterations <= data.maxIterations, {
-  message: "minIterations must be <= maxIterations",
-  path: ["minIterations"]
-});
-var PersistenceConfigSchema = z.object({
-  checkpointInterval: z.number().min(6e4).default(3e5),
-  // 5 min default
-  maxCheckpoints: z.number().min(1).max(100).default(50),
-  retentionDays: z.number().min(1).max(365).default(7),
-  compressOldCheckpoints: z.boolean().default(true)
-});
-var StackConfigSchema = z.object({
-  language: z.enum(["typescript", "python", "go", "rust", "java"]),
-  framework: z.string().optional(),
-  profile: z.string().optional()
-  // Custom profile path
-});
-var ProjectConfigSchema2 = z.object({
-  name: z.string().min(1),
-  version: z.string().default("0.1.0"),
-  description: z.string().optional()
-});
-var GitHubConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  token: z.string().optional(),
-  repo: z.string().optional(),
-  createPRs: z.boolean().default(true),
-  createIssues: z.boolean().default(true)
-});
-var IntegrationsConfigSchema = z.object({
-  github: GitHubConfigSchema.optional()
-});
-var MCPServerConfigEntrySchema = z.object({
-  name: z.string(),
-  transport: z.enum(["stdio", "http", "sse"]),
-  command: z.string().optional(),
-  args: z.array(z.string()).optional(),
-  url: z.string().optional(),
-  env: z.record(z.string(), z.string()).optional(),
-  auth: z.object({
-    type: z.enum(["oauth", "bearer", "apikey"]),
-    token: z.string().optional(),
-    tokenEnv: z.string().optional(),
-    headerName: z.string().optional()
-  }).optional(),
-  enabled: z.boolean().default(true),
-  description: z.string().optional()
-});
-var MCPConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  configFile: z.string().optional(),
-  // Path to external MCP config file
-  servers: z.array(MCPServerConfigEntrySchema).default([])
-});
-var ToolsConfigSchema = z.object({
-  webSearch: z.object({
-    engine: z.enum(["duckduckgo", "brave", "serpapi"]).default("duckduckgo"),
-    apiKey: z.string().optional(),
-    maxResults: z.number().min(1).max(20).default(5)
-  }).optional(),
-  memory: z.object({
-    maxMemories: z.number().min(1).max(1e4).default(1e3),
-    scope: z.enum(["global", "project", "both"]).default("project")
-  }).optional(),
-  checkpoint: z.object({
-    maxCheckpoints: z.number().min(1).max(200).default(50),
-    useGitStash: z.boolean().default(true)
-  }).optional(),
-  semanticSearch: z.object({
-    model: z.string().default("all-MiniLM-L6-v2"),
-    chunkSize: z.number().min(5).max(100).default(20),
-    threshold: z.number().min(0).max(1).default(0.3)
-  }).optional()
-});
-var ShipConfigSchema = z.object({
-  /** Default base branch for PRs */
-  defaultBaseBranch: z.string().default("main"),
-  /** Auto-detect version bump from commit history */
-  autoDetectBump: z.boolean().default(true),
-  /** Use squash merge for PRs */
-  squashMerge: z.boolean().default(true),
-  /** Delete feature branch after merge */
-  deleteBranchAfterMerge: z.boolean().default(true),
-  /** Create PRs as draft by default */
-  draftPr: z.boolean().default(false),
-  /** CI check timeout in ms (default 10 minutes) */
-  ciCheckTimeoutMs: z.number().default(6e5),
-  /** CI check poll interval in ms (default 15 seconds) */
-  ciCheckPollMs: z.number().default(15e3)
-});
-var SkillsConfigSchema = z.object({
-  /** Enable/disable skills system */
-  enabled: z.boolean().default(true),
-  /** Override global skills directory */
-  globalDir: z.string().optional(),
-  /** Override project skills directory */
-  projectDir: z.string().optional(),
-  /** Auto-activate skills based on user messages */
-  autoActivate: z.boolean().default(true),
-  /** Maximum concurrent active markdown skills */
-  maxActiveSkills: z.number().min(1).max(10).default(3),
-  /** List of skill IDs to disable */
-  disabled: z.array(z.string()).default([])
-});
-var CocoConfigSchema = z.object({
-  project: ProjectConfigSchema2,
-  provider: ProviderConfigSchema.default({
-    type: "anthropic",
-    model: "claude-sonnet-4-20250514",
-    maxTokens: 8192,
-    temperature: 0,
-    timeout: 12e4
-  }),
-  quality: QualityConfigSchema.default({
-    minScore: 85,
-    minCoverage: 80,
-    maxIterations: 10,
-    minIterations: 2,
-    convergenceThreshold: 2,
-    securityThreshold: 100
-  }),
-  persistence: PersistenceConfigSchema.default({
-    checkpointInterval: 3e5,
-    maxCheckpoints: 50,
-    retentionDays: 7,
-    compressOldCheckpoints: true
-  }),
-  stack: StackConfigSchema.optional(),
-  integrations: IntegrationsConfigSchema.optional(),
-  mcp: MCPConfigSchema.optional(),
-  tools: ToolsConfigSchema.optional(),
-  ship: ShipConfigSchema.optional(),
-  skills: SkillsConfigSchema.optional()
-});
-function createDefaultConfigObject(projectName, language = "typescript") {
-  return {
-    project: {
-      name: projectName,
-      version: "0.1.0"
-    },
-    provider: {
-      type: "anthropic",
-      model: "claude-sonnet-4-20250514",
-      maxTokens: 8192,
-      temperature: 0,
-      timeout: 12e4
-    },
-    quality: {
-      minScore: 85,
-      minCoverage: 80,
-      maxIterations: 10,
-      minIterations: 2,
-      convergenceThreshold: 2,
-      securityThreshold: 100
-    },
-    persistence: {
-      checkpointInterval: 3e5,
-      maxCheckpoints: 50,
-      retentionDays: 7,
-      compressOldCheckpoints: true
-    },
-    stack: {
-      language
-    }
-  };
-}
 
-// src/config/loader.ts
-init_paths();
-async function loadConfig(configPath) {
-  let config = createDefaultConfig("my-project");
-  const globalConfig = await loadConfigFile(CONFIG_PATHS.config, { strict: false });
-  if (globalConfig) {
-    config = deepMergeConfig(config, globalConfig);
-  }
-  const projectConfigPath = configPath || getProjectConfigPath2();
-  const projectConfig = await loadConfigFile(projectConfigPath);
-  if (projectConfig) {
-    config = deepMergeConfig(config, projectConfig);
-  }
-  return config;
-}
-async function loadConfigFile(configPath, options = {}) {
-  const { strict = true } = options;
-  try {
-    const content = await fs16__default.readFile(configPath, "utf-8");
-    const parsed = JSON5.parse(content);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      if (!strict) {
-        return null;
-      }
-      throw new ConfigError("Invalid configuration: expected an object", {
-        configPath
-      });
-    }
-    const result = CocoConfigSchema.partial().safeParse(parsed);
-    if (!result.success && strict) {
-      const issues = result.error.issues.map((i) => ({
-        path: i.path.join("."),
-        message: i.message
-      }));
-      throw new ConfigError("Invalid configuration", {
-        issues,
-        configPath
-      });
-    }
-    return parsed;
-  } catch (error) {
-    if (error instanceof ConfigError) {
-      throw error;
-    }
-    if (error.code === "ENOENT") {
-      return null;
-    }
-    throw new ConfigError("Failed to load configuration", {
-      configPath,
-      cause: error instanceof Error ? error : void 0
-    });
-  }
-}
-function deepMergeConfig(base, override) {
-  return {
-    ...base,
-    ...override,
-    project: { ...base.project, ...override.project },
-    provider: { ...base.provider, ...override.provider },
-    quality: { ...base.quality, ...override.quality },
-    persistence: { ...base.persistence, ...override.persistence },
-    // Merge optional sections only if present in either base or override
-    ...base.stack || override.stack ? { stack: { ...base.stack, ...override.stack } } : {},
-    ...base.integrations || override.integrations ? {
-      integrations: {
-        ...base.integrations,
-        ...override.integrations
-      }
-    } : {},
-    ...base.mcp || override.mcp ? { mcp: { ...base.mcp, ...override.mcp } } : {},
-    ...base.tools || override.tools ? { tools: { ...base.tools, ...override.tools } } : {}
-  };
-}
-function getProjectConfigPath2() {
-  return path17__default.join(process.cwd(), ".coco", "config.json");
-}
-async function saveConfig(config, configPath, global = false) {
-  const result = CocoConfigSchema.safeParse(config);
-  if (!result.success) {
-    const issues = result.error.issues.map((i) => ({
-      path: i.path.join("."),
-      message: i.message
-    }));
-    throw new ConfigError("Cannot save invalid configuration", {
-      issues,
-      configPath: configPath || getProjectConfigPath2()
-    });
-  }
-  const resolvedPath = configPath || (global ? CONFIG_PATHS.config : getProjectConfigPath2());
-  const dir = path17__default.dirname(resolvedPath);
-  await fs16__default.mkdir(dir, { recursive: true });
-  const content = JSON.stringify(result.data, null, 2);
-  await fs16__default.writeFile(resolvedPath, content, "utf-8");
-}
-function createDefaultConfig(projectName, language = "typescript") {
-  return createDefaultConfigObject(projectName, language);
-}
-async function configExists(configPath, scope = "any") {
-  if (configPath) {
-    try {
-      await fs16__default.access(configPath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  if (scope === "project" || scope === "any") {
-    try {
-      await fs16__default.access(getProjectConfigPath2());
-      return true;
-    } catch {
-      if (scope === "project") return false;
-    }
-  }
-  if (scope === "global" || scope === "any") {
-    try {
-      await fs16__default.access(CONFIG_PATHS.config);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  return false;
-}
+// src/config/index.ts
+init_loader();
+init_loader();
+
+// src/config/watcher.ts
+init_loader();
 z.string().regex(
   /^\d+\.\d+\.\d+$/,
   "Version must be in semver format (e.g., 1.0.0)"
 );
+init_errors();
 init_allowed_paths();
 function levenshtein(a, b) {
   if (a === b) return 0;
@@ -15904,11 +16081,113 @@ function levenshtein(a, b) {
 // src/utils/file-suggestions.ts
 var MAX_DIR_ENTRIES = 200;
 var MAX_SUGGESTIONS = 5;
+var DEFAULT_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  "vendor",
+  "__pycache__",
+  ".venv",
+  "venv",
+  ".tox",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".ruff_cache",
+  ".idea",
+  ".vscode",
+  ".DS_Store"
+]);
+var DEFAULT_FIND_OPTIONS = {
+  maxDepth: 8,
+  timeoutMs: 3e3,
+  includeHidden: true,
+  excludeDirs: DEFAULT_EXCLUDE_DIRS,
+  maxResults: 5,
+  type: "file"
+};
+async function findFileRecursive(rootDir, target, options = {}) {
+  const opts = { ...DEFAULT_FIND_OPTIONS, ...options };
+  const targetLower = target.toLowerCase();
+  const results = [];
+  const startTime = Date.now();
+  const isTimedOut = () => Date.now() - startTime > opts.timeoutMs;
+  const queue = [[path17__default.resolve(rootDir), 0]];
+  const visited = /* @__PURE__ */ new Set();
+  while (queue.length > 0 && results.length < opts.maxResults) {
+    if (isTimedOut()) break;
+    const [currentDir, depth] = queue.shift();
+    if (visited.has(currentDir)) continue;
+    visited.add(currentDir);
+    if (depth > opts.maxDepth) continue;
+    try {
+      const entries = await fs16__default.readdir(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (isTimedOut()) break;
+        const entryName = entry.name;
+        const entryPath = path17__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";
+        if (isMatch) {
+          const entryNameLower = entryName.toLowerCase();
+          let distance;
+          if (entryNameLower === targetLower) {
+            distance = 0;
+          } else {
+            distance = levenshtein(targetLower, entryNameLower);
+          }
+          const maxDistance = Math.max(target.length * 0.6, 3);
+          if (distance <= maxDistance) {
+            results.push({ path: entryPath, distance });
+          }
+        }
+        if (entry.isDirectory() && !opts.excludeDirs.has(entryName)) {
+          queue.push([entryPath, depth + 1]);
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return results.sort((a, b) => a.distance - b.distance).slice(0, opts.maxResults);
+}
+async function suggestSimilarFilesDeep(missingPath, rootDir = process.cwd(), options) {
+  const fastResults = await suggestSimilarFiles(missingPath, {
+    maxResults: MAX_SUGGESTIONS
+  });
+  if (fastResults.length > 0) {
+    return fastResults;
+  }
+  const absPath = path17__default.resolve(missingPath);
+  const target = path17__default.basename(absPath);
+  return findFileRecursive(rootDir, target, options);
+}
+async function suggestSimilarDirsDeep(missingPath, rootDir = process.cwd(), options) {
+  const absPath = path17__default.resolve(missingPath);
+  const target = path17__default.basename(absPath);
+  const parentDir = path17__default.dirname(absPath);
+  try {
+    const entries = await fs16__default.readdir(parentDir, { withFileTypes: true });
+    const dirs = entries.filter((e) => e.isDirectory());
+    const scored = dirs.map((d) => ({
+      path: path17__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) {
+      return scored;
+    }
+  } catch {
+  }
+  return findFileRecursive(rootDir, target, { ...options, type: "directory" });
+}
 async function suggestSimilarFiles(missingPath, options) {
   const absPath = path17__default.resolve(missingPath);
   const dir = path17__default.dirname(absPath);
   const target = path17__default.basename(absPath);
-  const maxResults = MAX_SUGGESTIONS;
+  const maxResults = options?.maxResults;
   try {
     const entries = await fs16__default.readdir(dir);
     const limited = entries.slice(0, MAX_DIR_ENTRIES);
@@ -15921,25 +16200,6 @@ async function suggestSimilarFiles(missingPath, options) {
     return [];
   }
 }
-async function suggestSimilarPaths(missingPath, options) {
-  const fileSuggestions = await suggestSimilarFiles(missingPath);
-  if (fileSuggestions.length > 0) return fileSuggestions;
-  const absPath = path17__default.resolve(missingPath);
-  const grandparent = path17__default.dirname(path17__default.dirname(absPath));
-  const parentBasename = path17__default.basename(path17__default.dirname(absPath));
-  const maxResults = MAX_SUGGESTIONS;
-  try {
-    const entries = await fs16__default.readdir(grandparent, { withFileTypes: true });
-    const dirs = entries.filter((e) => e.isDirectory()).slice(0, MAX_DIR_ENTRIES);
-    const scored = dirs.map((d) => ({
-      path: path17__default.join(grandparent, d.name),
-      distance: levenshtein(parentBasename.toLowerCase(), d.name.toLowerCase())
-    })).filter((s) => s.distance <= Math.max(parentBasename.length * 0.6, 3)).sort((a, b) => a.distance - b.distance);
-    return scored.slice(0, maxResults);
-  } catch {
-    return [];
-  }
-}
 function formatSuggestions(suggestions, baseDir) {
   if (suggestions.length === 0) return "";
   const base = baseDir ?? process.cwd();
@@ -16042,7 +16302,7 @@ function isENOENT(error) {
 }
 async function enrichENOENT(filePath, operation) {
   const absPath = path17__default.resolve(filePath);
-  const suggestions = await suggestSimilarFiles(absPath);
+  const suggestions = await suggestSimilarFilesDeep(absPath, process.cwd());
   const hint = formatSuggestions(suggestions, path17__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}
@@ -16050,7 +16310,7 @@ ${action}`;
 }
 async function enrichDirENOENT(dirPath) {
   const absPath = path17__default.resolve(dirPath);
-  const suggestions = await suggestSimilarPaths(absPath);
+  const suggestions = await suggestSimilarDirsDeep(absPath, process.cwd());
   const hint = formatSuggestions(suggestions, path17__default.dirname(absPath));
   return `Directory not found: ${dirPath}${hint}
 Use list_dir or glob to find the correct path.`;
@@ -16682,6 +16942,7 @@ var fileTools = [
 function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+init_errors();
 var DEFAULT_TIMEOUT_MS = 12e4;
 var MAX_OUTPUT_SIZE = 1024 * 1024;
 var DANGEROUS_PATTERNS_FULL = [
@@ -17014,6 +17275,7 @@ function truncateOutput(output, maxLength = 5e4) {
 
 [Output truncated - ${output.length - maxLength} more characters]`;
 }
+init_errors();
 function enrichGitError(operation, error) {
   const msg = error instanceof Error ? error.message : String(error);
   if (/not a git repository/i.test(msg))
@@ -17691,6 +17953,7 @@ var checkAgentCapabilityTool = defineTool({
   }
 });
 var simpleAgentTools = [spawnSimpleAgentTool, checkAgentCapabilityTool];
+init_errors();
 async function detectTestFramework2(cwd) {
   try {
     await fs16__default.access(path17__default.join(cwd, "pom.xml"));
@@ -18054,6 +18317,7 @@ Examples:
   }
 });
 var testTools = [runTestsTool, getCoverageTool, runTestFileTool];
+init_errors();
 async function detectLinter2(cwd) {
   try {
     await fs16__default.access(path17__default.join(cwd, "pom.xml"));
@@ -18438,6 +18702,7 @@ Examples:
   }
 });
 var qualityTools = [runLinterTool, analyzeComplexityTool, calculateQualityTool];
+init_errors();
 var grepTool = defineTool({
   name: "grep",
   description: `Search for text patterns in files using regex.
@@ -18605,7 +18870,10 @@ Examples:
       return { matches, count: matches.length };
     } catch (error) {
       if (error.code === "ENOENT") {
-        throw new ToolError(`File not found: ${file}. Use glob to find the correct path.`, {
+        const suggestions = await suggestSimilarFilesDeep(file, process.cwd());
+        const hint = formatSuggestions(suggestions, path17__default.dirname(file));
+        throw new ToolError(`File not found: ${file}${hint}
+Use glob to find the correct path.`, {
           tool: "find_in_file"
         });
       }
@@ -18617,6 +18885,7 @@ Examples:
   }
 });
 var searchTools = [grepTool, findInFileTool];
+init_errors();
 var DEFAULT_TIMEOUT_MS3 = 3e4;
 var MAX_RESPONSE_SIZE = 5 * 1024 * 1024;
 var httpFetchTool = defineTool({
@@ -18758,6 +19027,7 @@ Examples:
   }
 });
 var httpTools = [httpFetchTool, httpJsonTool];
+init_errors();
 var DEFAULT_TIMEOUT_MS4 = 6e5;
 var MAX_OUTPUT_SIZE2 = 2 * 1024 * 1024;
 function getBuildHint(stderr, tool) {
@@ -19883,6 +20153,7 @@ Examples:
   }
 });
 var permissionsTools = [managePermissionsTool];
+init_errors();
 var DEFAULT_SEARCH_TIMEOUT_MS = 15e3;
 var MAX_QUERY_LENGTH = 500;
 var MIN_REQUEST_INTERVAL_MS = 1e3;
@@ -20123,6 +20394,7 @@ Examples:
     }
   }
 });
+init_errors();
 var DEFAULT_TIMEOUT_MS5 = 3e4;
 var DEFAULT_MAX_LENGTH = 8e3;
 var MAX_DOWNLOAD_SIZE = 10 * 1024 * 1024;
@@ -20458,6 +20730,7 @@ Examples:
 
 // src/tools/web.ts
 var webTools = [webSearchTool, webFetchTool];
+init_errors();
 hljs.registerLanguage("bash", bash);
 hljs.registerLanguage("css", css);
 hljs.registerLanguage("dockerfile", dockerfile);
@@ -20488,63 +20761,63 @@ var LANG_ALIASES = {
 };
 var TOKEN_COLORS = {
   // Keywords & control flow
-  keyword: (t) => chalk4.blue(t),
-  "keyword.control": (t) => chalk4.blue(t),
+  keyword: (t) => chalk5.blue(t),
+  "keyword.control": (t) => chalk5.blue(t),
   // Built-in types and literals
-  built_in: (t) => chalk4.cyan(t),
-  type: (t) => chalk4.cyan(t),
-  class: (t) => chalk4.cyan(t),
-  "title.class": (t) => chalk4.cyan(t),
-  "title.class.inherited": (t) => chalk4.cyan(t),
+  built_in: (t) => chalk5.cyan(t),
+  type: (t) => chalk5.cyan(t),
+  class: (t) => chalk5.cyan(t),
+  "title.class": (t) => chalk5.cyan(t),
+  "title.class.inherited": (t) => chalk5.cyan(t),
   // Functions
-  "title.function": (t) => chalk4.green(t),
-  "title.function.invoke": (t) => chalk4.green(t),
-  title: (t) => chalk4.green(t),
+  "title.function": (t) => chalk5.green(t),
+  "title.function.invoke": (t) => chalk5.green(t),
+  title: (t) => chalk5.green(t),
   // Strings
-  string: (t) => chalk4.yellow(t),
-  "template-tag": (t) => chalk4.yellow(t),
-  "template-variable": (t) => chalk4.green(t),
+  string: (t) => chalk5.yellow(t),
+  "template-tag": (t) => chalk5.yellow(t),
+  "template-variable": (t) => chalk5.green(t),
   // Numbers
-  number: (t) => chalk4.magenta(t),
+  number: (t) => chalk5.magenta(t),
   // Literals (true, false, null)
-  literal: (t) => chalk4.magenta(t),
+  literal: (t) => chalk5.magenta(t),
   // Comments
-  comment: (t) => chalk4.dim(t),
-  doctag: (t) => chalk4.dim.bold(t),
+  comment: (t) => chalk5.dim(t),
+  doctag: (t) => chalk5.dim.bold(t),
   // Regular expressions
-  regexp: (t) => chalk4.red(t),
+  regexp: (t) => chalk5.red(t),
   // Attributes & properties
-  attr: (t) => chalk4.cyan(t),
-  attribute: (t) => chalk4.cyan(t),
-  property: (t) => chalk4.white(t),
+  attr: (t) => chalk5.cyan(t),
+  attribute: (t) => chalk5.cyan(t),
+  property: (t) => chalk5.white(t),
   // Operators & punctuation
-  operator: (t) => chalk4.dim.white(t),
-  punctuation: (t) => chalk4.dim.white(t),
+  operator: (t) => chalk5.dim.white(t),
+  punctuation: (t) => chalk5.dim.white(t),
   // Meta / preprocessor
-  meta: (t) => chalk4.dim(t),
-  "meta keyword": (t) => chalk4.blue(t),
-  "meta string": (t) => chalk4.yellow(t),
+  meta: (t) => chalk5.dim(t),
+  "meta keyword": (t) => chalk5.blue(t),
+  "meta string": (t) => chalk5.yellow(t),
   // Variables & params
-  variable: (t) => chalk4.white(t),
-  "variable.language": (t) => chalk4.blue(t),
-  params: (t) => chalk4.white(t),
+  variable: (t) => chalk5.white(t),
+  "variable.language": (t) => chalk5.blue(t),
+  params: (t) => chalk5.white(t),
   // Tags (HTML/XML)
-  tag: (t) => chalk4.blue(t),
-  name: (t) => chalk4.blue(t),
+  tag: (t) => chalk5.blue(t),
+  name: (t) => chalk5.blue(t),
   // Symbols & selectors (CSS, Ruby)
-  symbol: (t) => chalk4.magenta(t),
-  selector: (t) => chalk4.green(t),
-  "selector-tag": (t) => chalk4.blue(t),
-  "selector-class": (t) => chalk4.green(t),
-  "selector-id": (t) => chalk4.cyan(t),
+  symbol: (t) => chalk5.magenta(t),
+  selector: (t) => chalk5.green(t),
+  "selector-tag": (t) => chalk5.blue(t),
+  "selector-class": (t) => chalk5.green(t),
+  "selector-id": (t) => chalk5.cyan(t),
   // Additions/deletions (diffs)
-  addition: (t) => chalk4.green(t),
-  deletion: (t) => chalk4.red(t),
+  addition: (t) => chalk5.green(t),
+  deletion: (t) => chalk5.red(t),
   // Section headers
-  section: (t) => chalk4.bold(t),
+  section: (t) => chalk5.bold(t),
   // Emphasis
-  emphasis: (t) => chalk4.italic(t),
-  strong: (t) => chalk4.bold(t)
+  emphasis: (t) => chalk5.italic(t),
+  strong: (t) => chalk5.bold(t)
 };
 function hljsToChalk(html) {
   const safeSpans = [];
@@ -20599,10 +20872,10 @@ function highlightLine(line, lang) {
 }
 
 // src/cli/repl/output/diff-renderer.ts
-var bgDeleteLine = chalk4.bgRgb(80, 20, 20);
-var bgAddLine = chalk4.bgRgb(20, 60, 20);
-var bgDeleteWord = chalk4.bgRgb(160, 40, 40);
-var bgAddWord = chalk4.bgRgb(40, 120, 40);
+var bgDeleteLine = chalk5.bgRgb(80, 20, 20);
+var bgAddLine = chalk5.bgRgb(20, 60, 20);
+var bgDeleteWord = chalk5.bgRgb(160, 40, 40);
+var bgAddWord = chalk5.bgRgb(40, 120, 40);
 function parseDiff(raw) {
   const files = [];
   const lines = raw.split("\n");
@@ -20768,9 +21041,6 @@ function highlightWordChanges(deletedContent, addedContent) {
   return { styledDelete, styledAdd };
 }
 var getTerminalWidth = () => process.stdout.columns || 80;
-function stripAnsi(str) {
-  return str.replace(/\x1b\[[0-9;]*m/g, "");
-}
 function detectLanguage2(filePath) {
   const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
   const extMap = {
@@ -20796,43 +21066,37 @@ function detectLanguage2(filePath) {
 }
 function renderDiff(diff, options) {
   const showLineNumbers = options?.showLineNumbers ?? true;
-  const maxWidth = options?.maxWidth ?? Math.min(getTerminalWidth() - 2, 120);
+  options?.maxWidth ?? Math.min(getTerminalWidth() - 2, 120);
   const compact = options?.compact ?? false;
   if (diff.files.length === 0) {
-    console.log(chalk4.dim("\n  No changes\n"));
+    console.log(chalk5.dim("\n  No changes\n"));
     return;
   }
   for (const file of diff.files) {
-    renderFileBlock(file, { showLineNumbers, maxWidth, compact });
+    renderFileBlock(file, { showLineNumbers, compact });
   }
   const { stats } = diff;
   const parts = [];
   parts.push(`${stats.filesChanged} file${stats.filesChanged !== 1 ? "s" : ""}`);
-  if (stats.additions > 0) parts.push(chalk4.green(`+${stats.additions}`));
-  if (stats.deletions > 0) parts.push(chalk4.red(`-${stats.deletions}`));
-  console.log(chalk4.dim(`
+  if (stats.additions > 0) parts.push(chalk5.green(`+${stats.additions}`));
+  if (stats.deletions > 0) parts.push(chalk5.red(`-${stats.deletions}`));
+  console.log(chalk5.dim(`
   ${parts.join(", ")}
 `));
 }
 function renderFileBlock(file, opts) {
-  const { maxWidth, showLineNumbers, compact } = opts;
+  const { showLineNumbers, compact } = opts;
   const lang = detectLanguage2(file.path);
-  const contentWidth = Math.max(1, maxWidth - 4);
   const typeLabel = file.type === "modified" ? "modified" : file.type === "added" ? "new file" : file.type === "deleted" ? "deleted" : `renamed from ${file.oldPath}`;
   const statsLabel = ` +${file.additions} -${file.deletions}`;
-  const title = ` ${file.path} (${typeLabel}${statsLabel}) `;
-  const topFill = Math.max(0, maxWidth - 2 - stripAnsi(title).length);
-  console.log(
-    chalk4.magenta("\u256D\u2500\u2500") + chalk4.cyan.bold(title) + chalk4.magenta("\u2500".repeat(topFill) + "\u256E")
-  );
+  const title = `${file.path} (${typeLabel}${statsLabel})`;
+  console.log(chalk5.cyan.bold(title));
   for (let h = 0; h < file.hunks.length; h++) {
     const hunk = file.hunks[h];
     if (!compact || h > 0) {
-      const hunkLabel = hunk.heading ? ` ${chalk4.dim(hunk.heading)}` : "";
+      const hunkLabel = hunk.heading ? ` ${chalk5.dim(hunk.heading)}` : "";
       console.log(
-        chalk4.magenta("\u2502") + " " + chalk4.cyan(
-          `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`
-        ) + hunkLabel
+        chalk5.cyan(`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`) + hunkLabel
       );
     }
     const pairs = pairAdjacentLines(hunk.lines);
@@ -20858,12 +21122,11 @@ function renderFileBlock(file, opts) {
         } else {
           content = line.content;
         }
-        const innerText = `${lineNo}${prefix} ${content}`;
-        const plainLen = stripAnsi(innerText).length + 1;
-        const pad = Math.max(0, contentWidth - plainLen);
-        console.log(
-          chalk4.magenta("\u2502") + bgAddLine(` ${innerText}` + " ".repeat(pad + 2)) + chalk4.magenta("\u2502")
-        );
+        if (lang) {
+          content = highlightLine(content, lang);
+        }
+        const lineStr = `${lineNo}${prefix} ${content}`;
+        console.log(bgAddLine(lineStr));
       } else if (line.type === "delete") {
         const isPaired = pairedDeleteIndices.has(li);
         let content;
@@ -20872,32 +21135,27 @@ function renderFileBlock(file, opts) {
         } else {
           content = line.content;
         }
-        const innerText = `${lineNo}${prefix} ${content}`;
-        const plainLen = stripAnsi(innerText).length + 1;
-        const pad = Math.max(0, contentWidth - plainLen);
-        console.log(
-          chalk4.magenta("\u2502") + bgDeleteLine(` ${innerText}` + " ".repeat(pad + 2)) + chalk4.magenta("\u2502")
-        );
+        if (lang) {
+          content = highlightLine(content, lang);
+        }
+        const lineStr = `${lineNo}${prefix} ${content}`;
+        console.log(bgDeleteLine(lineStr));
       } else {
         let content = line.content;
         if (lang) {
           content = highlightLine(content, lang);
         }
         const lineStr = `${lineNo}${prefix} ${content}`;
-        const plainLen = stripAnsi(lineStr).length;
-        const pad = Math.max(0, contentWidth - plainLen);
-        console.log(
-          chalk4.magenta("\u2502") + chalk4.dim(` ${lineStr}`) + " ".repeat(pad) + " " + chalk4.magenta("\u2502")
-        );
+        console.log(chalk5.dim(lineStr));
       }
     }
   }
-  console.log(chalk4.magenta("\u2570" + "\u2500".repeat(Math.max(0, maxWidth - 2)) + "\u256F"));
+  console.log();
 }
 function formatLineNo(line, show) {
   if (!show) return "";
   const lineNo = line.type === "delete" ? line.oldLineNo : line.newLineNo;
-  return chalk4.dim(`${String(lineNo ?? "").padStart(5)} `);
+  return chalk5.dim(`${String(lineNo ?? "").padStart(5)} `);
 }
 function getChangedLines(diff) {
   const result = /* @__PURE__ */ new Map();
@@ -20994,6 +21252,10 @@ Examples:
   }
 });
 var diffTools = [showDiffTool];
+init_errors();
+
+// src/utils/files.ts
+init_errors();
 async function fileExists(filePath) {
   try {
     await fs16__default.access(filePath);
@@ -21505,6 +21767,7 @@ Examples:
   }
 });
 var reviewTools = [reviewCodeTool];
+init_errors();
 var fs25 = await import('fs/promises');
 var path27 = await import('path');
 var { glob: glob14 } = await import('glob');
@@ -22019,6 +22282,7 @@ Examples:
   }
 });
 var codebaseMapTools = [codebaseMapTool];
+init_errors();
 init_paths();
 var fs26 = await import('fs/promises');
 var path28 = await import('path');
@@ -22214,6 +22478,7 @@ Examples:
   }
 });
 var memoryTools = [createMemoryTool, recallMemoryTool, listMemoriesTool];
+init_errors();
 var fs27 = await import('fs/promises');
 var crypto3 = await import('crypto');
 var CHECKPOINT_FILE = ".coco/checkpoints.json";
@@ -22657,6 +22922,7 @@ Examples:
   }
 });
 var semanticSearchTools = [semanticSearchTool];
+init_errors();
 var fs29 = await import('fs/promises');
 var path30 = await import('path');
 var { glob: glob16 } = await import('glob');
@@ -22991,6 +23257,7 @@ Examples:
   }
 });
 var diagramTools = [generateDiagramTool];
+init_errors();
 var fs30 = await import('fs/promises');
 var path31 = await import('path');
 var DEFAULT_MAX_PAGES = 20;
@@ -23107,6 +23374,7 @@ Examples:
   }
 });
 var pdfTools = [readPdfTool];
+init_errors();
 var fs31 = await import('fs/promises');
 var path32 = await import('path');
 var SUPPORTED_FORMATS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"]);
@@ -23291,6 +23559,7 @@ Examples:
   }
 });
 var imageTools = [readImageTool];
+init_errors();
 var path33 = await import('path');
 var DANGEROUS_PATTERNS = [
   /\bDROP\s+(?:TABLE|DATABASE|INDEX|VIEW)\b/i,
@@ -24664,6 +24933,7 @@ var recommendBranchTool = defineTool({
   }
 });
 var gitEnhancedTools = [analyzeRepoHealthTool, getCommitStatsTool, recommendBranchTool];
+init_errors();
 async function ghExec(args, cwd) {
   try {
     const result = await execa("gh", args, {
@@ -24848,6 +25118,8 @@ var githubTools = [
   ghPrListTool,
   ghReleaseCreateTool
 ];
+init_errors();
+init_platform();
 var INTERPRETER_MAP = {
   ".py": ["python3"],
   ".sh": ["bash"],
@@ -25156,6 +25428,9 @@ function createFullToolRegistry() {
   return registry;
 }
 
+// src/index.ts
+init_errors();
+
 export { ADRGenerator, AnthropicProvider, ArchitectureGenerator, BacklogGenerator, CICDGenerator, CocoError, CodeGenerator, CodeReviewer, CompleteExecutor, ConfigError, ConvergeExecutor, DiscoveryEngine, DockerGenerator, DocsGenerator, OrchestrateExecutor, OutputExecutor, PhaseError, SessionManager, SpecificationGenerator, TaskError, TaskIterator, ToolRegistry, VERSION, configExists, createADRGenerator, createAnthropicProvider, createArchitectureGenerator, createBacklogGenerator, createCICDGenerator, createCodeGenerator, createCodeReviewer, createCompleteExecutor, createConvergeExecutor, createDefaultConfig, createDiscoveryEngine, createDockerGenerator, createDocsGenerator, createFullToolRegistry, createLogger, createOrchestrateExecutor, createOrchestrator, createOutputExecutor, createProvider, createSessionManager, createSpecificationGenerator, createTaskIterator, createToolRegistry, loadConfig, registerAllTools, saveConfig };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map