nairon-bench 0.3.12 → 0.3.14

package/dist/index.js

@@ -4447,8 +4447,8 @@ function defineCommand2(def) {
 
 // src/commands/scan.ts
 init_dist();
-import { existsSync as existsSync8, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4, readFileSync as readFileSync8 } from "node:fs";
-import { join as join8 } from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4, readFileSync as readFileSync9 } from "node:fs";
+import { join as join9 } from "node:path";
 
 // ../../node_modules/simple-git/dist/esm/index.js
 var import_file_exists = __toESM(require_dist(), 1);
@@ -10767,7 +10767,7 @@ function getTechStackSpecificRecommendations(projectContext) {
       description: "Vercel's React and Next.js patterns for your stack",
       impact: "medium",
       type: "skill",
-      installCommand: "npx skills add vercel/react-best-practices"
+      installCommand: "npx skills add vercel-labs/agent-skills@vercel-react-best-practices --yes"
     });
   }
   if (database2?.includes("convex")) {
@@ -11458,652 +11458,246 @@ function renderBar(value, width) {
   return "█".repeat(filled) + "░".repeat(empty);
 }
 
-// src/lib/optimization-installer.ts
-import { execSync as execSync2, spawnSync } from "node:child_process";
-import { existsSync as existsSync7, writeFileSync as writeFileSync3, readFileSync as readFileSync7, mkdirSync as mkdirSync3, readdirSync as readdirSync4 } from "node:fs";
-import { join as join7 } from "node:path";
+// src/lib/frustration-detector.ts
+import { existsSync as existsSync7, readFileSync as readFileSync7, readdirSync as fsReaddirSync } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-async function installOptimizations(optimizations, projectDir, options = {}) {
-  const results = [];
-  for (const opt of optimizations) {
-    if (!opt.selected)
-      continue;
-    try {
-      const result = await installSingleOptimization(opt, projectDir, options);
-      results.push(result);
-    } catch (err) {
-      results.push({
-        id: opt.id,
-        name: opt.name,
-        success: false,
-        message: "Installation failed",
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  return results;
-}
-async function installSingleOptimization(opt, projectDir, options) {
-  if (options.dryRun) {
-    return {
-      id: opt.id,
-      name: opt.name,
-      success: true,
-      message: `[DRY RUN] Would install: ${opt.installCommand || opt.configPath || "unknown"}`
-    };
-  }
-  switch (opt.type) {
-    case "mcp":
-      return installMCP(opt, projectDir, options.agent);
-    case "skill":
-      return installSkill(opt);
-    case "config":
-      return installConfig(opt, projectDir);
-    case "hook":
-      return installHook(opt, projectDir);
-    default:
-      return {
-        id: opt.id,
-        name: opt.name,
-        success: false,
-        message: "Unknown optimization type"
-      };
-  }
-}
-function installMCP(opt, projectDir, agent) {
-  if (opt.installCommand?.startsWith("claude mcp add")) {
-    try {
-      execSync2(opt.installCommand, {
-        encoding: "utf-8",
-        stdio: "pipe",
-        timeout: 60000
-      });
-      return {
-        id: opt.id,
-        name: opt.name,
-        success: true,
-        message: `Installed via: ${opt.installCommand}`
-      };
-    } catch (err) {}
-  }
-  if (opt.id === "beads" || opt.name.toLowerCase().includes("beads")) {
-    try {
-      execSync2("bun add -g beads", { encoding: "utf-8", stdio: "pipe", timeout: 60000 });
-      execSync2("bd init", { cwd: projectDir, encoding: "utf-8", stdio: "pipe", timeout: 30000 });
-      return {
-        id: opt.id,
-        name: opt.name,
-        success: true,
-        message: "Installed Beads globally and initialized in project"
-      };
-    } catch (err) {
-      return {
-        id: opt.id,
-        name: opt.name,
-        success: false,
-        message: "Failed to install Beads",
-        error: err instanceof Error ? err.message : String(err)
-      };
-    }
+import { join as join7 } from "node:path";
+
+// ../../node_modules/ora/index.js
+import process8 from "node:process";
+import { stripVTControlCharacters } from "node:util";
+
+// ../../node_modules/chalk/source/vendor/ansi-styles/index.js
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code2) => `\x1B[${code2 + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code2) => `\x1B[${38 + offset};5;${code2}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    blackBright: [90, 39],
+    gray: [90, 39],
+    grey: [90, 39],
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    bgGrey: [100, 49],
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
   }
-  if (opt.installCommand) {
-    try {
-      execSync2(opt.installCommand, {
-        encoding: "utf-8",
-        stdio: "pipe",
-        timeout: 60000
-      });
-      return {
-        id: opt.id,
-        name: opt.name,
-        success: true,
-        message: `Installed via: ${opt.installCommand}`
-      };
-    } catch (err) {
-      return {
-        id: opt.id,
-        name: opt.name,
-        success: false,
-        message: "Failed to install MCP",
-        error: err instanceof Error ? err.message : String(err)
+};
+var modifierNames = Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+var colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = new Map;
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
       };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
     }
-  }
-  return {
-    id: opt.id,
-    name: opt.name,
-    success: false,
-    message: "No install command available"
-  };
-}
-function installSkill(opt) {
-  if (!opt.installCommand) {
-    return {
-      id: opt.id,
-      name: opt.name,
-      success: false,
-      message: "No install command for skill"
-    };
-  }
-  try {
-    const skillPath = opt.installCommand.replace(/^npx\s+/, "").replace(/^bunx\s+/, "").replace(/^skills\s+add\s+/, "").trim();
-    let result = spawnSync("bunx", ["--bun", "skills", "add", skillPath], {
-      encoding: "utf-8",
-      stdio: "pipe",
-      timeout: 120000
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
     });
-    if (result.status !== 0) {
-      result = spawnSync("npx", ["-y", "skills", "add", skillPath], {
-        encoding: "utf-8",
-        stdio: "pipe",
-        timeout: 120000
-      });
-    }
-    if (result.status === 0) {
-      return {
-        id: opt.id,
-        name: opt.name,
-        success: true,
-        message: `Skill installed successfully`
-      };
-    } else {
-      const output = (result.stderr || result.stdout || "").toLowerCase();
-      if (output.includes("already exists") || output.includes("already installed")) {
-        return {
-          id: opt.id,
-          name: opt.name,
-          success: true,
-          message: `Skill already installed`
-        };
-      }
-      return {
-        id: opt.id,
-        name: opt.name,
-        success: false,
-        message: "Skill installation failed",
-        error: result.stderr || result.stdout || "Unknown error"
-      };
-    }
-  } catch (err) {
-    return {
-      id: opt.id,
-      name: opt.name,
-      success: false,
-      message: "Failed to install skill",
-      error: err instanceof Error ? err.message : String(err)
-    };
   }
-}
-function installConfig(opt, projectDir) {
-  if (!opt.configPath || !opt.configContent) {
-    return {
-      id: opt.id,
-      name: opt.name,
-      success: false,
-      message: "No config path or content provided"
-    };
-  }
-  try {
-    const fullPath = opt.configPath.startsWith("/") || opt.configPath.startsWith("~") ? opt.configPath.replace("~", homedir6()) : join7(projectDir, opt.configPath);
-    if (existsSync7(fullPath)) {
-      return {
-        id: opt.id,
-        name: opt.name,
-        success: true,
-        message: `Config already exists: ${opt.configPath}`
-      };
-    }
-    const parentDir = fullPath.substring(0, fullPath.lastIndexOf("/"));
-    if (parentDir && !existsSync7(parentDir)) {
-      mkdirSync3(parentDir, { recursive: true });
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code2) {
+        if (code2 < 8) {
+          return 30 + code2;
+        }
+        if (code2 < 16) {
+          return 90 + (code2 - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code2 >= 232) {
+          red = ((code2 - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code2 -= 16;
+          const remainder = code2 % 36;
+          red = Math.floor(code2 / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
     }
-    writeFileSync3(fullPath, opt.configContent);
-    return {
-      id: opt.id,
-      name: opt.name,
-      success: true,
-      message: `Created: ${opt.configPath}`
-    };
-  } catch (err) {
-    return {
-      id: opt.id,
-      name: opt.name,
-      success: false,
-      message: "Failed to create config",
-      error: err instanceof Error ? err.message : String(err)
-    };
-  }
+  });
+  return styles;
 }
-function installHook(opt, projectDir) {
-  const agentsMdPath = join7(projectDir, "AGENTS.md");
-  try {
-    let content = "";
-    if (existsSync7(agentsMdPath)) {
-      content = readFileSync7(agentsMdPath, "utf-8");
-    } else {
-      content = `# Agent Instructions
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
 
-`;
+// ../../node_modules/chalk/source/vendor/supports-color/index.js
+import process2 from "node:process";
+import os from "node:os";
+import tty2 from "node:tty";
+function hasFlag(flag, argv2 = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv2.indexOf(prefix + flag);
+  const terminatorPosition = argv2.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+var { env: env2 } = process2;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env2) {
+    if (env2.FORCE_COLOR === "true") {
+      return 1;
     }
-    const hookName = opt.name.toLowerCase();
-    if (content.toLowerCase().includes(hookName)) {
-      return {
-        id: opt.id,
-        name: opt.name,
-        success: true,
-        message: "Hook already configured in AGENTS.md"
-      };
+    if (env2.FORCE_COLOR === "false") {
+      return 0;
     }
-    const hookSection = opt.configContent || `
-## ${opt.name}
-${opt.description}
-`;
-    content += `
-` + hookSection;
-    writeFileSync3(agentsMdPath, content);
-    return {
-      id: opt.id,
-      name: opt.name,
-      success: true,
-      message: "Added hook to AGENTS.md"
-    };
-  } catch (err) {
-    return {
-      id: opt.id,
-      name: opt.name,
-      success: false,
-      message: "Failed to add hook",
-      error: err instanceof Error ? err.message : String(err)
-    };
+    return env2.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env2.FORCE_COLOR, 10), 3);
   }
 }
-function phaseRecToInstallable(rec) {
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
   return {
-    id: rec.title.toLowerCase().replace(/\s+/g, "-"),
-    name: rec.title,
-    type: rec.type,
-    description: rec.description,
-    installCommand: rec.installCommand,
-    selected: false
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
   };
 }
-function checkInstalledStatus(projectDir) {
-  const home = homedir6();
-  const status = {
-    context7: false,
-    supermemory: false,
-    nia: false,
-    beads: false,
-    skills: []
-  };
-  const mcpConfigPaths = [
-    join7(home, ".claude.json"),
-    join7(home, ".claude", "claude_desktop_config.json"),
-    join7(home, ".claude", "settings.json"),
-    join7(home, ".claude", "settings.local.json"),
-    join7(projectDir, ".mcp.json"),
-    join7(projectDir, ".claude", "settings.local.json")
-  ];
-  for (const configPath of mcpConfigPaths) {
-    if (existsSync7(configPath)) {
-      try {
-        const config = JSON.parse(readFileSync7(configPath, "utf-8"));
-        const mcpServers = config.mcpServers || config.mcp_servers || {};
-        for (const name of Object.keys(mcpServers)) {
-          const mcpName = name.toLowerCase();
-          if (mcpName.includes("context7") || mcpName === "c7") {
-            status.context7 = true;
-          }
-          if (mcpName.includes("supermemory") || mcpName.includes("memory")) {
-            status.supermemory = true;
-          }
-          if (mcpName.includes("nia")) {
-            status.nia = true;
-          }
-        }
-      } catch {}
-    }
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== undefined) {
+    flagForceColor = noFlagForceColor;
   }
-  status.beads = existsSync7(join7(projectDir, ".beads"));
-  const skillsDirs = [
-    join7(home, ".claude", "skills"),
-    join7(home, ".config", "opencode", "skills"),
-    join7(home, ".agents", "skills"),
-    join7(projectDir, ".opencode", "skill")
-  ];
-  for (const dir of skillsDirs) {
-    if (existsSync7(dir)) {
-      try {
-        const skills = readdirSync4(dir);
-        for (const skill of skills) {
-          if (!status.skills.includes(skill.toLowerCase())) {
-            status.skills.push(skill.toLowerCase());
-          }
-        }
-      } catch {}
-    }
-  }
-  return status;
-}
-function filterAlreadyInstalled(optimizations, status) {
-  return optimizations.filter((opt) => {
-    const id = opt.id.toLowerCase();
-    if (id === "context7" && status.context7)
-      return false;
-    if (id === "supermemory" && status.supermemory)
-      return false;
-    if (id === "nia" && status.nia)
-      return false;
-    if (id === "beads" && status.beads)
-      return false;
-    if (opt.type === "skill") {
-      const skillName = opt.name.toLowerCase().replace(/\s+/g, "-");
-      if (status.skills.some((s2) => s2.includes(skillName) || skillName.includes(s2) || s2.includes("tdd") && id.includes("tdd") || s2.includes("debug") && id.includes("debug") || s2.includes("plan") && id.includes("plan"))) {
-        return false;
-      }
-    }
-    return true;
-  });
-}
-var QUICK_INSTALL_PRESETS = {
-  essential: [
-    {
-      id: "context7",
-      name: "Context7 MCP",
-      type: "mcp",
-      description: "Up-to-date library documentation",
-      installCommand: "claude mcp add context7 https://mcp.context7.com/mcp --transport http",
-      selected: true
-    },
-    {
-      id: "supermemory",
-      name: "Supermemory MCP",
-      type: "mcp",
-      description: "Persistent memory across sessions",
-      installCommand: "claude mcp add supermemory -- npx -y @supermemory/mcp@latest",
-      selected: true
-    },
-    {
-      id: "beads",
-      name: "Beads Task Manager",
-      type: "mcp",
-      description: "Persistent task tracking",
-      installCommand: "bun add -g beads && bd init",
-      selected: true
-    }
-  ],
-  productivity: [
-    {
-      id: "claude-md",
-      name: "CLAUDE.md",
-      type: "config",
-      description: "Project context file",
-      configPath: "CLAUDE.md",
-      configContent: `# Project Instructions
-
-## Build & Test Commands
-\`\`\`bash
-bun test           # Run tests
-bun run build      # Build project
-bun run lint       # Run linter
-\`\`\`
-
-## Architecture
-Describe your project structure here.
-
-## Conventions
-- Use TypeScript
-- Write tests for new features
-- Use conventional commits
-`,
-      selected: true
-    },
-    {
-      id: "vitest",
-      name: "Vitest",
-      type: "library",
-      description: "Fast unit testing framework",
-      installCommand: "bun add -D vitest",
-      selected: true
-    }
-  ]
-};
-
-// ../../node_modules/ora/index.js
-import process8 from "node:process";
-import { stripVTControlCharacters } from "node:util";
-
-// ../../node_modules/chalk/source/vendor/ansi-styles/index.js
-var ANSI_BACKGROUND_OFFSET = 10;
-var wrapAnsi16 = (offset = 0) => (code2) => `\x1B[${code2 + offset}m`;
-var wrapAnsi256 = (offset = 0) => (code2) => `\x1B[${38 + offset};5;${code2}m`;
-var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
-var styles = {
-  modifier: {
-    reset: [0, 0],
-    bold: [1, 22],
-    dim: [2, 22],
-    italic: [3, 23],
-    underline: [4, 24],
-    overline: [53, 55],
-    inverse: [7, 27],
-    hidden: [8, 28],
-    strikethrough: [9, 29]
-  },
-  color: {
-    black: [30, 39],
-    red: [31, 39],
-    green: [32, 39],
-    yellow: [33, 39],
-    blue: [34, 39],
-    magenta: [35, 39],
-    cyan: [36, 39],
-    white: [37, 39],
-    blackBright: [90, 39],
-    gray: [90, 39],
-    grey: [90, 39],
-    redBright: [91, 39],
-    greenBright: [92, 39],
-    yellowBright: [93, 39],
-    blueBright: [94, 39],
-    magentaBright: [95, 39],
-    cyanBright: [96, 39],
-    whiteBright: [97, 39]
-  },
-  bgColor: {
-    bgBlack: [40, 49],
-    bgRed: [41, 49],
-    bgGreen: [42, 49],
-    bgYellow: [43, 49],
-    bgBlue: [44, 49],
-    bgMagenta: [45, 49],
-    bgCyan: [46, 49],
-    bgWhite: [47, 49],
-    bgBlackBright: [100, 49],
-    bgGray: [100, 49],
-    bgGrey: [100, 49],
-    bgRedBright: [101, 49],
-    bgGreenBright: [102, 49],
-    bgYellowBright: [103, 49],
-    bgBlueBright: [104, 49],
-    bgMagentaBright: [105, 49],
-    bgCyanBright: [106, 49],
-    bgWhiteBright: [107, 49]
-  }
-};
-var modifierNames = Object.keys(styles.modifier);
-var foregroundColorNames = Object.keys(styles.color);
-var backgroundColorNames = Object.keys(styles.bgColor);
-var colorNames = [...foregroundColorNames, ...backgroundColorNames];
-function assembleStyles() {
-  const codes = new Map;
-  for (const [groupName, group] of Object.entries(styles)) {
-    for (const [styleName, style] of Object.entries(group)) {
-      styles[styleName] = {
-        open: `\x1B[${style[0]}m`,
-        close: `\x1B[${style[1]}m`
-      };
-      group[styleName] = styles[styleName];
-      codes.set(style[0], style[1]);
-    }
-    Object.defineProperty(styles, groupName, {
-      value: group,
-      enumerable: false
-    });
-  }
-  Object.defineProperty(styles, "codes", {
-    value: codes,
-    enumerable: false
-  });
-  styles.color.close = "\x1B[39m";
-  styles.bgColor.close = "\x1B[49m";
-  styles.color.ansi = wrapAnsi16();
-  styles.color.ansi256 = wrapAnsi256();
-  styles.color.ansi16m = wrapAnsi16m();
-  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
-  Object.defineProperties(styles, {
-    rgbToAnsi256: {
-      value(red, green, blue) {
-        if (red === green && green === blue) {
-          if (red < 8) {
-            return 16;
-          }
-          if (red > 248) {
-            return 231;
-          }
-          return Math.round((red - 8) / 247 * 24) + 232;
-        }
-        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
-      },
-      enumerable: false
-    },
-    hexToRgb: {
-      value(hex) {
-        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
-        if (!matches) {
-          return [0, 0, 0];
-        }
-        let [colorString] = matches;
-        if (colorString.length === 3) {
-          colorString = [...colorString].map((character) => character + character).join("");
-        }
-        const integer = Number.parseInt(colorString, 16);
-        return [
-          integer >> 16 & 255,
-          integer >> 8 & 255,
-          integer & 255
-        ];
-      },
-      enumerable: false
-    },
-    hexToAnsi256: {
-      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
-      enumerable: false
-    },
-    ansi256ToAnsi: {
-      value(code2) {
-        if (code2 < 8) {
-          return 30 + code2;
-        }
-        if (code2 < 16) {
-          return 90 + (code2 - 8);
-        }
-        let red;
-        let green;
-        let blue;
-        if (code2 >= 232) {
-          red = ((code2 - 232) * 10 + 8) / 255;
-          green = red;
-          blue = red;
-        } else {
-          code2 -= 16;
-          const remainder = code2 % 36;
-          red = Math.floor(code2 / 36) / 5;
-          green = Math.floor(remainder / 6) / 5;
-          blue = remainder % 6 / 5;
-        }
-        const value = Math.max(red, green, blue) * 2;
-        if (value === 0) {
-          return 30;
-        }
-        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
-        if (value === 2) {
-          result += 60;
-        }
-        return result;
-      },
-      enumerable: false
-    },
-    rgbToAnsi: {
-      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
-      enumerable: false
-    },
-    hexToAnsi: {
-      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
-      enumerable: false
-    }
-  });
-  return styles;
-}
-var ansiStyles = assembleStyles();
-var ansi_styles_default = ansiStyles;
-
-// ../../node_modules/chalk/source/vendor/supports-color/index.js
-import process2 from "node:process";
-import os from "node:os";
-import tty2 from "node:tty";
-function hasFlag(flag, argv2 = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
-  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
-  const position = argv2.indexOf(prefix + flag);
-  const terminatorPosition = argv2.indexOf("--");
-  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
-}
-var { env: env2 } = process2;
-var flagForceColor;
-if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-  flagForceColor = 0;
-} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-  flagForceColor = 1;
-}
-function envForceColor() {
-  if ("FORCE_COLOR" in env2) {
-    if (env2.FORCE_COLOR === "true") {
-      return 1;
-    }
-    if (env2.FORCE_COLOR === "false") {
-      return 0;
-    }
-    return env2.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env2.FORCE_COLOR, 10), 3);
-  }
-}
-function translateLevel(level) {
-  if (level === 0) {
-    return false;
-  }
-  return {
-    level,
-    hasBasic: true,
-    has256: level >= 2,
-    has16m: level >= 3
-  };
-}
-function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
-  const noFlagForceColor = envForceColor();
-  if (noFlagForceColor !== undefined) {
-    flagForceColor = noFlagForceColor;
-  }
-  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
-  if (forceColor === 0) {
-    return 0;
-  }
-  if (sniffFlags) {
-    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-      return 3;
-    }
-    if (hasFlag("color=256")) {
-      return 2;
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
     }
   }
   if ("TF_BUILD" in env2 && "AGENT_NAME" in env2) {
@@ -14878,394 +14472,1290 @@ class Ora {
 `)) {
       count += Math.max(1, Math.ceil(stringWidth2(line) / columns));
     }
-    return count;
-  }
-  get isEnabled() {
-    return this.#options.isEnabled && !this.#options.isSilent;
+    return count;
+  }
+  get isEnabled() {
+    return this.#options.isEnabled && !this.#options.isSilent;
+  }
+  set isEnabled(value) {
+    if (typeof value !== "boolean") {
+      throw new TypeError("The `isEnabled` option must be a boolean");
+    }
+    this.#options.isEnabled = value;
+  }
+  get isSilent() {
+    return this.#options.isSilent;
+  }
+  set isSilent(value) {
+    if (typeof value !== "boolean") {
+      throw new TypeError("The `isSilent` option must be a boolean");
+    }
+    this.#options.isSilent = value;
+  }
+  frame() {
+    const now = Date.now();
+    if (this.#frameIndex === -1 || now - this.#lastFrameTime >= this.interval) {
+      this.#frameIndex = (this.#frameIndex + 1) % this.#spinner.frames.length;
+      this.#lastFrameTime = now;
+    }
+    const { frames } = this.#spinner;
+    let frame = frames[this.#frameIndex];
+    if (this.color) {
+      frame = source_default[this.color](frame);
+    }
+    const fullPrefixText = this.#getFullPrefixText(this.#options.prefixText, " ");
+    const fullText = typeof this.text === "string" ? " " + this.text : "";
+    const fullSuffixText = this.#getFullSuffixText(this.#options.suffixText, " ");
+    return fullPrefixText + frame + fullText + fullSuffixText;
+  }
+  clear() {
+    if (!this.isEnabled || !this.#stream.isTTY) {
+      return this;
+    }
+    this.#internalWrite(() => {
+      this.#stream.cursorTo(0);
+      for (let index = 0;index < this.#linesToClear; index++) {
+        if (index > 0) {
+          this.#stream.moveCursor(0, -1);
+        }
+        this.#stream.clearLine(1);
+      }
+      if (this.#options.indent) {
+        this.#stream.cursorTo(this.#options.indent);
+      }
+    });
+    this.#linesToClear = 0;
+    return this;
+  }
+  #hookStream(stream) {
+    if (!stream || this.#hookedStreams.has(stream) || !stream.isTTY || typeof stream.write !== "function") {
+      return;
+    }
+    if (activeHooksPerStream.has(stream)) {
+      console.warn("[ora] Multiple concurrent spinners detected. This may cause visual corruption. Use one spinner at a time.");
+    }
+    const originalWrite = stream.write;
+    this.#hookedStreams.set(stream, originalWrite);
+    activeHooksPerStream.set(stream, this);
+    stream.write = (chunk, encoding, callback) => this.#hookedWrite(stream, originalWrite, chunk, encoding, callback);
+  }
+  #installHook() {
+    if (!this.isEnabled || this.#hookedStreams.size > 0) {
+      return;
+    }
+    const streamsToHook = new Set([this.#stream, process8.stdout, process8.stderr]);
+    for (const stream of streamsToHook) {
+      this.#hookStream(stream);
+    }
+  }
+  #uninstallHook() {
+    for (const [stream, originalWrite] of this.#hookedStreams) {
+      stream.write = originalWrite;
+      if (activeHooksPerStream.get(stream) === this) {
+        activeHooksPerStream.delete(stream);
+      }
+    }
+    this.#hookedStreams.clear();
+  }
+  #hookedWrite(stream, originalWrite, chunk, encoding, callback) {
+    if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = undefined;
+    }
+    if (this.#isInternalWrite) {
+      return originalWrite.call(stream, chunk, encoding, callback);
+    }
+    this.clear();
+    const chunkString = this.#stringifyChunk(chunk, encoding);
+    const chunkTerminatesLine = this.#chunkTerminatesLine(chunkString);
+    const writeResult = originalWrite.call(stream, chunk, encoding, callback);
+    if (chunkTerminatesLine) {
+      this.#clearRenderDeferral();
+    } else if (chunkString.length > 0) {
+      this.#scheduleRenderDeferral();
+    }
+    if (this.isSpinning && !this.#deferRenderTimer) {
+      this.render();
+    }
+    return writeResult;
+  }
+  render() {
+    if (!this.isEnabled || this.#drainHandler || this.#deferRenderTimer) {
+      return this;
+    }
+    const useSynchronizedOutput = this.#stream.isTTY;
+    let shouldDisableSynchronizedOutput = false;
+    try {
+      if (useSynchronizedOutput) {
+        this.#internalWrite(() => this.#stream.write(SYNCHRONIZED_OUTPUT_ENABLE));
+        shouldDisableSynchronizedOutput = true;
+      }
+      this.clear();
+      let frameContent = this.frame();
+      const columns = this.#stream.columns ?? 80;
+      const actualLineCount = this.#computeLineCountFrom(frameContent, columns);
+      const consoleHeight = this.#stream.rows;
+      if (consoleHeight && consoleHeight > 1 && actualLineCount > consoleHeight) {
+        const lines = frameContent.split(`
+`);
+        const maxLines = consoleHeight - 1;
+        frameContent = [...lines.slice(0, maxLines), "... (content truncated to fit terminal)"].join(`
+`);
+      }
+      const canContinue = this.#internalWrite(() => this.#stream.write(frameContent));
+      if (canContinue === false && this.#stream.isTTY) {
+        this.#drainHandler = () => {
+          this.#drainHandler = undefined;
+          this.#tryRender();
+        };
+        this.#stream.once("drain", this.#drainHandler);
+      }
+      this.#linesToClear = this.#computeLineCountFrom(frameContent, columns);
+    } finally {
+      if (shouldDisableSynchronizedOutput) {
+        this.#internalWrite(() => this.#stream.write(SYNCHRONIZED_OUTPUT_DISABLE));
+      }
+    }
+    return this;
+  }
+  start(text) {
+    if (text) {
+      this.text = text;
+    }
+    if (this.isSilent) {
+      return this;
+    }
+    if (!this.isEnabled) {
+      const symbol = this.text ? "-" : "";
+      const line = " ".repeat(this.#options.indent) + this.#buildOutputLine(symbol, this.text, this.#options.prefixText, this.#options.suffixText);
+      if (line.trim() !== "") {
+        this.#internalWrite(() => this.#stream.write(line + `
+`));
+      }
+      return this;
+    }
+    if (this.isSpinning) {
+      return this;
+    }
+    if (this.#options.hideCursor) {
+      cli_cursor_default.hide(this.#stream);
+    }
+    if (this.#options.discardStdin && process8.stdin.isTTY) {
+      stdin_discarder_default.start();
+      this.#isDiscardingStdin = true;
+    }
+    this.#installHook();
+    this.render();
+    this.#id = setInterval(this.render.bind(this), this.interval);
+    return this;
   }
-  set isEnabled(value) {
-    if (typeof value !== "boolean") {
-      throw new TypeError("The `isEnabled` option must be a boolean");
+  stop() {
+    clearInterval(this.#id);
+    this.#id = undefined;
+    this.#frameIndex = -1;
+    this.#lastFrameTime = 0;
+    this.#clearRenderDeferral();
+    this.#uninstallHook();
+    if (this.#drainHandler) {
+      this.#stream.removeListener("drain", this.#drainHandler);
+      this.#drainHandler = undefined;
     }
-    this.#options.isEnabled = value;
+    if (this.isEnabled) {
+      this.clear();
+      if (this.#options.hideCursor) {
+        cli_cursor_default.show(this.#stream);
+      }
+    }
+    if (this.#isDiscardingStdin) {
+      this.#isDiscardingStdin = false;
+      stdin_discarder_default.stop();
+    }
+    return this;
   }
-  get isSilent() {
-    return this.#options.isSilent;
+  succeed(text) {
+    return this.stopAndPersist({ symbol: exports_symbols.success, text });
   }
-  set isSilent(value) {
-    if (typeof value !== "boolean") {
-      throw new TypeError("The `isSilent` option must be a boolean");
-    }
-    this.#options.isSilent = value;
+  fail(text) {
+    return this.stopAndPersist({ symbol: exports_symbols.error, text });
   }
-  frame() {
-    const now = Date.now();
-    if (this.#frameIndex === -1 || now - this.#lastFrameTime >= this.interval) {
-      this.#frameIndex = (this.#frameIndex + 1) % this.#spinner.frames.length;
-      this.#lastFrameTime = now;
-    }
-    const { frames } = this.#spinner;
-    let frame = frames[this.#frameIndex];
-    if (this.color) {
-      frame = source_default[this.color](frame);
-    }
-    const fullPrefixText = this.#getFullPrefixText(this.#options.prefixText, " ");
-    const fullText = typeof this.text === "string" ? " " + this.text : "";
-    const fullSuffixText = this.#getFullSuffixText(this.#options.suffixText, " ");
-    return fullPrefixText + frame + fullText + fullSuffixText;
+  warn(text) {
+    return this.stopAndPersist({ symbol: exports_symbols.warning, text });
   }
-  clear() {
-    if (!this.isEnabled || !this.#stream.isTTY) {
+  info(text) {
+    return this.stopAndPersist({ symbol: exports_symbols.info, text });
+  }
+  stopAndPersist(options = {}) {
+    if (this.isSilent) {
       return this;
     }
-    this.#internalWrite(() => {
-      this.#stream.cursorTo(0);
-      for (let index = 0;index < this.#linesToClear; index++) {
-        if (index > 0) {
-          this.#stream.moveCursor(0, -1);
-        }
-        this.#stream.clearLine(1);
-      }
-      if (this.#options.indent) {
-        this.#stream.cursorTo(this.#options.indent);
-      }
-    });
-    this.#linesToClear = 0;
+    const symbol = options.symbol ?? " ";
+    const text = options.text ?? this.text;
+    const prefixText = options.prefixText ?? this.#options.prefixText;
+    const suffixText = options.suffixText ?? this.#options.suffixText;
+    const textToWrite = this.#buildOutputLine(symbol, text, prefixText, suffixText) + `
+`;
+    this.stop();
+    this.#internalWrite(() => this.#stream.write(textToWrite));
     return this;
   }
-  #hookStream(stream) {
-    if (!stream || this.#hookedStreams.has(stream) || !stream.isTTY || typeof stream.write !== "function") {
-      return;
+}
+function ora(options) {
+  return new Ora(options);
+}
+
+// src/lib/ui.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+import * as readline from "readline";
+var colors2 = {
+  primary: import_picocolors.default.cyan,
+  secondary: import_picocolors.default.blue,
+  accent: import_picocolors.default.magenta,
+  success: import_picocolors.default.green,
+  warning: import_picocolors.default.yellow,
+  error: import_picocolors.default.red,
+  info: import_picocolors.default.blue,
+  dim: import_picocolors.default.dim,
+  bold: import_picocolors.default.bold,
+  italic: import_picocolors.default.italic,
+  excellent: import_picocolors.default.green,
+  good: import_picocolors.default.cyan,
+  moderate: import_picocolors.default.yellow,
+  poor: import_picocolors.default.red,
+  highlight: (text) => import_picocolors.default.bold(import_picocolors.default.cyan(text)),
+  muted: (text) => import_picocolors.default.dim(import_picocolors.default.gray(text)),
+  link: (text) => import_picocolors.default.underline(import_picocolors.default.blue(text))
+};
+function createSpinner(text) {
+  return ora({
+    text,
+    spinner: "dots",
+    color: "cyan"
+  });
+}
+function formatTier(tier) {
+  const tierColors = {
+    elite: (s2) => import_picocolors.default.bold(import_picocolors.default.magenta(s2)),
+    expert: (s2) => import_picocolors.default.bold(import_picocolors.default.cyan(s2)),
+    advanced: (s2) => import_picocolors.default.bold(import_picocolors.default.green(s2)),
+    proficient: (s2) => import_picocolors.default.blue(s2),
+    intermediate: (s2) => import_picocolors.default.yellow(s2),
+    developing: (s2) => import_picocolors.default.dim(s2)
+  };
+  const colorFn = tierColors[tier.toLowerCase()] ?? colors2.dim;
+  return colorFn(tier.charAt(0).toUpperCase() + tier.slice(1));
+}
+var icons = {
+  success: colors2.success("✔"),
+  error: colors2.error("✖"),
+  warning: colors2.warning("⚠"),
+  info: colors2.info("ℹ"),
+  arrow: colors2.primary("→"),
+  bullet: colors2.dim("•"),
+  star: colors2.warning("★"),
+  check: colors2.success("✓"),
+  cross: colors2.error("✗"),
+  pending: colors2.dim("○"),
+  lightning: "⚡",
+  fire: "\uD83D\uDD25",
+  rocket: "\uD83D\uDE80",
+  chart: "\uD83D\uDCCA",
+  money: "\uD83D\uDCB0",
+  brain: "\uD83E\uDDE0",
+  target: "\uD83C\uDFAF"
+};
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function clearLine2() {
+  readline.clearLine(process.stdout, 0);
+  readline.cursorTo(process.stdout, 0);
+}
+function write(text) {
+  process.stdout.write(text);
+}
+async function animateProgressBar(label, score, options = {}) {
+  const { width = 20, charDelay = 40, labelWidth = 20 } = options;
+  const filled = Math.round(score / 100 * width);
+  let barColor = colors2.excellent;
+  if (score < 40)
+    barColor = colors2.poor;
+  else if (score < 60)
+    barColor = colors2.moderate;
+  else if (score < 75)
+    barColor = colors2.good;
+  const paddedLabel = label.padEnd(labelWidth);
+  const scoreStr = `${score}/100`.padStart(7);
+  write(`  ${colors2.dim(paddedLabel)} ${colors2.dim(scoreStr)}  `);
+  for (let i3 = 0;i3 < width; i3++) {
+    if (i3 < filled) {
+      write(barColor("█"));
+    } else {
+      write(colors2.dim("░"));
     }
-    if (activeHooksPerStream.has(stream)) {
-      console.warn("[ora] Multiple concurrent spinners detected. This may cause visual corruption. Use one spinner at a time.");
+    await sleep(charDelay);
+  }
+  console.log();
+}
+async function thinkingStep(thinkingText, duration = 800, successText) {
+  const spinner = createSpinner(thinkingText);
+  spinner.start();
+  await sleep(duration);
+  spinner.succeed(successText ?? thinkingText);
+}
+async function revealDiscovery(icon, text, delay2 = 300) {
+  await sleep(delay2);
+  console.log(`  ${icon} ${text}`);
+}
+async function showPhaseHeader(phase, total, title, delay2 = 400) {
+  await sleep(delay2);
+  console.log();
+  console.log(`  ${colors2.dim(`Phase ${phase}/${total}:`)} ${colors2.bold(colors2.primary(title))}`);
+  console.log(colors2.dim("  " + "─".repeat(40)));
+}
+async function animateScoreReveal(score, tier, options = {}) {
+  const { countDuration = 1000, barDelay = 50 } = options;
+  const scoreColor = score >= 80 ? colors2.excellent : score >= 60 ? colors2.good : score >= 40 ? colors2.moderate : colors2.poor;
+  console.log();
+  console.log(colors2.dim("  " + "═".repeat(45)));
+  console.log();
+  const steps = 30;
+  const stepDuration = countDuration / steps;
+  for (let i3 = 1;i3 <= steps; i3++) {
+    const current = Math.round(i3 / steps * score);
+    clearLine2();
+    write(`  ${colors2.bold("Your Score:")} ${scoreColor(colors2.bold(current.toString()))}/100`);
+    await sleep(stepDuration);
+  }
+  write(`  ${colors2.dim("(")}${formatTier(tier)}${colors2.dim(")")}`);
+  console.log();
+  console.log();
+  const barWidth = 30;
+  const filled = Math.round(score / 100 * barWidth);
+  write("  ");
+  for (let i3 = 0;i3 < barWidth; i3++) {
+    if (i3 < filled) {
+      write(scoreColor("█"));
+    } else {
+      write(colors2.dim("░"));
     }
-    const originalWrite = stream.write;
-    this.#hookedStreams.set(stream, originalWrite);
-    activeHooksPerStream.set(stream, this);
-    stream.write = (chunk, encoding, callback) => this.#hookedWrite(stream, originalWrite, chunk, encoding, callback);
+    await sleep(barDelay);
   }
-  #installHook() {
-    if (!this.isEnabled || this.#hookedStreams.size > 0) {
-      return;
+  console.log();
+  console.log();
+  console.log(colors2.dim("  " + "═".repeat(45)));
+}
+async function showFinding(type, label, value, unit = "", delay2 = 250) {
+  await sleep(delay2);
+  const iconMap = {
+    warning: icons.warning,
+    error: icons.error,
+    info: icons.info,
+    success: icons.success
+  };
+  const colorMap = {
+    warning: colors2.warning,
+    error: colors2.error,
+    info: colors2.info,
+    success: colors2.success
+  };
+  const icon = iconMap[type];
+  const valueColor = colorMap[type];
+  console.log(`  ${icon} ${label}: ${valueColor(value.toString())}${unit}`);
+}
+
+// src/lib/frustration-detector.ts
+var ROOT_CAUSE_PATTERNS = {
+  hallucination: {
+    patterns: [
+      /doesn'?t exist/i,
+      /not a valid/i,
+      /no such (file|method|function|class|property|module)/i,
+      /wrong api/i,
+      /outdated/i,
+      /deprecated/i,
+      /that'?s not (how|the)/i,
+      /method doesn'?t/i,
+      /property doesn'?t/i,
+      /hallucinating/i,
+      /made up/i,
+      /invented/i,
+      /that method/i,
+      /wrong syntax/i
+    ],
+    description: "AI hallucinated non-existent API/method/syntax",
+    fix: {
+      tool: "Context7",
+      description: "Provides up-to-date library documentation to prevent hallucinations",
+      installCommand: "claude mcp add context7 https://mcp.context7.com/mcp --transport http",
+      estimatedImprovementPercent: 70
     }
-    const streamsToHook = new Set([this.#stream, process8.stdout, process8.stderr]);
-    for (const stream of streamsToHook) {
-      this.#hookStream(stream);
+  },
+  missing_docs: {
+    patterns: [
+      /how do (i|you)/i,
+      /what'?s the (syntax|api|method|way)/i,
+      /documentation/i,
+      /check the docs/i,
+      /look up/i,
+      /find the right/i,
+      /correct (api|method|syntax)/i,
+      /which (api|method|function)/i
+    ],
+    description: "Needed documentation that AI didn't have access to",
+    fix: {
+      tool: "Context7",
+      description: "Live documentation lookup prevents outdated information",
+      installCommand: "claude mcp add context7 https://mcp.context7.com/mcp --transport http",
+      estimatedImprovementPercent: 65
     }
-  }
-  #uninstallHook() {
-    for (const [stream, originalWrite] of this.#hookedStreams) {
-      stream.write = originalWrite;
-      if (activeHooksPerStream.get(stream) === this) {
-        activeHooksPerStream.delete(stream);
-      }
+  },
+  context_loss: {
+    patterns: [
+      /i already told you/i,
+      /as i (said|mentioned)/i,
+      /we discussed/i,
+      /you forgot/i,
+      /remember/i,
+      /i explained/i,
+      /sessions ago/i,
+      /previously/i,
+      /earlier/i,
+      /context/i,
+      /last time/i,
+      /before/i
+    ],
+    description: "AI forgot previously established context",
+    fix: {
+      tool: "Supermemory",
+      description: "Persistent memory across sessions prevents context loss",
+      installCommand: "claude mcp add supermemory -- npx -y @supermemory/mcp@latest",
+      estimatedImprovementPercent: 80
     }
-    this.#hookedStreams.clear();
-  }
-  #hookedWrite(stream, originalWrite, chunk, encoding, callback) {
-    if (typeof encoding === "function") {
-      callback = encoding;
-      encoding = undefined;
+  },
+  unclear_prompt: {
+    patterns: [
+      /what do you mean/i,
+      /clarify/i,
+      /specify/i,
+      /more (details|context|information)/i,
+      /not sure what/i,
+      /which (file|one|version)/i,
+      /be more specific/i
+    ],
+    description: "Prompt was unclear, leading to misunderstanding",
+    fix: {
+      tool: "Writing Plans Skill",
+      description: "Helps write clearer, more structured prompts",
+      installCommand: "npx skills add obra/superpowers@writing-plans --yes",
+      estimatedImprovementPercent: 50
     }
-    if (this.#isInternalWrite) {
-      return originalWrite.call(stream, chunk, encoding, callback);
+  },
+  tool_failure: {
+    patterns: [
+      /tool failed/i,
+      /mcp error/i,
+      /error executing/i,
+      /command failed/i,
+      /couldn'?t run/i,
+      /failed to/i,
+      /error:/i,
+      /exception/i
+    ],
+    description: "Tool or MCP server failed to execute",
+    fix: {
+      tool: "MCP Doctor",
+      description: "Fix MCP configuration issues",
+      installCommand: "claude doctor && claude mcp list",
+      estimatedImprovementPercent: 40
     }
-    this.clear();
-    const chunkString = this.#stringifyChunk(chunk, encoding);
-    const chunkTerminatesLine = this.#chunkTerminatesLine(chunkString);
-    const writeResult = originalWrite.call(stream, chunk, encoding, callback);
-    if (chunkTerminatesLine) {
-      this.#clearRenderDeferral();
-    } else if (chunkString.length > 0) {
-      this.#scheduleRenderDeferral();
+  },
+  undo_loop: {
+    patterns: [
+      /undo/i,
+      /revert/i,
+      /go back/i,
+      /try again/i,
+      /start over/i,
+      /that'?s wrong/i,
+      /not what i wanted/i,
+      /roll back/i,
+      /put it back/i,
+      /restore/i,
+      /wrong/i
+    ],
+    description: "Got stuck in undo/redo loop from incorrect changes",
+    fix: {
+      tool: "Systematic Debugging Skill",
+      description: "Structured approach to fixing issues without loops",
+      installCommand: "npx skills add obra/superpowers@systematic-debugging --yes",
+      estimatedImprovementPercent: 55
     }
-    if (this.isSpinning && !this.#deferRenderTimer) {
-      this.render();
+  }
+};
+function detectFrustrations(sessions) {
+  const frustrations = [];
+  for (const session of sessions) {
+    const frustrationPatterns = session.patterns.filter((p) => p.type !== "smooth_flow" && p.type !== "long_back_forth");
+    if (frustrationPatterns.length === 0)
+      continue;
+    const sessionPath = findSessionPath(session.sessionId, session.agent);
+    const exactPrompts = sessionPath ? extractFrustrationPrompts(sessionPath, frustrationPatterns) : [];
+    for (let i3 = 0;i3 < frustrationPatterns.length; i3++) {
+      const pattern = frustrationPatterns[i3];
+      const exactPrompt = exactPrompts[i3] || "(Unable to extract prompt from session file)";
+      const rootCause = analyzeRootCause(exactPrompt, pattern.type);
+      const timeWasted = Math.round(pattern.estimatedWastedTokens / 1000);
+      const costWasted = pattern.estimatedWastedTokens * 0.000015;
+      frustrations.push({
+        sessionId: session.sessionId,
+        sessionPath: sessionPath || `${session.agent}/${session.sessionId}`,
+        agent: session.agent,
+        timestamp: session.startedAt,
+        exactPrompt: exactPrompt.slice(0, 500),
+        promptTruncated: exactPrompt.length > 500,
+        patternType: pattern.type,
+        patternDescription: getPatternDescription(pattern.type),
+        rootCause,
+        estimatedTimeWastedMinutes: timeWasted,
+        estimatedTokensWasted: pattern.estimatedWastedTokens,
+        estimatedCostWasted: Math.round(costWasted * 100) / 100,
+        recommendedFix: getRecommendedFix(rootCause.category)
+      });
     }
-    return writeResult;
   }
-  render() {
-    if (!this.isEnabled || this.#drainHandler || this.#deferRenderTimer) {
-      return this;
+  frustrations.sort((a2, b2) => b2.estimatedTimeWastedMinutes - a2.estimatedTimeWastedMinutes);
+  const totalTimeWasted = frustrations.reduce((a2, f3) => a2 + f3.estimatedTimeWastedMinutes, 0);
+  const totalTokensWasted = frustrations.reduce((a2, f3) => a2 + f3.estimatedTokensWasted, 0);
+  const totalCostWasted = frustrations.reduce((a2, f3) => a2 + f3.estimatedCostWasted, 0);
+  const byRootCause = {};
+  for (const f3 of frustrations) {
+    byRootCause[f3.rootCause.category] = (byRootCause[f3.rootCause.category] || 0) + 1;
+  }
+  const recommendations = aggregateRecommendations(frustrations);
+  return {
+    totalFrustrations: frustrations.length,
+    totalTimeWastedMinutes: totalTimeWasted,
+    totalTokensWasted,
+    totalCostWasted: Math.round(totalCostWasted * 100) / 100,
+    byRootCause,
+    topFrustrations: frustrations.slice(0, 5),
+    recommendations
+  };
+}
+function findSessionPath(sessionId, agent) {
+  const home = homedir6();
+  if (agent === "claude") {
+    const projectsDir = join7(home, ".claude", "projects");
+    if (!existsSync7(projectsDir))
+      return null;
+    try {
+      const projectDirs = fsReaddirSync(projectsDir, { withFileTypes: true }).filter((d2) => d2.isDirectory()).map((d2) => join7(projectsDir, d2.name));
+      for (const projectDir of projectDirs) {
+        const sessionFile = join7(projectDir, `${sessionId}.jsonl`);
+        if (existsSync7(sessionFile)) {
+          return sessionFile;
+        }
+      }
+    } catch {
+      return null;
     }
-    const useSynchronizedOutput = this.#stream.isTTY;
-    let shouldDisableSynchronizedOutput = false;
+  }
+  if (agent === "opencode") {
+    const baseDir = join7(home, ".local", "share", "opencode", "storage", "session");
+    if (!existsSync7(baseDir))
+      return null;
     try {
-      if (useSynchronizedOutput) {
-        this.#internalWrite(() => this.#stream.write(SYNCHRONIZED_OUTPUT_ENABLE));
-        shouldDisableSynchronizedOutput = true;
+      const projectDirs = fsReaddirSync(baseDir, { withFileTypes: true }).filter((d2) => d2.isDirectory()).map((d2) => join7(baseDir, d2.name));
+      for (const projectDir of projectDirs) {
+        const sessionFile = join7(projectDir, `${sessionId}.json`);
+        if (existsSync7(sessionFile)) {
+          return sessionFile;
+        }
       }
-      this.clear();
-      let frameContent = this.frame();
-      const columns = this.#stream.columns ?? 80;
-      const actualLineCount = this.#computeLineCountFrom(frameContent, columns);
-      const consoleHeight = this.#stream.rows;
-      if (consoleHeight && consoleHeight > 1 && actualLineCount > consoleHeight) {
-        const lines = frameContent.split(`
-`);
-        const maxLines = consoleHeight - 1;
-        frameContent = [...lines.slice(0, maxLines), "... (content truncated to fit terminal)"].join(`
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function extractFrustrationPrompts(sessionPath, patterns) {
+  try {
+    const content = readFileSync7(sessionPath, "utf-8");
+    const prompts = [];
+    if (sessionPath.endsWith(".jsonl")) {
+      const lines = content.trim().split(`
 `);
+      const messages = [];
+      for (const line of lines) {
+        try {
+          messages.push(JSON.parse(line));
+        } catch {}
       }
-      const canContinue = this.#internalWrite(() => this.#stream.write(frameContent));
-      if (canContinue === false && this.#stream.isTTY) {
-        this.#drainHandler = () => {
-          this.#drainHandler = undefined;
-          this.#tryRender();
-        };
-        this.#stream.once("drain", this.#drainHandler);
+      const userMessages = messages.map((m2, i3) => ({ msg: m2, index: i3 })).filter((m2) => {
+        const role = m2.msg.role ?? m2.msg.message?.role;
+        return role === "user";
+      });
+      for (const pattern of patterns) {
+        if (pattern.messageIndices && pattern.messageIndices.length > 0) {
+          const idx = pattern.messageIndices[0];
+          const userMsg = userMessages.find((m2) => m2.index === idx);
+          if (userMsg) {
+            const text = extractMessageText(userMsg.msg);
+            prompts.push(text);
+          } else {
+            const frustrationMsg = findFrustrationMessage(userMessages.map((m2) => extractMessageText(m2.msg)));
+            prompts.push(frustrationMsg || "");
+          }
+        } else {
+          const frustrationMsg = findFrustrationMessage(userMessages.map((m2) => extractMessageText(m2.msg)));
+          prompts.push(frustrationMsg || "");
+        }
       }
-      this.#linesToClear = this.#computeLineCountFrom(frameContent, columns);
-    } finally {
-      if (shouldDisableSynchronizedOutput) {
-        this.#internalWrite(() => this.#stream.write(SYNCHRONIZED_OUTPUT_DISABLE));
+    } else if (sessionPath.endsWith(".json")) {
+      for (const _3 of patterns) {
+        prompts.push("");
       }
     }
-    return this;
+    return prompts;
+  } catch {
+    return [];
   }
-  start(text) {
-    if (text) {
-      this.text = text;
+}
+function extractMessageText(msg) {
+  if (typeof msg.content === "string")
+    return msg.content;
+  if (Array.isArray(msg.content)) {
+    return msg.content.filter((c3) => c3.type === "text" && c3.text).map((c3) => c3.text).join(" ");
+  }
+  return "";
+}
+function findFrustrationMessage(messages) {
+  const frustrationIndicators = [
+    /[A-Z]{5,}/,
+    /!{2,}/,
+    /\?{2,}/,
+    /\b(ugh|argh|wtf|wrong|no|stop|don't|undo|revert)\b/i
+  ];
+  for (const msg of messages) {
+    for (const indicator of frustrationIndicators) {
+      if (indicator.test(msg)) {
+        return msg;
+      }
     }
-    if (this.isSilent) {
-      return this;
+  }
+  return null;
+}
+function analyzeRootCause(prompt2, patternType) {
+  if (patternType === "memory_loss") {
+    return {
+      category: "context_loss",
+      description: ROOT_CAUSE_PATTERNS.context_loss.description,
+      confidence: "high"
+    };
+  }
+  if (patternType === "undo_loop") {
+    for (const pattern of ROOT_CAUSE_PATTERNS.hallucination.patterns) {
+      if (pattern.test(prompt2)) {
+        return {
+          category: "hallucination",
+          description: ROOT_CAUSE_PATTERNS.hallucination.description,
+          confidence: "medium"
+        };
+      }
     }
-    if (!this.isEnabled) {
-      const symbol = this.text ? "-" : "";
-      const line = " ".repeat(this.#options.indent) + this.#buildOutputLine(symbol, this.text, this.#options.prefixText, this.#options.suffixText);
-      if (line.trim() !== "") {
-        this.#internalWrite(() => this.#stream.write(line + `
-`));
+    return {
+      category: "undo_loop",
+      description: ROOT_CAUSE_PATTERNS.undo_loop.description,
+      confidence: "high"
+    };
+  }
+  if (patternType === "tool_failure") {
+    return {
+      category: "tool_failure",
+      description: ROOT_CAUSE_PATTERNS.tool_failure.description,
+      confidence: "high"
+    };
+  }
+  for (const [category, config] of Object.entries(ROOT_CAUSE_PATTERNS)) {
+    for (const pattern of config.patterns) {
+      if (pattern.test(prompt2)) {
+        return {
+          category,
+          description: config.description,
+          confidence: "medium"
+        };
       }
-      return this;
     }
-    if (this.isSpinning) {
-      return this;
+  }
+  return {
+    category: "unknown",
+    description: "Unable to determine specific root cause",
+    confidence: "low"
+  };
+}
+function getRecommendedFix(category) {
+  const fixes = {
+    hallucination: ROOT_CAUSE_PATTERNS.hallucination.fix,
+    missing_docs: ROOT_CAUSE_PATTERNS.missing_docs.fix,
+    context_loss: ROOT_CAUSE_PATTERNS.context_loss.fix,
+    unclear_prompt: ROOT_CAUSE_PATTERNS.unclear_prompt.fix,
+    tool_failure: ROOT_CAUSE_PATTERNS.tool_failure.fix,
+    undo_loop: ROOT_CAUSE_PATTERNS.undo_loop.fix,
+    unknown: {
+      tool: "CLAUDE.md",
+      description: "Create project instructions to prevent common issues",
+      installCommand: `echo '# Project Instructions
+' > CLAUDE.md`,
+      estimatedImprovementPercent: 30
     }
-    if (this.#options.hideCursor) {
-      cli_cursor_default.hide(this.#stream);
+  };
+  return fixes[category];
+}
+function getPatternDescription(patternType) {
+  const descriptions = {
+    undo_loop: "Got stuck in undo/redo cycle",
+    memory_loss: "Had to re-explain context",
+    frustration_caps: "Expressed frustration (ALL CAPS)",
+    repeated_rephrasing: "Had to rephrase multiple times",
+    context_compaction: "Lost context due to compaction",
+    tool_failure: "Tool or MCP failed",
+    long_back_forth: "Excessive back-and-forth"
+  };
+  return descriptions[patternType] || patternType;
+}
+function aggregateRecommendations(frustrations) {
+  const byTool = {};
+  for (const f3 of frustrations) {
+    const key = f3.recommendedFix.tool;
+    if (!byTool[key]) {
+      byTool[key] = { count: 0, timeSaved: 0, costSaved: 0, fix: f3.recommendedFix };
     }
-    if (this.#options.discardStdin && process8.stdin.isTTY) {
-      stdin_discarder_default.start();
-      this.#isDiscardingStdin = true;
+    byTool[key].count++;
+    byTool[key].timeSaved += f3.estimatedTimeWastedMinutes * (f3.recommendedFix.estimatedImprovementPercent / 100);
+    byTool[key].costSaved += f3.estimatedCostWasted * (f3.recommendedFix.estimatedImprovementPercent / 100);
+  }
+  const recommendations = [];
+  for (const [tool, data] of Object.entries(byTool)) {
+    recommendations.push({
+      tool,
+      description: data.fix.description,
+      installCommand: data.fix.installCommand,
+      wouldHavePreventedCount: data.count,
+      estimatedTimeSavedMinutes: Math.round(data.timeSaved),
+      estimatedCostSaved: Math.round(data.costSaved * 100) / 100
+    });
+  }
+  recommendations.sort((a2, b2) => b2.estimatedTimeSavedMinutes - a2.estimatedTimeSavedMinutes);
+  return recommendations;
+}
+function formatFrustrationSummary(summary) {
+  const lines = [];
+  if (summary.totalFrustrations === 0) {
+    lines.push(`  ${icons.success} ${colors2.success("No frustration events detected!")}`);
+    return lines;
+  }
+  lines.push("");
+  lines.push(colors2.dim("  " + "═".repeat(50)));
+  lines.push(`  ${colors2.error("!")} ${colors2.bold("Frustration Analysis")}`);
+  lines.push(colors2.dim("  " + "═".repeat(50)));
+  lines.push("");
+  lines.push(`  ${colors2.bold("Summary:")}`);
+  lines.push(`    ${icons.warning} ${summary.totalFrustrations} frustration events detected`);
+  lines.push(`    ${colors2.dim(">")} ~${summary.totalTimeWastedMinutes} min wasted`);
+  lines.push(`    ${icons.money} ~$${summary.totalCostWasted.toFixed(2)} in tokens`);
+  lines.push("");
+  if (Object.keys(summary.byRootCause).length > 0) {
+    lines.push(`  ${colors2.bold("Root Causes:")}`);
+    for (const [cause, count] of Object.entries(summary.byRootCause)) {
+      const label = formatCauseLabel(cause);
+      lines.push(`    ${colors2.dim("•")} ${label}: ${count}x`);
     }
-    this.#installHook();
-    this.render();
-    this.#id = setInterval(this.render.bind(this), this.interval);
-    return this;
+    lines.push("");
   }
-  stop() {
-    clearInterval(this.#id);
-    this.#id = undefined;
-    this.#frameIndex = -1;
-    this.#lastFrameTime = 0;
-    this.#clearRenderDeferral();
-    this.#uninstallHook();
-    if (this.#drainHandler) {
-      this.#stream.removeListener("drain", this.#drainHandler);
-      this.#drainHandler = undefined;
+  if (summary.topFrustrations.length > 0) {
+    lines.push(`  ${colors2.bold("Top Frustrations:")}`);
+    lines.push("");
+    for (let i3 = 0;i3 < Math.min(3, summary.topFrustrations.length); i3++) {
+      const f3 = summary.topFrustrations[i3];
+      lines.push(...formatFrustrationEvent(f3, i3 + 1));
+      lines.push("");
     }
-    if (this.isEnabled) {
-      this.clear();
-      if (this.#options.hideCursor) {
-        cli_cursor_default.show(this.#stream);
-      }
+  }
+  if (summary.recommendations.length > 0) {
+    lines.push(`  ${colors2.bold(colors2.primary("Recommended Fixes:"))}`);
+    lines.push("");
+    for (const rec of summary.recommendations.slice(0, 3)) {
+      lines.push(`    ${colors2.success("+")} ${colors2.bold(rec.tool)}`);
+      lines.push(`      Would have prevented ${rec.wouldHavePreventedCount} issue${rec.wouldHavePreventedCount > 1 ? "s" : ""}`);
+      lines.push(`      Est. time saved: ${colors2.success(`~${rec.estimatedTimeSavedMinutes} min`)}`);
+      lines.push(`      ${colors2.dim("$")} ${colors2.primary(rec.installCommand)}`);
+      lines.push("");
     }
-    if (this.#isDiscardingStdin) {
-      this.#isDiscardingStdin = false;
-      stdin_discarder_default.stop();
+  }
+  lines.push(colors2.dim("  " + "═".repeat(50)));
+  return lines;
+}
+function formatFrustrationEvent(f3, index) {
+  const lines = [];
+  lines.push(`    ${colors2.warning(`${index}.`)} ${colors2.bold(f3.patternDescription)} ${colors2.dim(`(${f3.agent})`)}`);
+  lines.push(`       ${colors2.dim("Session:")} ${f3.sessionId.slice(0, 12)}...`);
+  lines.push(`       ${colors2.dim("Time wasted:")} ~${f3.estimatedTimeWastedMinutes} min`);
+  lines.push(`       ${colors2.dim("Cause:")} ${formatCauseLabel(f3.rootCause.category)}`);
+  if (f3.exactPrompt && f3.exactPrompt.length > 0 && !f3.exactPrompt.startsWith("(Unable")) {
+    lines.push("");
+    lines.push(`       ${colors2.dim("┌" + "─".repeat(40))}`);
+    const promptLines = wrapText(f3.exactPrompt, 38);
+    for (const line of promptLines.slice(0, 4)) {
+      lines.push(`       ${colors2.dim("│")} ${line}`);
+    }
+    if (promptLines.length > 4) {
+      lines.push(`       ${colors2.dim("│")} ${colors2.dim("...")}`);
+    }
+    lines.push(`       ${colors2.dim("└" + "─".repeat(40))}`);
+  }
+  lines.push("");
+  lines.push(`       ${colors2.success("Fix:")} ${f3.recommendedFix.tool}`);
+  lines.push(`       ${colors2.dim("$")} ${colors2.primary(f3.recommendedFix.installCommand)}`);
+  return lines;
+}
+function formatCauseLabel(cause) {
+  const labels = {
+    hallucination: colors2.error("API Hallucination"),
+    missing_docs: colors2.warning("Missing Docs"),
+    context_loss: colors2.warning("Context Loss"),
+    unclear_prompt: colors2.dim("Unclear Prompt"),
+    tool_failure: colors2.error("Tool Failure"),
+    undo_loop: colors2.warning("Undo Loop"),
+    unknown: colors2.dim("Unknown")
+  };
+  return labels[cause] || cause;
+}
+function wrapText(text, width) {
+  const words = text.split(/\s+/);
+  const lines = [];
+  let currentLine = "";
+  for (const word of words) {
+    if (currentLine.length + word.length + 1 <= width) {
+      currentLine += (currentLine ? " " : "") + word;
+    } else {
+      if (currentLine)
+        lines.push(currentLine);
+      currentLine = word.slice(0, width);
+    }
+  }
+  if (currentLine)
+    lines.push(currentLine);
+  return lines;
+}
+
+// src/lib/optimization-installer.ts
+import { execSync as execSync2, spawnSync } from "node:child_process";
+import { existsSync as existsSync8, writeFileSync as writeFileSync3, readFileSync as readFileSync8, mkdirSync as mkdirSync3, readdirSync as readdirSync4 } from "node:fs";
+import { join as join8 } from "node:path";
+import { homedir as homedir7 } from "node:os";
+async function installOptimizations(optimizations, projectDir, options = {}) {
+  const results = [];
+  for (const opt of optimizations) {
+    if (!opt.selected)
+      continue;
+    try {
+      const result = await installSingleOptimization(opt, projectDir, options);
+      results.push(result);
+    } catch (err) {
+      results.push({
+        id: opt.id,
+        name: opt.name,
+        success: false,
+        message: "Installation failed",
+        error: err instanceof Error ? err.message : String(err)
+      });
     }
-    return this;
   }
-  succeed(text) {
-    return this.stopAndPersist({ symbol: exports_symbols.success, text });
+  return results;
+}
+async function installSingleOptimization(opt, projectDir, options) {
+  if (options.dryRun) {
+    return {
+      id: opt.id,
+      name: opt.name,
+      success: true,
+      message: `[DRY RUN] Would install: ${opt.installCommand || opt.configPath || "unknown"}`
+    };
   }
-  fail(text) {
-    return this.stopAndPersist({ symbol: exports_symbols.error, text });
+  switch (opt.type) {
+    case "mcp":
+      return installMCP(opt, projectDir, options.agent);
+    case "skill":
+      return installSkill(opt);
+    case "config":
+      return installConfig(opt, projectDir);
+    case "hook":
+      return installHook(opt, projectDir);
+    default:
+      return {
+        id: opt.id,
+        name: opt.name,
+        success: false,
+        message: "Unknown optimization type"
+      };
   }
-  warn(text) {
-    return this.stopAndPersist({ symbol: exports_symbols.warning, text });
+}
+function installMCP(opt, projectDir, agent) {
+  if (opt.installCommand?.startsWith("claude mcp add")) {
+    try {
+      execSync2(opt.installCommand, {
+        encoding: "utf-8",
+        stdio: "pipe",
+        timeout: 60000
+      });
+      return {
+        id: opt.id,
+        name: opt.name,
+        success: true,
+        message: `Installed via: ${opt.installCommand}`
+      };
+    } catch (err) {}
   }
-  info(text) {
-    return this.stopAndPersist({ symbol: exports_symbols.info, text });
+  if (opt.id === "beads" || opt.name.toLowerCase().includes("beads")) {
+    try {
+      execSync2("bun add -g beads", { encoding: "utf-8", stdio: "pipe", timeout: 60000 });
+      execSync2("bd init", { cwd: projectDir, encoding: "utf-8", stdio: "pipe", timeout: 30000 });
+      return {
+        id: opt.id,
+        name: opt.name,
+        success: true,
+        message: "Installed Beads globally and initialized in project"
+      };
+    } catch (err) {
+      return {
+        id: opt.id,
+        name: opt.name,
+        success: false,
+        message: "Failed to install Beads",
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
   }
-  stopAndPersist(options = {}) {
-    if (this.isSilent) {
-      return this;
+  if (opt.installCommand) {
+    try {
+      execSync2(opt.installCommand, {
+        encoding: "utf-8",
+        stdio: "pipe",
+        timeout: 60000
+      });
+      return {
+        id: opt.id,
+        name: opt.name,
+        success: true,
+        message: `Installed via: ${opt.installCommand}`
+      };
+    } catch (err) {
+      return {
+        id: opt.id,
+        name: opt.name,
+        success: false,
+        message: "Failed to install MCP",
+        error: err instanceof Error ? err.message : String(err)
+      };
     }
-    const symbol = options.symbol ?? " ";
-    const text = options.text ?? this.text;
-    const prefixText = options.prefixText ?? this.#options.prefixText;
-    const suffixText = options.suffixText ?? this.#options.suffixText;
-    const textToWrite = this.#buildOutputLine(symbol, text, prefixText, suffixText) + `
-`;
-    this.stop();
-    this.#internalWrite(() => this.#stream.write(textToWrite));
-    return this;
   }
-}
-function ora(options) {
-  return new Ora(options);
-}
-
-// src/lib/ui.ts
-var import_picocolors = __toESM(require_picocolors(), 1);
-import * as readline from "readline";
-var colors2 = {
-  primary: import_picocolors.default.cyan,
-  secondary: import_picocolors.default.blue,
-  accent: import_picocolors.default.magenta,
-  success: import_picocolors.default.green,
-  warning: import_picocolors.default.yellow,
-  error: import_picocolors.default.red,
-  info: import_picocolors.default.blue,
-  dim: import_picocolors.default.dim,
-  bold: import_picocolors.default.bold,
-  italic: import_picocolors.default.italic,
-  excellent: import_picocolors.default.green,
-  good: import_picocolors.default.cyan,
-  moderate: import_picocolors.default.yellow,
-  poor: import_picocolors.default.red,
-  highlight: (text) => import_picocolors.default.bold(import_picocolors.default.cyan(text)),
-  muted: (text) => import_picocolors.default.dim(import_picocolors.default.gray(text)),
-  link: (text) => import_picocolors.default.underline(import_picocolors.default.blue(text))
-};
-function createSpinner(text) {
-  return ora({
-    text,
-    spinner: "dots",
-    color: "cyan"
-  });
-}
-function formatTier(tier) {
-  const tierColors = {
-    elite: (s2) => import_picocolors.default.bold(import_picocolors.default.magenta(s2)),
-    expert: (s2) => import_picocolors.default.bold(import_picocolors.default.cyan(s2)),
-    advanced: (s2) => import_picocolors.default.bold(import_picocolors.default.green(s2)),
-    proficient: (s2) => import_picocolors.default.blue(s2),
-    intermediate: (s2) => import_picocolors.default.yellow(s2),
-    developing: (s2) => import_picocolors.default.dim(s2)
+  return {
+    id: opt.id,
+    name: opt.name,
+    success: false,
+    message: "No install command available"
   };
-  const colorFn = tierColors[tier.toLowerCase()] ?? colors2.dim;
-  return colorFn(tier.charAt(0).toUpperCase() + tier.slice(1));
 }
-var icons = {
-  success: colors2.success("✔"),
-  error: colors2.error("✖"),
-  warning: colors2.warning("⚠"),
-  info: colors2.info("ℹ"),
-  arrow: colors2.primary("→"),
-  bullet: colors2.dim("•"),
-  star: colors2.warning("★"),
-  check: colors2.success("✓"),
-  cross: colors2.error("✗"),
-  pending: colors2.dim("○"),
-  lightning: "⚡",
-  fire: "\uD83D\uDD25",
-  rocket: "\uD83D\uDE80",
-  chart: "\uD83D\uDCCA",
-  money: "\uD83D\uDCB0",
-  brain: "\uD83E\uDDE0",
-  target: "\uD83C\uDFAF"
-};
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-function clearLine2() {
-  readline.clearLine(process.stdout, 0);
-  readline.cursorTo(process.stdout, 0);
+function installSkill(opt) {
+  if (!opt.installCommand) {
+    return {
+      id: opt.id,
+      name: opt.name,
+      success: false,
+      message: "No install command for skill"
+    };
+  }
+  try {
+    const skillPath = opt.installCommand.replace(/^npx\s+/, "").replace(/^bunx\s+/, "").replace(/^skills\s+add\s+/, "").trim();
+    let result = spawnSync("bunx", ["--bun", "skills", "add", skillPath], {
+      encoding: "utf-8",
+      stdio: "pipe",
+      timeout: 120000
+    });
+    if (result.status !== 0) {
+      result = spawnSync("npx", ["-y", "skills", "add", skillPath], {
+        encoding: "utf-8",
+        stdio: "pipe",
+        timeout: 120000
+      });
+    }
+    if (result.status === 0) {
+      return {
+        id: opt.id,
+        name: opt.name,
+        success: true,
+        message: `Skill installed successfully`
+      };
+    } else {
+      const output = (result.stderr || result.stdout || "").toLowerCase();
+      if (output.includes("already exists") || output.includes("already installed")) {
+        return {
+          id: opt.id,
+          name: opt.name,
+          success: true,
+          message: `Skill already installed`
+        };
+      }
+      return {
+        id: opt.id,
+        name: opt.name,
+        success: false,
+        message: "Skill installation failed",
+        error: result.stderr || result.stdout || "Unknown error"
+      };
+    }
+  } catch (err) {
+    return {
+      id: opt.id,
+      name: opt.name,
+      success: false,
+      message: "Failed to install skill",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
 }
-function write(text) {
-  process.stdout.write(text);
+function installConfig(opt, projectDir) {
+  if (!opt.configPath || !opt.configContent) {
+    return {
+      id: opt.id,
+      name: opt.name,
+      success: false,
+      message: "No config path or content provided"
+    };
+  }
+  try {
+    const fullPath = opt.configPath.startsWith("/") || opt.configPath.startsWith("~") ? opt.configPath.replace("~", homedir7()) : join8(projectDir, opt.configPath);
+    if (existsSync8(fullPath)) {
+      return {
+        id: opt.id,
+        name: opt.name,
+        success: true,
+        message: `Config already exists: ${opt.configPath}`
+      };
+    }
+    const parentDir = fullPath.substring(0, fullPath.lastIndexOf("/"));
+    if (parentDir && !existsSync8(parentDir)) {
+      mkdirSync3(parentDir, { recursive: true });
+    }
+    writeFileSync3(fullPath, opt.configContent);
+    return {
+      id: opt.id,
+      name: opt.name,
+      success: true,
+      message: `Created: ${opt.configPath}`
+    };
+  } catch (err) {
+    return {
+      id: opt.id,
+      name: opt.name,
+      success: false,
+      message: "Failed to create config",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
 }
-async function animateProgressBar(label, score, options = {}) {
-  const { width = 20, charDelay = 40, labelWidth = 20 } = options;
-  const filled = Math.round(score / 100 * width);
-  let barColor = colors2.excellent;
-  if (score < 40)
-    barColor = colors2.poor;
-  else if (score < 60)
-    barColor = colors2.moderate;
-  else if (score < 75)
-    barColor = colors2.good;
-  const paddedLabel = label.padEnd(labelWidth);
-  const scoreStr = `${score}/100`.padStart(7);
-  write(`  ${colors2.dim(paddedLabel)} ${colors2.dim(scoreStr)}  `);
-  for (let i3 = 0;i3 < width; i3++) {
-    if (i3 < filled) {
-      write(barColor("█"));
+function installHook(opt, projectDir) {
+  const agentsMdPath = join8(projectDir, "AGENTS.md");
+  try {
+    let content = "";
+    if (existsSync8(agentsMdPath)) {
+      content = readFileSync8(agentsMdPath, "utf-8");
     } else {
-      write(colors2.dim("░"));
+      content = `# Agent Instructions
+
+`;
     }
-    await sleep(charDelay);
+    const hookName = opt.name.toLowerCase();
+    if (content.toLowerCase().includes(hookName)) {
+      return {
+        id: opt.id,
+        name: opt.name,
+        success: true,
+        message: "Hook already configured in AGENTS.md"
+      };
+    }
+    const hookSection = opt.configContent || `
+## ${opt.name}
+${opt.description}
+`;
+    content += `
+` + hookSection;
+    writeFileSync3(agentsMdPath, content);
+    return {
+      id: opt.id,
+      name: opt.name,
+      success: true,
+      message: "Added hook to AGENTS.md"
+    };
+  } catch (err) {
+    return {
+      id: opt.id,
+      name: opt.name,
+      success: false,
+      message: "Failed to add hook",
+      error: err instanceof Error ? err.message : String(err)
+    };
   }
-  console.log();
-}
-async function thinkingStep(thinkingText, duration = 800, successText) {
-  const spinner = createSpinner(thinkingText);
-  spinner.start();
-  await sleep(duration);
-  spinner.succeed(successText ?? thinkingText);
-}
-async function revealDiscovery(icon, text, delay2 = 300) {
-  await sleep(delay2);
-  console.log(`  ${icon} ${text}`);
 }
-async function showPhaseHeader(phase, total, title, delay2 = 400) {
-  await sleep(delay2);
-  console.log();
-  console.log(`  ${colors2.dim(`Phase ${phase}/${total}:`)} ${colors2.bold(colors2.primary(title))}`);
-  console.log(colors2.dim("  " + "─".repeat(40)));
+function phaseRecToInstallable(rec) {
+  return {
+    id: rec.title.toLowerCase().replace(/\s+/g, "-"),
+    name: rec.title,
+    type: rec.type,
+    description: rec.description,
+    installCommand: rec.installCommand,
+    selected: false
+  };
 }
-async function animateScoreReveal(score, tier, options = {}) {
-  const { countDuration = 1000, barDelay = 50 } = options;
-  const scoreColor = score >= 80 ? colors2.excellent : score >= 60 ? colors2.good : score >= 40 ? colors2.moderate : colors2.poor;
-  console.log();
-  console.log(colors2.dim("  " + "═".repeat(45)));
-  console.log();
-  const steps = 30;
-  const stepDuration = countDuration / steps;
-  for (let i3 = 1;i3 <= steps; i3++) {
-    const current = Math.round(i3 / steps * score);
-    clearLine2();
-    write(`  ${colors2.bold("Your Score:")} ${scoreColor(colors2.bold(current.toString()))}/100`);
-    await sleep(stepDuration);
+function checkInstalledStatus(projectDir) {
+  const home = homedir7();
+  const status = {
+    context7: false,
+    supermemory: false,
+    nia: false,
+    beads: false,
+    skills: []
+  };
+  const mcpConfigPaths = [
+    join8(home, ".claude.json"),
+    join8(home, ".claude", "claude_desktop_config.json"),
+    join8(home, ".claude", "settings.json"),
+    join8(home, ".claude", "settings.local.json"),
+    join8(projectDir, ".mcp.json"),
+    join8(projectDir, ".claude", "settings.local.json")
+  ];
+  for (const configPath of mcpConfigPaths) {
+    if (existsSync8(configPath)) {
+      try {
+        const config = JSON.parse(readFileSync8(configPath, "utf-8"));
+        const mcpServers = config.mcpServers || config.mcp_servers || {};
+        for (const name of Object.keys(mcpServers)) {
+          const mcpName = name.toLowerCase();
+          if (mcpName.includes("context7") || mcpName === "c7") {
+            status.context7 = true;
+          }
+          if (mcpName.includes("supermemory") || mcpName.includes("memory")) {
+            status.supermemory = true;
+          }
+          if (mcpName.includes("nia")) {
+            status.nia = true;
+          }
+        }
+      } catch {}
+    }
   }
-  write(`  ${colors2.dim("(")}${formatTier(tier)}${colors2.dim(")")}`);
-  console.log();
-  console.log();
-  const barWidth = 30;
-  const filled = Math.round(score / 100 * barWidth);
-  write("  ");
-  for (let i3 = 0;i3 < barWidth; i3++) {
-    if (i3 < filled) {
-      write(scoreColor("█"));
-    } else {
-      write(colors2.dim("░"));
+  status.beads = existsSync8(join8(projectDir, ".beads"));
+  const skillsDirs = [
+    join8(home, ".claude", "skills"),
+    join8(home, ".config", "opencode", "skills"),
+    join8(home, ".agents", "skills"),
+    join8(projectDir, ".opencode", "skill")
+  ];
+  for (const dir of skillsDirs) {
+    if (existsSync8(dir)) {
+      try {
+        const skills = readdirSync4(dir);
+        for (const skill of skills) {
+          if (!status.skills.includes(skill.toLowerCase())) {
+            status.skills.push(skill.toLowerCase());
+          }
+        }
+      } catch {}
     }
-    await sleep(barDelay);
   }
-  console.log();
-  console.log();
-  console.log(colors2.dim("  " + "═".repeat(45)));
+  return status;
 }
-async function showFinding(type, label, value, unit = "", delay2 = 250) {
-  await sleep(delay2);
-  const iconMap = {
-    warning: icons.warning,
-    error: icons.error,
-    info: icons.info,
-    success: icons.success
-  };
-  const colorMap = {
-    warning: colors2.warning,
-    error: colors2.error,
-    info: colors2.info,
-    success: colors2.success
-  };
-  const icon = iconMap[type];
-  const valueColor = colorMap[type];
-  console.log(`  ${icon} ${label}: ${valueColor(value.toString())}${unit}`);
+function filterAlreadyInstalled(optimizations, status) {
+  return optimizations.filter((opt) => {
+    const id = opt.id.toLowerCase();
+    if (id === "context7" && status.context7)
+      return false;
+    if (id === "supermemory" && status.supermemory)
+      return false;
+    if (id === "nia" && status.nia)
+      return false;
+    if (id === "beads" && status.beads)
+      return false;
+    if (opt.type === "skill") {
+      const skillName = opt.name.toLowerCase().replace(/\s+/g, "-");
+      if (status.skills.some((s2) => s2.includes(skillName) || skillName.includes(s2) || s2.includes("tdd") && id.includes("tdd") || s2.includes("debug") && id.includes("debug") || s2.includes("plan") && id.includes("plan"))) {
+        return false;
+      }
+    }
+    return true;
+  });
 }
+var QUICK_INSTALL_PRESETS = {
+  essential: [
+    {
+      id: "context7",
+      name: "Context7 MCP",
+      type: "mcp",
+      description: "Up-to-date library documentation",
+      installCommand: "claude mcp add context7 https://mcp.context7.com/mcp --transport http",
+      selected: true
+    },
+    {
+      id: "supermemory",
+      name: "Supermemory MCP",
+      type: "mcp",
+      description: "Persistent memory across sessions",
+      installCommand: "claude mcp add supermemory -- npx -y @supermemory/mcp@latest",
+      selected: true
+    },
+    {
+      id: "beads",
+      name: "Beads Task Manager",
+      type: "mcp",
+      description: "Persistent task tracking",
+      installCommand: "bun add -g beads && bd init",
+      selected: true
+    }
+  ],
+  productivity: [
+    {
+      id: "claude-md",
+      name: "CLAUDE.md",
+      type: "config",
+      description: "Project context file",
+      configPath: "CLAUDE.md",
+      configContent: `# Project Instructions
+
+## Build & Test Commands
+\`\`\`bash
+bun test           # Run tests
+bun run build      # Build project
+bun run lint       # Run linter
+\`\`\`
+
+## Architecture
+Describe your project structure here.
+
+## Conventions
+- Use TypeScript
+- Write tests for new features
+- Use conventional commits
+`,
+      selected: true
+    },
+    {
+      id: "vitest",
+      name: "Vitest",
+      type: "library",
+      description: "Fast unit testing framework",
+      installCommand: "bun add -D vitest",
+      selected: true
+    }
+  ]
+};
 
 // src/commands/scan.ts
 var scanCommand = defineCommand2({
@@ -15489,10 +15979,19 @@ var scanCommand = defineCommand2({
       console.log(colors2.dim("  " + "═".repeat(45)));
       console.log();
       if (!args["no-report"]) {
-        const reportDir = join8(projectDir, args["report-dir"]);
+        const reportDir = join9(projectDir, args["report-dir"]);
         const reportPath = generateReport(reportDir, score, git, agents, tests, args.since, sdlcAnalysis, scanCost, analysis);
         console.log(`  ${icons.success} Report saved: ${colors2.dim(reportPath)}`);
       }
+      if (agents && agents.sessions.length > 0 && !args.brief) {
+        const frustrationSummary = detectFrustrations(agents.sessions);
+        if (frustrationSummary.totalFrustrations > 0) {
+          const frustrationLines = formatFrustrationSummary(frustrationSummary);
+          for (const line of frustrationLines) {
+            console.log(line);
+          }
+        }
+      }
       if (!args.brief) {
         const installedStatus = checkInstalledStatus(projectDir);
         const projectContext = loadProjectContext(projectDir);
@@ -15754,12 +16253,12 @@ var scanCommand = defineCommand2({
   }
 });
 function loadProjectContext(projectDir) {
-  const contextPath = join8(projectDir, ".nairon", "context.json");
-  if (!existsSync8(contextPath)) {
+  const contextPath = join9(projectDir, ".nairon", "context.json");
+  if (!existsSync9(contextPath)) {
     return null;
   }
   try {
-    const raw = readFileSync8(contextPath, "utf-8");
+    const raw = readFileSync9(contextPath, "utf-8");
     const data = JSON.parse(raw);
     const context = {
       painPoints: data.painPoints || [],
@@ -15812,12 +16311,12 @@ function parseSince(since) {
   return new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
 }
 function generateReport(reportDir, score, git, agents, tests, since, sdlcAnalysis, scanCost, analysis) {
-  if (!existsSync8(reportDir)) {
+  if (!existsSync9(reportDir)) {
     mkdirSync4(reportDir, { recursive: true });
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
   const filename = `scan-${timestamp}.md`;
-  const filepath = join8(reportDir, filename);
+  const filepath = join9(reportDir, filename);
   const lines = [];
   lines.push(`# NaironAI Scan Report`);
   lines.push("");
@@ -15958,11 +16457,11 @@ init_dist();
 init_client();
 
 // src/collectors/report-data.ts
-import { existsSync as existsSync9, readdirSync as readdirSync5, readFileSync as readFileSync9, statSync as statSync2 } from "node:fs";
-import { homedir as homedir7 } from "node:os";
-import { join as join9, basename as basename2 } from "node:path";
+import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync10, statSync as statSync2 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { join as join10, basename as basename3 } from "node:path";
 async function collectReportData(projectDir, since, until = new Date, harness) {
-  const projectName = basename2(projectDir);
+  const projectName = basename3(projectDir);
   const [commits, allSessions, mcpConfigs] = await Promise.all([
     collectGitCommits(projectDir, since, until),
     collectAllSessions(since, until, projectDir),
@@ -16043,12 +16542,12 @@ function detectAIAssistedCommit(message) {
 }
 async function collectAllSessions(since, until, projectDir) {
   const sessions = [];
-  const claudeDir = join9(homedir7(), ".claude");
-  if (existsSync9(claudeDir)) {
+  const claudeDir = join10(homedir8(), ".claude");
+  if (existsSync10(claudeDir)) {
     sessions.push(...collectClaudeCodeSessions(claudeDir, since, until, projectDir));
   }
-  const openCodeDir = join9(homedir7(), ".local", "share", "opencode");
-  if (existsSync9(openCodeDir)) {
+  const openCodeDir = join10(homedir8(), ".local", "share", "opencode");
+  if (existsSync10(openCodeDir)) {
     sessions.push(...collectOpenCodeSessions2(openCodeDir, since, until));
   }
   sessions.sort((a2, b2) => a2.startTime.getTime() - b2.startTime.getTime());
@@ -16056,15 +16555,15 @@ async function collectAllSessions(since, until, projectDir) {
 }
 function collectClaudeCodeSessions(claudeDir, since, until, projectDir) {
   const sessions = [];
-  const transcriptsDir = join9(claudeDir, "transcripts");
-  if (!existsSync9(transcriptsDir))
+  const transcriptsDir = join10(claudeDir, "transcripts");
+  if (!existsSync10(transcriptsDir))
     return sessions;
   const projectHash = projectDir ? hashPath(projectDir) : null;
-  const projectsDir = join9(claudeDir, "projects");
+  const projectsDir = join10(claudeDir, "projects");
   try {
     const transcriptFiles = readdirSync5(transcriptsDir).filter((f3) => f3.endsWith(".jsonl"));
     for (const file of transcriptFiles) {
-      const filePath = join9(transcriptsDir, file);
+      const filePath = join10(transcriptsDir, file);
       const stat = statSync2(filePath);
       if (stat.mtime < since || stat.mtime > until)
         continue;
@@ -16075,12 +16574,12 @@ function collectClaudeCodeSessions(claudeDir, since, until, projectDir) {
         }
       } catch {}
     }
-    if (projectHash && existsSync9(projectsDir)) {
-      const projectSessionDir = join9(projectsDir, projectHash);
-      if (existsSync9(projectSessionDir)) {
+    if (projectHash && existsSync10(projectsDir)) {
+      const projectSessionDir = join10(projectsDir, projectHash);
+      if (existsSync10(projectSessionDir)) {
         const projectFiles = readdirSync5(projectSessionDir).filter((f3) => f3.endsWith(".jsonl"));
         for (const file of projectFiles) {
-          const filePath = join9(projectSessionDir, file);
+          const filePath = join10(projectSessionDir, file);
           const stat = statSync2(filePath);
           if (stat.mtime < since || stat.mtime > until)
             continue;
@@ -16099,7 +16598,7 @@ function collectClaudeCodeSessions(claudeDir, since, until, projectDir) {
   return sessions;
 }
 function parseClaudeTranscript(filePath, fileName) {
-  const content = readFileSync9(filePath, "utf-8");
+  const content = readFileSync10(filePath, "utf-8");
   const lines = content.trim().split(`
 `).filter((l2) => l2.trim());
   if (lines.length === 0)
@@ -16189,25 +16688,25 @@ function parseClaudeTranscript(filePath, fileName) {
 }
 function collectOpenCodeSessions2(openCodeDir, since, until) {
   const sessions = [];
-  const sessionDir = join9(openCodeDir, "storage", "session");
-  const messageDir = join9(openCodeDir, "storage", "message");
-  const partDir = join9(openCodeDir, "storage", "part");
-  if (!existsSync9(sessionDir))
+  const sessionDir = join10(openCodeDir, "storage", "session");
+  const messageDir = join10(openCodeDir, "storage", "message");
+  const partDir = join10(openCodeDir, "storage", "part");
+  if (!existsSync10(sessionDir))
     return sessions;
   try {
-    const projectDirs = readdirSync5(sessionDir, { withFileTypes: true }).filter((d2) => d2.isDirectory()).map((d2) => join9(sessionDir, d2.name));
+    const projectDirs = readdirSync5(sessionDir, { withFileTypes: true }).filter((d2) => d2.isDirectory()).map((d2) => join10(sessionDir, d2.name));
     for (const projectDir of projectDirs) {
       const sessionFiles = readdirSync5(projectDir).filter((f3) => f3.endsWith(".json"));
       for (const sessionFile of sessionFiles) {
         try {
-          const sessionPath = join9(projectDir, sessionFile);
-          const sessionData = JSON.parse(readFileSync9(sessionPath, "utf-8"));
+          const sessionPath = join10(projectDir, sessionFile);
+          const sessionData = JSON.parse(readFileSync10(sessionPath, "utf-8"));
           const createdAt = new Date(sessionData.time?.created || 0);
           const updatedAt = new Date(sessionData.time?.updated || sessionData.time?.created || 0);
           if (updatedAt < since || createdAt > until)
             continue;
           const sessionId = sessionData.id;
-          const sessionMsgDir = join9(messageDir, sessionId);
+          const sessionMsgDir = join10(messageDir, sessionId);
           const prompts = [];
           const responses = [];
           const toolsUsed = new Set;
@@ -16218,12 +16717,12 @@ function collectOpenCodeSessions2(openCodeDir, since, until) {
           let model = "unknown";
           let startTime = createdAt;
           let endTime = updatedAt;
-          if (existsSync9(sessionMsgDir)) {
+          if (existsSync10(sessionMsgDir)) {
             const msgFiles = readdirSync5(sessionMsgDir).filter((f3) => f3.endsWith(".json")).sort();
             for (const msgFile of msgFiles) {
               try {
-                const msgPath = join9(sessionMsgDir, msgFile);
-                const msgData = JSON.parse(readFileSync9(msgPath, "utf-8"));
+                const msgPath = join10(sessionMsgDir, msgFile);
+                const msgData = JSON.parse(readFileSync10(msgPath, "utf-8"));
                 const msgId = msgData.id;
                 if (msgData.model?.modelID) {
                   model = msgData.model.modelID;
@@ -16233,14 +16732,14 @@ function collectOpenCodeSessions2(openCodeDir, since, until) {
                   startTime = msgTime;
                 if (msgTime > endTime)
                   endTime = msgTime;
-                const msgPartDir = join9(partDir, msgId);
+                const msgPartDir = join10(partDir, msgId);
                 let messageText = "";
-                if (existsSync9(msgPartDir)) {
+                if (existsSync10(msgPartDir)) {
                   const partFiles = readdirSync5(msgPartDir).filter((f3) => f3.endsWith(".json")).sort();
                   for (const partFile of partFiles) {
                     try {
-                      const partPath = join9(msgPartDir, partFile);
-                      const partData = JSON.parse(readFileSync9(partPath, "utf-8"));
+                      const partPath = join10(msgPartDir, partFile);
+                      const partData = JSON.parse(readFileSync10(partPath, "utf-8"));
                       if (partData.type === "text" && partData.text && !partData.synthetic) {
                         messageText += partData.text + `
 `;
@@ -16414,10 +16913,10 @@ function analyzeResponse(text, sessionId, index, promptId, timestamp) {
 }
 function collectMCPConfigs() {
   const configs = [];
-  const claudeConfig = join9(homedir7(), ".claude.json");
-  if (existsSync9(claudeConfig)) {
+  const claudeConfig = join10(homedir8(), ".claude.json");
+  if (existsSync10(claudeConfig)) {
     try {
-      const data = JSON.parse(readFileSync9(claudeConfig, "utf-8"));
+      const data = JSON.parse(readFileSync10(claudeConfig, "utf-8"));
       const mcpServers = data.mcpServers || {};
       for (const [name, config] of Object.entries(mcpServers)) {
         configs.push({
@@ -16430,13 +16929,13 @@ function collectMCPConfigs() {
     } catch {}
   }
   const openCodeConfigs = [
-    join9(homedir7(), ".opencode.json"),
-    join9(homedir7(), ".config", "opencode", "opencode.json")
+    join10(homedir8(), ".opencode.json"),
+    join10(homedir8(), ".config", "opencode", "opencode.json")
   ];
   for (const configPath of openCodeConfigs) {
-    if (existsSync9(configPath)) {
+    if (existsSync10(configPath)) {
       try {
-        const data = JSON.parse(readFileSync9(configPath, "utf-8"));
+        const data = JSON.parse(readFileSync10(configPath, "utf-8"));
         const mcpServers = data.mcp || {};
         for (const [name, config] of Object.entries(mcpServers)) {
           if (!configs.find((c3) => c3.name === name)) {
@@ -16451,10 +16950,10 @@ function collectMCPConfigs() {
       } catch {}
     }
   }
-  const cursorConfig = join9(homedir7(), ".cursor", "mcp.json");
-  if (existsSync9(cursorConfig)) {
+  const cursorConfig = join10(homedir8(), ".cursor", "mcp.json");
+  if (existsSync10(cursorConfig)) {
     try {
-      const data = JSON.parse(readFileSync9(cursorConfig, "utf-8"));
+      const data = JSON.parse(readFileSync10(cursorConfig, "utf-8"));
       const mcpServers = data.mcpServers || {};
       for (const [name, config] of Object.entries(mcpServers)) {
         if (!configs.find((c3) => c3.name === name)) {
@@ -18655,9 +19154,9 @@ function getSeverityEmoji(severity) {
 }
 
 // src/lib/tool-analyzer.ts
-import { existsSync as existsSync10, readdirSync as readdirSync6 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync11, readdirSync as readdirSync6 } from "node:fs";
+import { homedir as homedir9 } from "node:os";
+import { join as join11 } from "node:path";
 function analyzeToolUtilization(data) {
   const mcpServers = analyzeMCPServers(data);
   const mcpSummary = buildMCPSummary(mcpServers);
@@ -18807,24 +19306,24 @@ function categorizeTools(tools) {
 }
 function analyzeSkills() {
   const skills = [];
-  const home = homedir8();
+  const home = homedir9();
   const skillsDirs = [
-    join10(home, ".claude", "skills"),
-    join10(home, ".agents", "skills"),
-    join10(home, ".config", "claude", "skills")
+    join11(home, ".claude", "skills"),
+    join11(home, ".agents", "skills"),
+    join11(home, ".config", "claude", "skills")
   ];
   const projectSkillsDirs = [
-    join10(process.cwd(), ".claude", "skills"),
-    join10(process.cwd(), ".agents", "skills")
+    join11(process.cwd(), ".claude", "skills"),
+    join11(process.cwd(), ".agents", "skills")
   ];
   const openCodeSkillDirs = [
-    join10(home, ".config", "opencode", "skills"),
-    join10(home, ".local", "share", "opencode", "skills")
+    join11(home, ".config", "opencode", "skills"),
+    join11(home, ".local", "share", "opencode", "skills")
   ];
   const allSkillDirs = [...skillsDirs, ...projectSkillsDirs, ...openCodeSkillDirs];
   const seenSkills = new Set;
   for (const skillsDir of allSkillDirs) {
-    if (existsSync10(skillsDir)) {
+    if (existsSync11(skillsDir)) {
       try {
         const entries = readdirSync6(skillsDir, { withFileTypes: true });
         for (const entry of entries) {
@@ -18835,7 +19334,7 @@ function analyzeSkills() {
           if (entry.isDirectory() || entry.isSymbolicLink() || entry.name.endsWith(".md")) {
             skills.push({
               name: skillName,
-              path: join10(skillsDir, entry.name),
+              path: join11(skillsDir, entry.name),
               used: false,
               usageCount: 0
             });
@@ -19132,22 +19631,22 @@ function renderToolUtilizationMarkdown(analysis) {
 }
 
 // src/lib/coverage-parser.ts
-import { existsSync as existsSync11, readFileSync as readFileSync11 } from "node:fs";
-import { join as join11 } from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync12 } from "node:fs";
+import { join as join12 } from "node:path";
 function parseCoverageReport(projectDir) {
   const coveragePaths = [
-    { path: join11(projectDir, "coverage", "lcov.info"), parser: parseLcov },
-    { path: join11(projectDir, "coverage", "coverage-summary.json"), parser: parseIstanbulSummary },
-    { path: join11(projectDir, "coverage", "coverage-final.json"), parser: parseIstanbulFinal },
-    { path: join11(projectDir, "coverage", "cobertura-coverage.xml"), parser: parseCobertura },
-    { path: join11(projectDir, "coverage", "clover.xml"), parser: parseClover },
-    { path: join11(projectDir, "lcov.info"), parser: parseLcov },
-    { path: join11(projectDir, ".nyc_output", "coverage-summary.json"), parser: parseIstanbulSummary }
+    { path: join12(projectDir, "coverage", "lcov.info"), parser: parseLcov },
+    { path: join12(projectDir, "coverage", "coverage-summary.json"), parser: parseIstanbulSummary },
+    { path: join12(projectDir, "coverage", "coverage-final.json"), parser: parseIstanbulFinal },
+    { path: join12(projectDir, "coverage", "cobertura-coverage.xml"), parser: parseCobertura },
+    { path: join12(projectDir, "coverage", "clover.xml"), parser: parseClover },
+    { path: join12(projectDir, "lcov.info"), parser: parseLcov },
+    { path: join12(projectDir, ".nyc_output", "coverage-summary.json"), parser: parseIstanbulSummary }
   ];
   for (const { path, parser: parser4 } of coveragePaths) {
-    if (existsSync11(path)) {
+    if (existsSync12(path)) {
       try {
-        const content = readFileSync11(path, "utf-8");
+        const content = readFileSync12(path, "utf-8");
         return parser4(content, path);
       } catch {}
     }
@@ -21357,16 +21856,655 @@ function renderBar4(value, width) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync12 } from "node:fs";
-import { homedir as homedir9 } from "node:os";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync13 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+import { join as join13 } from "node:path";
 init_client();
+
+// src/lib/recommendations-db.ts
+var MCP_SERVERS = [
+  {
+    id: "context7",
+    name: "Context7",
+    type: "mcp",
+    description: "Live documentation for any library - reduces API hallucinations by 40%+",
+    installCommand: "claude mcp add context7 https://mcp.context7.com/mcp --transport http",
+    phases: ["requirements", "implementation"],
+    impact: "high",
+    detectionKey: "context7",
+    website: "https://context7.com",
+    badge: "Essential",
+    agents: {
+      "claude-code": { installCommand: "claude mcp add context7 https://mcp.context7.com/mcp --transport http" },
+      opencode: { installCommand: "Add to ~/.config/opencode/config.json mcpServers" }
+    }
+  },
+  {
+    id: "supermemory",
+    name: "Supermemory",
+    type: "mcp",
+    description: "Persistent memory across sessions - never re-explain context",
+    installCommand: "claude mcp add supermemory -- npx -y @supermemory/mcp@latest",
+    phases: ["requirements", "implementation"],
+    impact: "high",
+    detectionKey: "supermemory",
+    website: "https://supermemory.ai",
+    badge: "Essential",
+    agents: {
+      "claude-code": { installCommand: "claude mcp add supermemory -- npx -y @supermemory/mcp@latest" }
+    }
+  },
+  {
+    id: "nia",
+    name: "Nia",
+    type: "mcp",
+    description: "Index and search external codebases and documentation",
+    installCommand: "pipx run --no-cache nia-mcp-server",
+    phases: ["requirements"],
+    impact: "medium",
+    detectionKey: "nia",
+    website: "https://trynia.ai"
+  },
+  {
+    id: "greptile",
+    name: "Greptile",
+    type: "mcp",
+    description: "AI-powered code review and PR analysis",
+    installCommand: "claude mcp add greptile -- npx -y @greptile/mcp",
+    phases: ["review"],
+    impact: "high",
+    detectionKey: "greptile",
+    website: "https://www.greptile.com",
+    badge: "Recommended"
+  },
+  {
+    id: "agent-browser",
+    name: "Agent Browser",
+    type: "mcp",
+    description: "Live end-to-end browser testing and automation",
+    installCommand: "claude mcp add agent-browser -- npx -y agent-browser-mcp",
+    phases: ["review"],
+    impact: "high",
+    detectionKey: "agent-browser",
+    website: "https://agent-browser.dev",
+    badge: "Recommended"
+  },
+  {
+    id: "playwright-mcp",
+    name: "Playwright MCP",
+    type: "mcp",
+    description: "Browser automation for E2E testing and web scraping",
+    installCommand: "claude mcp add playwright -- npx -y @anthropic/playwright-mcp",
+    phases: ["review"],
+    impact: "medium",
+    detectionKey: "playwright",
+    website: "https://playwright.dev"
+  },
+  {
+    id: "github-mcp",
+    name: "GitHub MCP",
+    type: "mcp",
+    description: "GitHub integration for PRs, issues, and repo management",
+    installCommand: "claude mcp add github -- npx -y @anthropic/github-mcp",
+    phases: ["planning", "review"],
+    impact: "medium",
+    detectionKey: "github"
+  }
+];
+var PLUGINS = [
+  {
+    id: "beads",
+    name: "Beads",
+    type: "plugin",
+    description: "Lightweight issue tracking in git - survives context compaction",
+    installCommand: "bun add -g beads && bd init",
+    phases: ["planning"],
+    impact: "high",
+    detectionKey: "beads",
+    website: "https://github.com/steveyegge/beads",
+    badge: "Recommended"
+  },
+  {
+    id: "linear",
+    name: "Linear",
+    type: "plugin",
+    description: "Sync with Linear issues for team collaboration",
+    phases: ["planning"],
+    impact: "medium",
+    website: "https://linear.app"
+  },
+  {
+    id: "slack",
+    name: "Slack",
+    type: "plugin",
+    description: "Team notifications and updates",
+    phases: ["review"],
+    impact: "low",
+    website: "https://slack.com"
+  }
+];
+var SKILLS = [
+  {
+    id: "tdd-skill",
+    name: "Test-Driven Development",
+    type: "skill",
+    description: "Write tests first, then implement - reduces bugs by 40%",
+    installCommand: "npx skills add obra/superpowers@test-driven-development --yes",
+    phases: ["review"],
+    impact: "high",
+    website: "https://skills.sh"
+  },
+  {
+    id: "debugging-skill",
+    name: "Systematic Debugging",
+    type: "skill",
+    description: "Structured approach to finding and fixing bugs",
+    installCommand: "npx skills add obra/superpowers@systematic-debugging --yes",
+    phases: ["implementation", "review"],
+    impact: "medium",
+    website: "https://skills.sh"
+  },
+  {
+    id: "planning-skill",
+    name: "Writing Plans",
+    type: "skill",
+    description: "Structured planning before implementation",
+    installCommand: "npx skills add obra/superpowers@writing-plans --yes",
+    phases: ["planning"],
+    impact: "medium",
+    website: "https://skills.sh"
+  },
+  {
+    id: "code-review-skill",
+    name: "Code Review",
+    type: "skill",
+    description: "Thorough code review checklist and workflow",
+    installCommand: "npx skills add obra/superpowers@requesting-code-review --yes",
+    phases: ["review"],
+    impact: "medium",
+    website: "https://skills.sh"
+  },
+  {
+    id: "react-skill",
+    name: "React Best Practices",
+    type: "skill",
+    description: "Vercel's React and Next.js patterns",
+    installCommand: "npx skills add vercel-labs/agent-skills@vercel-react-best-practices --yes",
+    phases: ["implementation"],
+    impact: "medium",
+    website: "https://skills.sh"
+  },
+  {
+    id: "remotion-skill",
+    name: "Remotion",
+    type: "skill",
+    description: "Video creation with React",
+    installCommand: "npx skills add remotion-dev/skills@remotion-best-practices --yes",
+    phases: ["implementation"],
+    impact: "low",
+    website: "https://skills.sh"
+  },
+  {
+    id: "frontend-design-skill",
+    name: "Frontend Design",
+    type: "skill",
+    description: "Anthropic's frontend design patterns",
+    installCommand: "npx skills add anthropics/skills@frontend-design --yes",
+    phases: ["implementation"],
+    impact: "medium",
+    website: "https://skills.sh"
+  },
+  {
+    id: "web-design-skill",
+    name: "Web Design Guidelines",
+    type: "skill",
+    description: "Vercel's web design guidelines",
+    installCommand: "npx skills add vercel-labs/agent-skills@web-design-guidelines --yes",
+    phases: ["implementation"],
+    impact: "medium",
+    website: "https://skills.sh"
+  }
+];
+var LIBRARIES = [
+  {
+    id: "vitest",
+    name: "Vitest",
+    type: "library",
+    description: "Fast unit testing framework for TypeScript/JavaScript",
+    installCommand: "bun add -D vitest",
+    phases: ["review"],
+    impact: "high",
+    website: "https://vitest.dev"
+  },
+  {
+    id: "playwright",
+    name: "Playwright",
+    type: "library",
+    description: "E2E testing framework for web applications",
+    installCommand: "bun add -D playwright @playwright/test",
+    phases: ["review"],
+    impact: "medium",
+    website: "https://playwright.dev"
+  },
+  {
+    id: "biome",
+    name: "Biome",
+    type: "library",
+    description: "Fast linter and formatter (replaces ESLint + Prettier)",
+    installCommand: "bun add -D @biomejs/biome && bunx biome init",
+    phases: ["review"],
+    impact: "medium",
+    website: "https://biomejs.dev"
+  }
+];
+var CONFIG_FILES = [
+  {
+    id: "claude-md",
+    name: "CLAUDE.md",
+    type: "config",
+    description: "Project-specific instructions for AI - commands, conventions, architecture",
+    configPath: "CLAUDE.md",
+    configContent: `# Project Instructions
+
+## Build & Test Commands
+\`\`\`bash
+bun test           # Run tests
+bun run build      # Build project
+bun run lint       # Run linter
+\`\`\`
+
+## Architecture
+Describe your project structure here.
+
+## Conventions
+- Use TypeScript
+- Write tests for new features
+- Use conventional commits
+`,
+    phases: ["requirements"],
+    impact: "high"
+  },
+  {
+    id: "agents-md",
+    name: "AGENTS.md",
+    type: "config",
+    description: "Agent-specific instructions and workflows",
+    configPath: "AGENTS.md",
+    configContent: `# Agent Instructions
+
+## Package Manager
+This project uses **bun** exclusively.
+
+## Workflow
+1. Read existing code before making changes
+2. Write tests for new features
+3. Run \`bun test\` before committing
+`,
+    phases: ["requirements", "planning"],
+    impact: "medium"
+  }
+];
+var WORKFLOW_TOOLS = [
+  {
+    id: "granola",
+    name: "Granola",
+    type: "tool",
+    description: "AI meeting notes and requirements capture",
+    phases: ["requirements"],
+    impact: "medium",
+    website: "https://www.granola.ai/"
+  },
+  {
+    id: "repoprompt",
+    name: "RepoPrompt",
+    type: "tool",
+    description: "Generate AI prompts from your codebase",
+    phases: ["requirements"],
+    impact: "medium",
+    website: "https://repoprompt.com"
+  },
+  {
+    id: "figma",
+    name: "Figma / v0",
+    type: "tool",
+    description: "Design tools for UI/UX planning",
+    phases: ["planning"],
+    impact: "medium",
+    website: "https://figma.com"
+  }
+];
+var ALL_RECOMMENDATIONS = [
+  ...MCP_SERVERS,
+  ...PLUGINS,
+  ...SKILLS,
+  ...LIBRARIES,
+  ...CONFIG_FILES,
+  ...WORKFLOW_TOOLS
+];
+var INSTALLABLE_RECOMMENDATIONS = ALL_RECOMMENDATIONS.filter((r3) => r3.installCommand || r3.configPath);
+if (false) {}
+
+// src/lib/verify-recommendations.ts
+function validateSkillFormat(command) {
+  if (!command.match(/^(npx|bunx)\s+skills\s+add\s+/)) {
+    return { valid: false, message: "Must start with 'npx skills add' or 'bunx skills add'" };
+  }
+  const match = command.match(/skills\s+add\s+([^\s]+)/);
+  if (!match) {
+    return { valid: false, message: "Could not extract skill path" };
+  }
+  const skillPath = match[1] ?? "";
+  if (!skillPath.includes("@")) {
+    return {
+      valid: false,
+      message: `Invalid format '${skillPath}'. Must use @ separator: owner/repo@skill-name`
+    };
+  }
+  const skillMatch = skillPath.match(/^([^\/]+)\/([^@]+)@([^\/\s]+)$/);
+  if (!skillMatch) {
+    return {
+      valid: false,
+      message: `Invalid skill path '${skillPath}'. Expected: owner/repo@skill-name`
+    };
+  }
+  if (!command.includes("--yes")) {
+    return {
+      valid: false,
+      message: "Missing --yes flag for non-interactive installation"
+    };
+  }
+  return { valid: true, message: "Valid skills.sh format" };
+}
+function validateMCPFormat(command) {
+  if (command.startsWith("claude mcp add")) {
+    if (command.includes("-- npx") || command.includes("--transport")) {
+      return { valid: true, message: "Valid Claude MCP format" };
+    }
+    return { valid: false, message: "MCP command should have '-- npx' or '--transport' pattern" };
+  }
+  if (command.startsWith("pipx run")) {
+    return { valid: true, message: "Valid pipx MCP format" };
+  }
+  if (command.includes("config") || command.includes("mcpServers")) {
+    return { valid: true, message: "Manual configuration instruction" };
+  }
+  return { valid: false, message: "Unknown MCP install format" };
+}
+function validatePackageFormat(command) {
+  if (command.match(/^bun\s+add\s+(-[dDgG]\s+)?[@\w\/-]+/)) {
+    return { valid: true, message: "Valid bun add format" };
+  }
+  if (command.match(/^npm\s+(install|i)\s+(-[dDgG]\s+)?[@\w\/-]+/)) {
+    return { valid: true, message: "Valid npm install format" };
+  }
+  if (command.match(/^(bunx|npx)\s+/)) {
+    return { valid: true, message: "Valid bunx/npx format" };
+  }
+  return { valid: false, message: "Unknown package install format" };
+}
+async function checkNpmPackageExists(packageName) {
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${packageName}`, {
+      method: "HEAD",
+      signal: AbortSignal.timeout(5000)
+    });
+    if (response.ok) {
+      return { exists: true, message: "Package exists on npm" };
+    }
+    return { exists: false, message: `Package not found on npm (${response.status})` };
+  } catch (error2) {
+    return { exists: false, message: `Could not verify: ${error2 instanceof Error ? error2.message : String(error2)}` };
+  }
+}
+async function checkGitHubRepoExists(owner, repo) {
+  try {
+    const response = await fetch(`https://api.github.com/repos/${owner}/${repo}`, {
+      method: "HEAD",
+      signal: AbortSignal.timeout(5000)
+    });
+    if (response.ok) {
+      return { exists: true, message: "GitHub repo exists" };
+    }
+    if (response.status === 404) {
+      return { exists: false, message: `GitHub repo ${owner}/${repo} not found` };
+    }
+    return { exists: false, message: `GitHub API error (${response.status})` };
+  } catch (error2) {
+    return { exists: false, message: `Could not verify: ${error2 instanceof Error ? error2.message : String(error2)}` };
+  }
+}
+function verifyRecommendation(rec) {
+  const base = {
+    id: rec.id,
+    name: rec.name,
+    type: rec.type,
+    installCommand: rec.installCommand
+  };
+  if (!rec.installCommand && !rec.configPath) {
+    return { ...base, status: "skipped", message: "No install command (informational only)" };
+  }
+  if (rec.type === "config" && rec.configPath) {
+    return { ...base, status: "valid", message: `Config file: ${rec.configPath}` };
+  }
+  if (!rec.installCommand) {
+    return { ...base, status: "skipped", message: "No install command" };
+  }
+  switch (rec.type) {
+    case "skill": {
+      const result = validateSkillFormat(rec.installCommand);
+      return {
+        ...base,
+        status: result.valid ? "valid" : "invalid",
+        message: result.message
+      };
+    }
+    case "mcp": {
+      const result = validateMCPFormat(rec.installCommand);
+      return {
+        ...base,
+        status: result.valid ? "valid" : "invalid",
+        message: result.message
+      };
+    }
+    case "library":
+    case "plugin": {
+      const result = validatePackageFormat(rec.installCommand);
+      return {
+        ...base,
+        status: result.valid ? "valid" : "invalid",
+        message: result.message
+      };
+    }
+    default:
+      return { ...base, status: "warning", message: `Unknown type: ${rec.type}` };
+  }
+}
+function verifyAllRecommendations() {
+  const results = [];
+  for (const rec of ALL_RECOMMENDATIONS) {
+    results.push(verifyRecommendation(rec));
+  }
+  const valid = results.filter((r3) => r3.status === "valid").length;
+  const invalid = results.filter((r3) => r3.status === "invalid").length;
+  const warnings = results.filter((r3) => r3.status === "warning").length;
+  const skipped = results.filter((r3) => r3.status === "skipped").length;
+  return {
+    total: results.length,
+    valid,
+    invalid,
+    warnings,
+    skipped,
+    results
+  };
+}
+async function verifyRecommendationsThorough() {
+  const basicResults = verifyAllRecommendations();
+  const enhancedResults = [];
+  for (const result of basicResults.results) {
+    if (result.status === "invalid" || result.status === "skipped") {
+      enhancedResults.push(result);
+      continue;
+    }
+    if (result.installCommand?.includes("skills add")) {
+      const match = result.installCommand.match(/skills\s+add\s+([^\/]+)\/([^@]+)@/);
+      if (match && match[1] && match[2]) {
+        const owner = match[1];
+        const repo = match[2];
+        const check = await checkGitHubRepoExists(owner, repo);
+        if (!check.exists) {
+          enhancedResults.push({
+            ...result,
+            status: "invalid",
+            message: check.message
+          });
+          continue;
+        }
+      }
+    }
+    if (result.installCommand?.match(/npx\s+-y\s+@?[\w\/-]+/)) {
+      const match = result.installCommand.match(/npx\s+-y\s+(@?[\w\/-]+)/);
+      if (match && match[1]) {
+        const packageName = match[1];
+        const check = await checkNpmPackageExists(packageName);
+        if (!check.exists) {
+          enhancedResults.push({
+            ...result,
+            status: "warning",
+            message: check.message
+          });
+          continue;
+        }
+      }
+    }
+    enhancedResults.push(result);
+  }
+  const valid = enhancedResults.filter((r3) => r3.status === "valid").length;
+  const invalid = enhancedResults.filter((r3) => r3.status === "invalid").length;
+  const warnings = enhancedResults.filter((r3) => r3.status === "warning").length;
+  const skipped = enhancedResults.filter((r3) => r3.status === "skipped").length;
+  return {
+    total: enhancedResults.length,
+    valid,
+    invalid,
+    warnings,
+    skipped,
+    results: enhancedResults
+  };
+}
+function printVerificationResults(summary, verbose = false) {
+  console.log(`
+═══════════════════════════════════════════════════════════════`);
+  console.log("  RECOMMENDATION VERIFICATION REPORT");
+  console.log(`═══════════════════════════════════════════════════════════════
+`);
+  const invalid = summary.results.filter((r3) => r3.status === "invalid");
+  if (invalid.length > 0) {
+    console.log(`❌ INVALID RECOMMENDATIONS:
+`);
+    for (const r3 of invalid) {
+      console.log(`  ${r3.name} (${r3.type})`);
+      console.log(`    ID: ${r3.id}`);
+      console.log(`    Issue: ${r3.message}`);
+      if (r3.installCommand) {
+        console.log(`    Command: ${r3.installCommand}`);
+      }
+      console.log();
+    }
+  }
+  const warnings = summary.results.filter((r3) => r3.status === "warning");
+  if (warnings.length > 0) {
+    console.log(`⚠️  WARNINGS:
+`);
+    for (const r3 of warnings) {
+      console.log(`  ${r3.name}: ${r3.message}`);
+    }
+    console.log();
+  }
+  if (verbose) {
+    const valid = summary.results.filter((r3) => r3.status === "valid");
+    if (valid.length > 0) {
+      console.log(`✓ VALID RECOMMENDATIONS:
+`);
+      for (const r3 of valid) {
+        console.log(`  ${r3.name} (${r3.type}): ${r3.message}`);
+      }
+      console.log();
+    }
+  }
+  console.log("───────────────────────────────────────────────────────────────");
+  console.log(`  Total: ${summary.total}`);
+  console.log(`  ✓ Valid: ${summary.valid}`);
+  console.log(`  ❌ Invalid: ${summary.invalid}`);
+  console.log(`  ⚠️  Warnings: ${summary.warnings}`);
+  console.log(`  ○ Skipped: ${summary.skipped}`);
+  console.log(`───────────────────────────────────────────────────────────────
+`);
+  if (summary.invalid > 0) {
+    console.log(`❌ VERIFICATION FAILED - Fix invalid recommendations before release!
+`);
+  } else if (summary.warnings > 0) {
+    console.log(`⚠️  VERIFICATION PASSED WITH WARNINGS
+`);
+  } else {
+    console.log(`✓ ALL RECOMMENDATIONS VERIFIED
+`);
+  }
+}
+
+// src/commands/doctor.ts
 var doctorCommand = defineCommand2({
   meta: {
     name: "doctor",
     description: "Check tool detection, data sources, and connectivity health"
   },
-  async run() {
+  args: {
+    "verify-recommendations": {
+      type: "boolean",
+      description: "Verify all recommendations in the database are valid",
+      alias: "verify",
+      default: false
+    },
+    thorough: {
+      type: "boolean",
+      description: "Run thorough verification with network checks",
+      alias: "t",
+      default: false
+    },
+    verbose: {
+      type: "boolean",
+      description: "Show all results including valid recommendations",
+      alias: "v",
+      default: false
+    }
+  },
+  async run({ args }) {
+    if (args["verify-recommendations"]) {
+      console.log();
+      console.log(colors2.bold(colors2.primary("  NaironAI Recommendation Verifier")));
+      console.log(colors2.dim(`  Validating all recommendation install commands...
+`));
+      const spinner2 = createSpinner("Verifying recommendations...");
+      spinner2.start();
+      let summary;
+      if (args.thorough) {
+        spinner2.text = "Verifying recommendations (thorough mode with network checks)...";
+        summary = await verifyRecommendationsThorough();
+      } else {
+        summary = verifyAllRecommendations();
+      }
+      if (summary.invalid > 0) {
+        spinner2.fail(`Found ${summary.invalid} invalid recommendation(s)`);
+      } else if (summary.warnings > 0) {
+        spinner2.warn(`Verification passed with ${summary.warnings} warning(s)`);
+      } else {
+        spinner2.succeed("All recommendations verified");
+      }
+      printVerificationResults(summary, args.verbose);
+      if (summary.invalid > 0) {
+        process.exit(1);
+      }
+      return;
+    }
     console.log();
     console.log(colors2.bold(colors2.primary("  NaironAI Doctor")));
     console.log(colors2.dim(`  Checking system health...
@@ -21377,16 +22515,16 @@ var doctorCommand = defineCommand2({
     results.push({ label: "OS", status: "info", value: `${process.platform} ${process.arch}` });
     results.push({ label: "Bun", status: "info", value: typeof Bun !== "undefined" ? Bun.version : "N/A" });
     results.push({ label: "Node", status: "info", value: process.version });
-    results.push({ label: "Home", status: "info", value: homedir9() });
-    const gitDir = join12(process.cwd(), ".git");
-    if (existsSync12(gitDir)) {
+    results.push({ label: "Home", status: "info", value: homedir10() });
+    const gitDir = join13(process.cwd(), ".git");
+    if (existsSync13(gitDir)) {
       results.push({ label: "Git", status: "success", value: "Repository detected" });
     } else {
       results.push({ label: "Git", status: "warn", value: "No repository in current directory" });
     }
     for (const [agent, pathTemplate] of Object.entries(AGENT_LOG_PATHS)) {
-      const resolvedPath = pathTemplate.replace("~", homedir9());
-      if (existsSync12(resolvedPath)) {
+      const resolvedPath = pathTemplate.replace("~", homedir10());
+      if (existsSync13(resolvedPath)) {
         results.push({ label: agent, status: "success", value: `found at ${resolvedPath}` });
       }
     }
@@ -21440,9 +22578,9 @@ var doctorCommand = defineCommand2({
 });
 
 // src/commands/setup.ts
-import { existsSync as existsSync13, readFileSync as readFileSync12, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, copyFileSync } from "node:fs";
-import { join as join13, dirname as dirname2 } from "node:path";
-import { homedir as homedir10, platform as platform2 } from "node:os";
+import { existsSync as existsSync14, readFileSync as readFileSync13, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, copyFileSync } from "node:fs";
+import { join as join14, dirname as dirname2 } from "node:path";
+import { homedir as homedir11, platform as platform2 } from "node:os";
 import { execSync as execSync3 } from "node:child_process";
 import { createInterface } from "node:readline";
 var CONVEX_SITE_URL = "https://steady-bass-841.convex.site";
@@ -21461,7 +22599,7 @@ var FALLBACK_HARNESSES = [
     id: "claude-code",
     name: "Claude Code",
     configPaths: [
-      join13(homedir10(), ".claude.json")
+      join14(homedir11(), ".claude.json")
     ],
     mcpConfigKey: "mcpServers",
     detected: false
@@ -21470,8 +22608,8 @@ var FALLBACK_HARNESSES = [
     id: "opencode",
     name: "OpenCode",
     configPaths: [
-      join13(homedir10(), ".opencode.json"),
-      join13(homedir10(), ".config", "opencode", "opencode.json")
+      join14(homedir11(), ".opencode.json"),
+      join14(homedir11(), ".config", "opencode", "opencode.json")
     ],
     mcpConfigKey: "mcp",
     detected: false
@@ -21480,8 +22618,8 @@ var FALLBACK_HARNESSES = [
     id: "cursor",
     name: "Cursor",
     configPaths: [
-      join13(homedir10(), ".cursor", "mcp.json"),
-      join13(homedir10(), "Library", "Application Support", "Cursor", "User", "globalStorage", "mcp.json")
+      join14(homedir11(), ".cursor", "mcp.json"),
+      join14(homedir11(), "Library", "Application Support", "Cursor", "User", "globalStorage", "mcp.json")
     ],
     mcpConfigKey: "mcpServers",
     detected: false
@@ -21498,7 +22636,7 @@ function getConfigPathsForPlatform(harness) {
   } else {
     paths = pathMap.linux;
   }
-  return paths.map((p) => p.replace(/^~/, homedir10()).replace(/%USERPROFILE%/gi, homedir10()).replace(/%APPDATA%/gi, join13(homedir10(), "AppData", "Roaming")));
+  return paths.map((p) => p.replace(/^~/, homedir11()).replace(/%USERPROFILE%/gi, homedir11()).replace(/%APPDATA%/gi, join14(homedir11(), "AppData", "Roaming")));
 }
 function convertAPIHarnessToConfig(harness) {
   return {
@@ -21513,7 +22651,7 @@ function detectHarnesses(harnesses) {
   const detected = [];
   for (const harness of harnesses) {
     for (const configPath of harness.configPaths) {
-      if (existsSync13(configPath)) {
+      if (existsSync14(configPath)) {
         detected.push({
           ...harness,
           detected: true,
@@ -21526,19 +22664,19 @@ function detectHarnesses(harnesses) {
   return detected;
 }
 function backupConfig(configPath) {
-  const backupDir = join13(homedir10(), ".nairon", "backups");
-  if (!existsSync13(backupDir)) {
+  const backupDir = join14(homedir11(), ".nairon", "backups");
+  if (!existsSync14(backupDir)) {
     mkdirSync5(backupDir, { recursive: true });
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
   const filename = configPath.replace(/[/\\]/g, "_").replace(/^_/, "");
-  const backupPath = join13(backupDir, `${timestamp}_${filename}`);
+  const backupPath = join14(backupDir, `${timestamp}_${filename}`);
   copyFileSync(configPath, backupPath);
   return backupPath;
 }
 function readJsonConfig(configPath) {
   try {
-    const content = readFileSync12(configPath, "utf-8");
+    const content = readFileSync13(configPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -21546,7 +22684,7 @@ function readJsonConfig(configPath) {
 }
 function writeJsonConfig(configPath, config) {
   const dir = dirname2(configPath);
-  if (!existsSync13(dir)) {
+  if (!existsSync14(dir)) {
     mkdirSync5(dir, { recursive: true });
   }
   writeFileSync6(configPath, JSON.stringify(config, null, 2));
@@ -21590,7 +22728,7 @@ function getInstalledMCPs(harnesses) {
   const installed = new Set;
   for (const harness of harnesses) {
     for (const configPath of harness.configPaths) {
-      if (!existsSync13(configPath))
+      if (!existsSync14(configPath))
         continue;
       const config = readJsonConfig(configPath);
       const mcpServers = config[harness.mcpConfigKey];
@@ -21614,7 +22752,7 @@ async function installMCPServer(serverName, instruction, harness) {
   if (!harness.configPath || !instruction.mcpServerConfig)
     return false;
   try {
-    if (existsSync13(harness.configPath)) {
+    if (existsSync14(harness.configPath)) {
       backupConfig(harness.configPath);
     }
     const config = readJsonConfig(harness.configPath);
@@ -21659,8 +22797,8 @@ async function installBeads(projectDir) {
         }
       }
     }
-    const beadsDir = join13(projectDir, ".beads");
-    if (!existsSync13(beadsDir)) {
+    const beadsDir = join14(projectDir, ".beads");
+    if (!existsSync14(beadsDir)) {
       const projectName = projectDir.split(/[/\\]/).pop() ?? "project";
       const initSpinner = createSpinner(`Initializing Beads in ${projectName}...`);
       initSpinner.start();
@@ -21679,9 +22817,9 @@ async function installBeads(projectDir) {
   }
 }
 async function createClaudeRules(projectDir) {
-  const claudeMdPath = join13(projectDir, "CLAUDE.md");
-  const agentsMdPath = join13(projectDir, "AGENTS.md");
-  if (existsSync13(claudeMdPath) || existsSync13(agentsMdPath)) {
+  const claudeMdPath = join14(projectDir, "CLAUDE.md");
+  const agentsMdPath = join14(projectDir, "AGENTS.md");
+  if (existsSync14(claudeMdPath) || existsSync14(agentsMdPath)) {
     console.log(`  ${icons.info} CLAUDE.md or AGENTS.md already exists`);
     return true;
   }
@@ -22004,6 +23142,25 @@ var BOLD = "\x1B[1m";
 var RESET = "\x1B[0m";
 var MAGENTA = "\x1B[35m";
 var CHANGELOG = [
+  {
+    version: "0.3.14",
+    date: "2026-02-14",
+    title: "Enhanced Frustration Detection",
+    highlights: [
+      "Scan now shows exact prompts that caused frustration",
+      "Root cause analysis: hallucination, context loss, undo loops",
+      "Each frustration linked to a specific fix with install command"
+    ]
+  },
+  {
+    version: "0.3.13",
+    date: "2026-02-14",
+    title: "Reliable Recommendations",
+    highlights: [
+      "Fixed skills.sh format - skills now install correctly",
+      "New: nb doctor --verify-recommendations to validate install commands"
+    ]
+  },
   {
     version: "0.3.12",
     date: "2026-02-14",
@@ -22403,7 +23560,7 @@ function showFullChangelog() {
 // package.json
 var package_default = {
   name: "nairon-bench",
-  version: "0.3.12",
+  version: "0.3.14",
   description: "AI workflow benchmarking CLI",
   type: "module",
   bin: {
@@ -22435,8 +23592,9 @@ var package_default = {
     "build:linux-arm64": "bun build --compile --target=bun-linux-arm64 --outfile=dist/nb-linux-arm64 src/index.ts",
     "build:windows-x64": "bun build --compile --target=bun-windows-x64 --outfile=dist/nb-windows-x64.exe src/index.ts",
     typecheck: "tsc --noEmit",
-    test: "bun test",
-    "test:e2e": "bun test --test-name-pattern e2e",
+    test: "vitest run",
+    "test:e2e": "vitest run tests/e2e/",
+    "test:watch": "vitest",
     clean: "rm -rf dist",
     prepublishOnly: "bun run build"
   },
@@ -22461,9 +23619,9 @@ var versionCommand = defineCommand2({
 
 // src/commands/init.ts
 init_dist();
-import { existsSync as existsSync14 } from "node:fs";
-import { homedir as homedir11, platform as platform3, arch } from "node:os";
-import { join as join14 } from "node:path";
+import { existsSync as existsSync15 } from "node:fs";
+import { homedir as homedir12, platform as platform3, arch } from "node:os";
+import { join as join15 } from "node:path";
 init_client();
 
 // src/lib/github-auth.ts
@@ -22633,8 +23791,8 @@ var initCommand = defineCommand2({
     consola.start("Step 2/6: Detecting AI agents...");
     const detectedAgents = [];
     for (const [agent, pathTemplate] of Object.entries(AGENT_LOG_PATHS)) {
-      const resolvedPath = pathTemplate.replace("~", homedir11());
-      if (existsSync14(resolvedPath)) {
+      const resolvedPath = pathTemplate.replace("~", homedir12());
+      if (existsSync15(resolvedPath)) {
         detectedAgents.push(agent);
         consola.success(`  Found: ${agent}`);
       }
@@ -22737,7 +23895,7 @@ var initCommand = defineCommand2({
       { name: "playwright", configs: ["playwright.config.ts", "playwright.config.js"] }
     ];
     for (const fw of testFrameworks) {
-      if (fw.configs.some((c3) => existsSync14(join14(process.cwd(), c3)))) {
+      if (fw.configs.some((c3) => existsSync15(join15(process.cwd(), c3)))) {
         toolStack.testing.push(fw.name);
       }
     }
@@ -22806,13 +23964,13 @@ var initCommand = defineCommand2({
 });
 function detectPackageManager() {
   const cwd = process.cwd();
-  if (existsSync14(join14(cwd, "bun.lock")) || existsSync14(join14(cwd, "bun.lockb")))
+  if (existsSync15(join15(cwd, "bun.lock")) || existsSync15(join15(cwd, "bun.lockb")))
     return "bun";
-  if (existsSync14(join14(cwd, "pnpm-lock.yaml")))
+  if (existsSync15(join15(cwd, "pnpm-lock.yaml")))
     return "pnpm";
-  if (existsSync14(join14(cwd, "yarn.lock")))
+  if (existsSync15(join15(cwd, "yarn.lock")))
     return "yarn";
-  if (existsSync14(join14(cwd, "package-lock.json")))
+  if (existsSync15(join15(cwd, "package-lock.json")))
     return "npm";
   return;
 }
@@ -22827,15 +23985,15 @@ var CLAUDE_CODE_SKILLS = [
 ];
 function detectEasyWins(detectedAgents) {
   const wins = [];
-  const home = homedir11();
+  const home = homedir12();
   const hasClaudeCode = detectedAgents.some((a2) => a2.toLowerCase().includes("claude") || a2.toLowerCase().includes("opencode"));
-  const claudeConfigDir = join14(home, ".claude");
-  const hasClaudeConfig = existsSync14(claudeConfigDir);
+  const claudeConfigDir = join15(home, ".claude");
+  const hasClaudeConfig = existsSync15(claudeConfigDir);
   if (hasClaudeCode || hasClaudeConfig) {
-    const skillsDir = join14(home, ".claude", "skills");
+    const skillsDir = join15(home, ".claude", "skills");
     for (const skill of CLAUDE_CODE_SKILLS) {
-      const skillPath = join14(skillsDir, skill.id);
-      const isInstalled = existsSync14(skillPath);
+      const skillPath = join15(skillsDir, skill.id);
+      const isInstalled = existsSync15(skillPath);
       if (!isInstalled) {
         wins.push({
           icon: skill.icon,
@@ -22851,14 +24009,14 @@ function detectEasyWins(detectedAgents) {
 // src/commands/onboard.ts
 init_dist();
 init_client();
-import { existsSync as existsSync16, mkdirSync as mkdirSync6, readFileSync as readFileSync14, writeFileSync as writeFileSync7, readdirSync as readdirSync9 } from "node:fs";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync6, readFileSync as readFileSync15, writeFileSync as writeFileSync7, readdirSync as readdirSync9 } from "node:fs";
+import { join as join17 } from "node:path";
 
 // src/lib/project-context-detector.ts
-import { existsSync as existsSync15, readFileSync as readFileSync13, readdirSync as readdirSync8 } from "node:fs";
-import { join as join15, basename as basename3 } from "node:path";
+import { existsSync as existsSync16, readFileSync as readFileSync14, readdirSync as readdirSync8 } from "node:fs";
+import { join as join16, basename as basename4 } from "node:path";
 function detectProjectContext(projectDir) {
-  const projectName = basename3(projectDir);
+  const projectName = basename4(projectDir);
   const projectId = generateProjectId(projectDir);
   const techStack = detectTechStack(projectDir);
   const projectType = inferProjectType(projectDir, techStack);
@@ -22892,11 +24050,11 @@ function detectTechStack(projectDir) {
   };
 }
 function readPackageJson(projectDir) {
-  const pkgPath = join15(projectDir, "package.json");
-  if (!existsSync15(pkgPath))
+  const pkgPath = join16(projectDir, "package.json");
+  if (!existsSync16(pkgPath))
     return {};
   try {
-    return JSON.parse(readFileSync13(pkgPath, "utf-8"));
+    return JSON.parse(readFileSync14(pkgPath, "utf-8"));
   } catch {
     return {};
   }
@@ -22917,34 +24075,34 @@ function detectFramework(deps) {
   return null;
 }
 function detectMetaFramework(deps, projectDir) {
-  if (deps.next || existsSync15(join15(projectDir, "next.config.js")) || existsSync15(join15(projectDir, "next.config.mjs")))
+  if (deps.next || existsSync16(join16(projectDir, "next.config.js")) || existsSync16(join16(projectDir, "next.config.mjs")))
     return "next";
-  if (deps.nuxt || existsSync15(join15(projectDir, "nuxt.config.ts")))
+  if (deps.nuxt || existsSync16(join16(projectDir, "nuxt.config.ts")))
     return "nuxt";
   if (deps["@sveltejs/kit"])
     return "sveltekit";
-  if (deps.astro || existsSync15(join15(projectDir, "astro.config.mjs")))
+  if (deps.astro || existsSync16(join16(projectDir, "astro.config.mjs")))
     return "astro";
   if (deps["@remix-run/react"])
     return "remix";
   if (deps.gatsby)
     return "gatsby";
-  if (deps.vite || existsSync15(join15(projectDir, "vite.config.ts")))
+  if (deps.vite || existsSync16(join16(projectDir, "vite.config.ts")))
     return "vite";
   return null;
 }
 function detectRuntime(projectDir) {
-  if (existsSync15(join15(projectDir, "bun.lockb")) || existsSync15(join15(projectDir, "bun.lock")))
+  if (existsSync16(join16(projectDir, "bun.lockb")) || existsSync16(join16(projectDir, "bun.lock")))
     return "bun";
-  if (existsSync15(join15(projectDir, "deno.json")) || existsSync15(join15(projectDir, "deno.lock")))
+  if (existsSync16(join16(projectDir, "deno.json")) || existsSync16(join16(projectDir, "deno.lock")))
     return "deno";
   return "node";
 }
 function detectLanguage(projectDir) {
-  if (existsSync15(join15(projectDir, "tsconfig.json")))
+  if (existsSync16(join16(projectDir, "tsconfig.json")))
     return "typescript";
-  const srcDir = join15(projectDir, "src");
-  if (existsSync15(srcDir)) {
+  const srcDir = join16(projectDir, "src");
+  if (existsSync16(srcDir)) {
     try {
       const files = readdirSync8(srcDir);
       if (files.some((f3) => f3.endsWith(".ts") || f3.endsWith(".tsx")))
@@ -22955,7 +24113,7 @@ function detectLanguage(projectDir) {
 }
 function detectStyling(deps, projectDir) {
   const tools = [];
-  if (deps.tailwindcss || existsSync15(join15(projectDir, "tailwind.config.js")) || existsSync15(join15(projectDir, "tailwind.config.ts")))
+  if (deps.tailwindcss || existsSync16(join16(projectDir, "tailwind.config.js")) || existsSync16(join16(projectDir, "tailwind.config.ts")))
     tools.push("tailwind");
   if (deps["styled-components"])
     tools.push("styled-components");
@@ -23000,13 +24158,13 @@ function detectORM(deps) {
 }
 function detectTesting(deps, projectDir) {
   const tools = [];
-  if (deps.vitest || existsSync15(join15(projectDir, "vitest.config.ts")))
+  if (deps.vitest || existsSync16(join16(projectDir, "vitest.config.ts")))
     tools.push("vitest");
-  if (deps.jest || existsSync15(join15(projectDir, "jest.config.js")))
+  if (deps.jest || existsSync16(join16(projectDir, "jest.config.js")))
     tools.push("jest");
-  if (deps["@playwright/test"] || existsSync15(join15(projectDir, "playwright.config.ts")))
+  if (deps["@playwright/test"] || existsSync16(join16(projectDir, "playwright.config.ts")))
     tools.push("playwright");
-  if (deps.cypress || existsSync15(join15(projectDir, "cypress.config.ts")))
+  if (deps.cypress || existsSync16(join16(projectDir, "cypress.config.ts")))
     tools.push("cypress");
   if (deps["@testing-library/react"] || deps["@testing-library/vue"])
     tools.push("testing-library");
@@ -23038,7 +24196,7 @@ function detectBuildTools(deps, projectDir) {
     tools.push("esbuild");
   if (deps.webpack)
     tools.push("webpack");
-  if (deps.turbo || existsSync15(join15(projectDir, "turbo.json")))
+  if (deps.turbo || existsSync16(join16(projectDir, "turbo.json")))
     tools.push("turborepo");
   if (deps.tsup)
     tools.push("tsup");
@@ -23048,17 +24206,17 @@ function detectBuildTools(deps, projectDir) {
 }
 function detectDeployment(projectDir) {
   const tools = [];
-  if (existsSync15(join15(projectDir, "vercel.json")) || existsSync15(join15(projectDir, ".vercel")))
+  if (existsSync16(join16(projectDir, "vercel.json")) || existsSync16(join16(projectDir, ".vercel")))
     tools.push("vercel");
-  if (existsSync15(join15(projectDir, "netlify.toml")))
+  if (existsSync16(join16(projectDir, "netlify.toml")))
     tools.push("netlify");
-  if (existsSync15(join15(projectDir, "fly.toml")))
+  if (existsSync16(join16(projectDir, "fly.toml")))
     tools.push("fly");
-  if (existsSync15(join15(projectDir, "railway.json")))
+  if (existsSync16(join16(projectDir, "railway.json")))
     tools.push("railway");
-  if (existsSync15(join15(projectDir, "Dockerfile")))
+  if (existsSync16(join16(projectDir, "Dockerfile")))
     tools.push("docker");
-  if (existsSync15(join15(projectDir, ".github", "workflows")))
+  if (existsSync16(join16(projectDir, ".github", "workflows")))
     tools.push("github-actions");
   return tools;
 }
@@ -23081,20 +24239,20 @@ function detectAIML(deps) {
   return tools;
 }
 function inferProjectType(projectDir, techStack) {
-  if (existsSync15(join15(projectDir, "packages")) || existsSync15(join15(projectDir, "apps"))) {
+  if (existsSync16(join16(projectDir, "packages")) || existsSync16(join16(projectDir, "apps"))) {
     return "monorepo";
   }
   const pkg = readPackageJson(projectDir);
-  if (pkg.bin || existsSync15(join15(projectDir, "src", "cli.ts")) || existsSync15(join15(projectDir, "src", "index.ts"))) {
+  if (pkg.bin || existsSync16(join16(projectDir, "src", "cli.ts")) || existsSync16(join16(projectDir, "src", "index.ts"))) {
     const hasBin = !!pkg.bin;
-    const hasCommands = existsSync15(join15(projectDir, "src", "commands"));
+    const hasCommands = existsSync16(join16(projectDir, "src", "commands"));
     if (hasBin || hasCommands)
       return "cli";
   }
   if (!techStack.framework && !techStack.metaFramework && pkg.main) {
     return "library";
   }
-  if (existsSync15(join15(projectDir, "app.json")) || existsSync15(join15(projectDir, "expo"))) {
+  if (existsSync16(join16(projectDir, "app.json")) || existsSync16(join16(projectDir, "expo"))) {
     return "mobile";
   }
   if (techStack.database.length > 0 && !techStack.framework) {
@@ -23111,10 +24269,10 @@ function extractDescription(projectDir) {
     return pkg.description;
   const readmePaths = ["README.md", "readme.md", "Readme.md"];
   for (const readme of readmePaths) {
-    const path = join15(projectDir, readme);
-    if (existsSync15(path)) {
+    const path = join16(projectDir, readme);
+    if (existsSync16(path)) {
       try {
-        const content = readFileSync13(path, "utf-8");
+        const content = readFileSync14(path, "utf-8");
         const lines = content.split(`
 `);
         let foundTitle = false;
@@ -24532,9 +25690,9 @@ var onboardCommand = defineCommand2({
   },
   async run({ args }) {
     const projectPath = process.cwd();
-    const contextPath = join16(projectPath, ".nairon", "context.json");
-    if (existsSync16(contextPath) && !args.force) {
-      const existing = JSON.parse(readFileSync14(contextPath, "utf-8"));
+    const contextPath = join17(projectPath, ".nairon", "context.json");
+    if (existsSync17(contextPath) && !args.force) {
+      const existing = JSON.parse(readFileSync15(contextPath, "utf-8"));
       consola.info("Project already onboarded. Use --force to re-run.");
       consola.info(`Business: ${existing.businessContext?.domain || existing.businessContext?.slice?.(0, 50) || "Not set"}...`);
       consola.info(`Stack: ${formatTechStackSummary(existing)}`);
@@ -24682,8 +25840,8 @@ var onboardCommand = defineCommand2({
       createdAt: new Date().toISOString(),
       updatedAt: new Date().toISOString()
     };
-    const naironDir = join16(projectPath, ".nairon");
-    if (!existsSync16(naironDir)) {
+    const naironDir = join17(projectPath, ".nairon");
+    if (!existsSync17(naironDir)) {
       mkdirSync6(naironDir, { recursive: true });
     }
     writeFileSync7(contextPath, JSON.stringify(fullContext, null, 2));
@@ -24774,51 +25932,51 @@ function formatTechStackSummary(context) {
 function detectInstalledTools(projectPath) {
   const tools = [];
   const home = process.env.HOME || "";
-  const userClaudeJson = join16(home, ".claude.json");
-  if (existsSync16(userClaudeJson)) {
+  const userClaudeJson = join17(home, ".claude.json");
+  if (existsSync17(userClaudeJson)) {
     try {
-      const config = JSON.parse(readFileSync14(userClaudeJson, "utf-8"));
+      const config = JSON.parse(readFileSync15(userClaudeJson, "utf-8"));
       if (config.mcpServers) {
         tools.push(...Object.keys(config.mcpServers));
       }
     } catch {}
   }
-  const claudeDesktopConfig = join16(home, ".claude", "claude_desktop_config.json");
-  if (existsSync16(claudeDesktopConfig)) {
+  const claudeDesktopConfig = join17(home, ".claude", "claude_desktop_config.json");
+  if (existsSync17(claudeDesktopConfig)) {
     try {
-      const config = JSON.parse(readFileSync14(claudeDesktopConfig, "utf-8"));
+      const config = JSON.parse(readFileSync15(claudeDesktopConfig, "utf-8"));
       if (config.mcpServers) {
         tools.push(...Object.keys(config.mcpServers));
       }
     } catch {}
   }
-  const projectMcpJson = join16(projectPath, ".mcp.json");
-  if (existsSync16(projectMcpJson)) {
+  const projectMcpJson = join17(projectPath, ".mcp.json");
+  if (existsSync17(projectMcpJson)) {
     try {
-      const config = JSON.parse(readFileSync14(projectMcpJson, "utf-8"));
+      const config = JSON.parse(readFileSync15(projectMcpJson, "utf-8"));
       if (config.mcpServers) {
         tools.push(...Object.keys(config.mcpServers));
       }
     } catch {}
   }
-  const projectClaudeConfig = join16(projectPath, ".claude", "settings.json");
-  if (existsSync16(projectClaudeConfig)) {
+  const projectClaudeConfig = join17(projectPath, ".claude", "settings.json");
+  if (existsSync17(projectClaudeConfig)) {
     try {
-      const config = JSON.parse(readFileSync14(projectClaudeConfig, "utf-8"));
+      const config = JSON.parse(readFileSync15(projectClaudeConfig, "utf-8"));
       if (config.mcpServers) {
         tools.push(...Object.keys(config.mcpServers));
       }
     } catch {}
   }
-  const skillsDir = join16(home, ".config", "opencode", "skills");
-  if (existsSync16(skillsDir)) {
+  const skillsDir = join17(home, ".config", "opencode", "skills");
+  if (existsSync17(skillsDir)) {
     try {
       const skills = readdirSync9(skillsDir);
       tools.push(...skills.filter((s2) => !s2.startsWith(".")));
     } catch {}
   }
-  const agentsSkillsDir = join16(home, ".agents", "skills");
-  if (existsSync16(agentsSkillsDir)) {
+  const agentsSkillsDir = join17(home, ".agents", "skills");
+  if (existsSync17(agentsSkillsDir)) {
     try {
       const skills = readdirSync9(agentsSkillsDir);
       tools.push(...skills.filter((s2) => !s2.startsWith(".")));
@@ -24828,11 +25986,11 @@ function detectInstalledTools(projectPath) {
 }
 function detectPrimaryAgent() {
   const home = process.env.HOME || "";
-  if (existsSync16(join16(home, ".claude")))
+  if (existsSync17(join17(home, ".claude")))
     return "claude-code";
-  if (existsSync16(join16(home, ".cursor")))
+  if (existsSync17(join17(home, ".cursor")))
     return "cursor";
-  if (existsSync16(join16(home, ".config", "opencode")))
+  if (existsSync17(join17(home, ".config", "opencode")))
     return "opencode";
   return;
 }
@@ -24927,7 +26085,7 @@ function formatBytes(bytes) {
 // package.json
 var package_default2 = {
   name: "nairon-bench",
-  version: "0.3.12",
+  version: "0.3.14",
   description: "AI workflow benchmarking CLI",
   type: "module",
   bin: {
@@ -24959,8 +26117,9 @@ var package_default2 = {
     "build:linux-arm64": "bun build --compile --target=bun-linux-arm64 --outfile=dist/nb-linux-arm64 src/index.ts",
     "build:windows-x64": "bun build --compile --target=bun-windows-x64 --outfile=dist/nb-windows-x64.exe src/index.ts",
     typecheck: "tsc --noEmit",
-    test: "bun test",
-    "test:e2e": "bun test --test-name-pattern e2e",
+    test: "vitest run",
+    "test:e2e": "vitest run tests/e2e/",
+    "test:watch": "vitest",
     clean: "rm -rf dist",
     prepublishOnly: "bun run build"
   },