@corbat-tech/coco 1.0.2 → 1.1.0

package/dist/cli/index.js

@@ -2,9 +2,9 @@
 import * as os2 from 'os';
 import { homedir } from 'os';
 import * as path20 from 'path';
-import path20__default, { join, dirname } from 'path';
+import path20__default, { join, dirname, basename } from 'path';
 import * as fs19 from 'fs';
-import fs19__default, { readFileSync, constants } from 'fs';
+import fs19__default, { readFileSync, existsSync, constants } from 'fs';
 import * as fs22 from 'fs/promises';
 import fs22__default, { writeFile, access, readFile, mkdir, readdir, rm } from 'fs/promises';
 import { Command } from 'commander';
@@ -279,8 +279,8 @@ __export(trust_store_exports, {
   saveTrustStore: () => saveTrustStore,
   updateLastAccessed: () => updateLastAccessed
 });
-async function ensureDir(path35) {
-  await mkdir(dirname(path35), { recursive: true });
+async function ensureDir(path37) {
+  await mkdir(dirname(path37), { recursive: true });
 }
 async function loadTrustStore(storePath = TRUST_STORE_PATH) {
   try {
@@ -358,8 +358,8 @@ function canPerformOperation(store, projectPath, operation) {
   };
   return permissions[level]?.includes(operation) ?? false;
 }
-function normalizePath(path35) {
-  return join(path35);
+function normalizePath(path37) {
+  return join(path37);
 }
 function createTrustStore(storePath = TRUST_STORE_PATH) {
   let store = null;
@@ -609,8 +609,8 @@ Generated by Corbat-Coco v0.1.0
 
 // src/cli/commands/init.ts
 function registerInitCommand(program2) {
-  program2.command("init").description("Initialize a new Corbat-Coco project").argument("[path]", "Project directory path", ".").option("-t, --template <template>", "Project template to use").option("-y, --yes", "Skip prompts and use defaults").option("--skip-discovery", "Skip the discovery phase (use existing spec)").action(async (path35, options) => {
-    await runInit(path35, options);
+  program2.command("init").description("Initialize a new Corbat-Coco project").argument("[path]", "Project directory path", ".").option("-t, --template <template>", "Project template to use").option("-y, --yes", "Skip prompts and use defaults").option("--skip-discovery", "Skip the discovery phase (use existing spec)").action(async (path37, options) => {
+    await runInit(path37, options);
   });
 }
 async function runInit(projectPath, options) {
@@ -689,18 +689,18 @@ async function gatherProjectInfo() {
     language
   };
 }
-function getDefaultProjectInfo(path35) {
-  const name = path35 === "." ? "my-project" : path35.split("/").pop() || "my-project";
+function getDefaultProjectInfo(path37) {
+  const name = path37 === "." ? "my-project" : path37.split("/").pop() || "my-project";
   return {
     name,
     description: "",
     language: "typescript"
   };
 }
-async function checkExistingProject(path35) {
+async function checkExistingProject(path37) {
   try {
-    const fs38 = await import('fs/promises');
-    await fs38.access(`${path35}/.coco`);
+    const fs39 = await import('fs/promises');
+    await fs39.access(`${path37}/.coco`);
     return true;
   } catch {
     return false;
@@ -721,6 +721,12 @@ var QualityConfigSchema = z.object({
   minIterations: z.number().min(1).max(10).default(2),
   convergenceThreshold: z.number().min(0).max(10).default(2),
   securityThreshold: z.number().min(0).max(100).default(100)
+}).refine((data) => data.minIterations <= data.maxIterations, {
+  message: "minIterations must be <= maxIterations",
+  path: ["minIterations"]
+}).refine((data) => data.convergenceThreshold < data.minScore, {
+  message: "convergenceThreshold must be < minScore",
+  path: ["convergenceThreshold"]
 });
 var PersistenceConfigSchema = z.object({
   checkpointInterval: z.number().min(6e4).default(3e5),
@@ -976,6 +982,35 @@ var TimeoutError = class extends CocoError {
     this.operation = options.operation;
   }
 };
+var ERROR_SUGGESTIONS = {
+  PROVIDER_ERROR: "Check your API key and provider configuration. Run 'coco setup' to reconfigure.",
+  CONFIG_ERROR: "Check your .coco/config.json or run 'coco setup' to reconfigure.",
+  FILESYSTEM_ERROR: "Check that the path exists and you have read/write permissions.",
+  VALIDATION_ERROR: "Check the input data format. See 'coco --help' for usage.",
+  PHASE_ERROR: "Phase execution failed. Try 'coco resume' to continue from the last checkpoint.",
+  TASK_ERROR: "Task execution failed. The task can be retried from the last checkpoint with 'coco resume'.",
+  QUALITY_ERROR: "Quality score below threshold. Review the issues listed above and iterate on the code.",
+  RECOVERY_ERROR: "Checkpoint may be corrupted. Try 'coco init --force' to start fresh.",
+  TOOL_ERROR: "A tool execution failed. Check the error details above and retry.",
+  TIMEOUT_ERROR: "Operation timed out. Try increasing the timeout in config or simplifying the request.",
+  UNEXPECTED_ERROR: "An unexpected error occurred. Please report at github.com/corbat/corbat-coco/issues."
+};
+function formatError(error) {
+  if (error instanceof CocoError) {
+    let message = `[${error.code}] ${error.message}`;
+    const suggestion = error.suggestion ?? ERROR_SUGGESTIONS[error.code];
+    if (suggestion) {
+      message += `
+  Suggestion: ${suggestion}`;
+    }
+    return message;
+  }
+  if (error instanceof Error) {
+    return `${error.message}
+  Suggestion: ${ERROR_SUGGESTIONS["UNEXPECTED_ERROR"]}`;
+  }
+  return String(error);
+}
 
 // src/config/loader.ts
 init_paths();
@@ -7579,35 +7614,35 @@ async function createCliPhaseContext(projectPath, _onUserInput) {
     },
     tools: {
       file: {
-        async read(path35) {
-          const fs38 = await import('fs/promises');
-          return fs38.readFile(path35, "utf-8");
+        async read(path37) {
+          const fs39 = await import('fs/promises');
+          return fs39.readFile(path37, "utf-8");
         },
-        async write(path35, content) {
-          const fs38 = await import('fs/promises');
+        async write(path37, content) {
+          const fs39 = await import('fs/promises');
           const nodePath = await import('path');
-          await fs38.mkdir(nodePath.dirname(path35), { recursive: true });
-          await fs38.writeFile(path35, content, "utf-8");
+          await fs39.mkdir(nodePath.dirname(path37), { recursive: true });
+          await fs39.writeFile(path37, content, "utf-8");
         },
-        async exists(path35) {
-          const fs38 = await import('fs/promises');
+        async exists(path37) {
+          const fs39 = await import('fs/promises');
           try {
-            await fs38.access(path35);
+            await fs39.access(path37);
             return true;
           } catch {
             return false;
           }
         },
         async glob(pattern) {
-          const { glob: glob9 } = await import('glob');
-          return glob9(pattern, { cwd: projectPath });
+          const { glob: glob15 } = await import('glob');
+          return glob15(pattern, { cwd: projectPath });
         }
       },
       bash: {
         async exec(command, options = {}) {
-          const { execa: execa8 } = await import('execa');
+          const { execa: execa10 } = await import('execa');
           try {
-            const result = await execa8(command, {
+            const result = await execa10(command, {
               shell: true,
               cwd: options.cwd || projectPath,
               timeout: options.timeout,
@@ -7831,16 +7866,16 @@ async function loadTasks(_options) {
   ];
 }
 async function checkProjectState() {
-  const fs38 = await import('fs/promises');
+  const fs39 = await import('fs/promises');
   let hasProject = false;
   let hasPlan = false;
   try {
-    await fs38.access(".coco");
+    await fs39.access(".coco");
     hasProject = true;
   } catch {
   }
   try {
-    await fs38.access(".coco/planning/backlog.json");
+    await fs39.access(".coco/planning/backlog.json");
     hasPlan = true;
   } catch {
   }
@@ -7944,24 +7979,24 @@ function getPhaseStatusForPhase(phase) {
   return "in_progress";
 }
 async function loadProjectState(cwd, config) {
-  const fs38 = await import('fs/promises');
-  const path35 = await import('path');
-  const statePath = path35.join(cwd, ".coco", "state.json");
-  const backlogPath = path35.join(cwd, ".coco", "planning", "backlog.json");
-  const checkpointDir = path35.join(cwd, ".coco", "checkpoints");
+  const fs39 = await import('fs/promises');
+  const path37 = await import('path');
+  const statePath = path37.join(cwd, ".coco", "state.json");
+  const backlogPath = path37.join(cwd, ".coco", "planning", "backlog.json");
+  const checkpointDir = path37.join(cwd, ".coco", "checkpoints");
   let currentPhase = "idle";
   let metrics;
   let sprint;
   let checkpoints = [];
   try {
-    const stateContent = await fs38.readFile(statePath, "utf-8");
+    const stateContent = await fs39.readFile(statePath, "utf-8");
     const stateData = JSON.parse(stateContent);
     currentPhase = stateData.currentPhase || "idle";
     metrics = stateData.metrics;
   } catch {
   }
   try {
-    const backlogContent = await fs38.readFile(backlogPath, "utf-8");
+    const backlogContent = await fs39.readFile(backlogPath, "utf-8");
     const backlogData = JSON.parse(backlogContent);
     if (backlogData.currentSprint) {
       const tasks = backlogData.tasks || [];
@@ -7983,7 +8018,7 @@ async function loadProjectState(cwd, config) {
   } catch {
   }
   try {
-    const files = await fs38.readdir(checkpointDir);
+    const files = await fs39.readdir(checkpointDir);
     checkpoints = files.filter((f) => f.endsWith(".json")).sort().reverse();
   } catch {
   }
@@ -8119,8 +8154,8 @@ async function restoreFromCheckpoint(_checkpoint) {
 }
 async function checkProjectExists() {
   try {
-    const fs38 = await import('fs/promises');
-    await fs38.access(".coco");
+    const fs39 = await import('fs/promises');
+    await fs39.access(".coco");
     return true;
   } catch {
     return false;
@@ -8659,12 +8694,12 @@ async function loadConfig2() {
   };
 }
 async function saveConfig(config) {
-  const fs38 = await import('fs/promises');
-  await fs38.mkdir(".coco", { recursive: true });
-  await fs38.writeFile(".coco/config.json", JSON.stringify(config, null, 2));
+  const fs39 = await import('fs/promises');
+  await fs39.mkdir(".coco", { recursive: true });
+  await fs39.writeFile(".coco/config.json", JSON.stringify(config, null, 2));
 }
-function getNestedValue(obj, path35) {
-  const keys = path35.split(".");
+function getNestedValue(obj, path37) {
+  const keys = path37.split(".");
   let current = obj;
   for (const key of keys) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -8674,8 +8709,8 @@ function getNestedValue(obj, path35) {
   }
   return current;
 }
-function setNestedValue(obj, path35, value) {
-  const keys = path35.split(".");
+function setNestedValue(obj, path37, value) {
+  const keys = path37.split(".");
   let current = obj;
   for (let i = 0; i < keys.length - 1; i++) {
     const key = keys[i];
@@ -8896,8 +8931,8 @@ var MCPRegistryImpl = class {
   /**
    * Ensure directory exists
    */
-  async ensureDir(path35) {
-    await mkdir(dirname(path35), { recursive: true });
+  async ensureDir(path37) {
+    await mkdir(dirname(path37), { recursive: true });
   }
 };
 function createMCPRegistry(registryPath) {
@@ -9416,9 +9451,9 @@ function createEmptyMemoryContext() {
     errors: []
   };
 }
-function createMissingMemoryFile(path35, level) {
+function createMissingMemoryFile(path37, level) {
   return {
-    path: path35,
+    path: path37,
     level,
     content: "",
     sections: [],
@@ -9784,6 +9819,7 @@ var helpCommand = {
         commands: [
           { cmd: "/help, /?", desc: "Show this help message" },
           { cmd: "/help tools", desc: "Show available agent tools" },
+          { cmd: "/tutorial, /tut", desc: "Quick guide to using Coco" },
           { cmd: "/clear, /c", desc: "Clear conversation history" },
           { cmd: "/exit, /quit, /q", desc: "Exit the REPL" }
         ]
@@ -10329,11 +10365,11 @@ async function setupGcloudADC(provider) {
     console.log(chalk12.dim("   Opening browser for Google sign-in..."));
     console.log(chalk12.dim("   (Complete the sign-in in your browser, then return here)"));
     console.log();
-    const { exec: exec2 } = await import('child_process');
-    const { promisify: promisify3 } = await import('util');
-    const execAsync2 = promisify3(exec2);
+    const { exec: exec3 } = await import('child_process');
+    const { promisify: promisify4 } = await import('util');
+    const execAsync3 = promisify4(exec3);
     try {
-      await execAsync2("gcloud auth application-default login", {
+      await execAsync3("gcloud auth application-default login", {
         timeout: 12e4
         // 2 minute timeout
       });
@@ -11417,11 +11453,11 @@ async function setupGcloudADCForProvider(_provider) {
   if (p9.isCancel(runNow) || !runNow) {
     return false;
   }
-  const { exec: exec2 } = await import('child_process');
-  const { promisify: promisify3 } = await import('util');
-  const execAsync2 = promisify3(exec2);
+  const { exec: exec3 } = await import('child_process');
+  const { promisify: promisify4 } = await import('util');
+  const execAsync3 = promisify4(exec3);
   try {
-    await execAsync2("gcloud auth application-default login", { timeout: 12e4 });
+    await execAsync3("gcloud auth application-default login", { timeout: 12e4 });
     const token = await getADCAccessToken();
     if (token) {
       console.log(chalk12.green("\n   \u2713 Authentication successful!\n"));
@@ -12106,8 +12142,8 @@ async function listTrustedProjects2(trustStore) {
   p9.log.message("");
   for (const project of projects) {
     const level = project.approvalLevel.toUpperCase().padEnd(5);
-    const path35 = project.path.length > 50 ? "..." + project.path.slice(-47) : project.path;
-    p9.log.message(`  [${level}] ${path35}`);
+    const path37 = project.path.length > 50 ? "..." + project.path.slice(-47) : project.path;
+    p9.log.message(`  [${level}] ${path37}`);
     p9.log.message(`      Last accessed: ${new Date(project.lastAccessed).toLocaleString()}`);
   }
   p9.log.message("");
@@ -13277,7 +13313,7 @@ async function getCheckpoint(session, checkpointId) {
   return store.checkpoints.find((cp) => cp.id === checkpointId) ?? null;
 }
 async function restoreFiles(checkpoint, excludeFiles) {
-  const fs38 = await import('fs/promises');
+  const fs39 = await import('fs/promises');
   const restored = [];
   const failed = [];
   for (const fileCheckpoint of checkpoint.files) {
@@ -13285,7 +13321,7 @@ async function restoreFiles(checkpoint, excludeFiles) {
       continue;
     }
     try {
-      await fs38.writeFile(fileCheckpoint.filePath, fileCheckpoint.originalContent, "utf-8");
+      await fs39.writeFile(fileCheckpoint.filePath, fileCheckpoint.originalContent, "utf-8");
       restored.push(fileCheckpoint.filePath);
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
@@ -13367,8 +13403,8 @@ function displayRewindResult(result) {
     const fileName = filePath.split("/").pop() ?? filePath;
     console.log(`${chalk12.green(String.fromCodePoint(10003))} Restored: ${fileName}`);
   }
-  for (const { path: path35, error } of result.filesFailed) {
-    const fileName = path35.split("/").pop() ?? path35;
+  for (const { path: path37, error } of result.filesFailed) {
+    const fileName = path37.split("/").pop() ?? path37;
     console.log(`${chalk12.red(String.fromCodePoint(10007))} Failed: ${fileName} (${error})`);
   }
   if (result.conversationRestored) {
@@ -14773,8 +14809,8 @@ function formatToolSummary(toolName, input) {
       return String(input.path || ".");
     case "search_files": {
       const pattern = String(input.pattern || "");
-      const path35 = input.path ? ` in ${input.path}` : "";
-      return `"${pattern}"${path35}`;
+      const path37 = input.path ? ` in ${input.path}` : "";
+      return `"${pattern}"${path37}`;
     }
     case "bash_exec": {
       const cmd = String(input.command || "");
@@ -15985,6 +16021,56 @@ var imageCommand = {
     return false;
   }
 };
+var tutorialCommand = {
+  name: "tutorial",
+  aliases: ["tut", "learn"],
+  description: "Quick guide to using Coco",
+  usage: "/tutorial",
+  async execute() {
+    console.log(chalk12.cyan.bold("\n\u2550\u2550\u2550 Coco Quick Tutorial \u2550\u2550\u2550\n"));
+    const steps = [
+      {
+        step: "1",
+        title: "Ask Coco anything",
+        desc: 'Just type what you need: "Create a REST API with authentication"'
+      },
+      {
+        step: "2",
+        title: "Coco works autonomously",
+        desc: "Reads your project, writes code, runs tests, and iterates until quality passes"
+      },
+      {
+        step: "3",
+        title: "Enable quality mode",
+        desc: "Type /coco to enable auto-iteration: test \u2192 analyze \u2192 fix \u2192 repeat until score \u2265 85"
+      },
+      {
+        step: "4",
+        title: "Review changes",
+        desc: "Use /diff to see what changed, /status for project state"
+      },
+      {
+        step: "5",
+        title: "Save your work",
+        desc: "Use /commit to commit changes with a descriptive message"
+      }
+    ];
+    for (const { step, title, desc } of steps) {
+      console.log(`  ${chalk12.magenta.bold(step)}. ${chalk12.bold(title)}`);
+      console.log(`     ${chalk12.dim(desc)}`);
+      console.log();
+    }
+    console.log(chalk12.bold("Useful commands:"));
+    console.log(
+      `  ${chalk12.yellow("/coco")}       ${chalk12.dim("Toggle quality mode (auto-iteration)")}`
+    );
+    console.log(`  ${chalk12.yellow("/init")}       ${chalk12.dim("Initialize a new project")}`);
+    console.log(`  ${chalk12.yellow("/help")}       ${chalk12.dim("See all available commands")}`);
+    console.log(`  ${chalk12.yellow("/help tools")} ${chalk12.dim("See available agent tools")}`);
+    console.log();
+    return false;
+  }
+};
 
 // src/cli/repl/commands/index.ts
 var commands = [
@@ -16014,7 +16100,8 @@ var commands = [
   allowPathCommand,
   permissionsCommand,
   cocoCommand,
-  imageCommand
+  imageCommand,
+  tutorialCommand
 ];
 function isSlashCommand(input) {
   return input.startsWith("/");
@@ -16105,17 +16192,19 @@ function createInputHandler(_session) {
   let pasteBuffer = "";
   let isReadingClipboard = false;
   const getPrompt = () => {
+    const imageIndicator = hasPendingImage() ? chalk12.cyan(" \u{1F4CE} 1 image") : "";
+    const imageIndicatorLen = hasPendingImage() ? 10 : 0;
     if (isCocoMode()) {
       return {
-        str: "\u{1F965} " + chalk12.magenta("[coco]") + " \u203A ",
-        // 🥥=2 + space=1 + [coco]=6 + space=1 + ›=1 + space=1 = 12
-        visualLen: 12
+        str: "\u{1F965} " + chalk12.magenta("[coco]") + " \u203A " + imageIndicator,
+        // 🥥=2 + space=1 + [coco]=6 + space=1 + ›=1 + space=1 = 12 + image indicator
+        visualLen: 12 + imageIndicatorLen
       };
     }
     return {
-      str: chalk12.green("\u{1F965} \u203A "),
-      // 🥥=2 + space=1 + ›=1 + space=1 = 5
-      visualLen: 5
+      str: chalk12.green("\u{1F965} \u203A ") + imageIndicator,
+      // 🥥=2 + space=1 + ›=1 + space=1 = 5 + image indicator
+      visualLen: 5 + imageIndicatorLen
     };
   };
   const MAX_ROWS = 8;
@@ -16128,9 +16217,17 @@ function createInputHandler(_session) {
     return Math.max(1, Math.min(3, cols));
   }
   function render() {
-    process.stdout.write("\r" + ansiEscapes3.eraseDown);
+    const termCols = process.stdout.columns || 80;
     const prompt = getPrompt();
-    let output = prompt.str + currentLine;
+    const totalVisualLen = prompt.visualLen + currentLine.length;
+    const wrappedLines = Math.max(0, Math.ceil(totalVisualLen / termCols) - 1);
+    if (wrappedLines > 0) {
+      process.stdout.write(ansiEscapes3.cursorUp(wrappedLines));
+    }
+    process.stdout.write("\r" + ansiEscapes3.eraseDown);
+    const separator = chalk12.dim("\u2500".repeat(termCols));
+    let output = separator + "\n";
+    output += prompt.str + currentLine;
     completions = findCompletions(currentLine);
     selectedCompletion = Math.min(selectedCompletion, Math.max(0, completions.length - 1));
     if (cursorPos === currentLine.length && completions.length > 0 && completions[selectedCompletion]) {
@@ -16183,15 +16280,25 @@ function createInputHandler(_session) {
       for (let i = 0; i < BOTTOM_MARGIN; i++) {
         output += "\n";
       }
-      output += ansiEscapes3.cursorUp(lastMenuLines + BOTTOM_MARGIN);
+      output += ansiEscapes3.cursorUp(lastMenuLines + BOTTOM_MARGIN + 1);
     } else {
       lastMenuLines = 0;
       for (let i = 0; i < BOTTOM_MARGIN; i++) {
         output += "\n";
       }
-      output += ansiEscapes3.cursorUp(BOTTOM_MARGIN);
+      output += ansiEscapes3.cursorUp(BOTTOM_MARGIN + 1);
+    }
+    output += ansiEscapes3.cursorDown(1);
+    const cursorAbsolutePos = prompt.visualLen + cursorPos;
+    const finalLine = Math.floor(cursorAbsolutePos / termCols);
+    const finalCol = cursorAbsolutePos % termCols;
+    output += "\r";
+    if (finalLine > 0) {
+      output += ansiEscapes3.cursorDown(finalLine);
+    }
+    if (finalCol > 0) {
+      output += ansiEscapes3.cursorForward(finalCol);
     }
-    output += `\r${ansiEscapes3.cursorForward(prompt.visualLen + cursorPos)}`;
     process.stdout.write(output);
   }
   function clearMenu() {
@@ -16339,15 +16446,14 @@ function createInputHandler(_session) {
               process.stdout.write(
                 chalk12.green("  \u2713 Image captured") + chalk12.dim(` (${sizeKB} KB)`) + chalk12.dim(` \u2014 "${truncatedPrompt}"`)
               );
-              cleanup();
-              console.log();
-              const result = currentLine.trim();
-              if (result) {
-                sessionHistory.push(result);
-              }
-              resolve2(result || "");
-            }).catch(() => {
+              setTimeout(() => render(), 1200);
+            }).catch((err) => {
               isReadingClipboard = false;
+              const msg = err instanceof Error ? err.message : String(err);
+              if (msg.includes("color space")) {
+                render();
+                return;
+              }
               render();
             });
             return;
@@ -16357,7 +16463,9 @@ function createInputHandler(_session) {
               currentLine = completions[selectedCompletion].cmd;
             }
             cleanup();
+            const termWidth = process.stdout.columns || 80;
             console.log();
+            console.log(chalk12.dim("\u2500".repeat(termWidth)));
             const result = currentLine.trim();
             if (result) {
               sessionHistory.push(result);
@@ -18190,8 +18298,8 @@ function isPathAllowed(filePath, operation) {
     if (absolute.startsWith(normalizedHome) && !absolute.startsWith(normalizedCwd)) {
       if (isWithinAllowedPath(absolute, operation)) ; else if (operation === "read") {
         const allowedHomeReads = [".gitconfig", ".zshrc", ".bashrc"];
-        const basename2 = path20__default.basename(absolute);
-        if (!allowedHomeReads.includes(basename2)) {
+        const basename3 = path20__default.basename(absolute);
+        if (!allowedHomeReads.includes(basename3)) {
           const targetDir = path20__default.dirname(absolute);
           return {
             allowed: false,
@@ -18208,12 +18316,12 @@ function isPathAllowed(filePath, operation) {
     }
   }
   if (operation === "write" || operation === "delete") {
-    const basename2 = path20__default.basename(absolute);
+    const basename3 = path20__default.basename(absolute);
     for (const pattern of SENSITIVE_PATTERNS) {
-      if (pattern.test(basename2)) {
+      if (pattern.test(basename3)) {
         return {
           allowed: false,
-          reason: `Operation on sensitive file '${basename2}' requires explicit confirmation`
+          reason: `Operation on sensitive file '${basename3}' requires explicit confirmation`
         };
       }
     }
@@ -19471,59 +19579,322 @@ var simpleAutoCommitTool = defineTool({
   }
 });
 var gitSimpleTools = [checkProtectedBranchTool, simpleAutoCommitTool];
+
+// src/agents/provider-bridge.ts
+var agentProvider = null;
+var agentToolRegistry = null;
+function setAgentProvider(provider) {
+  agentProvider = provider;
+}
+function getAgentProvider() {
+  return agentProvider;
+}
+function setAgentToolRegistry(registry) {
+  agentToolRegistry = registry;
+}
+function getAgentToolRegistry() {
+  return agentToolRegistry;
+}
+
+// src/agents/executor.ts
+var AgentExecutor = class {
+  constructor(provider, toolRegistry) {
+    this.provider = provider;
+    this.toolRegistry = toolRegistry;
+  }
+  /**
+   * Execute an agent on a task with multi-turn tool use
+   */
+  async execute(agent, task) {
+    const startTime = Date.now();
+    const toolsUsed = /* @__PURE__ */ new Set();
+    const messages = [
+      {
+        role: "user",
+        content: this.buildTaskPrompt(task)
+      }
+    ];
+    const agentToolDefs = this.getToolDefinitionsForAgent(agent.allowedTools);
+    let turn = 0;
+    let totalTokens = 0;
+    while (turn < agent.maxTurns) {
+      turn++;
+      try {
+        const response = await this.provider.chatWithTools(messages, {
+          tools: agentToolDefs,
+          system: agent.systemPrompt
+        });
+        const usage = response.usage;
+        totalTokens += (usage?.inputTokens || 0) + (usage?.outputTokens || 0);
+        if (response.stopReason !== "tool_use" || response.toolCalls.length === 0) {
+          return {
+            output: response.content,
+            success: true,
+            turns: turn,
+            toolsUsed: Array.from(toolsUsed),
+            tokensUsed: totalTokens,
+            duration: Date.now() - startTime
+          };
+        }
+        const assistantContent = [];
+        if (response.content) {
+          assistantContent.push({
+            type: "text",
+            text: response.content
+          });
+        }
+        for (const toolCall of response.toolCalls) {
+          assistantContent.push({
+            type: "tool_use",
+            id: toolCall.id,
+            name: toolCall.name,
+            input: toolCall.input
+          });
+        }
+        messages.push({
+          role: "assistant",
+          content: assistantContent
+        });
+        const toolResults = [];
+        for (const toolCall of response.toolCalls) {
+          toolsUsed.add(toolCall.name);
+          try {
+            const result = await this.toolRegistry.execute(toolCall.name, toolCall.input);
+            toolResults.push({
+              type: "tool_result",
+              tool_use_id: toolCall.id,
+              content: result.success ? JSON.stringify(result.data) : `Error: ${result.error}`,
+              is_error: !result.success
+            });
+          } catch (error) {
+            toolResults.push({
+              type: "tool_result",
+              tool_use_id: toolCall.id,
+              content: `Tool execution error: ${error instanceof Error ? error.message : String(error)}`,
+              is_error: true
+            });
+          }
+        }
+        messages.push({
+          role: "user",
+          content: toolResults
+        });
+      } catch (error) {
+        return {
+          output: `Agent error on turn ${turn}: ${error instanceof Error ? error.message : String(error)}`,
+          success: false,
+          turns: turn,
+          toolsUsed: Array.from(toolsUsed),
+          tokensUsed: totalTokens,
+          duration: Date.now() - startTime
+        };
+      }
+    }
+    return {
+      output: "Agent reached maximum turns without completing task",
+      success: false,
+      turns: turn,
+      toolsUsed: Array.from(toolsUsed),
+      tokensUsed: totalTokens,
+      duration: Date.now() - startTime
+    };
+  }
+  /**
+   * Build task prompt with context
+   */
+  buildTaskPrompt(task) {
+    let prompt = `Task: ${task.description}
+`;
+    if (task.context && Object.keys(task.context).length > 0) {
+      prompt += `
+Context:
+${JSON.stringify(task.context, null, 2)}
+`;
+    }
+    prompt += `
+Complete this task autonomously using the available tools. When done, provide a summary of what you accomplished.`;
+    return prompt;
+  }
+  /**
+   * Get tool definitions filtered for this agent's allowed tools
+   */
+  getToolDefinitionsForAgent(allowedToolNames) {
+    const allDefs = this.toolRegistry.getToolDefinitionsForLLM();
+    if (allowedToolNames.length === 0) return allDefs;
+    return allDefs.filter((def) => allowedToolNames.includes(def.name));
+  }
+};
+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"]
+  }
+};
+
+// src/tools/simple-agent.ts
 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")
+  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"),
+  maxTurns: z.number().default(10).describe("Maximum tool-use turns for the agent")
 });
 var spawnSimpleAgentTool = defineTool({
   name: "spawnSimpleAgent",
-  description: `Spawn a sub-agent to handle a specific task.
+  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 and return results.
+The sub-agent will work on the task autonomously using available tools.
 
 Example: "Write unit tests for the authentication module"`,
   category: "build",
   parameters: SpawnSimpleAgentSchema,
   async execute(input) {
     const typedInput = input;
+    const provider = getAgentProvider();
+    const toolRegistry = getAgentToolRegistry();
+    if (!provider || !toolRegistry) {
+      const agentId2 = `agent-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+      return {
+        stdout: JSON.stringify({
+          agentId: agentId2,
+          status: "unavailable",
+          task: typedInput.task,
+          message: "Agent provider not initialized. Call setAgentProvider() during orchestrator startup.",
+          success: false
+        }),
+        stderr: "",
+        exitCode: 1,
+        duration: 0
+      };
+    }
     const agentId = `agent-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+    const executor = new AgentExecutor(provider, toolRegistry);
+    const roleDef = AGENT_ROLES[typedInput.role];
+    if (!roleDef) {
+      return {
+        stdout: JSON.stringify({
+          agentId,
+          status: "error",
+          message: `Unknown agent role: ${typedInput.role}`,
+          success: false
+        }),
+        stderr: "",
+        exitCode: 1,
+        duration: 0
+      };
+    }
+    const agentDef = { ...roleDef, maxTurns: typedInput.maxTurns };
+    const result = await executor.execute(agentDef, {
+      id: agentId,
+      description: typedInput.task,
+      context: typedInput.context ? { userContext: typedInput.context } : void 0
+    });
     return {
       stdout: JSON.stringify({
         agentId,
-        status: "simulated",
+        status: result.success ? "completed" : "failed",
         task: typedInput.task,
-        context: typedInput.context,
-        message: "Sub-agent system is available but requires provider integration to execute.",
-        note: "This tool demonstrates the multi-agent capability. Full implementation requires LLM provider integration in the agent loop."
+        output: result.output,
+        success: result.success,
+        turns: result.turns,
+        toolsUsed: result.toolsUsed,
+        tokensUsed: result.tokensUsed,
+        duration: result.duration
       }),
       stderr: "",
-      exitCode: 0,
-      duration: 0
+      exitCode: result.success ? 0 : 1,
+      duration: result.duration
     };
   }
 });
 var checkAgentCapabilityTool = defineTool({
   name: "checkAgentCapability",
-  description: "Check if multi-agent capability is available",
+  description: "Check if multi-agent capability is available and configured",
   category: "build",
   parameters: z.object({}),
   async execute() {
+    const provider = getAgentProvider();
+    const toolRegistry = getAgentToolRegistry();
+    const isReady = provider !== null && toolRegistry !== null;
     return {
       stdout: JSON.stringify({
         multiAgentSupported: true,
-        parallelExecution: "not yet implemented",
-        isolatedContexts: "not yet implemented",
+        providerConfigured: provider !== null,
+        toolRegistryConfigured: toolRegistry !== null,
+        ready: isReady,
+        availableRoles: Object.keys(AGENT_ROLES),
         features: {
-          taskDelegation: "available",
-          parallelSpawn: "requires integration",
-          contextForking: "requires integration"
+          taskDelegation: isReady ? "ready" : "requires provider initialization",
+          parallelSpawn: isReady ? "ready" : "requires provider initialization",
+          multiTurnToolUse: isReady ? "ready" : "requires provider initialization"
         },
-        status: "Multi-agent foundation exists. Full features require provider integration."
+        status: isReady ? "Multi-agent system is ready with real LLM tool-use execution." : "Provider not initialized. Call setAgentProvider() during startup."
       }),
       stderr: "",
       exitCode: 0,
@@ -19857,10 +20228,10 @@ var CoverageAnalyzer = class {
       join(this.projectPath, ".coverage", "coverage-summary.json"),
       join(this.projectPath, "coverage", "lcov-report", "coverage-summary.json")
     ];
-    for (const path35 of possiblePaths) {
+    for (const path37 of possiblePaths) {
       try {
-        await access(path35, constants.R_OK);
-        const content = await readFile(path35, "utf-8");
+        await access(path37, constants.R_OK);
+        const content = await readFile(path37, "utf-8");
         const report = JSON.parse(content);
         return parseCoverageSummary(report);
       } catch {
@@ -20514,147 +20885,1650 @@ var DuplicationAnalyzer = class {
     });
   }
 };
-
-// src/quality/types.ts
-var DEFAULT_QUALITY_WEIGHTS = {
-  correctness: 0.15,
-  completeness: 0.1,
-  robustness: 0.1,
-  readability: 0.1,
-  maintainability: 0.1,
-  complexity: 0.08,
-  duplication: 0.07,
-  testCoverage: 0.1,
-  testQuality: 0.05,
-  security: 0.08,
-  documentation: 0.04,
-  style: 0.03
-};
-var DEFAULT_QUALITY_THRESHOLDS = {
-  minimum: {
-    overall: 85,
-    testCoverage: 80,
-    security: 100
-    // No vulnerabilities allowed
-  },
-  target: {
-    overall: 95,
-    testCoverage: 90
-  }};
-var QualityEvaluator = class {
-  constructor(projectPath, useSnyk = false) {
+var execAsync2 = promisify(exec);
+var BuildVerifier = class {
+  projectPath;
+  constructor(projectPath) {
     this.projectPath = projectPath;
-    this.coverageAnalyzer = new CoverageAnalyzer(projectPath);
-    this.securityScanner = new CompositeSecurityScanner(projectPath, useSnyk);
-    this.complexityAnalyzer = new ComplexityAnalyzer(projectPath);
-    this.duplicationAnalyzer = new DuplicationAnalyzer(projectPath);
   }
-  coverageAnalyzer;
-  securityScanner;
-  complexityAnalyzer;
-  duplicationAnalyzer;
   /**
-   * Evaluate quality across all dimensions
-   * Returns QualityScores with 0% hardcoded values (5/12 dimensions are real)
+   * Verify that the project builds successfully
    */
-  async evaluate(files) {
-    const startTime = performance.now();
-    const targetFiles = files ?? await this.findSourceFiles();
-    const fileContents = await Promise.all(
-      targetFiles.map(async (file) => ({
-        path: file,
-        content: await readFile(file, "utf-8")
-      }))
-    );
-    const [coverageResult, securityResult, complexityResult, duplicationResult] = await Promise.all(
-      [
-        this.coverageAnalyzer.analyze().catch(() => null),
-        // Coverage may fail
-        this.securityScanner.scan(fileContents),
-        this.complexityAnalyzer.analyze(targetFiles),
-        this.duplicationAnalyzer.analyze(targetFiles)
-      ]
-    );
-    const dimensions = {
-      // REAL values (5/12):
-      testCoverage: coverageResult?.lines.percentage ?? 0,
-      security: securityResult.score,
-      complexity: complexityResult.score,
-      duplication: Math.max(0, 100 - duplicationResult.percentage),
-      style: 100,
-      // TODO: integrate linter
-      // Derived from real metrics (2/12):
-      readability: this.calculateReadability(complexityResult.averageComplexity),
-      maintainability: complexityResult.maintainabilityIndex,
-      // Still TODO - need test runner integration (5/12):
-      correctness: 85,
-      // TODO: run tests and check pass rate
-      completeness: 80,
-      // TODO: requirements tracking
-      robustness: 75,
-      // TODO: edge case analysis from tests
-      testQuality: 70,
-      // TODO: test quality analyzer
-      documentation: 60
-      // TODO: doc coverage analyzer
-    };
-    const overall = Object.entries(dimensions).reduce((sum, [key, value]) => {
-      const weight = DEFAULT_QUALITY_WEIGHTS[key] ?? 0;
-      return sum + value * weight;
-    }, 0);
-    const scores = {
-      overall: Math.round(overall),
-      dimensions,
-      evaluatedAt: /* @__PURE__ */ new Date(),
-      evaluationDurationMs: performance.now() - startTime
-    };
-    const issues = this.generateIssues(
-      securityResult.vulnerabilities,
-      complexityResult,
-      duplicationResult
-    );
-    const suggestions = this.generateSuggestions(dimensions);
-    const meetsMinimum = scores.overall >= DEFAULT_QUALITY_THRESHOLDS.minimum.overall && dimensions.testCoverage >= DEFAULT_QUALITY_THRESHOLDS.minimum.testCoverage && dimensions.security >= DEFAULT_QUALITY_THRESHOLDS.minimum.security;
-    const meetsTarget = scores.overall >= DEFAULT_QUALITY_THRESHOLDS.target.overall && dimensions.testCoverage >= DEFAULT_QUALITY_THRESHOLDS.target.testCoverage;
-    return {
-      scores,
-      meetsMinimum,
-      meetsTarget,
-      converged: false,
-      // Determined by iteration loop
-      issues,
-      suggestions
-    };
+  async verifyBuild() {
+    const startTime = Date.now();
+    try {
+      const buildCommand2 = await this.detectBuildCommand();
+      if (!buildCommand2) {
+        return {
+          success: true,
+          errors: [],
+          warnings: [],
+          duration: Date.now() - startTime,
+          stdout: "No build command detected",
+          stderr: ""
+        };
+      }
+      const { stdout, stderr } = await execAsync2(buildCommand2, {
+        cwd: this.projectPath,
+        timeout: 12e4,
+        // 2 minutes
+        maxBuffer: 10 * 1024 * 1024
+        // 10MB
+      });
+      const errors = this.parseErrors(stdout + stderr);
+      const warnings = this.parseWarnings(stdout + stderr);
+      return {
+        success: errors.length === 0,
+        errors,
+        warnings,
+        duration: Date.now() - startTime,
+        stdout,
+        stderr
+      };
+    } catch (error) {
+      const execError = error;
+      const errors = this.parseErrors(
+        (execError.stdout ?? "") + (execError.stderr ?? "") || (execError.message ?? "")
+      );
+      const warnings = this.parseWarnings(
+        (execError.stdout ?? "") + (execError.stderr ?? "") || ""
+      );
+      return {
+        success: false,
+        errors,
+        warnings,
+        duration: Date.now() - startTime,
+        stdout: execError.stdout || "",
+        stderr: execError.stderr || execError.message || ""
+      };
+    }
+  }
+  /**
+   * Run TypeScript type checking only (faster than full build)
+   */
+  async verifyTypes() {
+    const startTime = Date.now();
+    try {
+      const hasTsConfig = await this.fileExists(path20.join(this.projectPath, "tsconfig.json"));
+      if (!hasTsConfig) {
+        return {
+          success: true,
+          errors: [],
+          warnings: [],
+          duration: Date.now() - startTime,
+          stdout: "No tsconfig.json found",
+          stderr: ""
+        };
+      }
+      const { stdout, stderr } = await execAsync2("npx tsc --noEmit", {
+        cwd: this.projectPath,
+        timeout: 6e4,
+        // 1 minute
+        maxBuffer: 10 * 1024 * 1024
+      });
+      const errors = this.parseTypeScriptErrors(stdout + stderr);
+      const warnings = this.parseTypeScriptWarnings(stdout + stderr);
+      return {
+        success: errors.length === 0,
+        errors,
+        warnings,
+        duration: Date.now() - startTime,
+        stdout,
+        stderr
+      };
+    } catch (error) {
+      const execError = error;
+      const errors = this.parseTypeScriptErrors(
+        (execError.stdout ?? "") + (execError.stderr ?? "") || (execError.message ?? "")
+      );
+      const warnings = this.parseTypeScriptWarnings(
+        (execError.stdout ?? "") + (execError.stderr ?? "") || ""
+      );
+      return {
+        success: false,
+        errors,
+        warnings,
+        duration: Date.now() - startTime,
+        stdout: execError.stdout || "",
+        stderr: execError.stderr || execError.message || ""
+      };
+    }
   }
   /**
-   * Calculate readability from complexity
-   * Low complexity = high readability
+   * Detect build command from package.json
    */
-  calculateReadability(averageComplexity) {
-    if (averageComplexity <= 3) return 100;
-    return Math.max(0, 100 - (averageComplexity - 3) / 17 * 100);
+  async detectBuildCommand() {
+    try {
+      const packageJsonPath = path20.join(this.projectPath, "package.json");
+      const content = await fs22.readFile(packageJsonPath, "utf-8");
+      const packageJson = JSON.parse(content);
+      if (packageJson.scripts?.build) {
+        return "npm run build";
+      }
+      if (packageJson.devDependencies?.typescript || packageJson.dependencies?.typescript) {
+        return "npx tsc --noEmit";
+      }
+      return null;
+    } catch {
+      return null;
+    }
   }
   /**
-   * Generate quality issues from analyzer results
+   * Parse errors from build output
    */
-  generateIssues(securityVulns, complexityResult, duplicationResult) {
-    const issues = [];
-    for (const vuln of securityVulns) {
-      issues.push({
-        dimension: "security",
-        severity: vuln.severity === "critical" ? "critical" : vuln.severity === "high" ? "major" : "minor",
-        message: `${vuln.type}: ${vuln.description}`,
-        file: vuln.location.file,
-        line: vuln.location.line
+  parseErrors(output) {
+    const errors = [];
+    const tsErrorRegex = /(.+?)\((\d+),(\d+)\): error (TS\d+): (.+)/g;
+    let match;
+    while ((match = tsErrorRegex.exec(output)) !== null) {
+      errors.push({
+        file: match[1] || "",
+        line: parseInt(match[2] || "0", 10),
+        column: parseInt(match[3] || "0", 10),
+        code: match[4],
+        message: match[5] || ""
       });
     }
-    for (const file of complexityResult.files) {
-      for (const fn of file.functions) {
-        if (fn.complexity > 10) {
-          issues.push({
-            dimension: "complexity",
-            severity: "major",
-            message: `Function '${fn.name}' has high complexity (${fn.complexity})`,
+    const eslintErrorRegex = /(.+?):(\d+):(\d+): (.+)/g;
+    while ((match = eslintErrorRegex.exec(output)) !== null) {
+      if (!output.includes("error")) continue;
+      errors.push({
+        file: match[1] || "",
+        line: parseInt(match[2] || "0", 10),
+        column: parseInt(match[3] || "0", 10),
+        message: match[4] || ""
+      });
+    }
+    return errors;
+  }
+  /**
+   * Parse warnings from build output
+   */
+  parseWarnings(output) {
+    const warnings = [];
+    const tsWarningRegex = /(.+?)\((\d+),(\d+)\): warning (TS\d+): (.+)/g;
+    let match;
+    while ((match = tsWarningRegex.exec(output)) !== null) {
+      warnings.push({
+        file: match[1] || "",
+        line: parseInt(match[2] || "0", 10),
+        column: parseInt(match[3] || "0", 10),
+        code: match[4],
+        message: match[5] || ""
+      });
+    }
+    return warnings;
+  }
+  /**
+   * Parse TypeScript-specific errors
+   */
+  parseTypeScriptErrors(output) {
+    return this.parseErrors(output);
+  }
+  /**
+   * Parse TypeScript-specific warnings
+   */
+  parseTypeScriptWarnings(output) {
+    return this.parseWarnings(output);
+  }
+  /**
+   * Check if file exists
+   */
+  async fileExists(filePath) {
+    try {
+      await fs22.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/quality/analyzers/correctness.ts
+function parseVitestOutput(stdout) {
+  const testsMatch = stdout.match(
+    /Tests\s+(?:(\d+)\s+passed)?(?:\s*\|\s*(\d+)\s+failed)?(?:\s*\|\s*(\d+)\s+skipped)?/
+  );
+  if (testsMatch) {
+    return {
+      passed: parseInt(testsMatch[1] || "0", 10),
+      failed: parseInt(testsMatch[2] || "0", 10),
+      skipped: parseInt(testsMatch[3] || "0", 10)
+    };
+  }
+  try {
+    const json2 = JSON.parse(stdout);
+    return {
+      passed: json2.numPassedTests ?? 0,
+      failed: json2.numFailedTests ?? 0,
+      skipped: json2.numPendingTests ?? 0
+    };
+  } catch {
+  }
+  return { passed: 0, failed: 0, skipped: 0 };
+}
+function parseJestOutput(stdout) {
+  try {
+    const json2 = JSON.parse(stdout);
+    return {
+      passed: json2.numPassedTests ?? 0,
+      failed: json2.numFailedTests ?? 0,
+      skipped: json2.numPendingTests ?? 0
+    };
+  } catch {
+    const match = stdout.match(
+      /Tests:\s+(\d+)\s+passed(?:,\s*(\d+)\s+failed)?(?:,\s*(\d+)\s+skipped)?/
+    );
+    if (match) {
+      return {
+        passed: parseInt(match[1] || "0", 10),
+        failed: parseInt(match[2] || "0", 10),
+        skipped: parseInt(match[3] || "0", 10)
+      };
+    }
+  }
+  return { passed: 0, failed: 0, skipped: 0 };
+}
+function buildTestCommand(framework) {
+  switch (framework) {
+    case "vitest":
+      return { command: "npx", args: ["vitest", "run", "--reporter=verbose"] };
+    case "jest":
+      return { command: "npx", args: ["jest", "--json"] };
+    case "mocha":
+      return { command: "npx", args: ["mocha", "--reporter=json"] };
+    default:
+      return null;
+  }
+}
+var CorrectnessAnalyzer = class {
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    this.buildVerifier = new BuildVerifier(projectPath);
+  }
+  buildVerifier;
+  /**
+   * Analyze correctness by running tests and verifying build
+   */
+  async analyze() {
+    const [testResult, buildResult] = await Promise.all([
+      this.runTests(),
+      this.buildVerifier.verifyTypes().catch(() => ({ success: false, errors: [] }))
+    ]);
+    const total = testResult.passed + testResult.failed;
+    const testPassRate = total > 0 ? testResult.passed / total * 100 : 0;
+    const buildSuccess = buildResult.success;
+    let score;
+    if (total === 0 && !buildSuccess) {
+      score = 0;
+    } else if (total === 0) {
+      score = 30;
+    } else {
+      score = testPassRate / 100 * 70 + (buildSuccess ? 30 : 0);
+    }
+    score = Math.round(Math.max(0, Math.min(100, score)));
+    const details = this.buildDetails(testResult, buildSuccess, testPassRate, total);
+    return {
+      score,
+      testPassRate,
+      buildSuccess,
+      testsPassed: testResult.passed,
+      testsFailed: testResult.failed,
+      testsSkipped: testResult.skipped,
+      testsTotal: total,
+      buildErrors: buildResult.errors?.length ?? 0,
+      details
+    };
+  }
+  /**
+   * Run tests and parse results
+   */
+  async runTests() {
+    const framework = await detectTestFramework2(this.projectPath);
+    if (!framework) {
+      return { passed: 0, failed: 0, skipped: 0 };
+    }
+    const cmd = buildTestCommand(framework);
+    if (!cmd) {
+      return { passed: 0, failed: 0, skipped: 0 };
+    }
+    try {
+      const result = await execa(cmd.command, cmd.args, {
+        cwd: this.projectPath,
+        reject: false,
+        timeout: 3e5
+        // 5 minutes
+      });
+      const output = result.stdout + "\n" + result.stderr;
+      switch (framework) {
+        case "vitest":
+          return parseVitestOutput(output);
+        case "jest":
+          return parseJestOutput(result.stdout);
+        case "mocha": {
+          try {
+            const json2 = JSON.parse(result.stdout);
+            return {
+              passed: json2.stats?.passes ?? 0,
+              failed: json2.stats?.failures ?? 0,
+              skipped: json2.stats?.pending ?? 0
+            };
+          } catch {
+            return { passed: 0, failed: 0, skipped: 0 };
+          }
+        }
+        default:
+          return { passed: 0, failed: 0, skipped: 0 };
+      }
+    } catch {
+      return { passed: 0, failed: 0, skipped: 0 };
+    }
+  }
+  buildDetails(testResult, buildSuccess, testPassRate, total) {
+    const parts = [];
+    if (total > 0) {
+      parts.push(`Tests: ${testResult.passed}/${total} passed (${testPassRate.toFixed(1)}%)`);
+      if (testResult.failed > 0) {
+        parts.push(`${testResult.failed} failed`);
+      }
+    } else {
+      parts.push("No tests found");
+    }
+    parts.push(`Build: ${buildSuccess ? "success" : "failed"}`);
+    return parts.join(", ");
+  }
+};
+function countExports(ast) {
+  let exportCount = 0;
+  for (const node of ast.body) {
+    switch (node.type) {
+      case "ExportNamedDeclaration":
+        if (node.declaration) {
+          exportCount++;
+          if (node.declaration.type === "VariableDeclaration" && node.declaration.declarations.length > 1) {
+            exportCount += node.declaration.declarations.length - 1;
+          }
+        } else if (node.specifiers.length > 0) {
+          exportCount += node.specifiers.length;
+        }
+        break;
+      case "ExportDefaultDeclaration":
+        exportCount++;
+        break;
+      case "ExportAllDeclaration":
+        exportCount++;
+        break;
+    }
+  }
+  return exportCount;
+}
+var CompletenessAnalyzer = class {
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+  /**
+   * Analyze project completeness
+   */
+  async analyze(files) {
+    const sourceFiles = files ?? await this.findSourceFiles();
+    const testFiles = await this.findTestFiles();
+    const { totalExports, exportDensity } = await this.analyzeExports(sourceFiles);
+    const testFileRatio = this.calculateTestFileRatio(sourceFiles, testFiles);
+    const hasEntryPoint = await this.checkEntryPoint();
+    const exportScore = Math.min(40, exportDensity * 0.4);
+    const testScore = Math.min(40, testFileRatio * 0.4);
+    const entryScore = hasEntryPoint ? 20 : 0;
+    const score = Math.round(Math.max(0, Math.min(100, exportScore + testScore + entryScore)));
+    const details = this.buildDetails(
+      sourceFiles.length,
+      testFiles.length,
+      totalExports,
+      exportDensity,
+      testFileRatio,
+      hasEntryPoint
+    );
+    return {
+      score,
+      exportDensity,
+      testFileRatio,
+      hasEntryPoint,
+      sourceFileCount: sourceFiles.length,
+      testFileCount: testFiles.length,
+      totalExports,
+      details
+    };
+  }
+  /**
+   * Analyze export density across files
+   */
+  async analyzeExports(files) {
+    let totalExports = 0;
+    let filesWithExports = 0;
+    for (const file of files) {
+      try {
+        const content = await readFile(file, "utf-8");
+        const ast = parse(content, {
+          loc: true,
+          range: true,
+          jsx: file.endsWith(".tsx") || file.endsWith(".jsx")
+        });
+        const exports$1 = countExports(ast);
+        totalExports += exports$1;
+        if (exports$1 > 0) filesWithExports++;
+      } catch {
+      }
+    }
+    const exportDensity = files.length > 0 ? filesWithExports / files.length * 100 : 0;
+    return { totalExports, exportDensity };
+  }
+  /**
+   * Calculate ratio of source files that have corresponding test files
+   */
+  calculateTestFileRatio(sourceFiles, testFiles) {
+    if (sourceFiles.length === 0) return 0;
+    const testBaseNames = new Set(
+      testFiles.map((f) => {
+        const name = basename(f);
+        return name.replace(/\.(test|spec)\.(ts|tsx|js|jsx)$/, "");
+      })
+    );
+    let coveredCount = 0;
+    for (const sourceFile of sourceFiles) {
+      const name = basename(sourceFile).replace(/\.(ts|tsx|js|jsx)$/, "");
+      if (testBaseNames.has(name)) {
+        coveredCount++;
+      }
+    }
+    return coveredCount / sourceFiles.length * 100;
+  }
+  /**
+   * Check if project has a clear entry point
+   */
+  async checkEntryPoint() {
+    const entryPoints = [
+      "src/index.ts",
+      "src/index.js",
+      "src/main.ts",
+      "src/main.js",
+      "index.ts",
+      "index.js"
+    ];
+    for (const entry of entryPoints) {
+      try {
+        await access(join(this.projectPath, entry), constants.R_OK);
+        return true;
+      } catch {
+      }
+    }
+    try {
+      const pkgContent = await readFile(join(this.projectPath, "package.json"), "utf-8");
+      const pkg = JSON.parse(pkgContent);
+      if (pkg.main || pkg.exports) return true;
+    } catch {
+    }
+    return false;
+  }
+  buildDetails(sourceCount, testCount, totalExports, exportDensity, testFileRatio, hasEntryPoint) {
+    return [
+      `${sourceCount} source files, ${testCount} test files`,
+      `${totalExports} exports (${exportDensity.toFixed(1)}% files have exports)`,
+      `${testFileRatio.toFixed(1)}% source files have tests`,
+      `Entry point: ${hasEntryPoint ? "found" : "missing"}`
+    ].join(", ");
+  }
+  async findSourceFiles() {
+    return glob("**/*.{ts,js,tsx,jsx}", {
+      cwd: this.projectPath,
+      absolute: true,
+      ignore: ["**/node_modules/**", "**/*.test.*", "**/*.spec.*", "**/dist/**", "**/build/**"]
+    });
+  }
+  async findTestFiles() {
+    return glob("**/*.{test,spec}.{ts,tsx,js,jsx}", {
+      cwd: this.projectPath,
+      absolute: true,
+      ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"]
+    });
+  }
+};
+function analyzeRobustnessPatterns(ast) {
+  let functions = 0;
+  let functionsWithTryCatch = 0;
+  let optionalChaining = 0;
+  let nullishCoalescing = 0;
+  let typeGuards = 0;
+  let typeofChecks = 0;
+  let nullChecks = 0;
+  let insideFunction = false;
+  let currentFunctionHasTryCatch = false;
+  function traverse(node) {
+    const isFunctionNode = node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "MethodDefinition";
+    if (isFunctionNode) {
+      if (insideFunction && currentFunctionHasTryCatch) {
+        functionsWithTryCatch++;
+      }
+      functions++;
+      const previousInsideFunction = insideFunction;
+      const previousHasTryCatch = currentFunctionHasTryCatch;
+      insideFunction = true;
+      currentFunctionHasTryCatch = false;
+      traverseChildren(node);
+      if (currentFunctionHasTryCatch) {
+        functionsWithTryCatch++;
+      }
+      if (isFunctionNode) {
+        functions--;
+        functions++;
+      }
+      insideFunction = previousInsideFunction;
+      currentFunctionHasTryCatch = previousHasTryCatch;
+      return;
+    }
+    switch (node.type) {
+      case "TryStatement":
+        if (insideFunction) {
+          currentFunctionHasTryCatch = true;
+        }
+        break;
+      case "ChainExpression":
+        optionalChaining++;
+        break;
+      case "MemberExpression":
+        if (node.optional) {
+          optionalChaining++;
+        }
+        break;
+      case "CallExpression":
+        if (node.optional) {
+          optionalChaining++;
+        }
+        break;
+      case "LogicalExpression":
+        if (node.operator === "??") {
+          nullishCoalescing++;
+        }
+        break;
+      case "TSTypeAliasDeclaration":
+        typeGuards++;
+        break;
+      case "UnaryExpression":
+        if (node.operator === "typeof") {
+          typeofChecks++;
+        }
+        break;
+      case "BinaryExpression":
+        if (node.operator === "===" || node.operator === "!==" || node.operator === "==" || node.operator === "!=") {
+          if (isNullOrUndefined(node.left) || isNullOrUndefined(node.right)) {
+            nullChecks++;
+          }
+        }
+        break;
+    }
+    traverseChildren(node);
+  }
+  function traverseChildren(node) {
+    for (const key of Object.keys(node)) {
+      if (key === "parent") continue;
+      const child = node[key];
+      if (child && typeof child === "object") {
+        if (Array.isArray(child)) {
+          for (const item of child) {
+            if (item && typeof item === "object" && item.type) {
+              traverse(item);
+            }
+          }
+        } else if (child.type) {
+          traverse(child);
+        }
+      }
+    }
+  }
+  traverse(ast);
+  return {
+    functions,
+    functionsWithTryCatch,
+    optionalChaining,
+    nullishCoalescing,
+    typeGuards,
+    typeofChecks,
+    nullChecks
+  };
+}
+function isNullOrUndefined(node) {
+  if (node.type === "Literal" && node.value === null) return true;
+  if (node.type === "Identifier" && node.name === "undefined") return true;
+  return false;
+}
+var RobustnessAnalyzer = class {
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+  /**
+   * Analyze robustness of project files
+   */
+  async analyze(files) {
+    const targetFiles = files ?? await this.findSourceFiles();
+    let totalFunctions = 0;
+    let totalFunctionsWithTryCatch = 0;
+    let totalOptionalChaining = 0;
+    let totalNullishCoalescing = 0;
+    let totalTypeGuards = 0;
+    let totalTypeofChecks = 0;
+    let totalNullChecks = 0;
+    for (const file of targetFiles) {
+      try {
+        const content = await readFile(file, "utf-8");
+        const ast = parse(content, {
+          loc: true,
+          range: true,
+          jsx: file.endsWith(".tsx") || file.endsWith(".jsx")
+        });
+        const result = analyzeRobustnessPatterns(ast);
+        totalFunctions += result.functions;
+        totalFunctionsWithTryCatch += result.functionsWithTryCatch;
+        totalOptionalChaining += result.optionalChaining;
+        totalNullishCoalescing += result.nullishCoalescing;
+        totalTypeGuards += result.typeGuards;
+        totalTypeofChecks += result.typeofChecks;
+        totalNullChecks += result.nullChecks;
+      } catch {
+      }
+    }
+    const tryCatchRatio = totalFunctions > 0 ? totalFunctionsWithTryCatch / totalFunctions * 100 : 0;
+    const validationPerFunction = totalFunctions > 0 ? (totalTypeGuards + totalTypeofChecks + totalNullChecks) / totalFunctions : 0;
+    const inputValidationScore = Math.min(100, validationPerFunction * 50);
+    const defensivePerFunction = totalFunctions > 0 ? (totalOptionalChaining + totalNullishCoalescing) / totalFunctions : 0;
+    const defensiveCodingScore = Math.min(100, defensivePerFunction * 40);
+    const score = Math.round(
+      Math.max(
+        0,
+        Math.min(
+          100,
+          tryCatchRatio * 0.4 + inputValidationScore * 0.3 + defensiveCodingScore * 0.3
+        )
+      )
+    );
+    const details = [
+      `${totalFunctionsWithTryCatch}/${totalFunctions} functions with error handling`,
+      `${totalOptionalChaining} optional chaining, ${totalNullishCoalescing} nullish coalescing`,
+      `${totalTypeGuards + totalTypeofChecks + totalNullChecks} validation checks`
+    ].join(", ");
+    return {
+      score,
+      tryCatchRatio,
+      inputValidationScore,
+      defensiveCodingScore,
+      functionsAnalyzed: totalFunctions,
+      functionsWithErrorHandling: totalFunctionsWithTryCatch,
+      optionalChainingCount: totalOptionalChaining,
+      nullishCoalescingCount: totalNullishCoalescing,
+      typeGuardCount: totalTypeGuards,
+      details
+    };
+  }
+  async findSourceFiles() {
+    return glob("**/*.{ts,js,tsx,jsx}", {
+      cwd: this.projectPath,
+      absolute: true,
+      ignore: ["**/node_modules/**", "**/*.test.*", "**/*.spec.*", "**/dist/**", "**/build/**"]
+    });
+  }
+};
+var TRIVIAL_PATTERNS = [
+  /\.toBeDefined\(\)/,
+  /\.toBeUndefined\(\)/,
+  /\.toBeTruthy\(\)/,
+  /\.toBeFalsy\(\)/,
+  /\.toBe\(true\)/,
+  /\.toBe\(false\)/,
+  /\.not\.toBeNull\(\)/,
+  /\.toBeInstanceOf\(/,
+  /\.toBeTypeOf\(/
+];
+var EDGE_CASE_PATTERNS = [
+  /error/i,
+  /edge/i,
+  /boundary/i,
+  /invalid/i,
+  /empty/i,
+  /null/i,
+  /undefined/i,
+  /negative/i,
+  /overflow/i,
+  /timeout/i,
+  /fail/i,
+  /reject/i,
+  /throw/i,
+  /missing/i,
+  /malformed/i,
+  /corrupt/i
+];
+var MATCHER_PATTERNS = [
+  /\.toBe\(/,
+  /\.toEqual\(/,
+  /\.toStrictEqual\(/,
+  /\.toContain\(/,
+  /\.toMatch\(/,
+  /\.toHaveLength\(/,
+  /\.toHaveProperty\(/,
+  /\.toThrow/,
+  /\.toHaveBeenCalled/,
+  /\.toHaveBeenCalledWith\(/,
+  /\.toHaveBeenCalledTimes\(/,
+  /\.toBeGreaterThan\(/,
+  /\.toBeLessThan\(/,
+  /\.toBeCloseTo\(/,
+  /\.resolves\./,
+  /\.rejects\./
+];
+function analyzeTestFile(content) {
+  const lines = content.split("\n");
+  let totalAssertions = 0;
+  let trivialAssertions = 0;
+  let totalTests = 0;
+  let edgeCaseTests = 0;
+  const matchersUsed = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^\s*(it|test)\s*\(/.test(trimmed) || /^\s*(it|test)\s*\./.test(trimmed)) {
+      totalTests++;
+      for (const pattern of EDGE_CASE_PATTERNS) {
+        if (pattern.test(trimmed)) {
+          edgeCaseTests++;
+          break;
+        }
+      }
+    }
+    if (/expect\s*\(/.test(trimmed)) {
+      totalAssertions++;
+      for (const pattern of TRIVIAL_PATTERNS) {
+        if (pattern.test(trimmed)) {
+          trivialAssertions++;
+          break;
+        }
+      }
+      for (let i = 0; i < MATCHER_PATTERNS.length; i++) {
+        if (MATCHER_PATTERNS[i].test(trimmed)) {
+          matchersUsed.add(i);
+        }
+      }
+    }
+  }
+  return { totalAssertions, trivialAssertions, totalTests, edgeCaseTests, matchersUsed };
+}
+var TestQualityAnalyzer = class {
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+  /**
+   * Analyze test quality across the project
+   */
+  async analyze(files) {
+    const testFiles = files ?? await this.findTestFiles();
+    let totalAssertions = 0;
+    let trivialAssertions = 0;
+    let totalTests = 0;
+    let edgeCaseTests = 0;
+    const allMatchersUsed = /* @__PURE__ */ new Set();
+    for (const file of testFiles) {
+      try {
+        const content = await readFile(file, "utf-8");
+        const result = analyzeTestFile(content);
+        totalAssertions += result.totalAssertions;
+        trivialAssertions += result.trivialAssertions;
+        totalTests += result.totalTests;
+        edgeCaseTests += result.edgeCaseTests;
+        for (const m of result.matchersUsed) {
+          allMatchersUsed.add(m);
+        }
+      } catch {
+      }
+    }
+    const assertionDensity = totalTests > 0 ? totalAssertions / totalTests : 0;
+    const trivialAssertionRatio = totalAssertions > 0 ? trivialAssertions / totalAssertions * 100 : 0;
+    const edgeCaseRatio = totalTests > 0 ? edgeCaseTests / totalTests * 100 : 0;
+    const assertionDiversity = allMatchersUsed.size / MATCHER_PATTERNS.length * 100;
+    let score = 100;
+    score -= Math.min(40, trivialAssertionRatio * 0.4);
+    if (assertionDensity < 2) {
+      score -= (2 - assertionDensity) * 10;
+    }
+    if (edgeCaseRatio > 10) {
+      score += Math.min(10, (edgeCaseRatio - 10) * 0.5);
+    }
+    if (assertionDiversity > 30) {
+      score += Math.min(10, (assertionDiversity - 30) * 0.15);
+    }
+    if (totalTests === 0) {
+      score = 0;
+    }
+    score = Math.round(Math.max(0, Math.min(100, score)));
+    const details = [
+      `${totalTests} tests, ${totalAssertions} assertions`,
+      `${assertionDensity.toFixed(1)} assertions/test`,
+      `${trivialAssertionRatio.toFixed(1)}% trivial`,
+      `${edgeCaseRatio.toFixed(1)}% edge cases`,
+      `${allMatchersUsed.size}/${MATCHER_PATTERNS.length} matcher types`
+    ].join(", ");
+    return {
+      score,
+      assertionDensity,
+      trivialAssertionRatio,
+      edgeCaseRatio,
+      assertionDiversity,
+      totalTestFiles: testFiles.length,
+      totalAssertions,
+      trivialAssertions,
+      edgeCaseTests,
+      totalTests,
+      details
+    };
+  }
+  async findTestFiles() {
+    return glob("**/*.{test,spec}.{ts,tsx,js,jsx}", {
+      cwd: this.projectPath,
+      absolute: true,
+      ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"]
+    });
+  }
+};
+function hasJSDocComment(node, sourceCode) {
+  const startLine = node.loc.start.line;
+  const lines = sourceCode.split("\n");
+  for (let i = startLine - 2; i >= Math.max(0, startLine - 10); i--) {
+    const line = lines[i]?.trim() ?? "";
+    if (line.endsWith("*/")) {
+      for (let j = i; j >= Math.max(0, i - 20); j--) {
+        const commentLine = lines[j]?.trim() ?? "";
+        if (commentLine.startsWith("/**")) return true;
+        if (commentLine.startsWith("/*") && !commentLine.startsWith("/**")) return false;
+      }
+    }
+    if (line && !line.startsWith("*") && !line.startsWith("//") && !line.startsWith("/*")) {
+      break;
+    }
+  }
+  return false;
+}
+function analyzeExportDocumentation(ast, sourceCode) {
+  let exported = 0;
+  let documented = 0;
+  for (const node of ast.body) {
+    if (node.type === "ExportNamedDeclaration" && node.declaration) {
+      const decl = node.declaration;
+      switch (decl.type) {
+        case "FunctionDeclaration":
+          exported++;
+          if (hasJSDocComment(node, sourceCode)) documented++;
+          break;
+        case "ClassDeclaration":
+          exported++;
+          if (hasJSDocComment(node, sourceCode)) documented++;
+          break;
+        case "TSInterfaceDeclaration":
+        case "TSTypeAliasDeclaration":
+        case "TSEnumDeclaration":
+          exported++;
+          if (hasJSDocComment(node, sourceCode)) documented++;
+          break;
+        case "VariableDeclaration":
+          for (const _declarator of decl.declarations) {
+            exported++;
+            if (hasJSDocComment(node, sourceCode)) documented++;
+          }
+          break;
+      }
+    } else if (node.type === "ExportDefaultDeclaration") {
+      exported++;
+      if (hasJSDocComment(node, sourceCode)) documented++;
+    }
+  }
+  return { exported, documented };
+}
+var DocumentationAnalyzer = class {
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+  /**
+   * Analyze documentation quality
+   */
+  async analyze(files) {
+    const targetFiles = files ?? await this.findSourceFiles();
+    let totalExported = 0;
+    let totalDocumented = 0;
+    for (const file of targetFiles) {
+      try {
+        const content = await readFile(file, "utf-8");
+        const ast = parse(content, {
+          loc: true,
+          range: true,
+          comment: true,
+          jsx: file.endsWith(".tsx") || file.endsWith(".jsx")
+        });
+        const result = analyzeExportDocumentation(ast, content);
+        totalExported += result.exported;
+        totalDocumented += result.documented;
+      } catch {
+      }
+    }
+    const jsdocCoverage = totalExported > 0 ? totalDocumented / totalExported * 100 : 0;
+    const hasReadme = await this.fileExists("README.md");
+    const hasChangelog = await this.fileExists("CHANGELOG.md") || await this.fileExists("CHANGES.md");
+    const score = Math.round(
+      Math.max(
+        0,
+        Math.min(100, jsdocCoverage * 0.7 + (hasReadme ? 20 : 0) + (hasChangelog ? 10 : 0))
+      )
+    );
+    const details = [
+      `${totalDocumented}/${totalExported} exports documented (${jsdocCoverage.toFixed(1)}%)`,
+      `README: ${hasReadme ? "yes" : "no"}`,
+      `CHANGELOG: ${hasChangelog ? "yes" : "no"}`
+    ].join(", ");
+    return {
+      score,
+      jsdocCoverage,
+      hasReadme,
+      hasChangelog,
+      exportedDeclarations: totalExported,
+      documentedDeclarations: totalDocumented,
+      details
+    };
+  }
+  async fileExists(relativePath) {
+    try {
+      await access(join(this.projectPath, relativePath), constants.R_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async findSourceFiles() {
+    return glob("**/*.{ts,js,tsx,jsx}", {
+      cwd: this.projectPath,
+      absolute: true,
+      ignore: ["**/node_modules/**", "**/*.test.*", "**/*.spec.*", "**/dist/**", "**/build/**"]
+    });
+  }
+};
+async function detectLinter(projectPath) {
+  try {
+    const pkgContent = await readFile(join(projectPath, "package.json"), "utf-8");
+    const pkg = JSON.parse(pkgContent);
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (deps.oxlint) return "oxlint";
+    if (deps["@biomejs/biome"] || deps.biome) return "biome";
+    if (deps.eslint) return "eslint";
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function runOxlint(projectPath) {
+  try {
+    const result = await execa("npx", ["oxlint", "src", "--format=json"], {
+      cwd: projectPath,
+      reject: false,
+      timeout: 6e4
+    });
+    try {
+      const output = JSON.parse(result.stdout);
+      const errors = Array.isArray(output) ? output.filter((d) => {
+        const diag = d;
+        return diag.severity === 2 || diag.severity === "error";
+      }).length : 0;
+      const warnings = Array.isArray(output) ? output.filter((d) => {
+        const diag = d;
+        return diag.severity === 1 || diag.severity === "warning";
+      }).length : 0;
+      return { errors, warnings };
+    } catch {
+      const lines = (result.stdout + result.stderr).split("\n");
+      let errors = 0;
+      let warnings = 0;
+      for (const line of lines) {
+        if (/error\[/.test(line) || /✖.*error/.test(line)) errors++;
+        if (/warning\[/.test(line) || /⚠.*warning/.test(line)) warnings++;
+      }
+      return { errors, warnings };
+    }
+  } catch {
+    return { errors: 0, warnings: 0 };
+  }
+}
+async function runEslint(projectPath) {
+  try {
+    const result = await execa("npx", ["eslint", "src", "--format=json"], {
+      cwd: projectPath,
+      reject: false,
+      timeout: 12e4
+    });
+    try {
+      const output = JSON.parse(result.stdout);
+      const errors = output.reduce((sum, f) => sum + f.errorCount, 0);
+      const warnings = output.reduce((sum, f) => sum + f.warningCount, 0);
+      return { errors, warnings };
+    } catch {
+      return { errors: 0, warnings: 0 };
+    }
+  } catch {
+    return { errors: 0, warnings: 0 };
+  }
+}
+async function runBiome(projectPath) {
+  try {
+    const result = await execa("npx", ["@biomejs/biome", "lint", "src", "--reporter=json"], {
+      cwd: projectPath,
+      reject: false,
+      timeout: 6e4
+    });
+    try {
+      const output = JSON.parse(result.stdout);
+      const diagnostics = output.diagnostics ?? [];
+      const errors = diagnostics.filter(
+        (d) => d.severity === "error"
+      ).length;
+      const warnings = diagnostics.filter(
+        (d) => d.severity === "warning"
+      ).length;
+      return { errors, warnings };
+    } catch {
+      return { errors: 0, warnings: 0 };
+    }
+  } catch {
+    return { errors: 0, warnings: 0 };
+  }
+}
+var StyleAnalyzer = class {
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+  /**
+   * Analyze style/linting quality
+   */
+  async analyze() {
+    const linter = await detectLinter(this.projectPath);
+    if (!linter) {
+      return {
+        score: 50,
+        // Neutral score when no linter is configured
+        errors: 0,
+        warnings: 0,
+        linterUsed: null,
+        details: "No linter configured"
+      };
+    }
+    let result;
+    switch (linter) {
+      case "oxlint":
+        result = await runOxlint(this.projectPath);
+        break;
+      case "eslint":
+        result = await runEslint(this.projectPath);
+        break;
+      case "biome":
+        result = await runBiome(this.projectPath);
+        break;
+    }
+    const score = Math.round(
+      Math.max(0, Math.min(100, 100 - result.errors * 5 - result.warnings * 2))
+    );
+    const details = [
+      `Linter: ${linter}`,
+      `${result.errors} errors, ${result.warnings} warnings`
+    ].join(", ");
+    return {
+      score,
+      errors: result.errors,
+      warnings: result.warnings,
+      linterUsed: linter,
+      details
+    };
+  }
+};
+function analyzeReadabilityPatterns(ast) {
+  let goodNames = 0;
+  let totalNames = 0;
+  const functionLengths = [];
+  let maxNestingDepth = 0;
+  const cognitiveComplexities = [];
+  const allowedSingleChar = /* @__PURE__ */ new Set(["i", "j", "k", "_", "e", "x", "y", "t", "n"]);
+  function isGoodName(name) {
+    if (name.length === 1) {
+      return allowedSingleChar.has(name);
+    }
+    return name.length >= 3 && name.length <= 30;
+  }
+  function analyzeFunction(node) {
+    if (node.loc) {
+      const length = node.loc.end.line - node.loc.start.line + 1;
+      functionLengths.push(length);
+    }
+    let localMaxNesting = 0;
+    let cognitiveComplexity = 0;
+    function traverseForComplexity(n, currentNesting) {
+      localMaxNesting = Math.max(localMaxNesting, currentNesting);
+      let nextNesting = currentNesting;
+      let incrementsNesting = false;
+      switch (n.type) {
+        case "IfStatement":
+          cognitiveComplexity += 1;
+          incrementsNesting = true;
+          break;
+        case "ForStatement":
+        case "ForInStatement":
+        case "ForOfStatement":
+        case "WhileStatement":
+        case "DoWhileStatement":
+          cognitiveComplexity += 1 + currentNesting;
+          incrementsNesting = true;
+          break;
+        case "SwitchStatement":
+          cognitiveComplexity += 1 + currentNesting;
+          incrementsNesting = true;
+          break;
+        case "CatchClause":
+          cognitiveComplexity += 1 + currentNesting;
+          incrementsNesting = true;
+          break;
+        case "ConditionalExpression":
+          cognitiveComplexity += 1 + currentNesting;
+          incrementsNesting = true;
+          break;
+        case "LogicalExpression":
+          if (n.operator === "&&" || n.operator === "||") {
+            cognitiveComplexity += 1;
+          }
+          break;
+        case "FunctionExpression":
+        case "ArrowFunctionExpression":
+          incrementsNesting = true;
+          break;
+      }
+      if (incrementsNesting) {
+        nextNesting = currentNesting + 1;
+      }
+      traverseChildren(n, (child) => traverseForComplexity(child, nextNesting));
+    }
+    traverseForComplexity(node, 0);
+    maxNestingDepth = Math.max(maxNestingDepth, localMaxNesting);
+    cognitiveComplexities.push(cognitiveComplexity);
+  }
+  function collectNames(node) {
+    switch (node.type) {
+      case "FunctionDeclaration":
+        if (node.id) {
+          totalNames++;
+          if (isGoodName(node.id.name)) {
+            goodNames++;
+          }
+        }
+        for (const param of node.params) {
+          collectParamNames(param);
+        }
+        break;
+      case "FunctionExpression":
+      case "ArrowFunctionExpression":
+        for (const param of node.params) {
+          collectParamNames(param);
+        }
+        break;
+      case "VariableDeclarator":
+        if (node.id.type === "Identifier") {
+          totalNames++;
+          if (isGoodName(node.id.name)) {
+            goodNames++;
+          }
+        }
+        break;
+      case "MethodDefinition":
+        if (node.key.type === "Identifier") {
+          totalNames++;
+          if (isGoodName(node.key.name)) {
+            goodNames++;
+          }
+        }
+        if (node.value.type === "FunctionExpression") {
+          for (const param of node.value.params) {
+            collectParamNames(param);
+          }
+        }
+        break;
+    }
+  }
+  function collectParamNames(param) {
+    if (param.type === "Identifier") {
+      totalNames++;
+      if (isGoodName(param.name)) {
+        goodNames++;
+      }
+    } else if (param.type === "AssignmentPattern" && param.left.type === "Identifier") {
+      totalNames++;
+      if (isGoodName(param.left.name)) {
+        goodNames++;
+      }
+    } else if (param.type === "RestElement" && param.argument.type === "Identifier") {
+      totalNames++;
+      if (isGoodName(param.argument.name)) {
+        goodNames++;
+      }
+    }
+  }
+  function traverse(node) {
+    const isFunctionNode = node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "MethodDefinition";
+    collectNames(node);
+    if (isFunctionNode) {
+      analyzeFunction(node);
+    }
+    traverseChildren(node, traverse);
+  }
+  function traverseChildren(node, callback) {
+    for (const key of Object.keys(node)) {
+      if (key === "parent") continue;
+      const child = node[key];
+      if (child && typeof child === "object") {
+        if (Array.isArray(child)) {
+          for (const item of child) {
+            if (item && typeof item === "object" && item.type) {
+              callback(item);
+            }
+          }
+        } else if (child.type) {
+          callback(child);
+        }
+      }
+    }
+  }
+  traverse(ast);
+  return {
+    goodNames,
+    totalNames,
+    functionLengths,
+    maxNestingDepth,
+    cognitiveComplexities
+  };
+}
+var ReadabilityAnalyzer = class {
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+  /**
+   * Analyze readability of project files
+   */
+  async analyze(files) {
+    const targetFiles = files ?? await this.findSourceFiles();
+    let totalGoodNames = 0;
+    let totalNames = 0;
+    const allFunctionLengths = [];
+    let globalMaxNestingDepth = 0;
+    const allCognitiveComplexities = [];
+    for (const file of targetFiles) {
+      try {
+        const content = await readFile(file, "utf-8");
+        const ast = parse(content, {
+          loc: true,
+          range: true,
+          jsx: file.endsWith(".tsx") || file.endsWith(".jsx")
+        });
+        const result = analyzeReadabilityPatterns(ast);
+        totalGoodNames += result.goodNames;
+        totalNames += result.totalNames;
+        allFunctionLengths.push(...result.functionLengths);
+        globalMaxNestingDepth = Math.max(globalMaxNestingDepth, result.maxNestingDepth);
+        allCognitiveComplexities.push(...result.cognitiveComplexities);
+      } catch {
+      }
+    }
+    const namingScore = totalNames > 0 ? totalGoodNames / totalNames * 100 : 100;
+    const averageFunctionLength = allFunctionLengths.length > 0 ? allFunctionLengths.reduce((a, b) => a + b, 0) / allFunctionLengths.length : 0;
+    const functionLengthScore = allFunctionLengths.length > 0 ? Math.max(0, Math.min(100, 100 - (averageFunctionLength - 20) * 2.5)) : 100;
+    const maxNestingDepth = globalMaxNestingDepth;
+    const nestingDepthScore = Math.max(0, Math.min(100, 100 - (maxNestingDepth - 2) * 20));
+    const averageCognitiveComplexity = allCognitiveComplexities.length > 0 ? allCognitiveComplexities.reduce((a, b) => a + b, 0) / allCognitiveComplexities.length : 0;
+    const cognitiveComplexityScore = allCognitiveComplexities.length > 0 ? Math.max(0, Math.min(100, 100 - (averageCognitiveComplexity - 5) * 5)) : 100;
+    const score = Math.round(
+      namingScore * 0.25 + functionLengthScore * 0.25 + nestingDepthScore * 0.25 + cognitiveComplexityScore * 0.25
+    );
+    const details = [
+      `${totalGoodNames}/${totalNames} good names`,
+      `avg func ${averageFunctionLength.toFixed(1)} LOC`,
+      `max nesting ${maxNestingDepth}`,
+      `avg weighted complexity ${averageCognitiveComplexity.toFixed(1)}`
+    ].join(", ");
+    return {
+      score,
+      namingScore,
+      functionLengthScore,
+      nestingDepthScore,
+      cognitiveComplexityScore,
+      averageFunctionLength,
+      maxNestingDepth,
+      averageCognitiveComplexity,
+      details
+    };
+  }
+  async findSourceFiles() {
+    return glob("**/*.{ts,js,tsx,jsx}", {
+      cwd: this.projectPath,
+      absolute: true,
+      ignore: ["**/node_modules/**", "**/*.test.*", "**/*.spec.*", "**/dist/**", "**/build/**"]
+    });
+  }
+};
+function analyzeMaintainabilityPatterns(ast, filePath) {
+  let functionCount = 0;
+  let importCount = 0;
+  let crossBoundaryImportCount = 0;
+  function traverse(node) {
+    switch (node.type) {
+      case "FunctionDeclaration":
+      case "FunctionExpression":
+      case "ArrowFunctionExpression":
+      case "MethodDefinition":
+        functionCount++;
+        break;
+      case "ImportDeclaration":
+        importCount++;
+        if (isCrossBoundaryImport(node)) {
+          crossBoundaryImportCount++;
+        }
+        break;
+    }
+    traverseChildren(node);
+  }
+  function traverseChildren(node) {
+    for (const key of Object.keys(node)) {
+      if (key === "parent") continue;
+      const child = node[key];
+      if (child && typeof child === "object") {
+        if (Array.isArray(child)) {
+          for (const item of child) {
+            if (item && typeof item === "object" && item.type) {
+              traverse(item);
+            }
+          }
+        } else if (child.type) {
+          traverse(child);
+        }
+      }
+    }
+  }
+  traverse(ast);
+  return {
+    lineCount: 0,
+    // Will be set separately from content
+    functionCount,
+    importCount,
+    crossBoundaryImportCount
+  };
+}
+function isCrossBoundaryImport(node, _filePath) {
+  if (node.source.type !== "Literal" || typeof node.source.value !== "string") {
+    return false;
+  }
+  const importPath = node.source.value;
+  if (importPath.startsWith("node:")) {
+    return false;
+  }
+  if (!importPath.startsWith(".")) {
+    return false;
+  }
+  if (importPath.startsWith("../")) {
+    return true;
+  }
+  if (importPath.startsWith("./")) {
+    const relativePath = importPath.slice(2);
+    return relativePath.includes("/");
+  }
+  return false;
+}
+function countLines(content) {
+  return content.split("\n").length;
+}
+var MaintainabilityAnalyzer = class {
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+  /**
+   * Analyze maintainability of project files
+   */
+  async analyze(files) {
+    const targetFiles = files ?? await this.findSourceFiles();
+    if (targetFiles.length === 0) {
+      return {
+        score: 100,
+        fileLengthScore: 100,
+        functionCountScore: 100,
+        dependencyCountScore: 100,
+        couplingScore: 100,
+        averageFileLength: 0,
+        averageFunctionsPerFile: 0,
+        averageImportsPerFile: 0,
+        fileCount: 0,
+        details: "No files to analyze"
+      };
+    }
+    let totalLines = 0;
+    let totalFunctions = 0;
+    let totalImports = 0;
+    let totalCrossBoundaryImports = 0;
+    let filesAnalyzed = 0;
+    for (const file of targetFiles) {
+      try {
+        const content = await readFile(file, "utf-8");
+        const lineCount = countLines(content);
+        const ast = parse(content, {
+          loc: true,
+          range: true,
+          jsx: file.endsWith(".tsx") || file.endsWith(".jsx")
+        });
+        const result = analyzeMaintainabilityPatterns(ast, file);
+        totalLines += lineCount;
+        totalFunctions += result.functionCount;
+        totalImports += result.importCount;
+        totalCrossBoundaryImports += result.crossBoundaryImportCount;
+        filesAnalyzed++;
+      } catch {
+      }
+    }
+    const averageFileLength = filesAnalyzed > 0 ? totalLines / filesAnalyzed : 0;
+    const averageFunctionsPerFile = filesAnalyzed > 0 ? totalFunctions / filesAnalyzed : 0;
+    const averageImportsPerFile = filesAnalyzed > 0 ? totalImports / filesAnalyzed : 0;
+    const fileLengthScore = Math.max(0, Math.min(100, 100 - (averageFileLength - 200) * 0.33));
+    const functionCountScore = Math.max(0, Math.min(100, 100 - (averageFunctionsPerFile - 10) * 5));
+    const dependencyCountScore = Math.max(0, Math.min(100, 100 - (averageImportsPerFile - 5) * 5));
+    const crossBoundaryRatio = totalImports > 0 ? totalCrossBoundaryImports / totalImports : 0;
+    const couplingScore = Math.max(0, Math.min(100, 100 - crossBoundaryRatio * 100 * 0.5));
+    const score = Math.round(
+      fileLengthScore * 0.3 + functionCountScore * 0.25 + dependencyCountScore * 0.25 + couplingScore * 0.2
+    );
+    const details = [
+      `${Math.round(averageFileLength)} avg lines/file`,
+      `${averageFunctionsPerFile.toFixed(1)} avg functions/file`,
+      `${averageImportsPerFile.toFixed(1)} avg imports/file`,
+      `${Math.round(crossBoundaryRatio * 100)}% cross-boundary coupling`
+    ].join(", ");
+    return {
+      score,
+      fileLengthScore,
+      functionCountScore,
+      dependencyCountScore,
+      couplingScore,
+      averageFileLength,
+      averageFunctionsPerFile,
+      averageImportsPerFile,
+      fileCount: filesAnalyzed,
+      details
+    };
+  }
+  async findSourceFiles() {
+    return glob("**/*.{ts,js,tsx,jsx}", {
+      cwd: this.projectPath,
+      absolute: true,
+      ignore: ["**/node_modules/**", "**/*.test.*", "**/*.spec.*", "**/dist/**", "**/build/**"]
+    });
+  }
+};
+
+// src/quality/types.ts
+var DEFAULT_QUALITY_WEIGHTS = {
+  correctness: 0.15,
+  completeness: 0.1,
+  robustness: 0.1,
+  readability: 0.1,
+  maintainability: 0.1,
+  complexity: 0.08,
+  duplication: 0.07,
+  testCoverage: 0.1,
+  testQuality: 0.05,
+  security: 0.08,
+  documentation: 0.04,
+  style: 0.03
+};
+var DEFAULT_QUALITY_THRESHOLDS = {
+  minimum: {
+    overall: 85,
+    testCoverage: 80,
+    security: 100
+    // No vulnerabilities allowed
+  },
+  target: {
+    overall: 95,
+    testCoverage: 90
+  }};
+var QualityEvaluator = class {
+  constructor(projectPath, useSnyk = false) {
+    this.projectPath = projectPath;
+    this.coverageAnalyzer = new CoverageAnalyzer(projectPath);
+    this.securityScanner = new CompositeSecurityScanner(projectPath, useSnyk);
+    this.complexityAnalyzer = new ComplexityAnalyzer(projectPath);
+    this.duplicationAnalyzer = new DuplicationAnalyzer(projectPath);
+    this.correctnessAnalyzer = new CorrectnessAnalyzer(projectPath);
+    this.completenessAnalyzer = new CompletenessAnalyzer(projectPath);
+    this.robustnessAnalyzer = new RobustnessAnalyzer(projectPath);
+    this.testQualityAnalyzer = new TestQualityAnalyzer(projectPath);
+    this.documentationAnalyzer = new DocumentationAnalyzer(projectPath);
+    this.styleAnalyzer = new StyleAnalyzer(projectPath);
+    this.readabilityAnalyzer = new ReadabilityAnalyzer(projectPath);
+    this.maintainabilityAnalyzer = new MaintainabilityAnalyzer(projectPath);
+  }
+  coverageAnalyzer;
+  securityScanner;
+  complexityAnalyzer;
+  duplicationAnalyzer;
+  correctnessAnalyzer;
+  completenessAnalyzer;
+  robustnessAnalyzer;
+  testQualityAnalyzer;
+  documentationAnalyzer;
+  styleAnalyzer;
+  readabilityAnalyzer;
+  maintainabilityAnalyzer;
+  /**
+   * Evaluate quality across all 12 dimensions
+   * Every dimension is computed by real static analysis — zero hardcoded values
+   */
+  async evaluate(files) {
+    const startTime = performance.now();
+    const targetFiles = files ?? await this.findSourceFiles();
+    const fileContents = await Promise.all(
+      targetFiles.map(async (file) => ({
+        path: file,
+        content: await readFile(file, "utf-8")
+      }))
+    );
+    const [
+      coverageResult,
+      securityResult,
+      complexityResult,
+      duplicationResult,
+      correctnessResult,
+      completenessResult,
+      robustnessResult,
+      testQualityResult,
+      documentationResult,
+      styleResult,
+      readabilityResult,
+      maintainabilityResult
+    ] = await Promise.all([
+      this.coverageAnalyzer.analyze().catch(() => null),
+      this.securityScanner.scan(fileContents),
+      this.complexityAnalyzer.analyze(targetFiles),
+      this.duplicationAnalyzer.analyze(targetFiles),
+      this.correctnessAnalyzer.analyze().catch(() => ({ score: 0 })),
+      this.completenessAnalyzer.analyze(targetFiles).catch(() => ({ score: 0 })),
+      this.robustnessAnalyzer.analyze(targetFiles).catch(() => ({ score: 0 })),
+      this.testQualityAnalyzer.analyze().catch(() => ({ score: 0 })),
+      this.documentationAnalyzer.analyze(targetFiles).catch(() => ({ score: 0 })),
+      this.styleAnalyzer.analyze().catch(() => ({ score: 50 })),
+      this.readabilityAnalyzer.analyze(targetFiles).catch(() => ({ score: 50 })),
+      this.maintainabilityAnalyzer.analyze(targetFiles).catch(() => ({ score: 50 }))
+    ]);
+    const dimensions = {
+      testCoverage: coverageResult?.lines.percentage ?? 0,
+      security: securityResult.score,
+      complexity: complexityResult.score,
+      duplication: Math.max(0, 100 - duplicationResult.percentage),
+      style: styleResult.score,
+      readability: readabilityResult.score,
+      maintainability: maintainabilityResult.score,
+      correctness: correctnessResult.score,
+      completeness: completenessResult.score,
+      robustness: robustnessResult.score,
+      testQuality: testQualityResult.score,
+      documentation: documentationResult.score
+    };
+    const overall = Object.entries(dimensions).reduce((sum, [key, value]) => {
+      const weight = DEFAULT_QUALITY_WEIGHTS[key] ?? 0;
+      return sum + value * weight;
+    }, 0);
+    const scores = {
+      overall: Math.round(overall),
+      dimensions,
+      evaluatedAt: /* @__PURE__ */ new Date(),
+      evaluationDurationMs: performance.now() - startTime
+    };
+    const issues = this.generateIssues(
+      securityResult.vulnerabilities,
+      complexityResult,
+      duplicationResult,
+      correctnessResult,
+      styleResult,
+      documentationResult
+    );
+    const suggestions = this.generateSuggestions(dimensions);
+    const meetsMinimum = scores.overall >= DEFAULT_QUALITY_THRESHOLDS.minimum.overall && dimensions.testCoverage >= DEFAULT_QUALITY_THRESHOLDS.minimum.testCoverage && dimensions.security >= DEFAULT_QUALITY_THRESHOLDS.minimum.security;
+    const meetsTarget = scores.overall >= DEFAULT_QUALITY_THRESHOLDS.target.overall && dimensions.testCoverage >= DEFAULT_QUALITY_THRESHOLDS.target.testCoverage;
+    return {
+      scores,
+      meetsMinimum,
+      meetsTarget,
+      converged: false,
+      issues,
+      suggestions
+    };
+  }
+  /**
+   * Generate quality issues from analyzer results
+   */
+  generateIssues(securityVulns, complexityResult, duplicationResult, correctnessResult, styleResult, documentationResult) {
+    const issues = [];
+    for (const vuln of securityVulns) {
+      issues.push({
+        dimension: "security",
+        severity: vuln.severity === "critical" ? "critical" : vuln.severity === "high" ? "major" : "minor",
+        message: `${vuln.type}: ${vuln.description}`,
+        file: vuln.location.file,
+        line: vuln.location.line
+      });
+    }
+    for (const file of complexityResult.files) {
+      for (const fn of file.functions) {
+        if (fn.complexity > 10) {
+          issues.push({
+            dimension: "complexity",
+            severity: "major",
+            message: `Function '${fn.name}' has high complexity (${fn.complexity})`,
             file: file.file,
             line: fn.line,
             suggestion: "Refactor into smaller functions or reduce branching"
@@ -20670,6 +22544,38 @@ var QualityEvaluator = class {
         suggestion: "Extract common code into reusable functions or modules"
       });
     }
+    if (correctnessResult.testsFailed != null && correctnessResult.testsFailed > 0) {
+      issues.push({
+        dimension: "correctness",
+        severity: "critical",
+        message: `${correctnessResult.testsFailed} tests failing`,
+        suggestion: "Fix failing tests to improve correctness score"
+      });
+    }
+    if (correctnessResult.buildSuccess === false) {
+      issues.push({
+        dimension: "correctness",
+        severity: "critical",
+        message: "Build/type check failed",
+        suggestion: "Fix type errors to pass build verification"
+      });
+    }
+    if (styleResult.errors != null && styleResult.errors > 0) {
+      issues.push({
+        dimension: "style",
+        severity: "minor",
+        message: `${styleResult.errors} linting errors found`,
+        suggestion: "Run linter with --fix to auto-correct style issues"
+      });
+    }
+    if (documentationResult.jsdocCoverage !== void 0 && documentationResult.jsdocCoverage < 50) {
+      issues.push({
+        dimension: "documentation",
+        severity: "minor",
+        message: `Low JSDoc coverage: ${documentationResult.jsdocCoverage?.toFixed(1) ?? 0}%`,
+        suggestion: "Add JSDoc comments to exported functions and classes"
+      });
+    }
     return issues;
   }
   /**
@@ -20693,6 +22599,14 @@ var QualityEvaluator = class {
         estimatedImpact: 100 - dimensions.security
       });
     }
+    if (dimensions.correctness < 85) {
+      suggestions.push({
+        dimension: "correctness",
+        priority: "high",
+        description: "Fix failing tests and build errors",
+        estimatedImpact: 85 - dimensions.correctness
+      });
+    }
     if (dimensions.complexity < 80) {
       suggestions.push({
         dimension: "complexity",
@@ -20701,6 +22615,22 @@ var QualityEvaluator = class {
         estimatedImpact: Math.min(10, 80 - dimensions.complexity)
       });
     }
+    if (dimensions.documentation < 60) {
+      suggestions.push({
+        dimension: "documentation",
+        priority: "medium",
+        description: "Add JSDoc comments to exported declarations",
+        estimatedImpact: Math.min(15, 60 - dimensions.documentation)
+      });
+    }
+    if (dimensions.testQuality < 70) {
+      suggestions.push({
+        dimension: "testQuality",
+        priority: "medium",
+        description: "Replace trivial assertions with meaningful behavioral tests",
+        estimatedImpact: Math.min(10, 70 - dimensions.testQuality)
+      });
+    }
     if (dimensions.duplication < 95) {
       suggestions.push({
         dimension: "duplication",
@@ -20727,7 +22657,7 @@ function createQualityEvaluator(projectPath, useSnyk) {
 }
 
 // src/tools/quality.ts
-async function detectLinter(cwd) {
+async function detectLinter2(cwd) {
   try {
     const pkgPath = path20__default.join(cwd, "package.json");
     const pkgContent = await fs22__default.readFile(pkgPath, "utf-8");
@@ -20762,7 +22692,7 @@ Examples:
   }),
   async execute({ cwd, files, fix, linter }) {
     const projectDir = cwd ?? process.cwd();
-    const detectedLinter = linter ?? await detectLinter(projectDir);
+    const detectedLinter = linter ?? await detectLinter2(projectDir);
     if (!detectedLinter) {
       return {
         errors: 0,
@@ -20917,8 +22847,8 @@ Examples:
   }
 });
 async function findSourceFiles(cwd) {
-  const { glob: glob9 } = await import('glob');
-  return glob9("src/**/*.{ts,js,tsx,jsx}", {
+  const { glob: glob15 } = await import('glob');
+  return glob15("src/**/*.{ts,js,tsx,jsx}", {
     cwd,
     absolute: true,
     ignore: ["**/*.test.*", "**/*.spec.*", "**/node_modules/**"]
@@ -22475,9 +24405,9 @@ Examples:
   }
 });
 var diffTools = [showDiffTool];
-async function fileExists(path35) {
+async function fileExists(path37) {
   try {
-    await access(path35);
+    await access(path37);
     return true;
   } catch {
     return false;
@@ -22567,7 +24497,7 @@ async function detectMaturity(cwd) {
   if (!hasLintConfig && hasPackageJson) {
     try {
       const pkgRaw = await import('fs/promises').then(
-        (fs38) => fs38.readFile(join(cwd, "package.json"), "utf-8")
+        (fs39) => fs39.readFile(join(cwd, "package.json"), "utf-8")
       );
       const pkg = JSON.parse(pkgRaw);
       if (pkg.scripts?.lint || pkg.scripts?.["lint:fix"]) {
@@ -22934,9 +24864,9 @@ Examples:
   }
 });
 var reviewTools = [reviewCodeTool];
-var fs27 = await import('fs/promises');
-var path25 = await import('path');
-var { glob: glob6 } = await import('glob');
+var fs28 = await import('fs/promises');
+var path26 = await import('path');
+var { glob: glob12 } = await import('glob');
 var DEFAULT_MAX_FILES = 200;
 var LANGUAGE_EXTENSIONS = {
   typescript: [".ts", ".tsx", ".mts", ".cts"],
@@ -22961,7 +24891,7 @@ var DEFAULT_EXCLUDES = [
   "**/*.d.ts"
 ];
 function detectLanguage2(filePath) {
-  const ext = path25.extname(filePath).toLowerCase();
+  const ext = path26.extname(filePath).toLowerCase();
   for (const [lang, extensions] of Object.entries(LANGUAGE_EXTENSIONS)) {
     if (extensions.includes(ext)) return lang;
   }
@@ -23370,9 +25300,9 @@ Examples:
   }),
   async execute({ path: rootPath, include, exclude, languages, maxFiles, depth }) {
     const startTime = performance.now();
-    const absPath = path25.resolve(rootPath);
+    const absPath = path26.resolve(rootPath);
     try {
-      const stat2 = await fs27.stat(absPath);
+      const stat2 = await fs28.stat(absPath);
       if (!stat2.isDirectory()) {
         throw new ToolError(`Path is not a directory: ${absPath}`, {
           tool: "codebase_map"
@@ -23397,7 +25327,7 @@ Examples:
       pattern = `**/*{${allExts.join(",")}}`;
     }
     const excludePatterns = [...DEFAULT_EXCLUDES, ...exclude ?? []];
-    const files = await glob6(pattern, {
+    const files = await glob12(pattern, {
       cwd: absPath,
       ignore: excludePatterns,
       nodir: true,
@@ -23409,14 +25339,14 @@ Examples:
     let totalDefinitions = 0;
     let exportedSymbols = 0;
     for (const file of limitedFiles) {
-      const fullPath = path25.join(absPath, file);
+      const fullPath = path26.join(absPath, file);
       const language = detectLanguage2(file);
       if (!language) continue;
       if (languages && !languages.includes(language)) {
         continue;
       }
       try {
-        const content = await fs27.readFile(fullPath, "utf-8");
+        const content = await fs28.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;
@@ -23449,23 +25379,23 @@ Examples:
 });
 var codebaseMapTools = [codebaseMapTool];
 init_paths();
-var fs28 = await import('fs/promises');
-var path26 = await import('path');
+var fs29 = await import('fs/promises');
+var path27 = await import('path');
 var crypto2 = await import('crypto');
-var GLOBAL_MEMORIES_DIR = path26.join(COCO_HOME, "memories");
+var GLOBAL_MEMORIES_DIR = path27.join(COCO_HOME, "memories");
 var PROJECT_MEMORIES_DIR = ".coco/memories";
 var DEFAULT_MAX_MEMORIES = 1e3;
 async function ensureDir2(dirPath) {
-  await fs28.mkdir(dirPath, { recursive: true });
+  await fs29.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 = path26.join(dir, "index.json");
+  const indexPath = path27.join(dir, "index.json");
   try {
-    const content = await fs28.readFile(indexPath, "utf-8");
+    const content = await fs29.readFile(indexPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return [];
@@ -23474,14 +25404,14 @@ async function loadIndex(scope) {
 async function saveIndex(scope, index) {
   const dir = getMemoriesDir(scope);
   await ensureDir2(dir);
-  const indexPath = path26.join(dir, "index.json");
-  await fs28.writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
+  const indexPath = path27.join(dir, "index.json");
+  await fs29.writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
 }
 async function loadMemory(scope, id) {
   const dir = getMemoriesDir(scope);
-  const memPath = path26.join(dir, `${id}.json`);
+  const memPath = path27.join(dir, `${id}.json`);
   try {
-    const content = await fs28.readFile(memPath, "utf-8");
+    const content = await fs29.readFile(memPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -23490,8 +25420,8 @@ async function loadMemory(scope, id) {
 async function saveMemory(scope, memory) {
   const dir = getMemoriesDir(scope);
   await ensureDir2(dir);
-  const memPath = path26.join(dir, `${memory.id}.json`);
-  await fs28.writeFile(memPath, JSON.stringify(memory, null, 2), "utf-8");
+  const memPath = path27.join(dir, `${memory.id}.json`);
+  await fs29.writeFile(memPath, JSON.stringify(memory, null, 2), "utf-8");
 }
 var createMemoryTool = defineTool({
   name: "create_memory",
@@ -23643,17 +25573,17 @@ Examples:
   }
 });
 var memoryTools = [createMemoryTool, recallMemoryTool, listMemoriesTool];
-var fs29 = await import('fs/promises');
+var fs30 = 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 fs29.mkdir(".coco", { recursive: true });
+  await fs30.mkdir(".coco", { recursive: true });
 }
 async function loadCheckpoints() {
   try {
-    const content = await fs29.readFile(CHECKPOINT_FILE, "utf-8");
+    const content = await fs30.readFile(CHECKPOINT_FILE, "utf-8");
     return JSON.parse(content);
   } catch {
     return [];
@@ -23661,7 +25591,7 @@ async function loadCheckpoints() {
 }
 async function saveCheckpoints(checkpoints) {
   await ensureCocoDir();
-  await fs29.writeFile(CHECKPOINT_FILE, JSON.stringify(checkpoints, null, 2), "utf-8");
+  await fs30.writeFile(CHECKPOINT_FILE, JSON.stringify(checkpoints, null, 2), "utf-8");
 }
 async function execGit(args) {
   const { execaCommand } = await import('execa');
@@ -23821,9 +25751,9 @@ Examples:
   }
 });
 var checkpointTools = [createCheckpointTool, restoreCheckpointTool, listCheckpointsTool];
-var fs30 = await import('fs/promises');
-var path27 = await import('path');
-var { glob: glob7 } = await import('glob');
+var fs31 = await import('fs/promises');
+var path28 = await import('path');
+var { glob: glob13 } = await import('glob');
 var INDEX_DIR = ".coco/search-index";
 var DEFAULT_CHUNK_SIZE = 20;
 var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
@@ -23948,20 +25878,20 @@ async function getEmbedding(text9) {
 }
 async function loadIndex2(indexDir) {
   try {
-    const indexPath = path27.join(indexDir, "index.json");
-    const content = await fs30.readFile(indexPath, "utf-8");
+    const indexPath = path28.join(indexDir, "index.json");
+    const content = await fs31.readFile(indexPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 async function saveIndex2(indexDir, index) {
-  await fs30.mkdir(indexDir, { recursive: true });
-  const indexPath = path27.join(indexDir, "index.json");
-  await fs30.writeFile(indexPath, JSON.stringify(index), "utf-8");
+  await fs31.mkdir(indexDir, { recursive: true });
+  const indexPath = path28.join(indexDir, "index.json");
+  await fs31.writeFile(indexPath, JSON.stringify(index), "utf-8");
 }
 function isBinary(filePath) {
-  return BINARY_EXTENSIONS.has(path27.extname(filePath).toLowerCase());
+  return BINARY_EXTENSIONS.has(path28.extname(filePath).toLowerCase());
 }
 var semanticSearchTool = defineTool({
   name: "semantic_search",
@@ -23986,12 +25916,12 @@ Examples:
     const effectivePath = rootPath ?? ".";
     const effectiveMaxResults = maxResults ?? 10;
     const effectiveThreshold = threshold ?? 0.3;
-    const absPath = path27.resolve(effectivePath);
-    const indexDir = path27.join(absPath, INDEX_DIR);
+    const absPath = path28.resolve(effectivePath);
+    const indexDir = path28.join(absPath, INDEX_DIR);
     let index = reindex ? null : await loadIndex2(indexDir);
     if (!index) {
       const pattern = include ?? "**/*";
-      const files = await glob7(pattern, {
+      const files = await glob13(pattern, {
         cwd: absPath,
         ignore: DEFAULT_EXCLUDES2,
         nodir: true,
@@ -24000,10 +25930,10 @@ Examples:
       const chunks = [];
       for (const file of files) {
         if (isBinary(file)) continue;
-        const fullPath = path27.join(absPath, file);
+        const fullPath = path28.join(absPath, file);
         try {
-          const stat2 = await fs30.stat(fullPath);
-          const content = await fs30.readFile(fullPath, "utf-8");
+          const stat2 = await fs31.stat(fullPath);
+          const content = await fs31.readFile(fullPath, "utf-8");
           if (content.length > 1e5) continue;
           const fileChunks = chunkContent(content, DEFAULT_CHUNK_SIZE);
           for (const chunk of fileChunks) {
@@ -24062,12 +25992,12 @@ Examples:
   }
 });
 var semanticSearchTools = [semanticSearchTool];
-var fs31 = await import('fs/promises');
-var path28 = await import('path');
-var { glob: glob8 } = await import('glob');
+var fs32 = await import('fs/promises');
+var path29 = await import('path');
+var { glob: glob14 } = await import('glob');
 async function parseClassRelationships(rootPath, include) {
   const pattern = include ?? "**/*.{ts,tsx,js,jsx}";
-  const files = await glob8(pattern, {
+  const files = await glob14(pattern, {
     cwd: rootPath,
     ignore: ["**/node_modules/**", "**/dist/**", "**/*.test.*", "**/*.d.ts"],
     nodir: true
@@ -24076,7 +26006,7 @@ async function parseClassRelationships(rootPath, include) {
   const interfaces = [];
   for (const file of files.slice(0, 100)) {
     try {
-      const content = await fs31.readFile(path28.join(rootPath, file), "utf-8");
+      const content = await fs32.readFile(path29.join(rootPath, file), "utf-8");
       const lines = content.split("\n");
       for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
@@ -24195,14 +26125,14 @@ async function generateClassDiagram(rootPath, include) {
   };
 }
 async function generateArchitectureDiagram(rootPath) {
-  const entries = await fs31.readdir(rootPath, { withFileTypes: true });
+  const entries = await fs32.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 = path28.basename(rootPath);
+  const rootName = path29.basename(rootPath);
   lines.push(`  ROOT["${rootName}"]`);
   nodeCount++;
   for (const dir of dirs) {
@@ -24212,7 +26142,7 @@ async function generateArchitectureDiagram(rootPath) {
     nodeCount++;
     edgeCount++;
     try {
-      const subEntries = await fs31.readdir(path28.join(rootPath, dir.name), {
+      const subEntries = await fs32.readdir(path29.join(rootPath, dir.name), {
         withFileTypes: true
       });
       const subDirs = subEntries.filter(
@@ -24335,7 +26265,7 @@ Examples:
         tool: "generate_diagram"
       });
     }
-    const absPath = rootPath ? path28.resolve(rootPath) : process.cwd();
+    const absPath = rootPath ? path29.resolve(rootPath) : process.cwd();
     switch (type) {
       case "class":
         return generateClassDiagram(absPath, include);
@@ -24396,8 +26326,8 @@ Examples:
   }
 });
 var diagramTools = [generateDiagramTool];
-var fs32 = await import('fs/promises');
-var path29 = await import('path');
+var fs33 = await import('fs/promises');
+var path30 = await import('path');
 var DEFAULT_MAX_PAGES = 20;
 var MAX_FILE_SIZE = 50 * 1024 * 1024;
 function parsePageRange(rangeStr, totalPages) {
@@ -24432,9 +26362,9 @@ Examples:
   }),
   async execute({ path: filePath, pages, maxPages }) {
     const startTime = performance.now();
-    const absPath = path29.resolve(filePath);
+    const absPath = path30.resolve(filePath);
     try {
-      const stat2 = await fs32.stat(absPath);
+      const stat2 = await fs33.stat(absPath);
       if (!stat2.isFile()) {
         throw new ToolError(`Path is not a file: ${absPath}`, {
           tool: "read_pdf"
@@ -24465,7 +26395,7 @@ Examples:
     }
     try {
       const pdfParse = await import('pdf-parse');
-      const dataBuffer = await fs32.readFile(absPath);
+      const dataBuffer = await fs33.readFile(absPath);
       const pdfData = await pdfParse.default(dataBuffer, {
         max: maxPages
       });
@@ -24511,8 +26441,8 @@ Examples:
   }
 });
 var pdfTools = [readPdfTool];
-var fs33 = await import('fs/promises');
-var path30 = await import('path');
+var fs34 = await import('fs/promises');
+var path31 = 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 = {
@@ -24540,8 +26470,8 @@ 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 = path30.resolve(filePath);
-    const ext = path30.extname(absPath).toLowerCase();
+    const absPath = path31.resolve(filePath);
+    const ext = path31.extname(absPath).toLowerCase();
     if (!SUPPORTED_FORMATS.has(ext)) {
       throw new ToolError(
         `Unsupported image format '${ext}'. Supported: ${Array.from(SUPPORTED_FORMATS).join(", ")}`,
@@ -24549,7 +26479,7 @@ Examples:
       );
     }
     try {
-      const stat2 = await fs33.stat(absPath);
+      const stat2 = await fs34.stat(absPath);
       if (!stat2.isFile()) {
         throw new ToolError(`Path is not a file: ${absPath}`, {
           tool: "read_image"
@@ -24570,7 +26500,7 @@ Examples:
       if (error instanceof ToolError) throw error;
       throw error;
     }
-    const imageBuffer = await fs33.readFile(absPath);
+    const imageBuffer = await fs34.readFile(absPath);
     const base64 = imageBuffer.toString("base64");
     const mimeType = MIME_TYPES[ext] ?? "image/png";
     const selectedProvider = provider ?? "anthropic";
@@ -24683,7 +26613,7 @@ Examples:
   }
 });
 var imageTools = [readImageTool];
-var path31 = await import('path');
+var path32 = await import('path');
 var DANGEROUS_PATTERNS2 = [
   /\bDROP\s+(?:TABLE|DATABASE|INDEX|VIEW)\b/i,
   /\bTRUNCATE\b/i,
@@ -24714,7 +26644,7 @@ Examples:
   async execute({ database, query, params, readonly: isReadonlyParam }) {
     const isReadonly = isReadonlyParam ?? true;
     const startTime = performance.now();
-    const absPath = path31.resolve(database);
+    const absPath = path32.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.",
@@ -24787,7 +26717,7 @@ Examples:
   }),
   async execute({ database, table }) {
     const startTime = performance.now();
-    const absPath = path31.resolve(database);
+    const absPath = path32.resolve(database);
     try {
       const { default: Database } = await import('better-sqlite3');
       const db = new Database(absPath, { readonly: true, fileMustExist: true });
@@ -24958,14 +26888,14 @@ var findMissingImportsTool = defineTool({
   }
 });
 var astValidatorTools = [validateCodeTool, findMissingImportsTool];
-var fs34 = await import('fs/promises');
-var path32 = await import('path');
+var fs35 = await import('fs/promises');
+var path33 = 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 fs34.readFile(filePath, "utf-8");
+  const content = await fs35.readFile(filePath, "utf-8");
   const lines = content.split("\n").length;
   const functions = [];
   const classes = [];
@@ -25056,8 +26986,8 @@ async function analyzeFile(filePath, includeAst = false) {
   };
 }
 async function analyzeDirectory(dirPath) {
-  const { glob: glob9 } = await import('glob');
-  const files = await glob9("**/*.{ts,tsx,js,jsx}", {
+  const { glob: glob15 } = await import('glob');
+  const files = await glob15("**/*.{ts,tsx,js,jsx}", {
     cwd: dirPath,
     ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"],
     absolute: true
@@ -25069,10 +26999,10 @@ async function analyzeDirectory(dirPath) {
     try {
       const analysis = await analyzeFile(file, false);
       totalLines += analysis.lines;
-      const ext = path32.extname(file);
+      const ext = path33.extname(file);
       filesByType[ext] = (filesByType[ext] || 0) + 1;
       fileStats.push({
-        file: path32.relative(dirPath, file),
+        file: path33.relative(dirPath, file),
         lines: analysis.lines,
         complexity: analysis.complexity.cyclomatic
       });
@@ -25132,8 +27062,8 @@ var codeAnalyzerTools = [analyzeFileTool, analyzeDirectoryTool];
 var AgentTaskQueue = class {
   tasks = /* @__PURE__ */ new Map();
   completionOrder = [];
-  addTask(task) {
-    const id = `task-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+  addTask(task, idOverride) {
+    const id = idOverride ?? `task-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
     this.tasks.set(id, {
       ...task,
       id,
@@ -25179,10 +27109,20 @@ var AgentTaskQueue = class {
 };
 function planExecution(tasks, strategy) {
   const taskGraph = /* @__PURE__ */ new Map();
+  const unresolvedDependencies = [];
   tasks.forEach((task, idx) => {
-    const id = `task-${idx}`;
+    const id = task.id ?? `task-${idx}`;
     taskGraph.set(id, task.dependencies || []);
   });
+  const taskIds = new Set(taskGraph.keys());
+  for (const [id, deps] of taskGraph) {
+    const filtered = deps.filter((dep) => {
+      if (taskIds.has(dep)) return true;
+      unresolvedDependencies.push({ taskId: id, dependency: dep });
+      return false;
+    });
+    taskGraph.set(id, filtered);
+  }
   let plan = [];
   let estimatedTime = 0;
   let maxParallelism = 1;
@@ -25200,7 +27140,11 @@ function planExecution(tasks, strategy) {
       break;
     }
     case "priority-based": {
-      const sorted = tasks.map((t, idx) => ({ id: `task-${idx}`, len: t.description.length })).sort((a, b) => a.len - b.len);
+      const priorityOrder = { high: 0, medium: 1, low: 2 };
+      const sorted = tasks.map((t, idx) => ({
+        id: t.id ?? `task-${idx}`,
+        priority: t.priority ?? "medium"
+      })).sort((a, b) => (priorityOrder[a.priority] ?? 1) - (priorityOrder[b.priority] ?? 1));
       plan = sorted.map((t) => t.id);
       estimatedTime = tasks.length * 80;
       maxParallelism = 3;
@@ -25229,7 +27173,7 @@ function planExecution(tasks, strategy) {
       break;
     }
   }
-  return { plan, estimatedTime, maxParallelism };
+  return { plan, estimatedTime, maxParallelism, unresolvedDependencies };
 }
 var createAgentPlanTool = defineTool({
   name: "createAgentPlan",
@@ -25248,15 +27192,35 @@ var createAgentPlanTool = defineTool({
   async execute(input) {
     const typedInput = input;
     const queue = new AgentTaskQueue();
-    for (const task of typedInput.tasks) {
-      queue.addTask({
-        description: task.description,
-        priority: task.priority,
-        estimatedDuration: 100,
-        dependencies: task.dependencies
-      });
+    const indexIdMap = /* @__PURE__ */ new Map();
+    for (let idx = 0; idx < typedInput.tasks.length; idx++) {
+      indexIdMap.set(idx, `task-${idx}`);
+    }
+    const normalizeDependency = (dep) => {
+      if (indexIdMap.has(Number(dep))) {
+        return indexIdMap.get(Number(dep));
+      }
+      return dep;
+    };
+    for (const [idx, task] of typedInput.tasks.entries()) {
+      const id = indexIdMap.get(idx);
+      const normalizedDependencies = (task.dependencies || []).map(normalizeDependency);
+      queue.addTask(
+        {
+          description: task.description,
+          priority: task.priority,
+          estimatedDuration: 100,
+          dependencies: normalizedDependencies
+        },
+        id
+      );
     }
-    const executionPlan = planExecution(typedInput.tasks, typedInput.strategy);
+    const plannedTasks = typedInput.tasks.map((task, idx) => ({
+      id: indexIdMap.get(idx),
+      description: task.description,
+      dependencies: (task.dependencies || []).map(normalizeDependency)
+    }));
+    const executionPlan = planExecution(plannedTasks, typedInput.strategy);
     return {
       planId: `plan-${Date.now()}`,
       strategy: typedInput.strategy,
@@ -25264,6 +27228,7 @@ var createAgentPlanTool = defineTool({
       executionOrder: executionPlan.plan,
       estimatedTime: executionPlan.estimatedTime,
       maxParallelism: executionPlan.maxParallelism,
+      unresolvedDependencies: executionPlan.unresolvedDependencies,
       tasks: queue.getTasks().map((t) => ({
         id: t.id,
         description: t.description,
@@ -25276,30 +27241,59 @@ var createAgentPlanTool = defineTool({
 });
 var delegateTaskTool = defineTool({
   name: "delegateTask",
-  description: "Delegate a task to a virtual sub-agent (simulated for demonstration)",
+  description: "Delegate a task to a specialized sub-agent with real LLM tool-use execution.",
   category: "build",
   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"),
-    context: z.string().optional()
+    context: z.string().optional(),
+    maxTurns: z.number().default(10)
   }),
   async execute(input) {
     const typedInput = input;
+    const provider = getAgentProvider();
+    const toolRegistry = getAgentToolRegistry();
+    if (!provider || !toolRegistry) {
+      return {
+        agentId: `agent-${Date.now()}-${typedInput.agentRole}`,
+        taskId: typedInput.taskId,
+        role: typedInput.agentRole,
+        status: "unavailable",
+        message: "Agent provider not initialized. Call setAgentProvider() during orchestrator startup.",
+        success: false
+      };
+    }
     const agentId = `agent-${Date.now()}-${typedInput.agentRole}`;
+    const executor = new AgentExecutor(provider, toolRegistry);
+    const roleDef = AGENT_ROLES[typedInput.agentRole];
+    if (!roleDef) {
+      return {
+        agentId,
+        taskId: typedInput.taskId,
+        role: typedInput.agentRole,
+        status: "error",
+        message: `Unknown agent role: ${typedInput.agentRole}`,
+        success: false
+      };
+    }
+    const agentDef = { ...roleDef, maxTurns: typedInput.maxTurns };
+    const result = await executor.execute(agentDef, {
+      id: typedInput.taskId,
+      description: typedInput.task,
+      context: typedInput.context ? { userContext: typedInput.context } : void 0
+    });
     return {
       agentId,
       taskId: typedInput.taskId,
       role: typedInput.agentRole,
-      status: "simulated",
-      message: `Task delegated to ${typedInput.agentRole} agent`,
-      capabilities: {
-        researcher: ["web search", "document analysis", "information synthesis"],
-        coder: ["code generation", "refactoring", "debugging"],
-        reviewer: ["code review", "security analysis", "best practices"],
-        tester: ["test generation", "coverage analysis", "bug detection"],
-        optimizer: ["performance tuning", "complexity reduction", "resource optimization"]
-      }[typedInput.agentRole],
-      note: "This is a simulated agent. Full implementation requires provider integration."
+      status: result.success ? "completed" : "failed",
+      output: result.output,
+      success: result.success,
+      turns: result.turns,
+      toolsUsed: result.toolsUsed,
+      tokensUsed: result.tokensUsed,
+      duration: result.duration
     };
   }
 });
@@ -25335,10 +27329,14 @@ var aggregateResultsTool = defineTool({
         const winner = Array.from(counts.entries()).sort((a, b) => b[1] - a[1])[0];
         aggregatedOutput = winner ? winner[0] : "";
         break;
-      case "best":
-        const longest = completed.sort((a, b) => b.output.length - a.output.length)[0];
-        aggregatedOutput = longest ? longest.output : "";
+      case "best": {
+        const successRate = typedInput.results.length > 0 ? completed.length / typedInput.results.length : 0;
+        const bestResult = completed.length > 0 ? completed[0] : void 0;
+        aggregatedOutput = bestResult ? `[Success rate: ${Math.round(successRate * 100)}%]
+
+${bestResult.output}` : "";
         break;
+      }
       case "summary":
         aggregatedOutput = `Completed: ${completed.length}, Failed: ${failed.length}
 
@@ -25360,13 +27358,13 @@ ${completed.map((r) => `- ${r.agentId}: Success`).join("\n")}`;
   }
 });
 var agentCoordinatorTools = [createAgentPlanTool, delegateTaskTool, aggregateResultsTool];
-var fs35 = await import('fs/promises');
+var fs36 = 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 fs35.readFile(filePath, "utf-8");
+  const content = await fs36.readFile(filePath, "utf-8");
   const lines = content.split("\n");
   const suggestions = [];
   for (let i = 0; i < lines.length; i++) {
@@ -25412,7 +27410,8 @@ async function analyzeAndSuggest(filePath, _context) {
         reasoning: "'any' bypasses all type checking and can hide bugs"
       });
     }
-    if (line.trim() === "catch (error) {" || line.trim() === "catch (e) {") {
+    const trimmedLine = line.trim();
+    if (trimmedLine.endsWith("catch (error) {") || trimmedLine.endsWith("catch (e) {") || trimmedLine === "catch (error) {" || trimmedLine === "catch (e) {") {
       const nextLine = lines[i + 1];
       if (nextLine && nextLine.trim() === "}") {
         suggestions.push({
@@ -25457,7 +27456,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 fs35.access(testPath);
+        await fs36.access(testPath);
       } catch {
         suggestions.push({
           type: "testing",
@@ -25514,7 +27513,7 @@ var calculateCodeScoreTool = defineTool({
   async execute(input) {
     const { filePath } = input;
     const suggestions = await analyzeAndSuggest(filePath);
-    const content = await fs35.readFile(filePath, "utf-8");
+    const content = await fs36.readFile(filePath, "utf-8");
     const lines = content.split("\n");
     const nonEmptyLines = lines.filter((l) => l.trim()).length;
     let score = 100;
@@ -25548,8 +27547,8 @@ var calculateCodeScoreTool = defineTool({
   }
 });
 var smartSuggestionsTools = [suggestImprovementsTool, calculateCodeScoreTool];
-var fs36 = await import('fs/promises');
-var path33 = await import('path');
+var fs37 = await import('fs/promises');
+var path34 = await import('path');
 var ContextMemoryStore = class {
   items = /* @__PURE__ */ new Map();
   learnings = /* @__PURE__ */ new Map();
@@ -25561,7 +27560,7 @@ var ContextMemoryStore = class {
   }
   async load() {
     try {
-      const content = await fs36.readFile(this.storePath, "utf-8");
+      const content = await fs37.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 || {}));
@@ -25569,15 +27568,15 @@ var ContextMemoryStore = class {
     }
   }
   async save() {
-    const dir = path33.dirname(this.storePath);
-    await fs36.mkdir(dir, { recursive: true });
+    const dir = path34.dirname(this.storePath);
+    await fs37.mkdir(dir, { recursive: true });
     const data = {
       sessionId: this.sessionId,
       items: Object.fromEntries(this.items),
       learnings: Object.fromEntries(this.learnings),
       savedAt: Date.now()
     };
-    await fs36.writeFile(this.storePath, JSON.stringify(data, null, 2));
+    await fs37.writeFile(this.storePath, JSON.stringify(data, null, 2));
   }
   addContext(id, item) {
     this.items.set(id, item);
@@ -25742,11 +27741,11 @@ var contextEnhancerTools = [
   recordLearningTool,
   getLearnedPatternsTool
 ];
-var fs37 = await import('fs/promises');
-var path34 = await import('path');
+var fs38 = await import('fs/promises');
+var path35 = await import('path');
 async function discoverSkills(skillsDir) {
   try {
-    const files = await fs37.readdir(skillsDir);
+    const files = await fs38.readdir(skillsDir);
     return files.filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
   } catch {
     return [];
@@ -25754,12 +27753,12 @@ async function discoverSkills(skillsDir) {
 }
 async function loadSkillMetadata(skillPath) {
   try {
-    const content = await fs37.readFile(skillPath, "utf-8");
+    const content = await fs38.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] || path34.basename(skillPath, path34.extname(skillPath)),
+      name: nameMatch?.[1] || path35.basename(skillPath, path35.extname(skillPath)),
       description: descMatch?.[1] || "No description",
       version: versionMatch?.[1] || "1.0.0",
       dependencies: []
@@ -25803,7 +27802,7 @@ var discoverSkillsTool = defineTool({
     const { skillsDir } = input;
     const skills = await discoverSkills(skillsDir);
     const metadata = await Promise.all(
-      skills.map((s) => loadSkillMetadata(path34.join(skillsDir, s)))
+      skills.map((s) => loadSkillMetadata(path35.join(skillsDir, s)))
     );
     return {
       skillsDir,
@@ -26532,6 +28531,24 @@ var pc = chalk12;
 });
 
 // src/cli/repl/index.ts
+function visualWidth(str) {
+  const stripped = str.replace(/\x1b\[[0-9;]*m/g, "");
+  let width = 0;
+  for (const char of stripped) {
+    const cp = char.codePointAt(0) || 0;
+    if (cp > 128512 || cp >= 9728 && cp <= 10175 || cp >= 127744 && cp <= 129750 || cp >= 129280 && cp <= 129535 || cp >= 9986 && cp <= 10160 || cp >= 65024 && cp <= 65039 || cp === 8205) {
+      width += 2;
+    } else if (
+      // CJK Unified Ideographs and other wide characters
+      cp >= 4352 && cp <= 4447 || cp >= 11904 && cp <= 12350 || cp >= 12352 && cp <= 13247 || cp >= 19968 && cp <= 40959 || cp >= 63744 && cp <= 64255 || cp >= 65072 && cp <= 65135 || cp >= 65281 && cp <= 65376 || cp >= 65504 && cp <= 65510
+    ) {
+      width += 2;
+    } else {
+      width += 1;
+    }
+  }
+  return width;
+}
 async function startRepl(options = {}) {
   const projectPath = options.projectPath ?? process.cwd();
   const session = createSession(projectPath, options.config);
@@ -26576,6 +28593,8 @@ async function startRepl(options = {}) {
   }
   await loadCocoModePreference();
   const toolRegistry = createFullToolRegistry();
+  setAgentProvider(provider);
+  setAgentToolRegistry(toolRegistry);
   const inputHandler = createInputHandler();
   const intentRecognizer = createIntentRecognizer();
   await printWelcome(session);
@@ -26796,23 +28815,39 @@ async function startRepl(options = {}) {
   inputHandler.close();
 }
 async function printWelcome(session) {
+  const providerType = session.config.provider.type;
+  const model = session.config.provider.model || "default";
+  const isReturningUser = existsSync(path20__default.join(session.projectPath, ".coco"));
+  if (isReturningUser) {
+    const versionStr = chalk12.dim(`v${VERSION}`);
+    const providerStr = chalk12.dim(`${providerType}/${model}`);
+    console.log(
+      `
+  \u{1F965} Coco ${versionStr} ${chalk12.dim("\u2502")} ${providerStr} ${chalk12.dim("\u2502")} ${chalk12.yellow("/help")}
+`
+    );
+    return;
+  }
   const trustStore = createTrustStore();
   await trustStore.init();
   const trustLevel = trustStore.getLevel(session.projectPath);
   const boxWidth = 41;
   const innerWidth = boxWidth - 4;
-  const titleText = "CORBAT-COCO";
+  const titleContent = "\u{1F965} CORBAT-COCO";
   const versionText = `v${VERSION}`;
-  const titlePadding = innerWidth - titleText.length - versionText.length - 2;
+  const titleContentVisualWidth = visualWidth(titleContent);
+  const versionVisualWidth = visualWidth(versionText);
+  const titlePadding = innerWidth - titleContentVisualWidth - versionVisualWidth;
   const subtitleText = "open source \u2022 corbat.tech";
-  const subtitlePadding = innerWidth - subtitleText.length;
+  const subtitleVisualWidth = visualWidth(subtitleText);
+  const subtitlePadding = innerWidth - subtitleVisualWidth;
   console.log();
   console.log(chalk12.magenta("  \u256D" + "\u2500".repeat(boxWidth - 2) + "\u256E"));
   console.log(
-    chalk12.magenta("  \u2502 ") + "\u{1F965} " + chalk12.bold.white(titleText) + " ".repeat(titlePadding) + chalk12.dim(versionText) + chalk12.magenta(" \u2502")
+    chalk12.magenta("  \u2502 ") + "\u{1F965} " + chalk12.bold.white("CORBAT-COCO") + " ".repeat(Math.max(0, titlePadding)) + chalk12.dim(versionText) + chalk12.magenta(" \u2502")
   );
   console.log(
-    chalk12.magenta("  \u2502 ") + chalk12.dim(subtitleText) + " ".repeat(subtitlePadding) + chalk12.magenta(" \u2502")
+    chalk12.magenta("  \u2502 ") + chalk12.dim(subtitleText) + " ".repeat(Math.max(0, subtitlePadding)) + chalk12.magenta(" \u2502")
   );
   console.log(chalk12.magenta("  \u2570" + "\u2500".repeat(boxWidth - 2) + "\u256F"));
   const updateInfo = await checkForUpdates();
@@ -27067,7 +29102,7 @@ async function main() {
   await program.parseAsync(process.argv);
 }
 main().catch((error) => {
-  console.error("Fatal error:", error);
+  console.error(formatError(error));
   process.exit(1);
 });
 //# sourceMappingURL=index.js.map