@corbat-tech/coco 2.9.0 → 2.11.0

package/dist/index.js

@@ -1,12 +1,12 @@
 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 chalk3 from 'chalk';
-import * as p3 from '@clack/prompts';
+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';
 import { randomUUID } from 'crypto';
 import { execa } from 'execa';
@@ -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,12 +404,12 @@ __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(chalk3.yellow("  \u26A0 Access denied \u2014 path is outside the project directory"));
-  console.log(chalk3.dim(`  \u{1F4C1} ${absolute}`));
+  console.log(chalk4.yellow("  \u26A0 Access denied \u2014 path is outside the project directory"));
+  console.log(chalk4.dim(`  \u{1F4C1} ${absolute}`));
   console.log();
-  const action = await p3.select({
+  const action = await p4.select({
     message: "Grant access to this directory?",
     options: [
       { value: "session-write", label: "\u2713 Allow write (this session)" },
@@ -412,7 +419,7 @@ async function promptAllowPath(dirPath) {
       { value: "no", label: "\u2717 Deny" }
     ]
   });
-  if (p3.isCancel(action) || action === "no") {
+  if (p4.isCancel(action) || action === "no") {
     return false;
   }
   const level = action.includes("read") ? "read" : "write";
@@ -423,7 +430,7 @@ async function promptAllowPath(dirPath) {
   }
   const levelLabel = level === "write" ? "write" : "read-only";
   const persistLabel = persist ? " (remembered)" : "";
-  console.log(chalk3.green(`  \u2713 Access granted: ${levelLabel}${persistLabel}`));
+  console.log(chalk4.green(`  \u2713 Access granted: ${levelLabel}${persistLabel}`));
   return true;
 }
 var init_allow_path_prompt = __esm({
@@ -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}`);
@@ -15968,9 +16569,9 @@ Examples:
       if (file) {
         options.file = file;
       }
-      const log2 = await git.log(options);
+      const log3 = await git.log(options);
       return {
-        commits: log2.all.map((commit) => ({
+        commits: log3.all.map((commit) => ({
           hash: commit.hash,
           message: commit.message,
           author: commit.author_name,
@@ -16282,6 +16883,34 @@ var simpleAutoCommitTool = defineTool({
   }
 });
 var gitSimpleTools = [checkProtectedBranchTool, simpleAutoCommitTool];
+var AGENT_NAMES = {
+  explore: "Explorer",
+  plan: "Planner",
+  test: "Tester",
+  debug: "Debugger",
+  review: "Reviewer",
+  architect: "Architect",
+  security: "Security Auditor",
+  tdd: "TDD Guide",
+  refactor: "Refactorer",
+  e2e: "E2E Tester",
+  docs: "Docs Writer",
+  database: "Database Engineer"
+};
+var AGENT_DESCRIPTIONS = {
+  explore: "Search the codebase to answer questions and gather information",
+  plan: "Design implementation approaches and create detailed plans",
+  test: "Write and run tests to ensure code quality",
+  debug: "Analyze errors and fix issues",
+  review: "Review code for quality and best practices",
+  architect: "Design system architecture and create architectural decision records",
+  security: "Audit code for security vulnerabilities using OWASP Top 10",
+  tdd: "Drive development with test-first methodology and RED-GREEN-REFACTOR cycle",
+  refactor: "Improve code structure and quality without changing behavior",
+  e2e: "Write and run end-to-end tests covering full user workflows",
+  docs: "Generate and maintain documentation for code, APIs, and architecture",
+  database: "Design database schemas, write migrations, and optimize queries"
+};
 
 // src/agents/provider-bridge.ts
 var agentProvider = null;
@@ -16292,103 +16921,80 @@ function getAgentProvider() {
 function getAgentToolRegistry() {
   return agentToolRegistry;
 }
-var AGENT_ROLES = {
-  researcher: {
-    role: "researcher",
-    systemPrompt: `You are a code researcher agent. Your role is to:
-- Explore and understand existing codebases
-- Find relevant code patterns and examples
-- Identify dependencies and relationships
-- Document your findings clearly
-
-Use tools to search, read files, and analyze code structure.`,
-    allowedTools: ["read_file", "grep", "find_in_file", "glob", "codebase_map"]
-  },
-  coder: {
-    role: "coder",
-    systemPrompt: `You are a code generation agent. Your role is to:
-- Write high-quality, production-ready code
-- Follow best practices and coding standards
-- Ensure code is syntactically valid
-- Write clean, maintainable code
-
-Use tools to read existing code, write new files, and validate syntax.`,
-    allowedTools: ["read_file", "write_file", "edit_file", "bash_exec", "validateCode"]
-  },
-  tester: {
-    role: "tester",
-    systemPrompt: `You are a test generation agent. Your role is to:
-- Write comprehensive test suites
-- Achieve high code coverage
-- Test edge cases and error conditions
-- Ensure tests are reliable and maintainable
-
-Use tools to read code, write tests, and run them.`,
-    allowedTools: ["read_file", "write_file", "run_tests", "get_coverage", "run_test_file"]
-  },
-  reviewer: {
-    role: "reviewer",
-    systemPrompt: `You are a code review agent. Your role is to:
-- Identify code quality issues
-- Check for security vulnerabilities
-- Ensure best practices are followed
-- Provide actionable feedback
-
-Use tools to read and analyze code quality.`,
-    allowedTools: ["read_file", "calculate_quality", "analyze_complexity", "grep"]
-  },
-  optimizer: {
-    role: "optimizer",
-    systemPrompt: `You are a code optimization agent. Your role is to:
-- Reduce code complexity
-- Eliminate duplication
-- Improve performance
-- Refactor for maintainability
-
-Use tools to analyze and improve code.`,
-    allowedTools: ["read_file", "write_file", "edit_file", "analyze_complexity", "grep"]
-  },
-  planner: {
-    role: "planner",
-    systemPrompt: `You are a task planning agent. Your role is to:
-- Break down complex tasks into subtasks
-- Identify dependencies between tasks
-- Estimate complexity and effort
-- Create actionable plans
-
-Use tools to analyze requirements and explore the codebase.`,
-    allowedTools: ["read_file", "grep", "glob", "codebase_map"]
+function getAgentManager() {
+  {
+    return null;
   }
-};
+}
 
 // src/tools/simple-agent.ts
+var AGENT_TYPES = [
+  "explore",
+  "plan",
+  "test",
+  "debug",
+  "review",
+  "architect",
+  "security",
+  "tdd",
+  "refactor",
+  "e2e",
+  "docs",
+  "database"
+];
+var LEGACY_ROLE_MAP = {
+  researcher: "explore",
+  coder: "debug",
+  // "debug" has write + bash + read — closest to general coding
+  tester: "test",
+  reviewer: "review",
+  optimizer: "refactor",
+  planner: "plan"
+};
 var SpawnSimpleAgentSchema = z.object({
   task: z.string().describe("Task description for the sub-agent"),
   context: z.string().optional().describe("Additional context or instructions for the agent"),
-  role: z.enum(["researcher", "coder", "tester", "reviewer", "optimizer", "planner"]).default("coder").describe("Agent role to use"),
+  type: z.enum(AGENT_TYPES).optional().describe(
+    "Specialized agent type. Use 'explore' for codebase search, 'plan' for design, 'test' for testing, 'review' for code review, 'architect' for system design, 'security' for security audit, 'tdd' for test-driven development, 'debug' for debugging, 'refactor' for code improvement, 'e2e' for integration tests, 'docs' for documentation, 'database' for DB operations."
+  ),
+  role: z.enum(["researcher", "coder", "tester", "reviewer", "optimizer", "planner"]).optional().describe("DEPRECATED: Use 'type' instead. Legacy role name, mapped to new agent types."),
   maxTurns: z.number().default(10).describe("Maximum tool-use turns for the agent")
 });
+function resolveAgentType(input) {
+  if (input.type) return input.type;
+  if (input.role && input.role in LEGACY_ROLE_MAP) return LEGACY_ROLE_MAP[input.role];
+  return "explore";
+}
 var spawnSimpleAgentTool = defineTool({
   name: "spawnSimpleAgent",
-  description: `Spawn a sub-agent to handle a specific task with real LLM tool-use execution.
-
-Use this when you need to:
-- Delegate a focused task to another agent
-- Get a second opinion or alternative approach
-- Handle multiple independent subtasks
-
-The sub-agent will work on the task autonomously using available tools.
-
-Example: "Write unit tests for the authentication module"`,
+  description: `Spawn a specialized sub-agent to handle a specific task autonomously.
+
+Available agent types:
+- explore: Search and understand codebases (read-only, fast)
+- plan: Design implementation approaches (read-only)
+- test: Write and run tests
+- debug: Analyze errors and fix issues
+- review: Review code for quality and best practices (read-only)
+- architect: Design system architecture (read-only)
+- security: Audit code for security vulnerabilities (read-only)
+- tdd: Test-driven development with RED-GREEN-REFACTOR
+- refactor: Improve code structure without changing behavior
+- e2e: End-to-end integration testing
+- docs: Generate and maintain documentation
+- database: Design schemas, migrations, and optimize queries
+
+Each type has a filtered set of tools appropriate for its role.
+Use 'explore' for quick codebase searches, 'plan' for design before execution.`,
   category: "build",
   parameters: SpawnSimpleAgentSchema,
   async execute(input) {
     const typedInput = input;
-    {
-      const agentId2 = `agent-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+    const manager = getAgentManager();
+    if (!manager) {
+      const agentId = `agent-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
       return {
         stdout: JSON.stringify({
-          agentId: agentId2,
+          agentId,
           status: "unavailable",
           task: typedInput.task,
           message: "Agent provider not initialized. Call setAgentProvider() during orchestrator startup.",
@@ -16399,6 +17005,31 @@ Example: "Write unit tests for the authentication module"`,
         duration: 0
       };
     }
+    const agentType = resolveAgentType(typedInput);
+    const taskDescription = typedInput.context ? `${typedInput.task}
+
+Additional context: ${typedInput.context}` : typedInput.task;
+    const startTime = Date.now();
+    const result = await manager.spawn(agentType, taskDescription, {
+      timeout: typedInput.maxTurns * 6e4
+      // rough estimate: 1 min per turn
+    });
+    const duration = Date.now() - startTime;
+    return {
+      stdout: JSON.stringify({
+        agentId: result.agent.id,
+        agentType,
+        status: result.success ? "completed" : "failed",
+        task: typedInput.task,
+        output: result.output,
+        success: result.success,
+        usage: result.usage,
+        duration
+      }),
+      stderr: "",
+      exitCode: result.success ? 0 : 1,
+      duration
+    };
   }
 });
 var checkAgentCapabilityTool = defineTool({
@@ -16410,17 +17041,23 @@ var checkAgentCapabilityTool = defineTool({
     const provider = getAgentProvider();
     const toolRegistry = getAgentToolRegistry();
     const isReady = provider !== null;
+    const agentTypes = Object.entries(AGENT_DESCRIPTIONS).map(([type, description]) => ({
+      type,
+      name: AGENT_NAMES[type],
+      description
+    }));
     return {
       stdout: JSON.stringify({
         multiAgentSupported: true,
         providerConfigured: provider !== null,
         toolRegistryConfigured: toolRegistry !== null,
         ready: isReady,
-        availableRoles: Object.keys(AGENT_ROLES),
+        availableTypes: agentTypes,
         features: {
           taskDelegation: "requires provider initialization",
           parallelSpawn: "requires provider initialization",
-          multiTurnToolUse: "requires provider initialization"
+          multiTurnToolUse: "requires provider initialization",
+          specializedAgents: "requires provider initialization"
         },
         status: "Provider not initialized. Call setAgentProvider() during startup."
       }),
@@ -16433,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,
@@ -16615,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 {
@@ -16674,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,
@@ -16833,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;
@@ -16984,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();
@@ -17006,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];
@@ -17028,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++) {
@@ -17051,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,
@@ -17102,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";
@@ -17132,7 +17769,7 @@ Examples:
   }
 });
 var searchTools = [grepTool, findInFileTool];
-var DEFAULT_TIMEOUT_MS2 = 3e4;
+var DEFAULT_TIMEOUT_MS3 = 3e4;
 var MAX_RESPONSE_SIZE = 5 * 1024 * 1024;
 var httpFetchTool = defineTool({
   name: "http_fetch",
@@ -17155,7 +17792,7 @@ Examples:
   }),
   async execute({ url, method, headers, body, timeout, maxSize }) {
     const startTime = performance.now();
-    const timeoutMs = timeout ?? DEFAULT_TIMEOUT_MS2;
+    const timeoutMs = timeout ?? DEFAULT_TIMEOUT_MS3;
     const maxBytes = maxSize ?? MAX_RESPONSE_SIZE;
     try {
       const controller = new AbortController();
@@ -17273,7 +17910,7 @@ Examples:
   }
 });
 var httpTools = [httpFetchTool, httpJsonTool];
-var DEFAULT_TIMEOUT_MS3 = 6e5;
+var DEFAULT_TIMEOUT_MS4 = 6e5;
 var MAX_OUTPUT_SIZE2 = 2 * 1024 * 1024;
 function getBuildHint(stderr, tool) {
   if (/MODULE_NOT_FOUND|Cannot find module/i.test(stderr))
@@ -17300,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 {
     }
@@ -17337,7 +17974,7 @@ Examples:
   async execute({ script, cwd, packageManager, args, env: env2, timeout }) {
     const projectDir = cwd ?? process.cwd();
     const startTime = performance.now();
-    const timeoutMs = timeout ?? DEFAULT_TIMEOUT_MS3;
+    const timeoutMs = timeout ?? DEFAULT_TIMEOUT_MS4;
     const { CommandHeartbeat: CommandHeartbeat2 } = await Promise.resolve().then(() => (init_heartbeat(), heartbeat_exports));
     const heartbeat = new CommandHeartbeat2({
       onUpdate: (stats) => {
@@ -17433,7 +18070,7 @@ Examples:
   async execute({ cwd, packageManager, packages, dev, frozen, timeout }) {
     const projectDir = cwd ?? process.cwd();
     const startTime = performance.now();
-    const timeoutMs = timeout ?? DEFAULT_TIMEOUT_MS3;
+    const timeoutMs = timeout ?? DEFAULT_TIMEOUT_MS4;
     const { CommandHeartbeat: CommandHeartbeat2 } = await Promise.resolve().then(() => (init_heartbeat(), heartbeat_exports));
     const heartbeat = new CommandHeartbeat2({
       onUpdate: (stats) => {
@@ -17557,7 +18194,7 @@ Examples:
   async execute({ target, cwd, args, env: env2, timeout }) {
     const projectDir = cwd ?? process.cwd();
     const startTime = performance.now();
-    const timeoutMs = timeout ?? DEFAULT_TIMEOUT_MS3;
+    const timeoutMs = timeout ?? DEFAULT_TIMEOUT_MS4;
     const { CommandHeartbeat: CommandHeartbeat2 } = await Promise.resolve().then(() => (init_heartbeat(), heartbeat_exports));
     const heartbeat = new CommandHeartbeat2({
       onUpdate: (stats) => {
@@ -17573,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" });
       }
@@ -17660,7 +18297,7 @@ Examples:
   async execute({ cwd, project, noEmit, watch: watch2, args, timeout }) {
     const projectDir = cwd ?? process.cwd();
     const startTime = performance.now();
-    const timeoutMs = timeout ?? DEFAULT_TIMEOUT_MS3;
+    const timeoutMs = timeout ?? DEFAULT_TIMEOUT_MS4;
     const { CommandHeartbeat: CommandHeartbeat2 } = await Promise.resolve().then(() => (init_heartbeat(), heartbeat_exports));
     const heartbeat = new CommandHeartbeat2({
       onUpdate: (stats) => {
@@ -17778,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
@@ -18440,7 +19077,7 @@ Examples:
     }
   }
 });
-var DEFAULT_TIMEOUT_MS4 = 3e4;
+var DEFAULT_TIMEOUT_MS5 = 3e4;
 var DEFAULT_MAX_LENGTH = 5e4;
 var MAX_DOWNLOAD_SIZE = 10 * 1024 * 1024;
 var BLOCKED_SCHEMES = ["file:", "ftp:", "data:", "javascript:"];
@@ -18671,12 +19308,12 @@ Examples:
     url: z.string().url().describe("URL to fetch"),
     extractContent: z.boolean().optional().default(true).describe("Extract and clean main content (true) or return raw (false)"),
     maxLength: z.number().min(1e3).max(2e5).optional().default(DEFAULT_MAX_LENGTH).describe("Maximum content length in characters"),
-    timeout: z.number().min(1e3).max(12e4).optional().default(DEFAULT_TIMEOUT_MS4).describe("Timeout in milliseconds")
+    timeout: z.number().min(1e3).max(12e4).optional().default(DEFAULT_TIMEOUT_MS5).describe("Timeout in milliseconds")
   }),
   async execute({ url, extractContent, maxLength, timeout }) {
     const startTime = performance.now();
     const effectiveMaxLength = maxLength ?? DEFAULT_MAX_LENGTH;
-    const effectiveTimeout = timeout ?? DEFAULT_TIMEOUT_MS4;
+    const effectiveTimeout = timeout ?? DEFAULT_TIMEOUT_MS5;
     validateUrl(url);
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), effectiveTimeout);
@@ -18805,63 +19442,63 @@ var LANG_ALIASES = {
 };
 var TOKEN_COLORS = {
   // Keywords & control flow
-  keyword: (t) => chalk3.blue(t),
-  "keyword.control": (t) => chalk3.blue(t),
+  keyword: (t) => chalk4.blue(t),
+  "keyword.control": (t) => chalk4.blue(t),
   // Built-in types and literals
-  built_in: (t) => chalk3.cyan(t),
-  type: (t) => chalk3.cyan(t),
-  class: (t) => chalk3.cyan(t),
-  "title.class": (t) => chalk3.cyan(t),
-  "title.class.inherited": (t) => chalk3.cyan(t),
+  built_in: (t) => chalk4.cyan(t),
+  type: (t) => chalk4.cyan(t),
+  class: (t) => chalk4.cyan(t),
+  "title.class": (t) => chalk4.cyan(t),
+  "title.class.inherited": (t) => chalk4.cyan(t),
   // Functions
-  "title.function": (t) => chalk3.green(t),
-  "title.function.invoke": (t) => chalk3.green(t),
-  title: (t) => chalk3.green(t),
+  "title.function": (t) => chalk4.green(t),
+  "title.function.invoke": (t) => chalk4.green(t),
+  title: (t) => chalk4.green(t),
   // Strings
-  string: (t) => chalk3.yellow(t),
-  "template-tag": (t) => chalk3.yellow(t),
-  "template-variable": (t) => chalk3.green(t),
+  string: (t) => chalk4.yellow(t),
+  "template-tag": (t) => chalk4.yellow(t),
+  "template-variable": (t) => chalk4.green(t),
   // Numbers
-  number: (t) => chalk3.magenta(t),
+  number: (t) => chalk4.magenta(t),
   // Literals (true, false, null)
-  literal: (t) => chalk3.magenta(t),
+  literal: (t) => chalk4.magenta(t),
   // Comments
-  comment: (t) => chalk3.dim(t),
-  doctag: (t) => chalk3.dim.bold(t),
+  comment: (t) => chalk4.dim(t),
+  doctag: (t) => chalk4.dim.bold(t),
   // Regular expressions
-  regexp: (t) => chalk3.red(t),
+  regexp: (t) => chalk4.red(t),
   // Attributes & properties
-  attr: (t) => chalk3.cyan(t),
-  attribute: (t) => chalk3.cyan(t),
-  property: (t) => chalk3.white(t),
+  attr: (t) => chalk4.cyan(t),
+  attribute: (t) => chalk4.cyan(t),
+  property: (t) => chalk4.white(t),
   // Operators & punctuation
-  operator: (t) => chalk3.dim.white(t),
-  punctuation: (t) => chalk3.dim.white(t),
+  operator: (t) => chalk4.dim.white(t),
+  punctuation: (t) => chalk4.dim.white(t),
   // Meta / preprocessor
-  meta: (t) => chalk3.dim(t),
-  "meta keyword": (t) => chalk3.blue(t),
-  "meta string": (t) => chalk3.yellow(t),
+  meta: (t) => chalk4.dim(t),
+  "meta keyword": (t) => chalk4.blue(t),
+  "meta string": (t) => chalk4.yellow(t),
   // Variables & params
-  variable: (t) => chalk3.white(t),
-  "variable.language": (t) => chalk3.blue(t),
-  params: (t) => chalk3.white(t),
+  variable: (t) => chalk4.white(t),
+  "variable.language": (t) => chalk4.blue(t),
+  params: (t) => chalk4.white(t),
   // Tags (HTML/XML)
-  tag: (t) => chalk3.blue(t),
-  name: (t) => chalk3.blue(t),
+  tag: (t) => chalk4.blue(t),
+  name: (t) => chalk4.blue(t),
   // Symbols & selectors (CSS, Ruby)
-  symbol: (t) => chalk3.magenta(t),
-  selector: (t) => chalk3.green(t),
-  "selector-tag": (t) => chalk3.blue(t),
-  "selector-class": (t) => chalk3.green(t),
-  "selector-id": (t) => chalk3.cyan(t),
+  symbol: (t) => chalk4.magenta(t),
+  selector: (t) => chalk4.green(t),
+  "selector-tag": (t) => chalk4.blue(t),
+  "selector-class": (t) => chalk4.green(t),
+  "selector-id": (t) => chalk4.cyan(t),
   // Additions/deletions (diffs)
-  addition: (t) => chalk3.green(t),
-  deletion: (t) => chalk3.red(t),
+  addition: (t) => chalk4.green(t),
+  deletion: (t) => chalk4.red(t),
   // Section headers
-  section: (t) => chalk3.bold(t),
+  section: (t) => chalk4.bold(t),
   // Emphasis
-  emphasis: (t) => chalk3.italic(t),
-  strong: (t) => chalk3.bold(t)
+  emphasis: (t) => chalk4.italic(t),
+  strong: (t) => chalk4.bold(t)
 };
 function hljsToChalk(html) {
   const safeSpans = [];
@@ -18916,10 +19553,10 @@ function highlightLine(line, lang) {
 }
 
 // src/cli/repl/output/diff-renderer.ts
-var bgDeleteLine = chalk3.bgRgb(80, 20, 20);
-var bgAddLine = chalk3.bgRgb(20, 60, 20);
-var bgDeleteWord = chalk3.bgRgb(160, 40, 40);
-var bgAddWord = chalk3.bgRgb(40, 120, 40);
+var bgDeleteLine = chalk4.bgRgb(80, 20, 20);
+var bgAddLine = chalk4.bgRgb(20, 60, 20);
+var bgDeleteWord = chalk4.bgRgb(160, 40, 40);
+var bgAddWord = chalk4.bgRgb(40, 120, 40);
 function parseDiff(raw) {
   const files = [];
   const lines = raw.split("\n");
@@ -19116,7 +19753,7 @@ function renderDiff(diff, options) {
   const maxWidth = options?.maxWidth ?? Math.min(getTerminalWidth() - 2, 120);
   const compact = options?.compact ?? false;
   if (diff.files.length === 0) {
-    console.log(chalk3.dim("\n  No changes\n"));
+    console.log(chalk4.dim("\n  No changes\n"));
     return;
   }
   for (const file of diff.files) {
@@ -19125,9 +19762,9 @@ function renderDiff(diff, options) {
   const { stats } = diff;
   const parts = [];
   parts.push(`${stats.filesChanged} file${stats.filesChanged !== 1 ? "s" : ""}`);
-  if (stats.additions > 0) parts.push(chalk3.green(`+${stats.additions}`));
-  if (stats.deletions > 0) parts.push(chalk3.red(`-${stats.deletions}`));
-  console.log(chalk3.dim(`
+  if (stats.additions > 0) parts.push(chalk4.green(`+${stats.additions}`));
+  if (stats.deletions > 0) parts.push(chalk4.red(`-${stats.deletions}`));
+  console.log(chalk4.dim(`
   ${parts.join(", ")}
 `));
 }
@@ -19140,22 +19777,22 @@ function renderFileBlock(file, opts) {
   const title = ` ${file.path} (${typeLabel}${statsLabel}) `;
   const topFill = Math.max(0, maxWidth - 2 - stripAnsi(title).length);
   console.log(
-    chalk3.magenta("\u256D\u2500\u2500") + chalk3.cyan.bold(title) + chalk3.magenta("\u2500".repeat(topFill) + "\u256E")
+    chalk4.magenta("\u256D\u2500\u2500") + chalk4.cyan.bold(title) + chalk4.magenta("\u2500".repeat(topFill) + "\u256E")
   );
   for (let h = 0; h < file.hunks.length; h++) {
     const hunk = file.hunks[h];
     if (!compact || h > 0) {
-      const hunkLabel = hunk.heading ? ` ${chalk3.dim(hunk.heading)}` : "";
+      const hunkLabel = hunk.heading ? ` ${chalk4.dim(hunk.heading)}` : "";
       console.log(
-        chalk3.magenta("\u2502") + " " + chalk3.cyan(
+        chalk4.magenta("\u2502") + " " + chalk4.cyan(
           `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`
         ) + hunkLabel
       );
     }
     const pairs = pairAdjacentLines(hunk.lines);
-    const pairedDeleteIndices = new Set(pairs.map((p4) => p4.deleteIdx));
-    const pairedAddIndices = new Set(pairs.map((p4) => p4.addIdx));
-    const pairByAdd = new Map(pairs.map((p4) => [p4.addIdx, p4.deleteIdx]));
+    const pairedDeleteIndices = new Set(pairs.map((p5) => p5.deleteIdx));
+    const pairedAddIndices = new Set(pairs.map((p5) => p5.addIdx));
+    const pairByAdd = new Map(pairs.map((p5) => [p5.addIdx, p5.deleteIdx]));
     const wordHighlights = /* @__PURE__ */ new Map();
     for (const pair of pairs) {
       const delLine = hunk.lines[pair.deleteIdx];
@@ -19179,7 +19816,7 @@ function renderFileBlock(file, opts) {
         const plainLen = stripAnsi(innerText).length + 1;
         const pad = Math.max(0, contentWidth - plainLen);
         console.log(
-          chalk3.magenta("\u2502") + bgAddLine(` ${innerText}` + " ".repeat(pad + 2)) + chalk3.magenta("\u2502")
+          chalk4.magenta("\u2502") + bgAddLine(` ${innerText}` + " ".repeat(pad + 2)) + chalk4.magenta("\u2502")
         );
       } else if (line.type === "delete") {
         const isPaired = pairedDeleteIndices.has(li);
@@ -19193,7 +19830,7 @@ function renderFileBlock(file, opts) {
         const plainLen = stripAnsi(innerText).length + 1;
         const pad = Math.max(0, contentWidth - plainLen);
         console.log(
-          chalk3.magenta("\u2502") + bgDeleteLine(` ${innerText}` + " ".repeat(pad + 2)) + chalk3.magenta("\u2502")
+          chalk4.magenta("\u2502") + bgDeleteLine(` ${innerText}` + " ".repeat(pad + 2)) + chalk4.magenta("\u2502")
         );
       } else {
         let content = line.content;
@@ -19204,17 +19841,17 @@ function renderFileBlock(file, opts) {
         const plainLen = stripAnsi(lineStr).length;
         const pad = Math.max(0, contentWidth - plainLen);
         console.log(
-          chalk3.magenta("\u2502") + chalk3.dim(` ${lineStr}`) + " ".repeat(pad) + " " + chalk3.magenta("\u2502")
+          chalk4.magenta("\u2502") + chalk4.dim(` ${lineStr}`) + " ".repeat(pad) + " " + chalk4.magenta("\u2502")
         );
       }
     }
   }
-  console.log(chalk3.magenta("\u2570" + "\u2500".repeat(Math.max(0, maxWidth - 2)) + "\u256F"));
+  console.log(chalk4.magenta("\u2570" + "\u2500".repeat(Math.max(0, maxWidth - 2)) + "\u256F"));
 }
 function formatLineNo(line, show) {
   if (!show) return "";
   const lineNo = line.type === "delete" ? line.oldLineNo : line.newLineNo;
-  return chalk3.dim(`${String(lineNo ?? "").padStart(5)} `);
+  return chalk4.dim(`${String(lineNo ?? "").padStart(5)} `);
 }
 function getChangedLines(diff) {
   const result = /* @__PURE__ */ new Map();
@@ -19313,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;
@@ -19411,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"]) {
@@ -19580,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({
@@ -19811,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 = {
@@ -19838,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;
   }
@@ -20247,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"
@@ -20286,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;
@@ -20326,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 [];
@@ -20351,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;
@@ -20367,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",
@@ -20520,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 [];
@@ -20538,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');
@@ -20700,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;
@@ -20829,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",
@@ -20867,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) {
@@ -20884,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) {
@@ -20963,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}";
@@ -20977,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];
@@ -21096,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) {
@@ -21113,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(
@@ -21236,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);
@@ -21297,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) {
@@ -21333,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"
@@ -21366,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
       });
@@ -21413,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 = {
@@ -21442,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(", ")}`,
@@ -21458,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"
@@ -21479,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";
@@ -21516,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",
@@ -21597,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,
@@ -21628,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.",
@@ -21711,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 });
@@ -21770,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 = [];
@@ -21881,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
       });
@@ -22121,6 +22758,13 @@ var createAgentPlanTool = defineTool({
     };
   }
 });
+var LEGACY_ROLE_TO_TYPE = {
+  researcher: "explore",
+  coder: "debug",
+  reviewer: "review",
+  tester: "test",
+  optimizer: "refactor"
+};
 var delegateTaskTool = defineTool({
   name: "delegateTask",
   description: "Delegate a task to a specialized sub-agent with real LLM tool-use execution.",
@@ -22128,22 +22772,57 @@ var delegateTaskTool = defineTool({
   parameters: z.object({
     taskId: z.string(),
     task: z.string().describe("Description of the task for the agent to execute"),
-    agentRole: z.enum(["researcher", "coder", "reviewer", "tester", "optimizer"]).default("coder"),
+    agentType: z.enum([
+      "explore",
+      "plan",
+      "test",
+      "debug",
+      "review",
+      "architect",
+      "security",
+      "tdd",
+      "refactor",
+      "e2e",
+      "docs",
+      "database"
+    ]).optional().describe("Specialized agent type to use"),
+    agentRole: z.enum(["researcher", "coder", "reviewer", "tester", "optimizer"]).optional().describe("DEPRECATED: Use agentType instead"),
     context: z.string().optional(),
     maxTurns: z.number().default(10)
   }),
   async execute(input) {
     const typedInput = input;
-    {
+    const manager = getAgentManager();
+    if (!manager) {
+      const resolvedType = typedInput.agentType ?? "explore";
       return {
-        agentId: `agent-${Date.now()}-${typedInput.agentRole}`,
+        agentId: `agent-${Date.now()}-${resolvedType}`,
         taskId: typedInput.taskId,
-        role: typedInput.agentRole,
+        agentType: resolvedType,
         status: "unavailable",
         message: "Agent provider not initialized. Call setAgentProvider() during orchestrator startup.",
         success: false
       };
     }
+    const agentType = typedInput.agentType ?? (typedInput.agentRole ? LEGACY_ROLE_TO_TYPE[typedInput.agentRole] ?? "explore" : "explore");
+    const taskDescription = typedInput.context ? `${typedInput.task}
+
+Additional context: ${typedInput.context}` : typedInput.task;
+    const startTime = Date.now();
+    const result = await manager.spawn(agentType, taskDescription, {
+      timeout: typedInput.maxTurns * 6e4
+    });
+    const duration = Date.now() - startTime;
+    return {
+      agentId: result.agent.id,
+      taskId: typedInput.taskId,
+      agentType,
+      status: result.success ? "completed" : "failed",
+      output: result.output,
+      success: result.success,
+      usage: result.usage,
+      duration
+    };
   }
 });
 var aggregateResultsTool = defineTool({
@@ -22207,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++) {
@@ -22305,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",
@@ -22362,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;
@@ -22396,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();
@@ -22409,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 || {}));
@@ -22417,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);
@@ -22575,11 +23254,11 @@ var getLearnedPatternsTool = defineTool({
     const patterns = store.getFrequentPatterns(typedInput.limit);
     return {
       totalPatterns: patterns.length,
-      patterns: patterns.map((p4) => ({
-        pattern: p4.pattern,
-        preference: p4.userPreference,
-        frequency: p4.frequency,
-        lastUsed: new Date(p4.lastUsed).toISOString()
+      patterns: patterns.map((p5) => ({
+        pattern: p5.pattern,
+        preference: p5.userPreference,
+        frequency: p5.frequency,
+        lastUsed: new Date(p5.lastUsed).toISOString()
       }))
     };
   }
@@ -22590,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 [];
@@ -22602,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: []
@@ -22651,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,
@@ -23152,26 +23831,26 @@ 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;
     }
   }
   return void 0;
 }
 function isBlockedExecFile(filePath) {
-  return BLOCKED_EXEC_PATTERNS.some((p4) => p4.test(filePath));
+  return BLOCKED_EXEC_PATTERNS.some((p5) => p5.test(filePath));
 }
 function hasDangerousArgs(args) {
   const joined = args.join(" ");
-  return DANGEROUS_ARG_PATTERNS.some((p4) => p4.test(joined));
+  return DANGEROUS_ARG_PATTERNS.some((p5) => p5.test(joined));
 }
 function getInterpreter(ext) {
   return INTERPRETER_MAP[ext.toLowerCase()];
 }
 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;
@@ -23211,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`, {
@@ -23219,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" });
     }
@@ -23234,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;
@@ -23254,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" }
       );
     }
@@ -23306,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,
@@ -23315,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,
@@ -23325,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,
@@ -23333,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,
@@ -23349,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,