nairon-bench 0.3.13 → 0.3.15

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);
@@ -11458,854 +11458,448 @@ 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 {}
+  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;
     }
   }
-  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;
+  if ("TF_BUILD" in env2 && "AGENT_NAME" in env2) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === undefined) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env2.TERM === "dumb") {
+    return min;
+  }
+  if (process2.platform === "win32") {
+    const osRelease = os.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env2) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env2))) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env2)) || env2.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env2) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env2.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env2.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env2.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env2.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env2.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env2) {
+    const version2 = Number.parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env2.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version2 >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
       }
     }
-    return true;
+  }
+  if (/-256(color)?$/i.test(env2.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env2.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env2) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
   });
+  return translateLevel(level);
 }
-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
-    }
-  ]
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: tty2.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: tty2.isatty(2) })
 };
+var supports_color_default = supportsColor;
 
-// ../../node_modules/ora/index.js
-import process8 from "node:process";
-import { stripVTControlCharacters } from "node:util";
+// ../../node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? `\r
+` : `
+`) + postfix;
+    endIndex = index + 1;
+    index = string.indexOf(`
+`, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
 
-// ../../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]
+// ../../node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
+var GENERATOR = Symbol("GENERATOR");
+var STYLER = Symbol("STYLER");
+var IS_EMPTY = Symbol("IS_EMPTY");
+var levelMapping = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+var styles2 = Object.create(null);
+var applyOptions = (object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
   }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object.level = options.level === undefined ? colorLevel : options.level;
 };
-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;
+var chalkFactory = (options) => {
+  const chalk = (...strings) => strings.join(" ");
+  applyOptions(chalk, options);
+  Object.setPrototypeOf(chalk, createChalk.prototype);
+  return chalk;
+};
+function createChalk(options) {
+  return chalkFactory(options);
 }
-function envForceColor() {
-  if ("FORCE_COLOR" in env2) {
-    if (env2.FORCE_COLOR === "true") {
-      return 1;
-    }
-    if (env2.FORCE_COLOR === "false") {
-      return 0;
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+  styles2[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
     }
-    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;
+styles2.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
   }
-  if (sniffFlags) {
-    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-      return 3;
+};
+var getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
     }
-    if (hasFlag("color=256")) {
-      return 2;
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
     }
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
   }
-  if ("TF_BUILD" in env2 && "AGENT_NAME" in env2) {
-    return 1;
-  }
-  if (haveStream && !streamIsTTY && forceColor === undefined) {
-    return 0;
-  }
-  const min = forceColor || 0;
-  if (env2.TERM === "dumb") {
-    return min;
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
   }
-  if (process2.platform === "win32") {
-    const osRelease = os.release().split(".");
-    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
-      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+  return ansi_styles_default[type][model](...arguments_);
+};
+var usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  styles2[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
     }
-    return 1;
-  }
-  if ("CI" in env2) {
-    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env2))) {
-      return 3;
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles2[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
     }
-    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env2)) || env2.CI_NAME === "codeship") {
-      return 1;
-    }
-    return min;
-  }
-  if ("TEAMCITY_VERSION" in env2) {
-    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env2.TEAMCITY_VERSION) ? 1 : 0;
-  }
-  if (env2.COLORTERM === "truecolor") {
-    return 3;
-  }
-  if (env2.TERM === "xterm-kitty") {
-    return 3;
-  }
-  if (env2.TERM === "xterm-ghostty") {
-    return 3;
-  }
-  if (env2.TERM === "wezterm") {
-    return 3;
-  }
-  if ("TERM_PROGRAM" in env2) {
-    const version2 = Number.parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-    switch (env2.TERM_PROGRAM) {
-      case "iTerm.app": {
-        return version2 >= 3 ? 3 : 2;
-      }
-      case "Apple_Terminal": {
-        return 2;
-      }
-    }
-  }
-  if (/-256(color)?$/i.test(env2.TERM)) {
-    return 2;
-  }
-  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env2.TERM)) {
-    return 1;
-  }
-  if ("COLORTERM" in env2) {
-    return 1;
-  }
-  return min;
-}
-function createSupportsColor(stream, options = {}) {
-  const level = _supportsColor(stream, {
-    streamIsTTY: stream && stream.isTTY,
-    ...options
-  });
-  return translateLevel(level);
-}
-var supportsColor = {
-  stdout: createSupportsColor({ isTTY: tty2.isatty(1) }),
-  stderr: createSupportsColor({ isTTY: tty2.isatty(2) })
-};
-var supports_color_default = supportsColor;
-
-// ../../node_modules/chalk/source/utilities.js
-function stringReplaceAll(string, substring, replacer) {
-  let index = string.indexOf(substring);
-  if (index === -1) {
-    return string;
-  }
-  const substringLength = substring.length;
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    returnValue += string.slice(endIndex, index) + substring + replacer;
-    endIndex = index + substringLength;
-    index = string.indexOf(substring, endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
-}
-function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    const gotCR = string[index - 1] === "\r";
-    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? `\r
-` : `
-`) + postfix;
-    endIndex = index + 1;
-    index = string.indexOf(`
-`, endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
-}
-
-// ../../node_modules/chalk/source/index.js
-var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
-var GENERATOR = Symbol("GENERATOR");
-var STYLER = Symbol("STYLER");
-var IS_EMPTY = Symbol("IS_EMPTY");
-var levelMapping = [
-  "ansi",
-  "ansi",
-  "ansi256",
-  "ansi16m"
-];
-var styles2 = Object.create(null);
-var applyOptions = (object, options = {}) => {
-  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
-    throw new Error("The `level` option should be an integer from 0 to 3");
-  }
-  const colorLevel = stdoutColor ? stdoutColor.level : 0;
-  object.level = options.level === undefined ? colorLevel : options.level;
-};
-var chalkFactory = (options) => {
-  const chalk = (...strings) => strings.join(" ");
-  applyOptions(chalk, options);
-  Object.setPrototypeOf(chalk, createChalk.prototype);
-  return chalk;
-};
-function createChalk(options) {
-  return chalkFactory(options);
-}
-Object.setPrototypeOf(createChalk.prototype, Function.prototype);
-for (const [styleName, style] of Object.entries(ansi_styles_default)) {
-  styles2[styleName] = {
-    get() {
-      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
-      Object.defineProperty(this, styleName, { value: builder });
-      return builder;
-    }
-  };
-}
-styles2.visible = {
-  get() {
-    const builder = createBuilder(this, this[STYLER], true);
-    Object.defineProperty(this, "visible", { value: builder });
-    return builder;
-  }
-};
-var getModelAnsi = (model, level, type, ...arguments_) => {
-  if (model === "rgb") {
-    if (level === "ansi16m") {
-      return ansi_styles_default[type].ansi16m(...arguments_);
-    }
-    if (level === "ansi256") {
-      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
-    }
-    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
-  }
-  if (model === "hex") {
-    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
-  }
-  return ansi_styles_default[type][model](...arguments_);
-};
-var usedModels = ["rgb", "hex", "ansi256"];
-for (const model of usedModels) {
-  styles2[model] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
-    }
-  };
-  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
-  styles2[bgModel] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
-    }
-  };
-}
-var proto = Object.defineProperties(() => {}, {
-  ...styles2,
-  level: {
-    enumerable: true,
-    get() {
-      return this[GENERATOR].level;
-    },
-    set(level) {
-      this[GENERATOR].level = level;
+  };
+}
+var proto = Object.defineProperties(() => {}, {
+  ...styles2,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
     }
   }
 });
@@ -14524,748 +14118,1662 @@ function validate2(codePoint) {
   if (!Number.isSafeInteger(codePoint)) {
     throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
   }
-}
-function eastAsianWidth2(codePoint, { ambiguousAsWide = false } = {}) {
-  validate2(codePoint);
-  if (isFullWidth2(codePoint) || isWide2(codePoint) || ambiguousAsWide && isAmbiguous2(codePoint)) {
-    return 2;
+}
+function eastAsianWidth2(codePoint, { ambiguousAsWide = false } = {}) {
+  validate2(codePoint);
+  if (isFullWidth2(codePoint) || isWide2(codePoint) || ambiguousAsWide && isAmbiguous2(codePoint)) {
+    return 2;
+  }
+  return 1;
+}
+
+// ../../node_modules/string-width/index.js
+var segmenter2 = new Intl.Segmenter;
+var zeroWidthClusterRegex = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Format}|\p{Mark}|\p{Surrogate})+$/v;
+var leadingNonPrintingRegex = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Mark}\p{Surrogate}]+/v;
+var rgiEmojiRegex = /^\p{RGI_Emoji}$/v;
+function baseVisible(segment) {
+  return segment.replace(leadingNonPrintingRegex, "");
+}
+function isZeroWidthCluster(segment) {
+  return zeroWidthClusterRegex.test(segment);
+}
+function trailingHalfwidthWidth(segment, eastAsianWidthOptions) {
+  let extra = 0;
+  if (segment.length > 1) {
+    for (const char of segment.slice(1)) {
+      if (char >= "＀" && char <= "￯") {
+        extra += eastAsianWidth2(char.codePointAt(0), eastAsianWidthOptions);
+      }
+    }
+  }
+  return extra;
+}
+function stringWidth2(input, options = {}) {
+  if (typeof input !== "string" || input.length === 0) {
+    return 0;
+  }
+  const {
+    ambiguousIsNarrow = true,
+    countAnsiEscapeCodes = false
+  } = options;
+  let string = input;
+  if (!countAnsiEscapeCodes) {
+    string = stripAnsi3(string);
+  }
+  if (string.length === 0) {
+    return 0;
+  }
+  let width = 0;
+  const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
+  for (const { segment } of segmenter2.segment(string)) {
+    if (isZeroWidthCluster(segment)) {
+      continue;
+    }
+    if (rgiEmojiRegex.test(segment)) {
+      width += 2;
+      continue;
+    }
+    const codePoint = baseVisible(segment).codePointAt(0);
+    width += eastAsianWidth2(codePoint, eastAsianWidthOptions);
+    width += trailingHalfwidthWidth(segment, eastAsianWidthOptions);
+  }
+  return width;
+}
+
+// ../../node_modules/is-interactive/index.js
+function isInteractive({ stream = process.stdout } = {}) {
+  return Boolean(stream && stream.isTTY && process.env.TERM !== "dumb" && !("CI" in process.env));
+}
+
+// ../../node_modules/stdin-discarder/index.js
+import process7 from "node:process";
+var ASCII_ETX_CODE = 3;
+
+class StdinDiscarder {
+  #activeCount = 0;
+  #stdin;
+  #stdinWasPaused = false;
+  #stdinWasRaw = false;
+  #handleInputBound = (chunk) => {
+    if (!chunk?.length) {
+      return;
+    }
+    const code2 = typeof chunk === "string" ? chunk.codePointAt(0) : chunk[0];
+    if (code2 === ASCII_ETX_CODE) {
+      if (process7.listenerCount("SIGINT") > 0) {
+        process7.emit("SIGINT");
+      } else {
+        process7.kill(process7.pid, "SIGINT");
+      }
+    }
+  };
+  start() {
+    this.#activeCount++;
+    if (this.#activeCount === 1) {
+      this.#realStart();
+    }
+  }
+  stop() {
+    if (this.#activeCount === 0) {
+      return;
+    }
+    if (--this.#activeCount === 0) {
+      this.#realStop();
+    }
+  }
+  #realStart() {
+    const { stdin: stdin2 } = process7;
+    if (process7.platform === "win32" || !stdin2?.isTTY || typeof stdin2.setRawMode !== "function") {
+      this.#stdin = undefined;
+      return;
+    }
+    this.#stdin = stdin2;
+    this.#stdinWasPaused = stdin2.isPaused();
+    this.#stdinWasRaw = Boolean(stdin2.isRaw);
+    stdin2.setRawMode(true);
+    stdin2.prependListener("data", this.#handleInputBound);
+    if (this.#stdinWasPaused) {
+      stdin2.resume();
+    }
+  }
+  #realStop() {
+    if (!this.#stdin) {
+      return;
+    }
+    const stdin2 = this.#stdin;
+    stdin2.off("data", this.#handleInputBound);
+    if (stdin2.isTTY) {
+      stdin2.setRawMode?.(this.#stdinWasRaw);
+    }
+    if (this.#stdinWasPaused) {
+      stdin2.pause();
+    }
+    this.#stdin = undefined;
+    this.#stdinWasPaused = false;
+    this.#stdinWasRaw = false;
+  }
+}
+var stdinDiscarder = new StdinDiscarder;
+var stdin_discarder_default = Object.freeze(stdinDiscarder);
+
+// ../../node_modules/ora/index.js
+var RENDER_DEFERRAL_TIMEOUT = 200;
+var SYNCHRONIZED_OUTPUT_ENABLE = "\x1B[?2026h";
+var SYNCHRONIZED_OUTPUT_DISABLE = "\x1B[?2026l";
+var activeHooksPerStream = new Map;
+
+class Ora {
+  #linesToClear = 0;
+  #frameIndex = -1;
+  #lastFrameTime = 0;
+  #options;
+  #spinner;
+  #stream;
+  #id;
+  #hookedStreams = new Map;
+  #isInternalWrite = false;
+  #drainHandler;
+  #deferRenderTimer;
+  #isDiscardingStdin = false;
+  color;
+  #internalWrite(fn) {
+    this.#isInternalWrite = true;
+    try {
+      return fn();
+    } finally {
+      this.#isInternalWrite = false;
+    }
+  }
+  #tryRender() {
+    if (this.isSpinning) {
+      this.render();
+    }
+  }
+  #stringifyChunk(chunk, encoding) {
+    if (chunk === undefined || chunk === null) {
+      return "";
+    }
+    if (typeof chunk === "string") {
+      return chunk;
+    }
+    if (Buffer.isBuffer(chunk) || ArrayBuffer.isView(chunk)) {
+      const normalizedEncoding = typeof encoding === "string" && encoding && encoding !== "buffer" ? encoding : "utf8";
+      return Buffer.from(chunk).toString(normalizedEncoding);
+    }
+    return String(chunk);
+  }
+  #chunkTerminatesLine(chunkString) {
+    if (!chunkString) {
+      return false;
+    }
+    const lastCharacter = chunkString.at(-1);
+    return lastCharacter === `
+` || lastCharacter === "\r";
+  }
+  #scheduleRenderDeferral() {
+    if (this.#deferRenderTimer) {
+      return;
+    }
+    this.#deferRenderTimer = setTimeout(() => {
+      this.#deferRenderTimer = undefined;
+      if (this.isSpinning) {
+        this.#tryRender();
+      }
+    }, RENDER_DEFERRAL_TIMEOUT);
+    if (typeof this.#deferRenderTimer?.unref === "function") {
+      this.#deferRenderTimer.unref();
+    }
+  }
+  #clearRenderDeferral() {
+    if (this.#deferRenderTimer) {
+      clearTimeout(this.#deferRenderTimer);
+      this.#deferRenderTimer = undefined;
+    }
+  }
+  #buildOutputLine(symbol, text, prefixText, suffixText) {
+    const fullPrefixText = this.#getFullPrefixText(prefixText, " ");
+    const separatorText = symbol ? " " : "";
+    const fullText = typeof text === "string" ? separatorText + text : "";
+    const fullSuffixText = this.#getFullSuffixText(suffixText, " ");
+    return fullPrefixText + symbol + fullText + fullSuffixText;
+  }
+  constructor(options) {
+    if (typeof options === "string") {
+      options = {
+        text: options
+      };
+    }
+    this.#options = {
+      color: "cyan",
+      stream: process8.stderr,
+      discardStdin: true,
+      hideCursor: true,
+      ...options
+    };
+    this.color = this.#options.color;
+    this.#stream = this.#options.stream;
+    if (typeof this.#options.isEnabled !== "boolean") {
+      this.#options.isEnabled = isInteractive({ stream: this.#stream });
+    }
+    if (typeof this.#options.isSilent !== "boolean") {
+      this.#options.isSilent = false;
+    }
+    const userInterval = this.#options.interval;
+    this.spinner = this.#options.spinner;
+    this.#options.interval = userInterval;
+    this.text = this.#options.text;
+    this.prefixText = this.#options.prefixText;
+    this.suffixText = this.#options.suffixText;
+    this.indent = this.#options.indent;
+    if (process8.env.NODE_ENV === "test") {
+      this._stream = this.#stream;
+      this._isEnabled = this.#options.isEnabled;
+      Object.defineProperty(this, "_linesToClear", {
+        get() {
+          return this.#linesToClear;
+        },
+        set(newValue) {
+          this.#linesToClear = newValue;
+        }
+      });
+      Object.defineProperty(this, "_frameIndex", {
+        get() {
+          return this.#frameIndex;
+        }
+      });
+      Object.defineProperty(this, "_lineCount", {
+        get() {
+          const columns = this.#stream.columns ?? 80;
+          const prefixText = typeof this.#options.prefixText === "function" ? "" : this.#options.prefixText;
+          const suffixText = typeof this.#options.suffixText === "function" ? "" : this.#options.suffixText;
+          const fullPrefixText = typeof prefixText === "string" && prefixText !== "" ? prefixText + " " : "";
+          const fullSuffixText = typeof suffixText === "string" && suffixText !== "" ? " " + suffixText : "";
+          const spinnerChar = "-";
+          const fullText = " ".repeat(this.#options.indent) + fullPrefixText + spinnerChar + (typeof this.#options.text === "string" ? " " + this.#options.text : "") + fullSuffixText;
+          return this.#computeLineCountFrom(fullText, columns);
+        }
+      });
+    }
+  }
+  get indent() {
+    return this.#options.indent;
+  }
+  set indent(indent = 0) {
+    if (!(indent >= 0 && Number.isInteger(indent))) {
+      throw new Error("The `indent` option must be an integer from 0 and up");
+    }
+    this.#options.indent = indent;
+  }
+  get interval() {
+    return this.#options.interval ?? this.#spinner.interval ?? 100;
+  }
+  get spinner() {
+    return this.#spinner;
+  }
+  set spinner(spinner) {
+    this.#frameIndex = -1;
+    this.#options.interval = undefined;
+    if (typeof spinner === "object") {
+      if (!Array.isArray(spinner.frames) || spinner.frames.length === 0 || spinner.frames.some((frame) => typeof frame !== "string")) {
+        throw new Error("The given spinner must have a non-empty `frames` array of strings");
+      }
+      if (spinner.interval !== undefined && !(Number.isInteger(spinner.interval) && spinner.interval > 0)) {
+        throw new Error("`spinner.interval` must be a positive integer if provided");
+      }
+      this.#spinner = spinner;
+    } else if (!isUnicodeSupported2()) {
+      this.#spinner = cli_spinners_default.line;
+    } else if (spinner === undefined) {
+      this.#spinner = cli_spinners_default.dots;
+    } else if (spinner !== "default" && cli_spinners_default[spinner]) {
+      this.#spinner = cli_spinners_default[spinner];
+    } else {
+      throw new Error(`There is no built-in spinner named '${spinner}'. See https://github.com/sindresorhus/cli-spinners/blob/main/spinners.json for a full list.`);
+    }
+  }
+  get text() {
+    return this.#options.text;
+  }
+  set text(value = "") {
+    this.#options.text = value;
+  }
+  get prefixText() {
+    return this.#options.prefixText;
   }
