@plumpslabs/kuma 2.2.6 → 2.2.8

package/dist/index.js

@@ -104,12 +104,89 @@ function isRipgrepAvailable() {
 function quotePath(p) {
   return `"${p.replace(/"/g, '\\"')}"`;
 }
+async function searchInSingleFile(filePath, patterns, opts) {
+  const { maxResults, contextLines, filenamesOnly, countOnly, outputMode, compact } = opts;
+  const validation = validateFilePath(filePath);
+  if (!validation.valid) {
+    return compact ? `ERR:${filePath} - invalid path` : `Error: ${validation.error.message}`;
+  }
+  const resolvedPath = validation.resolvedPath;
+  if (!fs.existsSync(resolvedPath)) {
+    return compact ? `ERR:not found ${filePath}` : `Error: File not found: ${filePath}`;
+  }
+  const stat = fs.statSync(resolvedPath);
+  if (stat.size > 5e5) {
+    return compact ? `ERR:too large ${filePath}` : `Error: File too large (${(stat.size / 1024).toFixed(0)}KB). Use a more specific query.`;
+  }
+  if (isBinaryFile(resolvedPath)) {
+    return compact ? `ERR:binary ${filePath}` : `Error: Cannot search binary file: ${filePath}`;
+  }
+  const projectRoot = getProjectRoot();
+  const relativePath = resolvedPath.startsWith(projectRoot + "/") ? resolvedPath.slice(projectRoot.length + 1) : resolvedPath;
+  try {
+    const content = fs.readFileSync(resolvedPath, "utf-8");
+    const lines = content.split("\n");
+    const regex = createCombinedRegex(patterns);
+    const results = [];
+    const maxFileResults = Math.min(maxResults, 100);
+    let matchCount = 0;
+    for (let i = 0; i < lines.length; i++) {
+      if (results.length >= maxFileResults) break;
+      if (regex.test(lines[i])) {
+        matchCount++;
+        if (filenamesOnly) {
+          return relativePath;
+        }
+        if (countOnly) continue;
+        const ctxLines = [];
+        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 ? ">" : " ";
+          ctxLines.push(`${prefix}${ci + 1}: ${lines[ci].substring(0, 200)}`);
+        }
+        results.push({
+          file: relativePath,
+          line: i + 1,
+          content: ctxLines.join("\n")
+        });
+      }
+    }
+    if (countOnly) {
+      const counts = `${filePath}:${matchCount}`;
+      if (outputMode === "json") return JSON.stringify({ [filePath]: matchCount });
+      if (compact) return counts;
+      return `\u{1F4CA} Count results for "${patterns[0]}":
+${counts}`;
+    }
+    if (matchCount === 0) {
+      if (outputMode === "json") return JSON.stringify({ query: patterns[0], matches: 0 });
+      if (compact) return `0:${patterns[0]}`;
+      return `\u{1F50D} No matches for "${patterns[0]}" in ${filePath}.`;
+    }
+    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);
+    }
+    const header = `\u{1F50D} Smart Grep: "${patterns[0]}" \u2014 ${filePath}
+\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);
+  } catch (err) {
+    return compact ? `ERR:reading ${filePath}` : `Error reading file "${filePath}": ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
 async function handleSmartGrep(params) {
   const {
     query,
     queries,
     targetFolder,
     maxResults = 30,
+    filePath,
     extensions,
     contextLines = 1,
     filenamesOnly = false,
@@ -121,7 +198,7 @@ async function handleSmartGrep(params) {
   if (patterns.length === 0 || patterns[0].length < 1) {
     return compact ? "ERR:query required" : "Error: 'query' or 'queries' parameter is required.";
   }
-  const cacheKey = `${patterns.join("||")}:${targetFolder ?? "root"}:${maxResults}:${contextLines}:${filenamesOnly}:${countOnly}:${outputMode}:${extensions ? extensions.join(",") : ""}`;
+  const cacheKey = `${patterns.join("||")}:${filePath ?? ""}:${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: patterns[0], cached: true });
@@ -129,7 +206,16 @@ async function handleSmartGrep(params) {
   }
   const projectRoot = getProjectRoot();
   let result;
-  if (isRipgrepAvailable()) {
+  if (filePath) {
+    result = await searchInSingleFile(filePath, patterns, {
+      maxResults,
+      contextLines,
+      filenamesOnly,
+      countOnly,
+      outputMode,
+      compact
+    });
+  } else if (isRipgrepAvailable()) {
     result = await tryRipgrep(patterns, {
       projectRoot,
       targetFolder,
@@ -760,11 +846,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 });
   }
@@ -776,11 +899,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}".
@@ -792,6 +917,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) {
@@ -817,6 +958,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)}`;
@@ -1196,10 +1340,10 @@ File "${filePath}" restored from backup: "${relBackupPath}".`;
 }
 async function handleCommitRollback(filePath, version) {
   try {
-    const { execSync: execSync11 } = await import("child_process");
+    const { execSync: execSync13 } = await import("child_process");
     const root = getProjectRoot();
     if (version === "list") {
-      const log = execSync11("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:**`,
@@ -1209,7 +1353,7 @@ async function handleCommitRollback(filePath, version) {
         `\u{1F4A1} Use { action: "rollback", scope: "commit", version: <N> } to restore a specific commit.`
       ].join("\n");
     }
-    const status = execSync11("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.**`,
@@ -1230,10 +1374,10 @@ async function handleCommitRollback(filePath, version) {
       target = "HEAD~1";
     }
     if (filePath) {
-      execSync11(`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 {
-      execSync11(`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) {
@@ -1509,13 +1653,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) {
@@ -1546,7 +2096,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 ?? {};
@@ -1591,11 +2141,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");
@@ -1614,7 +2164,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 ?? {};
@@ -1638,8 +2188,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)) {
@@ -1659,22 +2209,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)
@@ -1690,8 +2240,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")) {
@@ -1712,7 +2262,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 ?? {};
@@ -1733,7 +2283,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 ?? {};
@@ -1746,22 +2296,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;
@@ -1772,15 +2322,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() {
@@ -1789,26 +2339,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;
@@ -1818,22 +2368,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"]);
@@ -1852,7 +2402,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";
@@ -1866,7 +2416,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 };
@@ -1883,14 +2433,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";
@@ -1903,7 +2453,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";
@@ -1917,7 +2467,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";
@@ -1925,7 +2475,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 {
@@ -1935,7 +2485,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 {
@@ -1944,7 +2494,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";
@@ -1955,10 +2505,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";
@@ -1969,7 +2519,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";
@@ -1984,7 +2534,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 ?? {};
@@ -2008,25 +2558,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()) {
@@ -2217,7 +2767,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.
@@ -2225,13 +2775,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;
@@ -2317,9 +2867,9 @@ function formatTimeoutResult(command, timeout) {
 }
 
 // src/agents/codeReviewer.ts
-import fs7 from "fs";
-import path7 from "path";
-import { execSync as execSync2 } from "child_process";
+import fs8 from "fs";
+import path9 from "path";
+import { execSync as execSync4 } from "child_process";
 var CODE_EXTENSIONS = [
   ".ts",
   ".tsx",
@@ -2349,7 +2899,7 @@ var CONFIG_EXTENSIONS = [
 function getGitChangedFiles() {
   try {
     const root = getProjectRoot();
-    const stdout = execSync2("git status --porcelain", {
+    const stdout = execSync4("git status --porcelain", {
       cwd: root,
       encoding: "utf-8"
     });
@@ -2362,7 +2912,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);
@@ -2399,7 +2949,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,
@@ -2411,7 +2961,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) {
@@ -2509,12 +3059,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,
@@ -2716,7 +3266,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);
@@ -2727,7 +3277,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 {
@@ -3453,10 +4003,10 @@ function formatConventionsOutput(conventions) {
 }
 
 // src/utils/gitUtils.ts
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 function runGitCommand(command) {
   const root = getProjectRoot();
-  return execSync3(command, {
+  return execSync5(command, {
     cwd: root,
     encoding: "utf-8",
     maxBuffer: 2 * 1024 * 1024
@@ -3584,8 +4134,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",
@@ -3603,7 +4153,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,
@@ -3615,14 +4165,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"),
@@ -3645,7 +4195,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;
   }
@@ -3654,12 +4204,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;
     }
@@ -3670,11 +4220,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);
@@ -3705,7 +4255,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);
@@ -3716,8 +4266,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();
@@ -3810,11 +4360,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 = [
@@ -3825,20 +4375,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 {
   }
@@ -3894,18 +4444,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 {
@@ -3929,7 +4479,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 = [];
@@ -4112,7 +4662,7 @@ function formatToolNotAvailable(requested, available) {
 }
 
 // src/utils/kumaShared.ts
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 function getSessionStats(inputGoal) {
   const summary = sessionMemory.getSummary();
   const goal = inputGoal || summary.currentGoal || "";
@@ -4134,7 +4684,7 @@ function getSessionStats(inputGoal) {
 function getGitDiffStat(timeout = 3e3) {
   try {
     const root = getProjectRoot();
-    return execSync4("git diff --stat", {
+    return execSync6("git diff --stat", {
       cwd: root,
       encoding: "utf-8",
       timeout
@@ -4407,8 +4957,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();
@@ -4416,27 +4966,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();
@@ -4444,7 +4994,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++;
@@ -4524,9 +5074,9 @@ function formatHealthDashboard(r) {
 }
 
 // src/guards/antiPatternDetector.ts
-import fs11 from "fs";
-import path11 from "path";
-import { execSync as execSync5 } from "child_process";
+import fs12 from "fs";
+import path13 from "path";
+import { execSync as execSync7 } from "child_process";
 var SCRIPT_PATCH_PATTERNS = [
   "writeFileSync",
   "writeFile",
@@ -4552,20 +5102,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
@@ -4599,15 +5149,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;
@@ -4620,7 +5170,7 @@ function scanRecentFiles(projectRoot) {
 function detectGitPatchScripts(projectRoot) {
   const warnings = [];
   try {
-    const statusStdout = execSync5("git status --porcelain", {
+    const statusStdout = execSync7("git status --porcelain", {
       cwd: projectRoot,
       encoding: "utf-8",
       timeout: 3e3
@@ -4631,14 +5181,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({
@@ -4653,7 +5203,7 @@ function detectGitPatchScripts(projectRoot) {
         }
       }
     }
-    const deletedStdout = execSync5("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
@@ -4661,7 +5211,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",
@@ -4721,21 +5271,21 @@ function detectAllAntiPatterns() {
 }
 
 // src/engine/contextSnapshot.ts
-import fs12 from "fs";
-import path12 from "path";
-import { execSync as execSync6 } 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 {
@@ -4756,7 +5306,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 });
@@ -4764,12 +5314,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;
@@ -4812,7 +5362,7 @@ function formatSnapshot(snapshot) {
 function getGitDiffStat2() {
   try {
     const root = getProjectRoot();
-    const stdout = execSync6("git diff --stat", {
+    const stdout = execSync8("git diff --stat", {
       cwd: root,
       encoding: "utf-8",
       timeout: 3e3
@@ -4957,25 +5507,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 {
         }
@@ -5019,9 +5569,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) {
@@ -5055,7 +5605,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,
@@ -5074,11 +5624,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;
@@ -5202,8 +5752,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()" },
@@ -5290,12 +5840,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] };
@@ -5311,12 +5861,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 = {
@@ -5427,8 +5977,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",
@@ -5454,15 +6004,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) {
@@ -5579,9 +6129,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",
@@ -5677,8 +6227,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 = [];
@@ -5722,8 +6272,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",
@@ -5741,8 +6291,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",
@@ -5964,8 +6514,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;
@@ -5978,13 +6528,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();
@@ -6001,10 +6551,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}`);
   }
@@ -6111,26 +6661,26 @@ function createSchema(db) {
 }
 
 // src/engine/kumaSelfHeal.ts
-import { execSync as execSync7 } 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);
@@ -6138,7 +6688,7 @@ function contentFingerprint(filePath) {
       hash.update(String(size));
       return hash.digest("hex");
     } finally {
-      fs19.closeSync(fd);
+      fs20.closeSync(fd);
     }
   } catch {
     return null;
@@ -6147,8 +6697,8 @@ function contentFingerprint(filePath) {
 function findByFingerprint(fingerprint, oldName) {
   try {
     const root = getProjectRoot();
-    const ext = path19.extname(oldName);
-    const result = execSync7(
+    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();
@@ -6181,8 +6731,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({
@@ -6195,7 +6745,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,
@@ -6216,7 +6766,7 @@ async function detectStaleNodes() {
 function findRenamedPath(oldPath) {
   try {
     const root = getProjectRoot();
-    const output = execSync7(
+    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();
@@ -6297,8 +6847,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;
@@ -6827,8 +7377,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;
@@ -6866,8 +7416,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"], {
@@ -6929,19 +7479,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;
         }
       }
@@ -6963,7 +7513,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 = "";
     }
@@ -7180,8 +7730,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);
@@ -7189,7 +7739,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()) {
@@ -7214,7 +7764,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 {
@@ -7230,11 +7780,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}`;
@@ -7255,7 +7805,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()) {
@@ -7278,10 +7828,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 {
@@ -7313,7 +7863,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()) {
@@ -7344,7 +7894,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;
@@ -7358,10 +7908,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) {
@@ -7388,14 +7938,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) {
@@ -7403,7 +7953,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 = [];
@@ -7438,7 +7988,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}\``,
       "",
@@ -7479,7 +8029,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;
@@ -7497,9 +8047,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,
@@ -7510,7 +8060,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])) {
@@ -7539,7 +8089,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("");
@@ -7556,7 +8106,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}`);
@@ -7571,9 +8121,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,
@@ -7590,14 +8140,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}\``,
@@ -7620,11 +8170,11 @@ Cannot find definition.`;
 }
 
 // src/engine/kumaTimeMachine.ts
-import { execSync as execSync8 } from "child_process";
+import { execSync as execSync10 } from "child_process";
 function getBlameForFile(filePath) {
   const root = getProjectRoot();
   try {
-    const output = execSync8(
+    const output = execSync10(
       `git blame --line-porcelain -- "${filePath}"`,
       { cwd: root, encoding: "utf-8", maxBuffer: 2 * 1024 * 1024, timeout: 1e4 }
     );
@@ -7670,7 +8220,7 @@ function getBlameForFile(filePath) {
 function getFileHistory(filePath, maxCount = 20) {
   const root = getProjectRoot();
   try {
-    const output = execSync8(
+    const output = execSync10(
       `git log --follow --format="%H||%an||%ai||%s" --shortstat -- "${filePath}"`,
       { cwd: root, encoding: "utf-8", maxBuffer: 2 * 1024 * 1024, timeout: 1e4 }
     );
@@ -7705,7 +8255,7 @@ async function getSymbolTimeline(symbolName, filePath, symbolType = "function")
     const blame = getBlameForFile(filePath);
     const pattern = getSymbolPattern(symbolName, symbolType);
     const root = getProjectRoot();
-    const content = execSync8(`git show HEAD:"${filePath}"`, {
+    const content = execSync10(`git show HEAD:"${filePath}"`, {
       cwd: root,
       encoding: "utf-8",
       maxBuffer: 2 * 1024 * 1024,
@@ -7732,7 +8282,7 @@ async function getSymbolTimeline(symbolName, filePath, symbolType = "function")
     const entries = [];
     for (const [hash, data] of commitMap) {
       try {
-        const msg = execSync8(
+        const msg = execSync10(
           `git log -1 --format="%s" ${hash}`,
           { cwd: root, encoding: "utf-8", maxBuffer: 1024 * 1024, timeout: 3e3 }
         ).trim();
@@ -7917,10 +8467,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) || {
@@ -7929,7 +8479,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);
@@ -8037,9 +8587,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",
@@ -8130,8 +8680,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) => {
@@ -8142,7 +8692,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 {
         }
@@ -8153,10 +8703,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");
@@ -8227,7 +8777,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
@@ -8236,7 +8786,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) {
@@ -8249,16 +8799,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;
@@ -8342,20 +8892,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) {
@@ -8435,7 +8985,7 @@ function formatDecisionTemplate() {
 }
 
 // src/engine/kumaContextEngine.ts
-import { execSync as execSync9 } from "child_process";
+import { execSync as execSync11 } from "child_process";
 var STOP_WORDS = /* @__PURE__ */ new Set([
   "the",
   "this",
@@ -8552,7 +9102,7 @@ async function searchNodesFts(db, terms) {
 function getFileRecencySeconds(filePath) {
   try {
     const escapedPath = filePath.replace(/"/g, '\\"');
-    const result = execSync9(
+    const result = execSync11(
       'git log -1 --format=%ct -- "' + escapedPath + '" 2>/dev/null || echo 0',
       { encoding: "utf-8", timeout: 2e3 }
     );
@@ -9269,9 +9819,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}";
@@ -9312,8 +9862,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();
@@ -9322,7 +9872,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++;
@@ -9350,12 +9900,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);
           }
@@ -9465,9 +10015,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)) {
@@ -9767,72 +10317,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 {
@@ -9843,9 +10393,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 };
@@ -9855,16 +10405,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 {
       }
@@ -10212,13 +10762,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'");
@@ -11067,14 +11617,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 {
@@ -11094,12 +11644,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";
@@ -11206,13 +11756,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";
@@ -11368,9 +11918,9 @@ function formatCollectivePatterns(patterns) {
 }
 
 // src/engine/kumaMarketplace.ts
-import { execSync as execSync10 } 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) ──
   {
@@ -11585,7 +12135,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"] },
@@ -11605,7 +12155,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;
       }
@@ -11650,17 +12200,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;
       }
@@ -11745,8 +12295,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 {
@@ -11754,14 +12304,14 @@ async function tryInstallFromNpm(templateId) {
   try {
     const npmPackage = `@kuma-templates/${name}`;
     const root = getProjectRoot();
-    execSync10(`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 [
@@ -11779,7 +12329,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;
@@ -12166,8 +12716,12 @@ async function handleCore(action, params) {
       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) {
@@ -12551,9 +13105,9 @@ 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)"),
@@ -12571,13 +13125,14 @@ function registerAllTools(server) {
       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"),
       readOutputMode: z.enum(["rich", "raw"]).optional().default("rich").describe("Output format for read: rich=line numbers, raw=content only"),
-      // edit params
+      // 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"),
@@ -12588,6 +13143,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"),
@@ -12923,23 +13484,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!"
       );
@@ -12953,13 +13514,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) {
@@ -12970,8 +13531,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`);
@@ -12979,22 +13540,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}`);
         }
       }