@plumpslabs/kuma 2.1.0 → 2.1.2

package/dist/index.js

@@ -75,6 +75,21 @@ function validateFilePath(filePath, projectRoot) {
         };
       }
     }
+    try {
+      if (fs.existsSync(resolvedPath)) {
+        const realPath = fs.realpathSync(resolvedPath);
+        const normalizedRealPath = path.normalize(realPath).toLowerCase();
+        if (!normalizedRealPath.startsWith(normalizedRoot)) {
+          return {
+            valid: false,
+            error: new Error(
+              `PATH_TRAVERSAL: Symlink escape detected. Path "${filePath}" resolves to "${realPath}" which is outside project root "${resolvedRoot}".`
+            )
+          };
+        }
+      }
+    } catch {
+    }
     if (normalizedPath.includes("node_modules")) {
       return {
         valid: true,
@@ -580,6 +595,10 @@ No unresolved issues.`;
     });
     return results.slice(0, limit);
   }
+  getConventions() {
+    this.ensureInit();
+    return this.state.conventions;
+  }
   pruneMemory() {
     this.ensureInit();
     this.state.toolCalls = this.state.toolCalls.slice(-3);
@@ -1594,159 +1613,624 @@ function formatBatchResult(results, totalRequested) {
   return lines.join("\n");
 }
 
-// src/utils/processRunner.ts
-import { spawn } from "child_process";
-var DEFAULT_MAX_STDOUT = 5e3;
-var DEFAULT_MAX_STDERR = 2e3;
-var DEFAULT_TIMEOUT = 60;
-function spawnProcess(command, options) {
-  const {
-    cwd,
-    timeoutSeconds = DEFAULT_TIMEOUT,
-    useShell = false,
-    maxStdout = DEFAULT_MAX_STDOUT,
-    maxStderr = DEFAULT_MAX_STDERR
-  } = options;
-  return new Promise((resolve) => {
-    const parts = command.split(" ");
-    const cmd = parts[0];
-    const args = parts.slice(1);
-    const proc = spawn(cmd, args, {
-      cwd,
-      shell: useShell,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    let timedOut = false;
-    const timeoutId = setTimeout(() => {
-      timedOut = true;
-      proc.kill("SIGTERM");
-      if (process.platform === "win32") {
-        try {
-          spawn("taskkill", ["/pid", String(proc.pid), "/f", "/t"], {
-            stdio: "ignore"
-          });
-        } catch {
-        }
-      }
-    }, timeoutSeconds * 1e3);
-    proc.stdout?.on("data", (data) => {
-      stdout += data.toString();
-    });
-    proc.stderr?.on("data", (data) => {
-      stderr += data.toString();
-    });
-    proc.on("close", (code) => {
-      clearTimeout(timeoutId);
-      resolve({
-        stdout: truncateOutput(stdout, maxStdout),
-        stderr: truncateOutput(stderr, maxStderr),
-        exitCode: code ?? -1,
-        timedOut
-      });
-    });
-    proc.on("error", () => {
-      clearTimeout(timeoutId);
-      resolve({
-        stdout,
-        stderr: `Failed to spawn process: ${cmd}`,
-        exitCode: -1,
-        timedOut: false
-      });
-    });
-  });
-}
-function spawnShell(command, options) {
-  return spawnProcess(command, { ...options, useShell: true });
-}
-function truncateOutput(output, maxChars) {
-  if (output.length <= maxChars) return output;
-  return output.slice(0, maxChars) + `
-
-[...truncated, ${output.length - maxChars} more characters]`;
-}
-
 // src/tools/safeTerminalExec.ts
-var TASK_COMMANDS = {
-  test: "npm test",
-  build: "npm run build",
-  lint: "npm run lint",
-  typecheck: "npx tsc --noEmit"
-};
-var DANGEROUS_PATTERNS = [
-  "rm -rf",
-  "rm -fr",
-  "del /f",
-  "rd /s",
-  "rmdir /s",
-  "git push",
-  "git commit",
-  "npm publish",
-  "npx publish",
-  "yarn publish",
-  "pnpm publish",
-  "> /dev/sda",
-  "format",
-  "mkfs",
-  "dd if=",
-  ":(){ :|:& };:",
-  "curl ",
-  "wget "
-];
-async function handleSafeTerminalExec(params) {
-  const { task, customCommand, timeout = 60 } = params;
-  if (task === "custom" && !customCommand) {
-    return "Error: Task 'custom' requires the 'customCommand' parameter.";
-  }
-  const command = task === "custom" ? customCommand : TASK_COMMANDS[task];
-  const cbResult = circuitBreaker.check("safe_terminal_exec", { task, command });
-  if (!cbResult.allowed) {
-    return `\u26A0\uFE0F Circuit breaker: ${cbResult.reason}
+import fs8 from "fs";
+import path8 from "path";
 
-Fix the code first before running the task again.`;
-  }
-  const dangerousPattern = DANGEROUS_PATTERNS.find((p) => command.toLowerCase().includes(p.toLowerCase()));
-  if (dangerousPattern) {
-    return `\u{1F6AB} BLOCKED: Command contains a dangerous pattern: "${dangerousPattern}".
-This command is not permitted.`;
+// src/utils/conventionsDetector.ts
+import fs7 from "fs";
+import path7 from "path";
+var cachedConventions = null;
+async function detectConventions(forceRescan = false) {
+  if (cachedConventions && !forceRescan) {
+    return cachedConventions;
   }
   const projectRoot = getProjectRoot();
+  const workspaces = detectWorkspaces(projectRoot);
+  const conventions = {
+    framework: detectFramework(projectRoot),
+    projectType: detectProjectType(projectRoot),
+    testRunner: detectTestRunner(projectRoot),
+    styling: detectStyling(projectRoot),
+    importAlias: detectImportAlias(projectRoot),
+    lintRules: detectLintRules(projectRoot),
+    packageManager: detectPackageManager(),
+    moduleSystem: detectModuleSystem(projectRoot),
+    language: detectLanguage(projectRoot),
+    features: detectFeatures(projectRoot),
+    isMonorepo: workspaces.length > 0,
+    workspaces
+  };
+  cachedConventions = conventions;
+  return conventions;
+}
+function detectFramework(root) {
+  const pkg = readJsonSafe(path7.join(root, "package.json"));
+  if (pkg) {
+    const pkgDeps = pkg.dependencies ?? {};
+    const pkgDevDeps = pkg.devDependencies ?? {};
+    const deps = { ...pkgDeps, ...pkgDevDeps };
+    if (deps.next) return "Next.js";
+    if (deps["@remix-run/react"]) return "Remix";
+    if (deps.gatsby) return "Gatsby";
+    if (deps.nuxt || deps["@nuxt/core"]) return "Nuxt.js";
+    if (deps.vue) return "Vue";
+    if (deps.react) return "React";
+    if (deps.svelte) return "Svelte";
+    if (deps.astro) return "Astro";
+    if (deps.solid || deps["solid-js"]) return "SolidJS";
+    if (deps.qwik || deps["@builder.io/qwik"]) return "Qwik";
+    if (deps.vite) return "Vite";
+    if (deps["@nestjs/core"]) return "NestJS";
+    if (deps.fastify) return "Fastify";
+    if (deps.express) return "Express";
+    if (deps.koa) return "Koa";
+    if (deps.hono) return "Hono";
+    if (deps["@hapi/hapi"]) return "Hapi";
+    if (deps["@modelcontextprotocol/sdk"]) return "MCP Server";
+    if (deps["@anthropic-ai/claude-agent-sdk"]) return "Claude Agent SDK";
+    if (deps.commander) return "Commander CLI";
+    if (deps.yargs) return "Yargs CLI";
+    if (deps["@oclif/core"] || deps.oclif) return "Oclif CLI";
+    if (deps.ink) return "Ink (React CLI)";
+    if (pkg.bin) return "CLI Tool";
+    if (pkg.main || pkg.exports) return "Library";
+  }
+  const subFrameworks = scanSubProjectFrameworks(root);
+  if (subFrameworks.length > 0) {
+    const freq = /* @__PURE__ */ new Map();
+    for (const fw of subFrameworks) {
+      freq.set(fw, (freq.get(fw) ?? 0) + 1);
+    }
+    const [topFw] = [...freq.entries()].sort((a, b) => b[1] - a[1])[0] ?? [];
+    if (topFw) return `${topFw} (monorepo)`;
+  }
+  return "unknown";
+}
+function scanSubProjectFrameworks(root) {
+  const frameworks = [];
   try {
-    sessionMemory.recordToolCall("execute_safe_test", { task, command });
-    const result = await spawnShell(command, {
-      cwd: projectRoot,
-      timeoutSeconds: timeout
-    });
-    const output = formatExecResult(result, command, task);
-    if (result.exitCode !== 0) {
-      sessionMemory.addFailedFile(task, result.stderr || result.stdout);
+    const entries = fs7.readdirSync(root, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+      const subDir = path7.join(root, entry.name);
+      const subPkg = readJsonSafe(path7.join(subDir, "package.json"));
+      if (!subPkg) continue;
+      const subDeps = { ...subPkg.dependencies ?? {}, ...subPkg.devDependencies ?? {} };
+      if (subDeps.next) frameworks.push("Next.js");
+      else if (subDeps.react) frameworks.push("React");
+      else if (subDeps.vue) frameworks.push("Vue");
+      else if (subDeps.svelte) frameworks.push("Svelte");
+      else if (subDeps.astro) frameworks.push("Astro");
+      else if (subDeps["@nestjs/core"]) frameworks.push("NestJS");
+      else if (subDeps.express) frameworks.push("Express");
+      else if (subDeps.hono) frameworks.push("Hono");
+      else if (subDeps.vite) frameworks.push("Vite");
+      else if (subDeps["@modelcontextprotocol/sdk"]) frameworks.push("MCP Server");
     }
-    return output;
-  } catch (err) {
-    const errorMsg = err instanceof Error ? err.message : String(err);
-    if (errorMsg.toLowerCase().includes("timeout")) {
-      return formatTimeoutResult(command, timeout);
+  } catch {
+  }
+  return frameworks;
+}
+function detectProjectType(root) {
+  const pkg = readJsonSafe(path7.join(root, "package.json"));
+  if (pkg) {
+    const pkgDeps = pkg.dependencies ?? {};
+    const pkgDevDeps = pkg.devDependencies ?? {};
+    const deps = { ...pkgDeps, ...pkgDevDeps };
+    if (deps["@modelcontextprotocol/sdk"]) return "mcp-server";
+    if (deps.next || deps.react || deps.vue || deps.svelte || deps.astro || deps.gatsby || deps.nuxt || deps["@remix-run/react"] || deps.solid) {
+      return "web-app";
     }
-    return `Error running "${command}": ${errorMsg}`;
+    if (deps.express || deps.fastify || deps.koa || deps.hono || deps["@nestjs/core"] || deps["@hapi/hapi"]) {
+      return "backend";
+    }
+    if (deps.commander || deps.yargs || deps["@oclif/core"] || deps.oclif || deps.ink) {
+      return "cli";
+    }
+    if (pkg.bin) return "cli";
+    if (pkg.main || pkg.exports) return "library";
   }
+  const subFrameworks = scanSubProjectFrameworks(root);
+  if (subFrameworks.length > 0) return "web-app";
+  return "unknown";
 }
-function formatExecResult(result, command, task) {
-  const status = result.exitCode === 0 ? "\u2705 PASS" : "\u274C FAIL";
-  const lines = [
-    `\u{1F4BB} ${status} \u2014 Task: ${task}`,
-    `$ ${command}`,
-    `Exit code: ${result.exitCode}`,
-    `Duration: ${result.timedOut ? "TIMEOUT" : "completed"}`,
-    ""
-  ];
-  if (result.stdout.trim()) {
-    lines.push("\u{1F4E4} STDOUT:", "```", result.stdout, "```", "");
+function detectWorkspaces(root) {
+  const results = [];
+  const pkg = readJsonSafe(path7.join(root, "package.json"));
+  const pnpmWorkspace = readYamlLite(path7.join(root, "pnpm-workspace.yaml"));
+  const patterns = /* @__PURE__ */ new Set();
+  const pkgWorkspaces = pkg?.workspaces;
+  if (Array.isArray(pkgWorkspaces)) {
+    for (const p of pkgWorkspaces) if (typeof p === "string") patterns.add(p);
+  } else if (pkgWorkspaces && typeof pkgWorkspaces === "object") {
+    const packages = pkgWorkspaces.packages;
+    if (Array.isArray(packages)) {
+      for (const p of packages) if (typeof p === "string") patterns.add(p);
+    }
   }
-  if (result.stderr.trim()) {
-    lines.push("\u{1F4E4} STDERR:", "```", result.stderr, "```", "");
+  if (Array.isArray(pnpmWorkspace?.packages)) {
+    for (const p of pnpmWorkspace.packages) if (typeof p === "string") patterns.add(p);
   }
-  if (result.exitCode !== 0) {
+  patterns.add("apps/*");
+  patterns.add("packages/*");
+  patterns.add("services/*");
+  for (const pattern of patterns) {
+    const match = pattern.match(/^([^*]+)\/\*$/);
+    if (!match) continue;
+    const dir = path7.join(root, match[1]);
+    if (!fs7.existsSync(dir)) continue;
+    let entries = [];
+    try {
+      entries = fs7.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+      const pkgPath = path7.join(dir, entry.name, "package.json");
+      const subPkg = readJsonSafe(pkgPath);
+      if (!subPkg) continue;
+      const workspacePath = path7.join(dir, entry.name);
+      results.push({
+        path: path7.relative(root, workspacePath),
+        name: subPkg.name ?? entry.name,
+        framework: detectFramework(workspacePath),
+        packageManager: detectPackageManagerForDir(workspacePath)
+      });
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return results.filter((w) => {
+    if (seen.has(w.path)) return false;
+    seen.add(w.path);
+    return true;
+  });
+}
+function readYamlLite(filePath) {
+  try {
+    if (!fs7.existsSync(filePath)) return null;
+    const text = fs7.readFileSync(filePath, "utf-8");
+    const packages = [];
+    let inPackages = false;
+    for (const rawLine of text.split("\n")) {
+      const line = rawLine.replace(/#.*$/, "").trimEnd();
+      if (/^packages:\s*$/.test(line)) {
+        inPackages = true;
+        continue;
+      }
+      if (inPackages) {
+        const m = line.match(/^\s*-\s*['"]?([^'"]+)['"]?\s*$/);
+        if (m) packages.push(m[1]);
+        else if (/^\S/.test(line)) inPackages = false;
+      }
+    }
+    return { packages };
+  } catch {
+    return null;
+  }
+}
+function detectTestRunner(root) {
+  const pkg = readJsonSafe(path7.join(root, "package.json"));
+  if (!pkg) return "unknown";
+  const pkgDeps2 = pkg.dependencies ?? {};
+  const pkgDevDeps2 = pkg.devDependencies ?? {};
+  const deps = { ...pkgDeps2, ...pkgDevDeps2 };
+  if (deps.vitest) return "Vitest";
+  if (deps.jest) return "Jest";
+  if (deps.mocha) return "Mocha";
+  if (deps.ava) return "AVA";
+  if (deps.cypress) return "Cypress";
+  if (deps.playwright) return "Playwright";
+  if (deps["@testing-library/react"]) return "React Testing Library";
+  const scripts = pkg.scripts ?? {};
+  if (scripts.test) {
+    if (scripts.test.includes("vitest")) return "Vitest";
+    if (scripts.test.includes("jest")) return "Jest";
+    if (scripts.test.includes("mocha")) return "Mocha";
+  }
+  return "unknown";
+}
+function detectStyling(root) {
+  const pkg = readJsonSafe(path7.join(root, "package.json"));
+  if (!pkg) return "unknown";
+  const pkgDeps3 = pkg.dependencies ?? {};
+  const pkgDevDeps3 = pkg.devDependencies ?? {};
+  const deps = { ...pkgDeps3, ...pkgDevDeps3 };
+  if (deps.tailwindcss) return "Tailwind CSS";
+  if (deps["styled-components"]) return "Styled Components";
+  if (deps["@emotion/react"]) return "Emotion";
+  if (deps.linaria) return "Linaria";
+  if (deps.sass || deps["node-sass"]) return "SCSS";
+  if (deps.less) return "Less";
+  if (deps["@vanilla-extract/css"]) return "Vanilla Extract";
+  if (deps.cssmodules || hasCSSModules(root)) return "CSS Modules";
+  const srcDir = path7.join(root, "src");
+  if (fs7.existsSync(srcDir)) {
+    const cssFiles = findFiles(srcDir, [".css", ".scss", ".less"]);
+    if (cssFiles.length > 0) return "Plain CSS/SCSS";
+  }
+  return "unknown";
+}
+function detectImportAlias(root) {
+  const tsconfig = readJsonSafe(path7.join(root, "tsconfig.json"));
+  const tsconfigPaths = tsconfig?.compilerOptions;
+  if (tsconfigPaths?.paths) {
+    const paths = tsconfigPaths.paths;
+    const alias = Object.keys(paths)[0];
+    if (alias) return alias.replace("/*", "");
+  }
+  const jsconfig = readJsonSafe(path7.join(root, "jsconfig.json"));
+  const jsconfigPaths = jsconfig?.compilerOptions;
+  if (jsconfigPaths?.paths) {
+    const paths = jsconfigPaths.paths;
+    const alias = Object.keys(paths)[0];
+    if (alias) return alias.replace("/*", "");
+  }
+  return void 0;
+}
+function detectLintRules(root) {
+  const rules = [];
+  if (fs7.existsSync(path7.join(root, ".eslintrc"))) rules.push("ESLint (.eslintrc)");
+  if (fs7.existsSync(path7.join(root, ".eslintrc.js"))) rules.push("ESLint (.eslintrc.js)");
+  if (fs7.existsSync(path7.join(root, ".eslintrc.json"))) rules.push("ESLint (.eslintrc.json)");
+  if (fs7.existsSync(path7.join(root, "eslint.config.js"))) rules.push("ESLint (flat config)");
+  if (fs7.existsSync(path7.join(root, ".prettierrc"))) rules.push("Prettier");
+  if (fs7.existsSync(path7.join(root, ".prettierrc.json"))) rules.push("Prettier");
+  if (fs7.existsSync(path7.join(root, ".prettierrc.js"))) rules.push("Prettier");
+  if (fs7.existsSync(path7.join(root, ".stylelintrc"))) rules.push("StyleLint");
+  if (fs7.existsSync(path7.join(root, ".stylelintrc.json"))) rules.push("StyleLint");
+  return rules;
+}
+function detectPackageManager() {
+  const root = getProjectRoot();
+  return detectPackageManagerForDir(root);
+}
+function detectPackageManagerForDir(dir) {
+  const root = getProjectRoot();
+  let currentDir = path7.resolve(dir);
+  while (currentDir.startsWith(root)) {
+    if (fs7.existsSync(path7.join(currentDir, "pnpm-lock.yaml"))) return "pnpm";
+    if (fs7.existsSync(path7.join(currentDir, "yarn.lock"))) return "yarn";
+    if (fs7.existsSync(path7.join(currentDir, "package-lock.json"))) return "npm";
+    if (fs7.existsSync(path7.join(currentDir, "bun.lockb"))) return "bun";
+    if (currentDir === root) break;
+    currentDir = path7.dirname(currentDir);
+  }
+  return "npm";
+}
+function detectModuleSystem(root) {
+  const pkg = readJsonSafe(path7.join(root, "package.json"));
+  if (pkg?.type === "module") return "esm";
+  const srcDir = path7.join(root, "src");
+  if (fs7.existsSync(srcDir)) {
+    const tsFiles = findFiles(srcDir, [".ts", ".tsx", ".js", ".jsx", ".mjs"]);
+    for (const file of tsFiles.slice(0, 20)) {
+      try {
+        const content = fs7.readFileSync(file, "utf-8");
+        if (content.includes("import ") || content.includes("export ")) return "esm";
+      } catch {
+        continue;
+      }
+    }
+  }
+  return "cjs";
+}
+function detectLanguage(root) {
+  if (fs7.existsSync(path7.join(root, "tsconfig.json"))) return "typescript";
+  const srcDir = path7.join(root, "src");
+  if (fs7.existsSync(srcDir)) {
+    const tsFiles = findFiles(srcDir, [".ts", ".tsx"]);
+    if (tsFiles.length > 0) return "typescript";
+  }
+  return "javascript";
+}
+function detectFeatures(root) {
+  const features = [];
+  const pkg = readJsonSafe(path7.join(root, "package.json"));
+  if (!pkg) return features;
+  const pkgDeps4 = pkg.dependencies ?? {};
+  const pkgDevDeps4 = pkg.devDependencies ?? {};
+  const deps = { ...pkgDeps4, ...pkgDevDeps4 };
+  if (deps["@prisma/client"] || deps.prisma) features.push("Prisma ORM");
+  if (deps.typeorm) features.push("TypeORM");
+  if (deps["drizzle-orm"]) features.push("Drizzle ORM");
+  if (deps.graphql || deps["@graphql-tools"]) features.push("GraphQL");
+  if (deps.trpc || deps["@trpc/client"]) features.push("tRPC");
+  if (deps["socket.io"] || deps.ws) features.push("WebSockets");
+  if (deps["@reduxjs/toolkit"] || deps.redux) features.push("Redux");
+  if (deps.zustand) features.push("Zustand");
+  if (deps["react-router"] || deps["react-router-dom"]) features.push("React Router");
+  if (deps["next-auth"] || deps["next-auth/react"]) features.push("NextAuth");
+  if (deps["@tanstack/react-query"]) features.push("React Query");
+  if (deps.jest || deps.vitest) features.push("Unit Testing");
+  if (deps.cypress || deps.playwright) features.push("E2E Testing");
+  if (deps.storybook || deps["@storybook/react"]) features.push("Storybook");
+  if (deps.i18next || deps["react-i18next"]) features.push("i18n");
+  return features;
+}
+function readJsonSafe(filePath) {
+  try {
+    if (fs7.existsSync(filePath)) {
+      return JSON.parse(fs7.readFileSync(filePath, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function hasCSSModules(root) {
+  const srcDir = path7.join(root, "src");
+  if (!fs7.existsSync(srcDir)) return false;
+  const files = findFiles(srcDir, [".module.css", ".module.scss", ".module.less"]);
+  return files.length > 0;
+}
+function findFiles(dir, extensions) {
+  const results = [];
+  try {
+    const entries = fs7.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path7.join(dir, entry.name);
+      if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+        results.push(...findFiles(fullPath, extensions));
+      } else if (entry.isFile()) {
+        if (extensions.some((ext) => entry.name.endsWith(ext))) {
+          results.push(fullPath);
+        }
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+
+// src/utils/processRunner.ts
+import { spawn } from "child_process";
+var DEFAULT_MAX_STDOUT = 5e3;
+var DEFAULT_MAX_STDERR = 2e3;
+var DEFAULT_TIMEOUT = 60;
+function spawnProcess(command, options) {
+  const {
+    cwd,
+    timeoutSeconds = DEFAULT_TIMEOUT,
+    useShell = false,
+    maxStdout = DEFAULT_MAX_STDOUT,
+    maxStderr = DEFAULT_MAX_STDERR
+  } = options;
+  return new Promise((resolve) => {
+    const parts = command.split(" ");
+    const cmd = parts[0];
+    const args = parts.slice(1);
+    const proc = spawn(cmd, args, {
+      cwd,
+      shell: useShell,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    const timeoutId = setTimeout(() => {
+      timedOut = true;
+      proc.kill("SIGTERM");
+      if (process.platform === "win32") {
+        try {
+          spawn("taskkill", ["/pid", String(proc.pid), "/f", "/t"], {
+            stdio: "ignore"
+          });
+        } catch {
+        }
+      }
+    }, timeoutSeconds * 1e3);
+    proc.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      clearTimeout(timeoutId);
+      resolve({
+        stdout: truncateOutput(stdout, maxStdout),
+        stderr: truncateOutput(stderr, maxStderr),
+        exitCode: code ?? -1,
+        timedOut
+      });
+    });
+    proc.on("error", () => {
+      clearTimeout(timeoutId);
+      resolve({
+        stdout,
+        stderr: `Failed to spawn process: ${cmd}`,
+        exitCode: -1,
+        timedOut: false
+      });
+    });
+  });
+}
+function spawnShell(command, options) {
+  return spawnProcess(command, { ...options, useShell: true });
+}
+function truncateOutput(output, maxChars) {
+  if (output.length <= maxChars) return output;
+  return output.slice(0, maxChars) + `
+
+[...truncated, ${output.length - maxChars} more characters]`;
+}
+
+// src/tools/safeTerminalExec.ts
+function stripShellObfuscation(cmd) {
+  let result = cmd;
+  let prev;
+  do {
+    prev = result;
+    result = result.replace(/\$\([^()]*\)/g, "");
+  } while (result !== prev);
+  do {
+    prev = result;
+    result = result.replace(/\$\(\([^()]*\)\)/g, "");
+  } while (result !== prev);
+  result = result.replace(/\$\{[^}]*\}/g, " ");
+  result = result.replace(/\$'[^']*'/g, "");
+  result = result.replace(/\$"[^"]*"/g, "");
+  result = result.replace(/\$[a-zA-Z_][a-zA-Z0-9_]*/g, " ");
+  result = result.replace(/\s+/g, " ").trim();
+  return result;
+}
+function buildTaskCommand(task, cwd) {
+  const pm = detectPackageManagerForDir(cwd);
+  const prefix = pm === "pnpm" ? "pnpm" : pm === "yarn" ? "yarn" : pm === "bun" ? "bun" : "npm";
+  const npx = pm === "pnpm" ? "pnpm" : pm === "bun" ? "bunx" : "npx";
+  switch (task) {
+    case "test":
+      return `${prefix} test`;
+    case "build":
+      return `${prefix} run build`;
+    case "lint":
+      return `${prefix} run lint`;
+    case "typecheck":
+      return `${npx} tsc --noEmit`;
+    default:
+      return `${prefix} test`;
+  }
+}
+var DANGEROUS_PATTERNS = [
+  // RM variants
+  "rm -rf",
+  "rm -fr",
+  "rm --recursive",
+  "rm --force",
+  "del /f",
+  "rd /s",
+  "rmdir /s",
+  // Git dangerous
+  "git push",
+  "git commit",
+  "git reset --hard",
+  "git clean -fd",
+  "git checkout -- .",
+  // Publish to registries
+  "npm publish",
+  "npx publish",
+  "yarn publish",
+  "pnpm publish",
+  // System destruction
+  "> /dev/sda",
+  "mkfs",
+  "dd if=",
+  "dd of=",
+  "fdisk",
+  "parted",
+  "mkswap",
+  // Fork bomb
+  ":(){ :|:& };:",
+  ":(){",
+  // Pipe to shell (remote code execution vector)
+  "| bash",
+  "| sh",
+  // Dangerous eval/exec
+  "eval ",
+  "exec ",
+  "source /dev/stdin",
+  ". /dev/stdin",
+  // Find destruction
+  "find . -delete",
+  "find / -delete",
+  "find . -exec rm",
+  "find / -exec rm",
+  // Chmod abuse
+  "chmod -R 777",
+  "chmod 777 /",
+  "chmod 000",
+  // Alias hijacking
+  "alias rm=",
+  "alias cd=",
+  "alias sudo=",
+  // Overwrite protection
+  "shred"
+];
+async function handleSafeTerminalExec(params) {
+  const { task, customCommand, timeout = 60, cwd: inputCwd, workspace } = params;
+  if (task === "custom" && !customCommand) {
+    return "Error: Task 'custom' requires the 'customCommand' parameter.";
+  }
+  const projectRoot = getProjectRoot();
+  let workingDir = projectRoot;
+  let resolvedFrom = "root";
+  if (workspace) {
+    const conventions = sessionMemory.getConventions();
+    const workspaces = conventions?.workspaces;
+    const matched = workspaces?.find((w) => w.name === workspace || w.path === workspace);
+    if (matched) {
+      workingDir = path8.resolve(projectRoot, matched.path);
+      resolvedFrom = `workspace "${matched.name}" \u2192 ${matched.path}`;
+    } else {
+      return `\u26A0\uFE0F Workspace "${workspace}" not found. Run project_conventions first to detect workspaces, or use 'cwd' parameter with a direct path.
+
+Available workspaces: ${workspaces?.map((w) => `"${w.name}" (${w.path})`).join(", ") || "none detected"}`;
+    }
+  } else if (inputCwd) {
+    const resolved = path8.resolve(projectRoot, inputCwd);
+    const normalizedResolved = path8.normalize(resolved).toLowerCase();
+    const normalizedRoot = path8.normalize(projectRoot).toLowerCase();
+    if (!normalizedResolved.startsWith(normalizedRoot)) {
+      return `\u{1F6AB} BLOCKED: Path "${inputCwd}" resolves outside project root "${projectRoot}".`;
+    }
+    if (!fs8.existsSync(resolved)) {
+      return `\u26A0\uFE0F Directory "${inputCwd}" does not exist at "${resolved}".`;
+    }
+    workingDir = resolved;
+    resolvedFrom = `cwd: ${inputCwd}`;
+  }
+  const command = task === "custom" ? customCommand : buildTaskCommand(task, workingDir);
+  const cbResult = circuitBreaker.check("safe_terminal_exec", { task, command });
+  if (!cbResult.allowed) {
+    return `\u26A0\uFE0F Circuit breaker: ${cbResult.reason}
+
+Fix the code first before running the task again.`;
+  }
+  const deobfuscated = stripShellObfuscation(command);
+  const dangerousPattern = DANGEROUS_PATTERNS.find(
+    (p) => deobfuscated.toLowerCase().includes(p.toLowerCase())
+  );
+  if (dangerousPattern) {
+    return `\u{1F6AB} BLOCKED: Command contains a dangerous pattern: "${dangerousPattern}".
+This command is not permitted.`;
+  }
+  try {
+    sessionMemory.recordToolCall("execute_safe_test", { task, command, cwd: workingDir });
+    const result = await spawnShell(command, {
+      cwd: workingDir,
+      timeoutSeconds: timeout
+    });
+    const output = formatExecResult(result, command, task, resolvedFrom);
+    if (result.exitCode !== 0) {
+      sessionMemory.addFailedFile(task, result.stderr || result.stdout);
+    }
+    return output;
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    if (errorMsg.toLowerCase().includes("timeout")) {
+      return formatTimeoutResult(command, timeout);
+    }
+    return `Error running "${command}": ${errorMsg}`;
+  }
+}
+function formatExecResult(result, command, task, resolvedFrom) {
+  const status = result.exitCode === 0 ? "\u2705 PASS" : "\u274C FAIL";
+  const lines = [
+    `\u{1F4BB} ${status} \u2014 Task: ${task}`,
+    `$ ${command}`,
+    ...resolvedFrom ? [`\u{1F4CD} ${resolvedFrom}`] : [],
+    `Exit code: ${result.exitCode}`,
+    `Duration: ${result.timedOut ? "TIMEOUT" : "completed"}`,
+    ""
+  ];
+  if (result.stdout.trim()) {
+    lines.push("\u{1F4E4} STDOUT:", "```", result.stdout, "```", "");
+  }
+  if (result.stderr.trim()) {
+    lines.push("\u{1F4E4} STDERR:", "```", result.stderr, "```", "");
+  }
+  if (result.exitCode !== 0) {
     lines.push(
       "\u{1F4A1} Recovery steps:",
       "  1. Read the error above \u2014 which file is failing?",
@@ -1776,8 +2260,8 @@ function formatTimeoutResult(command, timeout) {
 }
 
 // src/agents/codeReviewer.ts
-import fs7 from "fs";
-import path7 from "path";
+import fs9 from "fs";
+import path9 from "path";
 import { execSync } from "child_process";
 var CODE_EXTENSIONS = [
   ".ts",
@@ -1809,7 +2293,7 @@ function getGitChangedFiles() {
       if (filePath.startsWith('"') && filePath.endsWith('"')) {
         filePath = filePath.substring(1, filePath.length - 1);
       }
-      const ext = path7.extname(filePath).toLowerCase();
+      const ext = path9.extname(filePath).toLowerCase();
       if (CODE_EXTENSIONS.includes(ext)) files.push(filePath);
     }
     return files.slice(0, 10);
@@ -1846,7 +2330,7 @@ Pass an explicit 'files' array to review specific files.`;
       continue;
     }
     const resolvedPath = validation.resolvedPath;
-    if (!fs7.existsSync(resolvedPath)) {
+    if (!fs9.existsSync(resolvedPath)) {
       allIssues.push({
         file: filePath,
         line: 0,
@@ -1858,7 +2342,7 @@ Pass an explicit 'files' array to review specific files.`;
       continue;
     }
     try {
-      const content = fs7.readFileSync(resolvedPath, "utf-8");
+      const content = fs9.readFileSync(resolvedPath, "utf-8");
       filesReviewed++;
       checkGeneral(filePath, content, allIssues);
       switch (focus) {
@@ -1952,7 +2436,7 @@ function isTestFile(filePath) {
   return /\.(test|spec)\.[a-z]+$/i.test(filePath) || /__tests__/.test(filePath);
 }
 function isTsLike(filePath) {
-  const ext = path7.extname(filePath).toLowerCase();
+  const ext = path9.extname(filePath).toLowerCase();
   return ext === ".ts" || ext === ".tsx";
 }
 function checkGeneral(filePath, content, issues) {
@@ -2391,460 +2875,105 @@ function checkOverEngineering(filePath, content, issues) {
         line: lineNum,
         severity: "info",
         rule: sp.rule,
-        message: sp.msg,
-        suggestion: sp.suggestion
-      });
-    }
-  }
-  const exportDecls = [];
-  for (let i = 0; i < lines.length; i++) {
-    const ed = lines[i].match(/^\s*export\s+(const|let|var|function|class)\s+(\w+)/);
-    if (ed) exportDecls.push({ name: ed[2], line: i + 1 });
-  }
-  for (const decl of exportDecls) {
-    const refCount = (text.match(new RegExp(`\\b${decl.name}\\b`, "g")) || []).length;
-    const isReactComponent = /^[A-Z]/.test(decl.name) && /return\s+<|React\./.test(text);
-    if (refCount <= 1 && decl.name !== "default" && !isReactComponent) {
-      issues.push({
-        file: filePath,
-        line: decl.line,
-        severity: "info",
-        rule: "over-engineering/unused-export",
-        message: `"${decl.name}" is exported but referenced only in its declaration`,
-        suggestion: "Check if it is imported elsewhere; if not, remove or inline"
-      });
-    }
-  }
-}
-function findBlockBodies(lines, startPattern) {
-  const results = [];
-  for (let i = 0; i < lines.length; i++) {
-    const m = lines[i].match(startPattern);
-    if (!m) continue;
-    const name = m[0].match(/class\s+(\w+)/)?.[1] ?? "Unknown";
-    const body = collectBlockLines(lines, i);
-    results.push({ body: body.join("\n"), nameLine: i + 1, name });
-  }
-  return results;
-}
-function collectBlockLines(lines, startIdx) {
-  let depth = 0;
-  let started = false;
-  const block = [];
-  for (let j = startIdx; j < lines.length; j++) {
-    const line = lines[j];
-    block.push(line);
-    for (const ch of line) {
-      if (ch === "{") {
-        depth++;
-        started = true;
-      } else if (ch === "}") depth--;
-    }
-    if (started && depth <= 0) break;
-  }
-  return block;
-}
-function extractBodyAfter(lines, match) {
-  const startIdx = lines.findIndex((l) => l.includes(match[0].trim().split(/\s+/).pop() ?? ""));
-  if (startIdx < 0) return "";
-  return collectBlockLines(lines, startIdx).join("\n");
-}
-function formatReviewOutput(issues, filesReviewed, totalFiles, focus, customCriteria, autoDetected) {
-  const errors = issues.filter((i) => i.severity === "error");
-  const warnings = issues.filter((i) => i.severity === "warning");
-  const infos = issues.filter((i) => i.severity === "info");
-  const lines = [
-    `\u{1F50D} **Code Review \u2014 Focus: ${focus}**`,
-    ...focus === "over-engineering" ? ["\u{1F4A1} **The Ladder:** 1. Does this code need to exist? 2. Does stdlib cover it? 3. Is there a one-liner? 4. Only then, write it."] : [],
-    ...autoDetected ? [`\u{1F4C2} Auto-detected ${totalFiles} changed file(s) from git`] : [],
-    ...customCriteria ? [`\u{1F4CB} **Custom Criteria:** ${customCriteria}`] : [],
-    `\u{1F4C1} ${filesReviewed}/${totalFiles} files reviewed`,
-    `\u{1F534} ${errors.length} errors | \u{1F7E1} ${warnings.length} warnings | \u{1F535} ${infos.length} info`,
-    ""
-  ];
-  if (issues.length === 0) {
-    lines.push("\u2705 No issues found.");
-    return lines.join("\n");
-  }
-  const grouped = /* @__PURE__ */ new Map();
-  for (const issue of issues) {
-    const existing = grouped.get(issue.file) ?? [];
-    existing.push(issue);
-    grouped.set(issue.file, existing);
-  }
-  for (const [file, fileIssues] of grouped) {
-    lines.push(`**\u{1F4C4} ${file}:**`);
-    for (const issue of fileIssues) {
-      const icon = issue.severity === "error" ? "\u{1F534}" : issue.severity === "warning" ? "\u{1F7E1}" : "\u{1F535}";
-      lines.push(`  ${icon} [L${issue.line}] [${issue.rule}] ${issue.message}`);
-      if (issue.suggestion) lines.push(`     \u{1F4A1} ${issue.suggestion}`);
-    }
-    lines.push("");
-  }
-  if (errors.length > 0) {
-    lines.push("\u26A0\uFE0F Fix errors first, then warnings.");
-    lines.push("\u{1F4A1} Use precise_diff_editor to apply fixes.");
-  } else if (warnings.length > 0) {
-    lines.push("\u{1F4A1} Address warnings before merging.");
-  } else {
-    lines.push("\u2705 Only informational issues \u2014 ready for testing.");
-  }
-  return lines.join("\n");
-}
-
-// src/utils/conventionsDetector.ts
-import fs8 from "fs";
-import path8 from "path";
-var cachedConventions = null;
-async function detectConventions(forceRescan = false) {
-  if (cachedConventions && !forceRescan) {
-    return cachedConventions;
-  }
-  const projectRoot = getProjectRoot();
-  const workspaces = detectWorkspaces(projectRoot);
-  const conventions = {
-    framework: detectFramework(projectRoot),
-    projectType: detectProjectType(projectRoot),
-    testRunner: detectTestRunner(projectRoot),
-    styling: detectStyling(projectRoot),
-    importAlias: detectImportAlias(projectRoot),
-    lintRules: detectLintRules(projectRoot),
-    packageManager: detectPackageManager(),
-    moduleSystem: detectModuleSystem(projectRoot),
-    language: detectLanguage(projectRoot),
-    features: detectFeatures(projectRoot),
-    isMonorepo: workspaces.length > 0,
-    workspaces
-  };
-  cachedConventions = conventions;
-  return conventions;
-}
-function detectFramework(root) {
-  const pkg = readJsonSafe(path8.join(root, "package.json"));
-  if (pkg) {
-    const pkgDeps = pkg.dependencies ?? {};
-    const pkgDevDeps = pkg.devDependencies ?? {};
-    const deps = { ...pkgDeps, ...pkgDevDeps };
-    if (deps.next) return "Next.js";
-    if (deps["@remix-run/react"]) return "Remix";
-    if (deps.gatsby) return "Gatsby";
-    if (deps.nuxt || deps["@nuxt/core"]) return "Nuxt.js";
-    if (deps.vue) return "Vue";
-    if (deps.react) return "React";
-    if (deps.svelte) return "Svelte";
-    if (deps.astro) return "Astro";
-    if (deps.solid || deps["solid-js"]) return "SolidJS";
-    if (deps.qwik || deps["@builder.io/qwik"]) return "Qwik";
-    if (deps.vite) return "Vite";
-    if (deps["@nestjs/core"]) return "NestJS";
-    if (deps.fastify) return "Fastify";
-    if (deps.express) return "Express";
-    if (deps.koa) return "Koa";
-    if (deps.hono) return "Hono";
-    if (deps["@hapi/hapi"]) return "Hapi";
-    if (deps["@modelcontextprotocol/sdk"]) return "MCP Server";
-    if (deps["@anthropic-ai/claude-agent-sdk"]) return "Claude Agent SDK";
-    if (deps.commander) return "Commander CLI";
-    if (deps.yargs) return "Yargs CLI";
-    if (deps["@oclif/core"] || deps.oclif) return "Oclif CLI";
-    if (deps.ink) return "Ink (React CLI)";
-    if (pkg.bin) return "CLI Tool";
-    if (pkg.main || pkg.exports) return "Library";
-  }
-  const subFrameworks = scanSubProjectFrameworks(root);
-  if (subFrameworks.length > 0) {
-    const freq = /* @__PURE__ */ new Map();
-    for (const fw of subFrameworks) {
-      freq.set(fw, (freq.get(fw) ?? 0) + 1);
-    }
-    const [topFw] = [...freq.entries()].sort((a, b) => b[1] - a[1])[0] ?? [];
-    if (topFw) return `${topFw} (monorepo)`;
-  }
-  return "unknown";
-}
-function scanSubProjectFrameworks(root) {
-  const frameworks = [];
-  try {
-    const entries = fs8.readdirSync(root, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const subDir = path8.join(root, entry.name);
-      const subPkg = readJsonSafe(path8.join(subDir, "package.json"));
-      if (!subPkg) continue;
-      const subDeps = { ...subPkg.dependencies ?? {}, ...subPkg.devDependencies ?? {} };
-      if (subDeps.next) frameworks.push("Next.js");
-      else if (subDeps.react) frameworks.push("React");
-      else if (subDeps.vue) frameworks.push("Vue");
-      else if (subDeps.svelte) frameworks.push("Svelte");
-      else if (subDeps.astro) frameworks.push("Astro");
-      else if (subDeps["@nestjs/core"]) frameworks.push("NestJS");
-      else if (subDeps.express) frameworks.push("Express");
-      else if (subDeps.hono) frameworks.push("Hono");
-      else if (subDeps.vite) frameworks.push("Vite");
-      else if (subDeps["@modelcontextprotocol/sdk"]) frameworks.push("MCP Server");
-    }
-  } catch {
-  }
-  return frameworks;
-}
-function detectProjectType(root) {
-  const pkg = readJsonSafe(path8.join(root, "package.json"));
-  if (pkg) {
-    const pkgDeps = pkg.dependencies ?? {};
-    const pkgDevDeps = pkg.devDependencies ?? {};
-    const deps = { ...pkgDeps, ...pkgDevDeps };
-    if (deps["@modelcontextprotocol/sdk"]) return "mcp-server";
-    if (deps.next || deps.react || deps.vue || deps.svelte || deps.astro || deps.gatsby || deps.nuxt || deps["@remix-run/react"] || deps.solid) {
-      return "web-app";
-    }
-    if (deps.express || deps.fastify || deps.koa || deps.hono || deps["@nestjs/core"] || deps["@hapi/hapi"]) {
-      return "backend";
-    }
-    if (deps.commander || deps.yargs || deps["@oclif/core"] || deps.oclif || deps.ink) {
-      return "cli";
-    }
-    if (pkg.bin) return "cli";
-    if (pkg.main || pkg.exports) return "library";
-  }
-  const subFrameworks = scanSubProjectFrameworks(root);
-  if (subFrameworks.length > 0) return "web-app";
-  return "unknown";
-}
-function detectWorkspaces(root) {
-  const results = [];
-  const pkg = readJsonSafe(path8.join(root, "package.json"));
-  const pnpmWorkspace = readYamlLite(path8.join(root, "pnpm-workspace.yaml"));
-  const patterns = /* @__PURE__ */ new Set();
-  const pkgWorkspaces = pkg?.workspaces;
-  if (Array.isArray(pkgWorkspaces)) {
-    for (const p of pkgWorkspaces) if (typeof p === "string") patterns.add(p);
-  } else if (pkgWorkspaces && typeof pkgWorkspaces === "object") {
-    const packages = pkgWorkspaces.packages;
-    if (Array.isArray(packages)) {
-      for (const p of packages) if (typeof p === "string") patterns.add(p);
-    }
-  }
-  if (Array.isArray(pnpmWorkspace?.packages)) {
-    for (const p of pnpmWorkspace.packages) if (typeof p === "string") patterns.add(p);
-  }
-  patterns.add("apps/*");
-  patterns.add("packages/*");
-  patterns.add("services/*");
-  for (const pattern of patterns) {
-    const match = pattern.match(/^([^*]+)\/\*$/);
-    if (!match) continue;
-    const dir = path8.join(root, match[1]);
-    if (!fs8.existsSync(dir)) continue;
-    let entries = [];
-    try {
-      entries = fs8.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const pkgPath = path8.join(dir, entry.name, "package.json");
-      const subPkg = readJsonSafe(pkgPath);
-      if (!subPkg) continue;
-      results.push({
-        path: path8.relative(root, path8.join(dir, entry.name)),
-        name: subPkg.name ?? entry.name,
-        framework: detectFramework(path8.join(dir, entry.name))
+        message: sp.msg,
+        suggestion: sp.suggestion
       });
     }
   }
-  const seen = /* @__PURE__ */ new Set();
-  return results.filter((w) => {
-    if (seen.has(w.path)) return false;
-    seen.add(w.path);
-    return true;
-  });
-}
-function readYamlLite(filePath) {
-  try {
-    if (!fs8.existsSync(filePath)) return null;
-    const text = fs8.readFileSync(filePath, "utf-8");
-    const packages = [];
-    let inPackages = false;
-    for (const rawLine of text.split("\n")) {
-      const line = rawLine.replace(/#.*$/, "").trimEnd();
-      if (/^packages:\s*$/.test(line)) {
-        inPackages = true;
-        continue;
-      }
-      if (inPackages) {
-        const m = line.match(/^\s*-\s*['"]?([^'"]+)['"]?\s*$/);
-        if (m) packages.push(m[1]);
-        else if (/^\S/.test(line)) inPackages = false;
-      }
-    }
-    return { packages };
-  } catch {
-    return null;
+  const exportDecls = [];
+  for (let i = 0; i < lines.length; i++) {
+    const ed = lines[i].match(/^\s*export\s+(const|let|var|function|class)\s+(\w+)/);
+    if (ed) exportDecls.push({ name: ed[2], line: i + 1 });
   }
-}
-function detectTestRunner(root) {
-  const pkg = readJsonSafe(path8.join(root, "package.json"));
-  if (!pkg) return "unknown";
-  const pkgDeps2 = pkg.dependencies ?? {};
-  const pkgDevDeps2 = pkg.devDependencies ?? {};
-  const deps = { ...pkgDeps2, ...pkgDevDeps2 };
-  if (deps.vitest) return "Vitest";
-  if (deps.jest) return "Jest";
-  if (deps.mocha) return "Mocha";
-  if (deps.ava) return "AVA";
-  if (deps.cypress) return "Cypress";
-  if (deps.playwright) return "Playwright";
-  if (deps["@testing-library/react"]) return "React Testing Library";
-  const scripts = pkg.scripts ?? {};
-  if (scripts.test) {
-    if (scripts.test.includes("vitest")) return "Vitest";
-    if (scripts.test.includes("jest")) return "Jest";
-    if (scripts.test.includes("mocha")) return "Mocha";
+  for (const decl of exportDecls) {
+    const refCount = (text.match(new RegExp(`\\b${decl.name}\\b`, "g")) || []).length;
+    const isReactComponent = /^[A-Z]/.test(decl.name) && /return\s+<|React\./.test(text);
+    if (refCount <= 1 && decl.name !== "default" && !isReactComponent) {
+      issues.push({
+        file: filePath,
+        line: decl.line,
+        severity: "info",
+        rule: "over-engineering/unused-export",
+        message: `"${decl.name}" is exported but referenced only in its declaration`,
+        suggestion: "Check if it is imported elsewhere; if not, remove or inline"
+      });
+    }
   }
-  return "unknown";
 }
-function detectStyling(root) {
-  const pkg = readJsonSafe(path8.join(root, "package.json"));
-  if (!pkg) return "unknown";
-  const pkgDeps3 = pkg.dependencies ?? {};
-  const pkgDevDeps3 = pkg.devDependencies ?? {};
-  const deps = { ...pkgDeps3, ...pkgDevDeps3 };
-  if (deps.tailwindcss) return "Tailwind CSS";
-  if (deps["styled-components"]) return "Styled Components";
-  if (deps["@emotion/react"]) return "Emotion";
-  if (deps.linaria) return "Linaria";
-  if (deps.sass || deps["node-sass"]) return "SCSS";
-  if (deps.less) return "Less";
-  if (deps["@vanilla-extract/css"]) return "Vanilla Extract";
-  if (deps.cssmodules || hasCSSModules(root)) return "CSS Modules";
-  const srcDir = path8.join(root, "src");
-  if (fs8.existsSync(srcDir)) {
-    const cssFiles = findFiles(srcDir, [".css", ".scss", ".less"]);
-    if (cssFiles.length > 0) return "Plain CSS/SCSS";
+function findBlockBodies(lines, startPattern) {
+  const results = [];
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(startPattern);
+    if (!m) continue;
+    const name = m[0].match(/class\s+(\w+)/)?.[1] ?? "Unknown";
+    const body = collectBlockLines(lines, i);
+    results.push({ body: body.join("\n"), nameLine: i + 1, name });
   }
-  return "unknown";
+  return results;
 }
-function detectImportAlias(root) {
-  const tsconfig = readJsonSafe(path8.join(root, "tsconfig.json"));
-  const tsconfigPaths = tsconfig?.compilerOptions;
-  if (tsconfigPaths?.paths) {
-    const paths = tsconfigPaths.paths;
-    const alias = Object.keys(paths)[0];
-    if (alias) return alias.replace("/*", "");
-  }
-  const jsconfig = readJsonSafe(path8.join(root, "jsconfig.json"));
-  const jsconfigPaths = jsconfig?.compilerOptions;
-  if (jsconfigPaths?.paths) {
-    const paths = jsconfigPaths.paths;
-    const alias = Object.keys(paths)[0];
-    if (alias) return alias.replace("/*", "");
+function collectBlockLines(lines, startIdx) {
+  let depth = 0;
+  let started = false;
+  const block = [];
+  for (let j = startIdx; j < lines.length; j++) {
+    const line = lines[j];
+    block.push(line);
+    for (const ch of line) {
+      if (ch === "{") {
+        depth++;
+        started = true;
+      } else if (ch === "}") depth--;
+    }
+    if (started && depth <= 0) break;
   }
-  return void 0;
-}
-function detectLintRules(root) {
-  const rules = [];
-  if (fs8.existsSync(path8.join(root, ".eslintrc"))) rules.push("ESLint (.eslintrc)");
-  if (fs8.existsSync(path8.join(root, ".eslintrc.js"))) rules.push("ESLint (.eslintrc.js)");
-  if (fs8.existsSync(path8.join(root, ".eslintrc.json"))) rules.push("ESLint (.eslintrc.json)");
-  if (fs8.existsSync(path8.join(root, "eslint.config.js"))) rules.push("ESLint (flat config)");
-  if (fs8.existsSync(path8.join(root, ".prettierrc"))) rules.push("Prettier");
-  if (fs8.existsSync(path8.join(root, ".prettierrc.json"))) rules.push("Prettier");
-  if (fs8.existsSync(path8.join(root, ".prettierrc.js"))) rules.push("Prettier");
-  if (fs8.existsSync(path8.join(root, ".stylelintrc"))) rules.push("StyleLint");
-  if (fs8.existsSync(path8.join(root, ".stylelintrc.json"))) rules.push("StyleLint");
-  return rules;
+  return block;
 }
-function detectPackageManager() {
-  const root = getProjectRoot();
-  if (fs8.existsSync(path8.join(root, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs8.existsSync(path8.join(root, "yarn.lock"))) return "yarn";
-  if (fs8.existsSync(path8.join(root, "package-lock.json"))) return "npm";
-  if (fs8.existsSync(path8.join(root, "bun.lockb"))) return "bun";
-  return "npm";
+function extractBodyAfter(lines, match) {
+  const startIdx = lines.findIndex((l) => l.includes(match[0].trim().split(/\s+/).pop() ?? ""));
+  if (startIdx < 0) return "";
+  return collectBlockLines(lines, startIdx).join("\n");
 }
-function detectModuleSystem(root) {
-  const pkg = readJsonSafe(path8.join(root, "package.json"));
-  if (pkg?.type === "module") return "esm";
-  const srcDir = path8.join(root, "src");
-  if (fs8.existsSync(srcDir)) {
-    const tsFiles = findFiles(srcDir, [".ts", ".tsx", ".js", ".jsx", ".mjs"]);
-    for (const file of tsFiles.slice(0, 20)) {
-      try {
-        const content = fs8.readFileSync(file, "utf-8");
-        if (content.includes("import ") || content.includes("export ")) return "esm";
-      } catch {
-        continue;
-      }
-    }
+function formatReviewOutput(issues, filesReviewed, totalFiles, focus, customCriteria, autoDetected) {
+  const errors = issues.filter((i) => i.severity === "error");
+  const warnings = issues.filter((i) => i.severity === "warning");
+  const infos = issues.filter((i) => i.severity === "info");
+  const lines = [
+    `\u{1F50D} **Code Review \u2014 Focus: ${focus}**`,
+    ...focus === "over-engineering" ? ["\u{1F4A1} **The Ladder:** 1. Does this code need to exist? 2. Does stdlib cover it? 3. Is there a one-liner? 4. Only then, write it."] : [],
+    ...autoDetected ? [`\u{1F4C2} Auto-detected ${totalFiles} changed file(s) from git`] : [],
+    ...customCriteria ? [`\u{1F4CB} **Custom Criteria:** ${customCriteria}`] : [],
+    `\u{1F4C1} ${filesReviewed}/${totalFiles} files reviewed`,
+    `\u{1F534} ${errors.length} errors | \u{1F7E1} ${warnings.length} warnings | \u{1F535} ${infos.length} info`,
+    ""
+  ];
+  if (issues.length === 0) {
+    lines.push("\u2705 No issues found.");
+    return lines.join("\n");
   }
-  return "cjs";
-}
-function detectLanguage(root) {
-  if (fs8.existsSync(path8.join(root, "tsconfig.json"))) return "typescript";
-  const srcDir = path8.join(root, "src");
-  if (fs8.existsSync(srcDir)) {
-    const tsFiles = findFiles(srcDir, [".ts", ".tsx"]);
-    if (tsFiles.length > 0) return "typescript";
+  const grouped = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const existing = grouped.get(issue.file) ?? [];
+    existing.push(issue);
+    grouped.set(issue.file, existing);
   }
-  return "javascript";
-}
-function detectFeatures(root) {
-  const features = [];
-  const pkg = readJsonSafe(path8.join(root, "package.json"));
-  if (!pkg) return features;
-  const pkgDeps4 = pkg.dependencies ?? {};
-  const pkgDevDeps4 = pkg.devDependencies ?? {};
-  const deps = { ...pkgDeps4, ...pkgDevDeps4 };
-  if (deps["@prisma/client"] || deps.prisma) features.push("Prisma ORM");
-  if (deps.typeorm) features.push("TypeORM");
-  if (deps["drizzle-orm"]) features.push("Drizzle ORM");
-  if (deps.graphql || deps["@graphql-tools"]) features.push("GraphQL");
-  if (deps.trpc || deps["@trpc/client"]) features.push("tRPC");
-  if (deps["socket.io"] || deps.ws) features.push("WebSockets");
-  if (deps["@reduxjs/toolkit"] || deps.redux) features.push("Redux");
-  if (deps.zustand) features.push("Zustand");
-  if (deps["react-router"] || deps["react-router-dom"]) features.push("React Router");
-  if (deps["next-auth"] || deps["next-auth/react"]) features.push("NextAuth");
-  if (deps["@tanstack/react-query"]) features.push("React Query");
-  if (deps.jest || deps.vitest) features.push("Unit Testing");
-  if (deps.cypress || deps.playwright) features.push("E2E Testing");
-  if (deps.storybook || deps["@storybook/react"]) features.push("Storybook");
-  if (deps.i18next || deps["react-i18next"]) features.push("i18n");
-  return features;
-}
-function readJsonSafe(filePath) {
-  try {
-    if (fs8.existsSync(filePath)) {
-      return JSON.parse(fs8.readFileSync(filePath, "utf-8"));
+  for (const [file, fileIssues] of grouped) {
+    lines.push(`**\u{1F4C4} ${file}:**`);
+    for (const issue of fileIssues) {
+      const icon = issue.severity === "error" ? "\u{1F534}" : issue.severity === "warning" ? "\u{1F7E1}" : "\u{1F535}";
+      lines.push(`  ${icon} [L${issue.line}] [${issue.rule}] ${issue.message}`);
+      if (issue.suggestion) lines.push(`     \u{1F4A1} ${issue.suggestion}`);
     }
-  } catch {
+    lines.push("");
   }
-  return null;
-}
-function hasCSSModules(root) {
-  const srcDir = path8.join(root, "src");
-  if (!fs8.existsSync(srcDir)) return false;
-  const files = findFiles(srcDir, [".module.css", ".module.scss", ".module.less"]);
-  return files.length > 0;
-}
-function findFiles(dir, extensions) {
-  const results = [];
-  try {
-    const entries = fs8.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path8.join(dir, entry.name);
-      if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
-        results.push(...findFiles(fullPath, extensions));
-      } else if (entry.isFile()) {
-        if (extensions.some((ext) => entry.name.endsWith(ext))) {
-          results.push(fullPath);
-        }
-      }
-    }
-  } catch {
+  if (errors.length > 0) {
+    lines.push("\u26A0\uFE0F Fix errors first, then warnings.");
+    lines.push("\u{1F4A1} Use precise_diff_editor to apply fixes.");
+  } else if (warnings.length > 0) {
+    lines.push("\u{1F4A1} Address warnings before merging.");
+  } else {
+    lines.push("\u2705 Only informational issues \u2014 ready for testing.");
   }
-  return results;
+  return lines.join("\n");
 }
 
 // src/agents/projectConventions.ts
@@ -3035,8 +3164,8 @@ async function handleGitDiff(params) {
 }
 
 // src/tools/projectStructure.ts
-import fs9 from "fs";
-import path9 from "path";
+import fs10 from "fs";
+import path10 from "path";
 var DEFAULT_IGNORE = [
   "node_modules",
   ".git",
@@ -3073,7 +3202,7 @@ async function handleProjectStructure(params) {
   sessionMemory.recordToolCall("project_structure", { depth: clampedDepth, folderOnly });
   try {
     const tree = buildTree(root, root, clampedDepth, 0, folderOnly, includePattern, excludePattern);
-    const projectName = path9.basename(root);
+    const projectName = path10.basename(root);
     const lines = [
       "[Project Structure] - " + projectName,
       "Depth: " + clampedDepth + " | " + (folderOnly ? "Folders only" : "Files and folders"),
@@ -3096,7 +3225,7 @@ function buildTree(root, currentDir, maxDepth, currentDepth, folderOnly, include
   const lines = [];
   let entries = [];
   try {
-    entries = fs9.readdirSync(currentDir, { withFileTypes: true });
+    entries = fs10.readdirSync(currentDir, { withFileTypes: true });
   } catch {
     return lines;
   }
@@ -3105,12 +3234,12 @@ function buildTree(root, currentDir, maxDepth, currentDepth, folderOnly, include
     if (!a.isDirectory() && b.isDirectory()) return 1;
     return a.name.localeCompare(b.name);
   });
-  const relativeDir = path9.relative(root, currentDir) || ".";
+  const relativeDir = path10.relative(root, currentDir) || ".";
   const prefix = getPrefix(currentDepth);
   for (const entry of entries) {
     if (shouldIgnore(entry.name, relativeDir, root)) continue;
-    const fullPath = path9.join(currentDir, entry.name);
-    const relativePath = path9.relative(root, fullPath);
+    const fullPath = path10.join(currentDir, entry.name);
+    const relativePath = path10.relative(root, fullPath);
     if (includePattern && !entry.name.includes(includePattern) && !relativePath.includes(includePattern)) {
       if (!entry.isDirectory()) continue;
     }
@@ -3121,11 +3250,11 @@ function buildTree(root, currentDir, maxDepth, currentDepth, folderOnly, include
       lines.push(prefix + "[D] " + entry.name + "/");
       let subEntries = [];
       try {
-        subEntries = fs9.readdirSync(fullPath, { withFileTypes: true });
+        subEntries = fs10.readdirSync(fullPath, { withFileTypes: true });
       } catch {
       }
       const hasVisibleContent = subEntries.some(
-        (e) => !shouldIgnore(e.name, path9.relative(root, fullPath), root)
+        (e) => !shouldIgnore(e.name, path10.relative(root, fullPath), root)
       );
       if (hasVisibleContent) {
         const subLines = buildTree(root, fullPath, maxDepth, currentDepth + 1, folderOnly, includePattern, excludePattern);
@@ -3156,7 +3285,7 @@ function getPrefix(depth) {
 }
 function getFileSize(fullPath) {
   try {
-    const stat = fs9.statSync(fullPath);
+    const stat = fs10.statSync(fullPath);
     if (stat.size < 1024) return stat.size + "B";
     if (stat.size < 1024 * 1024) return (stat.size / 1024).toFixed(0) + "KB";
     const sizeMB = (stat.size / (1024 * 1024)).toFixed(1);
@@ -3167,8 +3296,8 @@ function getFileSize(fullPath) {
 }
 
 // src/tools/staticAnalysis.ts
-import fs10 from "fs";
-import path10 from "path";
+import fs11 from "fs";
+import path11 from "path";
 async function handleStaticAnalysis(params) {
   const { tool = "all", files, autoFix = false, timeout = 60 } = params;
   const root = getProjectRoot();
@@ -3223,11 +3352,11 @@ function detectAvailableTools(root) {
     "eslint.config.js",
     "eslint.config.mjs"
   ];
-  const hasEslintConfig = eslintConfigs.some((cfg) => fs10.existsSync(path10.join(root, cfg)));
+  const hasEslintConfig = eslintConfigs.some((cfg) => fs11.existsSync(path11.join(root, cfg)));
   if (hasEslintConfig && depNames.has("eslint")) {
     tools.push("eslint");
   }
-  if (fs10.existsSync(path10.join(root, "tsconfig.json")) && depNames.has("typescript")) {
+  if (fs11.existsSync(path11.join(root, "tsconfig.json")) && depNames.has("typescript")) {
     tools.push("tsc");
   }
   const prettierConfigs = [
@@ -3238,20 +3367,20 @@ function detectAvailableTools(root) {
     ".prettierrc.toml",
     "prettier.config.js"
   ];
-  const hasPrettierConfig = prettierConfigs.some((cfg) => fs10.existsSync(path10.join(root, cfg)));
+  const hasPrettierConfig = prettierConfigs.some((cfg) => fs11.existsSync(path11.join(root, cfg)));
   if (hasPrettierConfig && depNames.has("prettier")) {
     tools.push("prettier");
   }
-  if (fs10.existsSync(path10.join(root, "ruff.toml")) || fs10.existsSync(path10.join(root, ".ruff.toml"))) {
+  if (fs11.existsSync(path11.join(root, "ruff.toml")) || fs11.existsSync(path11.join(root, ".ruff.toml"))) {
     tools.push("ruff");
   }
   return tools;
 }
 function readPackageJson(root) {
   try {
-    const pkgPath = path10.join(root, "package.json");
-    if (fs10.existsSync(pkgPath)) {
-      return JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path11.join(root, "package.json");
+    if (fs11.existsSync(pkgPath)) {
+      return JSON.parse(fs11.readFileSync(pkgPath, "utf-8"));
     }
   } catch {
   }
@@ -3296,8 +3425,8 @@ function buildToolCommand(tool, files, autoFix) {
 }
 function detectPackageManagerPrefix() {
   const root = getProjectRoot();
-  if (fs10.existsSync(path10.join(root, "pnpm-lock.yaml"))) return "pnpm ";
-  if (fs10.existsSync(path10.join(root, "yarn.lock"))) return "yarn ";
+  if (fs11.existsSync(path11.join(root, "pnpm-lock.yaml"))) return "pnpm ";
+  if (fs11.existsSync(path11.join(root, "yarn.lock"))) return "yarn ";
   return "npx --no-install ";
 }
 function parseToolOutput(tool, stdout, stderr, projectRoot) {
@@ -3316,7 +3445,7 @@ function parseToolOutput(tool, stdout, stderr, projectRoot) {
 }
 function resolveToolPath(filePath, projectRoot) {
   const trimmed = filePath.trim();
-  return path10.isAbsolute(trimmed) ? path10.relative(projectRoot, trimmed) : trimmed.replace(/^\.\//, "");
+  return path11.isAbsolute(trimmed) ? path11.relative(projectRoot, trimmed) : trimmed.replace(/^\.\//, "");
 }
 function parseEslintOutput(output, projectRoot) {
   const issues = [];
@@ -3593,8 +3722,8 @@ async function handleReflect(params) {
 import { execSync as execSync6 } from "child_process";
 
 // src/guards/antiPatternDetector.ts
-import fs11 from "fs";
-import path11 from "path";
+import fs12 from "fs";
+import path12 from "path";
 import { execSync as execSync4 } from "child_process";
 var SCRIPT_PATCH_PATTERNS = [
   "writeFileSync",
@@ -3621,20 +3750,20 @@ function findPatchScripts(projectRoot) {
   const warnings = [];
   const recentFiles = scanRecentFiles(projectRoot);
   for (const file of recentFiles) {
-    const ext = path11.extname(file).toLowerCase();
+    const ext = path12.extname(file).toLowerCase();
     if (!SCRIPT_EXTENSIONS.includes(ext)) continue;
-    const relativePath = path11.relative(projectRoot, file);
+    const relativePath = path12.relative(projectRoot, file);
     if (relativePath.startsWith("src") || relativePath.startsWith("test") || relativePath.startsWith("node_modules") || relativePath.startsWith(".")) {
       continue;
     }
     try {
-      const content = fs11.readFileSync(file, "utf-8").toLowerCase();
+      const content = fs12.readFileSync(file, "utf-8").toLowerCase();
       const matchedPattern = SCRIPT_PATCH_PATTERNS.find((p) => content.includes(p.toLowerCase()));
       if (matchedPattern) {
         warnings.push({
           severity: "high",
           pattern: "script-patching",
-          message: `Created script file that modifies other files: ${path11.basename(file)}`,
+          message: `Created script file that modifies other files: ${path12.basename(file)}`,
           suggestion: "Use **precise_diff_editor** instead \u2014 it has fuzzy matching, auto-backup, and rollback support",
           evidence: `File: ${relativePath} contains '${matchedPattern}'`,
           filePath: relativePath
@@ -3668,15 +3797,15 @@ function detectBashGrepUsage() {
 function scanRecentFiles(projectRoot) {
   const recent = [];
   try {
-    const entries = fs11.readdirSync(projectRoot, { withFileTypes: true });
+    const entries = fs12.readdirSync(projectRoot, { withFileTypes: true });
     const now = Date.now();
     const recentThreshold = 30 * 60 * 1e3;
     for (const entry of entries) {
       if (!entry.isFile()) continue;
       try {
-        const stat = fs11.statSync(path11.join(projectRoot, entry.name));
+        const stat = fs12.statSync(path12.join(projectRoot, entry.name));
         if (now - stat.mtimeMs < recentThreshold || now - stat.ctimeMs < recentThreshold) {
-          recent.push(path11.join(projectRoot, entry.name));
+          recent.push(path12.join(projectRoot, entry.name));
         }
       } catch {
         continue;
@@ -3700,14 +3829,14 @@ function detectGitPatchScripts(projectRoot) {
         const prefix = line.substring(0, 2);
         if (prefix !== "??" && prefix !== "A ") continue;
         const file = line.substring(3).trim();
-        const ext = path11.extname(file).toLowerCase();
+        const ext = path12.extname(file).toLowerCase();
         if (!SCRIPT_EXTENSIONS.includes(ext)) continue;
         const isRootLevel = !file.includes("/");
         const isScriptsDir = file.startsWith("scripts/") || file.startsWith("patches/");
         if (!isRootLevel && !isScriptsDir) continue;
-        const fullPath = path11.join(projectRoot, file);
-        if (fs11.existsSync(fullPath)) {
-          const content = fs11.readFileSync(fullPath, "utf-8").toLowerCase();
+        const fullPath = path12.join(projectRoot, file);
+        if (fs12.existsSync(fullPath)) {
+          const content = fs12.readFileSync(fullPath, "utf-8").toLowerCase();
           const matchedPattern = SCRIPT_PATCH_PATTERNS.find((p) => content.includes(p.toLowerCase()));
           if (matchedPattern) {
             warnings.push({
@@ -3730,7 +3859,7 @@ function detectGitPatchScripts(projectRoot) {
     if (deletedStdout) {
       const deletedFiles = deletedStdout.split("\n").filter(Boolean);
       for (const file of deletedFiles) {
-        const ext = path11.extname(file).toLowerCase();
+        const ext = path12.extname(file).toLowerCase();
         if (SCRIPT_EXTENSIONS.includes(ext)) {
           warnings.push({
             severity: "high",
@@ -3790,21 +3919,21 @@ function detectAllAntiPatterns() {
 }
 
 // src/engine/contextSnapshot.ts
-import fs12 from "fs";
-import path12 from "path";
+import fs13 from "fs";
+import path13 from "path";
 import { execSync as execSync5 } from "child_process";
 var SNAPSHOT_DIR = "context-snapshots";
 function snapshotDir() {
-  return path12.join(getProjectRoot(), ".kuma", SNAPSHOT_DIR);
+  return path13.join(getProjectRoot(), ".kuma", SNAPSHOT_DIR);
 }
 function ensureSnapshotDir() {
   const dir = snapshotDir();
-  if (!fs12.existsSync(dir)) {
-    fs12.mkdirSync(dir, { recursive: true });
+  if (!fs13.existsSync(dir)) {
+    fs13.mkdirSync(dir, { recursive: true });
   }
 }
 function snapshotFilePath(timestamp) {
-  return path12.join(snapshotDir(), `${timestamp}.json`);
+  return path13.join(snapshotDir(), `${timestamp}.json`);
 }
 function saveSnapshot(goal) {
   try {
@@ -3825,7 +3954,7 @@ function saveSnapshot(goal) {
     hasConventions: !!summary.hasConventions
   };
   try {
-    fs12.writeFileSync(snapshotFilePath(Date.now()), JSON.stringify(snapshot, null, 2), "utf-8");
+    fs13.writeFileSync(snapshotFilePath(Date.now()), JSON.stringify(snapshot, null, 2), "utf-8");
   } catch {
   }
   sessionMemory.recordToolCall("kuma_context", { action: "save", goal: snapshot.goal });
@@ -3833,12 +3962,12 @@ function saveSnapshot(goal) {
 }
 function listSnapshots() {
   const dir = snapshotDir();
-  if (!fs12.existsSync(dir)) return [];
+  if (!fs13.existsSync(dir)) return [];
   try {
-    const files = fs12.readdirSync(dir).filter((f) => f.endsWith(".json")).sort((a, b) => b.localeCompare(a));
+    const files = fs13.readdirSync(dir).filter((f) => f.endsWith(".json")).sort((a, b) => b.localeCompare(a));
     return files.map((f) => {
       try {
-        const content = fs12.readFileSync(path12.join(dir, f), "utf-8");
+        const content = fs13.readFileSync(path13.join(dir, f), "utf-8");
         return JSON.parse(content);
       } catch {
         return null;
@@ -4046,8 +4175,8 @@ async function handleKumaContext(params) {
 
 // src/engine/lspClient.ts
 import { spawn as spawn2 } from "child_process";
-import path13 from "path";
-import fs13 from "fs";
+import path14 from "path";
+import fs14 from "fs";
 var LSPClient = class {
   process = null;
   requestId = 0;
@@ -4085,8 +4214,8 @@ var LSPClient = class {
       console.error(`[LSP] typescript-language-server not found. LSP features will fallback to regex.`);
       return;
     }
-    const tsconfigPath = path13.join(root, "tsconfig.json");
-    if (!fs13.existsSync(tsconfigPath)) {
+    const tsconfigPath = path14.join(root, "tsconfig.json");
+    if (!fs14.existsSync(tsconfigPath)) {
       console.error(`[LSP] Warning: tsconfig.json not found at "${root}". Running in implicit project mode.`);
     }
     this.process = spawn2(lspBinary, ["--stdio", "--log-level=4"], {
@@ -4148,19 +4277,19 @@ var LSPClient = class {
   /** Resolve the typescript-language-server binary from local or global install */
   resolveLspBinary(projectRoot) {
     const candidates = [
-      path13.join(projectRoot, "node_modules", ".bin", "typescript-language-server"),
-      path13.join(projectRoot, "..", "node_modules", ".bin", "typescript-language-server")
+      path14.join(projectRoot, "node_modules", ".bin", "typescript-language-server"),
+      path14.join(projectRoot, "..", "node_modules", ".bin", "typescript-language-server")
     ];
     for (const candidate of candidates) {
-      if (fs13.existsSync(candidate)) {
+      if (fs14.existsSync(candidate)) {
         return candidate;
       }
     }
     try {
       const envPath = process.env.PATH ?? "";
-      for (const dir of envPath.split(path13.delimiter)) {
-        const binPath = path13.join(dir, "typescript-language-server");
-        if (fs13.existsSync(binPath)) {
+      for (const dir of envPath.split(path14.delimiter)) {
+        const binPath = path14.join(dir, "typescript-language-server");
+        if (fs14.existsSync(binPath)) {
           return binPath;
         }
       }
@@ -4181,7 +4310,7 @@ var LSPClient = class {
     this.openDocuments.add(filePath);
     let content;
     try {
-      content = fs13.readFileSync(filePath, "utf-8");
+      content = fs14.readFileSync(filePath, "utf-8");
     } catch {
       content = "";
     }
@@ -4398,8 +4527,8 @@ var LSPClient = class {
 var lspClient = new LSPClient();
 
 // src/tools/lspTools.ts
-import fs14 from "fs";
-import path14 from "path";
+import fs15 from "fs";
+import path15 from "path";
 async function handleFindReferences(params) {
   const { filePath, line, character } = params;
   const validation = validateFilePath(filePath);
@@ -4407,7 +4536,7 @@ async function handleFindReferences(params) {
     return `Error: ${validation.error.message}`;
   }
   const resolvedPath = validation.resolvedPath;
-  if (!fs14.existsSync(resolvedPath)) {
+  if (!fs15.existsSync(resolvedPath)) {
     return `Error: File not found: "${filePath}".`;
   }
   if (!lspClient.isAvailable()) {
@@ -4429,7 +4558,7 @@ async function handleFindReferences(params) {
     const enrichedRefs = references.map((ref) => {
       let lineContent = "";
       try {
-        const content = fs14.readFileSync(ref.filePath, "utf-8");
+        const content = fs15.readFileSync(ref.filePath, "utf-8");
         const lines2 = content.split("\n");
         lineContent = lines2[ref.line]?.trim() ?? "";
       } catch {
@@ -4445,11 +4574,11 @@ async function handleFindReferences(params) {
     const projectRoot = getProjectRoot();
     const lines = [
       `\u{1F50D} **Find References** \u2014 ${enrichedRefs.length} references found`,
-      `\u{1F4CD} File: ${path14.relative(projectRoot, resolvedPath)}:${line + 1}:${character + 1}`,
+      `\u{1F4CD} File: ${path15.relative(projectRoot, resolvedPath)}:${line + 1}:${character + 1}`,
       ""
     ];
     for (const [file, refs] of grouped) {
-      const relPath = path14.relative(projectRoot, file);
+      const relPath = path15.relative(projectRoot, file);
       lines.push(`**\u{1F4C4} ${relPath}:**`);
       for (const ref of refs) {
         const loc = `L${ref.line + 1}:${ref.character + 1}`;
@@ -4470,7 +4599,7 @@ async function handleGoToDefinition(params) {
     return `Error: ${validation.error.message}`;
   }
   const resolvedPath = validation.resolvedPath;
-  if (!fs14.existsSync(resolvedPath)) {
+  if (!fs15.existsSync(resolvedPath)) {
     return `Error: File not found: "${filePath}".`;
   }
   if (!lspClient.isAvailable()) {
@@ -4490,10 +4619,10 @@ async function handleGoToDefinition(params) {
 \u26A0\uFE0F Cannot find definition for symbol at this position.`;
     }
     const projectRoot = getProjectRoot();
-    const relPath = path14.relative(projectRoot, definition.filePath);
+    const relPath = path15.relative(projectRoot, definition.filePath);
     let lineContent = "";
     try {
-      const content = fs14.readFileSync(definition.filePath, "utf-8");
+      const content = fs15.readFileSync(definition.filePath, "utf-8");
       const lines2 = content.split("\n");
       lineContent = lines2[definition.line]?.trim() ?? "";
     } catch {
@@ -4525,7 +4654,7 @@ async function handleRenameSymbol(params) {
     return `Error: ${validation.error.message}`;
   }
   const resolvedPath = validation.resolvedPath;
-  if (!fs14.existsSync(resolvedPath)) {
+  if (!fs15.existsSync(resolvedPath)) {
     return `Error: File not found: "${filePath}".`;
   }
   if (!lspClient.isAvailable()) {
@@ -4554,7 +4683,7 @@ Make sure:
     const fileChanges = [];
     for (const change of result.changes) {
       try {
-        const content = fs14.readFileSync(change.filePath, "utf-8");
+        const content = fs15.readFileSync(change.filePath, "utf-8");
         const lines2 = content.split("\n");
         const sortedEdits = [...change.edits].sort((a, b) => {
           if (b.line !== a.line) return b.line - a.line;
@@ -4568,10 +4697,10 @@ Make sure:
             lines2[edit.line] = before + edit.newText + after;
           }
         }
-        fs14.writeFileSync(change.filePath, lines2.join("\n"), "utf-8");
+        fs15.writeFileSync(change.filePath, lines2.join("\n"), "utf-8");
         totalEdits += change.edits.length;
         fileChanges.push({
-          filePath: path14.relative(projectRoot, change.filePath),
+          filePath: path15.relative(projectRoot, change.filePath),
           editCount: change.edits.length
         });
       } catch (err) {
@@ -4598,13 +4727,13 @@ async function handleGetTypeInfo(params) {
     return `Error: ${validation.error.message}`;
   }
   const resolvedPath = validation.resolvedPath;
-  if (!fs14.existsSync(resolvedPath)) {
+  if (!fs15.existsSync(resolvedPath)) {
     return `Error: File not found: "${filePath}".`;
   }
   if (!lspClient.isAvailable()) {
     sessionMemory.recordToolCall("lsp_query", { action: "type", filePath, line, character, fallback: "line-context" });
     try {
-      const fileContent = fs14.readFileSync(resolvedPath, "utf-8");
+      const fileContent = fs15.readFileSync(resolvedPath, "utf-8");
       const fileLines = fileContent.split("\n");
       const targetLine = fileLines[line];
       if (!targetLine) {
@@ -4612,7 +4741,7 @@ async function handleGetTypeInfo(params) {
       }
       const symbolName = extractSymbolAtPosition(resolvedPath, line, character);
       const projectRoot = getProjectRoot();
-      const relPath = path14.relative(projectRoot, resolvedPath);
+      const relPath = path15.relative(projectRoot, resolvedPath);
       const contextStart = Math.max(0, line - 3);
       const contextEnd = Math.min(fileLines.length, line + 4);
       const contextLines = [];
@@ -4650,7 +4779,7 @@ async function handleGetTypeInfo(params) {
 \u26A0\uFE0F No type info for this position.`;
     }
     const projectRoot = getProjectRoot();
-    const relPath = path14.relative(projectRoot, resolvedPath);
+    const relPath = path15.relative(projectRoot, resolvedPath);
     const lines = [
       `\u{1F4CB} **Type Info** \u2014 \`${relPath}:${line + 1}:${character + 1}\``,
       "",
@@ -4691,7 +4820,7 @@ async function handleLspQuery(params) {
 }
 function extractSymbolAtPosition(filePath, line, character) {
   try {
-    const content = fs14.readFileSync(filePath, "utf-8");
+    const content = fs15.readFileSync(filePath, "utf-8");
     const lines = content.split("\n");
     const targetLine = lines[line];
     if (!targetLine) return null;
@@ -4722,7 +4851,7 @@ async function fallbackGrepReferences(symbolName, _filePath, _line, _character)
     const regex = new RegExp(`\\b${escapedSymbol}\\b`, "g");
     for (const file of tsFiles.slice(0, 100)) {
       try {
-        const content = fs14.readFileSync(file, "utf-8");
+        const content = fs15.readFileSync(file, "utf-8");
         const lines2 = content.split("\n");
         for (let i = 0; i < lines2.length; i++) {
           if (regex.test(lines2[i])) {
@@ -4751,8 +4880,28 @@ async function fallbackGrepReferences(symbolName, _filePath, _line, _character)
       `\u26A0\uFE0F Regex results may be less accurate than LSP (includes comments/strings).`,
       ""
     ];
+    if (grouped.size > 1) {
+      const fileList = [...grouped.keys()].map((f) => path15.relative(projectRoot, f)).join(", ");
+      lines.push(`\u26A0\uFE0F **Ambiguity warning:** Found matches across ${grouped.size} different files (${fileList}).`);
+      lines.push(`   Regex fallback cannot distinguish between different scopes with the same symbol name.`);
+      lines.push(`   If you intended only one scope, clarify which file or location you mean.`);
+      lines.push(`   \u{1F4A1} Install typescript-language-server for scope-aware disambiguation.`);
+      lines.push("");
+    } else if (results.length > 1) {
+      const filePath = [...grouped.keys()][0];
+      const refs = grouped.get(filePath);
+      const matchLines = refs.map((r) => r.line);
+      const minLine = Math.min(...matchLines);
+      const maxLine = Math.max(...matchLines);
+      if (maxLine - minLine > 15) {
+        lines.push(`\u26A0\uFE0F **Ambiguity warning:** Found ${results.length} matches for "${symbolName}" spanning lines ${minLine}-${maxLine} in the same file.`);
+        lines.push(`   They may be in different function scopes \u2014 regex cannot distinguish them.`);
+        lines.push(`   \u{1F4A1} Verify each match is the intended symbol before editing.`);
+        lines.push("");
+      }
+    }
     for (const [file, refs] of grouped) {
-      const relPath = path14.relative(projectRoot, file);
+      const relPath = path15.relative(projectRoot, file);
       lines.push(`**\u{1F4C4} ${relPath}:**`);
       for (const ref of refs) {
         lines.push(`  \u2514 L${ref.line} \u2014 ${ref.content}`);
@@ -4786,14 +4935,14 @@ async function fallbackGrepDefinition(symbolName) {
     ];
     for (const file of tsFiles) {
       try {
-        const content = fs14.readFileSync(file, "utf-8");
+        const content = fs15.readFileSync(file, "utf-8");
         const lines = content.split("\n");
         for (let i = 0; i < lines.length; i++) {
           const trimmed = lines[i].trim();
           for (const pattern of declPatterns) {
             if (pattern.test(trimmed)) {
               const projectRoot = getProjectRoot();
-              const relPath = path14.relative(projectRoot, file);
+              const relPath = path15.relative(projectRoot, file);
               return [
                 `\u{1F4CD} **Go to Definition** (regex fallback)`,
                 `\u{1F4C4} File: \`${relPath}\``,
@@ -4906,11 +5055,13 @@ function registerAllTools(server) {
   );
   server.tool(
     "execute_safe_test",
-    "Run tests, lint, or typecheck with timeout protection and circuit breaker. Use after every edit to verify you didn't break anything.",
+    "Run tests, lint, or typecheck with timeout protection and circuit breaker. Supports monorepo workspaces via 'workspace' or relative 'cwd'. Use after every edit to verify you didn't break anything.",
     {
       task: z.enum(["test", "build", "lint", "typecheck", "custom"]).describe("Task to execute: test, build, lint, typecheck, or custom"),
       customCommand: z.string({ invalid_type_error: '"customCommand" must be a string command like "npm run my-script"' }).optional().describe("Custom command (required only if task='custom')"),
-      timeout: z.number({ invalid_type_error: '"timeout" must be a number in seconds (5-180)' }).min(5).max(180).optional().default(60).describe("Timeout in seconds (default: 60s, max: 180s)")
+      timeout: z.number({ invalid_type_error: '"timeout" must be a number in seconds (5-180)' }).min(5).max(180).optional().default(60).describe("Timeout in seconds (default: 60s, max: 180s)"),
+      cwd: z.string().optional().describe("Relative directory from project root (e.g. 'packages/web'). Defaults to project root."),
+      workspace: z.string().optional().describe("Workspace name from project_conventions (e.g. 'frontend', 'api'). Auto-resolves to path.")
     },
     async (params) => {
       try {
@@ -5143,8 +5294,8 @@ function registerAllTools(server) {
 }
 
 // src/cli/init.ts
-import fs15 from "fs";
-import path15 from "path";
+import fs16 from "fs";
+import path16 from "path";
 var ALL_CONFIG_TYPES = [
   "claude",
   "cursor",
@@ -5536,10 +5687,10 @@ var TEMPLATES = {
 };
 var APPEND_SEPARATOR = "\n\n---\n_Generated by Kuma MCP - https://github.com/plumpslabs/kuma_\n\n";
 function handleOpencodeSecondary(root, results) {
-  const claudePath = path15.resolve(root, "CLAUDE.md");
-  if (!fs15.existsSync(claudePath)) {
+  const claudePath = path16.resolve(root, "CLAUDE.md");
+  if (!fs16.existsSync(claudePath)) {
     try {
-      fs15.writeFileSync(claudePath, [
+      fs16.writeFileSync(claudePath, [
         "# Kuma MCP - OpenCode Instructions",
         "",
         KUMA_CORE_INSTRUCTIONS
@@ -5556,21 +5707,21 @@ function handleOpencodeSecondary(root, results) {
   }
 }
 function handleCodexSecondary(root, results) {
-  const tomlPath = path15.resolve(root, ".codex/config.toml");
+  const tomlPath = path16.resolve(root, ".codex/config.toml");
   if (results.some((r) => r.filePath === ".codex/config.toml")) return;
   try {
-    const dir = path15.dirname(tomlPath);
-    if (!fs15.existsSync(dir)) fs15.mkdirSync(dir, { recursive: true });
-    if (fs15.existsSync(tomlPath)) {
-      const existingContent = fs15.readFileSync(tomlPath, "utf-8");
+    const dir = path16.dirname(tomlPath);
+    if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
+    if (fs16.existsSync(tomlPath)) {
+      const existingContent = fs16.readFileSync(tomlPath, "utf-8");
       if (existingContent.includes("kuma")) {
         results.push({ type: "codex", filePath: ".codex/config.toml", action: "skipped" });
         return;
       }
-      fs15.writeFileSync(tomlPath, existingContent.trimEnd() + "\n\n" + codexConfigTomlTemplate(), "utf-8");
+      fs16.writeFileSync(tomlPath, existingContent.trimEnd() + "\n\n" + codexConfigTomlTemplate(), "utf-8");
       results.push({ type: "codex", filePath: ".codex/config.toml", action: "appended" });
     } else {
-      fs15.writeFileSync(tomlPath, codexConfigTomlTemplate(), "utf-8");
+      fs16.writeFileSync(tomlPath, codexConfigTomlTemplate(), "utf-8");
       results.push({ type: "codex", filePath: ".codex/config.toml", action: "created" });
     }
   } catch (err) {
@@ -5583,11 +5734,11 @@ function handleCodexSecondary(root, results) {
   }
 }
 function handleQwenSecondary(root, results) {
-  const settingsPath = path15.resolve(root, "settings.json");
+  const settingsPath = path16.resolve(root, "settings.json");
   if (results.some((r) => r.filePath === "settings.json")) return;
   try {
-    if (fs15.existsSync(settingsPath)) {
-      const existingContent = fs15.readFileSync(settingsPath, "utf-8");
+    if (fs16.existsSync(settingsPath)) {
+      const existingContent = fs16.readFileSync(settingsPath, "utf-8");
       if (existingContent.includes("kuma")) {
         if (!existingContent.includes("_Generated by Kuma MCP_")) {
           try {
@@ -5595,7 +5746,7 @@ function handleQwenSecondary(root, results) {
             parsed.mcpServers = parsed.mcpServers || {};
             if (!parsed.mcpServers.kuma) {
               parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
-              fs15.writeFileSync(settingsPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+              fs16.writeFileSync(settingsPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
               results.push({ type: "qwen", filePath: "settings.json", action: "appended" });
               return;
             }
@@ -5610,13 +5761,13 @@ function handleQwenSecondary(root, results) {
         parsed.mcpServers = parsed.mcpServers || {};
         if (!parsed.mcpServers.kuma) {
           parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
-          fs15.writeFileSync(settingsPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+          fs16.writeFileSync(settingsPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
           results.push({ type: "qwen", filePath: "settings.json", action: "appended" });
         }
       } catch {
       }
     } else {
-      fs15.writeFileSync(settingsPath, qwenSettingsTemplate(), "utf-8");
+      fs16.writeFileSync(settingsPath, qwenSettingsTemplate(), "utf-8");
       results.push({ type: "qwen", filePath: "settings.json", action: "created" });
     }
   } catch (err) {
@@ -5652,18 +5803,18 @@ function getCombinedAgentsMd(selectedTypes) {
   return sections.join("\n\n---\n\n");
 }
 function handleAntigravityMcpConfig(root, results) {
-  const mcpPath = path15.resolve(root, ".agents/mcp_config.json");
+  const mcpPath = path16.resolve(root, ".agents/mcp_config.json");
   if (results.some((r) => r.filePath === ".agents/mcp_config.json")) return;
   try {
-    const mcpDir = path15.dirname(mcpPath);
-    if (fs15.existsSync(mcpPath)) {
-      const existingContent = fs15.readFileSync(mcpPath, "utf-8");
+    const mcpDir = path16.dirname(mcpPath);
+    if (fs16.existsSync(mcpPath)) {
+      const existingContent = fs16.readFileSync(mcpPath, "utf-8");
       if (existingContent.includes("kuma")) {
         if (!existingContent.includes("_Generated by Kuma MCP_")) {
           const trimmed = existingContent.trimEnd();
           if (trimmed.endsWith("}")) {
             const updated = trimmed.slice(0, -1).trimEnd() + ',\n  "_kuma_note": "Kuma MCP - Generated by kuma init"\n}\n';
-            fs15.writeFileSync(mcpPath, updated, "utf-8");
+            fs16.writeFileSync(mcpPath, updated, "utf-8");
             results.push({ type: "antigravity", filePath: ".agents/mcp_config.json", action: "appended" });
           }
         }
@@ -5672,11 +5823,11 @@ function handleAntigravityMcpConfig(root, results) {
       const parsed = JSON.parse(existingContent);
       parsed.mcpServers = parsed.mcpServers || {};
       parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
-      fs15.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+      fs16.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
       results.push({ type: "antigravity", filePath: ".agents/mcp_config.json", action: "appended" });
     } else {
-      if (!fs15.existsSync(mcpDir)) fs15.mkdirSync(mcpDir, { recursive: true });
-      fs15.writeFileSync(mcpPath, antigravityMcpConfigTemplate(), "utf-8");
+      if (!fs16.existsSync(mcpDir)) fs16.mkdirSync(mcpDir, { recursive: true });
+      fs16.writeFileSync(mcpPath, antigravityMcpConfigTemplate(), "utf-8");
       results.push({ type: "antigravity", filePath: ".agents/mcp_config.json", action: "created" });
     }
   } catch (err) {
@@ -5689,18 +5840,18 @@ function handleAntigravityMcpConfig(root, results) {
   }
 }
 function handleAiderSecondary(root, results) {
-  const ymlPath = path15.resolve(root, ".aider.conf.yml");
+  const ymlPath = path16.resolve(root, ".aider.conf.yml");
   if (results.some((r) => r.filePath === ".aider.conf.yml")) return;
   try {
     const conventionsRef = "read: CONVENTIONS.md";
-    if (fs15.existsSync(ymlPath)) {
-      const existingContent = fs15.readFileSync(ymlPath, "utf-8");
+    if (fs16.existsSync(ymlPath)) {
+      const existingContent = fs16.readFileSync(ymlPath, "utf-8");
       if (existingContent.includes("CONVENTIONS.md") || existingContent.includes("kuma")) {
         results.push({ type: "aider", filePath: ".aider.conf.yml", action: "skipped" });
         return;
       }
       const newContent = existingContent.trimEnd() + "\n\n# Kuma MCP conventions\n" + conventionsRef + "\n";
-      fs15.writeFileSync(ymlPath, newContent, "utf-8");
+      fs16.writeFileSync(ymlPath, newContent, "utf-8");
       results.push({ type: "aider", filePath: ".aider.conf.yml", action: "appended" });
     } else {
       const content = [
@@ -5710,7 +5861,7 @@ function handleAiderSecondary(root, results) {
         conventionsRef,
         ""
       ].join("\n");
-      fs15.writeFileSync(ymlPath, content, "utf-8");
+      fs16.writeFileSync(ymlPath, content, "utf-8");
       results.push({ type: "aider", filePath: ".aider.conf.yml", action: "created" });
     }
   } catch (err) {
@@ -5723,10 +5874,10 @@ function handleAiderSecondary(root, results) {
   }
 }
 function handleCopilotSecondary(root, results) {
-  const skillPath = path15.resolve(root, ".github/skills/kuma/SKILL.md");
+  const skillPath = path16.resolve(root, ".github/skills/kuma/SKILL.md");
   if (results.some((r) => r.filePath === ".github/skills/kuma/SKILL.md")) return;
   try {
-    const dir = path15.dirname(skillPath);
+    const dir = path16.dirname(skillPath);
     const content = [
       "---",
       "name: kuma-mcp",
@@ -5737,17 +5888,17 @@ function handleCopilotSecondary(root, results) {
       "",
       KUMA_CORE_INSTRUCTIONS
     ].join("\n");
-    if (fs15.existsSync(skillPath)) {
-      const existingContent = fs15.readFileSync(skillPath, "utf-8");
+    if (fs16.existsSync(skillPath)) {
+      const existingContent = fs16.readFileSync(skillPath, "utf-8");
       if (existingContent.includes("kuma")) {
         results.push({ type: "copilot", filePath: ".github/skills/kuma/SKILL.md", action: "skipped" });
         return;
       }
-      fs15.writeFileSync(skillPath, existingContent.trimEnd() + "\n\n" + content, "utf-8");
+      fs16.writeFileSync(skillPath, existingContent.trimEnd() + "\n\n" + content, "utf-8");
       results.push({ type: "copilot", filePath: ".github/skills/kuma/SKILL.md", action: "appended" });
     } else {
-      if (!fs15.existsSync(dir)) fs15.mkdirSync(dir, { recursive: true });
-      fs15.writeFileSync(skillPath, content, "utf-8");
+      if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
+      fs16.writeFileSync(skillPath, content, "utf-8");
       results.push({ type: "copilot", filePath: ".github/skills/kuma/SKILL.md", action: "created" });
     }
   } catch (err) {
@@ -5760,21 +5911,21 @@ function handleCopilotSecondary(root, results) {
   }
 }
 function handleOpenclawSecondary(root, results) {
-  const mcpPath = path15.resolve(root, ".agents/mcp_config.json");
+  const mcpPath = path16.resolve(root, ".agents/mcp_config.json");
   if (results.some((r) => r.filePath === ".agents/mcp_config.json")) return;
   try {
-    const dir = path15.dirname(mcpPath);
-    if (fs15.existsSync(mcpPath)) {
-      const existingContent = fs15.readFileSync(mcpPath, "utf-8");
+    const dir = path16.dirname(mcpPath);
+    if (fs16.existsSync(mcpPath)) {
+      const existingContent = fs16.readFileSync(mcpPath, "utf-8");
       if (existingContent.includes("kuma")) return;
       const parsed = JSON.parse(existingContent);
       parsed.mcpServers = parsed.mcpServers || {};
       parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
-      fs15.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+      fs16.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
       results.push({ type: "openclaw", filePath: ".agents/mcp_config.json", action: "appended" });
     } else {
-      if (!fs15.existsSync(dir)) fs15.mkdirSync(dir, { recursive: true });
-      fs15.writeFileSync(mcpPath, antigravityMcpConfigTemplate(), "utf-8");
+      if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
+      fs16.writeFileSync(mcpPath, antigravityMcpConfigTemplate(), "utf-8");
       results.push({ type: "openclaw", filePath: ".agents/mcp_config.json", action: "created" });
     }
   } catch (err) {
@@ -5787,20 +5938,20 @@ function handleOpenclawSecondary(root, results) {
   }
 }
 function handleCodewhaleSecondary(root, results) {
-  const mcpPath = path15.resolve(root, ".codewhale/mcp.json");
+  const mcpPath = path16.resolve(root, ".codewhale/mcp.json");
   if (results.some((r) => r.filePath === ".codewhale/mcp.json")) return;
   try {
-    const dir = path15.dirname(mcpPath);
-    if (fs15.existsSync(mcpPath)) {
-      const existingContent = fs15.readFileSync(mcpPath, "utf-8");
+    const dir = path16.dirname(mcpPath);
+    if (fs16.existsSync(mcpPath)) {
+      const existingContent = fs16.readFileSync(mcpPath, "utf-8");
       if (existingContent.includes("kuma")) return;
       const parsed = JSON.parse(existingContent);
       parsed.mcpServers = parsed.mcpServers || {};
       parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
-      fs15.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+      fs16.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
       results.push({ type: "codewhale", filePath: ".codewhale/mcp.json", action: "appended" });
     } else {
-      if (!fs15.existsSync(dir)) fs15.mkdirSync(dir, { recursive: true });
+      if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
       const config = {
         mcpServers: {
           kuma: {
@@ -5810,7 +5961,7 @@ function handleCodewhaleSecondary(root, results) {
           }
         }
       };
-      fs15.writeFileSync(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+      fs16.writeFileSync(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
       results.push({ type: "codewhale", filePath: ".codewhale/mcp.json", action: "created" });
     }
   } catch (err) {
@@ -5831,24 +5982,24 @@ function runInit(types, projectRoot) {
   let agentsMdHandled = false;
   for (const type of selected) {
     const relativePath = configFilePath(type);
-    const fullPath = path15.resolve(root, relativePath);
+    const fullPath = path16.resolve(root, relativePath);
     const getTemplate = TEMPLATES[type];
     try {
       if (AGENTS_MD_TYPES.includes(type) && !agentsMdHandled) {
         agentsMdHandled = true;
         const combinedContent = getCombinedAgentsMd(new Set(agentsMdSelected));
-        if (fs15.existsSync(fullPath)) {
-          const existingContent = fs15.readFileSync(fullPath, "utf-8");
+        if (fs16.existsSync(fullPath)) {
+          const existingContent = fs16.readFileSync(fullPath, "utf-8");
           if (existingContent.includes("_Generated by Kuma MCP_")) {
             results.push({ type, filePath: relativePath, action: "skipped" });
           } else {
-            fs15.writeFileSync(fullPath, existingContent.trimEnd() + "\n\n" + combinedContent, "utf-8");
+            fs16.writeFileSync(fullPath, existingContent.trimEnd() + "\n\n" + combinedContent, "utf-8");
             results.push({ type, filePath: relativePath, action: "appended" });
           }
         } else {
-          const dir = path15.dirname(fullPath);
-          if (!fs15.existsSync(dir)) fs15.mkdirSync(dir, { recursive: true });
-          fs15.writeFileSync(fullPath, combinedContent, "utf-8");
+          const dir = path16.dirname(fullPath);
+          if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
+          fs16.writeFileSync(fullPath, combinedContent, "utf-8");
           results.push({ type, filePath: relativePath, action: "created" });
         }
         if (selectedSet.has("codex")) handleCodexSecondary(root, results);
@@ -5859,8 +6010,8 @@ function runInit(types, projectRoot) {
         continue;
       } else {
         const template = getTemplate();
-        if (fs15.existsSync(fullPath)) {
-          const existingContent = fs15.readFileSync(fullPath, "utf-8");
+        if (fs16.existsSync(fullPath)) {
+          const existingContent = fs16.readFileSync(fullPath, "utf-8");
           if (existingContent.includes("_Generated by Kuma MCP_")) {
             if (type === "antigravity") {
               handleAntigravityMcpConfig(root, results);
@@ -5873,14 +6024,14 @@ function runInit(types, projectRoot) {
             continue;
           }
           const newContent = existingContent.trimEnd() + APPEND_SEPARATOR + template;
-          fs15.writeFileSync(fullPath, newContent, "utf-8");
+          fs16.writeFileSync(fullPath, newContent, "utf-8");
           results.push({ type, filePath: relativePath, action: "appended" });
         } else {
-          const dir = path15.dirname(fullPath);
-          if (!fs15.existsSync(dir)) {
-            fs15.mkdirSync(dir, { recursive: true });
+          const dir = path16.dirname(fullPath);
+          if (!fs16.existsSync(dir)) {
+            fs16.mkdirSync(dir, { recursive: true });
           }
-          fs15.writeFileSync(fullPath, template, "utf-8");
+          fs16.writeFileSync(fullPath, template, "utf-8");
           results.push({ type, filePath: relativePath, action: "created" });
         }
         if (type === "antigravity") {