-  return 1;
-}
-
-// ../../node_modules/string-width/index.js
-var segmenter2 = new Intl.Segmenter;
-var zeroWidthClusterRegex = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Format}|\p{Mark}|\p{Surrogate})+$/v;
-var leadingNonPrintingRegex = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Mark}\p{Surrogate}]+/v;
-var rgiEmojiRegex = /^\p{RGI_Emoji}$/v;
-function baseVisible(segment) {
-  return segment.replace(leadingNonPrintingRegex, "");
-}
-function isZeroWidthCluster(segment) {
-  return zeroWidthClusterRegex.test(segment);
-}
-function trailingHalfwidthWidth(segment, eastAsianWidthOptions) {
-  let extra = 0;
-  if (segment.length > 1) {
-    for (const char of segment.slice(1)) {
-      if (char >= "＀" && char <= "￯") {
-        extra += eastAsianWidth2(char.codePointAt(0), eastAsianWidthOptions);
-      }
+  set prefixText(value = "") {
+    this.#options.prefixText = value;
+  }
+  get suffixText() {
+    return this.#options.suffixText;
+  }
+  set suffixText(value = "") {
+    this.#options.suffixText = value;
+  }
+  get isSpinning() {
+    return this.#id !== undefined;
+  }
+  #formatAffix(value, separator, placeBefore = false) {
+    const resolved = typeof value === "function" ? value() : value;
+    if (typeof resolved === "string" && resolved !== "") {
+      return placeBefore ? separator + resolved : resolved + separator;
     }
+    return "";
   }
-  return extra;
-}
-function stringWidth2(input, options = {}) {
-  if (typeof input !== "string" || input.length === 0) {
-    return 0;
+  #getFullPrefixText(prefixText = this.#options.prefixText, postfix = " ") {
+    return this.#formatAffix(prefixText, postfix, false);
   }
-  const {
-    ambiguousIsNarrow = true,
-    countAnsiEscapeCodes = false
-  } = options;
-  let string = input;
-  if (!countAnsiEscapeCodes) {
-    string = stripAnsi3(string);
+  #getFullSuffixText(suffixText = this.#options.suffixText, prefix = " ") {
+    return this.#formatAffix(suffixText, prefix, true);
   }
-  if (string.length === 0) {
-    return 0;
+  #computeLineCountFrom(text, columns) {
+    let count = 0;
+    for (const line of stripVTControlCharacters(text).split(`
+`)) {
+      count += Math.max(1, Math.ceil(stringWidth2(line) / columns));
+    }
+    return count;
   }
-  let width = 0;
-  const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
-  for (const { segment } of segmenter2.segment(string)) {
-    if (isZeroWidthCluster(segment)) {
-      continue;
+  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");
     }
-    if (rgiEmojiRegex.test(segment)) {
-      width += 2;
-      continue;
+    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");
     }
-    const codePoint = baseVisible(segment).codePointAt(0);
-    width += eastAsianWidth2(codePoint, eastAsianWidthOptions);
-    width += trailingHalfwidthWidth(segment, eastAsianWidthOptions);
+    this.#options.isSilent = value;
   }
-  return width;
-}
-
-// ../../node_modules/is-interactive/index.js
-function isInteractive({ stream = process.stdout } = {}) {
-  return Boolean(stream && stream.isTTY && process.env.TERM !== "dumb" && !("CI" in process.env));
-}
-
-// ../../node_modules/stdin-discarder/index.js
-import process7 from "node:process";
-var ASCII_ETX_CODE = 3;
-
-class StdinDiscarder {
-  #activeCount = 0;
-  #stdin;
-  #stdinWasPaused = false;
-  #stdinWasRaw = false;
-  #handleInputBound = (chunk) => {
-    if (!chunk?.length) {
-      return;
+  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 code2 = typeof chunk === "string" ? chunk.codePointAt(0) : chunk[0];
-    if (code2 === ASCII_ETX_CODE) {
-      if (process7.listenerCount("SIGINT") > 0) {
-        process7.emit("SIGINT");
-      } else {
-        process7.kill(process7.pid, "SIGINT");
-      }
+    const { frames } = this.#spinner;
+    let frame = frames[this.#frameIndex];
+    if (this.color) {
+      frame = source_default[this.color](frame);
     }
-  };
-  start() {
-    this.#activeCount++;
-    if (this.#activeCount === 1) {
-      this.#realStart();
+    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;
   }
-  stop() {
-    if (this.#activeCount === 0) {
+  #hookStream(stream) {
+    if (!stream || this.#hookedStreams.has(stream) || !stream.isTTY || typeof stream.write !== "function") {
       return;
     }
-    if (--this.#activeCount === 0) {
-      this.#realStop();
+    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);
   }
-  #realStart() {
-    const { stdin: stdin2 } = process7;
-    if (process7.platform === "win32" || !stdin2?.isTTY || typeof stdin2.setRawMode !== "function") {
-      this.#stdin = undefined;
+  #installHook() {
+    if (!this.isEnabled || this.#hookedStreams.size > 0) {
       return;
     }
-    this.#stdin = stdin2;
-    this.#stdinWasPaused = stdin2.isPaused();
-    this.#stdinWasRaw = Boolean(stdin2.isRaw);
-    stdin2.setRawMode(true);
-    stdin2.prependListener("data", this.#handleInputBound);
-    if (this.#stdinWasPaused) {
-      stdin2.resume();
+    const streamsToHook = new Set([this.#stream, process8.stdout, process8.stderr]);
+    for (const stream of streamsToHook) {
+      this.#hookStream(stream);
     }
   }
-  #realStop() {
-    if (!this.#stdin) {
-      return;
+  #uninstallHook() {
+    for (const [stream, originalWrite] of this.#hookedStreams) {
+      stream.write = originalWrite;
+      if (activeHooksPerStream.get(stream) === this) {
+        activeHooksPerStream.delete(stream);
+      }
     }
-    const stdin2 = this.#stdin;
-    stdin2.off("data", this.#handleInputBound);
-    if (stdin2.isTTY) {
-      stdin2.setRawMode?.(this.#stdinWasRaw);
+    this.#hookedStreams.clear();
+  }
+  #hookedWrite(stream, originalWrite, chunk, encoding, callback) {
+    if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = undefined;
     }
-    if (this.#stdinWasPaused) {
-      stdin2.pause();
+    if (this.#isInternalWrite) {
+      return originalWrite.call(stream, chunk, encoding, callback);
     }
-    this.#stdin = undefined;
-    this.#stdinWasPaused = false;
-    this.#stdinWasRaw = false;
+    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;
   }
-}
-var stdinDiscarder = new StdinDiscarder;
-var stdin_discarder_default = Object.freeze(stdinDiscarder);
-
-// ../../node_modules/ora/index.js
-var RENDER_DEFERRAL_TIMEOUT = 200;
-var SYNCHRONIZED_OUTPUT_ENABLE = "\x1B[?2026h";
-var SYNCHRONIZED_OUTPUT_DISABLE = "\x1B[?2026l";
-var activeHooksPerStream = new Map;
-
-class Ora {
-  #linesToClear = 0;
-  #frameIndex = -1;
-  #lastFrameTime = 0;
-  #options;
-  #spinner;
-  #stream;
-  #id;
-  #hookedStreams = new Map;
-  #isInternalWrite = false;
-  #drainHandler;
-  #deferRenderTimer;
-  #isDiscardingStdin = false;
-  color;
-  #internalWrite(fn) {
-    this.#isInternalWrite = true;
+  render() {
+    if (!this.isEnabled || this.#drainHandler || this.#deferRenderTimer) {
+      return this;
+    }
+    const useSynchronizedOutput = this.#stream.isTTY;
+    let shouldDisableSynchronizedOutput = false;
     try {
-      return fn();
+      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 {
-      this.#isInternalWrite = false;
+      if (shouldDisableSynchronizedOutput) {
+        this.#internalWrite(() => this.#stream.write(SYNCHRONIZED_OUTPUT_DISABLE));
+      }
     }
+    return this;
   }
-  #tryRender() {
-    if (this.isSpinning) {
-      this.render();
+  start(text) {
+    if (text) {
+      this.text = text;
     }
-  }
-  #stringifyChunk(chunk, encoding) {
-    if (chunk === undefined || chunk === null) {
-      return "";
+    if (this.isSilent) {
+      return this;
     }
-    if (typeof chunk === "string") {
-      return chunk;
+    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 (Buffer.isBuffer(chunk) || ArrayBuffer.isView(chunk)) {
-      const normalizedEncoding = typeof encoding === "string" && encoding && encoding !== "buffer" ? encoding : "utf8";
-      return Buffer.from(chunk).toString(normalizedEncoding);
+    if (this.isSpinning) {
+      return this;
     }
-    return String(chunk);
-  }
-  #chunkTerminatesLine(chunkString) {
-    if (!chunkString) {
-      return false;
+    if (this.#options.hideCursor) {
+      cli_cursor_default.hide(this.#stream);
     }
-    const lastCharacter = chunkString.at(-1);
-    return lastCharacter === `
-` || lastCharacter === "\r";
+    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;
   }
-  #scheduleRenderDeferral() {
-    if (this.#deferRenderTimer) {
-      return;
+  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.#deferRenderTimer = setTimeout(() => {
-      this.#deferRenderTimer = undefined;
-      if (this.isSpinning) {
-        this.#tryRender();
+    if (this.isEnabled) {
+      this.clear();
+      if (this.#options.hideCursor) {
+        cli_cursor_default.show(this.#stream);
       }
-    }, RENDER_DEFERRAL_TIMEOUT);
-    if (typeof this.#deferRenderTimer?.unref === "function") {
-      this.#deferRenderTimer.unref();
     }
-  }
-  #clearRenderDeferral() {
-    if (this.#deferRenderTimer) {
-      clearTimeout(this.#deferRenderTimer);
-      this.#deferRenderTimer = undefined;
+    if (this.#isDiscardingStdin) {
+      this.#isDiscardingStdin = false;
+      stdin_discarder_default.stop();
     }
+    return this;
   }
-  #buildOutputLine(symbol, text, prefixText, suffixText) {
-    const fullPrefixText = this.#getFullPrefixText(prefixText, " ");
-    const separatorText = symbol ? " " : "";
-    const fullText = typeof text === "string" ? separatorText + text : "";
-    const fullSuffixText = this.#getFullSuffixText(suffixText, " ");
-    return fullPrefixText + symbol + fullText + fullSuffixText;
+  succeed(text) {
+    return this.stopAndPersist({ symbol: exports_symbols.success, text });
   }
-  constructor(options) {
-    if (typeof options === "string") {
-      options = {
-        text: options
-      };
-    }
-    this.#options = {
-      color: "cyan",
-      stream: process8.stderr,
-      discardStdin: true,
-      hideCursor: true,
-      ...options
-    };
-    this.color = this.#options.color;
-    this.#stream = this.#options.stream;
-    if (typeof this.#options.isEnabled !== "boolean") {
-      this.#options.isEnabled = isInteractive({ stream: this.#stream });
-    }
-    if (typeof this.#options.isSilent !== "boolean") {
-      this.#options.isSilent = false;
-    }
-    const userInterval = this.#options.interval;
-    this.spinner = this.#options.spinner;
-    this.#options.interval = userInterval;
-    this.text = this.#options.text;
-    this.prefixText = this.#options.prefixText;
-    this.suffixText = this.#options.suffixText;
-    this.indent = this.#options.indent;
-    if (process8.env.NODE_ENV === "test") {
-      this._stream = this.#stream;
-      this._isEnabled = this.#options.isEnabled;
-      Object.defineProperty(this, "_linesToClear", {
-        get() {
-          return this.#linesToClear;
-        },
-        set(newValue) {
-          this.#linesToClear = newValue;
-        }
-      });
-      Object.defineProperty(this, "_frameIndex", {
-        get() {
-          return this.#frameIndex;
-        }
-      });
-      Object.defineProperty(this, "_lineCount", {
-        get() {
-          const columns = this.#stream.columns ?? 80;
-          const prefixText = typeof this.#options.prefixText === "function" ? "" : this.#options.prefixText;
-          const suffixText = typeof this.#options.suffixText === "function" ? "" : this.#options.suffixText;
-          const fullPrefixText = typeof prefixText === "string" && prefixText !== "" ? prefixText + " " : "";
-          const fullSuffixText = typeof suffixText === "string" && suffixText !== "" ? " " + suffixText : "";
-          const spinnerChar = "-";
-          const fullText = " ".repeat(this.#options.indent) + fullPrefixText + spinnerChar + (typeof this.#options.text === "string" ? " " + this.#options.text : "") + fullSuffixText;
-          return this.#computeLineCountFrom(fullText, columns);
-        }
-      });
-    }
+  fail(text) {
+    return this.stopAndPersist({ symbol: exports_symbols.error, text });
   }
-  get indent() {
-    return this.#options.indent;
+  warn(text) {
+    return this.stopAndPersist({ symbol: exports_symbols.warning, text });
   }
-  set indent(indent = 0) {
-    if (!(indent >= 0 && Number.isInteger(indent))) {
-      throw new Error("The `indent` option must be an integer from 0 and up");
+  info(text) {
+    return this.stopAndPersist({ symbol: exports_symbols.info, text });
+  }
+  stopAndPersist(options = {}) {
+    if (this.isSilent) {
+      return this;
+    }
+    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)
+  };
+  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("░"));
     }
-    this.#options.indent = indent;
-  }
-  get interval() {
-    return this.#options.interval ?? this.#spinner.interval ?? 100;
+    await sleep(charDelay);
   }
-  get spinner() {
-    return this.#spinner;
+  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);
   }
-  set spinner(spinner) {
-    this.#frameIndex = -1;
-    this.#options.interval = undefined;
-    if (typeof spinner === "object") {
-      if (!Array.isArray(spinner.frames) || spinner.frames.length === 0 || spinner.frames.some((frame) => typeof frame !== "string")) {
-        throw new Error("The given spinner must have a non-empty `frames` array of strings");
-      }
-      if (spinner.interval !== undefined && !(Number.isInteger(spinner.interval) && spinner.interval > 0)) {
-        throw new Error("`spinner.interval` must be a positive integer if provided");
-      }
-      this.#spinner = spinner;
-    } else if (!isUnicodeSupported2()) {
-      this.#spinner = cli_spinners_default.line;
-    } else if (spinner === undefined) {
-      this.#spinner = cli_spinners_default.dots;
-    } else if (spinner !== "default" && cli_spinners_default[spinner]) {
-      this.#spinner = cli_spinners_default[spinner];
+  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 {
-      throw new Error(`There is no built-in spinner named '${spinner}'. See https://github.com/sindresorhus/cli-spinners/blob/main/spinners.json for a full list.`);
+      write(colors2.dim("░"));
     }
+    await sleep(barDelay);
   }
-  get text() {
-    return this.#options.text;
-  }
-  set text(value = "") {
-    this.#options.text = value;
-  }
-  get prefixText() {
-    return this.#options.prefixText;
-  }
-  set prefixText(value = "") {
-    this.#options.prefixText = value;
-  }
-  get suffixText() {
-    return this.#options.suffixText;
-  }
-  set suffixText(value = "") {
-    this.#options.suffixText = value;
-  }
-  get isSpinning() {
-    return this.#id !== undefined;
-  }
-  #formatAffix(value, separator, placeBefore = false) {
-    const resolved = typeof value === "function" ? value() : value;
-    if (typeof resolved === "string" && resolved !== "") {
-      return placeBefore ? separator + resolved : resolved + separator;
+  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
     }
-    return "";
-  }
-  #getFullPrefixText(prefixText = this.#options.prefixText, postfix = " ") {
-    return this.#formatAffix(prefixText, postfix, false);
-  }
-  #getFullSuffixText(suffixText = this.#options.suffixText, prefix = " ") {
-    return this.#formatAffix(suffixText, prefix, true);
-  }
-  #computeLineCountFrom(text, columns) {
-    let count = 0;
-    for (const line of stripVTControlCharacters(text).split(`
-`)) {
-      count += Math.max(1, Math.ceil(stringWidth2(line) / columns));
+  },
+  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
+    }
+  },
+  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
+    }
+  },
+  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
+    }
+  },
+  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
+    }
+  },
+  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
     }
-    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");
+};
+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)
+      });
     }
-    this.#options.isEnabled = value;
   }
-  get isSilent() {
-    return this.#options.isSilent;
+  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;
   }
-  set isSilent(value) {
-    if (typeof value !== "boolean") {
-      throw new TypeError("The `isSilent` option must be a boolean");
+  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;
     }
-    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);
+  if (agent === "opencode") {
+    const baseDir = join7(home, ".local", "share", "opencode", "storage", "session");
+    if (!existsSync7(baseDir))
+      return null;
+    try {
+      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;
+        }
+      }
+    } catch {
+      return null;
     }
