@corbat-tech/coco 2.10.0 → 2.11.0

package/dist/index.js

@@ -1,10 +1,10 @@
 import { homedir } from 'os';
-import * as path16 from 'path';
-import path16__default, { dirname, join, basename, resolve } from 'path';
+import * as path17 from 'path';
+import path17__default, { dirname, join, basename, resolve } from 'path';
 import * as fs4 from 'fs';
 import fs4__default, { readFileSync, constants } from 'fs';
-import * as fs15 from 'fs/promises';
-import fs15__default, { readFile, access, readdir } from 'fs/promises';
+import * as fs16 from 'fs/promises';
+import fs16__default, { readFile, access, readdir } from 'fs/promises';
 import chalk4 from 'chalk';
 import * as p4 from '@clack/prompts';
 import { fileURLToPath } from 'url';
@@ -92,7 +92,7 @@ function loadGlobalCocoEnv() {
   try {
     const home = process.env.HOME || process.env.USERPROFILE || "";
     if (!home) return;
-    const globalEnvPath = path16.join(home, ".coco", ".env");
+    const globalEnvPath = path17.join(home, ".coco", ".env");
     const content = fs4.readFileSync(globalEnvPath, "utf-8");
     for (const line of content.split("\n")) {
       const trimmed = line.trim();
@@ -128,6 +128,8 @@ function getApiKey(provider) {
       return process.env["OLLAMA_API_KEY"] ?? "ollama";
     case "codex":
       return void 0;
+    case "copilot":
+      return process.env["GITHUB_TOKEN"] ?? process.env["GH_TOKEN"];
     case "groq":
       return process.env["GROQ_API_KEY"];
     case "openrouter":
@@ -162,6 +164,8 @@ function getBaseUrl(provider) {
       return process.env["OLLAMA_BASE_URL"] ?? "http://localhost:11434/v1";
     case "codex":
       return "https://chatgpt.com/backend-api/codex/responses";
+    case "copilot":
+      return process.env["COPILOT_BASE_URL"] ?? "https://api.githubcopilot.com";
     case "groq":
       return process.env["GROQ_BASE_URL"] ?? "https://api.groq.com/openai/v1";
     case "openrouter":
@@ -183,11 +187,11 @@ function getBaseUrl(provider) {
 function getDefaultModel(provider) {
   switch (provider) {
     case "anthropic":
-      return process.env["ANTHROPIC_MODEL"] ?? "claude-opus-4-6-20260115";
+      return process.env["ANTHROPIC_MODEL"] ?? "claude-opus-4-6";
     case "openai":
       return process.env["OPENAI_MODEL"] ?? "gpt-5.3-codex";
     case "gemini":
-      return process.env["GEMINI_MODEL"] ?? "gemini-3-flash-preview";
+      return process.env["GEMINI_MODEL"] ?? "gemini-3.1-pro-preview";
     case "kimi":
       return process.env["KIMI_MODEL"] ?? "kimi-k2.5";
     case "kimi-code":
@@ -198,6 +202,8 @@ function getDefaultModel(provider) {
       return process.env["OLLAMA_MODEL"] ?? "llama3.1";
     case "codex":
       return process.env["CODEX_MODEL"] ?? "gpt-5.3-codex";
+    case "copilot":
+      return process.env["COPILOT_MODEL"] ?? "claude-sonnet-4.6";
     case "groq":
       return process.env["GROQ_MODEL"] ?? "llama-3.3-70b-versatile";
     case "openrouter":
@@ -232,6 +238,7 @@ var init_env = __esm({
       "anthropic",
       "openai",
       "codex",
+      "copilot",
       "gemini",
       "kimi",
       "kimi-code",
@@ -257,10 +264,10 @@ function getAllowedPaths() {
   return [...sessionAllowedPaths];
 }
 function isWithinAllowedPath(absolutePath, operation) {
-  const normalizedTarget = path16__default.normalize(absolutePath);
+  const normalizedTarget = path17__default.normalize(absolutePath);
   for (const entry of sessionAllowedPaths) {
-    const normalizedAllowed = path16__default.normalize(entry.path);
-    if (normalizedTarget === normalizedAllowed || normalizedTarget.startsWith(normalizedAllowed + path16__default.sep)) {
+    const normalizedAllowed = path17__default.normalize(entry.path);
+    if (normalizedTarget === normalizedAllowed || normalizedTarget.startsWith(normalizedAllowed + path17__default.sep)) {
       if (operation === "read") return true;
       if (entry.level === "write") return true;
     }
@@ -268,8 +275,8 @@ function isWithinAllowedPath(absolutePath, operation) {
   return false;
 }
 function addAllowedPathToSession(dirPath, level) {
-  const absolute = path16__default.resolve(dirPath);
-  if (sessionAllowedPaths.some((e) => path16__default.normalize(e.path) === path16__default.normalize(absolute))) {
+  const absolute = path17__default.resolve(dirPath);
+  if (sessionAllowedPaths.some((e) => path17__default.normalize(e.path) === path17__default.normalize(absolute))) {
     return;
   }
   sessionAllowedPaths.push({
@@ -280,14 +287,14 @@ function addAllowedPathToSession(dirPath, level) {
 }
 async function persistAllowedPath(dirPath, level) {
   if (!currentProjectPath) return;
-  const absolute = path16__default.resolve(dirPath);
+  const absolute = path17__default.resolve(dirPath);
   const store = await loadStore();
   if (!store.projects[currentProjectPath]) {
     store.projects[currentProjectPath] = [];
   }
   const entries = store.projects[currentProjectPath];
-  const normalized = path16__default.normalize(absolute);
-  if (entries.some((e) => path16__default.normalize(e.path) === normalized)) {
+  const normalized = path17__default.normalize(absolute);
+  if (entries.some((e) => path17__default.normalize(e.path) === normalized)) {
     return;
   }
   entries.push({
@@ -299,7 +306,7 @@ async function persistAllowedPath(dirPath, level) {
 }
 async function loadStore() {
   try {
-    const content = await fs15__default.readFile(STORE_FILE, "utf-8");
+    const content = await fs16__default.readFile(STORE_FILE, "utf-8");
     return { ...DEFAULT_STORE, ...JSON.parse(content) };
   } catch {
     return { ...DEFAULT_STORE };
@@ -307,8 +314,8 @@ async function loadStore() {
 }
 async function saveStore(store) {
   try {
-    await fs15__default.mkdir(path16__default.dirname(STORE_FILE), { recursive: true });
-    await fs15__default.writeFile(STORE_FILE, JSON.stringify(store, null, 2), "utf-8");
+    await fs16__default.mkdir(path17__default.dirname(STORE_FILE), { recursive: true });
+    await fs16__default.writeFile(STORE_FILE, JSON.stringify(store, null, 2), "utf-8");
   } catch {
   }
 }
@@ -316,7 +323,7 @@ var STORE_FILE, DEFAULT_STORE, sessionAllowedPaths, currentProjectPath;
 var init_allowed_paths = __esm({
   "src/tools/allowed-paths.ts"() {
     init_paths();
-    STORE_FILE = path16__default.join(CONFIG_PATHS.home, "allowed-paths.json");
+    STORE_FILE = path17__default.join(CONFIG_PATHS.home, "allowed-paths.json");
     DEFAULT_STORE = {
       version: 1,
       projects: {}
@@ -397,7 +404,7 @@ __export(allow_path_prompt_exports, {
   promptAllowPath: () => promptAllowPath
 });
 async function promptAllowPath(dirPath) {
-  const absolute = path16__default.resolve(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}`));
@@ -1778,13 +1785,13 @@ function createSpecificationGenerator(llm, config) {
   return new SpecificationGenerator(llm, config);
 }
 function getPersistencePaths(projectPath) {
-  const baseDir = path16__default.join(projectPath, ".coco", "spec");
+  const baseDir = path17__default.join(projectPath, ".coco", "spec");
   return {
     baseDir,
-    sessionFile: path16__default.join(baseDir, "discovery-session.json"),
-    specFile: path16__default.join(baseDir, "spec.md"),
-    conversationLog: path16__default.join(baseDir, "conversation.jsonl"),
-    checkpointFile: path16__default.join(baseDir, "checkpoint.json")
+    sessionFile: path17__default.join(baseDir, "discovery-session.json"),
+    specFile: path17__default.join(baseDir, "spec.md"),
+    conversationLog: path17__default.join(baseDir, "conversation.jsonl"),
+    checkpointFile: path17__default.join(baseDir, "checkpoint.json")
   };
 }
 var SessionPersistence = class {
@@ -1797,7 +1804,7 @@ var SessionPersistence = class {
    */
   async ensureDir() {
     try {
-      await fs15__default.mkdir(this.paths.baseDir, { recursive: true });
+      await fs16__default.mkdir(this.paths.baseDir, { recursive: true });
     } catch {
       throw new FileSystemError(`Failed to create persistence directory: ${this.paths.baseDir}`, {
         path: this.paths.baseDir,
@@ -1812,7 +1819,7 @@ var SessionPersistence = class {
     await this.ensureDir();
     try {
       const data = JSON.stringify(session, null, 2);
-      await fs15__default.writeFile(this.paths.sessionFile, data, "utf-8");
+      await fs16__default.writeFile(this.paths.sessionFile, data, "utf-8");
     } catch {
       throw new FileSystemError("Failed to save discovery session", {
         path: this.paths.sessionFile,
@@ -1825,7 +1832,7 @@ var SessionPersistence = class {
    */
   async loadSession() {
     try {
-      const data = await fs15__default.readFile(this.paths.sessionFile, "utf-8");
+      const data = await fs16__default.readFile(this.paths.sessionFile, "utf-8");
       const parsed = JSON.parse(data);
       parsed.startedAt = new Date(parsed.startedAt);
       parsed.updatedAt = new Date(parsed.updatedAt);
@@ -1851,7 +1858,7 @@ var SessionPersistence = class {
    */
   async hasSession() {
     try {
-      await fs15__default.access(this.paths.sessionFile);
+      await fs16__default.access(this.paths.sessionFile);
       return true;
     } catch {
       return false;
@@ -1862,7 +1869,7 @@ var SessionPersistence = class {
    */
   async deleteSession() {
     try {
-      await fs15__default.unlink(this.paths.sessionFile);
+      await fs16__default.unlink(this.paths.sessionFile);
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw new FileSystemError("Failed to delete discovery session", {
@@ -1878,7 +1885,7 @@ var SessionPersistence = class {
   async saveSpecification(content) {
     await this.ensureDir();
     try {
-      await fs15__default.writeFile(this.paths.specFile, content, "utf-8");
+      await fs16__default.writeFile(this.paths.specFile, content, "utf-8");
     } catch {
       throw new FileSystemError("Failed to save specification", {
         path: this.paths.specFile,
@@ -1891,7 +1898,7 @@ var SessionPersistence = class {
    */
   async loadSpecification() {
     try {
-      return await fs15__default.readFile(this.paths.specFile, "utf-8");
+      return await fs16__default.readFile(this.paths.specFile, "utf-8");
     } catch {
       return null;
     }
@@ -1907,7 +1914,7 @@ var SessionPersistence = class {
       content
     };
     try {
-      await fs15__default.appendFile(this.paths.conversationLog, JSON.stringify(entry) + "\n", "utf-8");
+      await fs16__default.appendFile(this.paths.conversationLog, JSON.stringify(entry) + "\n", "utf-8");
     } catch {
       throw new FileSystemError("Failed to append to conversation log", {
         path: this.paths.conversationLog,
@@ -1920,7 +1927,7 @@ var SessionPersistence = class {
    */
   async loadConversationLog() {
     try {
-      const data = await fs15__default.readFile(this.paths.conversationLog, "utf-8");
+      const data = await fs16__default.readFile(this.paths.conversationLog, "utf-8");
       const lines = data.trim().split("\n");
       return lines.filter((line) => line.trim()).map((line) => JSON.parse(line));
     } catch {
@@ -1934,7 +1941,7 @@ var SessionPersistence = class {
     await this.ensureDir();
     try {
       const data = JSON.stringify(checkpoint, null, 2);
-      await fs15__default.writeFile(this.paths.checkpointFile, data, "utf-8");
+      await fs16__default.writeFile(this.paths.checkpointFile, data, "utf-8");
     } catch {
       throw new FileSystemError("Failed to save checkpoint", {
         path: this.paths.checkpointFile,
@@ -1947,7 +1954,7 @@ var SessionPersistence = class {
    */
   async loadCheckpoint() {
     try {
-      const data = await fs15__default.readFile(this.paths.checkpointFile, "utf-8");
+      const data = await fs16__default.readFile(this.paths.checkpointFile, "utf-8");
       const parsed = JSON.parse(data);
       parsed.timestamp = new Date(parsed.timestamp);
       return parsed;
@@ -1960,7 +1967,7 @@ var SessionPersistence = class {
    */
   async clearAll() {
     try {
-      await fs15__default.rm(this.paths.baseDir, { recursive: true, force: true });
+      await fs16__default.rm(this.paths.baseDir, { recursive: true, force: true });
     } catch (error) {
       if (error.code !== "ENOENT") {
         throw new FileSystemError("Failed to clear persistence data", {
@@ -3814,8 +3821,8 @@ var OrchestrateExecutor = class {
   }
   async loadSpecification(projectPath) {
     try {
-      const jsonPath = path16__default.join(projectPath, ".coco", "spec", "spec.json");
-      const jsonContent = await fs15__default.readFile(jsonPath, "utf-8");
+      const jsonPath = path17__default.join(projectPath, ".coco", "spec", "spec.json");
+      const jsonContent = await fs16__default.readFile(jsonPath, "utf-8");
       return JSON.parse(jsonContent);
     } catch {
       return this.createMinimalSpec(projectPath);
@@ -3826,7 +3833,7 @@ var OrchestrateExecutor = class {
       version: "1.0.0",
       generatedAt: /* @__PURE__ */ new Date(),
       overview: {
-        name: path16__default.basename(projectPath),
+        name: path17__default.basename(projectPath),
         description: "Project specification",
         goals: [],
         targetUsers: ["developers"],
@@ -3853,53 +3860,53 @@ var OrchestrateExecutor = class {
     };
   }
   async saveArchitecture(projectPath, architecture) {
-    const dir = path16__default.join(projectPath, ".coco", "architecture");
-    await fs15__default.mkdir(dir, { recursive: true });
-    const mdPath = path16__default.join(dir, "ARCHITECTURE.md");
-    await fs15__default.writeFile(mdPath, generateArchitectureMarkdown(architecture), "utf-8");
-    const jsonPath = path16__default.join(dir, "architecture.json");
-    await fs15__default.writeFile(jsonPath, JSON.stringify(architecture, null, 2), "utf-8");
+    const dir = path17__default.join(projectPath, ".coco", "architecture");
+    await fs16__default.mkdir(dir, { recursive: true });
+    const mdPath = path17__default.join(dir, "ARCHITECTURE.md");
+    await fs16__default.writeFile(mdPath, generateArchitectureMarkdown(architecture), "utf-8");
+    const jsonPath = path17__default.join(dir, "architecture.json");
+    await fs16__default.writeFile(jsonPath, JSON.stringify(architecture, null, 2), "utf-8");
     return mdPath;
   }
   async saveADRs(projectPath, adrs) {
-    const dir = path16__default.join(projectPath, ".coco", "architecture", "adrs");
-    await fs15__default.mkdir(dir, { recursive: true });
+    const dir = path17__default.join(projectPath, ".coco", "architecture", "adrs");
+    await fs16__default.mkdir(dir, { recursive: true });
     const paths = [];
-    const indexPath = path16__default.join(dir, "README.md");
-    await fs15__default.writeFile(indexPath, generateADRIndexMarkdown(adrs), "utf-8");
+    const indexPath = path17__default.join(dir, "README.md");
+    await fs16__default.writeFile(indexPath, generateADRIndexMarkdown(adrs), "utf-8");
     paths.push(indexPath);
     for (const adr of adrs) {
       const filename = getADRFilename(adr);
-      const adrPath = path16__default.join(dir, filename);
-      await fs15__default.writeFile(adrPath, generateADRMarkdown(adr), "utf-8");
+      const adrPath = path17__default.join(dir, filename);
+      await fs16__default.writeFile(adrPath, generateADRMarkdown(adr), "utf-8");
       paths.push(adrPath);
     }
     return paths;
   }
   async saveBacklog(projectPath, backlogResult) {
-    const dir = path16__default.join(projectPath, ".coco", "planning");
-    await fs15__default.mkdir(dir, { recursive: true });
-    const mdPath = path16__default.join(dir, "BACKLOG.md");
-    await fs15__default.writeFile(mdPath, generateBacklogMarkdown(backlogResult.backlog), "utf-8");
-    const jsonPath = path16__default.join(dir, "backlog.json");
-    await fs15__default.writeFile(jsonPath, JSON.stringify(backlogResult, null, 2), "utf-8");
+    const dir = path17__default.join(projectPath, ".coco", "planning");
+    await fs16__default.mkdir(dir, { recursive: true });
+    const mdPath = path17__default.join(dir, "BACKLOG.md");
+    await fs16__default.writeFile(mdPath, generateBacklogMarkdown(backlogResult.backlog), "utf-8");
+    const jsonPath = path17__default.join(dir, "backlog.json");
+    await fs16__default.writeFile(jsonPath, JSON.stringify(backlogResult, null, 2), "utf-8");
     return mdPath;
   }
   async saveSprint(projectPath, sprint, backlogResult) {
-    const dir = path16__default.join(projectPath, ".coco", "planning", "sprints");
-    await fs15__default.mkdir(dir, { recursive: true });
+    const dir = path17__default.join(projectPath, ".coco", "planning", "sprints");
+    await fs16__default.mkdir(dir, { recursive: true });
     const filename = `${sprint.id}.md`;
-    const sprintPath = path16__default.join(dir, filename);
-    await fs15__default.writeFile(sprintPath, generateSprintMarkdown(sprint, backlogResult.backlog), "utf-8");
-    const jsonPath = path16__default.join(dir, `${sprint.id}.json`);
-    await fs15__default.writeFile(jsonPath, JSON.stringify(sprint, null, 2), "utf-8");
+    const sprintPath = path17__default.join(dir, filename);
+    await fs16__default.writeFile(sprintPath, generateSprintMarkdown(sprint, backlogResult.backlog), "utf-8");
+    const jsonPath = path17__default.join(dir, `${sprint.id}.json`);
+    await fs16__default.writeFile(jsonPath, JSON.stringify(sprint, null, 2), "utf-8");
     return sprintPath;
   }
   async saveDiagram(projectPath, id, mermaid) {
-    const dir = path16__default.join(projectPath, ".coco", "architecture", "diagrams");
-    await fs15__default.mkdir(dir, { recursive: true });
-    const diagramPath = path16__default.join(dir, `${id}.mmd`);
-    await fs15__default.writeFile(diagramPath, mermaid, "utf-8");
+    const dir = path17__default.join(projectPath, ".coco", "architecture", "diagrams");
+    await fs16__default.mkdir(dir, { recursive: true });
+    const diagramPath = path17__default.join(dir, `${id}.mmd`);
+    await fs16__default.writeFile(diagramPath, mermaid, "utf-8");
     return diagramPath;
   }
 };
@@ -4054,10 +4061,10 @@ var CoverageAnalyzer = class {
       join(this.projectPath, ".coverage", "coverage-summary.json"),
       join(this.projectPath, "coverage", "lcov-report", "coverage-summary.json")
     ];
-    for (const path39 of possiblePaths) {
+    for (const path40 of possiblePaths) {
       try {
-        await access(path39, constants.R_OK);
-        const content = await readFile(path39, "utf-8");
+        await access(path40, constants.R_OK);
+        const content = await readFile(path40, "utf-8");
         const report = JSON.parse(content);
         return parseCoverageSummary(report);
       } catch {
@@ -4776,7 +4783,7 @@ var BuildVerifier = class {
   async verifyTypes() {
     const startTime = Date.now();
     try {
-      const hasTsConfig = await this.fileExists(path16.join(this.projectPath, "tsconfig.json"));
+      const hasTsConfig = await this.fileExists(path17.join(this.projectPath, "tsconfig.json"));
       if (!hasTsConfig) {
         return {
           success: true,
@@ -4826,8 +4833,8 @@ var BuildVerifier = class {
    */
   async detectBuildCommand() {
     try {
-      const packageJsonPath = path16.join(this.projectPath, "package.json");
-      const content = await fs15.readFile(packageJsonPath, "utf-8");
+      const packageJsonPath = path17.join(this.projectPath, "package.json");
+      const content = await fs16.readFile(packageJsonPath, "utf-8");
       const packageJson = JSON.parse(content);
       if (packageJson.scripts?.build) {
         return "npm run build";
@@ -4903,7 +4910,7 @@ var BuildVerifier = class {
    */
   async fileExists(filePath) {
     try {
-      await fs15.access(filePath);
+      await fs16.access(filePath);
       return true;
     } catch {
       return false;
@@ -6449,9 +6456,9 @@ function detectProjectLanguage(files) {
   return { language: dominant, confidence, evidence };
 }
 function getFileExtension(filePath) {
-  const base = path16.basename(filePath);
+  const base = path17.basename(filePath);
   if (base.endsWith(".d.ts")) return ".d.ts";
-  return path16.extname(filePath).toLowerCase();
+  return path17.extname(filePath).toLowerCase();
 }
 function buildEvidence(dominant, counts, totalSourceFiles, files) {
   const evidence = [];
@@ -6459,7 +6466,7 @@ function buildEvidence(dominant, counts, totalSourceFiles, files) {
   evidence.push(`${dominantCount} of ${totalSourceFiles} source files are ${dominant}`);
   const configFiles = ["tsconfig.json", "pom.xml", "build.gradle", "Cargo.toml", "go.mod"];
   for (const cfg of configFiles) {
-    if (files.some((f) => path16.basename(f) === cfg)) {
+    if (files.some((f) => path17.basename(f) === cfg)) {
       evidence.push(`Found ${cfg}`);
     }
   }
@@ -8171,7 +8178,7 @@ function setupFileLogging(logger, logDir, name) {
   if (!fs4__default.existsSync(logDir)) {
     fs4__default.mkdirSync(logDir, { recursive: true });
   }
-  const logFile = path16__default.join(logDir, `${name}.log`);
+  const logFile = path17__default.join(logDir, `${name}.log`);
   logger.attachTransport((logObj) => {
     const line = JSON.stringify(logObj) + "\n";
     fs4__default.appendFileSync(logFile, line);
@@ -8234,12 +8241,12 @@ function humanizeError(message, toolName) {
     return msg;
   }
   if (/ENOENT/i.test(msg)) {
-    const path39 = extractQuotedPath(msg);
-    return path39 ? `File or directory not found: ${path39}` : "File or directory not found";
+    const path40 = extractQuotedPath(msg);
+    return path40 ? `File or directory not found: ${path40}` : "File or directory not found";
   }
   if (/EACCES/i.test(msg)) {
-    const path39 = extractQuotedPath(msg);
-    return path39 ? `Permission denied: ${path39}` : "Permission denied \u2014 check file permissions";
+    const path40 = extractQuotedPath(msg);
+    return path40 ? `Permission denied: ${path40}` : "Permission denied \u2014 check file permissions";
   }
   if (/EISDIR/i.test(msg)) {
     return "Expected a file but found a directory at the specified path";
@@ -9724,14 +9731,14 @@ var CompleteExecutor = class {
    */
   async checkpoint(context) {
     if (this.checkpointState && this.currentSprint) {
-      const checkpointPath = path16__default.join(
+      const checkpointPath = path17__default.join(
         context.projectPath,
         ".coco",
         "checkpoints",
         `complete-${this.currentSprint.id}.json`
       );
-      await fs15__default.mkdir(path16__default.dirname(checkpointPath), { recursive: true });
-      await fs15__default.writeFile(checkpointPath, JSON.stringify(this.checkpointState, null, 2), "utf-8");
+      await fs16__default.mkdir(path17__default.dirname(checkpointPath), { recursive: true });
+      await fs16__default.writeFile(checkpointPath, JSON.stringify(this.checkpointState, null, 2), "utf-8");
     }
     return {
       phase: "complete",
@@ -9751,13 +9758,13 @@ var CompleteExecutor = class {
     const sprintId = checkpoint.resumePoint;
     if (sprintId === "start") return;
     try {
-      const checkpointPath = path16__default.join(
+      const checkpointPath = path17__default.join(
         context.projectPath,
         ".coco",
         "checkpoints",
         `complete-${sprintId}.json`
       );
-      const content = await fs15__default.readFile(checkpointPath, "utf-8");
+      const content = await fs16__default.readFile(checkpointPath, "utf-8");
       this.checkpointState = JSON.parse(content);
       this.completedTaskIds = new Set(this.checkpointState.completedTaskIds);
     } catch {
@@ -10004,14 +10011,14 @@ var CompleteExecutor = class {
     };
     const saveFiles = async (files) => {
       for (const file of files) {
-        const filePath = path16__default.join(context.projectPath, file.path);
-        const dir = path16__default.dirname(filePath);
-        await fs15__default.mkdir(dir, { recursive: true });
+        const filePath = path17__default.join(context.projectPath, file.path);
+        const dir = path17__default.dirname(filePath);
+        await fs16__default.mkdir(dir, { recursive: true });
         if (file.action === "delete") {
-          await fs15__default.unlink(filePath).catch(() => {
+          await fs16__default.unlink(filePath).catch(() => {
           });
         } else {
-          await fs15__default.writeFile(filePath, file.content, "utf-8");
+          await fs16__default.writeFile(filePath, file.content, "utf-8");
         }
       }
     };
@@ -10137,8 +10144,8 @@ var CompleteExecutor = class {
    */
   async loadBacklog(projectPath) {
     try {
-      const backlogPath = path16__default.join(projectPath, ".coco", "planning", "backlog.json");
-      const content = await fs15__default.readFile(backlogPath, "utf-8");
+      const backlogPath = path17__default.join(projectPath, ".coco", "planning", "backlog.json");
+      const content = await fs16__default.readFile(backlogPath, "utf-8");
       const data = JSON.parse(content);
       return data.backlog;
     } catch {
@@ -10150,12 +10157,12 @@ var CompleteExecutor = class {
    */
   async loadCurrentSprint(projectPath) {
     try {
-      const sprintsDir = path16__default.join(projectPath, ".coco", "planning", "sprints");
-      const files = await fs15__default.readdir(sprintsDir);
+      const sprintsDir = path17__default.join(projectPath, ".coco", "planning", "sprints");
+      const files = await fs16__default.readdir(sprintsDir);
       const jsonFiles = files.filter((f) => f.endsWith(".json"));
       if (jsonFiles.length === 0) return null;
-      const sprintPath = path16__default.join(sprintsDir, jsonFiles[0] || "");
-      const content = await fs15__default.readFile(sprintPath, "utf-8");
+      const sprintPath = path17__default.join(sprintsDir, jsonFiles[0] || "");
+      const content = await fs16__default.readFile(sprintPath, "utf-8");
       const sprint = JSON.parse(content);
       sprint.startDate = new Date(sprint.startDate);
       return sprint;
@@ -10167,12 +10174,12 @@ var CompleteExecutor = class {
    * Save sprint results
    */
   async saveSprintResults(projectPath, result) {
-    const resultsDir = path16__default.join(projectPath, ".coco", "results");
-    await fs15__default.mkdir(resultsDir, { recursive: true });
-    const resultsPath = path16__default.join(resultsDir, `${result.sprintId}-results.json`);
-    await fs15__default.writeFile(resultsPath, JSON.stringify(result, null, 2), "utf-8");
-    const mdPath = path16__default.join(resultsDir, `${result.sprintId}-results.md`);
-    await fs15__default.writeFile(mdPath, this.generateResultsMarkdown(result), "utf-8");
+    const resultsDir = path17__default.join(projectPath, ".coco", "results");
+    await fs16__default.mkdir(resultsDir, { recursive: true });
+    const resultsPath = path17__default.join(resultsDir, `${result.sprintId}-results.json`);
+    await fs16__default.writeFile(resultsPath, JSON.stringify(result, null, 2), "utf-8");
+    const mdPath = path17__default.join(resultsDir, `${result.sprintId}-results.md`);
+    await fs16__default.writeFile(mdPath, this.generateResultsMarkdown(result), "utf-8");
     return resultsPath;
   }
   /**
@@ -11396,9 +11403,9 @@ var OutputExecutor = class {
       const cicdGenerator = new CICDGenerator(metadata, cicdConfig);
       const cicdFiles = cicdGenerator.generate();
       for (const file of cicdFiles) {
-        const filePath = path16__default.join(context.projectPath, file.path);
-        await this.ensureDir(path16__default.dirname(filePath));
-        await fs15__default.writeFile(filePath, file.content, "utf-8");
+        const filePath = path17__default.join(context.projectPath, file.path);
+        await this.ensureDir(path17__default.dirname(filePath));
+        await fs16__default.writeFile(filePath, file.content, "utf-8");
         artifacts.push({
           type: "cicd",
           path: filePath,
@@ -11408,16 +11415,16 @@ var OutputExecutor = class {
       if (this.config.docker.enabled) {
         const dockerGenerator = new DockerGenerator(metadata);
         const dockerfile2 = dockerGenerator.generateDockerfile();
-        const dockerfilePath = path16__default.join(context.projectPath, "Dockerfile");
-        await fs15__default.writeFile(dockerfilePath, dockerfile2, "utf-8");
+        const dockerfilePath = path17__default.join(context.projectPath, "Dockerfile");
+        await fs16__default.writeFile(dockerfilePath, dockerfile2, "utf-8");
         artifacts.push({
           type: "deployment",
           path: dockerfilePath,
           description: "Dockerfile"
         });
         const dockerignore = dockerGenerator.generateDockerignore();
-        const dockerignorePath = path16__default.join(context.projectPath, ".dockerignore");
-        await fs15__default.writeFile(dockerignorePath, dockerignore, "utf-8");
+        const dockerignorePath = path17__default.join(context.projectPath, ".dockerignore");
+        await fs16__default.writeFile(dockerignorePath, dockerignore, "utf-8");
         artifacts.push({
           type: "deployment",
           path: dockerignorePath,
@@ -11425,8 +11432,8 @@ var OutputExecutor = class {
         });
         if (this.config.docker.compose) {
           const compose = dockerGenerator.generateDockerCompose();
-          const composePath = path16__default.join(context.projectPath, "docker-compose.yml");
-          await fs15__default.writeFile(composePath, compose, "utf-8");
+          const composePath = path17__default.join(context.projectPath, "docker-compose.yml");
+          await fs16__default.writeFile(composePath, compose, "utf-8");
           artifacts.push({
             type: "deployment",
             path: composePath,
@@ -11437,8 +11444,8 @@ var OutputExecutor = class {
       const docsGenerator = new DocsGenerator(metadata);
       const docs = docsGenerator.generate();
       if (this.config.docs.readme) {
-        const readmePath = path16__default.join(context.projectPath, "README.md");
-        await fs15__default.writeFile(readmePath, docs.readme, "utf-8");
+        const readmePath = path17__default.join(context.projectPath, "README.md");
+        await fs16__default.writeFile(readmePath, docs.readme, "utf-8");
         artifacts.push({
           type: "documentation",
           path: readmePath,
@@ -11446,8 +11453,8 @@ var OutputExecutor = class {
         });
       }
       if (this.config.docs.contributing) {
-        const contributingPath = path16__default.join(context.projectPath, "CONTRIBUTING.md");
-        await fs15__default.writeFile(contributingPath, docs.contributing, "utf-8");
+        const contributingPath = path17__default.join(context.projectPath, "CONTRIBUTING.md");
+        await fs16__default.writeFile(contributingPath, docs.contributing, "utf-8");
         artifacts.push({
           type: "documentation",
           path: contributingPath,
@@ -11455,8 +11462,8 @@ var OutputExecutor = class {
         });
       }
       if (this.config.docs.changelog) {
-        const changelogPath = path16__default.join(context.projectPath, "CHANGELOG.md");
-        await fs15__default.writeFile(changelogPath, docs.changelog, "utf-8");
+        const changelogPath = path17__default.join(context.projectPath, "CHANGELOG.md");
+        await fs16__default.writeFile(changelogPath, docs.changelog, "utf-8");
         artifacts.push({
           type: "documentation",
           path: changelogPath,
@@ -11464,11 +11471,11 @@ var OutputExecutor = class {
         });
       }
       if (this.config.docs.api) {
-        const docsDir = path16__default.join(context.projectPath, "docs");
+        const docsDir = path17__default.join(context.projectPath, "docs");
         await this.ensureDir(docsDir);
         if (docs.api) {
-          const apiPath = path16__default.join(docsDir, "api.md");
-          await fs15__default.writeFile(apiPath, docs.api, "utf-8");
+          const apiPath = path17__default.join(docsDir, "api.md");
+          await fs16__default.writeFile(apiPath, docs.api, "utf-8");
           artifacts.push({
             type: "documentation",
             path: apiPath,
@@ -11476,8 +11483,8 @@ var OutputExecutor = class {
           });
         }
         if (docs.deployment) {
-          const deployPath = path16__default.join(docsDir, "deployment.md");
-          await fs15__default.writeFile(deployPath, docs.deployment, "utf-8");
+          const deployPath = path17__default.join(docsDir, "deployment.md");
+          await fs16__default.writeFile(deployPath, docs.deployment, "utf-8");
           artifacts.push({
             type: "documentation",
             path: deployPath,
@@ -11485,8 +11492,8 @@ var OutputExecutor = class {
           });
         }
         if (docs.development) {
-          const devPath = path16__default.join(docsDir, "development.md");
-          await fs15__default.writeFile(devPath, docs.development, "utf-8");
+          const devPath = path17__default.join(docsDir, "development.md");
+          await fs16__default.writeFile(devPath, docs.development, "utf-8");
           artifacts.push({
             type: "documentation",
             path: devPath,
@@ -11551,16 +11558,16 @@ var OutputExecutor = class {
    */
   async loadMetadata(projectPath) {
     try {
-      const packagePath = path16__default.join(projectPath, "package.json");
-      const content = await fs15__default.readFile(packagePath, "utf-8");
+      const packagePath = path17__default.join(projectPath, "package.json");
+      const content = await fs16__default.readFile(packagePath, "utf-8");
       const pkg = JSON.parse(content);
       let packageManager = "npm";
       try {
-        await fs15__default.access(path16__default.join(projectPath, "pnpm-lock.yaml"));
+        await fs16__default.access(path17__default.join(projectPath, "pnpm-lock.yaml"));
         packageManager = "pnpm";
       } catch {
         try {
-          await fs15__default.access(path16__default.join(projectPath, "yarn.lock"));
+          await fs16__default.access(path17__default.join(projectPath, "yarn.lock"));
           packageManager = "yarn";
         } catch {
         }
@@ -11572,7 +11579,7 @@ var OutputExecutor = class {
         repository = pkg.repository.url;
       }
       return {
-        name: pkg.name || path16__default.basename(projectPath),
+        name: pkg.name || path17__default.basename(projectPath),
         description: pkg.description || "",
         version: pkg.version || "0.1.0",
         language: "typescript",
@@ -11586,7 +11593,7 @@ var OutputExecutor = class {
       };
     } catch {
       return {
-        name: path16__default.basename(projectPath),
+        name: path17__default.basename(projectPath),
         description: "",
         version: "0.1.0",
         language: "typescript",
@@ -11602,7 +11609,7 @@ var OutputExecutor = class {
    * Ensure directory exists
    */
   async ensureDir(dir) {
-    await fs15__default.mkdir(dir, { recursive: true });
+    await fs16__default.mkdir(dir, { recursive: true });
   }
 };
 function createOutputExecutor(config) {
@@ -11664,18 +11671,19 @@ async function withRetry(fn, config = {}) {
 }
 
 // src/providers/anthropic.ts
-var DEFAULT_MODEL = "claude-opus-4-6-20260115";
+var DEFAULT_MODEL = "claude-opus-4-6";
 var CONTEXT_WINDOWS = {
   // Kimi Code model (Anthropic-compatible endpoint)
   "kimi-for-coding": 131072,
-  // Claude 4.6 (latest, Jan 2026) - 200K-1M context, 128K output
-  "claude-opus-4-6-20260115": 2e5,
-  // Claude 4.5 models (Nov 2025)
-  "claude-opus-4-5-20251124": 2e5,
+  // Claude 4.6 (latest) — 200K standard, 1M beta
+  "claude-opus-4-6": 2e5,
+  "claude-sonnet-4-6": 2e5,
+  // Claude 4.5 models
+  "claude-opus-4-5-20251101": 2e5,
   "claude-sonnet-4-5-20250929": 2e5,
   "claude-haiku-4-5-20251001": 2e5,
   // Claude 4.1 models
-  "claude-opus-4-1-20250801": 2e5,
+  "claude-opus-4-1-20250805": 2e5,
   // Claude 4 models
   "claude-sonnet-4-20250514": 2e5,
   "claude-opus-4-20250514": 2e5,
@@ -12985,18 +12993,18 @@ async function refreshAccessToken(provider, refreshToken) {
 }
 function getTokenStoragePath(provider) {
   const home = process.env.HOME || process.env.USERPROFILE || "";
-  return path16.join(home, ".coco", "tokens", `${provider}.json`);
+  return path17.join(home, ".coco", "tokens", `${provider}.json`);
 }
 async function saveTokens(provider, tokens) {
   const filePath = getTokenStoragePath(provider);
-  const dir = path16.dirname(filePath);
-  await fs15.mkdir(dir, { recursive: true, mode: 448 });
-  await fs15.writeFile(filePath, JSON.stringify(tokens, null, 2), { mode: 384 });
+  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 fs15.readFile(filePath, "utf-8");
+    const content = await fs16.readFile(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -13005,7 +13013,7 @@ async function loadTokens(provider) {
 async function deleteTokens(provider) {
   const filePath = getTokenStoragePath(provider);
   try {
-    await fs15.unlink(filePath);
+    await fs16.unlink(filePath);
   } catch {
   }
 }
@@ -13043,6 +13051,124 @@ function detectWSL() {
   }
 }
 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);
@@ -13355,22 +13481,496 @@ var CodexProvider = class {
     yield* this.stream(messages, options);
   }
 };
-var DEFAULT_MODEL4 = "gemini-3-flash-preview";
 var CONTEXT_WINDOWS4 = {
-  // Gemini 3 series (latest, Jan 2026 - use -preview suffix)
+  // Claude models
+  "claude-sonnet-4.6": 2e5,
+  "claude-opus-4.6": 2e5,
+  "claude-sonnet-4.5": 2e5,
+  "claude-opus-4.5": 2e5,
+  "claude-haiku-4.5": 2e5,
+  // OpenAI models — chat/completions
+  "gpt-4.1": 1048576,
+  // OpenAI models — /responses API (Codex/GPT-5+)
+  "gpt-5.3-codex": 4e5,
+  "gpt-5.2-codex": 4e5,
+  "gpt-5.1-codex-max": 4e5,
+  "gpt-5.2": 4e5,
+  "gpt-5.1": 4e5,
+  // Google models
+  "gemini-3.1-pro-preview": 1e6,
+  "gemini-3-flash-preview": 1e6,
+  "gemini-2.5-pro": 1048576
+};
+var DEFAULT_MODEL4 = "claude-sonnet-4.6";
+var COPILOT_HEADERS = {
+  "Copilot-Integration-Id": "vscode-chat",
+  "Editor-Version": "vscode/1.99.0",
+  "Editor-Plugin-Version": "copilot-chat/0.26.7",
+  "X-GitHub-Api-Version": "2025-04-01"
+};
+function needsResponsesApi(model) {
+  return model.includes("codex") || model.startsWith("gpt-5") || model.startsWith("o4-") || model.startsWith("o3-");
+}
+var CopilotProvider = class extends OpenAIProvider {
+  baseUrl = "https://api.githubcopilot.com";
+  currentToken = null;
+  /** In-flight refresh promise to prevent concurrent token exchanges */
+  refreshPromise = null;
+  constructor() {
+    super("copilot", "GitHub Copilot");
+  }
+  /**
+   * Initialize the provider with Copilot credentials.
+   *
+   * Gets a valid Copilot API token (from cache or by refreshing),
+   * then creates an OpenAI client configured for the Copilot endpoint.
+   */
+  async initialize(config) {
+    this.config = {
+      ...config,
+      model: config.model ?? DEFAULT_MODEL4
+    };
+    const tokenResult = await getValidCopilotToken();
+    if (tokenResult) {
+      this.currentToken = tokenResult.token;
+      this.baseUrl = tokenResult.baseUrl;
+    } else if (config.apiKey) {
+      this.currentToken = config.apiKey;
+    }
+    if (!this.currentToken) {
+      throw new ProviderError(
+        "No Copilot token found. Please authenticate with: coco --provider copilot",
+        { provider: this.id }
+      );
+    }
+    this.createCopilotClient();
+  }
+  /**
+   * Create the OpenAI client configured for Copilot API
+   */
+  createCopilotClient() {
+    this.client = new OpenAI({
+      apiKey: this.currentToken,
+      baseURL: this.config.baseUrl ?? this.baseUrl,
+      timeout: this.config.timeout ?? 12e4,
+      defaultHeaders: COPILOT_HEADERS
+    });
+  }
+  /**
+   * Refresh the Copilot token if expired.
+   *
+   * Uses a mutex so concurrent callers share a single in-flight token
+   * exchange. The slot is cleared inside the IIFE's finally block,
+   * which runs after all awaiting callers have resumed.
+   */
+  async refreshTokenIfNeeded() {
+    if (!this.refreshPromise) {
+      this.refreshPromise = (async () => {
+        try {
+          const tokenResult = await getValidCopilotToken();
+          if (tokenResult && tokenResult.isNew) {
+            this.currentToken = tokenResult.token;
+            this.baseUrl = tokenResult.baseUrl;
+            this.createCopilotClient();
+          }
+        } finally {
+          this.refreshPromise = null;
+        }
+      })();
+    }
+    await this.refreshPromise;
+  }
+  // --- Override public methods to add token refresh + Responses API routing ---
+  async chat(messages, options) {
+    await this.refreshTokenIfNeeded();
+    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL4;
+    if (needsResponsesApi(model)) {
+      return this.chatViaResponses(messages, options);
+    }
+    return super.chat(messages, options);
+  }
+  async chatWithTools(messages, options) {
+    await this.refreshTokenIfNeeded();
+    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL4;
+    if (needsResponsesApi(model)) {
+      return this.chatWithToolsViaResponses(messages, options);
+    }
+    return super.chatWithTools(messages, options);
+  }
+  // Note: Token is refreshed before the stream starts but NOT mid-stream.
+  // Copilot tokens last ~25 min. Very long streams may get a 401 mid-stream
+  // which surfaces as a ProviderError. The retry layer handles re-attempts.
+  async *stream(messages, options) {
+    await this.refreshTokenIfNeeded();
+    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL4;
+    if (needsResponsesApi(model)) {
+      yield* this.streamViaResponses(messages, options);
+      return;
+    }
+    yield* super.stream(messages, options);
+  }
+  async *streamWithTools(messages, options) {
+    await this.refreshTokenIfNeeded();
+    const model = options?.model ?? this.config.model ?? DEFAULT_MODEL4;
+    if (needsResponsesApi(model)) {
+      yield* this.streamWithToolsViaResponses(messages, options);
+      return;
+    }
+    yield* super.streamWithTools(messages, options);
+  }
+  // --- Responses API implementations ---
+  /**
+   * Simple chat via Responses API (no tools)
+   */
+  async chatViaResponses(messages, options) {
+    this.ensureInitialized();
+    return withRetry(async () => {
+      try {
+        const model = options?.model ?? this.config.model ?? DEFAULT_MODEL4;
+        const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
+        const response = await this.client.responses.create({
+          model,
+          input,
+          instructions: instructions ?? void 0,
+          max_output_tokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
+          temperature: options?.temperature ?? this.config.temperature ?? 0,
+          store: false
+        });
+        return {
+          id: response.id,
+          content: response.output_text ?? "",
+          stopReason: response.status === "completed" ? "end_turn" : "max_tokens",
+          usage: {
+            inputTokens: response.usage?.input_tokens ?? 0,
+            outputTokens: response.usage?.output_tokens ?? 0
+          },
+          model: String(response.model)
+        };
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }, DEFAULT_RETRY_CONFIG);
+  }
+  /**
+   * Chat with tools via Responses API
+   */
+  async chatWithToolsViaResponses(messages, options) {
+    this.ensureInitialized();
+    return withRetry(async () => {
+      try {
+        const model = options?.model ?? this.config.model ?? DEFAULT_MODEL4;
+        const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
+        const tools = this.convertToolsForResponses(options.tools);
+        const response = await this.client.responses.create({
+          model,
+          input,
+          instructions: instructions ?? void 0,
+          tools,
+          max_output_tokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
+          temperature: options?.temperature ?? this.config.temperature ?? 0,
+          store: false
+        });
+        let content = "";
+        const toolCalls = [];
+        for (const item of response.output) {
+          if (item.type === "message") {
+            for (const part of item.content) {
+              if (part.type === "output_text") {
+                content += part.text;
+              }
+            }
+          } else if (item.type === "function_call") {
+            toolCalls.push({
+              id: item.call_id,
+              name: item.name,
+              input: this.parseToolArguments(item.arguments)
+            });
+          }
+        }
+        return {
+          id: response.id,
+          content,
+          stopReason: response.status === "completed" ? "end_turn" : "tool_use",
+          usage: {
+            inputTokens: response.usage?.input_tokens ?? 0,
+            outputTokens: response.usage?.output_tokens ?? 0
+          },
+          model: String(response.model),
+          toolCalls
+        };
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }, DEFAULT_RETRY_CONFIG);
+  }
+  /**
+   * Stream via Responses API (no tools)
+   */
+  async *streamViaResponses(messages, options) {
+    this.ensureInitialized();
+    try {
+      const model = options?.model ?? this.config.model ?? DEFAULT_MODEL4;
+      const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
+      const stream = await this.client.responses.create({
+        model,
+        input,
+        instructions: instructions ?? void 0,
+        max_output_tokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
+        temperature: options?.temperature ?? this.config.temperature ?? 0,
+        store: false,
+        stream: true
+      });
+      for await (const event of stream) {
+        if (event.type === "response.output_text.delta") {
+          yield { type: "text", text: event.delta };
+        } else if (event.type === "response.completed") {
+          yield { type: "done", stopReason: "end_turn" };
+        }
+      }
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+  /**
+   * Stream with tools via Responses API
+   */
+  async *streamWithToolsViaResponses(messages, options) {
+    this.ensureInitialized();
+    try {
+      const model = options?.model ?? this.config.model ?? DEFAULT_MODEL4;
+      const { input, instructions } = this.convertToResponsesInput(messages, options?.system);
+      const tools = this.convertToolsForResponses(options.tools);
+      const stream = await this.client.responses.create({
+        model,
+        input,
+        instructions: instructions ?? void 0,
+        tools,
+        max_output_tokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
+        temperature: options?.temperature ?? this.config.temperature ?? 0,
+        store: false,
+        stream: true
+      });
+      const fnCallBuilders = /* @__PURE__ */ new Map();
+      for await (const event of stream) {
+        switch (event.type) {
+          case "response.output_text.delta":
+            yield { type: "text", text: event.delta };
+            break;
+          case "response.output_item.added":
+            if (event.item.type === "function_call") {
+              const fc = event.item;
+              fnCallBuilders.set(fc.call_id, {
+                callId: fc.call_id,
+                name: fc.name,
+                arguments: ""
+              });
+              yield {
+                type: "tool_use_start",
+                toolCall: { id: fc.call_id, name: fc.name }
+              };
+            }
+            break;
+          case "response.function_call_arguments.delta":
+            {
+              const builder = fnCallBuilders.get(event.item_id);
+              if (builder) {
+                builder.arguments += event.delta;
+              }
+            }
+            break;
+          case "response.function_call_arguments.done":
+            {
+              const builder = fnCallBuilders.get(event.item_id);
+              if (builder) {
+                yield {
+                  type: "tool_use_end",
+                  toolCall: {
+                    id: builder.callId,
+                    name: builder.name,
+                    input: this.parseToolArguments(event.arguments)
+                  }
+                };
+                fnCallBuilders.delete(event.item_id);
+              }
+            }
+            break;
+          case "response.completed":
+            {
+              for (const [, builder] of fnCallBuilders) {
+                yield {
+                  type: "tool_use_end",
+                  toolCall: {
+                    id: builder.callId,
+                    name: builder.name,
+                    input: this.parseToolArguments(builder.arguments)
+                  }
+                };
+              }
+              fnCallBuilders.clear();
+              const hasToolCalls = event.response.output.some((i) => i.type === "function_call");
+              yield {
+                type: "done",
+                stopReason: hasToolCalls ? "tool_use" : "end_turn"
+              };
+            }
+            break;
+        }
+      }
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+  // --- Responses API helpers ---
+  /**
+   * Convert our internal messages to Responses API input format.
+   *
+   * The Responses API uses a flat array of input items (EasyInputMessage,
+   * function_call, function_call_output) instead of the chat completions
+   * messages array.
+   */
+  convertToResponsesInput(messages, systemPrompt) {
+    const input = [];
+    let instructions = null;
+    if (systemPrompt) {
+      instructions = systemPrompt;
+    }
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        instructions = (instructions ? instructions + "\n\n" : "") + this.contentToStr(msg.content);
+      } else if (msg.role === "user") {
+        if (Array.isArray(msg.content) && msg.content.some((b) => b.type === "tool_result")) {
+          for (const block of msg.content) {
+            if (block.type === "tool_result") {
+              const tr = block;
+              input.push({
+                type: "function_call_output",
+                call_id: tr.tool_use_id,
+                output: tr.content
+              });
+            }
+          }
+        } else {
+          input.push({
+            role: "user",
+            content: this.contentToStr(msg.content)
+          });
+        }
+      } else if (msg.role === "assistant") {
+        if (typeof msg.content === "string") {
+          input.push({
+            role: "assistant",
+            content: msg.content
+          });
+        } else if (Array.isArray(msg.content)) {
+          const textParts = [];
+          for (const block of msg.content) {
+            if (block.type === "text") {
+              textParts.push(block.text);
+            } else if (block.type === "tool_use") {
+              if (textParts.length > 0) {
+                input.push({
+                  role: "assistant",
+                  content: textParts.join("")
+                });
+                textParts.length = 0;
+              }
+              input.push({
+                type: "function_call",
+                call_id: block.id,
+                name: block.name,
+                arguments: JSON.stringify(block.input)
+              });
+            }
+          }
+          if (textParts.length > 0) {
+            input.push({
+              role: "assistant",
+              content: textParts.join("")
+            });
+          }
+        }
+      }
+    }
+    return { input, instructions };
+  }
+  /**
+   * Convert our tool definitions to Responses API FunctionTool format
+   */
+  convertToolsForResponses(tools) {
+    return tools.map((tool) => ({
+      type: "function",
+      name: tool.name,
+      description: tool.description ?? void 0,
+      parameters: tool.input_schema ?? null,
+      strict: false
+    }));
+  }
+  /**
+   * Parse tool call arguments with jsonrepair fallback
+   */
+  parseToolArguments(args) {
+    try {
+      return args ? JSON.parse(args) : {};
+    } catch {
+      try {
+        if (args) {
+          const repaired = jsonrepair(args);
+          return JSON.parse(repaired);
+        }
+      } catch {
+        console.error(`[${this.name}] Cannot parse tool arguments: ${args.slice(0, 200)}`);
+      }
+      return {};
+    }
+  }
+  /**
+   * Convert message content to string
+   */
+  contentToStr(content) {
+    if (typeof content === "string") return content;
+    return content.filter((b) => b.type === "text").map((b) => b.text).join("");
+  }
+  // --- Override metadata methods ---
+  /**
+   * Count tokens (approximate — Copilot models vary in tokenizer)
+   */
+  countTokens(text) {
+    if (!text) return 0;
+    return Math.ceil(text.length / 3.5);
+  }
+  /**
+   * Get context window for the current model
+   */
+  getContextWindow() {
+    const model = this.config.model ?? DEFAULT_MODEL4;
+    return CONTEXT_WINDOWS4[model] ?? 128e3;
+  }
+  /**
+   * Check if Copilot credentials are available
+   */
+  async isAvailable() {
+    try {
+      const tokenResult = await getValidCopilotToken();
+      return tokenResult !== null;
+    } catch {
+      return false;
+    }
+  }
+};
+var DEFAULT_MODEL5 = "gemini-3.1-pro-preview";
+var CONTEXT_WINDOWS5 = {
+  // Gemini 3.1 series (latest)
+  "gemini-3.1-pro-preview": 1e6,
+  "gemini-3.1-flash-lite-preview": 1e6,
+  // Gemini 3 series
   "gemini-3-flash-preview": 1e6,
-  "gemini-3-pro-preview": 1e6,
   // Gemini 2.5 series (production stable)
-  "gemini-2.5-pro-preview-05-06": 1048576,
-  "gemini-2.5-flash-preview-05-20": 1048576,
   "gemini-2.5-pro": 1048576,
   "gemini-2.5-flash": 1048576,
-  // Gemini 2.0 series (GA stable)
-  "gemini-2.0-flash": 1048576,
+  "gemini-2.5-flash-lite": 1048576,
   // Legacy
   "gemini-1.5-flash": 1e6,
-  "gemini-1.5-pro": 2e6,
-  "gemini-1.0-pro": 32e3
+  "gemini-1.5-pro": 2e6
 };
 var GeminiProvider = class {
   id = "gemini";
@@ -13429,7 +14029,7 @@ var GeminiProvider = class {
     await this.refreshADCIfNeeded();
     try {
       const model = this.client.getGenerativeModel({
-        model: options?.model ?? this.config.model ?? DEFAULT_MODEL4,
+        model: options?.model ?? this.config.model ?? DEFAULT_MODEL5,
         generationConfig: {
           maxOutputTokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
           temperature: options?.temperature ?? this.config.temperature ?? 0,
@@ -13458,7 +14058,7 @@ var GeminiProvider = class {
         }
       ];
       const model = this.client.getGenerativeModel({
-        model: options?.model ?? this.config.model ?? DEFAULT_MODEL4,
+        model: options?.model ?? this.config.model ?? DEFAULT_MODEL5,
         generationConfig: {
           maxOutputTokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
           temperature: options?.temperature ?? this.config.temperature ?? 0
@@ -13487,7 +14087,7 @@ var GeminiProvider = class {
     await this.refreshADCIfNeeded();
     try {
       const model = this.client.getGenerativeModel({
-        model: options?.model ?? this.config.model ?? DEFAULT_MODEL4,
+        model: options?.model ?? this.config.model ?? DEFAULT_MODEL5,
         generationConfig: {
           maxOutputTokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
           temperature: options?.temperature ?? this.config.temperature ?? 0
@@ -13526,7 +14126,7 @@ var GeminiProvider = class {
         }
       ];
       const model = this.client.getGenerativeModel({
-        model: options?.model ?? this.config.model ?? DEFAULT_MODEL4,
+        model: options?.model ?? this.config.model ?? DEFAULT_MODEL5,
         generationConfig: {
           maxOutputTokens: options?.maxTokens ?? this.config.maxTokens ?? 8192,
           temperature: options?.temperature ?? this.config.temperature ?? 0
@@ -13610,8 +14210,8 @@ var GeminiProvider = class {
    * Get context window size
    */
   getContextWindow() {
-    const model = this.config.model ?? DEFAULT_MODEL4;
-    return CONTEXT_WINDOWS4[model] ?? 1e6;
+    const model = this.config.model ?? DEFAULT_MODEL5;
+    return CONTEXT_WINDOWS5[model] ?? 1e6;
   }
   /**
    * Check if provider is available
@@ -13619,7 +14219,7 @@ var GeminiProvider = class {
   async isAvailable() {
     if (!this.client) return false;
     try {
-      const modelName = this.config.model ?? DEFAULT_MODEL4;
+      const modelName = this.config.model ?? DEFAULT_MODEL5;
       const model = this.client.getGenerativeModel({ model: modelName });
       await model.generateContent("hi");
       return true;
@@ -13751,7 +14351,7 @@ var GeminiProvider = class {
         inputTokens: usage?.promptTokenCount ?? 0,
         outputTokens: usage?.candidatesTokenCount ?? 0
       },
-      model: this.config.model ?? DEFAULT_MODEL4
+      model: this.config.model ?? DEFAULT_MODEL5
     };
   }
   /**
@@ -13786,7 +14386,7 @@ var GeminiProvider = class {
         inputTokens: usage?.promptTokenCount ?? 0,
         outputTokens: usage?.candidatesTokenCount ?? 0
       },
-      model: this.config.model ?? DEFAULT_MODEL4,
+      model: this.config.model ?? DEFAULT_MODEL5,
       toolCalls
     };
   }
@@ -13820,8 +14420,6 @@ var GeminiProvider = class {
     });
   }
 };
-
-// src/providers/index.ts
 init_env();
 async function createProvider(type, config = {}) {
   let provider;
@@ -13843,6 +14441,9 @@ async function createProvider(type, config = {}) {
     case "codex":
       provider = new CodexProvider();
       break;
+    case "copilot":
+      provider = new CopilotProvider();
+      break;
     case "gemini":
       provider = new GeminiProvider();
       break;
@@ -14013,9 +14614,9 @@ function createInitialState(config) {
 }
 async function loadExistingState(projectPath) {
   try {
-    const fs37 = await import('fs/promises');
+    const fs38 = await import('fs/promises');
     const statePath = `${projectPath}/.coco/state/project.json`;
-    const content = await fs37.readFile(statePath, "utf-8");
+    const content = await fs38.readFile(statePath, "utf-8");
     const data = JSON.parse(content);
     data.createdAt = new Date(data.createdAt);
     data.updatedAt = new Date(data.updatedAt);
@@ -14025,13 +14626,13 @@ async function loadExistingState(projectPath) {
   }
 }
 async function saveState(state) {
-  const fs37 = await import('fs/promises');
+  const fs38 = await import('fs/promises');
   const statePath = `${state.path}/.coco/state`;
-  await fs37.mkdir(statePath, { recursive: true });
+  await fs38.mkdir(statePath, { recursive: true });
   const filePath = `${statePath}/project.json`;
   const tmpPath = `${filePath}.tmp.${Date.now()}`;
-  await fs37.writeFile(tmpPath, JSON.stringify(state, null, 2), "utf-8");
-  await fs37.rename(tmpPath, filePath);
+  await fs38.writeFile(tmpPath, JSON.stringify(state, null, 2), "utf-8");
+  await fs38.rename(tmpPath, filePath);
 }
 function getPhaseExecutor(phase) {
   switch (phase) {
@@ -14090,20 +14691,20 @@ async function createPhaseContext(config, state) {
   };
   const tools = {
     file: {
-      async read(path39) {
-        const fs37 = await import('fs/promises');
-        return fs37.readFile(path39, "utf-8");
+      async read(path40) {
+        const fs38 = await import('fs/promises');
+        return fs38.readFile(path40, "utf-8");
       },
-      async write(path39, content) {
-        const fs37 = await import('fs/promises');
+      async write(path40, content) {
+        const fs38 = await import('fs/promises');
         const nodePath = await import('path');
-        await fs37.mkdir(nodePath.dirname(path39), { recursive: true });
-        await fs37.writeFile(path39, content, "utf-8");
+        await fs38.mkdir(nodePath.dirname(path40), { recursive: true });
+        await fs38.writeFile(path40, content, "utf-8");
       },
-      async exists(path39) {
-        const fs37 = await import('fs/promises');
+      async exists(path40) {
+        const fs38 = await import('fs/promises');
         try {
-          await fs37.access(path39);
+          await fs38.access(path40);
           return true;
         } catch {
           return false;
@@ -14252,9 +14853,9 @@ async function createSnapshot(state) {
 var MAX_CHECKPOINT_VERSIONS = 5;
 async function getCheckpointFiles(state, phase) {
   try {
-    const fs37 = await import('fs/promises');
+    const fs38 = await import('fs/promises');
     const checkpointDir = `${state.path}/.coco/checkpoints`;
-    const files = await fs37.readdir(checkpointDir);
+    const files = await fs38.readdir(checkpointDir);
     const phaseFiles = files.filter((f) => f.startsWith(`snapshot-pre-${phase}-`) && f.endsWith(".json")).sort((a, b) => {
       const tsA = parseInt(a.split("-").pop()?.replace(".json", "") ?? "0", 10);
       const tsB = parseInt(b.split("-").pop()?.replace(".json", "") ?? "0", 10);
@@ -14267,11 +14868,11 @@ async function getCheckpointFiles(state, phase) {
 }
 async function cleanupOldCheckpoints(state, phase) {
   try {
-    const fs37 = await import('fs/promises');
+    const fs38 = await import('fs/promises');
     const files = await getCheckpointFiles(state, phase);
     if (files.length > MAX_CHECKPOINT_VERSIONS) {
       const filesToDelete = files.slice(MAX_CHECKPOINT_VERSIONS);
-      await Promise.all(filesToDelete.map((f) => fs37.unlink(f).catch(() => {
+      await Promise.all(filesToDelete.map((f) => fs38.unlink(f).catch(() => {
       })));
     }
   } catch {
@@ -14279,13 +14880,13 @@ async function cleanupOldCheckpoints(state, phase) {
 }
 async function saveSnapshot(state, snapshotId) {
   try {
-    const fs37 = await import('fs/promises');
+    const fs38 = await import('fs/promises');
     const snapshotPath = `${state.path}/.coco/checkpoints/snapshot-${snapshotId}.json`;
     const snapshotDir = `${state.path}/.coco/checkpoints`;
-    await fs37.mkdir(snapshotDir, { recursive: true });
+    await fs38.mkdir(snapshotDir, { recursive: true });
     const createdAt = state.createdAt instanceof Date ? state.createdAt.toISOString() : String(state.createdAt);
     const updatedAt = state.updatedAt instanceof Date ? state.updatedAt.toISOString() : String(state.updatedAt);
-    await fs37.writeFile(
+    await fs38.writeFile(
       snapshotPath,
       JSON.stringify(
         {
@@ -14597,7 +15198,7 @@ async function loadConfig(configPath) {
 async function loadConfigFile(configPath, options = {}) {
   const { strict = true } = options;
   try {
-    const content = await fs15__default.readFile(configPath, "utf-8");
+    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) {
@@ -14653,7 +15254,7 @@ function deepMergeConfig(base, override) {
   };
 }
 function getProjectConfigPath2() {
-  return path16__default.join(process.cwd(), ".coco", "config.json");
+  return path17__default.join(process.cwd(), ".coco", "config.json");
 }
 async function saveConfig(config, configPath, global = false) {
   const result = CocoConfigSchema.safeParse(config);
@@ -14668,10 +15269,10 @@ async function saveConfig(config, configPath, global = false) {
     });
   }
   const resolvedPath = configPath || (global ? CONFIG_PATHS.config : getProjectConfigPath2());
-  const dir = path16__default.dirname(resolvedPath);
-  await fs15__default.mkdir(dir, { recursive: true });
+  const dir = path17__default.dirname(resolvedPath);
+  await fs16__default.mkdir(dir, { recursive: true });
   const content = JSON.stringify(result.data, null, 2);
-  await fs15__default.writeFile(resolvedPath, content, "utf-8");
+  await fs16__default.writeFile(resolvedPath, content, "utf-8");
 }
 function createDefaultConfig(projectName, language = "typescript") {
   return createDefaultConfigObject(projectName, language);
@@ -14679,7 +15280,7 @@ function createDefaultConfig(projectName, language = "typescript") {
 async function configExists(configPath, scope = "any") {
   if (configPath) {
     try {
-      await fs15__default.access(configPath);
+      await fs16__default.access(configPath);
       return true;
     } catch {
       return false;
@@ -14687,7 +15288,7 @@ async function configExists(configPath, scope = "any") {
   }
   if (scope === "project" || scope === "any") {
     try {
-      await fs15__default.access(getProjectConfigPath2());
+      await fs16__default.access(getProjectConfigPath2());
       return true;
     } catch {
       if (scope === "project") return false;
@@ -14695,7 +15296,7 @@ async function configExists(configPath, scope = "any") {
   }
   if (scope === "global" || scope === "any") {
     try {
-      await fs15__default.access(CONFIG_PATHS.config);
+      await fs16__default.access(CONFIG_PATHS.config);
       return true;
     } catch {
       return false;
@@ -14737,15 +15338,15 @@ function levenshtein(a, b) {
 var MAX_DIR_ENTRIES = 200;
 var MAX_SUGGESTIONS = 5;
 async function suggestSimilarFiles(missingPath, options) {
-  const absPath = path16__default.resolve(missingPath);
-  const dir = path16__default.dirname(absPath);
-  const target = path16__default.basename(absPath);
+  const absPath = path17__default.resolve(missingPath);
+  const dir = path17__default.dirname(absPath);
+  const target = path17__default.basename(absPath);
   const maxResults = MAX_SUGGESTIONS;
   try {
-    const entries = await fs15__default.readdir(dir);
+    const entries = await fs16__default.readdir(dir);
     const limited = entries.slice(0, MAX_DIR_ENTRIES);
     const scored = limited.map((name) => ({
-      path: path16__default.join(dir, name),
+      path: path17__default.join(dir, name),
       distance: levenshtein(target.toLowerCase(), name.toLowerCase())
     })).filter((s) => s.distance <= Math.max(target.length * 0.6, 3)).sort((a, b) => a.distance - b.distance);
     return scored.slice(0, maxResults);
@@ -14756,15 +15357,15 @@ async function suggestSimilarFiles(missingPath, options) {
 async function suggestSimilarPaths(missingPath, options) {
   const fileSuggestions = await suggestSimilarFiles(missingPath);
   if (fileSuggestions.length > 0) return fileSuggestions;
-  const absPath = path16__default.resolve(missingPath);
-  const grandparent = path16__default.dirname(path16__default.dirname(absPath));
-  const parentBasename = path16__default.basename(path16__default.dirname(absPath));
+  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 fs15__default.readdir(grandparent, { withFileTypes: true });
+    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: path16__default.join(grandparent, d.name),
+      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);
@@ -14776,7 +15377,7 @@ function formatSuggestions(suggestions, baseDir) {
   if (suggestions.length === 0) return "";
   const base = baseDir ?? process.cwd();
   const lines = suggestions.map((s) => {
-    const rel = path16__default.relative(base, s.path);
+    const rel = path17__default.relative(base, s.path);
     return `  - ${rel}`;
   });
   return `
@@ -14809,7 +15410,7 @@ function hasNullByte(str) {
 }
 function normalizePath(filePath) {
   let normalized = filePath.replace(/\0/g, "");
-  normalized = path16__default.normalize(normalized);
+  normalized = path17__default.normalize(normalized);
   return normalized;
 }
 function isPathAllowed(filePath, operation) {
@@ -14817,31 +15418,31 @@ function isPathAllowed(filePath, operation) {
     return { allowed: false, reason: "Path contains invalid characters" };
   }
   const normalized = normalizePath(filePath);
-  const absolute = path16__default.resolve(normalized);
+  const absolute = path17__default.resolve(normalized);
   const cwd = process.cwd();
   for (const blocked of BLOCKED_PATHS) {
-    const normalizedBlocked = path16__default.normalize(blocked);
-    if (absolute === normalizedBlocked || absolute.startsWith(normalizedBlocked + path16__default.sep)) {
+    const normalizedBlocked = path17__default.normalize(blocked);
+    if (absolute === normalizedBlocked || absolute.startsWith(normalizedBlocked + path17__default.sep)) {
       return { allowed: false, reason: `Access to system path '${blocked}' is not allowed` };
     }
   }
   const home = process.env.HOME;
   if (home) {
-    const normalizedHome = path16__default.normalize(home);
-    const normalizedCwd = path16__default.normalize(cwd);
+    const normalizedHome = path17__default.normalize(home);
+    const normalizedCwd = path17__default.normalize(cwd);
     if (absolute.startsWith(normalizedHome) && !absolute.startsWith(normalizedCwd)) {
       if (isWithinAllowedPath(absolute, operation)) ; else if (operation === "read") {
         const allowedHomeReads = [".gitconfig", ".zshrc", ".bashrc"];
-        const basename5 = path16__default.basename(absolute);
+        const basename5 = path17__default.basename(absolute);
         if (!allowedHomeReads.includes(basename5)) {
-          const targetDir = path16__default.dirname(absolute);
+          const targetDir = path17__default.dirname(absolute);
           return {
             allowed: false,
             reason: `Reading files outside project directory is not allowed. Use /allow-path ${targetDir} to grant access.`
           };
         }
       } else {
-        const targetDir = path16__default.dirname(absolute);
+        const targetDir = path17__default.dirname(absolute);
         return {
           allowed: false,
           reason: `${operation} operations outside project directory are not allowed. Use /allow-path ${targetDir} to grant access.`
@@ -14850,7 +15451,7 @@ function isPathAllowed(filePath, operation) {
     }
   }
   if (operation === "write" || operation === "delete") {
-    const basename5 = path16__default.basename(absolute);
+    const basename5 = path17__default.basename(absolute);
     for (const pattern of SENSITIVE_PATTERNS) {
       if (pattern.test(basename5)) {
         return {
@@ -14873,17 +15474,17 @@ function isENOENT(error) {
   return error.code === "ENOENT";
 }
 async function enrichENOENT(filePath, operation) {
-  const absPath = path16__default.resolve(filePath);
+  const absPath = path17__default.resolve(filePath);
   const suggestions = await suggestSimilarFiles(absPath);
-  const hint = formatSuggestions(suggestions, path16__default.dirname(absPath));
+  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}
 ${action}`;
 }
 async function enrichDirENOENT(dirPath) {
-  const absPath = path16__default.resolve(dirPath);
+  const absPath = path17__default.resolve(dirPath);
   const suggestions = await suggestSimilarPaths(absPath);
-  const hint = formatSuggestions(suggestions, path16__default.dirname(absPath));
+  const hint = formatSuggestions(suggestions, path17__default.dirname(absPath));
   return `Directory not found: ${dirPath}${hint}
 Use list_dir or glob to find the correct path.`;
 }
@@ -14904,13 +15505,13 @@ Examples:
   async execute({ path: filePath, encoding, maxSize }) {
     validatePath(filePath, "read");
     try {
-      const absolutePath = path16__default.resolve(filePath);
-      const stats = await fs15__default.stat(absolutePath);
+      const absolutePath = path17__default.resolve(filePath);
+      const stats = await fs16__default.stat(absolutePath);
       const maxBytes = maxSize ?? DEFAULT_MAX_FILE_SIZE;
       let truncated = false;
       let content;
       if (stats.size > maxBytes) {
-        const handle = await fs15__default.open(absolutePath, "r");
+        const handle = await fs16__default.open(absolutePath, "r");
         try {
           const buffer = Buffer.alloc(maxBytes);
           await handle.read(buffer, 0, maxBytes, 0);
@@ -14920,7 +15521,7 @@ Examples:
           await handle.close();
         }
       } else {
-        content = await fs15__default.readFile(absolutePath, encoding);
+        content = await fs16__default.readFile(absolutePath, encoding);
       }
       return {
         content,
@@ -14963,10 +15564,10 @@ Examples:
   async execute({ path: filePath, content, createDirs, dryRun }) {
     validatePath(filePath, "write");
     try {
-      const absolutePath = path16__default.resolve(filePath);
+      const absolutePath = path17__default.resolve(filePath);
       let wouldCreate = false;
       try {
-        await fs15__default.access(absolutePath);
+        await fs16__default.access(absolutePath);
       } catch {
         wouldCreate = true;
       }
@@ -14979,10 +15580,10 @@ Examples:
         };
       }
       if (createDirs) {
-        await fs15__default.mkdir(path16__default.dirname(absolutePath), { recursive: true });
+        await fs16__default.mkdir(path17__default.dirname(absolutePath), { recursive: true });
       }
-      await fs15__default.writeFile(absolutePath, content, "utf-8");
-      const stats = await fs15__default.stat(absolutePath);
+      await fs16__default.writeFile(absolutePath, content, "utf-8");
+      const stats = await fs16__default.stat(absolutePath);
       return {
         path: absolutePath,
         size: stats.size,
@@ -15025,8 +15626,8 @@ Examples:
   async execute({ path: filePath, oldText, newText, all, dryRun }) {
     validatePath(filePath, "write");
     try {
-      const absolutePath = path16__default.resolve(filePath);
-      let content = await fs15__default.readFile(absolutePath, "utf-8");
+      const absolutePath = path17__default.resolve(filePath);
+      let content = await fs16__default.readFile(absolutePath, "utf-8");
       let replacements = 0;
       if (all) {
         const regex = new RegExp(escapeRegex(oldText), "g");
@@ -15075,7 +15676,7 @@ Hint: Use read_file first to verify the exact content.`
           preview
         };
       }
-      await fs15__default.writeFile(absolutePath, content, "utf-8");
+      await fs16__default.writeFile(absolutePath, content, "utf-8");
       return {
         path: absolutePath,
         replacements,
@@ -15146,8 +15747,8 @@ Examples:
   }),
   async execute({ path: filePath }) {
     try {
-      const absolutePath = path16__default.resolve(filePath);
-      const stats = await fs15__default.stat(absolutePath);
+      const absolutePath = path17__default.resolve(filePath);
+      const stats = await fs16__default.stat(absolutePath);
       return {
         exists: true,
         isFile: stats.isFile(),
@@ -15177,12 +15778,12 @@ Examples:
   }),
   async execute({ path: dirPath, recursive }) {
     try {
-      const absolutePath = path16__default.resolve(dirPath);
+      const absolutePath = path17__default.resolve(dirPath);
       const entries = [];
       async function listDir(dir, prefix = "") {
-        const items = await fs15__default.readdir(dir, { withFileTypes: true });
+        const items = await fs16__default.readdir(dir, { withFileTypes: true });
         for (const item of items) {
-          const fullPath = path16__default.join(dir, item.name);
+          const fullPath = path17__default.join(dir, item.name);
           const relativePath = prefix ? `${prefix}/${item.name}` : item.name;
           if (item.isDirectory()) {
             entries.push({ name: relativePath, type: "directory" });
@@ -15190,7 +15791,7 @@ Examples:
               await listDir(fullPath, relativePath);
             }
           } else if (item.isFile()) {
-            const stats = await fs15__default.stat(fullPath);
+            const stats = await fs16__default.stat(fullPath);
             entries.push({ name: relativePath, type: "file", size: stats.size });
           }
         }
@@ -15237,23 +15838,23 @@ Examples:
     }
     validatePath(filePath, "delete");
     try {
-      const absolutePath = path16__default.resolve(filePath);
-      const stats = await fs15__default.stat(absolutePath);
+      const absolutePath = path17__default.resolve(filePath);
+      const stats = await fs16__default.stat(absolutePath);
       if (stats.isDirectory()) {
         if (!recursive) {
           throw new ToolError("Cannot delete directory without recursive: true", {
             tool: "delete_file"
           });
         }
-        await fs15__default.rm(absolutePath, { recursive: true });
+        await fs16__default.rm(absolutePath, { recursive: true });
       } else {
-        await fs15__default.unlink(absolutePath);
+        await fs16__default.unlink(absolutePath);
       }
       return { deleted: true, path: absolutePath };
     } catch (error) {
       if (error instanceof ToolError) throw error;
       if (error.code === "ENOENT") {
-        return { deleted: false, path: path16__default.resolve(filePath) };
+        return { deleted: false, path: path17__default.resolve(filePath) };
       }
       throw new FileSystemError(`Failed to delete: ${filePath}`, {
         path: filePath,
@@ -15281,11 +15882,11 @@ Examples:
     validatePath(source, "read");
     validatePath(destination, "write");
     try {
-      const srcPath = path16__default.resolve(source);
-      const destPath = path16__default.resolve(destination);
+      const srcPath = path17__default.resolve(source);
+      const destPath = path17__default.resolve(destination);
       if (!overwrite) {
         try {
-          await fs15__default.access(destPath);
+          await fs16__default.access(destPath);
           throw new ToolError(
             `Destination already exists: ${destination}. Use overwrite: true to replace.`,
             {
@@ -15298,9 +15899,9 @@ Examples:
           }
         }
       }
-      await fs15__default.mkdir(path16__default.dirname(destPath), { recursive: true });
-      await fs15__default.copyFile(srcPath, destPath);
-      const stats = await fs15__default.stat(destPath);
+      await fs16__default.mkdir(path17__default.dirname(destPath), { recursive: true });
+      await fs16__default.copyFile(srcPath, destPath);
+      const stats = await fs16__default.stat(destPath);
       return {
         source: srcPath,
         destination: destPath,
@@ -15342,11 +15943,11 @@ Examples:
     validatePath(source, "delete");
     validatePath(destination, "write");
     try {
-      const srcPath = path16__default.resolve(source);
-      const destPath = path16__default.resolve(destination);
+      const srcPath = path17__default.resolve(source);
+      const destPath = path17__default.resolve(destination);
       if (!overwrite) {
         try {
-          await fs15__default.access(destPath);
+          await fs16__default.access(destPath);
           throw new ToolError(
             `Destination already exists: ${destination}. Use overwrite: true to replace.`,
             {
@@ -15359,8 +15960,8 @@ Examples:
           }
         }
       }
-      await fs15__default.mkdir(path16__default.dirname(destPath), { recursive: true });
-      await fs15__default.rename(srcPath, destPath);
+      await fs16__default.mkdir(path17__default.dirname(destPath), { recursive: true });
+      await fs16__default.rename(srcPath, destPath);
       return {
         source: srcPath,
         destination: destPath
@@ -15402,13 +16003,13 @@ Examples:
   }),
   async execute({ path: dirPath, depth, showHidden, dirsOnly }) {
     try {
-      const absolutePath = path16__default.resolve(dirPath ?? ".");
+      const absolutePath = path17__default.resolve(dirPath ?? ".");
       let totalFiles = 0;
       let totalDirs = 0;
-      const lines = [path16__default.basename(absolutePath) + "/"];
+      const lines = [path17__default.basename(absolutePath) + "/"];
       async function buildTree(dir, prefix, currentDepth) {
         if (currentDepth > (depth ?? 4)) return;
-        let items = await fs15__default.readdir(dir, { withFileTypes: true });
+        let items = await fs16__default.readdir(dir, { withFileTypes: true });
         if (!showHidden) {
           items = items.filter((item) => !item.name.startsWith("."));
         }
@@ -15428,7 +16029,7 @@ Examples:
           if (item.isDirectory()) {
             totalDirs++;
             lines.push(`${prefix}${connector}${item.name}/`);
-            await buildTree(path16__default.join(dir, item.name), prefix + childPrefix, currentDepth + 1);
+            await buildTree(path17__default.join(dir, item.name), prefix + childPrefix, currentDepth + 1);
           } else {
             totalFiles++;
             lines.push(`${prefix}${connector}${item.name}`);
@@ -16469,8 +17070,8 @@ var checkAgentCapabilityTool = defineTool({
 var simpleAgentTools = [spawnSimpleAgentTool, checkAgentCapabilityTool];
 async function detectTestFramework2(cwd) {
   try {
-    const pkgPath = path16__default.join(cwd, "package.json");
-    const pkgContent = await fs15__default.readFile(pkgPath, "utf-8");
+    const pkgPath = path17__default.join(cwd, "package.json");
+    const pkgContent = await fs16__default.readFile(pkgPath, "utf-8");
     const pkg = JSON.parse(pkgContent);
     const deps = {
       ...pkg.dependencies,
@@ -16651,13 +17252,13 @@ Examples:
     const projectDir = cwd ?? process.cwd();
     try {
       const coverageLocations = [
-        path16__default.join(projectDir, "coverage", "coverage-summary.json"),
-        path16__default.join(projectDir, "coverage", "coverage-final.json"),
-        path16__default.join(projectDir, ".nyc_output", "coverage-summary.json")
+        path17__default.join(projectDir, "coverage", "coverage-summary.json"),
+        path17__default.join(projectDir, "coverage", "coverage-final.json"),
+        path17__default.join(projectDir, ".nyc_output", "coverage-summary.json")
       ];
       for (const location of coverageLocations) {
         try {
-          const content = await fs15__default.readFile(location, "utf-8");
+          const content = await fs16__default.readFile(location, "utf-8");
           const coverage = JSON.parse(content);
           if (coverage.total) {
             return {
@@ -16710,8 +17311,8 @@ Examples:
 var testTools = [runTestsTool, getCoverageTool, runTestFileTool];
 async function detectLinter2(cwd) {
   try {
-    const pkgPath = path16__default.join(cwd, "package.json");
-    const pkgContent = await fs15__default.readFile(pkgPath, "utf-8");
+    const pkgPath = path17__default.join(cwd, "package.json");
+    const pkgContent = await fs16__default.readFile(pkgPath, "utf-8");
     const pkg = JSON.parse(pkgContent);
     const deps = {
       ...pkg.dependencies,
@@ -16869,7 +17470,7 @@ Examples:
       let totalFunctions = 0;
       let complexFunctions = 0;
       for (const file of targetFiles) {
-        const content = await fs15__default.readFile(file, "utf-8");
+        const content = await fs16__default.readFile(file, "utf-8");
         const fileComplexity = analyzeFileComplexity(content, file);
         fileResults.push(fileComplexity);
         totalComplexity += fileComplexity.complexity;
@@ -17020,7 +17621,7 @@ Examples:
     caseSensitive,
     wholeWord
   }) {
-    const targetPath = searchPath ? path16__default.resolve(searchPath) : process.cwd();
+    const targetPath = searchPath ? path17__default.resolve(searchPath) : process.cwd();
     const matches = [];
     let filesSearched = 0;
     const filesWithMatches = /* @__PURE__ */ new Set();
@@ -17042,7 +17643,7 @@ Examples:
           tool: "grep"
         });
       }
-      const stats = await fs15__default.stat(targetPath);
+      const stats = await fs16__default.stat(targetPath);
       let filesToSearch;
       if (stats.isFile()) {
         filesToSearch = [targetPath];
@@ -17064,7 +17665,7 @@ Examples:
         }
         filesSearched++;
         try {
-          const content = await fs15__default.readFile(file, "utf-8");
+          const content = await fs16__default.readFile(file, "utf-8");
           const lines = content.split("\n");
           let fileHasMatch = false;
           for (let i = 0; i < lines.length; i++) {
@@ -17087,7 +17688,7 @@ Examples:
                 contextAfter.push(lines[j] ?? "");
               }
               matches.push({
-                file: path16__default.relative(process.cwd(), file),
+                file: path17__default.relative(process.cwd(), file),
                 line: i + 1,
                 column: match.index + 1,
                 content: line,
@@ -17138,8 +17739,8 @@ Examples:
   }),
   async execute({ file, pattern, caseSensitive }) {
     try {
-      const absolutePath = path16__default.resolve(file);
-      const content = await fs15__default.readFile(absolutePath, "utf-8");
+      const absolutePath = path17__default.resolve(file);
+      const content = await fs16__default.readFile(absolutePath, "utf-8");
       const lines = content.split("\n");
       const matches = [];
       const flags = caseSensitive ? "" : "i";
@@ -17336,7 +17937,7 @@ async function detectPackageManager(cwd) {
   ];
   for (const { file, pm } of lockfiles) {
     try {
-      await fs15__default.access(path16__default.join(cwd, file));
+      await fs16__default.access(path17__default.join(cwd, file));
       return pm;
     } catch {
     }
@@ -17609,7 +18210,7 @@ ${message}
     });
     try {
       try {
-        await fs15__default.access(path16__default.join(projectDir, "Makefile"));
+        await fs16__default.access(path17__default.join(projectDir, "Makefile"));
       } catch {
         throw new ToolError("No Makefile found in directory", { tool: "make" });
       }
@@ -17814,7 +18415,7 @@ z.object({
 });
 
 // src/cli/repl/session.ts
-path16__default.dirname(CONFIG_PATHS.trustedTools);
+path17__default.dirname(CONFIG_PATHS.trustedTools);
 CONFIG_PATHS.trustedTools;
 
 // src/cli/repl/recommended-permissions.ts
@@ -19349,15 +19950,15 @@ Examples:
 var diffTools = [showDiffTool];
 async function fileExists(filePath) {
   try {
-    await fs15__default.access(filePath);
+    await fs16__default.access(filePath);
     return true;
   } catch {
     return false;
   }
 }
-async function fileExists2(path39) {
+async function fileExists2(path40) {
   try {
-    await access(path39);
+    await access(path40);
     return true;
   } catch {
     return false;
@@ -19447,7 +20048,7 @@ async function detectMaturity(cwd) {
   if (!hasLintConfig && hasPackageJson) {
     try {
       const pkgRaw = await import('fs/promises').then(
-        (fs37) => fs37.readFile(join(cwd, "package.json"), "utf-8")
+        (fs38) => fs38.readFile(join(cwd, "package.json"), "utf-8")
       );
       const pkg = JSON.parse(pkgRaw);
       if (pkg.scripts?.lint || pkg.scripts?.["lint:fix"]) {
@@ -19616,7 +20217,7 @@ async function checkTestCoverage(diff, cwd) {
     );
     if (!hasTestChange) {
       const ext = src.path.match(/\.(ts|tsx|js|jsx)$/)?.[0] ?? ".ts";
-      const testExists = await fileExists(path16__default.join(cwd, `${baseName}.test${ext}`)) || await fileExists(path16__default.join(cwd, `${baseName}.spec${ext}`));
+      const testExists = await fileExists(path17__default.join(cwd, `${baseName}.test${ext}`)) || await fileExists(path17__default.join(cwd, `${baseName}.spec${ext}`));
       if (testExists) {
         if (src.additions >= TEST_COVERAGE_LARGE_CHANGE_THRESHOLD) {
           findings.push({
@@ -19847,8 +20448,8 @@ Examples:
   }
 });
 var reviewTools = [reviewCodeTool];
-var fs24 = await import('fs/promises');
-var path26 = await import('path');
+var fs25 = await import('fs/promises');
+var path27 = await import('path');
 var { glob: glob14 } = await import('glob');
 var DEFAULT_MAX_FILES = 200;
 var LANGUAGE_EXTENSIONS = {
@@ -19874,7 +20475,7 @@ var DEFAULT_EXCLUDES = [
   "**/*.d.ts"
 ];
 function detectLanguage3(filePath) {
-  const ext = path26.extname(filePath).toLowerCase();
+  const ext = path27.extname(filePath).toLowerCase();
   for (const [lang, extensions] of Object.entries(LANGUAGE_EXTENSIONS)) {
     if (extensions.includes(ext)) return lang;
   }
@@ -20283,9 +20884,9 @@ Examples:
   }),
   async execute({ path: rootPath, include, exclude, languages, maxFiles, depth }) {
     const startTime = performance.now();
-    const absPath = path26.resolve(rootPath);
+    const absPath = path27.resolve(rootPath);
     try {
-      const stat2 = await fs24.stat(absPath);
+      const stat2 = await fs25.stat(absPath);
       if (!stat2.isDirectory()) {
         throw new ToolError(`Path is not a directory: ${absPath}`, {
           tool: "codebase_map"
@@ -20322,14 +20923,14 @@ Examples:
     let totalDefinitions = 0;
     let exportedSymbols = 0;
     for (const file of limitedFiles) {
-      const fullPath = path26.join(absPath, file);
+      const fullPath = path27.join(absPath, file);
       const language = detectLanguage3(file);
       if (!language) continue;
       if (languages && !languages.includes(language)) {
         continue;
       }
       try {
-        const content = await fs24.readFile(fullPath, "utf-8");
+        const content = await fs25.readFile(fullPath, "utf-8");
         const lineCount = content.split("\n").length;
         const parsed = parseFile(content, language);
         const definitions = depth === "overview" ? parsed.definitions.filter((d) => d.exported) : parsed.definitions;
@@ -20362,23 +20963,23 @@ Examples:
 });
 var codebaseMapTools = [codebaseMapTool];
 init_paths();
-var fs25 = await import('fs/promises');
-var path27 = await import('path');
+var fs26 = await import('fs/promises');
+var path28 = await import('path');
 var crypto2 = await import('crypto');
-var GLOBAL_MEMORIES_DIR = path27.join(COCO_HOME, "memories");
+var GLOBAL_MEMORIES_DIR = path28.join(COCO_HOME, "memories");
 var PROJECT_MEMORIES_DIR = ".coco/memories";
 var DEFAULT_MAX_MEMORIES = 1e3;
 async function ensureDir(dirPath) {
-  await fs25.mkdir(dirPath, { recursive: true });
+  await fs26.mkdir(dirPath, { recursive: true });
 }
 function getMemoriesDir(scope) {
   return scope === "global" ? GLOBAL_MEMORIES_DIR : PROJECT_MEMORIES_DIR;
 }
 async function loadIndex(scope) {
   const dir = getMemoriesDir(scope);
-  const indexPath = path27.join(dir, "index.json");
+  const indexPath = path28.join(dir, "index.json");
   try {
-    const content = await fs25.readFile(indexPath, "utf-8");
+    const content = await fs26.readFile(indexPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return [];
@@ -20387,14 +20988,14 @@ async function loadIndex(scope) {
 async function saveIndex(scope, index) {
   const dir = getMemoriesDir(scope);
   await ensureDir(dir);
-  const indexPath = path27.join(dir, "index.json");
-  await fs25.writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
+  const indexPath = path28.join(dir, "index.json");
+  await fs26.writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
 }
 async function loadMemory(scope, id) {
   const dir = getMemoriesDir(scope);
-  const memPath = path27.join(dir, `${id}.json`);
+  const memPath = path28.join(dir, `${id}.json`);
   try {
-    const content = await fs25.readFile(memPath, "utf-8");
+    const content = await fs26.readFile(memPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -20403,8 +21004,8 @@ async function loadMemory(scope, id) {
 async function saveMemory(scope, memory) {
   const dir = getMemoriesDir(scope);
   await ensureDir(dir);
-  const memPath = path27.join(dir, `${memory.id}.json`);
-  await fs25.writeFile(memPath, JSON.stringify(memory, null, 2), "utf-8");
+  const memPath = path28.join(dir, `${memory.id}.json`);
+  await fs26.writeFile(memPath, JSON.stringify(memory, null, 2), "utf-8");
 }
 var createMemoryTool = defineTool({
   name: "create_memory",
@@ -20556,17 +21157,17 @@ Examples:
   }
 });
 var memoryTools = [createMemoryTool, recallMemoryTool, listMemoriesTool];
-var fs26 = await import('fs/promises');
+var fs27 = await import('fs/promises');
 var crypto3 = await import('crypto');
 var CHECKPOINT_FILE = ".coco/checkpoints.json";
 var DEFAULT_MAX_CHECKPOINTS = 50;
 var STASH_PREFIX = "coco-cp";
 async function ensureCocoDir() {
-  await fs26.mkdir(".coco", { recursive: true });
+  await fs27.mkdir(".coco", { recursive: true });
 }
 async function loadCheckpoints() {
   try {
-    const content = await fs26.readFile(CHECKPOINT_FILE, "utf-8");
+    const content = await fs27.readFile(CHECKPOINT_FILE, "utf-8");
     return JSON.parse(content);
   } catch {
     return [];
@@ -20574,7 +21175,7 @@ async function loadCheckpoints() {
 }
 async function saveCheckpoints(checkpoints) {
   await ensureCocoDir();
-  await fs26.writeFile(CHECKPOINT_FILE, JSON.stringify(checkpoints, null, 2), "utf-8");
+  await fs27.writeFile(CHECKPOINT_FILE, JSON.stringify(checkpoints, null, 2), "utf-8");
 }
 async function execGit(args) {
   const { execaCommand } = await import('execa');
@@ -20736,8 +21337,8 @@ Examples:
   }
 });
 var checkpointTools = [createCheckpointTool, restoreCheckpointTool, listCheckpointsTool];
-var fs27 = await import('fs/promises');
-var path28 = await import('path');
+var fs28 = await import('fs/promises');
+var path29 = await import('path');
 var { glob: glob15 } = await import('glob');
 var INDEX_DIR = ".coco/search-index";
 var DEFAULT_CHUNK_SIZE = 20;
@@ -20865,20 +21466,20 @@ async function getEmbedding(text) {
 }
 async function loadIndex2(indexDir) {
   try {
-    const indexPath = path28.join(indexDir, "index.json");
-    const content = await fs27.readFile(indexPath, "utf-8");
+    const indexPath = path29.join(indexDir, "index.json");
+    const content = await fs28.readFile(indexPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 async function saveIndex2(indexDir, index) {
-  await fs27.mkdir(indexDir, { recursive: true });
-  const indexPath = path28.join(indexDir, "index.json");
-  await fs27.writeFile(indexPath, JSON.stringify(index), "utf-8");
+  await fs28.mkdir(indexDir, { recursive: true });
+  const indexPath = path29.join(indexDir, "index.json");
+  await fs28.writeFile(indexPath, JSON.stringify(index), "utf-8");
 }
 function isBinary(filePath) {
-  return BINARY_EXTENSIONS.has(path28.extname(filePath).toLowerCase());
+  return BINARY_EXTENSIONS.has(path29.extname(filePath).toLowerCase());
 }
 var semanticSearchTool = defineTool({
   name: "semantic_search",
@@ -20903,8 +21504,8 @@ Examples:
     const effectivePath = rootPath ?? ".";
     const effectiveMaxResults = maxResults ?? 10;
     const effectiveThreshold = threshold ?? 0.3;
-    const absPath = path28.resolve(effectivePath);
-    const indexDir = path28.join(absPath, INDEX_DIR);
+    const absPath = path29.resolve(effectivePath);
+    const indexDir = path29.join(absPath, INDEX_DIR);
     let index = reindex ? null : await loadIndex2(indexDir);
     let warnings = [];
     if (!index) {
@@ -20920,10 +21521,10 @@ Examples:
       let indexSaveWarning = "";
       for (const file of files) {
         if (isBinary(file)) continue;
-        const fullPath = path28.join(absPath, file);
+        const fullPath = path29.join(absPath, file);
         try {
-          const stat2 = await fs27.stat(fullPath);
-          const content = await fs27.readFile(fullPath, "utf-8");
+          const stat2 = await fs28.stat(fullPath);
+          const content = await fs28.readFile(fullPath, "utf-8");
           if (content.length > 1e5) continue;
           const fileChunks = chunkContent(content, DEFAULT_CHUNK_SIZE);
           for (const chunk of fileChunks) {
@@ -20999,8 +21600,8 @@ Examples:
   }
 });
 var semanticSearchTools = [semanticSearchTool];
-var fs28 = await import('fs/promises');
-var path29 = await import('path');
+var fs29 = await import('fs/promises');
+var path30 = await import('path');
 var { glob: glob16 } = await import('glob');
 async function parseClassRelationships(rootPath, include) {
   const pattern = include ?? "**/*.{ts,tsx,js,jsx}";
@@ -21013,7 +21614,7 @@ async function parseClassRelationships(rootPath, include) {
   const interfaces = [];
   for (const file of files.slice(0, 100)) {
     try {
-      const content = await fs28.readFile(path29.join(rootPath, file), "utf-8");
+      const content = await fs29.readFile(path30.join(rootPath, file), "utf-8");
       const lines = content.split("\n");
       for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
@@ -21132,14 +21733,14 @@ async function generateClassDiagram(rootPath, include) {
   };
 }
 async function generateArchitectureDiagram(rootPath) {
-  const entries = await fs28.readdir(rootPath, { withFileTypes: true });
+  const entries = await fs29.readdir(rootPath, { withFileTypes: true });
   const dirs = entries.filter(
     (e) => e.isDirectory() && !e.name.startsWith(".") && !["node_modules", "dist", "build", "coverage", "__pycache__", "target"].includes(e.name)
   );
   const lines = ["graph TD"];
   let nodeCount = 0;
   let edgeCount = 0;
-  const rootName = path29.basename(rootPath);
+  const rootName = path30.basename(rootPath);
   lines.push(`  ROOT["${rootName}"]`);
   nodeCount++;
   for (const dir of dirs) {
@@ -21149,7 +21750,7 @@ async function generateArchitectureDiagram(rootPath) {
     nodeCount++;
     edgeCount++;
     try {
-      const subEntries = await fs28.readdir(path29.join(rootPath, dir.name), {
+      const subEntries = await fs29.readdir(path30.join(rootPath, dir.name), {
         withFileTypes: true
       });
       const subDirs = subEntries.filter(
@@ -21272,7 +21873,7 @@ Examples:
         tool: "generate_diagram"
       });
     }
-    const absPath = rootPath ? path29.resolve(rootPath) : process.cwd();
+    const absPath = rootPath ? path30.resolve(rootPath) : process.cwd();
     switch (type) {
       case "class":
         return generateClassDiagram(absPath, include);
@@ -21333,8 +21934,8 @@ Examples:
   }
 });
 var diagramTools = [generateDiagramTool];
-var fs29 = await import('fs/promises');
-var path30 = await import('path');
+var fs30 = await import('fs/promises');
+var path31 = await import('path');
 var DEFAULT_MAX_PAGES = 20;
 var MAX_FILE_SIZE = 50 * 1024 * 1024;
 function parsePageRange(rangeStr, totalPages) {
@@ -21369,9 +21970,9 @@ Examples:
   }),
   async execute({ path: filePath, pages, maxPages }) {
     const startTime = performance.now();
-    const absPath = path30.resolve(filePath);
+    const absPath = path31.resolve(filePath);
     try {
-      const stat2 = await fs29.stat(absPath);
+      const stat2 = await fs30.stat(absPath);
       if (!stat2.isFile()) {
         throw new ToolError(`Path is not a file: ${absPath}`, {
           tool: "read_pdf"
@@ -21402,7 +22003,7 @@ Examples:
     }
     try {
       const pdfParse = await import('pdf-parse');
-      const dataBuffer = await fs29.readFile(absPath);
+      const dataBuffer = await fs30.readFile(absPath);
       const pdfData = await pdfParse.default(dataBuffer, {
         max: maxPages
       });
@@ -21449,8 +22050,8 @@ Examples:
   }
 });
 var pdfTools = [readPdfTool];
-var fs30 = await import('fs/promises');
-var path31 = await import('path');
+var fs31 = await import('fs/promises');
+var path32 = await import('path');
 var SUPPORTED_FORMATS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"]);
 var MAX_IMAGE_SIZE = 20 * 1024 * 1024;
 var MIME_TYPES = {
@@ -21478,15 +22079,15 @@ Examples:
   async execute({ path: filePath, prompt, provider }) {
     const startTime = performance.now();
     const effectivePrompt = prompt ?? "Describe this image in detail. If it's code or a UI, identify the key elements.";
-    const absPath = path31.resolve(filePath);
+    const absPath = path32.resolve(filePath);
     const cwd = process.cwd();
-    if (!absPath.startsWith(cwd + path31.sep) && absPath !== cwd) {
+    if (!absPath.startsWith(cwd + path32.sep) && absPath !== cwd) {
       throw new ToolError(
         `Path traversal denied: '${filePath}' resolves outside the project directory`,
         { tool: "read_image" }
       );
     }
-    const ext = path31.extname(absPath).toLowerCase();
+    const ext = path32.extname(absPath).toLowerCase();
     if (!SUPPORTED_FORMATS.has(ext)) {
       throw new ToolError(
         `Unsupported image format '${ext}'. Supported: ${Array.from(SUPPORTED_FORMATS).join(", ")}`,
@@ -21494,7 +22095,7 @@ Examples:
       );
     }
     try {
-      const stat2 = await fs30.stat(absPath);
+      const stat2 = await fs31.stat(absPath);
       if (!stat2.isFile()) {
         throw new ToolError(`Path is not a file: ${absPath}`, {
           tool: "read_image"
@@ -21515,7 +22116,7 @@ Examples:
       if (error instanceof ToolError) throw error;
       throw error;
     }
-    const imageBuffer = await fs30.readFile(absPath);
+    const imageBuffer = await fs31.readFile(absPath);
     const base64 = imageBuffer.toString("base64");
     const mimeType = MIME_TYPES[ext] ?? "image/png";
     const selectedProvider = provider ?? "anthropic";
@@ -21552,8 +22153,8 @@ Examples:
         description = response.content.filter((block) => block.type === "text").map((block) => block.text).join("\n") || "No description generated";
       } else if (selectedProvider === "openai") {
         model = "gpt-4o";
-        const { default: OpenAI2 } = await import('openai');
-        const client = new OpenAI2();
+        const { default: OpenAI3 } = await import('openai');
+        const client = new OpenAI3();
         const openaiMessages = [
           {
             role: "user",
@@ -21633,7 +22234,7 @@ Examples:
   }
 });
 var imageTools = [readImageTool];
-var path32 = await import('path');
+var path33 = await import('path');
 var DANGEROUS_PATTERNS = [
   /\bDROP\s+(?:TABLE|DATABASE|INDEX|VIEW)\b/i,
   /\bTRUNCATE\b/i,
@@ -21664,7 +22265,7 @@ Examples:
   async execute({ database, query, params, readonly: isReadonlyParam }) {
     const isReadonly = isReadonlyParam ?? true;
     const startTime = performance.now();
-    const absPath = path32.resolve(database);
+    const absPath = path33.resolve(database);
     if (isReadonly && isDangerousSql(query)) {
       throw new ToolError(
         "Write operations (INSERT, UPDATE, DELETE, DROP, ALTER, TRUNCATE, CREATE) are blocked in readonly mode. Set readonly: false to allow writes.",
@@ -21747,7 +22348,7 @@ Examples:
   }),
   async execute({ database, table }) {
     const startTime = performance.now();
-    const absPath = path32.resolve(database);
+    const absPath = path33.resolve(database);
     try {
       const { default: Database } = await import('better-sqlite3');
       const db = new Database(absPath, { readonly: true, fileMustExist: true });
@@ -21806,14 +22407,14 @@ Examples:
   }
 });
 var databaseTools = [sqlQueryTool, inspectSchemaTool];
-var fs31 = await import('fs/promises');
-var path33 = await import('path');
+var fs32 = await import('fs/promises');
+var path34 = await import('path');
 var AnalyzeFileSchema = z.object({
   filePath: z.string().describe("Path to file to analyze"),
   includeAst: z.boolean().default(false).describe("Include AST in result")
 });
 async function analyzeFile(filePath, includeAst = false) {
-  const content = await fs31.readFile(filePath, "utf-8");
+  const content = await fs32.readFile(filePath, "utf-8");
   const lines = content.split("\n").length;
   const functions = [];
   const classes = [];
@@ -21917,10 +22518,10 @@ async function analyzeDirectory(dirPath) {
     try {
       const analysis = await analyzeFile(file, false);
       totalLines += analysis.lines;
-      const ext = path33.extname(file);
+      const ext = path34.extname(file);
       filesByType[ext] = (filesByType[ext] || 0) + 1;
       fileStats.push({
-        file: path33.relative(dirPath, file),
+        file: path34.relative(dirPath, file),
         lines: analysis.lines,
         complexity: analysis.complexity.cyclomatic
       });
@@ -22285,13 +22886,13 @@ ${completed.map((r) => `- ${r.agentId}: Success`).join("\n")}`;
   }
 });
 var agentCoordinatorTools = [createAgentPlanTool, delegateTaskTool, aggregateResultsTool];
-var fs32 = await import('fs/promises');
+var fs33 = await import('fs/promises');
 var SuggestImprovementsSchema = z.object({
   filePath: z.string().describe("File to analyze for improvement suggestions"),
   context: z.string().optional().describe("Additional context about the code")
 });
 async function analyzeAndSuggest(filePath, _context) {
-  const content = await fs32.readFile(filePath, "utf-8");
+  const content = await fs33.readFile(filePath, "utf-8");
   const lines = content.split("\n");
   const suggestions = [];
   for (let i = 0; i < lines.length; i++) {
@@ -22383,7 +22984,7 @@ async function analyzeAndSuggest(filePath, _context) {
     if (filePath.endsWith(".ts") && !filePath.includes("test") && !filePath.includes(".d.ts") && line.includes("export ")) {
       const testPath = filePath.replace(".ts", ".test.ts");
       try {
-        await fs32.access(testPath);
+        await fs33.access(testPath);
       } catch {
         suggestions.push({
           type: "testing",
@@ -22440,7 +23041,7 @@ var calculateCodeScoreTool = defineTool({
   async execute(input) {
     const { filePath } = input;
     const suggestions = await analyzeAndSuggest(filePath);
-    const content = await fs32.readFile(filePath, "utf-8");
+    const content = await fs33.readFile(filePath, "utf-8");
     const lines = content.split("\n");
     const nonEmptyLines = lines.filter((l) => l.trim()).length;
     let score = 100;
@@ -22474,8 +23075,8 @@ var calculateCodeScoreTool = defineTool({
   }
 });
 var smartSuggestionsTools = [suggestImprovementsTool, calculateCodeScoreTool];
-var fs33 = await import('fs/promises');
-var path34 = await import('path');
+var fs34 = await import('fs/promises');
+var path35 = await import('path');
 var ContextMemoryStore = class {
   items = /* @__PURE__ */ new Map();
   learnings = /* @__PURE__ */ new Map();
@@ -22487,7 +23088,7 @@ var ContextMemoryStore = class {
   }
   async load() {
     try {
-      const content = await fs33.readFile(this.storePath, "utf-8");
+      const content = await fs34.readFile(this.storePath, "utf-8");
       const data = JSON.parse(content);
       this.items = new Map(Object.entries(data.items || {}));
       this.learnings = new Map(Object.entries(data.learnings || {}));
@@ -22495,15 +23096,15 @@ var ContextMemoryStore = class {
     }
   }
   async save() {
-    const dir = path34.dirname(this.storePath);
-    await fs33.mkdir(dir, { recursive: true });
+    const dir = path35.dirname(this.storePath);
+    await fs34.mkdir(dir, { recursive: true });
     const data = {
       sessionId: this.sessionId,
       items: Object.fromEntries(this.items),
       learnings: Object.fromEntries(this.learnings),
       savedAt: Date.now()
     };
-    await fs33.writeFile(this.storePath, JSON.stringify(data, null, 2));
+    await fs34.writeFile(this.storePath, JSON.stringify(data, null, 2));
   }
   addContext(id, item) {
     this.items.set(id, item);
@@ -22668,11 +23269,11 @@ var contextEnhancerTools = [
   recordLearningTool,
   getLearnedPatternsTool
 ];
-var fs34 = await import('fs/promises');
-var path35 = await import('path');
+var fs35 = await import('fs/promises');
+var path36 = await import('path');
 async function discoverSkills(skillsDir) {
   try {
-    const files = await fs34.readdir(skillsDir);
+    const files = await fs35.readdir(skillsDir);
     return files.filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
   } catch {
     return [];
@@ -22680,12 +23281,12 @@ async function discoverSkills(skillsDir) {
 }
 async function loadSkillMetadata(skillPath) {
   try {
-    const content = await fs34.readFile(skillPath, "utf-8");
+    const content = await fs35.readFile(skillPath, "utf-8");
     const nameMatch = content.match(/@name\s+(\S+)/);
     const descMatch = content.match(/@description\s+(.+)/);
     const versionMatch = content.match(/@version\s+(\S+)/);
     return {
-      name: nameMatch?.[1] || path35.basename(skillPath, path35.extname(skillPath)),
+      name: nameMatch?.[1] || path36.basename(skillPath, path36.extname(skillPath)),
       description: descMatch?.[1] || "No description",
       version: versionMatch?.[1] || "1.0.0",
       dependencies: []
@@ -22729,7 +23330,7 @@ var discoverSkillsTool = defineTool({
     const { skillsDir } = input;
     const skills = await discoverSkills(skillsDir);
     const metadata = await Promise.all(
-      skills.map((s) => loadSkillMetadata(path35.join(skillsDir, s)))
+      skills.map((s) => loadSkillMetadata(path36.join(skillsDir, s)))
     );
     return {
       skillsDir,
@@ -23230,8 +23831,8 @@ function hasNullByte2(str) {
 }
 function isBlockedPath(absolute) {
   for (const blocked of BLOCKED_PATHS2) {
-    const normalizedBlocked = path16__default.normalize(blocked);
-    if (absolute === normalizedBlocked || absolute.startsWith(normalizedBlocked + path16__default.sep)) {
+    const normalizedBlocked = path17__default.normalize(blocked);
+    if (absolute === normalizedBlocked || absolute.startsWith(normalizedBlocked + path17__default.sep)) {
       return blocked;
     }
   }
@@ -23249,7 +23850,7 @@ function getInterpreter(ext) {
 }
 async function isExecutable(filePath) {
   try {
-    await fs15__default.access(filePath, fs15__default.constants.X_OK);
+    await fs16__default.access(filePath, fs16__default.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -23289,7 +23890,7 @@ Examples:
       throw new ToolError("Invalid file path", { tool: "open_file" });
     }
     const workDir = cwd ?? process.cwd();
-    const absolute = path16__default.isAbsolute(filePath) ? path16__default.normalize(filePath) : path16__default.resolve(workDir, filePath);
+    const absolute = path17__default.isAbsolute(filePath) ? path17__default.normalize(filePath) : path17__default.resolve(workDir, filePath);
     const blockedBy = isBlockedPath(absolute);
     if (blockedBy) {
       throw new ToolError(`Access to system path '${blockedBy}' is not allowed`, {
@@ -23297,7 +23898,7 @@ Examples:
       });
     }
     try {
-      await fs15__default.access(absolute);
+      await fs16__default.access(absolute);
     } catch {
       throw new ToolError(`File not found: ${absolute}`, { tool: "open_file" });
     }
@@ -23312,14 +23913,14 @@ Examples:
       };
     }
     if (isBlockedExecFile(absolute)) {
-      throw new ToolError(`Execution of sensitive file is blocked: ${path16__default.basename(absolute)}`, {
+      throw new ToolError(`Execution of sensitive file is blocked: ${path17__default.basename(absolute)}`, {
         tool: "open_file"
       });
     }
     if (args.length > 0 && hasDangerousArgs(args)) {
       throw new ToolError("Arguments contain dangerous patterns", { tool: "open_file" });
     }
-    const ext = path16__default.extname(absolute);
+    const ext = path17__default.extname(absolute);
     const interpreter = getInterpreter(ext);
     const executable = await isExecutable(absolute);
     let command;
@@ -23332,7 +23933,7 @@ Examples:
       cmdArgs = [...args];
     } else {
       throw new ToolError(
-        `Cannot execute '${path16__default.basename(absolute)}': no known interpreter for '${ext || "(no extension)"}' and file is not executable`,
+        `Cannot execute '${path17__default.basename(absolute)}': no known interpreter for '${ext || "(no extension)"}' and file is not executable`,
         { tool: "open_file" }
       );
     }
@@ -23384,7 +23985,7 @@ Examples:
     reason: z.string().optional().describe("Why access is needed (shown to user for context)")
   }),
   async execute({ path: dirPath, reason }) {
-    const absolute = path16__default.resolve(dirPath);
+    const absolute = path17__default.resolve(dirPath);
     if (isWithinAllowedPath(absolute, "read")) {
       return {
         authorized: true,
@@ -23393,8 +23994,8 @@ Examples:
       };
     }
     for (const blocked of BLOCKED_SYSTEM_PATHS) {
-      const normalizedBlocked = path16__default.normalize(blocked);
-      if (absolute === normalizedBlocked || absolute.startsWith(normalizedBlocked + path16__default.sep)) {
+      const normalizedBlocked = path17__default.normalize(blocked);
+      if (absolute === normalizedBlocked || absolute.startsWith(normalizedBlocked + path17__default.sep)) {
         return {
           authorized: false,
           path: absolute,
@@ -23403,7 +24004,7 @@ Examples:
       }
     }
     const cwd = process.cwd();
-    if (absolute === path16__default.normalize(cwd) || absolute.startsWith(path16__default.normalize(cwd) + path16__default.sep)) {
+    if (absolute === path17__default.normalize(cwd) || absolute.startsWith(path17__default.normalize(cwd) + path17__default.sep)) {
       return {
         authorized: true,
         path: absolute,
@@ -23411,7 +24012,7 @@ Examples:
       };
     }
     try {
-      const stat2 = await fs15__default.stat(absolute);
+      const stat2 = await fs16__default.stat(absolute);
       if (!stat2.isDirectory()) {
         return {
           authorized: false,
@@ -23427,7 +24028,7 @@ Examples:
       };
     }
     const existing = getAllowedPaths();
-    if (existing.some((e) => path16__default.normalize(e.path) === path16__default.normalize(absolute))) {
+    if (existing.some((e) => path17__default.normalize(e.path) === path17__default.normalize(absolute))) {
       return {
         authorized: true,
         path: absolute,