@plumpslabs/kuma 2.2.5 → 2.2.7

package/dist/index.js

@@ -33,6 +33,7 @@ import { z } from "zod";
 import fg from "fast-glob";
 import fs from "fs";
 import path from "path";
+import { execSync } from "child_process";
 
 // src/utils/tokenCounter.ts
 function estimateTokens(text) {
@@ -86,94 +87,315 @@ var IGNORE_PATTERNS = [
 ];
 var grepCache = /* @__PURE__ */ new Map();
 var CACHE_TTL_MS = 3e4;
+var rgAvailable = null;
+function isRipgrepAvailable() {
+  if (process.env.KUMA_DISABLE_RG === "1" || process.env.KUMA_DISABLE_RG === "true") {
+    return false;
+  }
+  if (rgAvailable !== null) return rgAvailable;
+  try {
+    execSync("rg --version", { stdio: "ignore", timeout: 2e3 });
+    rgAvailable = true;
+  } catch {
+    rgAvailable = false;
+  }
+  return rgAvailable;
+}
+function quotePath(p) {
+  return `"${p.replace(/"/g, '\\"')}"`;
+}
 async function handleSmartGrep(params) {
-  const { query, targetFolder, maxResults = 30, extensions } = params;
-  if (!query || query.length < 1) {
-    return "Error: 'query' parameter is required.";
+  const {
+    query,
+    queries,
+    targetFolder,
+    maxResults = 30,
+    extensions,
+    contextLines = 1,
+    filenamesOnly = false,
+    countOnly = false,
+    outputMode = "rich",
+    compact = false
+  } = params;
+  const patterns = queries && queries.length > 0 ? queries : query ? [query] : [];
+  if (patterns.length === 0 || patterns[0].length < 1) {
+    return compact ? "ERR:query required" : "Error: 'query' or 'queries' parameter is required.";
   }
-  const cacheKey = `${query}:${targetFolder ?? "root"}:${maxResults}:${extensions ? extensions.join(",") : ""}`;
+  const cacheKey = `${patterns.join("||")}:${targetFolder ?? "root"}:${maxResults}:${contextLines}:${filenamesOnly}:${countOnly}:${outputMode}:${extensions ? extensions.join(",") : ""}`;
   const cached = grepCache.get(cacheKey);
   if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
-    sessionMemory.recordToolCall("smart_grep", { query, cached: true });
+    sessionMemory.recordToolCall("smart_grep", { query: patterns[0], cached: true });
     return cached.results;
   }
   const projectRoot = getProjectRoot();
+  let result;
+  if (isRipgrepAvailable()) {
+    result = await tryRipgrep(patterns, {
+      projectRoot,
+      targetFolder,
+      maxResults,
+      extensions,
+      contextLines,
+      filenamesOnly,
+      countOnly,
+      outputMode,
+      compact
+    });
+  } else {
+    result = await jsGrep(patterns, {
+      projectRoot,
+      targetFolder,
+      maxResults,
+      extensions,
+      contextLines,
+      filenamesOnly,
+      countOnly,
+      outputMode,
+      compact
+    });
+  }
+  grepCache.set(cacheKey, { results: result, timestamp: Date.now() });
+  sessionMemory.recordToolCall("smart_grep", {
+    query: patterns[0],
+    matchCount: result.length,
+    engine: rgAvailable ? "ripgrep" : "js"
+  });
+  return result;
+}
+async function tryRipgrep(patterns, opts) {
+  const args = [];
+  args.push("rg", "--no-heading", "--color", "never", "-i");
+  if (opts.extensions && opts.extensions.length > 0) {
+    for (const ext of opts.extensions) {
+      const clean = ext.startsWith(".") ? ext.slice(1) : ext;
+      args.push("--type-add", `kuma:*.${clean}`);
+      args.push("--type", "kuma");
+    }
+  }
+  if (opts.contextLines > 0 && !opts.filenamesOnly && !opts.countOnly) {
+    args.push("-C", String(opts.contextLines));
+  }
+  if (!opts.filenamesOnly && !opts.countOnly) {
+    const perFileLimit = Math.min(opts.maxResults, 50);
+    args.push("-m", String(perFileLimit));
+  }
+  if (opts.filenamesOnly) {
+    args.push("-l");
+  }
+  if (opts.countOnly) {
+    args.push("-c");
+  }
+  for (const p of patterns) {
+    args.push("-e", p);
+  }
+  const searchDir = opts.targetFolder ? path.join(opts.projectRoot, opts.targetFolder) : opts.projectRoot;
+  args.push(quotePath(searchDir));
   try {
-    const searchPattern = targetFolder ? path.join(targetFolder, "**/*").replace(/\\/g, "/") : "**/*";
-    const targetDepth = targetFolder ? targetFolder.split("/").filter(Boolean).length : 0;
-    const maxDepth = targetFolder ? Math.min(targetDepth + 5, 20) : 10;
-    let entries = await fg(searchPattern, {
-      cwd: projectRoot,
-      ignore: IGNORE_PATTERNS,
-      onlyFiles: true,
-      absolute: false,
-      deep: maxDepth,
-      dot: false
-      // Skip dotfiles
+    const output = execSync(args.join(" "), {
+      cwd: opts.projectRoot,
+      maxBuffer: 10 * 1024 * 1024,
+      // 10MB
+      timeout: 15e3,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
     });
-    if (extensions && extensions.length > 0) {
-      const normalizedExts = extensions.map(
-        (e) => e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`
-      );
-      entries = entries.filter((entry) => {
-        const ext = path.extname(entry).toLowerCase();
-        return normalizedExts.includes(ext);
-      });
+    if (!output || output.trim().length === 0) {
+      return formatEmpty(patterns[0], opts);
     }
-    if (entries.length === 0) {
-      const msg = `No files found${targetFolder ? ` in folder "${targetFolder}"` : ""}${extensions ? ` with extensions [${extensions.join(", ")}]` : ""}.`;
-      grepCache.set(cacheKey, { results: msg, timestamp: Date.now() });
-      return msg;
+    return formatRipgrepOutput(output, patterns, opts);
+  } catch (err) {
+    if (err.status === 1) {
+      return formatEmpty(patterns[0], opts);
     }
-    const regex = createRegex(query);
-    const results = [];
-    let filesScanned = 0;
-    for (const entry of entries) {
-      if (results.length >= maxResults) break;
-      filesScanned++;
-      try {
-        const fullPath = path.join(projectRoot, entry);
-        const stat = fs.statSync(fullPath);
-        if (stat.size > 5e5) continue;
-        if (isBinaryFile(fullPath)) continue;
-        const content = fs.readFileSync(fullPath, "utf-8");
-        const lines = content.split("\n");
-        for (let i = 0; i < lines.length; i++) {
-          if (results.length >= maxResults) break;
-          const line = lines[i];
-          if (regex.test(line)) {
-            const contextLines = [];
-            if (i > 0)
-              contextLines.push(`${i}: ${lines[i - 1].substring(0, 200)}`);
-            contextLines.push(`${i + 1}: ${line.substring(0, 200)}`);
-            if (i < lines.length - 1)
-              contextLines.push(`${i + 2}: ${lines[i + 1].substring(0, 200)}`);
-            results.push({
-              file: entry,
-              line: i + 1,
-              content: contextLines.join("\n")
-            });
-          }
+    return await jsGrep(patterns, opts);
+  }
+}
+function formatRipgrepOutput(output, patterns, opts) {
+  const lines = output.trim().split("\n");
+  if (opts.countOnly) {
+    const counts = lines.map((l) => {
+      const parts = l.split(":");
+      if (parts.length >= 2) {
+        const count = parts.pop();
+        return `${parts.join(":")}:${count}`;
+      }
+      return l;
+    });
+    if (opts.outputMode === "json") {
+      const obj = {};
+      for (const c of counts) {
+        const idx = c.lastIndexOf(":");
+        if (idx > 0) {
+          obj[c.slice(0, idx)] = parseInt(c.slice(idx + 1), 10);
         }
-      } catch {
-        continue;
       }
+      return JSON.stringify(obj);
     }
-    const formatted = formatResults(results, query, filesScanned);
-    grepCache.set(cacheKey, { results: formatted, timestamp: Date.now() });
-    sessionMemory.recordToolCall("smart_grep", {
-      query,
-      matchCount: results.length,
-      filesScanned
+    if (opts.compact) return counts.join("\n");
+    return `\u{1F4CA} Count results for "${patterns[0]}":
+${counts.join("\n")}`;
+  }
+  if (opts.filenamesOnly) {
+    if (opts.outputMode === "json") return JSON.stringify(lines);
+    if (opts.compact) return lines.join("\n");
+    return `\u{1F4C1} Files matching "${patterns[0]}":
+${lines.join("\n")}`;
+  }
+  const results = parseRipgrepOutput(output, opts.projectRoot).slice(0, opts.maxResults);
+  if (results.length === 0) {
+    return formatEmpty(patterns[0], opts);
+  }
+  if (opts.compact || opts.outputMode === "raw") {
+    return results.map((r) => `${r.file}:${r.line}:${r.content}`).join("\n");
+  }
+  if (opts.outputMode === "json") {
+    return JSON.stringify(results);
+  }
+  const header = `\u{1F50D} Smart Grep: "${patterns[0]}"
+\u{1F4C1} ${results.length} matches
+`;
+  const body = results.map((r, i) => `[${i + 1}] \u{1F4C4} ${r.file}:${r.line}
+    ${r.content}`).join("\n");
+  return limitLines(`${header}${body}`, 150);
+}
+function parseRipgrepOutput(output, projectRoot) {
+  const results = [];
+  const lines = output.trim().split("\n");
+  const rootPrefix = projectRoot ? projectRoot.replace(/\/+$/, "") + "/" : "";
+  for (const line of lines) {
+    const lastColonIdx = line.lastIndexOf(":");
+    if (lastColonIdx <= 0) continue;
+    const beforeLastColon = line.slice(0, lastColonIdx);
+    const afterLastColon = line.slice(lastColonIdx + 1);
+    if (!afterLastColon.trim()) continue;
+    const secondLastColonIdx = beforeLastColon.lastIndexOf(":");
+    if (secondLastColonIdx <= 0) continue;
+    let potentialFile = beforeLastColon.slice(0, secondLastColonIdx);
+    const potentialLineStr = beforeLastColon.slice(secondLastColonIdx + 1);
+    const potentialLine = parseInt(potentialLineStr, 10);
+    if (isNaN(potentialLine) || potentialLine <= 0) continue;
+    if (rootPrefix && potentialFile.startsWith(rootPrefix)) {
+      potentialFile = potentialFile.slice(rootPrefix.length);
+    }
+    results.push({
+      file: potentialFile,
+      line: potentialLine,
+      content: afterLastColon.trim()
     });
-    sessionMemory.addSearchResult(
-      query,
-      results.map((r) => r.file)
+  }
+  return results;
+}
+async function jsGrep(patterns, opts) {
+  const { projectRoot, targetFolder, maxResults, extensions, contextLines, filenamesOnly, countOnly, outputMode, compact } = opts;
+  const searchPattern = targetFolder ? path.join(targetFolder, "**/*").replace(/\\/g, "/") : "**/*";
+  const targetDepth = targetFolder ? targetFolder.split("/").filter(Boolean).length : 0;
+  const maxDepth = targetFolder ? Math.min(targetDepth + 5, 20) : 10;
+  let entries = await fg(searchPattern, {
+    cwd: projectRoot,
+    ignore: IGNORE_PATTERNS,
+    onlyFiles: true,
+    absolute: false,
+    deep: maxDepth,
+    dot: false
+  });
+  if (extensions && extensions.length > 0) {
+    const normalizedExts = extensions.map(
+      (e) => e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`
     );
-    return formatted;
-  } catch (err) {
-    return `Error searching "${query}": ${err instanceof Error ? err.message : String(err)}`;
+    entries = entries.filter((entry) => {
+      const ext = path.extname(entry).toLowerCase();
+      return normalizedExts.includes(ext);
+    });
   }
+  if (entries.length === 0) {
+    return formatEmpty(patterns[0], opts);
+  }
+  const regex = createCombinedRegex(patterns);
+  const results = [];
+  const fileCounts = /* @__PURE__ */ new Map();
+  const matchedFiles = /* @__PURE__ */ new Set();
+  let filesScanned = 0;
+  for (const entry of entries) {
+    if (!filenamesOnly && results.length >= maxResults) break;
+    filesScanned++;
+    try {
+      const fullPath = path.join(projectRoot, entry);
+      const stat = fs.statSync(fullPath);
+      if (stat.size > 5e5) continue;
+      if (isBinaryFile(fullPath)) continue;
+      const content = fs.readFileSync(fullPath, "utf-8");
+      const lines = content.split("\n");
+      let fileMatchCount = 0;
+      for (let i = 0; i < lines.length; i++) {
+        if (!filenamesOnly && results.length >= maxResults) break;
+        if (regex.test(lines[i])) {
+          fileMatchCount++;
+          matchedFiles.add(entry);
+          if (filenamesOnly) {
+            break;
+          }
+          if (countOnly) {
+            fileCounts.set(entry, (fileCounts.get(entry) || 0) + 1);
+            continue;
+          }
+          const contextLinesArr = [];
+          const startCtx = Math.max(0, i - contextLines);
+          const endCtx = Math.min(lines.length - 1, i + contextLines);
+          for (let ci = startCtx; ci <= endCtx; ci++) {
+            const prefix = ci === i ? ">" : " ";
+            contextLinesArr.push(`${prefix}${ci + 1}: ${lines[ci].substring(0, 200)}`);
+          }
+          results.push({
+            file: entry,
+            line: i + 1,
+            content: contextLinesArr.join("\n")
+          });
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  if (matchedFiles.size === 0) {
+    return formatEmpty(patterns[0], opts);
+  }
+  if (filenamesOnly) {
+    const files = Array.from(matchedFiles);
+    if (outputMode === "json") return JSON.stringify(files);
+    if (compact) return files.join("\n");
+    return `\u{1F4C1} Files matching "${patterns[0]}":
+${files.join("\n")}`;
+  }
+  if (countOnly) {
+    const counts = Array.from(fileCounts.entries()).map(([f, c]) => `${f}:${c}`);
+    if (outputMode === "json") return JSON.stringify(Object.fromEntries(fileCounts));
+    if (compact) return counts.join("\n");
+    return `\u{1F4CA} Count results for "${patterns[0]}":
+${counts.join("\n")}`;
+  }
+  if (compact || outputMode === "raw") {
+    return results.map((r) => `${r.file}:${r.line}:${r.content.split("\n")[0].replace(/^[>\s]+\d+:\s*/, "")}`).join("\n");
+  }
+  if (outputMode === "json") {
+    return JSON.stringify(results);
+  }
+  return formatResults(results, patterns[0], filesScanned);
+}
+function createCombinedRegex(patterns) {
+  if (patterns.length === 1) {
+    return createRegex(patterns[0]);
+  }
+  const combined = patterns.map((p) => {
+    try {
+      if (/[.\\+*?[\](){}^$|]/.test(p)) {
+        return `(?:${p})`;
+      }
+      return `(?:${p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})`;
+    } catch {
+      return p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+  }).join("|");
+  return new RegExp(combined, "i");
 }
 function createRegex(query) {
   const normalized = query.replace(/\\\|/g, "|");
@@ -185,23 +407,27 @@ function createRegex(query) {
   }
   return new RegExp(normalized.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
 }
+function formatEmpty(pattern, opts) {
+  if (opts.outputMode === "json") return JSON.stringify({ query: pattern, matches: 0, results: [] });
+  if (opts.compact) return `0:${pattern}`;
+  return `\u{1F50D} No matches for "${pattern}".`;
+}
 function formatResults(results, query, filesScanned) {
   if (results.length === 0) {
     return `\u{1F50D} No matches for "${query}" (${filesScanned} files scanned).`;
   }
-  const lines = [
+  const lines_out = [
     `\u{1F50D} Smart Grep: "${query}"`,
     `\u{1F4C1} ${results.length} matches from ${filesScanned} files scanned`,
     "",
     ...results.map((r, i) => {
-      const filePath = r.file;
-      return `[${i + 1}] \u{1F4C4} ${filePath}:${r.line}
+      return `[${i + 1}] \u{1F4C4} ${r.file}:${r.line}
 ${r.content.split("\n").map((l) => `    ${l}`).join("\n")}`;
     }),
     "",
     `\u{1F4A1} Use smart_file_picker to open a specific file.`
   ];
-  return limitLines(lines.join("\n"), 150);
+  return limitLines(lines_out.join("\n"), 150);
 }
 function isBinaryFile(filePath) {
   try {
@@ -224,10 +450,54 @@ import path2 from "path";
 var MAX_FILE_SIZE = 1e6;
 var CHUNK_THRESHOLD = 300;
 async function handleSmartFilePicker(params) {
-  const { filePath, startLine, endLine, chunkStrategy = "smart" } = params;
+  const {
+    filePath,
+    files,
+    startLine,
+    endLine,
+    contextLines = 5,
+    chunkStrategy = "smart",
+    outputMode = "rich",
+    compact = false
+  } = params;
+  const filePaths = [];
+  if (files && files.length > 0) {
+    filePaths.push(...files);
+  } else if (filePath) {
+    filePaths.push(filePath);
+  } else {
+    return compact ? "ERR:filePath required" : "Error: 'filePath' or 'files' parameter is required.";
+  }
+  const results = [];
+  for (const fp of filePaths) {
+    const result = await readSingleFile(fp, {
+      startLine,
+      endLine,
+      contextLines,
+      chunkStrategy,
+      outputMode,
+      compact
+    });
+    results.push(result);
+  }
+  if (results.length === 1) return results[0];
+  if (compact || outputMode === "raw") {
+    return results.join("\n---\n");
+  }
+  return results.join("\n\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n\n");
+}
+async function readSingleFile(filePath, opts) {
+  const {
+    startLine,
+    endLine,
+    contextLines,
+    chunkStrategy,
+    outputMode,
+    compact
+  } = opts;
   const validation = validateFilePath(filePath);
   if (!validation.valid) {
-    return "Error: " + validation.error.message;
+    return compact ? `ERR:${filePath} - ${validation.error.message}` : `Error: ${validation.error.message}`;
   }
   const resolvedPath = validation.resolvedPath;
   if (!fs2.existsSync(resolvedPath)) {
@@ -235,15 +505,21 @@ async function handleSmartFilePicker(params) {
     let suggestion;
     if (!path2.isAbsolute(filePath)) {
       const cwdPath = path2.resolve(process.cwd(), filePath);
-      suggestion = "Path resolved to: " + resolvedPath + "\nCWD: " + process.cwd() + "\nProject root: " + projectRoot + "\nHint: Try path relative to project root, or relative to CWD (" + cwdPath + ")\nTry smart_grep first to locate the correct file.";
+      suggestion = `Path resolved to: ${resolvedPath}
+CWD: ${process.cwd()}
+Project root: ${projectRoot}
+Hint: Try path relative to project root, or relative to CWD (${cwdPath})
+Try smart_grep first to locate the correct file.`;
     } else {
       suggestion = "File does not exist. Try smart_grep to locate it.";
     }
-    return 'Error: File not found: "' + filePath + '".\n' + suggestion;
+    return compact ? `ERR:not found "${filePath}"` : `Error: File not found: "${filePath}".
+${suggestion}`;
   }
   const stat = fs2.statSync(resolvedPath);
   if (stat.size > MAX_FILE_SIZE) {
-    return "Error: File too large (" + (stat.size / 1024 / 1024).toFixed(1) + "MB). Max 1MB.\nUse smart_grep to find specific content instead.";
+    return compact ? `ERR:too large ${filePath} (${(stat.size / 1024 / 1024).toFixed(1)}MB)` : `Error: File too large (${(stat.size / 1024 / 1024).toFixed(1)}MB). Max 1MB.
+Use smart_grep to find specific content instead.`;
   }
   try {
     const content = fs2.readFileSync(resolvedPath, "utf-8");
@@ -254,6 +530,26 @@ async function handleSmartFilePicker(params) {
       chunkStrategy,
       totalLines
     });
+    if (compact || outputMode === "raw") {
+      if (startLine !== void 0 || endLine !== void 0) {
+        const start = startLine ?? 1;
+        const end = endLine ?? totalLines;
+        return lines.slice(start - 1, end).join("\n");
+      }
+      if (totalLines <= CHUNK_THRESHOLD || chunkStrategy === "full") {
+        return content;
+      }
+      const tailStart = Math.max(totalLines - 50, 0);
+      return lines.slice(0, 50).join("\n") + `
+... ${totalLines - 100} lines hidden ...
+` + lines.slice(tailStart).join("\n");
+    }
+    if (startLine !== void 0 && endLine === void 0) {
+      const ctxStart = Math.max(0, startLine - 1 - contextLines);
+      const ctxEnd = Math.min(totalLines, startLine - 1 + contextLines);
+      const selectedLines = lines.slice(ctxStart, ctxEnd);
+      return formatJumpOutput(filePath, selectedLines, ctxStart + 1, startLine, totalLines);
+    }
     if (startLine !== void 0 || endLine !== void 0) {
       const start = startLine ?? 1;
       const end = endLine ?? totalLines;
@@ -278,30 +574,43 @@ async function handleSmartFilePicker(params) {
         );
     }
   } catch (err) {
-    return 'Error reading file "' + filePath + '": ' + (err instanceof Error ? err.message : String(err));
+    return compact ? `ERR:reading "${filePath}"` : `Error reading file "${filePath}": ${err instanceof Error ? err.message : String(err)}`;
   }
 }
+function formatJumpOutput(filePath, lines, startLine, targetLine, totalLines) {
+  const header = [
+    `File: ${filePath}`,
+    `${totalLines} total lines`,
+    `Jumped to line ${targetLine} (\xB1context)`,
+    ""
+  ].join("\n");
+  const body = lines.map((line, i) => {
+    const lineNum = startLine + i;
+    const marker = lineNum === targetLine ? ">" : " ";
+    return `${marker} ${String(lineNum).padStart(4, " ")} | ${line}`;
+  }).join("\n");
+  return header + "\n" + body;
+}
 function formatOutput(filePath, lines, startLine, totalLines, truncated) {
   const header = [
-    "File: " + filePath,
-    totalLines + " total lines",
-    truncated ? "Showing " + lines.length + " lines (file >" + CHUNK_THRESHOLD + " lines). Use startLine/endLine for a specific range." : "",
+    `File: ${filePath}`,
+    `${totalLines} total lines`,
+    truncated ? `Showing ${lines.length} lines (file >${CHUNK_THRESHOLD} lines). Use startLine/endLine for a specific range.` : "",
     ""
   ].filter(Boolean).join("\n");
   const body = lines.map((line, i) => {
     const lineNum = startLine + i;
-    return String(lineNum).padStart(4, " ") + " | " + line;
+    return `${String(lineNum).padStart(4, " ")} | ${line}`;
   }).join("\n");
-  const full = header + "\n" + body;
-  return truncateToTokenLimit(full, 2e3);
+  return truncateToTokenLimit(`${header}
+${body}`, 2e3);
 }
 async function handleOutlineStrategy(filePath, lines, totalLines) {
   const importLines = [];
   const exportLines = [];
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i].trim();
-    if (line.startsWith("//") || line.startsWith("#") || line.startsWith("/*") || line.startsWith("*"))
-      continue;
+    if (line.startsWith("//") || line.startsWith("#") || line.startsWith("/*") || line.startsWith("*")) continue;
     if (line.startsWith("import ") || line.startsWith("from ") || line.startsWith("require(")) {
       importLines.push(line);
       continue;
@@ -311,15 +620,15 @@ async function handleOutlineStrategy(filePath, lines, totalLines) {
     }
   }
   const result = [
-    "File: " + filePath,
-    totalLines + " total lines (OUTLINE MODE - signatures and imports only)",
+    `File: ${filePath}`,
+    `${totalLines} total lines (OUTLINE MODE - signatures and imports only)`,
     "",
     "Imports:",
-    ...importLines.slice(0, 30).map((l) => "  " + l.substring(0, 150)),
-    importLines.length > 30 ? "  ...and " + (importLines.length - 30) + " more imports" : "",
+    ...importLines.slice(0, 30).map((l) => `  ${l.substring(0, 150)}`),
+    importLines.length > 30 ? `  ...and ${importLines.length - 30} more imports` : "",
     "",
     "Exports & Declarations:",
-    ...exportLines.map((e) => "  [L" + e.line + "] " + e.text),
+    ...exportLines.map((e) => `  [L${e.line}] ${e.text}`),
     "",
     "Pass startLine/endLine to read a specific range.",
     'Or use chunkStrategy: "full" to read the entire file.'
@@ -337,7 +646,7 @@ async function handleSmartStrategy(filePath, lines, totalLines) {
     smartLines.push({ line: -1, text: "" });
     smartLines.push({
       line: -1,
-      text: "  ... " + (tailStart - headerEnd) + " lines hidden ..."
+      text: `  ... ${tailStart - headerEnd} lines hidden ...`
     });
     smartLines.push({ line: -1, text: "" });
   }
@@ -354,18 +663,18 @@ async function handleSmartStrategy(filePath, lines, totalLines) {
     smartLines.push({ line: i + 1, text: lines[i] });
   }
   const header = [
-    "File: " + filePath,
-    totalLines + " total lines (SMART MODE - header + signatures + tail)",
+    `File: ${filePath}`,
+    `${totalLines} total lines (SMART MODE - header + signatures + tail)`,
     "Pass startLine/endLine to read a specific range.",
     'Or use chunkStrategy: "full" to read the entire file.',
     ""
   ].join("\n");
   const body = smartLines.map((s) => {
     if (s.line === -1) return s.text;
-    return String(s.line).padStart(4, " ") + " | " + s.text;
+    return `${String(s.line).padStart(4, " ")} | ${s.text}`;
   }).join("\n");
-  const full = header + "\n" + body;
-  return truncateToTokenLimit(full, 3e3);
+  return truncateToTokenLimit(`${header}
+${body}`, 3e3);
 }
 function findHeaderEnd(lines) {
   let lastImportLine = 0;
@@ -386,9 +695,7 @@ function extractKeyDeclarations(lines) {
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i].trim();
     if (!line || line.startsWith("//") || line.startsWith("#")) continue;
-    if (/^(export\s+)?(async\s+)?(function|class|interface|type|enum|const|let|var|def)\s/.test(
-      line
-    )) {
+    if (/^(export\s+)?(async\s+)?(function|class|interface|type|enum|const|let|var|def)\s/.test(line)) {
       decls.push({ line: i, text: line.substring(0, 150) });
     }
   }
@@ -453,11 +760,48 @@ var CircuitBreakerStore = class {
 var circuitBreaker = new CircuitBreakerStore();
 
 // src/tools/preciseDiffEditor.ts
+function fastApplyEdit(content, edit) {
+  const { searchBlock, replaceBlock, allowMultiple = false } = edit;
+  const count = countOccurrences(content, searchBlock);
+  if (count === 0) {
+    return {
+      success: false,
+      matched: 0,
+      replaced: 0,
+      error: `DIFF_MISMATCH: searchBlock not found (fast mode - exact match only)`,
+      details: content
+    };
+  }
+  const newContent = allowMultiple ? replaceAll(content, searchBlock, replaceBlock) : content.replace(searchBlock, replaceBlock);
+  return {
+    success: true,
+    matched: count,
+    replaced: allowMultiple ? count : 1,
+    details: newContent
+  };
+}
+function formatFastEditResult(results, filePath) {
+  const successCount = results.filter((r) => r.success).length;
+  const failCount = results.filter((r) => !r.success).length;
+  if (failCount === 0) {
+    return `\u26A1 Fast edit: ${filePath} \u2014 ${successCount} edits applied.`;
+  }
+  const lines = [`\u26A1 Fast edit: ${filePath}`];
+  for (let i = 0; i < results.length; i++) {
+    const r = results[i];
+    if (r.success) {
+      lines.push(`  [${i + 1}] \u2705 ${r.matched}x matched, ${r.replaced}x replaced`);
+    } else {
+      lines.push(`  [${i + 1}] \u274C ${r.error}`);
+    }
+  }
+  return lines.join("\n");
+}
 function generateEditId() {
   return `edit-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
 }
 async function handlePreciseDiffEditor(params) {
-  const { filePath, edits, dryRun = false, action, scope } = params;
+  const { filePath, edits, safe = true, dryRun = false, action, scope } = params;
   if (action === "rollback") {
     return handleRollbackEdit({ filePath, version: params.version, scope: scope || "file", editId: params.editId });
   }
@@ -469,11 +813,13 @@ async function handlePreciseDiffEditor(params) {
     return `Error: ${validation.error.message}`;
   }
   const resolvedPath = validation.resolvedPath;
-  const cbResult = circuitBreaker.check("precise_diff_editor", { filePath });
-  if (!cbResult.allowed) {
-    return `\u26A0\uFE0F ${cbResult.reason}
+  if (safe) {
+    const cbResult = circuitBreaker.check("precise_diff_editor", { filePath });
+    if (!cbResult.allowed) {
+      return `\u26A0\uFE0F ${cbResult.reason}
 
 Try reading the file first with smart_file_picker to verify current content.`;
+    }
   }
   if (!fs3.existsSync(resolvedPath)) {
     return `Error: File not found: "${filePath}".
@@ -485,6 +831,22 @@ Use batch_file_writer to create a new file.`;
     const results = [];
     for (let i = 0; i < edits.length; i++) {
       const edit = edits[i];
+      if (!safe) {
+        const result2 = fastApplyEdit(currentContent, edit);
+        if (result2.success) {
+          fs3.writeFileSync(resolvedPath, result2.details, "utf-8");
+          currentContent = result2.details;
+          sessionMemory.recordToolCall("precise_diff_editor", {
+            filePath,
+            editIndex: i,
+            fast: true,
+            success: true
+          });
+          sessionMemory.addModifiedFile(filePath);
+        }
+        results.push(result2);
+        continue;
+      }
       const result = applyEdit(currentContent, edit, resolvedPath, i, dryRun);
       if (result.success) {
         if (!dryRun) {
@@ -510,6 +872,9 @@ Use batch_file_writer to create a new file.`;
     if (dryRun) {
       return formatDryRunResult(results, filePath, originalContent);
     }
+    if (!safe) {
+      return formatFastEditResult(results, filePath);
+    }
     return formatDiffResult(results, filePath);
   } catch (err) {
     return `Error editing file "${filePath}": ${err instanceof Error ? err.message : String(err)}`;
@@ -889,10 +1254,10 @@ File "${filePath}" restored from backup: "${relBackupPath}".`;
 }
 async function handleCommitRollback(filePath, version) {
   try {
-    const { execSync: execSync10 } = await import("child_process");
+    const { execSync: execSync13 } = await import("child_process");
     const root = getProjectRoot();
     if (version === "list") {
-      const log = execSync10("git log --oneline -20", { cwd: root, encoding: "utf-8" });
+      const log = execSync13("git log --oneline -20", { cwd: root, encoding: "utf-8" });
       const lines = log.trim().split("\n").map((l) => `  ${l}`).join("\n");
       return [
         `\u{1F4CB} **Recent Commits:**`,
@@ -902,7 +1267,7 @@ async function handleCommitRollback(filePath, version) {
         `\u{1F4A1} Use { action: "rollback", scope: "commit", version: <N> } to restore a specific commit.`
       ].join("\n");
     }
-    const status = execSync10("git status --porcelain", { cwd: root, encoding: "utf-8" }).trim();
+    const status = execSync13("git status --porcelain", { cwd: root, encoding: "utf-8" }).trim();
     if (status) {
       return [
         `\u26A0\uFE0F **Uncommitted changes detected.**`,
@@ -923,10 +1288,10 @@ async function handleCommitRollback(filePath, version) {
       target = "HEAD~1";
     }
     if (filePath) {
-      execSync10(`git checkout ${target} -- "${filePath}"`, { cwd: root, encoding: "utf-8" });
+      execSync13(`git checkout ${target} -- "${filePath}"`, { cwd: root, encoding: "utf-8" });
       return `\u2705 **Commit Rollback** \u2014 File "${filePath}" restored from ${target}.`;
     } else {
-      execSync10(`git checkout ${target}`, { cwd: root, encoding: "utf-8" });
+      execSync13(`git checkout ${target}`, { cwd: root, encoding: "utf-8" });
       return `\u2705 **Commit Rollback** \u2014 Project restored to ${target}.`;
     }
   } catch (err) {
@@ -1202,13 +1567,419 @@ function formatBatchResult(results, totalRequested) {
   return lines.join("\n");
 }
 
-// src/tools/safeTerminalExec.ts
-import fs6 from "fs";
+// src/tools/kumaFind.ts
+import fg2 from "fast-glob";
+import path5 from "path";
+import { execSync as execSync2 } from "child_process";
+var IGNORE_PATTERNS2 = [
+  "**/node_modules/**",
+  "**/.next/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.git/**",
+  "**/.cache/**",
+  "**/.kuma/backups/**",
+  "**/coverage/**",
+  "**/.nyc_output/**"
+];
+var CACHE_TTL_MS2 = 3e4;
+var findCache = /* @__PURE__ */ new Map();
+var rgAvailable2 = null;
+function isRipgrepAvailable2() {
+  if (process.env.KUMA_DISABLE_RG === "1" || process.env.KUMA_DISABLE_RG === "true") {
+    return false;
+  }
+  if (rgAvailable2 !== null) return rgAvailable2;
+  try {
+    execSync2("rg --version", { stdio: "ignore", timeout: 2e3 });
+    rgAvailable2 = true;
+  } catch {
+    rgAvailable2 = false;
+  }
+  return rgAvailable2;
+}
+function quotePath2(p) {
+  return `"${p.replace(/"/g, '\\"')}"`;
+}
+async function handleKumaFind(params) {
+  const {
+    name = "*",
+    path: pathPattern,
+    extensions,
+    targetFolder,
+    maxResults = 30,
+    type = "file",
+    outputMode = "rich",
+    compact = false
+  } = params;
+  const recursiveName = !pathPattern && !targetFolder && !name.startsWith("**/") ? `**/${name}` : name;
+  const cacheKey = `${recursiveName}:${pathPattern ?? ""}:${targetFolder ?? ""}:${type}:${maxResults}:${extensions ? extensions.join(",") : ""}`;
+  const cached = findCache.get(cacheKey);
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS2) {
+    return cached.results;
+  }
+  const projectRoot = getProjectRoot();
+  let entries;
+  if (isRipgrepAvailable2() && type !== "dir") {
+    entries = await tryRipgrepFind({
+      name: recursiveName,
+      pathPattern,
+      targetFolder,
+      extensions,
+      maxResults,
+      projectRoot
+    });
+  } else {
+    entries = await fastGlobFind({
+      name: recursiveName,
+      pathPattern,
+      targetFolder,
+      extensions,
+      maxResults,
+      type,
+      projectRoot
+    });
+  }
+  if (entries.length === 0) {
+    const noResult = compact ? `0:${name}` : `\u{1F50D} No files found matching "${name}"${targetFolder ? ` in ${targetFolder}` : ""}.`;
+    findCache.set(cacheKey, { results: noResult, timestamp: Date.now() });
+    return noResult;
+  }
+  sessionMemory.recordToolCall("kuma_find", {
+    name,
+    matchCount: entries.length,
+    engine: rgAvailable2 ? "ripgrep" : "fast-glob"
+  });
+  let result;
+  if (outputMode === "json") {
+    result = JSON.stringify(entries);
+  } else if (compact || outputMode === "raw") {
+    result = entries.join("\n");
+  } else {
+    const lines = [
+      `\u{1F50D} Find: "${name}"`,
+      `\u{1F4C1} ${entries.length} files found${targetFolder ? ` in ${targetFolder}` : ""}`,
+      "",
+      ...entries.map((e, i) => `[${i + 1}] \u{1F4C4} ${e}`)
+    ];
+    result = lines.join("\n");
+  }
+  findCache.set(cacheKey, { results: result, timestamp: Date.now() });
+  return result;
+}
+async function tryRipgrepFind(opts) {
+  const { name, pathPattern, targetFolder, extensions, maxResults, projectRoot } = opts;
+  const args = ["rg", "--files", "--no-ignore-vcs", "--color", "never"];
+  for (const ignore of IGNORE_PATTERNS2) {
+    const glob = ignore.replace(/^\*\*\//, "");
+    args.push("-g", `!${glob}`);
+  }
+  args.push("-g", name);
+  if (pathPattern) {
+    args.push("-g", pathPattern);
+  }
+  if (extensions && extensions.length > 0) {
+    for (const ext of extensions) {
+      const clean = ext.startsWith(".") ? ext : `.${ext}`;
+      args.push("-g", `*${clean}`);
+    }
+  }
+  const searchDir = targetFolder ? path5.join(projectRoot, targetFolder) : projectRoot;
+  args.push(quotePath2(searchDir));
+  try {
+    const output = execSync2(args.join(" "), {
+      cwd: projectRoot,
+      maxBuffer: 5 * 1024 * 1024,
+      timeout: 1e4,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (!output || output.trim().length === 0) return [];
+    let files = output.trim().split("\n").map((f) => f.trim()).filter(Boolean);
+    if (targetFolder) {
+      const prefix = targetFolder.replace(/\/+$/, "") + "/";
+      files = files.map((f) => prefix + f);
+    }
+    return files.slice(0, maxResults);
+  } catch (err) {
+    return [];
+  }
+}
+async function fastGlobFind(opts) {
+  const { name, pathPattern, targetFolder, extensions, maxResults, type, projectRoot } = opts;
+  const globParts = [];
+  if (pathPattern) {
+    globParts.push(pathPattern.replace(/^\/+/, "").replace(/\/+$/, ""));
+  } else if (targetFolder) {
+    globParts.push(targetFolder.replace(/^\/+/, "").replace(/\/+$/, ""));
+  }
+  globParts.push(name);
+  const searchPattern = globParts.join("/");
+  try {
+    let entries = await fg2(searchPattern, {
+      cwd: projectRoot,
+      ignore: IGNORE_PATTERNS2,
+      onlyFiles: type === "file",
+      onlyDirectories: type === "dir",
+      absolute: false,
+      deep: 20,
+      dot: false
+    });
+    if (extensions && extensions.length > 0 && type !== "dir") {
+      const normalizedExts = extensions.map(
+        (e) => e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`
+      );
+      entries = entries.filter((entry) => {
+        const ext = path5.extname(entry).toLowerCase();
+        return normalizedExts.includes(ext);
+      });
+    }
+    return entries.slice(0, maxResults);
+  } catch {
+    return [];
+  }
+}
+
+// src/tools/kumaStats.ts
+import fs5 from "fs";
 import path6 from "path";
+import { execSync as execSync3 } from "child_process";
+import fg3 from "fast-glob";
+var LANG_MAP = {
+  ts: "TypeScript",
+  tsx: "TypeScript React",
+  js: "JavaScript",
+  jsx: "JavaScript React",
+  py: "Python",
+  go: "Go",
+  rs: "Rust",
+  java: "Java",
+  kt: "Kotlin",
+  rb: "Ruby",
+  php: "PHP",
+  cs: "C#",
+  swift: "Swift",
+  c: "C",
+  cpp: "C++",
+  h: "C/C++ Header",
+  css: "CSS",
+  scss: "SCSS",
+  less: "Less",
+  html: "HTML",
+  json: "JSON",
+  yaml: "YAML",
+  yml: "YAML",
+  md: "Markdown",
+  sql: "SQL",
+  graphql: "GraphQL",
+  prisma: "Prisma",
+  toml: "TOML",
+  xml: "XML",
+  svg: "SVG",
+  sh: "Shell",
+  bash: "Shell",
+  dockerfile: "Dockerfile"
+};
+async function handleKumaStats(params) {
+  const {
+    filePath,
+    target = "project",
+    outputMode = "rich",
+    compact = false,
+    extensions
+  } = params;
+  if (target === "file" && filePath) {
+    return await statsSingleFile(filePath, { outputMode, compact });
+  }
+  if (target === "dir" && filePath) {
+    return await statsDirectory(filePath, { outputMode, compact, extensions });
+  }
+  return await statsProject({ outputMode, compact, extensions });
+}
+async function statsSingleFile(filePath, opts) {
+  const { outputMode, compact } = opts;
+  const validation = validateFilePath(filePath);
+  if (!validation.valid) {
+    return compact ? `ERR:${filePath}` : `Error: ${validation.error.message}`;
+  }
+  const resolvedPath = validation.resolvedPath;
+  if (!fs5.existsSync(resolvedPath)) {
+    return compact ? `ERR:not found` : `Error: File not found: ${filePath}`;
+  }
+  const stat = fs5.statSync(resolvedPath);
+  const isDir = stat.isDirectory();
+  if (isDir) {
+    return statsDirectory(filePath, { outputMode, compact });
+  }
+  const content = fs5.readFileSync(resolvedPath, "utf-8");
+  const lines = content.split("\n");
+  const ext = path6.extname(resolvedPath).replace(".", "").toLowerCase();
+  const lang = LANG_MAP[ext] || ext.toUpperCase() || "Unknown";
+  const totalBytes = stat.size;
+  const nonEmpty = lines.filter((l) => l.trim().length > 0).length;
+  if (outputMode === "json") {
+    return JSON.stringify({
+      file: filePath,
+      lines: lines.length,
+      nonEmpty,
+      size: totalBytes,
+      sizeHuman: formatBytes(totalBytes),
+      language: lang
+    });
+  }
+  if (compact || outputMode === "raw") {
+    return `${filePath}	${lines.length}	${formatBytes(totalBytes)}	${lang}`;
+  }
+  return [
+    `\u{1F4CA} Stats: ${filePath}`,
+    `\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`,
+    `  Language:    ${lang}`,
+    `  Lines:       ${lines.length}`,
+    `  Non-empty:   ${nonEmpty}`,
+    `  Size:        ${formatBytes(totalBytes)}`
+  ].join("\n");
+}
+async function statsDirectory(dirPath, opts) {
+  const { outputMode, compact, extensions } = opts;
+  const projectRoot = getProjectRoot();
+  const resolved = path6.isAbsolute(dirPath) ? dirPath : path6.join(projectRoot, dirPath);
+  if (!fs5.existsSync(resolved)) {
+    return compact ? `ERR:not found ${dirPath}` : `Error: Directory not found: ${dirPath}`;
+  }
+  let totalFiles = 0;
+  let totalLines = 0;
+  let totalBytes = 0;
+  const langCounts = {};
+  const entries = await fg3("**/*", {
+    cwd: resolved,
+    onlyFiles: true,
+    ignore: [
+      "**/node_modules/**",
+      "**/.git/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.next/**",
+      "**/coverage/**",
+      "**/*.map"
+    ],
+    deep: 10,
+    dot: false
+  });
+  for (const entry of entries) {
+    const ext = path6.extname(entry).replace(".", "").toLowerCase();
+    if (extensions && extensions.length > 0) {
+      const normalizedExts = extensions.map(
+        (e) => e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`
+      );
+      if (!normalizedExts.includes(`.${ext}`)) continue;
+    }
+    totalFiles++;
+    const fullPath = path6.join(resolved, entry);
+    try {
+      const stat = fs5.statSync(fullPath);
+      if (stat.size > 1e6) {
+        totalBytes += stat.size;
+        continue;
+      }
+      const content = fs5.readFileSync(fullPath, "utf-8");
+      const lineCount = content.split("\n").length;
+      totalLines += lineCount;
+      totalBytes += stat.size;
+      const lang = LANG_MAP[ext] || ext.toUpperCase() || "Other";
+      if (!langCounts[lang]) {
+        langCounts[lang] = { files: 0, lines: 0 };
+      }
+      langCounts[lang].files++;
+      langCounts[lang].lines += lineCount;
+    } catch {
+      try {
+        const fallbackStat = fs5.statSync(fullPath);
+        totalBytes += fallbackStat.size;
+      } catch {
+        totalBytes += 0;
+      }
+    }
+  }
+  sessionMemory.recordToolCall("kuma_stats", {
+    target: dirPath,
+    totalFiles,
+    totalLines
+  });
+  if (outputMode === "json") {
+    return JSON.stringify({
+      directory: dirPath,
+      totalFiles,
+      totalLines,
+      totalBytes,
+      sizeHuman: formatBytes(totalBytes),
+      languages: langCounts
+    });
+  }
+  if (compact || outputMode === "raw") {
+    const langs = Object.entries(langCounts).sort((a, b) => b[1].lines - a[1].lines).map(([name, counts]) => `${name}	${counts.files}	${counts.lines}`).join("\n");
+    return `${dirPath}	${totalFiles}	${totalLines}	${formatBytes(totalBytes)}
+${langs}`;
+  }
+  const langSummary = Object.entries(langCounts).sort((a, b) => b[1].lines - a[1].lines).slice(0, 10).map(
+    ([name, counts]) => `  ${name.padEnd(20)} ${String(counts.files).padStart(5)} files  ${String(counts.lines).padStart(8)} lines`
+  ).join("\n");
+  return [
+    `\u{1F4CA} Directory Stats: ${dirPath}`,
+    `\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`,
+    `  Total files:   ${totalFiles}`,
+    `  Total lines:   ${totalLines}`,
+    `  Total size:    ${formatBytes(totalBytes)}`,
+    ``,
+    `Top Languages:`,
+    langSummary
+  ].join("\n");
+}
+async function statsProject(opts) {
+  const projectRoot = getProjectRoot();
+  const projectName = path6.basename(projectRoot);
+  const projectStats = await statsDirectory(projectRoot, opts);
+  let branch = "unknown";
+  let lastCommit = "unknown";
+  try {
+    branch = execSync3("git rev-parse --abbrev-ref HEAD 2>/dev/null || echo unknown", {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      timeout: 2e3
+    }).trim();
+    lastCommit = execSync3('git log -1 --format="%h %s" 2>/dev/null || echo unknown', {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      timeout: 2e3
+    }).trim();
+  } catch {
+  }
+  if (opts.outputMode === "raw" || opts.compact) {
+    return `Project: ${projectName}	Branch: ${branch}	${lastCommit}
+${projectStats}`;
+  }
+  return [
+    `\u{1F4CA} Project: ${projectName}`,
+    `\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501`,
+    `  Branch:      ${branch}`,
+    `  Last commit: ${lastCommit}`,
+    ``,
+    projectStats
+  ].join("\n");
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  return `${(bytes / Math.pow(1024, i)).toFixed(1)} ${units[i]}`;
+}
+
+// src/tools/safeTerminalExec.ts
+import fs7 from "fs";
+import path8 from "path";
 
 // src/utils/conventionsDetector.ts
-import fs5 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path7 from "path";
 var cachedConventions = null;
 async function detectConventions(forceRescan = false) {
   if (cachedConventions && !forceRescan) {
@@ -1239,7 +2010,7 @@ async function detectConventions(forceRescan = false) {
   return conventions;
 }
 function detectFramework(root) {
-  const pkg = readJsonSafe(path5.join(root, "package.json"));
+  const pkg = readJsonSafe(path7.join(root, "package.json"));
   if (pkg) {
     const pkgDeps = pkg.dependencies ?? {};
     const pkgDevDeps = pkg.devDependencies ?? {};
@@ -1284,11 +2055,11 @@ function detectFramework(root) {
 function scanSubProjectFrameworks(root) {
   const frameworks = [];
   try {
-    const entries = fs5.readdirSync(root, { withFileTypes: true });
+    const entries = fs6.readdirSync(root, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const subDir = path5.join(root, entry.name);
-      const subPkg = readJsonSafe(path5.join(subDir, "package.json"));
+      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");
@@ -1307,7 +2078,7 @@ function scanSubProjectFrameworks(root) {
   return frameworks;
 }
 function detectProjectType(root) {
-  const pkg = readJsonSafe(path5.join(root, "package.json"));
+  const pkg = readJsonSafe(path7.join(root, "package.json"));
   if (pkg) {
     const pkgDeps = pkg.dependencies ?? {};
     const pkgDevDeps = pkg.devDependencies ?? {};
@@ -1331,8 +2102,8 @@ function detectProjectType(root) {
 }
 function detectWorkspaces(root) {
   const results = [];
-  const pkg = readJsonSafe(path5.join(root, "package.json"));
-  const pnpmWorkspace = readYamlLite(path5.join(root, "pnpm-workspace.yaml"));
+  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)) {
@@ -1352,22 +2123,22 @@ function detectWorkspaces(root) {
   for (const pattern of patterns) {
     const match = pattern.match(/^([^*]+)\/\*$/);
     if (!match) continue;
-    const dir = path5.join(root, match[1]);
-    if (!fs5.existsSync(dir)) continue;
+    const dir = path7.join(root, match[1]);
+    if (!fs6.existsSync(dir)) continue;
     let entries = [];
     try {
-      entries = fs5.readdirSync(dir, { withFileTypes: true });
+      entries = fs6.readdirSync(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const pkgPath = path5.join(dir, entry.name, "package.json");
+      const pkgPath = path7.join(dir, entry.name, "package.json");
       const subPkg = readJsonSafe(pkgPath);
       if (!subPkg) continue;
-      const workspacePath = path5.join(dir, entry.name);
+      const workspacePath = path7.join(dir, entry.name);
       results.push({
-        path: path5.relative(root, workspacePath),
+        path: path7.relative(root, workspacePath),
         name: subPkg.name ?? entry.name,
         framework: detectFramework(workspacePath),
         packageManager: detectPackageManagerForDir(workspacePath)
@@ -1383,8 +2154,8 @@ function detectWorkspaces(root) {
 }
 function readYamlLite(filePath) {
   try {
-    if (!fs5.existsSync(filePath)) return null;
-    const text = fs5.readFileSync(filePath, "utf-8");
+    if (!fs6.existsSync(filePath)) return null;
+    const text = fs6.readFileSync(filePath, "utf-8");
     const packages = [];
     let inPackages = false;
     for (const rawLine of text.split("\n")) {
@@ -1405,7 +2176,7 @@ function readYamlLite(filePath) {
   }
 }
 function detectTestRunner(root) {
-  const pkg = readJsonSafe(path5.join(root, "package.json"));
+  const pkg = readJsonSafe(path7.join(root, "package.json"));
   if (!pkg) return "unknown";
   const pkgDeps2 = pkg.dependencies ?? {};
   const pkgDevDeps2 = pkg.devDependencies ?? {};
@@ -1426,7 +2197,7 @@ function detectTestRunner(root) {
   return "unknown";
 }
 function detectStyling(root) {
-  const pkg = readJsonSafe(path5.join(root, "package.json"));
+  const pkg = readJsonSafe(path7.join(root, "package.json"));
   if (!pkg) return "unknown";
   const pkgDeps3 = pkg.dependencies ?? {};
   const pkgDevDeps3 = pkg.devDependencies ?? {};
@@ -1439,22 +2210,22 @@ function detectStyling(root) {
   if (deps.less) return "Less";
   if (deps["@vanilla-extract/css"]) return "Vanilla Extract";
   if (deps.cssmodules || hasCSSModules(root)) return "CSS Modules";
-  const srcDir = path5.join(root, "src");
-  if (fs5.existsSync(srcDir)) {
+  const srcDir = path7.join(root, "src");
+  if (fs6.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(path5.join(root, "tsconfig.json"));
+  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(path5.join(root, "jsconfig.json"));
+  const jsconfig = readJsonSafe(path7.join(root, "jsconfig.json"));
   const jsconfigPaths = jsconfig?.compilerOptions;
   if (jsconfigPaths?.paths) {
     const paths = jsconfigPaths.paths;
@@ -1465,15 +2236,15 @@ function detectImportAlias(root) {
 }
 function detectLintRules(root) {
   const rules = [];
-  if (fs5.existsSync(path5.join(root, ".eslintrc"))) rules.push("ESLint (.eslintrc)");
-  if (fs5.existsSync(path5.join(root, ".eslintrc.js"))) rules.push("ESLint (.eslintrc.js)");
-  if (fs5.existsSync(path5.join(root, ".eslintrc.json"))) rules.push("ESLint (.eslintrc.json)");
-  if (fs5.existsSync(path5.join(root, "eslint.config.js"))) rules.push("ESLint (flat config)");
-  if (fs5.existsSync(path5.join(root, ".prettierrc"))) rules.push("Prettier");
-  if (fs5.existsSync(path5.join(root, ".prettierrc.json"))) rules.push("Prettier");
-  if (fs5.existsSync(path5.join(root, ".prettierrc.js"))) rules.push("Prettier");
-  if (fs5.existsSync(path5.join(root, ".stylelintrc"))) rules.push("StyleLint");
-  if (fs5.existsSync(path5.join(root, ".stylelintrc.json"))) rules.push("StyleLint");
+  if (fs6.existsSync(path7.join(root, ".eslintrc"))) rules.push("ESLint (.eslintrc)");
+  if (fs6.existsSync(path7.join(root, ".eslintrc.js"))) rules.push("ESLint (.eslintrc.js)");
+  if (fs6.existsSync(path7.join(root, ".eslintrc.json"))) rules.push("ESLint (.eslintrc.json)");
+  if (fs6.existsSync(path7.join(root, "eslint.config.js"))) rules.push("ESLint (flat config)");
+  if (fs6.existsSync(path7.join(root, ".prettierrc"))) rules.push("Prettier");
+  if (fs6.existsSync(path7.join(root, ".prettierrc.json"))) rules.push("Prettier");
+  if (fs6.existsSync(path7.join(root, ".prettierrc.js"))) rules.push("Prettier");
+  if (fs6.existsSync(path7.join(root, ".stylelintrc"))) rules.push("StyleLint");
+  if (fs6.existsSync(path7.join(root, ".stylelintrc.json"))) rules.push("StyleLint");
   return rules;
 }
 function detectPackageManager() {
@@ -1482,26 +2253,26 @@ function detectPackageManager() {
 }
 function detectPackageManagerForDir(dir) {
   const root = getProjectRoot();
-  let currentDir = path5.resolve(dir);
+  let currentDir = path7.resolve(dir);
   while (currentDir.startsWith(root)) {
-    if (fs5.existsSync(path5.join(currentDir, "pnpm-lock.yaml"))) return "pnpm";
-    if (fs5.existsSync(path5.join(currentDir, "yarn.lock"))) return "yarn";
-    if (fs5.existsSync(path5.join(currentDir, "package-lock.json"))) return "npm";
-    if (fs5.existsSync(path5.join(currentDir, "bun.lockb"))) return "bun";
+    if (fs6.existsSync(path7.join(currentDir, "pnpm-lock.yaml"))) return "pnpm";
+    if (fs6.existsSync(path7.join(currentDir, "yarn.lock"))) return "yarn";
+    if (fs6.existsSync(path7.join(currentDir, "package-lock.json"))) return "npm";
+    if (fs6.existsSync(path7.join(currentDir, "bun.lockb"))) return "bun";
     if (currentDir === root) break;
-    currentDir = path5.dirname(currentDir);
+    currentDir = path7.dirname(currentDir);
   }
   return "npm";
 }
 function detectModuleSystem(root) {
-  const pkg = readJsonSafe(path5.join(root, "package.json"));
+  const pkg = readJsonSafe(path7.join(root, "package.json"));
   if (pkg?.type === "module") return "esm";
-  const srcDir = path5.join(root, "src");
-  if (fs5.existsSync(srcDir)) {
+  const srcDir = path7.join(root, "src");
+  if (fs6.existsSync(srcDir)) {
     const tsFiles = findFiles(srcDir, [".ts", ".tsx", ".js", ".jsx", ".mjs"]);
     for (const file of tsFiles.slice(0, 20)) {
       try {
-        const content = fs5.readFileSync(file, "utf-8");
+        const content = fs6.readFileSync(file, "utf-8");
         if (content.includes("import ") || content.includes("export ")) return "esm";
       } catch {
         continue;
@@ -1511,22 +2282,22 @@ function detectModuleSystem(root) {
   return "cjs";
 }
 function detectLanguage(root) {
-  if (fs5.existsSync(path5.join(root, "go.mod"))) return "go";
-  if (fs5.existsSync(path5.join(root, "Cargo.toml"))) return "rust";
-  if (fs5.existsSync(path5.join(root, "composer.json"))) return "php";
-  if (fs5.existsSync(path5.join(root, "pyproject.toml")) || fs5.existsSync(path5.join(root, "requirements.txt")) || fs5.existsSync(path5.join(root, "setup.py"))) return "python";
-  if (fs5.existsSync(path5.join(root, "Gemfile"))) return "ruby";
-  if (fs5.existsSync(path5.join(root, "pom.xml"))) return "java";
-  if (fs5.existsSync(path5.join(root, "build.gradle")) || fs5.existsSync(path5.join(root, "build.gradle.kts"))) return "kotlin";
-  if (fs5.existsSync(path5.join(root, "Package.swift"))) return "swift";
+  if (fs6.existsSync(path7.join(root, "go.mod"))) return "go";
+  if (fs6.existsSync(path7.join(root, "Cargo.toml"))) return "rust";
+  if (fs6.existsSync(path7.join(root, "composer.json"))) return "php";
+  if (fs6.existsSync(path7.join(root, "pyproject.toml")) || fs6.existsSync(path7.join(root, "requirements.txt")) || fs6.existsSync(path7.join(root, "setup.py"))) return "python";
+  if (fs6.existsSync(path7.join(root, "Gemfile"))) return "ruby";
+  if (fs6.existsSync(path7.join(root, "pom.xml"))) return "java";
+  if (fs6.existsSync(path7.join(root, "build.gradle")) || fs6.existsSync(path7.join(root, "build.gradle.kts"))) return "kotlin";
+  if (fs6.existsSync(path7.join(root, "Package.swift"))) return "swift";
   try {
-    const entries = fs5.readdirSync(root);
+    const entries = fs6.readdirSync(root);
     if (entries.some((e) => e.endsWith(".csproj"))) return "csharp";
   } catch {
   }
-  if (fs5.existsSync(path5.join(root, "tsconfig.json"))) return "typescript";
-  const srcDir = path5.join(root, "src");
-  if (fs5.existsSync(srcDir)) {
+  if (fs6.existsSync(path7.join(root, "tsconfig.json"))) return "typescript";
+  const srcDir = path7.join(root, "src");
+  if (fs6.existsSync(srcDir)) {
     const tsFiles = findFiles(srcDir, [".ts", ".tsx"]);
     if (tsFiles.length > 0) return "typescript";
     const jsFiles = findFiles(srcDir, [".js", ".jsx"]);
@@ -1545,7 +2316,7 @@ function detectMultiLanguageFramework(root, language) {
   switch (language) {
     case "go": {
       try {
-        const goMod = fs5.readFileSync(path5.join(root, "go.mod"), "utf-8");
+        const goMod = fs6.readFileSync(path7.join(root, "go.mod"), "utf-8");
         if (goMod.includes("github.com/gin-gonic/gin")) return "Gin";
         if (goMod.includes("github.com/labstack/echo")) return "Echo";
         if (goMod.includes("github.com/gofiber/fiber")) return "Fiber";
@@ -1559,7 +2330,7 @@ function detectMultiLanguageFramework(root, language) {
     }
     case "php": {
       try {
-        const composer = JSON.parse(fs5.readFileSync(path5.join(root, "composer.json"), "utf-8"));
+        const composer = JSON.parse(fs6.readFileSync(path7.join(root, "composer.json"), "utf-8"));
         const req = composer.require ?? {};
         const reqDev = composer["require-dev"] ?? {};
         const deps = { ...req, ...reqDev };
@@ -1576,14 +2347,14 @@ function detectMultiLanguageFramework(root, language) {
     }
     case "python": {
       try {
-        if (fs5.existsSync(path5.join(root, "pyproject.toml"))) {
-          const content = fs5.readFileSync(path5.join(root, "pyproject.toml"), "utf-8");
+        if (fs6.existsSync(path7.join(root, "pyproject.toml"))) {
+          const content = fs6.readFileSync(path7.join(root, "pyproject.toml"), "utf-8");
           if (content.includes("django")) return "Django";
           if (content.includes("flask")) return "Flask";
           if (content.includes("fastapi")) return "FastAPI";
         }
-        if (fs5.existsSync(path5.join(root, "requirements.txt"))) {
-          const content = fs5.readFileSync(path5.join(root, "requirements.txt"), "utf-8");
+        if (fs6.existsSync(path7.join(root, "requirements.txt"))) {
+          const content = fs6.readFileSync(path7.join(root, "requirements.txt"), "utf-8");
           if (content.includes("django")) return "Django";
           if (content.includes("flask")) return "Flask";
           if (content.includes("fastapi")) return "FastAPI";
@@ -1596,7 +2367,7 @@ function detectMultiLanguageFramework(root, language) {
     }
     case "rust": {
       try {
-        const cargo = fs5.readFileSync(path5.join(root, "Cargo.toml"), "utf-8");
+        const cargo = fs6.readFileSync(path7.join(root, "Cargo.toml"), "utf-8");
         if (cargo.includes("axum")) return "Axum";
         if (cargo.includes("actix-web")) return "Actix Web";
         if (cargo.includes("rocket")) return "Rocket";
@@ -1610,7 +2381,7 @@ function detectMultiLanguageFramework(root, language) {
     }
     case "java": {
       try {
-        const content = fs5.readFileSync(path5.join(root, "pom.xml"), "utf-8");
+        const content = fs6.readFileSync(path7.join(root, "pom.xml"), "utf-8");
         if (content.includes("spring-boot")) return "Spring Boot";
         if (content.includes("quarkus")) return "Quarkus";
         if (content.includes("micronaut")) return "Micronaut";
@@ -1618,7 +2389,7 @@ function detectMultiLanguageFramework(root, language) {
         if (content.includes("helidon")) return "Helidon";
       } catch {
         try {
-          const gradle = fs5.readFileSync(path5.join(root, "build.gradle"), "utf-8");
+          const gradle = fs6.readFileSync(path7.join(root, "build.gradle"), "utf-8");
           if (gradle.includes("spring")) return "Spring Boot";
           if (gradle.includes("quarkus")) return "Quarkus";
         } catch {
@@ -1628,7 +2399,7 @@ function detectMultiLanguageFramework(root, language) {
     }
     case "kotlin": {
       try {
-        const gradle = fs5.readFileSync(path5.join(root, "build.gradle.kts"), "utf-8");
+        const gradle = fs6.readFileSync(path7.join(root, "build.gradle.kts"), "utf-8");
         if (gradle.includes("spring")) return "Spring Boot (Kotlin)";
         if (gradle.includes("ktor")) return "Ktor";
       } catch {
@@ -1637,7 +2408,7 @@ function detectMultiLanguageFramework(root, language) {
     }
     case "ruby": {
       try {
-        const gemfile = fs5.readFileSync(path5.join(root, "Gemfile"), "utf-8");
+        const gemfile = fs6.readFileSync(path7.join(root, "Gemfile"), "utf-8");
         if (gemfile.includes("rails")) return "Ruby on Rails";
         if (gemfile.includes("sinatra")) return "Sinatra";
         if (gemfile.includes("hanami")) return "Hanami";
@@ -1648,10 +2419,10 @@ function detectMultiLanguageFramework(root, language) {
     }
     case "csharp": {
       try {
-        const entries = fs5.readdirSync(root);
+        const entries = fs6.readdirSync(root);
         const csproj = entries.find((e) => e.endsWith(".csproj"));
         if (csproj) {
-          const content = fs5.readFileSync(path5.join(root, csproj), "utf-8");
+          const content = fs6.readFileSync(path7.join(root, csproj), "utf-8");
           if (content.includes("Microsoft.AspNetCore")) return "ASP.NET Core";
           if (content.includes("Microsoft.Maui")) return ".NET MAUI";
           if (content.includes("Serilog")) return "Serilog";
@@ -1662,7 +2433,7 @@ function detectMultiLanguageFramework(root, language) {
     }
     case "swift": {
       try {
-        const content = fs5.readFileSync(path5.join(root, "Package.swift"), "utf-8");
+        const content = fs6.readFileSync(path7.join(root, "Package.swift"), "utf-8");
         if (content.includes("vapor")) return "Vapor";
         if (content.includes("swift-nio")) return "SwiftNIO";
         if (content.includes("perfect")) return "Perfect";
@@ -1677,7 +2448,7 @@ function detectMultiLanguageFramework(root, language) {
 }
 function detectFeatures(root) {
   const features = [];
-  const pkg = readJsonSafe(path5.join(root, "package.json"));
+  const pkg = readJsonSafe(path7.join(root, "package.json"));
   if (!pkg) return features;
   const pkgDeps4 = pkg.dependencies ?? {};
   const pkgDevDeps4 = pkg.devDependencies ?? {};
@@ -1701,25 +2472,25 @@ function detectFeatures(root) {
 }
 function readJsonSafe(filePath) {
   try {
-    if (fs5.existsSync(filePath)) {
-      return JSON.parse(fs5.readFileSync(filePath, "utf-8"));
+    if (fs6.existsSync(filePath)) {
+      return JSON.parse(fs6.readFileSync(filePath, "utf-8"));
     }
   } catch {
   }
   return null;
 }
 function hasCSSModules(root) {
-  const srcDir = path5.join(root, "src");
-  if (!fs5.existsSync(srcDir)) return false;
+  const srcDir = path7.join(root, "src");
+  if (!fs6.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 = fs5.readdirSync(dir, { withFileTypes: true });
+    const entries = fs6.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path5.join(dir, entry.name);
+      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()) {
@@ -1910,7 +2681,7 @@ async function handleSafeTerminalExec(params) {
     const workspaces = conventions?.workspaces;
     const matched = workspaces?.find((w) => w.name === workspace || w.path === workspace);
     if (matched) {
-      workingDir = path6.resolve(projectRoot, matched.path);
+      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.
@@ -1918,13 +2689,13 @@ async function handleSafeTerminalExec(params) {
 Available workspaces: ${workspaces?.map((w) => `"${w.name}" (${w.path})`).join(", ") || "none detected"}`;
     }
   } else if (inputCwd) {
-    const resolved = path6.resolve(projectRoot, inputCwd);
-    const normalizedResolved = path6.normalize(resolved).toLowerCase();
-    const normalizedRoot = path6.normalize(projectRoot).toLowerCase();
+    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 (!fs6.existsSync(resolved)) {
+    if (!fs7.existsSync(resolved)) {
       return `\u26A0\uFE0F Directory "${inputCwd}" does not exist at "${resolved}".`;
     }
     workingDir = resolved;
@@ -2010,9 +2781,9 @@ function formatTimeoutResult(command, timeout) {
 }
 
 // src/agents/codeReviewer.ts
-import fs7 from "fs";
-import path7 from "path";
-import { execSync } from "child_process";
+import fs8 from "fs";
+import path9 from "path";
+import { execSync as execSync4 } from "child_process";
 var CODE_EXTENSIONS = [
   ".ts",
   ".tsx",
@@ -2042,7 +2813,7 @@ var CONFIG_EXTENSIONS = [
 function getGitChangedFiles() {
   try {
     const root = getProjectRoot();
-    const stdout = execSync("git status --porcelain", {
+    const stdout = execSync4("git status --porcelain", {
       cwd: root,
       encoding: "utf-8"
     });
@@ -2055,7 +2826,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);
@@ -2092,7 +2863,7 @@ Pass an explicit 'files' array to review specific files.`;
       continue;
     }
     const resolvedPath = validation.resolvedPath;
-    if (!fs7.existsSync(resolvedPath)) {
+    if (!fs8.existsSync(resolvedPath)) {
       allIssues.push({
         file: filePath,
         line: 0,
@@ -2104,7 +2875,7 @@ Pass an explicit 'files' array to review specific files.`;
       continue;
     }
     try {
-      const content = fs7.readFileSync(resolvedPath, "utf-8");
+      const content = fs8.readFileSync(resolvedPath, "utf-8");
       filesReviewed++;
       checkGeneral(filePath, content, allIssues);
       switch (focus) {
@@ -2202,12 +2973,12 @@ 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) {
   const lines = content.split("\n");
-  const ext = path7.extname(filePath).toLowerCase();
+  const ext = path9.extname(filePath).toLowerCase();
   if (content.length > 0 && !content.endsWith("\n")) {
     issues.push({
       file: filePath,
@@ -2409,7 +3180,7 @@ function stripJsonComments(text) {
   return cleaned.join("\n");
 }
 function checkConfigFile(filePath, content, issues) {
-  const ext = path7.extname(filePath).toLowerCase();
+  const ext = path9.extname(filePath).toLowerCase();
   const lines = content.split("\n");
   if (ext === ".json" || ext === ".jsonc") {
     checkJson(filePath, content, lines, issues);
@@ -2420,7 +3191,7 @@ function checkConfigFile(filePath, content, issues) {
   }
 }
 function checkJson(filePath, content, lines, issues) {
-  const ext = path7.extname(filePath).toLowerCase();
+  const ext = path9.extname(filePath).toLowerCase();
   const isJsonc = ext === ".jsonc";
   const contentToParse = isJsonc ? stripJsonComments(content) : content;
   try {
@@ -3146,10 +3917,10 @@ function formatConventionsOutput(conventions) {
 }
 
 // src/utils/gitUtils.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 function runGitCommand(command) {
   const root = getProjectRoot();
-  return execSync2(command, {
+  return execSync5(command, {
     cwd: root,
     encoding: "utf-8",
     maxBuffer: 2 * 1024 * 1024
@@ -3277,8 +4048,8 @@ async function handleGitDiff(params) {
 }
 
 // src/tools/projectStructure.ts
-import fs8 from "fs";
-import path8 from "path";
+import fs9 from "fs";
+import path10 from "path";
 var DEFAULT_IGNORE = [
   "node_modules",
   ".git",
@@ -3296,7 +4067,7 @@ var DEFAULT_IGNORE = [
   "*.log"
 ];
 var treeCache = /* @__PURE__ */ new Map();
-var CACHE_TTL_MS2 = 6e4;
+var CACHE_TTL_MS3 = 6e4;
 async function handleProjectStructure(params) {
   const {
     depth = 3,
@@ -3308,14 +4079,14 @@ async function handleProjectStructure(params) {
   const clampedDepth = Math.max(1, Math.min(depth, 6));
   const cacheKey = `${root}:${clampedDepth}:${folderOnly}:${includePattern ?? ""}:${excludePattern ?? ""}`;
   const cached = treeCache.get(cacheKey);
-  if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS2) {
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS3) {
     sessionMemory.recordToolCall("project_structure", { depth: clampedDepth, folderOnly, cached: true });
     return cached.result;
   }
   sessionMemory.recordToolCall("project_structure", { depth: clampedDepth, folderOnly });
   try {
     const tree = buildTree(root, root, clampedDepth, 0, folderOnly, includePattern, excludePattern);
-    const projectName = path8.basename(root);
+    const projectName = path10.basename(root);
     const lines = [
       "[Project Structure] - " + projectName,
       "Depth: " + clampedDepth + " | " + (folderOnly ? "Folders only" : "Files and folders"),
@@ -3338,7 +4109,7 @@ function buildTree(root, currentDir, maxDepth, currentDepth, folderOnly, include
   const lines = [];
   let entries = [];
   try {
-    entries = fs8.readdirSync(currentDir, { withFileTypes: true });
+    entries = fs9.readdirSync(currentDir, { withFileTypes: true });
   } catch {
     return lines;
   }
@@ -3347,12 +4118,12 @@ function buildTree(root, currentDir, maxDepth, currentDepth, folderOnly, include
     if (!a.isDirectory() && b.isDirectory()) return 1;
     return a.name.localeCompare(b.name);
   });
-  const relativeDir = path8.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 = path8.join(currentDir, entry.name);
-    const relativePath = path8.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;
     }
@@ -3363,11 +4134,11 @@ function buildTree(root, currentDir, maxDepth, currentDepth, folderOnly, include
       lines.push(prefix + "[D] " + entry.name + "/");
       let subEntries = [];
       try {
-        subEntries = fs8.readdirSync(fullPath, { withFileTypes: true });
+        subEntries = fs9.readdirSync(fullPath, { withFileTypes: true });
       } catch {
       }
       const hasVisibleContent = subEntries.some(
-        (e) => !shouldIgnore(e.name, path8.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);
@@ -3398,7 +4169,7 @@ function getPrefix(depth) {
 }
 function getFileSize(fullPath) {
   try {
-    const stat = fs8.statSync(fullPath);
+    const stat = fs9.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);
@@ -3409,8 +4180,8 @@ function getFileSize(fullPath) {
 }
 
 // src/tools/staticAnalysis.ts
-import fs9 from "fs";
-import path9 from "path";
+import fs10 from "fs";
+import path11 from "path";
 async function handleStaticAnalysis(params) {
   const { tool = "all", files, autoFix = false, timeout = 60 } = params;
   const root = getProjectRoot();
@@ -3503,11 +4274,11 @@ function detectAvailableTools(root) {
     "eslint.config.js",
     "eslint.config.mjs"
   ];
-  const hasEslintConfig = eslintConfigs.some((cfg) => fs9.existsSync(path9.join(root, cfg)));
+  const hasEslintConfig = eslintConfigs.some((cfg) => fs10.existsSync(path11.join(root, cfg)));
   if (hasEslintConfig && depNames.has("eslint")) {
     tools.push("eslint");
   }
-  if (fs9.existsSync(path9.join(root, "tsconfig.json")) && depNames.has("typescript")) {
+  if (fs10.existsSync(path11.join(root, "tsconfig.json")) && depNames.has("typescript")) {
     tools.push("tsc");
   }
   const prettierConfigs = [
@@ -3518,20 +4289,20 @@ function detectAvailableTools(root) {
     ".prettierrc.toml",
     "prettier.config.js"
   ];
-  const hasPrettierConfig = prettierConfigs.some((cfg) => fs9.existsSync(path9.join(root, cfg)));
+  const hasPrettierConfig = prettierConfigs.some((cfg) => fs10.existsSync(path11.join(root, cfg)));
   if (hasPrettierConfig && depNames.has("prettier")) {
     tools.push("prettier");
   }
-  if (fs9.existsSync(path9.join(root, "ruff.toml")) || fs9.existsSync(path9.join(root, ".ruff.toml"))) {
+  if (fs10.existsSync(path11.join(root, "ruff.toml")) || fs10.existsSync(path11.join(root, ".ruff.toml"))) {
     tools.push("ruff");
   }
   return tools;
 }
 function readPackageJson(root) {
   try {
-    const pkgPath = path9.join(root, "package.json");
-    if (fs9.existsSync(pkgPath)) {
-      return JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path11.join(root, "package.json");
+    if (fs10.existsSync(pkgPath)) {
+      return JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
     }
   } catch {
   }
@@ -3587,18 +4358,18 @@ function buildToolCommand(tool, files, autoFix) {
 }
 function detectPackageManagerPrefix() {
   const root = getProjectRoot();
-  if (fs9.existsSync(path9.join(root, "pnpm-lock.yaml"))) return "pnpm ";
-  if (fs9.existsSync(path9.join(root, "yarn.lock"))) return "yarn ";
+  if (fs10.existsSync(path11.join(root, "pnpm-lock.yaml"))) return "pnpm ";
+  if (fs10.existsSync(path11.join(root, "yarn.lock"))) return "yarn ";
   return "npx --no-install ";
 }
 function findBinary(root, binName) {
   const candidates = [
-    path9.join(root, "node_modules", ".bin", binName),
-    path9.join(root, "..", "node_modules", ".bin", binName)
+    path11.join(root, "node_modules", ".bin", binName),
+    path11.join(root, "..", "node_modules", ".bin", binName)
   ];
   for (const candidate of candidates) {
     try {
-      if (fs9.existsSync(candidate)) {
+      if (fs10.existsSync(candidate)) {
         return candidate;
       }
     } catch {
@@ -3622,7 +4393,7 @@ function parseToolOutput(tool, stdout, stderr, projectRoot) {
 }
 function resolveToolPath(filePath, projectRoot) {
   const trimmed = filePath.trim();
-  return path9.isAbsolute(trimmed) ? path9.relative(projectRoot, trimmed) : trimmed.replace(/^\.\//, "");
+  return path11.isAbsolute(trimmed) ? path11.relative(projectRoot, trimmed) : trimmed.replace(/^\.\//, "");
 }
 function parseEslintOutput(output, projectRoot) {
   const issues = [];
@@ -3805,7 +4576,7 @@ function formatToolNotAvailable(requested, available) {
 }
 
 // src/utils/kumaShared.ts
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 function getSessionStats(inputGoal) {
   const summary = sessionMemory.getSummary();
   const goal = inputGoal || summary.currentGoal || "";
@@ -3827,7 +4598,7 @@ function getSessionStats(inputGoal) {
 function getGitDiffStat(timeout = 3e3) {
   try {
     const root = getProjectRoot();
-    return execSync3("git diff --stat", {
+    return execSync6("git diff --stat", {
       cwd: root,
       encoding: "utf-8",
       timeout
@@ -4100,8 +4871,8 @@ function formatAnalytics(a) {
 }
 
 // src/engine/kumaHealthDashboard.ts
-import fs10 from "fs";
-import path10 from "path";
+import fs11 from "fs";
+import path12 from "path";
 function computeHealthDashboard() {
   const analytics = computeAnalytics();
   const root = getProjectRoot();
@@ -4109,27 +4880,27 @@ function computeHealthDashboard() {
   const gitChanges = gitStat ? gitStat.split("\n").filter((l) => l.includes("|")).length : 0;
   let backupCount = 0;
   try {
-    const bd = path10.join(root, ".kuma", "backups");
-    if (fs10.existsSync(bd)) backupCount = fs10.readdirSync(bd).filter((d) => /^\d+$/.test(d)).length;
+    const bd = path12.join(root, ".kuma", "backups");
+    if (fs11.existsSync(bd)) backupCount = fs11.readdirSync(bd).filter((d) => /^\d+$/.test(d)).length;
   } catch {
   }
   const dirFileCounts = /* @__PURE__ */ new Map();
   try {
     const walk = (dir, base) => {
       try {
-        for (const e of fs10.readdirSync(dir, { withFileTypes: true })) {
+        for (const e of fs11.readdirSync(dir, { withFileTypes: true })) {
           if (e.name.startsWith(".") || e.name === "node_modules") continue;
-          const full = path10.join(dir, e.name);
+          const full = path12.join(dir, e.name);
           if (e.isDirectory()) walk(full, base);
           else if (e.isFile() && /\.(ts|tsx|js|jsx)$/.test(e.name)) {
-            const rel = path10.dirname(path10.relative(base, full));
+            const rel = path12.dirname(path12.relative(base, full));
             dirFileCounts.set(rel, (dirFileCounts.get(rel) || 0) + 1);
           }
         }
       } catch {
       }
     };
-    walk(path10.join(root, "src"), root);
+    walk(path12.join(root, "src"), root);
   } catch {
   }
   const dirMap = /* @__PURE__ */ new Map();
@@ -4137,7 +4908,7 @@ function computeHealthDashboard() {
     if (call.toolName === "precise_diff_editor") {
       const fp = call.params?.filePath;
       if (fp) {
-        const dir = path10.dirname(fp) || ".";
+        const dir = path12.dirname(fp) || ".";
         const e = dirMap.get(dir) || { edits: 0, failures: 0 };
         e.edits++;
         if (call.params?.success === false) e.failures++;
@@ -4217,9 +4988,9 @@ function formatHealthDashboard(r) {
 }
 
 // src/guards/antiPatternDetector.ts
-import fs11 from "fs";
-import path11 from "path";
-import { execSync as execSync4 } from "child_process";
+import fs12 from "fs";
+import path13 from "path";
+import { execSync as execSync7 } from "child_process";
 var SCRIPT_PATCH_PATTERNS = [
   "writeFileSync",
   "writeFile",
@@ -4245,20 +5016,20 @@ function findPatchScripts(projectRoot) {
   const warnings = [];
   const recentFiles = scanRecentFiles(projectRoot);
   for (const file of recentFiles) {
-    const ext = path11.extname(file).toLowerCase();
+    const ext = path13.extname(file).toLowerCase();
     if (!SCRIPT_EXTENSIONS.includes(ext)) continue;
-    const relativePath = path11.relative(projectRoot, file);
+    const relativePath = path13.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: ${path13.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
@@ -4292,15 +5063,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(path13.join(projectRoot, entry.name));
         if (now - stat.mtimeMs < recentThreshold || now - stat.ctimeMs < recentThreshold) {
-          recent.push(path11.join(projectRoot, entry.name));
+          recent.push(path13.join(projectRoot, entry.name));
         }
       } catch {
         continue;
@@ -4313,7 +5084,7 @@ function scanRecentFiles(projectRoot) {
 function detectGitPatchScripts(projectRoot) {
   const warnings = [];
   try {
-    const statusStdout = execSync4("git status --porcelain", {
+    const statusStdout = execSync7("git status --porcelain", {
       cwd: projectRoot,
       encoding: "utf-8",
       timeout: 3e3
@@ -4324,14 +5095,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 = path13.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 = path13.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({
@@ -4346,7 +5117,7 @@ function detectGitPatchScripts(projectRoot) {
         }
       }
     }
-    const deletedStdout = execSync4("git diff --name-only --diff-filter=D HEAD", {
+    const deletedStdout = execSync7("git diff --name-only --diff-filter=D HEAD", {
       cwd: projectRoot,
       encoding: "utf-8",
       timeout: 3e3
@@ -4354,7 +5125,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 = path13.extname(file).toLowerCase();
         if (SCRIPT_EXTENSIONS.includes(ext)) {
           warnings.push({
             severity: "high",
@@ -4414,21 +5185,21 @@ function detectAllAntiPatterns() {
 }
 
 // src/engine/contextSnapshot.ts
-import fs12 from "fs";
-import path12 from "path";
-import { execSync as execSync5 } from "child_process";
+import fs13 from "fs";
+import path14 from "path";
+import { execSync as execSync8 } from "child_process";
 var SNAPSHOT_DIR = "context-snapshots";
 function snapshotDir() {
-  return path12.join(getProjectRoot(), ".kuma", SNAPSHOT_DIR);
+  return path14.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 path14.join(snapshotDir(), `${timestamp}.json`);
 }
 function saveSnapshot(goal) {
   try {
@@ -4449,7 +5220,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 });
@@ -4457,12 +5228,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(path14.join(dir, f), "utf-8");
         return JSON.parse(content);
       } catch {
         return null;
@@ -4505,7 +5276,7 @@ function formatSnapshot(snapshot) {
 function getGitDiffStat2() {
   try {
     const root = getProjectRoot();
-    const stdout = execSync5("git diff --stat", {
+    const stdout = execSync8("git diff --stat", {
       cwd: root,
       encoding: "utf-8",
       timeout: 3e3
@@ -4650,25 +5421,25 @@ async function handleKumaContext(params) {
 }
 
 // src/tools/kumaInit.ts
-import fs13 from "fs";
-import path13 from "path";
+import fs14 from "fs";
+import path15 from "path";
 async function handleKumaInit(params) {
   const root = params.projectRoot ?? getProjectRoot();
-  const kumaDir = path13.join(root, ".kuma");
-  const memoriesDir = path13.join(kumaDir, "memories");
-  const initMdPath = path13.join(kumaDir, "init.md");
+  const kumaDir = path15.join(root, ".kuma");
+  const memoriesDir = path15.join(kumaDir, "memories");
+  const initMdPath = path15.join(kumaDir, "init.md");
   sessionMemory.recordToolCall("kuma_init", { projectRoot: root });
   let rules = "";
-  if (fs13.existsSync(initMdPath)) {
-    rules = fs13.readFileSync(initMdPath, "utf-8");
+  if (fs14.existsSync(initMdPath)) {
+    rules = fs14.readFileSync(initMdPath, "utf-8");
   }
   const memories = [];
-  if (fs13.existsSync(memoriesDir)) {
+  if (fs14.existsSync(memoriesDir)) {
     try {
-      const files = fs13.readdirSync(memoriesDir).filter((f) => f.endsWith(".md"));
+      const files = fs14.readdirSync(memoriesDir).filter((f) => f.endsWith(".md"));
       for (const file of files) {
         try {
-          const content = fs13.readFileSync(path13.join(memoriesDir, file), "utf-8");
+          const content = fs14.readFileSync(path15.join(memoriesDir, file), "utf-8");
           memories.push({ topic: file.replace(/\.md$/, ""), content });
         } catch {
         }
@@ -4712,9 +5483,9 @@ ${memoryList}`);
 }
 
 // src/tools/kumaRisk.ts
-import path14 from "path";
-import fg2 from "fast-glob";
-import fs14 from "fs";
+import path16 from "path";
+import fg4 from "fast-glob";
+import fs15 from "fs";
 async function handleKumaRisk(params) {
   const { symbol, filePath, depth = 2 } = params;
   if (!symbol && !filePath) {
@@ -4748,7 +5519,7 @@ async function handleKumaRisk(params) {
   ];
   let entries = [];
   try {
-    entries = await fg2("**/*.{ts,tsx,js,jsx,mjs,cjs}", {
+    entries = await fg4("**/*.{ts,tsx,js,jsx,mjs,cjs}", {
       cwd: root,
       ignore: ignorePatterns,
       onlyFiles: true,
@@ -4767,11 +5538,11 @@ async function handleKumaRisk(params) {
   for (const entry of entries) {
     if (results.length >= maxResults) break;
     try {
-      const fullPath = path14.join(root, entry);
-      const stat = fs14.statSync(fullPath);
+      const fullPath = path16.join(root, entry);
+      const stat = fs15.statSync(fullPath);
       if (stat.size > 5e5) continue;
       if (isBinaryFile(fullPath)) continue;
-      const content = fs14.readFileSync(fullPath, "utf-8");
+      const content = fs15.readFileSync(fullPath, "utf-8");
       const lines = content.split("\n");
       for (let i = 0; i < lines.length; i++) {
         if (results.length >= maxResults) break;
@@ -4895,8 +5666,8 @@ function formatRiskReport(report, circularDepWarning) {
 }
 
 // src/tools/kumaDependencyGuard.ts
-import fs15 from "fs";
-import path15 from "path";
+import fs16 from "fs";
+import path17 from "path";
 var NATIVE_JS_ALTERNATIVES = {
   "lodash": [
     { method: "Array.prototype.map()", description: "Replace _.map()" },
@@ -4983,12 +5754,12 @@ var NATIVE_JS_ALTERNATIVES = {
 };
 function findExistingDependency(packageName) {
   const root = getProjectRoot();
-  const packageJsonPath = path15.join(root, "package.json");
-  if (!fs15.existsSync(packageJsonPath)) {
+  const packageJsonPath = path17.join(root, "package.json");
+  if (!fs16.existsSync(packageJsonPath)) {
     return { found: false };
   }
   try {
-    const pkg = JSON.parse(fs15.readFileSync(packageJsonPath, "utf-8"));
+    const pkg = JSON.parse(fs16.readFileSync(packageJsonPath, "utf-8"));
     const deps = pkg.dependencies || {};
     if (deps[packageName]) {
       return { found: true, version: deps[packageName] };
@@ -5004,12 +5775,12 @@ function findExistingDependency(packageName) {
 }
 function findSimilarExisting(packageName) {
   const root = getProjectRoot();
-  const packageJsonPath = path15.join(root, "package.json");
-  if (!fs15.existsSync(packageJsonPath)) {
+  const packageJsonPath = path17.join(root, "package.json");
+  if (!fs16.existsSync(packageJsonPath)) {
     return [];
   }
   try {
-    const pkg = JSON.parse(fs15.readFileSync(packageJsonPath, "utf-8"));
+    const pkg = JSON.parse(fs16.readFileSync(packageJsonPath, "utf-8"));
     const allDeps = { ...pkg.dependencies || {}, ...pkg.devDependencies || {} };
     const installedPackages = Object.keys(allDeps);
     const alternativeMap = {
@@ -5120,8 +5891,8 @@ function getEstimatedPackageSize(packageName) {
 }
 
 // src/tools/kumaPolicy.ts
-import fs16 from "fs";
-import path16 from "path";
+import fs17 from "fs";
+import path18 from "path";
 var DEFAULT_POLICY = {
   never_touch: [
     ".env",
@@ -5147,15 +5918,15 @@ var DEFAULT_POLICY = {
 };
 function loadPolicy() {
   const root = getProjectRoot();
-  const ymlPath = path16.join(root, ".kuma", "policy.yml");
-  const yamlPath = path16.join(root, ".kuma", "policy.yaml");
+  const ymlPath = path18.join(root, ".kuma", "policy.yml");
+  const yamlPath = path18.join(root, ".kuma", "policy.yaml");
   let policyContent = null;
   let policyPath = null;
-  if (fs16.existsSync(ymlPath)) {
-    policyContent = fs16.readFileSync(ymlPath, "utf-8");
+  if (fs17.existsSync(ymlPath)) {
+    policyContent = fs17.readFileSync(ymlPath, "utf-8");
     policyPath = ymlPath;
-  } else if (fs16.existsSync(yamlPath)) {
-    policyContent = fs16.readFileSync(yamlPath, "utf-8");
+  } else if (fs17.existsSync(yamlPath)) {
+    policyContent = fs17.readFileSync(yamlPath, "utf-8");
     policyPath = yamlPath;
   }
   if (!policyContent) {
@@ -5272,9 +6043,9 @@ function checkFilePathPolicy(filePath, policy) {
   if (policy.max_file_size && policy.max_file_size > 0) {
     try {
       const root = getProjectRoot();
-      const fullPath = path16.join(root, filePath);
-      if (fs16.existsSync(fullPath)) {
-        const sizeKB = fs16.statSync(fullPath).size / 1024;
+      const fullPath = path18.join(root, filePath);
+      if (fs17.existsSync(fullPath)) {
+        const sizeKB = fs17.statSync(fullPath).size / 1024;
         if (sizeKB > policy.max_file_size) {
           violations.push({
             rule: "max_file_size",
@@ -5370,8 +6141,8 @@ function formatPolicyResult(type, value, result, policy) {
 }
 
 // src/engine/safetyScore.ts
-import fs17 from "fs";
-import path17 from "path";
+import fs18 from "fs";
+import path19 from "path";
 function computeSafetyScore(inputGoal) {
   const stats = getSessionStats(inputGoal);
   const checks = [];
@@ -5415,8 +6186,8 @@ function computeSafetyScore(inputGoal) {
     totalScore += 20;
   }
   const backupDir = getKumaBackupsDir();
-  if (fs17.existsSync(backupDir)) {
-    const backupCount = fs17.readdirSync(backupDir).filter((d) => /^\d+$/.test(d)).length;
+  if (fs18.existsSync(backupDir)) {
+    const backupCount = fs18.readdirSync(backupDir).filter((d) => /^\d+$/.test(d)).length;
     checks.push({
       label: "Backup Available",
       status: "pass",
@@ -5434,8 +6205,8 @@ function computeSafetyScore(inputGoal) {
     totalScore += 5;
   }
   try {
-    const lspPath = path17.join(getProjectRoot(), "node_modules", ".bin", "typescript-language-server");
-    if (fs17.existsSync(lspPath)) {
+    const lspPath = path19.join(getProjectRoot(), "node_modules", ".bin", "typescript-language-server");
+    if (fs18.existsSync(lspPath)) {
       checks.push({
         label: "LSP Available",
         status: "pass",
@@ -5657,8 +6428,8 @@ function formatSafetyScore(report) {
 
 // src/engine/kumaDb.ts
 import initSqlJs from "sql.js";
-import fs18 from "fs";
-import path18 from "path";
+import fs19 from "fs";
+import path20 from "path";
 var DB_FILENAME = "kuma.db";
 var dbInstance = null;
 var initPromise = null;
@@ -5671,13 +6442,13 @@ async function getDb() {
 async function initDb() {
   const SQL = await initSqlJs();
   const kumaDir = getKumaDir();
-  const dbPath = path18.join(kumaDir, DB_FILENAME);
-  if (!fs18.existsSync(kumaDir)) {
-    fs18.mkdirSync(kumaDir, { recursive: true });
+  const dbPath = path20.join(kumaDir, DB_FILENAME);
+  if (!fs19.existsSync(kumaDir)) {
+    fs19.mkdirSync(kumaDir, { recursive: true });
   }
   let db;
-  if (fs18.existsSync(dbPath)) {
-    const buffer = fs18.readFileSync(dbPath);
+  if (fs19.existsSync(dbPath)) {
+    const buffer = fs19.readFileSync(dbPath);
     db = new SQL.Database(buffer);
   } else {
     db = new SQL.Database();
@@ -5694,10 +6465,10 @@ function saveDb(db) {
   if (!d) return;
   try {
     const kumaDir = getKumaDir();
-    const dbPath = path18.join(kumaDir, DB_FILENAME);
+    const dbPath = path20.join(kumaDir, DB_FILENAME);
     const data = d.export();
     const buffer = Buffer.from(data);
-    fs18.writeFileSync(dbPath, buffer);
+    fs19.writeFileSync(dbPath, buffer);
   } catch (err) {
     console.error(`[KumaDB] Failed to save database: ${err}`);
   }
@@ -5804,26 +6575,26 @@ function createSchema(db) {
 }
 
 // src/engine/kumaSelfHeal.ts
-import { execSync as execSync6 } from "child_process";
-import fs19 from "fs";
-import path19 from "path";
+import { execSync as execSync9 } from "child_process";
+import fs20 from "fs";
+import path21 from "path";
 import crypto from "crypto";
 function contentFingerprint(filePath) {
   try {
-    const fullPath = path19.join(getProjectRoot(), filePath);
-    if (!fs19.existsSync(fullPath)) return null;
-    const stat = fs19.statSync(fullPath);
+    const fullPath = path21.join(getProjectRoot(), filePath);
+    if (!fs20.existsSync(fullPath)) return null;
+    const stat = fs20.statSync(fullPath);
     if (!stat.isFile()) return null;
-    const fd = fs19.openSync(fullPath, "r");
+    const fd = fs20.openSync(fullPath, "r");
     try {
       const size = stat.size;
       const readSize = Math.min(1024, size);
       const head = Buffer.alloc(readSize);
-      fs19.readSync(fd, head, 0, readSize, 0);
+      fs20.readSync(fd, head, 0, readSize, 0);
       let tail = Buffer.alloc(0);
       if (size > 2048) {
         tail = Buffer.alloc(1024);
-        fs19.readSync(fd, tail, 0, 1024, size - 1024);
+        fs20.readSync(fd, tail, 0, 1024, size - 1024);
       }
       const hash = crypto.createHash("md5");
       hash.update(head);
@@ -5831,7 +6602,7 @@ function contentFingerprint(filePath) {
       hash.update(String(size));
       return hash.digest("hex");
     } finally {
-      fs19.closeSync(fd);
+      fs20.closeSync(fd);
     }
   } catch {
     return null;
@@ -5840,8 +6611,8 @@ function contentFingerprint(filePath) {
 function findByFingerprint(fingerprint, oldName) {
   try {
     const root = getProjectRoot();
-    const ext = path19.extname(oldName);
-    const result = execSync6(
+    const ext = path21.extname(oldName);
+    const result = execSync9(
       `find . -name "*${ext}" -type f -not -path "./node_modules/*" -not -path "./.git/*" -not -path "./dist/*" -not -path "./build/*" 2>/dev/null | head -200`,
       { cwd: root, encoding: "utf-8", maxBuffer: 1024 * 1024, timeout: 1e4 }
     ).trim();
@@ -5874,8 +6645,8 @@ async function detectStaleNodes() {
       const row = stmt.getAsObject();
       const filePath = row.file_path;
       if (filePath.startsWith("search::") || filePath.startsWith("api_route::")) continue;
-      const fullPath = path19.join(root, filePath);
-      if (!fs19.existsSync(fullPath)) {
+      const fullPath = path21.join(root, filePath);
+      if (!fs20.existsSync(fullPath)) {
         const newPath = findRenamedPath(filePath);
         if (newPath) {
           stale.push({
@@ -5888,7 +6659,7 @@ async function detectStaleNodes() {
           });
         } else {
           const oldFingerprint = contentFingerprint(filePath);
-          const contentMatch = oldFingerprint ? findByFingerprint(oldFingerprint, path19.basename(filePath)) : null;
+          const contentMatch = oldFingerprint ? findByFingerprint(oldFingerprint, path21.basename(filePath)) : null;
           stale.push({
             nodeId: row.id,
             type: row.type,
@@ -5909,7 +6680,7 @@ async function detectStaleNodes() {
 function findRenamedPath(oldPath) {
   try {
     const root = getProjectRoot();
-    const output = execSync6(
+    const output = execSync9(
       `git log --follow --diff-filter=R --name-only --format="" -1 -- "${oldPath}"`,
       { cwd: root, encoding: "utf-8", maxBuffer: 1024 * 1024, timeout: 5e3 }
     ).trim();
@@ -5990,8 +6761,8 @@ async function healOnQuery(filePaths) {
   try {
     const stalePaths = filePaths.filter((fp) => {
       if (!fp || fp.startsWith("search::") || fp.startsWith("api_route::")) return false;
-      const fullPath = path19.join(getProjectRoot(), fp);
-      return !fs19.existsSync(fullPath);
+      const fullPath = path21.join(getProjectRoot(), fp);
+      return !fs20.existsSync(fullPath);
     });
     if (stalePaths.length === 0) return { healed: 0 };
     let healed = 0;
@@ -6520,8 +7291,8 @@ async function pruneExperiences(keepPerTool = 50) {
 
 // src/engine/lspClient.ts
 import { spawn as spawn2 } from "child_process";
-import path20 from "path";
-import fs20 from "fs";
+import path22 from "path";
+import fs21 from "fs";
 var LSPClient = class {
   process = null;
   requestId = 0;
@@ -6559,8 +7330,8 @@ var LSPClient = class {
       console.error(`[LSP] typescript-language-server not found. LSP features will fallback to regex.`);
       return;
     }
-    const tsconfigPath = path20.join(root, "tsconfig.json");
-    if (!fs20.existsSync(tsconfigPath)) {
+    const tsconfigPath = path22.join(root, "tsconfig.json");
+    if (!fs21.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"], {
@@ -6622,19 +7393,19 @@ var LSPClient = class {
   /** Resolve the typescript-language-server binary from local or global install */
   resolveLspBinary(projectRoot) {
     const candidates = [
-      path20.join(projectRoot, "node_modules", ".bin", "typescript-language-server"),
-      path20.join(projectRoot, "..", "node_modules", ".bin", "typescript-language-server")
+      path22.join(projectRoot, "node_modules", ".bin", "typescript-language-server"),
+      path22.join(projectRoot, "..", "node_modules", ".bin", "typescript-language-server")
     ];
     for (const candidate of candidates) {
-      if (fs20.existsSync(candidate)) {
+      if (fs21.existsSync(candidate)) {
         return candidate;
       }
     }
     try {
       const envPath = process.env.PATH ?? "";
-      for (const dir of envPath.split(path20.delimiter)) {
-        const binPath = path20.join(dir, "typescript-language-server");
-        if (fs20.existsSync(binPath)) {
+      for (const dir of envPath.split(path22.delimiter)) {
+        const binPath = path22.join(dir, "typescript-language-server");
+        if (fs21.existsSync(binPath)) {
           return binPath;
         }
       }
@@ -6656,7 +7427,7 @@ var LSPClient = class {
     this.openDocuments.add(filePath);
     let content;
     try {
-      content = fs20.readFileSync(filePath, "utf-8");
+      content = fs21.readFileSync(filePath, "utf-8");
     } catch {
       content = "";
     }
@@ -6873,8 +7644,8 @@ var LSPClient = class {
 var lspClient = new LSPClient();
 
 // src/tools/lspTools.ts
-import fs21 from "fs";
-import path21 from "path";
+import fs22 from "fs";
+import path23 from "path";
 async function handleFindReferences(params) {
   const { filePath, line, character } = params;
   const validation = validateFilePath(filePath);
@@ -6882,7 +7653,7 @@ async function handleFindReferences(params) {
     return `Error: ${validation.error.message}`;
   }
   const resolvedPath = validation.resolvedPath;
-  if (!fs21.existsSync(resolvedPath)) {
+  if (!fs22.existsSync(resolvedPath)) {
     return `Error: File not found: "${filePath}".`;
   }
   if (!lspClient.isAvailable()) {
@@ -6907,7 +7678,7 @@ No references found for symbol at this position.`;
     const enrichedRefs = references.map((ref) => {
       let lineContent = "";
       try {
-        const content = fs21.readFileSync(ref.filePath, "utf-8");
+        const content = fs22.readFileSync(ref.filePath, "utf-8");
         const lines2 = content.split("\n");
         lineContent = lines2[ref.line]?.trim() ?? "";
       } catch {
@@ -6923,11 +7694,11 @@ No references found for symbol at this position.`;
     const projectRoot = getProjectRoot();
     const lines = [
       `**Find References** \u2014 ${enrichedRefs.length} references found`,
-      `\u{1F4CD} File: ${path21.relative(projectRoot, resolvedPath)}:${line + 1}:${character + 1}`,
+      `\u{1F4CD} File: ${path23.relative(projectRoot, resolvedPath)}:${line + 1}:${character + 1}`,
       ""
     ];
     for (const [file, refs] of grouped) {
-      const relPath = path21.relative(projectRoot, file);
+      const relPath = path23.relative(projectRoot, file);
       lines.push(`**\u{1F4C4} ${relPath}:**`);
       for (const ref of refs) {
         const loc = `L${ref.line + 1}:${ref.character + 1}`;
@@ -6948,7 +7719,7 @@ async function handleGoToDefinition(params) {
     return `Error: ${validation.error.message}`;
   }
   const resolvedPath = validation.resolvedPath;
-  if (!fs21.existsSync(resolvedPath)) {
+  if (!fs22.existsSync(resolvedPath)) {
     return `Error: File not found: "${filePath}".`;
   }
   if (!lspClient.isAvailable()) {
@@ -6971,10 +7742,10 @@ Try selecting a smaller/cleaner position, or install typescript-language-server
 Cannot find definition for symbol at this position.`;
     }
     const projectRoot = getProjectRoot();
-    const relPath = path21.relative(projectRoot, definition.filePath);
+    const relPath = path23.relative(projectRoot, definition.filePath);
     let lineContent = "";
     try {
-      const content = fs21.readFileSync(definition.filePath, "utf-8");
+      const content = fs22.readFileSync(definition.filePath, "utf-8");
       const lines2 = content.split("\n");
       lineContent = lines2[definition.line]?.trim() ?? "";
     } catch {
@@ -7006,7 +7777,7 @@ async function handleRenameSymbol(params) {
     return `Error: ${validation.error.message}`;
   }
   const resolvedPath = validation.resolvedPath;
-  if (!fs21.existsSync(resolvedPath)) {
+  if (!fs22.existsSync(resolvedPath)) {
     return `Error: File not found: "${filePath}".`;
   }
   if (!lspClient.isAvailable()) {
@@ -7037,7 +7808,7 @@ Make sure:
     const fileChanges = [];
     for (const change of result.changes) {
       try {
-        const content = fs21.readFileSync(change.filePath, "utf-8");
+        const content = fs22.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;
@@ -7051,10 +7822,10 @@ Make sure:
             lines2[edit.line] = before + edit.newText + after;
           }
         }
-        fs21.writeFileSync(change.filePath, lines2.join("\n"), "utf-8");
+        fs22.writeFileSync(change.filePath, lines2.join("\n"), "utf-8");
         totalEdits += change.edits.length;
         fileChanges.push({
-          filePath: path21.relative(projectRoot, change.filePath),
+          filePath: path23.relative(projectRoot, change.filePath),
           editCount: change.edits.length
         });
       } catch (err) {
@@ -7081,14 +7852,14 @@ async function handleGetTypeInfo(params) {
     return `Error: ${validation.error.message}`;
   }
   const resolvedPath = validation.resolvedPath;
-  if (!fs21.existsSync(resolvedPath)) {
+  if (!fs22.existsSync(resolvedPath)) {
     return `Error: File not found: "${filePath}".`;
   }
   if (!lspClient.isAvailable()) {
     sessionMemory.recordToolCall("lsp_query", { action: "type", filePath, line, character, fallback: "line-context" });
     console.error(`[LSP] typescript-language-server not found. Using file-read fallback for type info.`);
     try {
-      const fileContent = fs21.readFileSync(resolvedPath, "utf-8");
+      const fileContent = fs22.readFileSync(resolvedPath, "utf-8");
       const fileLines = fileContent.split("\n");
       const targetLine = fileLines[line];
       if (!targetLine) {
@@ -7096,7 +7867,7 @@ async function handleGetTypeInfo(params) {
       }
       const symbolName = extractSymbolAtPosition(resolvedPath, line, character);
       const projectRoot = getProjectRoot();
-      const relPath = path21.relative(projectRoot, resolvedPath);
+      const relPath = path23.relative(projectRoot, resolvedPath);
       const contextStart = Math.max(0, line - 3);
       const contextEnd = Math.min(fileLines.length, line + 4);
       const contextLines = [];
@@ -7131,7 +7902,7 @@ async function handleGetTypeInfo(params) {
 No type info for this position.`;
     }
     const projectRoot = getProjectRoot();
-    const relPath = path21.relative(projectRoot, resolvedPath);
+    const relPath = path23.relative(projectRoot, resolvedPath);
     const lines = [
       `\u{1F4CB} **Type Info** \u2014 \`${relPath}:${line + 1}:${character + 1}\``,
       "",
@@ -7172,7 +7943,7 @@ async function handleLspQuery(params) {
 }
 function extractSymbolAtPosition(filePath, line, character) {
   try {
-    const content = fs21.readFileSync(filePath, "utf-8");
+    const content = fs22.readFileSync(filePath, "utf-8");
     const lines = content.split("\n");
     const targetLine = lines[line];
     if (!targetLine) return null;
@@ -7190,9 +7961,9 @@ function extractSymbolAtPosition(filePath, line, character) {
 }
 async function fallbackGrepReferences(symbolName, _filePath, _line, _character) {
   try {
-    const { default: fg4 } = await import("fast-glob");
+    const { default: fg6 } = await import("fast-glob");
     const root = getProjectRoot();
-    const tsFiles = await fg4(["**/*.{ts,tsx,js,jsx}"], {
+    const tsFiles = await fg6(["**/*.{ts,tsx,js,jsx}"], {
       cwd: root,
       ignore: ["node_modules/**", "dist/**", ".git/**"],
       onlyFiles: true,
@@ -7203,7 +7974,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 = fs21.readFileSync(file, "utf-8");
+        const content = fs22.readFileSync(file, "utf-8");
         const lines2 = content.split("\n");
         for (let i = 0; i < lines2.length; i++) {
           if (regex.test(lines2[i])) {
@@ -7232,7 +8003,7 @@ No references found. Symbol may not be used in other files.`;
       ""
     ];
     if (grouped.size > 1) {
-      const fileList = [...grouped.keys()].map((f) => path21.relative(projectRoot, f)).join(", ");
+      const fileList = [...grouped.keys()].map((f) => path23.relative(projectRoot, f)).join(", ");
       lines.push(`**Ambiguity note:** Found matches across ${grouped.size} different files (${fileList}).`);
       lines.push(`   Verify each match is the right scope \u2014 results may include same-named symbols.`);
       lines.push("");
@@ -7249,7 +8020,7 @@ No references found. Symbol may not be used in other files.`;
       }
     }
     for (const [file, refs] of grouped) {
-      const relPath = path21.relative(projectRoot, file);
+      const relPath = path23.relative(projectRoot, file);
       lines.push(`**\u{1F4C4} ${relPath}:**`);
       for (const ref of refs) {
         lines.push(`  \u2514 L${ref.line} \u2014 ${ref.content}`);
@@ -7264,9 +8035,9 @@ No references found. Symbol may not be used in other files.`;
 }
 async function fallbackGrepDefinition(symbolName) {
   try {
-    const { default: fg4 } = await import("fast-glob");
+    const { default: fg6 } = await import("fast-glob");
     const root = getProjectRoot();
-    const tsFiles = await fg4(["**/*.{ts,tsx,js,jsx}"], {
+    const tsFiles = await fg6(["**/*.{ts,tsx,js,jsx}"], {
       cwd: root,
       ignore: ["node_modules/**", "dist/**", ".git/**"],
       onlyFiles: true,
@@ -7283,14 +8054,14 @@ async function fallbackGrepDefinition(symbolName) {
     ];
     for (const file of tsFiles) {
       try {
-        const content = fs21.readFileSync(file, "utf-8");
+        const content = fs22.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 = path21.relative(projectRoot, file);
+              const relPath = path23.relative(projectRoot, file);
               return [
                 `\u{1F4CD} **Go to Definition**`,
                 `\u{1F4C4} File: \`${relPath}\``,
@@ -7313,11 +8084,11 @@ Cannot find definition.`;
 }
 
 // src/engine/kumaTimeMachine.ts
-import { execSync as execSync7 } from "child_process";
+import { execSync as execSync10 } from "child_process";
 function getBlameForFile(filePath) {
   const root = getProjectRoot();
   try {
-    const output = execSync7(
+    const output = execSync10(
       `git blame --line-porcelain -- "${filePath}"`,
       { cwd: root, encoding: "utf-8", maxBuffer: 2 * 1024 * 1024, timeout: 1e4 }
     );
@@ -7363,7 +8134,7 @@ function getBlameForFile(filePath) {
 function getFileHistory(filePath, maxCount = 20) {
   const root = getProjectRoot();
   try {
-    const output = execSync7(
+    const output = execSync10(
       `git log --follow --format="%H||%an||%ai||%s" --shortstat -- "${filePath}"`,
       { cwd: root, encoding: "utf-8", maxBuffer: 2 * 1024 * 1024, timeout: 1e4 }
     );
@@ -7398,7 +8169,7 @@ async function getSymbolTimeline(symbolName, filePath, symbolType = "function")
     const blame = getBlameForFile(filePath);
     const pattern = getSymbolPattern(symbolName, symbolType);
     const root = getProjectRoot();
-    const content = execSync7(`git show HEAD:"${filePath}"`, {
+    const content = execSync10(`git show HEAD:"${filePath}"`, {
       cwd: root,
       encoding: "utf-8",
       maxBuffer: 2 * 1024 * 1024,
@@ -7425,7 +8196,7 @@ async function getSymbolTimeline(symbolName, filePath, symbolType = "function")
     const entries = [];
     for (const [hash, data] of commitMap) {
       try {
-        const msg = execSync7(
+        const msg = execSync10(
           `git log -1 --format="%s" ${hash}`,
           { cwd: root, encoding: "utf-8", maxBuffer: 1024 * 1024, timeout: 3e3 }
         ).trim();
@@ -7610,10 +8381,10 @@ async function getIntentPatterns(limit = 10) {
         ORDER BY id ASC
       `);
       pathStmt.bind([session.id]);
-      const path29 = [];
+      const path31 = [];
       while (pathStmt.step()) {
         const row = pathStmt.getAsObject();
-        path29.push(row.tool_name);
+        path31.push(row.tool_name);
       }
       pathStmt.free();
       const existing = clusterMap.get(clusterKey) || {
@@ -7622,7 +8393,7 @@ async function getIntentPatterns(limit = 10) {
         totalDuration: 0,
         lastUsed: 0
       };
-      existing.paths.push(path29);
+      existing.paths.push(path31);
       existing.successes.push(session.success);
       existing.lastUsed = Math.max(existing.lastUsed, session.startedAt);
       clusterMap.set(clusterKey, existing);
@@ -7730,9 +8501,9 @@ function formatIntentSuggestion(intent, suggestion) {
 }
 
 // src/engine/kumaArchGuard.ts
-import fg3 from "fast-glob";
-import fs22 from "fs";
-import path22 from "path";
+import fg5 from "fast-glob";
+import fs23 from "fs";
+import path24 from "path";
 var ARCHITECTURES = [
   {
     name: "clean-architecture",
@@ -7823,8 +8594,8 @@ var ARCHITECTURES = [
 ];
 function detectArchitecture() {
   const root = getProjectRoot();
-  const srcDir = path22.join(root, "src");
-  if (!fs22.existsSync(srcDir)) {
+  const srcDir = path24.join(root, "src");
+  if (!fs23.existsSync(srcDir)) {
     return getArchitectureProfile("flat");
   }
   const scores = ARCHITECTURES.map((arch) => {
@@ -7835,7 +8606,7 @@ function detectArchitecture() {
         totalPatterns++;
         const globPattern = pattern.replace(/\/\*\*$/, "/**");
         try {
-          const matches = fg3.sync(globPattern, { cwd: root, onlyFiles: false, deep: 1 });
+          const matches = fg5.sync(globPattern, { cwd: root, onlyFiles: false, deep: 1 });
           if (matches.length > 0) matchCount++;
         } catch {
         }
@@ -7846,10 +8617,10 @@ function detectArchitecture() {
   scores.sort((a, b) => b.score - a.score);
   const best = scores[0];
   if (!best || best.score < 0.2) {
-    if (fs22.existsSync(path22.join(srcDir, "domain")) || fs22.existsSync(path22.join(srcDir, "entities"))) {
+    if (fs23.existsSync(path24.join(srcDir, "domain")) || fs23.existsSync(path24.join(srcDir, "entities"))) {
       return getArchitectureProfile("clean-architecture");
     }
-    if (fs22.existsSync(path22.join(srcDir, "data")) || fs22.existsSync(path22.join(srcDir, "business"))) {
+    if (fs23.existsSync(path24.join(srcDir, "data")) || fs23.existsSync(path24.join(srcDir, "business"))) {
       return getArchitectureProfile("layered-architecture");
     }
     return getArchitectureProfile("flat");
@@ -7920,7 +8691,7 @@ async function scanFilesystemForViolations(profile) {
   const arch = profile || detectArchitecture();
   const root = getProjectRoot();
   try {
-    const files = await fg3(["src/**/*.{ts,tsx,js,jsx}"], {
+    const files = await fg5(["src/**/*.{ts,tsx,js,jsx}"], {
       cwd: root,
       ignore: ["**/node_modules/**", "**/*.test.*", "**/*.spec.*", "**/*.d.ts"],
       onlyFiles: true
@@ -7929,7 +8700,7 @@ async function scanFilesystemForViolations(profile) {
     const requireRegex = /require\(['"]([^'"]+)['"]\)/g;
     for (const file of files.slice(0, 200)) {
       try {
-        const content = fs22.readFileSync(path22.join(root, file), "utf-8");
+        const content = fs23.readFileSync(path24.join(root, file), "utf-8");
         const imports = [];
         let match;
         while ((match = importRegex.exec(content)) !== null) {
@@ -7942,16 +8713,16 @@ async function scanFilesystemForViolations(profile) {
           if (!imp.startsWith(".") && !imp.startsWith("/") && !imp.startsWith("src/")) continue;
           let targetFile = imp;
           if (imp.startsWith(".")) {
-            const resolved = path22.resolve(path22.dirname(file), imp);
-            targetFile = path22.relative(root, resolved);
+            const resolved = path24.resolve(path24.dirname(file), imp);
+            targetFile = path24.relative(root, resolved);
           } else if (imp.startsWith("/")) {
             targetFile = imp.substring(1);
           }
-          if (!path22.extname(targetFile)) {
+          if (!path24.extname(targetFile)) {
             const extVariants = [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js"];
             let found = false;
             for (const ext of extVariants) {
-              if (fs22.existsSync(path22.join(root, targetFile + ext))) {
+              if (fs23.existsSync(path24.join(root, targetFile + ext))) {
                 targetFile += ext;
                 found = true;
                 break;
@@ -8035,20 +8806,20 @@ function formatArchitectureDetection(profile) {
 }
 
 // src/engine/kumaMemory.ts
-import fs23 from "fs";
-import path23 from "path";
+import fs24 from "fs";
+import path25 from "path";
 var MEMORY_DIR = ".kuma/memories";
 function scoreMemoryRelevance(context, limit = 5) {
   const results = [];
-  const kumaDir = path23.join(getProjectRoot(), MEMORY_DIR);
-  if (!fs23.existsSync(kumaDir)) return [];
+  const kumaDir = path25.join(getProjectRoot(), MEMORY_DIR);
+  if (!fs24.existsSync(kumaDir)) return [];
   const terms = context.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
   if (terms.length === 0) return [];
   try {
-    const files = fs23.readdirSync(kumaDir).filter((f) => f.endsWith(".md"));
+    const files = fs24.readdirSync(kumaDir).filter((f) => f.endsWith(".md"));
     for (const file of files) {
       try {
-        const content = fs23.readFileSync(path23.join(kumaDir, file), "utf-8");
+        const content = fs24.readFileSync(path25.join(kumaDir, file), "utf-8");
         const lower = content.toLowerCase();
         let matchCount = 0;
         for (const term of terms) {
@@ -8128,7 +8899,7 @@ function formatDecisionTemplate() {
 }
 
 // src/engine/kumaContextEngine.ts
-import { execSync as execSync8 } from "child_process";
+import { execSync as execSync11 } from "child_process";
 var STOP_WORDS = /* @__PURE__ */ new Set([
   "the",
   "this",
@@ -8245,7 +9016,7 @@ async function searchNodesFts(db, terms) {
 function getFileRecencySeconds(filePath) {
   try {
     const escapedPath = filePath.replace(/"/g, '\\"');
-    const result = execSync8(
+    const result = execSync11(
       'git log -1 --format=%ct -- "' + escapedPath + '" 2>/dev/null || echo 0',
       { encoding: "utf-8", timeout: 2e3 }
     );
@@ -8962,9 +9733,9 @@ async function buildOwnershipMap(db, focus, limit) {
   const dirGroups = /* @__PURE__ */ new Map();
   while (stmt.step()) {
     const row = stmt.getAsObject();
-    const path29 = row.file_path || row.name;
-    const dir = topDir(path29);
-    if (focus && !path29.includes(focus)) continue;
+    const path31 = row.file_path || row.name;
+    const dir = topDir(path31);
+    if (focus && !path31.includes(focus)) continue;
     if (!dirGroups.has(dir)) dirGroups.set(dir, []);
     const existing = dirGroups.get(dir);
     const emoji = row.type === "function" ? "\u{1F527}" : row.type === "file" ? "\u{1F4C4}" : "\u{1F4CC}";
@@ -9005,8 +9776,8 @@ function mermaidId(name) {
 }
 
 // src/engine/kumaHeatMap.ts
-import fs24 from "fs";
-import path24 from "path";
+import fs25 from "fs";
+import path26 from "path";
 async function computeHeatMap() {
   const history = sessionMemory.getToolCallHistory(100);
   const db = await getDb();
@@ -9015,7 +9786,7 @@ async function computeHeatMap() {
     const p = call.params;
     const fp = p.filePath || p.file || "";
     if (!fp) continue;
-    const dir = path24.dirname(fp).split("/")[0] || ".";
+    const dir = path26.dirname(fp).split("/")[0] || ".";
     const entry = dirData.get(dir) || { edits: 0, reads: 0, failures: 0 };
     if (call.toolName === "precise_diff_editor" || call.toolName === "batch_file_writer") {
       entry.edits++;
@@ -9043,12 +9814,12 @@ async function computeHeatMap() {
   } catch {
   }
   const root = getProjectRoot();
-  const srcDir = path24.join(root, "src");
-  if (fs24.existsSync(srcDir)) {
+  const srcDir = path26.join(root, "src");
+  if (fs25.existsSync(srcDir)) {
     try {
-      for (const entry of fs24.readdirSync(srcDir, { withFileTypes: true })) {
+      for (const entry of fs25.readdirSync(srcDir, { withFileTypes: true })) {
         if (entry.isDirectory() && !entry.name.startsWith(".")) {
-          const count = countFiles(path24.join(srcDir, entry.name));
+          const count = countFiles(path26.join(srcDir, entry.name));
           if (!dirFileCounts.has(entry.name) || dirFileCounts.get(entry.name) < count) {
             dirFileCounts.set(entry.name, count);
           }
@@ -9158,9 +9929,9 @@ function formatHeatMap(report) {
 function countFiles(dir) {
   let count = 0;
   try {
-    for (const entry of fs24.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of fs25.readdirSync(dir, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) continue;
-      const full = path24.join(dir, entry.name);
+      const full = path26.join(dir, entry.name);
       if (entry.isDirectory()) {
         count += countFiles(full);
       } else if (/\.(ts|tsx|js|jsx|go|rs|py|java|kt)$/.test(entry.name)) {
@@ -9460,72 +10231,72 @@ function simpleHash(str) {
 }
 
 // src/engine/kumaLock.ts
-import fs25 from "fs";
-import path25 from "path";
+import fs26 from "fs";
+import path27 from "path";
 var LOCKS_DIR = ".kuma/locks";
 function locksDir() {
-  return path25.join(getProjectRoot(), LOCKS_DIR);
+  return path27.join(getProjectRoot(), LOCKS_DIR);
 }
 function ensureLocksDir() {
   const dir = locksDir();
-  if (!fs25.existsSync(dir)) fs25.mkdirSync(dir, { recursive: true });
+  if (!fs26.existsSync(dir)) fs26.mkdirSync(dir, { recursive: true });
 }
 function lockPath(filePath) {
   const safeName = filePath.replace(/[^a-zA-Z0-9_./-]/g, "_");
-  return path25.join(locksDir(), `${safeName}.lock.json`);
+  return path27.join(locksDir(), `${safeName}.lock.json`);
 }
 function acquireLock(filePath, agentId) {
   ensureLocksDir();
   const lp = lockPath(filePath);
   const id = agentId || `agent-${process.pid}`;
-  if (fs25.existsSync(lp)) {
+  if (fs26.existsSync(lp)) {
     try {
-      const existing = JSON.parse(fs25.readFileSync(lp, "utf-8"));
+      const existing = JSON.parse(fs26.readFileSync(lp, "utf-8"));
       if (existing.agentId === id) {
         return `\u{1F512} **Already locked** by you (${id}) on ${new Date(existing.acquiredAt).toISOString()}`;
       }
       const elapsed = Math.floor((Date.now() - existing.acquiredAt) / 1e3);
       if (elapsed > 300) {
-        fs25.unlinkSync(lp);
+        fs26.unlinkSync(lp);
       } else {
         return `\u{1F512} **Locked** by ${existing.agentId} since ${new Date(existing.acquiredAt).toISOString()} (${elapsed}s ago)`;
       }
     } catch {
-      fs25.unlinkSync(lp);
+      fs26.unlinkSync(lp);
     }
   }
   const entry = { filePath, agentId: id, acquiredAt: Date.now(), status: "locked" };
-  fs25.writeFileSync(lp, JSON.stringify(entry, null, 2), "utf-8");
+  fs26.writeFileSync(lp, JSON.stringify(entry, null, 2), "utf-8");
   return `\u{1F513} **Lock acquired** on \`${filePath}\` by ${id}`;
 }
 function releaseLock(filePath, agentId) {
   ensureLocksDir();
   const lp = lockPath(filePath);
   const id = agentId || `agent-${process.pid}`;
-  if (!fs25.existsSync(lp)) {
+  if (!fs26.existsSync(lp)) {
     return `\u26A0\uFE0F No lock found for \`${filePath}\``;
   }
   try {
-    const existing = JSON.parse(fs25.readFileSync(lp, "utf-8"));
+    const existing = JSON.parse(fs26.readFileSync(lp, "utf-8"));
     if (existing.agentId !== id) {
       return `\u26A0\uFE0F Cannot release lock held by ${existing.agentId}. Use force:true to override.`;
     }
-    fs25.unlinkSync(lp);
+    fs26.unlinkSync(lp);
     return `\u{1F513} **Lock released** on \`${filePath}\``;
   } catch {
-    fs25.unlinkSync(lp);
+    fs26.unlinkSync(lp);
     return `\u{1F513} **Lock released** (force cleanup) on \`${filePath}\``;
   }
 }
 function listLocks() {
   ensureLocksDir();
   const dir = locksDir();
-  const files = fs25.readdirSync(dir).filter((f) => f.endsWith(".lock.json"));
+  const files = fs26.readdirSync(dir).filter((f) => f.endsWith(".lock.json"));
   if (files.length === 0) return "\u{1F513} No active locks.";
   const lines = ["\u{1F512} **Active Locks:**", ""];
   for (const f of files) {
     try {
-      const entry = JSON.parse(fs25.readFileSync(path25.join(dir, f), "utf-8"));
+      const entry = JSON.parse(fs26.readFileSync(path27.join(dir, f), "utf-8"));
       const elapsed = Math.floor((Date.now() - entry.acquiredAt) / 1e3);
       lines.push(`  \u2022 \`${entry.filePath}\` \u2014 locked by ${entry.agentId} (${elapsed}s ago)`);
     } catch {
@@ -9536,9 +10307,9 @@ function listLocks() {
 }
 function isLocked(filePath) {
   const lp = lockPath(filePath);
-  if (!fs25.existsSync(lp)) return { locked: false };
+  if (!fs26.existsSync(lp)) return { locked: false };
   try {
-    const entry = JSON.parse(fs25.readFileSync(lp, "utf-8"));
+    const entry = JSON.parse(fs26.readFileSync(lp, "utf-8"));
     return { locked: true, by: entry.agentId, since: entry.acquiredAt };
   } catch {
     return { locked: false };
@@ -9548,16 +10319,16 @@ function cleanStaleLocks() {
   ensureLocksDir();
   const dir = locksDir();
   let count = 0;
-  for (const f of fs25.readdirSync(dir).filter((f2) => f2.endsWith(".lock.json"))) {
+  for (const f of fs26.readdirSync(dir).filter((f2) => f2.endsWith(".lock.json"))) {
     try {
-      const entry = JSON.parse(fs25.readFileSync(path25.join(dir, f), "utf-8"));
+      const entry = JSON.parse(fs26.readFileSync(path27.join(dir, f), "utf-8"));
       if (Date.now() - entry.acquiredAt > 3e5) {
-        fs25.unlinkSync(path25.join(dir, f));
+        fs26.unlinkSync(path27.join(dir, f));
         count++;
       }
     } catch {
       try {
-        fs25.unlinkSync(path25.join(dir, f));
+        fs26.unlinkSync(path27.join(dir, f));
         count++;
       } catch {
       }
@@ -9905,13 +10676,13 @@ function formatConfidence(report, target) {
 }
 
 // src/engine/kumaDNA.ts
-import path26 from "path";
+import path28 from "path";
 async function generateDNA() {
   try {
     const db = await getDb();
     const summary = sessionMemory.getSummary();
     const root = getProjectRoot();
-    const projectName = path26.basename(root);
+    const projectName = path28.basename(root);
     let totalFiles = 0, totalFunctions = 0, totalTests = 0;
     try {
       const filesR = db.exec("SELECT COUNT(*) as c FROM nodes WHERE type = 'file'");
@@ -10760,14 +11531,14 @@ async function handleSafetyCheck(params) {
 }
 
 // src/engine/kumaCollective.ts
-import fs26 from "fs";
-import path27 from "path";
+import fs27 from "fs";
+import path29 from "path";
 var DEFAULT_ENDPOINT = process.env.KUMA_COLLECTIVE_URL || "";
 function getSyncConfig() {
   try {
-    const configPath = path27.join(getProjectRoot(), ".kuma", "config.json");
-    if (fs26.existsSync(configPath)) {
-      const raw = fs26.readFileSync(configPath, "utf-8");
+    const configPath = path29.join(getProjectRoot(), ".kuma", "config.json");
+    if (fs27.existsSync(configPath)) {
+      const raw = fs27.readFileSync(configPath, "utf-8");
       const config = JSON.parse(raw);
       if (config.collective) {
         return {
@@ -10787,12 +11558,12 @@ function getSyncConfig() {
 }
 function getInstanceId() {
   try {
-    const idPath = path27.join(getProjectRoot(), ".kuma", ".instance-id");
-    if (fs26.existsSync(idPath)) {
-      return fs26.readFileSync(idPath, "utf-8").trim();
+    const idPath = path29.join(getProjectRoot(), ".kuma", ".instance-id");
+    if (fs27.existsSync(idPath)) {
+      return fs27.readFileSync(idPath, "utf-8").trim();
     }
     const id = `anon-${Math.random().toString(36).slice(2, 10)}`;
-    fs26.writeFileSync(idPath, id, "utf-8");
+    fs27.writeFileSync(idPath, id, "utf-8");
     return id;
   } catch {
     return "anon-unknown";
@@ -10899,13 +11670,13 @@ function exportAnonymizedPatterns() {
 function detectProjectLanguage() {
   try {
     const root = getProjectRoot();
-    if (fs26.existsSync(path27.join(root, "go.mod"))) return "go";
-    if (fs26.existsSync(path27.join(root, "Cargo.toml"))) return "rust";
-    if (fs26.existsSync(path27.join(root, "composer.json"))) return "php";
-    if (fs26.existsSync(path27.join(root, "pyproject.toml")) || fs26.existsSync(path27.join(root, "requirements.txt"))) return "python";
-    if (fs26.existsSync(path27.join(root, "Gemfile"))) return "ruby";
-    if (fs26.existsSync(path27.join(root, "pom.xml")) || fs26.existsSync(path27.join(root, "build.gradle"))) return "java";
-    if (fs26.existsSync(path27.join(root, "package.json"))) return "typescript";
+    if (fs27.existsSync(path29.join(root, "go.mod"))) return "go";
+    if (fs27.existsSync(path29.join(root, "Cargo.toml"))) return "rust";
+    if (fs27.existsSync(path29.join(root, "composer.json"))) return "php";
+    if (fs27.existsSync(path29.join(root, "pyproject.toml")) || fs27.existsSync(path29.join(root, "requirements.txt"))) return "python";
+    if (fs27.existsSync(path29.join(root, "Gemfile"))) return "ruby";
+    if (fs27.existsSync(path29.join(root, "pom.xml")) || fs27.existsSync(path29.join(root, "build.gradle"))) return "java";
+    if (fs27.existsSync(path29.join(root, "package.json"))) return "typescript";
     return "unknown";
   } catch {
     return "unknown";
@@ -11061,9 +11832,9 @@ function formatCollectivePatterns(patterns) {
 }
 
 // src/engine/kumaMarketplace.ts
-import { execSync as execSync9 } from "child_process";
-import fs27 from "fs";
-import path28 from "path";
+import { execSync as execSync12 } from "child_process";
+import fs28 from "fs";
+import path30 from "path";
 var BUILT_IN_TEMPLATES = [
   // ── Framework Web (JS/TS) ──
   {
@@ -11278,7 +12049,7 @@ async function listMarketplace() {
     `\u{1F4E6} ${templates.length} template(s) available`,
     ""
   ];
-  const LANG_MAP = [
+  const LANG_MAP2 = [
     { lang: "typescript", keywords: ["typescript", "hono", "elysia", "tanstack", "zustand", "prisma", "drizzle", "shadcn"] },
     { lang: "javascript", keywords: ["javascript", "express"] },
     { lang: "go", keywords: ["go", "gin"] },
@@ -11298,7 +12069,7 @@ async function listMarketplace() {
     general: "\u{1F4E6}"
   };
   function detectLang(t) {
-    for (const entry of LANG_MAP) {
+    for (const entry of LANG_MAP2) {
       if (entry.keywords.some((k) => t.tags.some((tag) => tag.includes(k)))) {
         return entry.lang;
       }
@@ -11343,17 +12114,17 @@ function scanNpmTemplates() {
   const found = [];
   try {
     const root = getProjectRoot();
-    const nodeModulesPath = path28.join(root, "node_modules", "@kuma-templates");
-    if (!fs27.existsSync(nodeModulesPath)) return found;
-    const packages = fs27.readdirSync(nodeModulesPath);
+    const nodeModulesPath = path30.join(root, "node_modules", "@kuma-templates");
+    if (!fs28.existsSync(nodeModulesPath)) return found;
+    const packages = fs28.readdirSync(nodeModulesPath);
     for (const pkg of packages) {
-      const pkgPath = path28.join(nodeModulesPath, pkg, "package.json");
-      if (!fs27.existsSync(pkgPath)) continue;
-      const pkgJson = JSON.parse(fs27.readFileSync(pkgPath, "utf-8"));
-      const templatePath = path28.join(nodeModulesPath, pkg, "template.json");
+      const pkgPath = path30.join(nodeModulesPath, pkg, "package.json");
+      if (!fs28.existsSync(pkgPath)) continue;
+      const pkgJson = JSON.parse(fs28.readFileSync(pkgPath, "utf-8"));
+      const templatePath = path30.join(nodeModulesPath, pkg, "template.json");
       let nodeCount = 0, edgeCount = 0;
-      if (fs27.existsSync(templatePath)) {
-        const tmpl = JSON.parse(fs27.readFileSync(templatePath, "utf-8"));
+      if (fs28.existsSync(templatePath)) {
+        const tmpl = JSON.parse(fs28.readFileSync(templatePath, "utf-8"));
         nodeCount = tmpl.nodes?.length || 0;
         edgeCount = tmpl.edges?.length || 0;
       }
@@ -11438,8 +12209,8 @@ async function tryInstallFromNpm(templateId) {
   const name = templateId.replace(/^graph:/, "");
   try {
     const root = getProjectRoot();
-    const pkgPath = path28.join(root, "node_modules", "@kuma-templates", name, "template.json");
-    if (fs27.existsSync(pkgPath)) {
+    const pkgPath = path30.join(root, "node_modules", "@kuma-templates", name, "template.json");
+    if (fs28.existsSync(pkgPath)) {
       return await loadNpmTemplate(pkgPath, name);
     }
   } catch {
@@ -11447,14 +12218,14 @@ async function tryInstallFromNpm(templateId) {
   try {
     const npmPackage = `@kuma-templates/${name}`;
     const root = getProjectRoot();
-    execSync9(`npm install --no-save ${npmPackage}`, {
+    execSync12(`npm install --no-save ${npmPackage}`, {
       cwd: root,
       encoding: "utf-8",
       timeout: 3e4,
       stdio: "pipe"
     });
-    const templatePath = path28.join(root, "node_modules", "@kuma-templates", name, "template.json");
-    if (fs27.existsSync(templatePath)) {
+    const templatePath = path30.join(root, "node_modules", "@kuma-templates", name, "template.json");
+    if (fs28.existsSync(templatePath)) {
       return await loadNpmTemplate(templatePath, name);
     }
     return [
@@ -11472,7 +12243,7 @@ async function tryInstallFromNpm(templateId) {
   }
 }
 async function loadNpmTemplate(templatePath, name) {
-  const raw = fs27.readFileSync(templatePath, "utf-8");
+  const raw = fs28.readFileSync(templatePath, "utf-8");
   const template = JSON.parse(raw);
   const db = await getDb();
   let nodeCount = 0;
@@ -11842,18 +12613,29 @@ async function handleInit(action, params) {
 }
 async function handleCore(action, params) {
   switch (action) {
-    case "grep":
-      return await handleSmartGrep(params);
-    case "read":
-      return await handleSmartFilePicker(params);
+    case "grep": {
+      const p = { ...params, outputMode: params.grepOutputMode || params.outputMode || "rich" };
+      return await handleSmartGrep(p);
+    }
+    case "read": {
+      const readParams = { ...params, outputMode: params.readOutputMode || params.outputMode || "rich" };
+      if (params.filePaths) {
+        readParams.files = params.filePaths;
+      }
+      return await handleSmartFilePicker(readParams);
+    }
     case "edit":
       return await handlePreciseDiffEditor(params);
     case "batch":
       return await handleBatchFileWriter(params);
     case "lsp":
       return await handleLspQuery({ ...params, action: params.lspAction });
+    case "find":
+      return await handleKumaFind(params);
+    case "stats":
+      return await handleKumaStats(params);
     default:
-      return `\u26A0\uFE0F Unknown action "${action}" for kuma_core. Use: grep, read, edit, batch, lsp`;
+      return `\u26A0\uFE0F Unknown action "${action}" for kuma_core. Use: grep, read, edit, batch, lsp, find, stats`;
   }
 }
 async function handleVerify(action, params) {
@@ -12237,26 +13019,34 @@ function registerAllTools(server) {
   });
   server.tool(
     "kuma_core",
-    "Core coding tools: grep (search), read (file), edit (search-and-replace), batch (create files), lsp (rename/reference).",
+    "Core coding tools: grep (search code), read (open file), edit (search-and-replace), batch (create files), lsp (rename/reference), find (files by name/pattern), stats (file/dir/project statistics).",
     {
-      action: z.enum(["grep", "read", "edit", "batch", "lsp"]).describe("Action: grep=search code, read=open file, edit=edit with safety, batch=create files, lsp=semantic analysis"),
+      action: z.enum(["grep", "read", "edit", "batch", "lsp", "find", "stats"]).describe("Action: grep=search code, read=open file, edit=edit with safety, batch=create files, lsp=semantic analysis, find=files by name, stats=file/dir/project stats"),
       // grep params
       query: z.string().optional().describe("Regex pattern for grep action"),
+      queries: z.array(z.string()).optional().describe("Multiple regex patterns (OR'd together, single pass)"),
       targetFolder: z.string().optional().describe("Target folder for grep"),
       maxResults: z.number().min(1).max(100).optional().default(30).describe("Max results"),
       extensions: z.array(z.string()).optional().describe("File extensions filter"),
+      contextLines: z.number().min(0).max(20).optional().default(1).describe("Context lines around match (grep) or jump-to-line (read)"),
+      filenamesOnly: z.boolean().optional().default(false).describe("Only show matching filenames (like grep -l)"),
+      countOnly: z.boolean().optional().default(false).describe("Only show match count per file (like grep -c)"),
+      grepOutputMode: z.enum(["rich", "raw", "json"]).optional().default("rich").describe("Output format for grep: rich=emojis, raw=compact, json=parseable"),
       // read params
       filePath: z.string().optional().describe("File path for read/edit/batch actions"),
+      filePaths: z.array(z.string()).optional().describe("Multiple file paths to read in one call"),
       startLine: z.number().min(1).optional().describe("Start line (1-indexed) for read"),
       endLine: z.number().min(1).optional().describe("End line (1-indexed) for read"),
       chunkStrategy: z.enum(["full", "smart", "outline"]).optional().default("smart").describe("Read strategy"),
-      // edit params
+      readOutputMode: z.enum(["rich", "raw"]).optional().default("rich").describe("Output format for read: rich=line numbers, raw=content only"),
+      // edit params — BATCH SUPPORTED: pass multiple edits[] in 1 call (faster than calling edit 5x)
       edits: z.array(z.object({
         searchBlock: z.string().min(1).describe("Code to replace"),
         replaceBlock: z.string().describe("Replacement code"),
         allowMultiple: z.boolean().optional().default(false).describe("Allow multiple replacements"),
         fuzzyThreshold: z.number().min(0).max(1).optional().default(0.85).describe("Fuzzy threshold")
-      })).min(1).max(10).optional().describe("Array of edits (for edit action)"),
+      })).min(1).max(10).optional().describe("Array of edits (for edit action) \u2014 batch multiple edits in 1 call for speed"),
+      safe: z.boolean().optional().default(true).describe("Safe mode: true=create backup + safety checks (default), false=skip backup for speed (40x faster, no rollback)"),
       dryRun: z.boolean().optional().default(false).describe("Preview without writing"),
       version: z.union([z.number().min(1), z.literal("list")]).optional().describe("Backup version for rollback"),
       scope: z.enum(["file", "dir", "edit-id", "commit"]).optional().describe("Rollback scope"),
@@ -12267,6 +13057,12 @@ function registerAllTools(server) {
         content: z.string().describe("File content"),
         instructions: z.string().min(1).describe("Reason for creating")
       })).min(1).max(15).optional().describe("Array of files (for batch action)"),
+      // find params
+      name: z.string().optional().describe("File name glob pattern for find action (e.g. '*seed*', '*.tsx')"),
+      path: z.string().optional().describe("Path glob pattern for find action (e.g. '**/utils/**', '*/seed*')"),
+      type: z.enum(["file", "dir", "both"]).optional().default("file").describe("Type filter for find: file=files only, dir=dirs only"),
+      // stats params
+      target: z.enum(["file", "dir", "project"]).optional().default("project").describe("Stats target: file=single file, dir=directory, project=entire project"),
       // lsp params
       line: z.number().min(0).optional().describe("Line number (0-indexed) for LSP"),
       character: z.number().min(0).optional().describe("Character position (0-indexed) for LSP"),
@@ -12602,23 +13398,23 @@ async function main() {
     });
     const output = formatInitResults(results);
     console.log(output);
-    const fs28 = await import("fs");
-    const path29 = await import("path");
-    const matchaSkills = path29.resolve(process.cwd(), "skills/matcha/SKILL.md");
-    const matchaAgents = path29.resolve(
+    const fs29 = await import("fs");
+    const path31 = await import("path");
+    const matchaSkills = path31.resolve(process.cwd(), "skills/matcha/SKILL.md");
+    const matchaAgents = path31.resolve(
       process.cwd(),
       ".agents/skills/matcha/SKILL.md"
     );
-    const matchaRootSkills = path29.resolve(
+    const matchaRootSkills = path31.resolve(
       process.cwd(),
       "skills/matcha/SKILL.md"
     );
-    const matchaAgentsMd = path29.resolve(process.cwd(), "AGENTS.md");
-    const matchaWindsurfRules = path29.resolve(
+    const matchaAgentsMd = path31.resolve(process.cwd(), "AGENTS.md");
+    const matchaWindsurfRules = path31.resolve(
       process.cwd(),
       ".windsurfrules"
     );
-    if (fs28.existsSync(matchaSkills) || fs28.existsSync(matchaAgents) || fs28.existsSync(matchaRootSkills) || fs28.existsSync(matchaAgentsMd) || fs28.existsSync(matchaWindsurfRules)) {
+    if (fs29.existsSync(matchaSkills) || fs29.existsSync(matchaAgents) || fs29.existsSync(matchaRootSkills) || fs29.existsSync(matchaAgentsMd) || fs29.existsSync(matchaWindsurfRules)) {
       console.error(
         "\n\u{1F375} Hey, I see matcha is installed \u2014 they pair well together!"
       );
@@ -12632,13 +13428,13 @@ async function main() {
   (async () => {
     try {
       const { generateInitMdContent } = await import("./init-INY6XOQT.js");
-      const fs28 = await import("fs");
-      const path29 = await import("path");
-      const initMdPath = path29.resolve(process.cwd(), ".kuma/init.md");
-      if (!fs28.existsSync(initMdPath)) {
-        const kumaDir = path29.dirname(initMdPath);
-        if (!fs28.existsSync(kumaDir)) fs28.mkdirSync(kumaDir, { recursive: true });
-        fs28.writeFileSync(initMdPath, generateInitMdContent(), "utf-8");
+      const fs29 = await import("fs");
+      const path31 = await import("path");
+      const initMdPath = path31.resolve(process.cwd(), ".kuma/init.md");
+      if (!fs29.existsSync(initMdPath)) {
+        const kumaDir = path31.dirname(initMdPath);
+        if (!fs29.existsSync(kumaDir)) fs29.mkdirSync(kumaDir, { recursive: true });
+        fs29.writeFileSync(initMdPath, generateInitMdContent(), "utf-8");
         console.error(`[${SERVER_NAME}] Auto-generated .kuma/init.md`);
       }
     } catch (err) {
@@ -12649,8 +13445,8 @@ async function main() {
     try {
       const { detectAgent, getSkillPath, getAgentLabel } = await import("./agentDetector-HROEABDO.js");
       const { generateSkill, getSecondaryFiles } = await import("./skillGenerator-F6YO4H5D.js");
-      const fs28 = await import("fs");
-      const path29 = await import("path");
+      const fs29 = await import("fs");
+      const path31 = await import("path");
       const detection = detectAgent();
       if (!detection.primary) {
         console.error(`[${SERVER_NAME}] No AI agent detected \u2014 skipping auto-skill creation`);
@@ -12658,22 +13454,22 @@ async function main() {
       }
       const agentType = detection.primary;
       const skillPath = getSkillPath(agentType);
-      const fullPath = path29.resolve(process.cwd(), skillPath);
-      if (fs28.existsSync(fullPath)) {
+      const fullPath = path31.resolve(process.cwd(), skillPath);
+      if (fs29.existsSync(fullPath)) {
         console.error(`[${SERVER_NAME}] Skill exists for ${getAgentLabel(agentType)} \u2014 skipping`);
         return;
       }
-      const dir = path29.dirname(fullPath);
-      if (!fs28.existsSync(dir)) fs28.mkdirSync(dir, { recursive: true });
-      fs28.writeFileSync(fullPath, generateSkill(agentType), "utf-8");
+      const dir = path31.dirname(fullPath);
+      if (!fs29.existsSync(dir)) fs29.mkdirSync(dir, { recursive: true });
+      fs29.writeFileSync(fullPath, generateSkill(agentType), "utf-8");
       console.error(`[${SERVER_NAME}] Auto-created ${skillPath} for ${getAgentLabel(agentType)}`);
       const secondaryFiles = getSecondaryFiles(agentType);
       for (const sf of secondaryFiles) {
-        const sfPath = path29.resolve(process.cwd(), sf.path);
-        const sfDir = path29.dirname(sfPath);
-        if (!fs28.existsSync(sfPath)) {
-          if (!fs28.existsSync(sfDir)) fs28.mkdirSync(sfDir, { recursive: true });
-          fs28.writeFileSync(sfPath, sf.content, "utf-8");
+        const sfPath = path31.resolve(process.cwd(), sf.path);
+        const sfDir = path31.dirname(sfPath);
+        if (!fs29.existsSync(sfPath)) {
+          if (!fs29.existsSync(sfDir)) fs29.mkdirSync(sfDir, { recursive: true });
+          fs29.writeFileSync(sfPath, sf.content, "utf-8");
           console.error(`[${SERVER_NAME}] Auto-created ${sf.path}`);
         }
       }