-    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);
+  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 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.#stream.clearLine(1);
       }
-      if (this.#options.indent) {
-        this.#stream.cursorTo(this.#options.indent);
+    } else if (sessionPath.endsWith(".json")) {
+      for (const _3 of patterns) {
+        prompts.push("");
       }
-    });
-    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);
+    return prompts;
+  } catch {
+    return [];
   }
-  #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);
+}
+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;
+      }
     }
   }
-  #uninstallHook() {
-    for (const [stream, originalWrite] of this.#hookedStreams) {
-      stream.write = originalWrite;
-      if (activeHooksPerStream.get(stream) === this) {
-        activeHooksPerStream.delete(stream);
+  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"
+        };
       }
     }
-    this.#hookedStreams.clear();
+    return {
+      category: "undo_loop",
+      description: ROOT_CAUSE_PATTERNS.undo_loop.description,
+      confidence: "high"
+    };
   }
-  #hookedWrite(stream, originalWrite, chunk, encoding, callback) {
-    if (typeof encoding === "function") {
-      callback = encoding;
-      encoding = undefined;
+  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"
+        };
+      }
     }
-    if (this.#isInternalWrite) {
-      return originalWrite.call(stream, chunk, encoding, callback);
+  }
+  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
     }
-    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();
+  };
+  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, frustrations: [] };
     }
-    if (this.isSpinning && !this.#deferRenderTimer) {
-      this.render();
+    byTool[key].count++;
+    byTool[key].timeSaved += f3.estimatedTimeWastedMinutes * (f3.recommendedFix.estimatedImprovementPercent / 100);
+    byTool[key].costSaved += f3.estimatedCostWasted * (f3.recommendedFix.estimatedImprovementPercent / 100);
+    byTool[key].frustrations.push(f3);
+  }
+  const recommendations = [];
+  for (const [tool, data] of Object.entries(byTool)) {
+    const preventedFrustrations = data.frustrations.sort((a2, b2) => b2.estimatedTimeWastedMinutes - a2.estimatedTimeWastedMinutes).slice(0, 3).map((f3) => ({
+      patternType: f3.patternDescription,
+      promptSnippet: f3.exactPrompt.slice(0, 80) + (f3.exactPrompt.length > 80 ? "..." : ""),
+      timeWasted: f3.estimatedTimeWastedMinutes
+    }));
+    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,
+      preventedFrustrations
+    });
+  }
+  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`);
     }
-    return writeResult;
+    lines.push("");
   }
-  render() {
-    if (!this.isEnabled || this.#drainHandler || this.#deferRenderTimer) {
-      return this;
+  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("");
     }
-    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));
+  }
+  if (summary.recommendations.length > 0) {
+    lines.push(`  ${colors2.bold(colors2.primary("Contextual Recommendations:"))}`);
+    lines.push("");
+    const totalTimeSavings = summary.recommendations.reduce((a2, r3) => a2 + r3.estimatedTimeSavedMinutes, 0);
+    const totalCostSavings = summary.recommendations.reduce((a2, r3) => a2 + r3.estimatedCostSaved, 0);
+    lines.push(`  ${colors2.dim("Total potential savings:")} ${colors2.success(`~${totalTimeSavings} min`)} | ${colors2.success(`$${totalCostSavings.toFixed(2)}`)}`);
+    lines.push("");
+    for (let i3 = 0;i3 < Math.min(3, summary.recommendations.length); i3++) {
+      const rec = summary.recommendations[i3];
+      lines.push(`    ${colors2.success(`${i3 + 1}.`)} ${colors2.bold(rec.tool)}`);
+      lines.push(`       ${rec.description}`);
+      lines.push(`       ${colors2.dim("Prevented:")} ${rec.wouldHavePreventedCount} issue${rec.wouldHavePreventedCount > 1 ? "s" : ""} ${colors2.dim("|")} ${colors2.success(`~${rec.estimatedTimeSavedMinutes} min saved`)}`);
+      if (rec.preventedFrustrations.length > 0) {
+        lines.push(`       ${colors2.dim("Would have fixed:")}`);
+        for (const pf of rec.preventedFrustrations.slice(0, 2)) {
+          lines.push(`         ${colors2.dim("•")} ${pf.patternType} ${colors2.dim(`(${pf.timeWasted} min)`)}`);
+        }
       }
+      lines.push(`       ${colors2.dim("Install:")} ${colors2.primary(rec.installCommand)}`);
+      lines.push("");
     }
-    return this;
   }
-  start(text) {
-    if (text) {
-      this.text = text;
+  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 (this.isSilent) {
-      return this;
+    if (promptLines.length > 4) {
+      lines.push(`       ${colors2.dim("│")} ${colors2.dim("...")}`);
     }
-    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;
+    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 (this.isSpinning) {
-      return this;
+  }
+  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)
+      });
     }
-    if (this.#options.hideCursor) {
-      cli_cursor_default.hide(this.#stream);
+  }
+  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)
+      };
     }
-    if (this.#options.discardStdin && process8.stdin.isTTY) {
-      stdin_discarder_default.start();
-      this.#isDiscardingStdin = true;
+  }
+  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)
+      };
     }
-    this.#installHook();
-    this.render();
-    this.#id = setInterval(this.render.bind(this), this.interval);
-    return this;
   }
-  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;
+  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
+    });
+    if (result.status !== 0) {
+      result = spawnSync("npx", ["-y", "skills", "add", skillPath], {
+        encoding: "utf-8",
+        stdio: "pipe",
+        timeout: 120000
+      });
     }
-    if (this.isEnabled) {
-      this.clear();
-      if (this.#options.hideCursor) {
-        cli_cursor_default.show(this.#stream);
+    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"
+      };
     }
-    if (this.#isDiscardingStdin) {
-      this.#isDiscardingStdin = false;
-      stdin_discarder_default.stop();
-    }
-    return this;
-  }
-  succeed(text) {
-    return this.stopAndPersist({ symbol: exports_symbols.success, text });
-  }
-  fail(text) {
-    return this.stopAndPersist({ symbol: exports_symbols.error, text });
-  }
-  warn(text) {
-    return this.stopAndPersist({ symbol: exports_symbols.warning, text });
+  } catch (err) {
+    return {
+      id: opt.id,
+      name: opt.name,
+      success: false,
+      message: "Failed to install skill",
+      error: err instanceof Error ? err.message : String(err)
+    };
   }
-  info(text) {
-    return this.stopAndPersist({ symbol: exports_symbols.info, 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"
+    };
   }
-  stopAndPersist(options = {}) {
-    if (this.isSilent) {
-      return this;
+  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 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)
-  };
-  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("█"));
+    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)
+    };
+  }
+}
+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 +15997,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 +16271,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 +16329,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 +16475,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 +16560,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 +16573,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 +16592,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 +16616,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 +16706,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 +16735,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 +16750,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 +16931,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 +16947,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 +16968,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 +19172,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 +19324,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 +19352,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 +19649,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,9 +21874,9 @@ 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
@@ -22016,16 +22533,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}` });
       }
     }
@@ -22079,9 +22596,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";
@@ -22100,7 +22617,7 @@ var FALLBACK_HARNESSES = [
     id: "claude-code",
     name: "Claude Code",
     configPaths: [
-      join13(homedir10(), ".claude.json")
+      join14(homedir11(), ".claude.json")
     ],
     mcpConfigKey: "mcpServers",
     detected: false
@@ -22109,8 +22626,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
@@ -22119,8 +22636,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
@@ -22137,7 +22654,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 {
@@ -22152,7 +22669,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,
@@ -22165,19 +22682,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 {};
@@ -22185,7 +22702,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));
@@ -22229,7 +22746,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];
@@ -22253,7 +22770,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);
@@ -22298,8 +22815,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();
@@ -22318,9 +22835,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;
   }
@@ -22643,6 +23160,26 @@ var BOLD = "\x1B[1m";
 var RESET = "\x1B[0m";
 var MAGENTA = "\x1B[35m";
 var CHANGELOG = [
+  {
+    version: "0.3.15",
+    date: "2026-02-14",
+    title: "Contextual Recommendations",
+    highlights: [
+      "Recommendations now linked to specific frustrations they prevent",
+      "Total time and cost savings summary",
+      "See exactly which issues each tool would have fixed"
+    ]
+  },
+  {
+    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",
@@ -23051,7 +23588,7 @@ function showFullChangelog() {
 // package.json
 var package_default = {
   name: "nairon-bench",
-  version: "0.3.13",
+  version: "0.3.15",
   description: "AI workflow benchmarking CLI",
   type: "module",
   bin: {
@@ -23110,9 +23647,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
@@ -23282,8 +23819,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}`);
       }
@@ -23386,7 +23923,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);
       }
     }
@@ -23455,13 +23992,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;
 }
@@ -23476,15 +24013,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,
@@ -23500,14 +24037,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);
@@ -23541,11 +24078,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 {};
   }
@@ -23566,34 +24103,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")))
@@ -23604,7 +24141,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");
@@ -23649,13 +24186,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");
@@ -23687,7 +24224,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");
@@ -23697,17 +24234,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;
 }
@@ -23730,20 +24267,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) {
@@ -23760,10 +24297,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;
@@ -25181,9 +25718,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)}`);
@@ -25331,8 +25868,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));
@@ -25423,51 +25960,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(".")));
@@ -25477,11 +26014,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;
 }
@@ -25576,7 +26113,7 @@ function formatBytes(bytes) {
 // package.json
 var package_default2 = {
   name: "nairon-bench",
-  version: "0.3.13",
+  version: "0.3.15",
   description: "AI workflow benchmarking CLI",
   type: "module",
   bin: {