@plumpslabs/kuma 2.1.5 → 2.2.0

package/dist/index.js

@@ -1,14 +1,23 @@
 #!/usr/bin/env node
+import {
+  getSessionMemory,
+  handleWriteMemory,
+  searchSessionMemory,
+  sessionMemory
+} from "./chunk-QPVPFUCQ.js";
 import {
   ALL_CONFIG_TYPES,
-  ensureBackupDir,
   formatInitResults,
+  runInit
+} from "./chunk-EM6IK2TB.js";
+import {
+  ensureBackupDir,
   getBackupPath,
+  getKumaDir,
   getProjectRoot,
-  runInit,
   validateFileExtension,
   validateFilePath
-} from "./chunk-2BFTJMBP.js";
+} from "./chunk-7Q3YUJSM.js";
 
 // src/index.ts
 import { readFileSync } from "fs";
@@ -21,8 +30,8 @@ import { z } from "zod";
 
 // src/tools/smartGrep.ts
 import fg from "fast-glob";
-import fs2 from "fs";
-import path2 from "path";
+import fs from "fs";
+import path from "path";
 
 // src/utils/tokenCounter.ts
 function estimateTokens(text) {
@@ -46,611 +55,6 @@ function limitLines(text, maxLines) {
 [...${lines.length - maxLines} more lines truncated]`;
 }
 
-// src/engine/sessionMemory.ts
-import fs from "fs";
-import path from "path";
-var SessionMemory = class {
-  state;
-  initialized = false;
-  init(config) {
-    const kumaDir = path.join(config.projectRoot, ".kuma");
-    const sessionFile = path.join(kumaDir, "memory.json");
-    const oldFile = path.join(kumaDir, ".kuma-memory.json");
-    if (fs.existsSync(oldFile) && !fs.existsSync(sessionFile)) {
-      try {
-        fs.renameSync(oldFile, sessionFile);
-        console.error("[SessionMemory] Migrated .kuma-memory.json \u2192 memory.json");
-      } catch {
-      }
-    }
-    const oldSessionFile = path.join(kumaDir, "session.json");
-    if (fs.existsSync(oldSessionFile) && !fs.existsSync(sessionFile)) {
-      try {
-        fs.renameSync(oldSessionFile, sessionFile);
-        console.error("[SessionMemory] Migrated session.json \u2192 memory.json");
-      } catch {
-      }
-    }
-    if (fs.existsSync(sessionFile)) {
-      try {
-        const raw = fs.readFileSync(sessionFile, "utf-8");
-        const parsed = JSON.parse(raw);
-        this.state = {
-          projectRoot: parsed.projectRoot || config.projectRoot,
-          startTime: parsed.startTime || config.startTime,
-          currentGoal: parsed.currentGoal || "",
-          completedSteps: parsed.completedSteps || [],
-          modifiedFiles: new Map(parsed.modifiedFiles || []),
-          failedFiles: new Map(parsed.failedFiles || []),
-          searchResults: new Map(parsed.searchResults || []),
-          dependencyGraph: new Map(parsed.dependencyGraph || []),
-          toolCalls: parsed.toolCalls || [],
-          conventions: parsed.conventions
-        };
-        this.initialized = true;
-        console.error(`[SessionMemory] Loaded persistent session memory.json`);
-        return;
-      } catch (err) {
-        console.error(`[SessionMemory] Failed to load persistent session: ${err}. Re-initializing.`);
-      }
-    }
-    this.state = {
-      projectRoot: config.projectRoot,
-      startTime: config.startTime,
-      currentGoal: "",
-      completedSteps: [],
-      modifiedFiles: /* @__PURE__ */ new Map(),
-      failedFiles: /* @__PURE__ */ new Map(),
-      searchResults: /* @__PURE__ */ new Map(),
-      dependencyGraph: /* @__PURE__ */ new Map(),
-      toolCalls: []
-    };
-    this.initialized = true;
-    this.save();
-    this.ensureMemoriesDir();
-    console.error(`[SessionMemory] Initialized at ${new Date(config.startTime).toISOString()}`);
-  }
-  memoriesDir() {
-    return path.join(this.state.projectRoot, ".kuma", "memories");
-  }
-  ensureMemoriesDir() {
-    const dir = this.memoriesDir();
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-  }
-  memoryFilePath(topic) {
-    return path.join(this.memoriesDir(), `${topic}.md`);
-  }
-  getMemoryContent(topic) {
-    this.ensureInit();
-    this.ensureMemoriesDir();
-    const filePath = this.memoryFilePath(topic);
-    if (fs.existsSync(filePath)) {
-      return fs.readFileSync(filePath, "utf-8");
-    }
-    return this.generateMemory(topic);
-  }
-  writeMemory(topic, content) {
-    this.ensureInit();
-    this.ensureMemoriesDir();
-    this.writeMemoryFile(topic, content);
-  }
-  writeMemoryFile(topic, content) {
-    const filePath = this.memoryFilePath(topic);
-    fs.writeFileSync(filePath, content, "utf-8");
-  }
-  generateMemory(topic) {
-    switch (topic) {
-      case "architecture":
-        return this.generateArchitectureMd();
-      case "conventions":
-        return this.generateConventionsMd();
-      case "known-issues":
-        return this.generateKnownIssuesMd();
-      default:
-        return `# ${topic}
-
-(empty)`;
-    }
-  }
-  generateArchitectureMd() {
-    const conv = this.state.conventions;
-    if (!conv) return `# Architecture
-
-Run project_conventions first to auto-generate.`;
-    const stackKeys = ["framework", "projectType", "monorepo", "buildTool", "packageManager"];
-    const lines = [
-      "# Architecture",
-      "",
-      `Generated at ${(/* @__PURE__ */ new Date()).toISOString()}`,
-      "",
-      "## Stack",
-      ""
-    ];
-    for (const key of stackKeys) {
-      if (conv[key] !== void 0) {
-        lines.push(`- **${key}**: ${JSON.stringify(conv[key])}`);
-      }
-    }
-    lines.push("", "## Project Layout", "");
-    if (conv.workspaces) {
-      lines.push(`- Monorepo workspaces: ${JSON.stringify(conv.workspaces)}`);
-    }
-    lines.push(`- Source root: ${conv.srcDir || "src/"}`);
-    return lines.join("\n");
-  }
-  generateConventionsMd() {
-    const conv = this.state.conventions;
-    if (!conv) return `# Conventions
-
-Run project_conventions first to auto-generate.`;
-    const styleKeys = ["testRunner", "styling", "importAlias", "lintConfig", "codeStyle"];
-    const lines = [
-      "# Conventions",
-      "",
-      `Generated at ${(/* @__PURE__ */ new Date()).toISOString()}`,
-      "",
-      "## Code Style",
-      ""
-    ];
-    for (const key of styleKeys) {
-      if (conv[key] !== void 0) {
-        lines.push(`- **${key}**: ${JSON.stringify(conv[key])}`);
-      }
-    }
-    if (conv.testRunner) {
-      lines.push("", `## Testing
-
-- Test runner: ${conv.testRunner}`);
-    }
-    if (conv.importAlias) {
-      lines.push("", `## Imports
-
-- Alias: \`${conv.importAlias}\``);
-    }
-    return lines.join("\n");
-  }
-  generateKnownIssuesMd() {
-    const allFailures = this.getFailedFiles();
-    const unresolved = allFailures.filter((f) => f.failures.some((ff) => !ff.resolved));
-    if (unresolved.length === 0) return `# Known Issues
-
-No unresolved issues.`;
-    const lines = [
-      "# Known Issues",
-      "",
-      `Generated at ${(/* @__PURE__ */ new Date()).toISOString()}`,
-      ""
-    ];
-    for (const f of unresolved) {
-      lines.push(`## ${f.task}`);
-      for (const ff of f.failures) {
-        if (!ff.resolved) {
-          lines.push(`- ${new Date(ff.timestamp).toISOString()}: ${ff.error}`);
-        }
-      }
-      lines.push("");
-    }
-    return lines.join("\n");
-  }
-  save() {
-    if (!this.initialized || !this.state) return;
-    try {
-      const kumaDir = path.join(this.state.projectRoot, ".kuma");
-      if (!fs.existsSync(kumaDir)) {
-        fs.mkdirSync(kumaDir, { recursive: true });
-      }
-      const serialized = {
-        projectRoot: this.state.projectRoot,
-        startTime: this.state.startTime,
-        currentGoal: this.state.currentGoal,
-        completedSteps: this.state.completedSteps,
-        modifiedFiles: Array.from(this.state.modifiedFiles.entries()),
-        failedFiles: Array.from(this.state.failedFiles.entries()),
-        searchResults: Array.from(this.state.searchResults.entries()),
-        dependencyGraph: Array.from(this.state.dependencyGraph.entries()),
-        toolCalls: this.state.toolCalls,
-        conventions: this.state.conventions
-      };
-      fs.writeFileSync(path.join(kumaDir, "memory.json"), JSON.stringify(serialized, null, 2), "utf-8");
-    } catch (err) {
-      console.error(`[SessionMemory] Failed to save session: ${err}`);
-    }
-  }
-  setGoal(goal) {
-    this.ensureInit();
-    this.state.currentGoal = goal;
-    this.save();
-  }
-  addCompletedStep(step) {
-    this.ensureInit();
-    if (!this.state.completedSteps.includes(step)) {
-      this.state.completedSteps.push(step);
-      this.save();
-    }
-  }
-  addModifiedFile(filePath) {
-    this.ensureInit();
-    const existing = this.state.modifiedFiles.get(filePath);
-    if (existing) {
-      existing.modifiedAt = Date.now();
-      existing.status = "modified";
-    } else {
-      this.state.modifiedFiles.set(filePath, {
-        filePath,
-        modifiedAt: Date.now(),
-        status: "modified"
-      });
-    }
-    this.save();
-  }
-  addCreatedFile(filePath) {
-    this.ensureInit();
-    this.state.modifiedFiles.set(filePath, {
-      filePath,
-      modifiedAt: Date.now(),
-      status: "created"
-    });
-    this.save();
-  }
-  addFailedFile(task, error) {
-    this.ensureInit();
-    const trimmedError = error?.trim() ?? "";
-    if (!trimmedError) return;
-    const truncatedError = trimmedError.substring(0, 500);
-    const failures = this.state.failedFiles.get(task) ?? [];
-    const lastUnresolved = [...failures].reverse().find((f) => !f.resolved);
-    if (lastUnresolved && lastUnresolved.error === truncatedError) return;
-    failures.push({
-      task,
-      error: truncatedError,
-      timestamp: Date.now(),
-      resolved: false
-    });
-    this.state.failedFiles.set(task, failures);
-    this.save();
-    this.ensureMemoriesDir();
-    this.writeMemoryFile("known-issues", this.generateKnownIssuesMd());
-  }
-  markFailureResolved(task) {
-    this.ensureInit();
-    const failures = this.state.failedFiles.get(task);
-    if (failures) {
-      let changed = false;
-      for (const f of failures) {
-        if (!f.resolved) {
-          f.resolved = true;
-          changed = true;
-        }
-      }
-      if (changed) {
-        this.save();
-        this.ensureMemoriesDir();
-        this.writeMemoryFile("known-issues", this.generateKnownIssuesMd());
-      }
-    }
-  }
-  addSearchResult(query, files) {
-    this.ensureInit();
-    this.state.searchResults.set(query, files);
-    this.save();
-  }
-  addDependency(file, dependsOn) {
-    this.ensureInit();
-    const deps = this.state.dependencyGraph.get(file) ?? [];
-    if (!deps.includes(dependsOn)) {
-      deps.push(dependsOn);
-      this.state.dependencyGraph.set(file, deps);
-      this.save();
-    }
-  }
-  recordToolCall(toolName, params) {
-    this.ensureInit();
-    this.state.toolCalls.push({
-      toolName,
-      params,
-      timestamp: Date.now()
-    });
-    if (this.state.toolCalls.length > 100) {
-      this.state.toolCalls = this.state.toolCalls.slice(-100);
-    }
-    this.save();
-  }
-  setConventions(conventions) {
-    this.ensureInit();
-    this.state.conventions = conventions;
-    this.save();
-    this.ensureMemoriesDir();
-    this.writeMemoryFile("architecture", this.generateArchitectureMd());
-    this.writeMemoryFile("conventions", this.generateConventionsMd());
-  }
-  // ============================================================
-  // KEYWORD SEARCH — Search session memory content
-  // ============================================================
-  /**
-   * Load previous session data into current session.
-   * Called by kuma_init() to hydrate conventions, failures, and modified files
-   * from a prior session stored in memory.json.
-   */
-  loadSession() {
-    this.ensureInit();
-    const kumaDir = path.join(this.state.projectRoot, ".kuma");
-    const sessionFile = path.join(kumaDir, "memory.json");
-    if (!fs.existsSync(sessionFile)) {
-      return { hasPrevSession: false, toolCallCount: 0, hasConventions: !!this.state.conventions };
-    }
-    try {
-      const raw = fs.readFileSync(sessionFile, "utf-8");
-      const parsed = JSON.parse(raw);
-      if (!this.state.conventions && parsed.conventions) {
-        this.state.conventions = parsed.conventions;
-      }
-      const prevFailed = parsed.failedFiles;
-      if (prevFailed) {
-        for (const [task, failures] of prevFailed) {
-          for (const f of failures) {
-            if (!f.resolved) {
-              const existing = this.state.failedFiles.get(task);
-              if (!existing?.some((ef) => ef.error === f.error)) {
-                this.state.failedFiles.set(task, [...existing || [], f]);
-              }
-            }
-          }
-        }
-      }
-      const prevModified = parsed.modifiedFiles;
-      if (prevModified) {
-        for (const [filePath, mod] of prevModified) {
-          if (!this.state.modifiedFiles.has(filePath)) {
-            this.state.modifiedFiles.set(filePath, {
-              filePath,
-              modifiedAt: mod.modifiedAt,
-              status: mod.status
-            });
-          }
-        }
-      }
-      const prevSearch = parsed.searchResults;
-      if (prevSearch) {
-        for (const [query, files] of prevSearch) {
-          if (!this.state.searchResults.has(query)) {
-            this.state.searchResults.set(query, files);
-          }
-        }
-      }
-      const toolCallCount = parsed.toolCalls?.length ?? 0;
-      this.save();
-      return {
-        hasPrevSession: true,
-        toolCallCount,
-        hasConventions: !!this.state.conventions
-      };
-    } catch {
-      return { hasPrevSession: false, toolCallCount: 0, hasConventions: !!this.state.conventions };
-    }
-  }
-  /**
-   * Search through tool call history, memory files, search results,
-   * errors, and file modifications for a keyword.
-   */
-  searchMemory(query, limit = 20) {
-    this.ensureInit();
-    const results = [];
-    const q = query.toLowerCase();
-    for (const call of this.state.toolCalls) {
-      const paramStr = JSON.stringify(call.params);
-      if (call.toolName.toLowerCase().includes(q) || paramStr.toLowerCase().includes(q)) {
-        results.push({
-          type: `tool:${call.toolName}`,
-          content: `${call.toolName}(${JSON.stringify(call.params).substring(0, 200)})`,
-          timestamp: call.timestamp
-        });
-      }
-    }
-    for (const [queryStr, files] of this.state.searchResults) {
-      if (queryStr.toLowerCase().includes(q) || files.some((f) => f.toLowerCase().includes(q))) {
-        results.push({
-          type: "search",
-          content: `Query: "${queryStr}" \u2192 ${files.slice(0, 5).join(", ")}${files.length > 5 ? ` (+${files.length - 5} more)` : ""}`
-        });
-      }
-    }
-    for (const [, mod] of this.state.modifiedFiles) {
-      if (mod.filePath.toLowerCase().includes(q)) {
-        results.push({
-          type: `file:${mod.status}`,
-          content: `${mod.status.toUpperCase()}: ${mod.filePath}`,
-          timestamp: mod.modifiedAt
-        });
-      }
-    }
-    for (const [task, failures] of this.state.failedFiles) {
-      for (const f of failures) {
-        if (task.toLowerCase().includes(q) || f.error.toLowerCase().includes(q)) {
-          results.push({
-            type: `failure:${task}`,
-            content: `[${f.resolved ? "RESOLVED" : "UNRESOLVED"}] ${task}: ${f.error.substring(0, 200)}`,
-            timestamp: f.timestamp
-          });
-        }
-      }
-    }
-    for (const [file, deps] of this.state.dependencyGraph) {
-      if (file.toLowerCase().includes(q)) {
-        results.push({
-          type: "dependency",
-          content: `${file} depends on: ${deps.join(", ")}`
-        });
-      }
-    }
-    const memoriesDir = this.memoriesDir();
-    if (fs.existsSync(memoriesDir)) {
-      try {
-        const files = fs.readdirSync(memoriesDir);
-        for (const file of files) {
-          if (!file.endsWith(".md")) continue;
-          const filePath = path.join(memoriesDir, file);
-          try {
-            const content = fs.readFileSync(filePath, "utf-8");
-            const lines = content.split("\n");
-            for (let i = 0; i < lines.length; i++) {
-              if (lines[i].toLowerCase().includes(q)) {
-                const topicName = file.replace(/\.md$/, "");
-                results.push({
-                  type: `memory:${topicName}`,
-                  content: `[${topicName}] L${i + 1}: ${lines[i].trim().substring(0, 150)}`
-                });
-                if (results.filter((r) => r.type.startsWith("memory")).length >= 5) break;
-              }
-            }
-          } catch {
-          }
-        }
-      } catch {
-      }
-    }
-    results.sort((a, b) => {
-      if (a.timestamp && b.timestamp) return b.timestamp - a.timestamp;
-      if (a.timestamp) return -1;
-      if (b.timestamp) return 1;
-      return 0;
-    });
-    return results.slice(0, limit);
-  }
-  getConventions() {
-    this.ensureInit();
-    return this.state.conventions;
-  }
-  pruneMemory() {
-    this.ensureInit();
-    this.state.toolCalls = this.state.toolCalls.slice(-3);
-    this.state.searchResults.clear();
-    this.state.completedSteps = [];
-    this.save();
-  }
-  getSummary(topic) {
-    this.ensureInit();
-    if (topic) {
-      const content = this.getMemoryContent(topic);
-      return { topic, content };
-    }
-    const unresolvedFailures = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const [, failures] of this.state.failedFiles) {
-      for (const f of failures) {
-        if (f.resolved) continue;
-        const error = f.error.substring(0, 200);
-        if (!error.trim()) continue;
-        const key = `${f.task}::${error}`;
-        if (seen.has(key)) continue;
-        seen.add(key);
-        unresolvedFailures.push({ task: f.task, error });
-      }
-    }
-    const hasMemories = fs.existsSync(this.memoriesDir());
-    let availableMemories = [];
-    if (hasMemories) {
-      try {
-        availableMemories = fs.readdirSync(this.memoriesDir()).filter((f) => f.endsWith(".md")).map((f) => f.replace(/\.md$/, ""));
-      } catch {
-      }
-    }
-    return {
-      projectRoot: this.state.projectRoot,
-      sessionDuration: Math.round((Date.now() - this.state.startTime) / 1e3) + "s",
-      currentGoal: this.state.currentGoal,
-      completedSteps: this.state.completedSteps,
-      modifiedFiles: Array.from(this.state.modifiedFiles.values()),
-      unresolvedFailures,
-      toolCallCount: this.state.toolCalls.length,
-      recentSearches: Array.from(this.state.searchResults.keys()).slice(-5),
-      hasConventions: !!this.state.conventions,
-      ...availableMemories.length > 0 ? { availableMemories } : {},
-      ...availableMemories.length > 0 ? { hint: `Use get_session_memory({ topic: "<name>" }) to load a specific memory. Topics: ${availableMemories.join(", ")}` } : {}
-    };
-  }
-  getModifiedFiles() {
-    this.ensureInit();
-    return Array.from(this.state.modifiedFiles.values());
-  }
-  getFailedFiles() {
-    this.ensureInit();
-    const result = [];
-    for (const [task, failures] of this.state.failedFiles) {
-      result.push({ task, failures });
-    }
-    return result;
-  }
-  getToolCallHistory(limit = 10) {
-    this.ensureInit();
-    return this.state.toolCalls.slice(-limit);
-  }
-  detectLoop() {
-    this.ensureInit();
-    const recentCalls = this.state.toolCalls.slice(-10);
-    if (recentCalls.length < 6) return { isLooping: false };
-    const toolCounts = /* @__PURE__ */ new Map();
-    for (const call of recentCalls) {
-      toolCounts.set(call.toolName, (toolCounts.get(call.toolName) ?? 0) + 1);
-    }
-    for (const [toolName, count] of toolCounts) {
-      if (count >= 4) {
-        return {
-          isLooping: true,
-          toolName,
-          message: `Detected potential loop: "${toolName}" called ${count} times in last ${recentCalls.length} tool calls. Consider a different approach.`
-        };
-      }
-    }
-    return { isLooping: false };
-  }
-  ensureInit() {
-    if (!this.initialized) {
-      this.init({
-        projectRoot: process.cwd(),
-        startTime: Date.now()
-      });
-    }
-  }
-};
-var sessionMemory = new SessionMemory();
-function getSessionMemory(topic) {
-  return sessionMemory.getSummary(topic);
-}
-function searchSessionMemory(params) {
-  const { query, limit = 20 } = params;
-  sessionMemory.recordToolCall("search_session_memory", { query, limit });
-  const results = sessionMemory.searchMemory(query, limit);
-  if (results.length === 0) {
-    return `\u{1F50D} **Search Memory** \u2014 No results for "${query}".`;
-  }
-  const lines = [
-    `\u{1F50D} **Search Memory** \u2014 ${results.length} results for "${query}"`,
-    ""
-  ];
-  for (const r of results) {
-    const icon = r.type.startsWith("tool:") ? "\u{1F6E0}\uFE0F" : r.type.startsWith("file:") ? r.type.includes("created") ? "\u2728" : "\u{1F4DD}" : r.type.startsWith("failure") ? "\u274C" : r.type.startsWith("memory") ? "\u{1F9E0}" : r.type === "search" ? "\u{1F50E}" : r.type === "dependency" ? "\u{1F517}" : "\u{1F4C4}";
-    const timeStr = r.timestamp ? new Date(r.timestamp).toLocaleTimeString() : "";
-    lines.push(`${icon} ${timeStr ? `[${timeStr}] ` : ""}${r.content}`);
-  }
-  lines.push("", `\u{1F4A1} Use get_session_memory({topic: "..."}) to load a specific memory topic.`);
-  return lines.join("\n");
-}
-function handleWriteMemory(params) {
-  const { topic, content, mode = "append" } = params;
-  const existing = sessionMemory.getMemoryContent(topic);
-  let finalContent = content;
-  if (mode === "prepend") {
-    finalContent = content + "\n\n" + existing;
-  } else if (mode === "append") {
-    finalContent = existing + "\n\n" + content;
-  }
-  sessionMemory.writeMemory(topic, finalContent);
-  sessionMemory.recordToolCall("write_memory", { topic, mode });
-  return `\u2705 Memory "${topic}" updated (mode: ${mode}).`;
-}
-
 // src/tools/smartGrep.ts
 var IGNORE_PATTERNS = [
   "**/node_modules/**",
@@ -659,7 +63,7 @@ var IGNORE_PATTERNS = [
   "**/build/**",
   "**/.git/**",
   "**/.cache/**",
-  "**/.agent-backups/**",
+  "**/.kuma/backups/**",
   "**/*.min.js",
   "**/*.bundle.js",
   "**/*.map",
@@ -694,7 +98,7 @@ async function handleSmartGrep(params) {
   }
   const projectRoot = getProjectRoot();
   try {
-    const searchPattern = targetFolder ? path2.join(targetFolder, "**/*").replace(/\\/g, "/") : "**/*";
+    const searchPattern = targetFolder ? path.join(targetFolder, "**/*").replace(/\\/g, "/") : "**/*";
     let entries = await fg(searchPattern, {
       cwd: projectRoot,
       ignore: IGNORE_PATTERNS,
@@ -710,7 +114,7 @@ async function handleSmartGrep(params) {
         (e) => e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`
       );
       entries = entries.filter((entry) => {
-        const ext = path2.extname(entry).toLowerCase();
+        const ext = path.extname(entry).toLowerCase();
         return normalizedExts.includes(ext);
       });
     }
@@ -726,11 +130,11 @@ async function handleSmartGrep(params) {
       if (results.length >= maxResults) break;
       filesScanned++;
       try {
-        const fullPath = path2.join(projectRoot, entry);
-        const stat = fs2.statSync(fullPath);
+        const fullPath = path.join(projectRoot, entry);
+        const stat = fs.statSync(fullPath);
         if (stat.size > 5e5) continue;
         if (isBinaryFile(fullPath)) continue;
-        const content = fs2.readFileSync(fullPath, "utf-8");
+        const content = fs.readFileSync(fullPath, "utf-8");
         const lines = content.split("\n");
         for (let i = 0; i < lines.length; i++) {
           if (results.length >= maxResults) break;
@@ -799,9 +203,9 @@ ${r.content.split("\n").map((l) => `    ${l}`).join("\n")}`;
 function isBinaryFile(filePath) {
   try {
     const buffer = Buffer.alloc(512);
-    const fd = fs2.openSync(filePath, "r");
-    const bytesRead = fs2.readSync(fd, buffer, 0, 512, 0);
-    fs2.closeSync(fd);
+    const fd = fs.openSync(filePath, "r");
+    const bytesRead = fs.readSync(fd, buffer, 0, 512, 0);
+    fs.closeSync(fd);
     for (let i = 0; i < bytesRead; i++) {
       if (buffer[i] === 0) return true;
     }
@@ -812,8 +216,8 @@ function isBinaryFile(filePath) {
 }
 
 // src/tools/smartFilePicker.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs2 from "fs";
+import path2 from "path";
 var MAX_FILE_SIZE = 1e6;
 var CHUNK_THRESHOLD = 300;
 async function handleSmartFilePicker(params) {
@@ -823,23 +227,23 @@ async function handleSmartFilePicker(params) {
     return "Error: " + validation.error.message;
   }
   const resolvedPath = validation.resolvedPath;
-  if (!fs3.existsSync(resolvedPath)) {
+  if (!fs2.existsSync(resolvedPath)) {
     const projectRoot = getProjectRoot();
     let suggestion;
-    if (!path3.isAbsolute(filePath)) {
-      const cwdPath = path3.resolve(process.cwd(), filePath);
+    if (!path2.isAbsolute(filePath)) {
+      const cwdPath = path2.resolve(process.cwd(), filePath);
       suggestion = "Path resolved to: " + resolvedPath + "\nCWD: " + process.cwd() + "\nProject root: " + projectRoot + "\nHint: Try path relative to project root, or relative to CWD (" + cwdPath + ")\nTry smart_grep first to locate the correct file.";
     } else {
       suggestion = "File does not exist. Try smart_grep to locate it.";
     }
     return 'Error: File not found: "' + filePath + '".\n' + suggestion;
   }
-  const stat = fs3.statSync(resolvedPath);
+  const stat = fs2.statSync(resolvedPath);
   if (stat.size > MAX_FILE_SIZE) {
     return "Error: File too large (" + (stat.size / 1024 / 1024).toFixed(1) + "MB). Max 1MB.\nUse smart_grep to find specific content instead.";
   }
   try {
-    const content = fs3.readFileSync(resolvedPath, "utf-8");
+    const content = fs2.readFileSync(resolvedPath, "utf-8");
     const lines = content.split("\n");
     const totalLines = lines.length;
     sessionMemory.recordToolCall("smart_file_picker", {
@@ -989,8 +393,8 @@ function extractKeyDeclarations(lines) {
 }
 
 // src/tools/preciseDiffEditor.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs3 from "fs";
+import path3 from "path";
 
 // src/utils/errorHandler.ts
 var CircuitBreakerStore = class {
@@ -1046,10 +450,13 @@ var CircuitBreakerStore = class {
 var circuitBreaker = new CircuitBreakerStore();
 
 // src/tools/preciseDiffEditor.ts
+function generateEditId() {
+  return `edit-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+}
 async function handlePreciseDiffEditor(params) {
-  const { filePath, edits, dryRun = false, action } = params;
+  const { filePath, edits, dryRun = false, action, scope } = params;
   if (action === "rollback") {
-    return handleRollbackEdit({ filePath, version: params.version });
+    return handleRollbackEdit({ filePath, version: params.version, scope: scope || "file", editId: params.editId });
   }
   if (!edits || edits.length === 0) {
     return "Error: 'edits' required for edit mode, or use action: 'rollback' for rollback.";
@@ -1065,12 +472,12 @@ async function handlePreciseDiffEditor(params) {
 
 Try reading the file first with smart_file_picker to verify current content.`;
   }
-  if (!fs4.existsSync(resolvedPath)) {
+  if (!fs3.existsSync(resolvedPath)) {
     return `Error: File not found: "${filePath}".
 Use batch_file_writer to create a new file.`;
   }
   try {
-    const originalContent = fs4.readFileSync(resolvedPath, "utf-8");
+    const originalContent = fs3.readFileSync(resolvedPath, "utf-8");
     let currentContent = originalContent;
     const results = [];
     for (let i = 0; i < edits.length; i++) {
@@ -1078,10 +485,16 @@ Use batch_file_writer to create a new file.`;
       const result = applyEdit(currentContent, edit, resolvedPath, i, dryRun);
       if (result.success) {
         if (!dryRun) {
-          fs4.writeFileSync(resolvedPath, result.details, "utf-8");
+          const editId = generateEditId();
+          result.editId = editId;
+          fs3.writeFileSync(resolvedPath, result.details, "utf-8");
+          if (result.backupPath) {
+            updateBackupManifest(result.backupPath, editId, filePath, i);
+          }
           sessionMemory.recordToolCall("precise_diff_editor", {
             filePath,
             editIndex: i,
+            editId,
             success: true,
             matched: result.matched
           });
@@ -1268,11 +681,29 @@ function findNearestLine(content, search) {
 function createBackup(filePath) {
   ensureBackupDir();
   const backupPath = getBackupPath(filePath);
-  const backupDir = path4.dirname(backupPath);
-  fs4.mkdirSync(backupDir, { recursive: true });
-  fs4.copyFileSync(filePath, backupPath);
+  const backupDir = path3.dirname(backupPath);
+  fs3.mkdirSync(backupDir, { recursive: true });
+  fs3.copyFileSync(filePath, backupPath);
   return backupPath;
 }
+function updateBackupManifest(backupPath, editId, filePath, editIndex) {
+  try {
+    const backupDir = path3.dirname(backupPath);
+    const manifestPath = path3.join(backupDir, "backup_manifest.json");
+    let manifest;
+    if (fs3.existsSync(manifestPath)) {
+      const existing = fs3.readFileSync(manifestPath, "utf-8");
+      manifest = JSON.parse(existing);
+    } else {
+      const tsDir = path3.basename(backupDir);
+      manifest = { timestamp: Number(tsDir) || Date.now(), edits: [] };
+    }
+    manifest.edits.push({ editId, filePath, editIndex });
+    fs3.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+  } catch (err) {
+    console.error(`[BackupManifest] Failed to update manifest: ${err}`);
+  }
+}
 function formatDryRunResult(results, filePath, originalContent) {
   const lines = [
     `\u{1F50D} **DRY RUN** \u2014 ${filePath}`,
@@ -1356,9 +787,12 @@ function formatDiffResult(results, filePath) {
     if (r.success) {
       lines.push(`[${i + 1}] \u2705 Matched: ${r.matched}x, Replaced: ${r.replaced}x`);
       if (r.backupPath) {
-        const relativePath = path4.relative(getProjectRoot(), r.backupPath);
+        const relativePath = path3.relative(getProjectRoot(), r.backupPath);
         lines.push(`    Backup: ${relativePath}`);
       }
+      if (r.editId) {
+        lines.push(`    editId: \`${r.editId}\``);
+      }
     } else {
       lines.push(`[${i + 1}] \u274C ${r.error}`);
       if (r.details) {
@@ -1369,7 +803,8 @@ function formatDiffResult(results, filePath) {
   lines.push(
     "",
     `\u{1F4A1} Use smart_file_picker to read the file and verify edit results.`,
-    `\u{1F4A1} Or execute_safe_test({task: "typecheck"}) to check if edits broke anything.`
+    `\u{1F4A1} Or execute_safe_test({task: "typecheck"}) to check if edits broke anything.`,
+    `\u{1F4A1} Rollback options: { action: "rollback", version: <N> } | { scope: "edit-id", editId: "<id>" } | { scope: "dir", ... }`
   );
   return lines.join("\n");
 }
@@ -1384,31 +819,39 @@ function formatRelativeTime(timestamp) {
   return `${days}d ago`;
 }
 async function handleRollbackEdit(params) {
-  const { filePath, version } = params;
+  const { filePath, version, scope = "file", editId } = params;
+  if (scope === "commit") {
+    return handleCommitRollback(filePath, version);
+  }
+  if (scope === "edit-id") {
+    return handleEditIdRollback(editId, version);
+  }
+  if (scope === "dir") {
+    return handleDirRollback(filePath, version);
+  }
+  if (!filePath) {
+    return "Error: 'filePath' is required for file-scoped rollback.";
+  }
   const validation = validateFilePath(filePath);
   if (!validation.valid) {
     return `Error: ${validation.error.message}`;
   }
   const resolvedPath = validation.resolvedPath;
   const root = getProjectRoot();
-  const relativePath = path4.relative(root, resolvedPath);
-  const backupRoot = path4.join(root, ".agent-backups");
-  if (!fs4.existsSync(backupRoot)) {
-    return `Error: No backup folder (.agent-backups) found in project root.`;
+  const relativePath = path3.relative(root, resolvedPath);
+  const backupRoot = path3.join(root, ".kuma", "backups");
+  if (!fs3.existsSync(backupRoot)) {
+    return `Error: No backup folder (.kuma/backups) found in project root.`;
   }
   try {
-    const dirs = fs4.readdirSync(backupRoot).filter((name) => {
-      const fullPath = path4.join(backupRoot, name);
-      return fs4.statSync(fullPath).isDirectory() && /^\d+$/.test(name);
-    });
+    const dirs = getBackupTimestamps(backupRoot);
     if (dirs.length === 0) {
-      return `Error: No valid backup found in .agent-backups folder.`;
+      return `Error: No valid backup found in .kuma/backups folder.`;
     }
-    dirs.sort((a, b) => Number(b) - Number(a));
     const backupVersions = [];
     for (const dir of dirs) {
-      const potentialBackupPath = path4.join(backupRoot, dir, relativePath);
-      if (fs4.existsSync(potentialBackupPath)) {
+      const potentialBackupPath = path3.join(backupRoot, dir, relativePath);
+      if (fs3.existsSync(potentialBackupPath)) {
         backupVersions.push({ dir, backupPath: potentialBackupPath });
       }
     }
@@ -1416,16 +859,7 @@ async function handleRollbackEdit(params) {
       return `Error: No backup history found for file "${filePath}".`;
     }
     if (version === "list") {
-      const lines = [`\u{1F4CB} Backup Versions for "${filePath}":`];
-      backupVersions.forEach((v, i) => {
-        const ts = Number(v.dir);
-        const date = new Date(ts).toISOString();
-        const relative = formatRelativeTime(ts);
-        lines.push(`  [${i + 1}] ${date} (${relative})`);
-      });
-      lines.push("");
-      lines.push(`\u{1F4A1} Use rollback_last_edit({ filePath: "${filePath}", version: <N> }) to restore a specific version.`);
-      return lines.join("\n");
+      return formatBackupVersionList(backupVersions, filePath);
     }
     let selectedIndex = 0;
     if (typeof version === "number") {
@@ -1435,24 +869,253 @@ async function handleRollbackEdit(params) {
       selectedIndex = version - 1;
     }
     const selected = backupVersions[selectedIndex];
-    fs4.copyFileSync(selected.backupPath, resolvedPath);
+    fs3.copyFileSync(selected.backupPath, resolvedPath);
     sessionMemory.recordToolCall("rollback_last_edit", {
       filePath,
       backupTimestamp: selected.dir,
       version: version ?? 1,
+      scope: "file",
       success: true
     });
-    const relBackupPath = path4.relative(root, selected.backupPath);
+    const relBackupPath = path3.relative(root, selected.backupPath);
     return `\u2705 Rollback Successful!
 File "${filePath}" restored from backup: "${relBackupPath}".`;
   } catch (err) {
     return `Error performing rollback for "${filePath}": ${err instanceof Error ? err.message : String(err)}`;
   }
 }
+async function handleCommitRollback(filePath, version) {
+  try {
+    const { execSync: execSync6 } = await import("child_process");
+    const root = getProjectRoot();
+    if (version === "list") {
+      const log = execSync6("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:**`,
+        "",
+        lines,
+        "",
+        `\u{1F4A1} Use { action: "rollback", scope: "commit", version: <N> } to restore a specific commit.`
+      ].join("\n");
+    }
+    const status = execSync6("git status --porcelain", { cwd: root, encoding: "utf-8" }).trim();
+    if (status) {
+      return [
+        `\u26A0\uFE0F **Uncommitted changes detected.**`,
+        `Running \`git checkout HEAD~N\` would destroy these changes.`,
+        "",
+        `Options:`,
+        `  1. Stash changes first: run \`git stash\``,
+        `  2. Commit changes: run \`git commit -m "..."\``,
+        `  3. Use file-scoped rollback instead: { action: "rollback", scope: "file", ... }`,
+        "",
+        `\u{1F4A1} Run \`git stash\` first, then retry the commit rollback.`
+      ].join("\n");
+    }
+    let target = "";
+    if (typeof version === "number" && version >= 1) {
+      target = `HEAD~${version}`;
+    } else {
+      target = "HEAD~1";
+    }
+    if (filePath) {
+      execSync6(`git checkout ${target} -- "${filePath}"`, { cwd: root, encoding: "utf-8" });
+      return `\u2705 **Commit Rollback** \u2014 File "${filePath}" restored from ${target}.`;
+    } else {
+      execSync6(`git checkout ${target}`, { cwd: root, encoding: "utf-8" });
+      return `\u2705 **Commit Rollback** \u2014 Project restored to ${target}.`;
+    }
+  } catch (err) {
+    return `Error performing git rollback: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+async function handleEditIdRollback(editId, version) {
+  if (!editId && version !== "list") {
+    return "Error: 'editId' is required for edit-id scoped rollback.";
+  }
+  const root = getProjectRoot();
+  const backupRoot = path3.join(root, ".kuma", "backups");
+  const dirs = getBackupTimestamps(backupRoot);
+  if (dirs.length === 0) {
+    return "Error: No backups found.";
+  }
+  const matchingEdits = [];
+  const allEdits = [];
+  for (const dir of dirs) {
+    const manifestPath = path3.join(backupRoot, dir, "backup_manifest.json");
+    if (!fs3.existsSync(manifestPath)) continue;
+    try {
+      const manifest = JSON.parse(fs3.readFileSync(manifestPath, "utf-8"));
+      for (const edit of manifest.edits) {
+        allEdits.push({ dir, editId: edit.editId, filePath: edit.filePath });
+        if (edit.editId === editId) {
+          matchingEdits.push({ dir, editId: edit.editId, filePath: edit.filePath });
+        }
+      }
+    } catch {
+    }
+  }
+  if (version === "list") {
+    if (allEdits.length === 0) {
+      return "\u{1F4CB} **Edit IDs** \u2014 No edit IDs found in backup manifests.\n\nNew edits will be tracked with editId going forward.";
+    }
+    const lines = ["\u{1F4CB} **Tracked Edit IDs:**", ""];
+    for (const e of allEdits.slice(0, 30)) {
+      const ts = new Date(Number(e.dir)).toISOString();
+      lines.push(`  \u2022 \`${e.editId}\` \u2014 ${e.filePath} (${ts})`);
+    }
+    if (allEdits.length > 30) lines.push(`  ... +${allEdits.length - 30} more`);
+    lines.push("", `\u{1F4A1} Use { action: "rollback", scope: "edit-id", editId: "<id>" } to restore a specific edit.`);
+    return lines.join("\n");
+  }
+  if (matchingEdits.length === 0) {
+    return `\u26A0\uFE0F **Edit ID not found** \u2014 "${editId}" not in backup manifests.
+
+Edit IDs are tracked for new edits. To rollback by file, use scope: "file".`;
+  }
+  const results = [];
+  for (const match of matchingEdits) {
+    const backupFilePath = path3.join(backupRoot, match.dir, match.filePath);
+    if (fs3.existsSync(backupFilePath)) {
+      const resolvedPath = path3.join(root, match.filePath);
+      fs3.copyFileSync(backupFilePath, resolvedPath);
+      results.push(`  \u2705 \`${match.filePath}\` restored`);
+    }
+  }
+  sessionMemory.recordToolCall("rollback_last_edit", {
+    editId,
+    filesRestored: matchingEdits.length,
+    success: true
+  });
+  return [
+    `\u2705 **Edit Rollback** \u2014 Restored ${matchingEdits.length} file(s) for edit "${editId}":`,
+    "",
+    ...results
+  ].join("\n");
+}
+async function handleDirRollback(dirPath, version) {
+  if (!dirPath) {
+    return "Error: 'filePath' (directory path) is required for dir-scoped rollback.";
+  }
+  const root = getProjectRoot();
+  const backupRoot = path3.join(root, ".kuma", "backups");
+  const dirs = getBackupTimestamps(backupRoot);
+  if (dirs.length === 0) {
+    return "Error: No backups found.";
+  }
+  const normalizedDir = dirPath.replace(/\\/g, "/").replace(/\/$/, "");
+  const backupFiles = [];
+  for (const dir of dirs) {
+    const backupDirPath = path3.join(backupRoot, dir);
+    const files = walkBackupDir(backupDirPath);
+    for (const file of files) {
+      const relative = path3.relative(backupDirPath, file);
+      if (relative.startsWith(normalizedDir) || relative.startsWith(normalizedDir.replace(/^\//, ""))) {
+        backupFiles.push({ dir, relativePath: relative, fullPath: file });
+      }
+    }
+  }
+  if (version === "list") {
+    const timestampFiles = /* @__PURE__ */ new Map();
+    for (const bf of backupFiles) {
+      if (!timestampFiles.has(bf.dir)) timestampFiles.set(bf.dir, []);
+      timestampFiles.get(bf.dir).push(bf.relativePath);
+    }
+    const lines = [`\u{1F4CB} **Backup Snapshots for directory "${dirPath}":**`, ""];
+    for (const [ts, files] of timestampFiles) {
+      const date = new Date(Number(ts)).toISOString();
+      lines.push(`  \u{1F4C1} ${date} \u2014 ${files.length} file(s)`);
+      for (const f of files.slice(0, 5)) {
+        lines.push(`     \u2022 ${f}`);
+      }
+      if (files.length > 5) lines.push(`     ... +${files.length - 5} more`);
+    }
+    lines.push("", `\u{1F4A1} Use { action: "rollback", scope: "dir", filePath: "${dirPath}", version: <N> } to restore.`);
+    return lines.join("\n");
+  }
+  const byTimestamp = /* @__PURE__ */ new Map();
+  for (const bf of backupFiles) {
+    if (!byTimestamp.has(bf.dir)) byTimestamp.set(bf.dir, []);
+    byTimestamp.get(bf.dir).push(bf);
+  }
+  const sortedTimestamps = [...byTimestamp.keys()].sort((a, b) => Number(b) - Number(a));
+  let selectedTs;
+  if (typeof version === "number" && version >= 1) {
+    if (version > sortedTimestamps.length) {
+      return `Error: Version ${version} is invalid. ${sortedTimestamps.length} snapshots available (1-${sortedTimestamps.length}).`;
+    }
+    selectedTs = sortedTimestamps[version - 1];
+  } else {
+    selectedTs = sortedTimestamps[0];
+  }
+  const filesToRestore = byTimestamp.get(selectedTs) || [];
+  let restoredCount = 0;
+  for (const bf of filesToRestore) {
+    const targetPath = path3.join(root, bf.relativePath);
+    try {
+      fs3.copyFileSync(bf.fullPath, targetPath);
+      restoredCount++;
+    } catch {
+    }
+  }
+  sessionMemory.recordToolCall("rollback_last_edit", {
+    scope: "dir",
+    directory: dirPath,
+    filesRestored: restoredCount,
+    backupTimestamp: selectedTs,
+    success: true
+  });
+  return [
+    `\u2705 **Directory Rollback** \u2014 Restored ${restoredCount} file(s) in "${dirPath}" from snapshot ${new Date(Number(selectedTs)).toISOString()}:`
+  ].join("\n");
+}
+function walkBackupDir(dirPath) {
+  const results = [];
+  try {
+    const entries = fs3.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path3.join(dirPath, entry.name);
+      if (entry.name === "backup_manifest.json") continue;
+      if (entry.isDirectory()) {
+        results.push(...walkBackupDir(fullPath));
+      } else {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function getBackupTimestamps(backupRoot) {
+  try {
+    const dirs = fs3.readdirSync(backupRoot).filter((name) => {
+      const fullPath = path3.join(backupRoot, name);
+      return fs3.statSync(fullPath).isDirectory() && /^\d+$/.test(name);
+    });
+    return dirs.sort((a, b) => Number(b) - Number(a));
+  } catch {
+    return [];
+  }
+}
+function formatBackupVersionList(backupVersions, filePath) {
+  const lines = [`\u{1F4CB} Backup Versions for "${filePath}":`];
+  backupVersions.forEach((v, i) => {
+    const ts = Number(v.dir);
+    const date = new Date(ts).toISOString();
+    const relative = formatRelativeTime(ts);
+    lines.push(`  [${i + 1}] ${date} (${relative})`);
+  });
+  lines.push("");
+  lines.push(`\u{1F4A1} Use { action: "rollback", version: <N>, filePath: "${filePath}" } to restore a specific version.`);
+  lines.push(`\u{1F4A1} Or use { scope: "dir", filePath: "<directory>" } to rollback a whole directory.`);
+  lines.push(`\u{1F4A1} Or use { scope: "edit-id", editId: "<id>" } to rollback by edit ID.`);
+  return lines.join("\n");
+}
 
 // src/tools/batchFileWriter.ts
-import fs5 from "fs";
-import path5 from "path";
+import fs4 from "fs";
+import path4 from "path";
 async function handleBatchFileWriter(params) {
   const { files } = params;
   if (files.length > 15) {
@@ -1479,22 +1142,22 @@ async function handleBatchFileWriter(params) {
         results.push({
           filePath: file.filePath,
           success: false,
-          error: `File extension not allowed: "${path5.extname(file.filePath)}". Allowed extensions: .ts, .js, .tsx, .jsx, .json, .md, .css, .html, .yml, .yaml, .toml, .sh, .env`
+          error: `File extension not allowed: "${path4.extname(file.filePath)}". Allowed extensions: .ts, .js, .tsx, .jsx, .json, .md, .css, .html, .yml, .yaml, .toml, .sh, .env`
         });
         continue;
       }
-      if (fs5.existsSync(resolvedPath)) {
+      if (fs4.existsSync(resolvedPath)) {
         ensureBackupDir();
         const backupPath = getBackupPath(file.filePath);
-        const backupDir = path5.dirname(backupPath);
-        fs5.mkdirSync(backupDir, { recursive: true });
-        fs5.copyFileSync(resolvedPath, backupPath);
+        const backupDir = path4.dirname(backupPath);
+        fs4.mkdirSync(backupDir, { recursive: true });
+        fs4.copyFileSync(resolvedPath, backupPath);
       }
-      const dir = path5.dirname(resolvedPath);
-      if (!fs5.existsSync(dir)) {
-        fs5.mkdirSync(dir, { recursive: true });
+      const dir = path4.dirname(resolvedPath);
+      if (!fs4.existsSync(dir)) {
+        fs4.mkdirSync(dir, { recursive: true });
       }
-      fs5.writeFileSync(resolvedPath, file.content, "utf-8");
+      fs4.writeFileSync(resolvedPath, file.content, "utf-8");
       sessionMemory.recordToolCall("batch_file_writer", {
         filePath: file.filePath,
         instructions: file.instructions,
@@ -1537,12 +1200,12 @@ function formatBatchResult(results, totalRequested) {
 }
 
 // src/tools/safeTerminalExec.ts
-import fs7 from "fs";
-import path7 from "path";
-
-// src/utils/conventionsDetector.ts
 import fs6 from "fs";
 import path6 from "path";
+
+// src/utils/conventionsDetector.ts
+import fs5 from "fs";
+import path5 from "path";
 var cachedConventions = null;
 async function detectConventions(forceRescan = false) {
   if (cachedConventions && !forceRescan) {
@@ -1568,7 +1231,7 @@ async function detectConventions(forceRescan = false) {
   return conventions;
 }
 function detectFramework(root) {
-  const pkg = readJsonSafe(path6.join(root, "package.json"));
+  const pkg = readJsonSafe(path5.join(root, "package.json"));
   if (pkg) {
     const pkgDeps = pkg.dependencies ?? {};
     const pkgDevDeps = pkg.devDependencies ?? {};
@@ -1613,11 +1276,11 @@ function detectFramework(root) {
 function scanSubProjectFrameworks(root) {
   const frameworks = [];
   try {
-    const entries = fs6.readdirSync(root, { withFileTypes: true });
+    const entries = fs5.readdirSync(root, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const subDir = path6.join(root, entry.name);
-      const subPkg = readJsonSafe(path6.join(subDir, "package.json"));
+      const subDir = path5.join(root, entry.name);
+      const subPkg = readJsonSafe(path5.join(subDir, "package.json"));
       if (!subPkg) continue;
       const subDeps = { ...subPkg.dependencies ?? {}, ...subPkg.devDependencies ?? {} };
       if (subDeps.next) frameworks.push("Next.js");
@@ -1636,7 +1299,7 @@ function scanSubProjectFrameworks(root) {
   return frameworks;
 }
 function detectProjectType(root) {
-  const pkg = readJsonSafe(path6.join(root, "package.json"));
+  const pkg = readJsonSafe(path5.join(root, "package.json"));
   if (pkg) {
     const pkgDeps = pkg.dependencies ?? {};
     const pkgDevDeps = pkg.devDependencies ?? {};
@@ -1660,8 +1323,8 @@ function detectProjectType(root) {
 }
 function detectWorkspaces(root) {
   const results = [];
-  const pkg = readJsonSafe(path6.join(root, "package.json"));
-  const pnpmWorkspace = readYamlLite(path6.join(root, "pnpm-workspace.yaml"));
+  const pkg = readJsonSafe(path5.join(root, "package.json"));
+  const pnpmWorkspace = readYamlLite(path5.join(root, "pnpm-workspace.yaml"));
   const patterns = /* @__PURE__ */ new Set();
   const pkgWorkspaces = pkg?.workspaces;
   if (Array.isArray(pkgWorkspaces)) {
@@ -1681,22 +1344,22 @@ function detectWorkspaces(root) {
   for (const pattern of patterns) {
     const match = pattern.match(/^([^*]+)\/\*$/);
     if (!match) continue;
-    const dir = path6.join(root, match[1]);
-    if (!fs6.existsSync(dir)) continue;
+    const dir = path5.join(root, match[1]);
+    if (!fs5.existsSync(dir)) continue;
     let entries = [];
     try {
-      entries = fs6.readdirSync(dir, { withFileTypes: true });
+      entries = fs5.readdirSync(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const pkgPath = path6.join(dir, entry.name, "package.json");
+      const pkgPath = path5.join(dir, entry.name, "package.json");
       const subPkg = readJsonSafe(pkgPath);
       if (!subPkg) continue;
-      const workspacePath = path6.join(dir, entry.name);
+      const workspacePath = path5.join(dir, entry.name);
       results.push({
-        path: path6.relative(root, workspacePath),
+        path: path5.relative(root, workspacePath),
         name: subPkg.name ?? entry.name,
         framework: detectFramework(workspacePath),
         packageManager: detectPackageManagerForDir(workspacePath)
@@ -1712,8 +1375,8 @@ function detectWorkspaces(root) {
 }
 function readYamlLite(filePath) {
   try {
-    if (!fs6.existsSync(filePath)) return null;
-    const text = fs6.readFileSync(filePath, "utf-8");
+    if (!fs5.existsSync(filePath)) return null;
+    const text = fs5.readFileSync(filePath, "utf-8");
     const packages = [];
     let inPackages = false;
     for (const rawLine of text.split("\n")) {
@@ -1734,7 +1397,7 @@ function readYamlLite(filePath) {
   }
 }
 function detectTestRunner(root) {
-  const pkg = readJsonSafe(path6.join(root, "package.json"));
+  const pkg = readJsonSafe(path5.join(root, "package.json"));
   if (!pkg) return "unknown";
   const pkgDeps2 = pkg.dependencies ?? {};
   const pkgDevDeps2 = pkg.devDependencies ?? {};
@@ -1755,7 +1418,7 @@ function detectTestRunner(root) {
   return "unknown";
 }
 function detectStyling(root) {
-  const pkg = readJsonSafe(path6.join(root, "package.json"));
+  const pkg = readJsonSafe(path5.join(root, "package.json"));
   if (!pkg) return "unknown";
   const pkgDeps3 = pkg.dependencies ?? {};
   const pkgDevDeps3 = pkg.devDependencies ?? {};
@@ -1768,22 +1431,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 = path6.join(root, "src");
-  if (fs6.existsSync(srcDir)) {
+  const srcDir = path5.join(root, "src");
+  if (fs5.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(path6.join(root, "tsconfig.json"));
+  const tsconfig = readJsonSafe(path5.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(path6.join(root, "jsconfig.json"));
+  const jsconfig = readJsonSafe(path5.join(root, "jsconfig.json"));
   const jsconfigPaths = jsconfig?.compilerOptions;
   if (jsconfigPaths?.paths) {
     const paths = jsconfigPaths.paths;
@@ -1794,15 +1457,15 @@ function detectImportAlias(root) {
 }
 function detectLintRules(root) {
   const rules = [];
-  if (fs6.existsSync(path6.join(root, ".eslintrc"))) rules.push("ESLint (.eslintrc)");
-  if (fs6.existsSync(path6.join(root, ".eslintrc.js"))) rules.push("ESLint (.eslintrc.js)");
-  if (fs6.existsSync(path6.join(root, ".eslintrc.json"))) rules.push("ESLint (.eslintrc.json)");
-  if (fs6.existsSync(path6.join(root, "eslint.config.js"))) rules.push("ESLint (flat config)");
-  if (fs6.existsSync(path6.join(root, ".prettierrc"))) rules.push("Prettier");
-  if (fs6.existsSync(path6.join(root, ".prettierrc.json"))) rules.push("Prettier");
-  if (fs6.existsSync(path6.join(root, ".prettierrc.js"))) rules.push("Prettier");
-  if (fs6.existsSync(path6.join(root, ".stylelintrc"))) rules.push("StyleLint");
-  if (fs6.existsSync(path6.join(root, ".stylelintrc.json"))) rules.push("StyleLint");
+  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");
   return rules;
 }
 function detectPackageManager() {
@@ -1811,26 +1474,26 @@ function detectPackageManager() {
 }
 function detectPackageManagerForDir(dir) {
   const root = getProjectRoot();
-  let currentDir = path6.resolve(dir);
+  let currentDir = path5.resolve(dir);
   while (currentDir.startsWith(root)) {
-    if (fs6.existsSync(path6.join(currentDir, "pnpm-lock.yaml"))) return "pnpm";
-    if (fs6.existsSync(path6.join(currentDir, "yarn.lock"))) return "yarn";
-    if (fs6.existsSync(path6.join(currentDir, "package-lock.json"))) return "npm";
-    if (fs6.existsSync(path6.join(currentDir, "bun.lockb"))) return "bun";
+    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 (currentDir === root) break;
-    currentDir = path6.dirname(currentDir);
+    currentDir = path5.dirname(currentDir);
   }
   return "npm";
 }
 function detectModuleSystem(root) {
-  const pkg = readJsonSafe(path6.join(root, "package.json"));
+  const pkg = readJsonSafe(path5.join(root, "package.json"));
   if (pkg?.type === "module") return "esm";
-  const srcDir = path6.join(root, "src");
-  if (fs6.existsSync(srcDir)) {
+  const srcDir = path5.join(root, "src");
+  if (fs5.existsSync(srcDir)) {
     const tsFiles = findFiles(srcDir, [".ts", ".tsx", ".js", ".jsx", ".mjs"]);
     for (const file of tsFiles.slice(0, 20)) {
       try {
-        const content = fs6.readFileSync(file, "utf-8");
+        const content = fs5.readFileSync(file, "utf-8");
         if (content.includes("import ") || content.includes("export ")) return "esm";
       } catch {
         continue;
@@ -1840,9 +1503,9 @@ function detectModuleSystem(root) {
   return "cjs";
 }
 function detectLanguage(root) {
-  if (fs6.existsSync(path6.join(root, "tsconfig.json"))) return "typescript";
-  const srcDir = path6.join(root, "src");
-  if (fs6.existsSync(srcDir)) {
+  if (fs5.existsSync(path5.join(root, "tsconfig.json"))) return "typescript";
+  const srcDir = path5.join(root, "src");
+  if (fs5.existsSync(srcDir)) {
     const tsFiles = findFiles(srcDir, [".ts", ".tsx"]);
     if (tsFiles.length > 0) return "typescript";
   }
@@ -1850,7 +1513,7 @@ function detectLanguage(root) {
 }
 function detectFeatures(root) {
   const features = [];
-  const pkg = readJsonSafe(path6.join(root, "package.json"));
+  const pkg = readJsonSafe(path5.join(root, "package.json"));
   if (!pkg) return features;
   const pkgDeps4 = pkg.dependencies ?? {};
   const pkgDevDeps4 = pkg.devDependencies ?? {};
@@ -1874,25 +1537,25 @@ function detectFeatures(root) {
 }
 function readJsonSafe(filePath) {
   try {
-    if (fs6.existsSync(filePath)) {
-      return JSON.parse(fs6.readFileSync(filePath, "utf-8"));
+    if (fs5.existsSync(filePath)) {
+      return JSON.parse(fs5.readFileSync(filePath, "utf-8"));
     }
   } catch {
   }
   return null;
 }
 function hasCSSModules(root) {
-  const srcDir = path6.join(root, "src");
-  if (!fs6.existsSync(srcDir)) return false;
+  const srcDir = path5.join(root, "src");
+  if (!fs5.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 = fs6.readdirSync(dir, { withFileTypes: true });
+    const entries = fs5.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path6.join(dir, entry.name);
+      const fullPath = path5.join(dir, entry.name);
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
         results.push(...findFiles(fullPath, extensions));
       } else if (entry.isFile()) {
@@ -2083,7 +1746,7 @@ async function handleSafeTerminalExec(params) {
     const workspaces = conventions?.workspaces;
     const matched = workspaces?.find((w) => w.name === workspace || w.path === workspace);
     if (matched) {
-      workingDir = path7.resolve(projectRoot, matched.path);
+      workingDir = path6.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.
@@ -2091,13 +1754,13 @@ async function handleSafeTerminalExec(params) {
 Available workspaces: ${workspaces?.map((w) => `"${w.name}" (${w.path})`).join(", ") || "none detected"}`;
     }
   } else if (inputCwd) {
-    const resolved = path7.resolve(projectRoot, inputCwd);
-    const normalizedResolved = path7.normalize(resolved).toLowerCase();
-    const normalizedRoot = path7.normalize(projectRoot).toLowerCase();
+    const resolved = path6.resolve(projectRoot, inputCwd);
+    const normalizedResolved = path6.normalize(resolved).toLowerCase();
+    const normalizedRoot = path6.normalize(projectRoot).toLowerCase();
     if (!normalizedResolved.startsWith(normalizedRoot)) {
       return `\u{1F6AB} BLOCKED: Path "${inputCwd}" resolves outside project root "${projectRoot}".`;
     }
-    if (!fs7.existsSync(resolved)) {
+    if (!fs6.existsSync(resolved)) {
       return `\u26A0\uFE0F Directory "${inputCwd}" does not exist at "${resolved}".`;
     }
     workingDir = resolved;
@@ -2183,8 +1846,8 @@ function formatTimeoutResult(command, timeout) {
 }
 
 // src/agents/codeReviewer.ts
-import fs8 from "fs";
-import path8 from "path";
+import fs7 from "fs";
+import path7 from "path";
 import { execSync } from "child_process";
 var CODE_EXTENSIONS = [
   ".ts",
@@ -2228,7 +1891,7 @@ function getGitChangedFiles() {
       if (filePath.startsWith('"') && filePath.endsWith('"')) {
         filePath = filePath.substring(1, filePath.length - 1);
       }
-      const ext = path8.extname(filePath).toLowerCase();
+      const ext = path7.extname(filePath).toLowerCase();
       if (CODE_EXTENSIONS.includes(ext)) files.push(filePath);
     }
     return files.slice(0, 10);
@@ -2265,7 +1928,7 @@ Pass an explicit 'files' array to review specific files.`;
       continue;
     }
     const resolvedPath = validation.resolvedPath;
-    if (!fs8.existsSync(resolvedPath)) {
+    if (!fs7.existsSync(resolvedPath)) {
       allIssues.push({
         file: filePath,
         line: 0,
@@ -2277,7 +1940,7 @@ Pass an explicit 'files' array to review specific files.`;
       continue;
     }
     try {
-      const content = fs8.readFileSync(resolvedPath, "utf-8");
+      const content = fs7.readFileSync(resolvedPath, "utf-8");
       filesReviewed++;
       checkGeneral(filePath, content, allIssues);
       switch (focus) {
@@ -2375,12 +2038,12 @@ function isTestFile(filePath) {
   return /\.(test|spec)\.[a-z]+$/i.test(filePath) || /__tests__/.test(filePath);
 }
 function isTsLike(filePath) {
-  const ext = path8.extname(filePath).toLowerCase();
+  const ext = path7.extname(filePath).toLowerCase();
   return ext === ".ts" || ext === ".tsx";
 }
 function checkGeneral(filePath, content, issues) {
   const lines = content.split("\n");
-  const ext = path8.extname(filePath).toLowerCase();
+  const ext = path7.extname(filePath).toLowerCase();
   if (content.length > 0 && !content.endsWith("\n")) {
     issues.push({
       file: filePath,
@@ -2582,7 +2245,7 @@ function stripJsonComments(text) {
   return cleaned.join("\n");
 }
 function checkConfigFile(filePath, content, issues) {
-  const ext = path8.extname(filePath).toLowerCase();
+  const ext = path7.extname(filePath).toLowerCase();
   const lines = content.split("\n");
   if (ext === ".json" || ext === ".jsonc") {
     checkJson(filePath, content, lines, issues);
@@ -2593,7 +2256,7 @@ function checkConfigFile(filePath, content, issues) {
   }
 }
 function checkJson(filePath, content, lines, issues) {
-  const ext = path8.extname(filePath).toLowerCase();
+  const ext = path7.extname(filePath).toLowerCase();
   const isJsonc = ext === ".jsonc";
   const contentToParse = isJsonc ? stripJsonComments(content) : content;
   try {
@@ -3450,13 +3113,13 @@ async function handleGitDiff(params) {
 }
 
 // src/tools/projectStructure.ts
-import fs9 from "fs";
-import path9 from "path";
+import fs8 from "fs";
+import path8 from "path";
 var DEFAULT_IGNORE = [
   "node_modules",
   ".git",
   ".kuma",
-  ".agent-backups",
+  ".kuma/backups",
   "dist",
   ".next",
   "build",
@@ -3488,7 +3151,7 @@ async function handleProjectStructure(params) {
   sessionMemory.recordToolCall("project_structure", { depth: clampedDepth, folderOnly });
   try {
     const tree = buildTree(root, root, clampedDepth, 0, folderOnly, includePattern, excludePattern);
-    const projectName = path9.basename(root);
+    const projectName = path8.basename(root);
     const lines = [
       "[Project Structure] - " + projectName,
       "Depth: " + clampedDepth + " | " + (folderOnly ? "Folders only" : "Files and folders"),
@@ -3511,7 +3174,7 @@ function buildTree(root, currentDir, maxDepth, currentDepth, folderOnly, include
   const lines = [];
   let entries = [];
   try {
-    entries = fs9.readdirSync(currentDir, { withFileTypes: true });
+    entries = fs8.readdirSync(currentDir, { withFileTypes: true });
   } catch {
     return lines;
   }
@@ -3520,12 +3183,12 @@ function buildTree(root, currentDir, maxDepth, currentDepth, folderOnly, include
     if (!a.isDirectory() && b.isDirectory()) return 1;
     return a.name.localeCompare(b.name);
   });
-  const relativeDir = path9.relative(root, currentDir) || ".";
+  const relativeDir = path8.relative(root, currentDir) || ".";
   const prefix = getPrefix(currentDepth);
   for (const entry of entries) {
     if (shouldIgnore(entry.name, relativeDir, root)) continue;
-    const fullPath = path9.join(currentDir, entry.name);
-    const relativePath = path9.relative(root, fullPath);
+    const fullPath = path8.join(currentDir, entry.name);
+    const relativePath = path8.relative(root, fullPath);
     if (includePattern && !entry.name.includes(includePattern) && !relativePath.includes(includePattern)) {
       if (!entry.isDirectory()) continue;
     }
@@ -3536,11 +3199,11 @@ function buildTree(root, currentDir, maxDepth, currentDepth, folderOnly, include
       lines.push(prefix + "[D] " + entry.name + "/");
       let subEntries = [];
       try {
-        subEntries = fs9.readdirSync(fullPath, { withFileTypes: true });
+        subEntries = fs8.readdirSync(fullPath, { withFileTypes: true });
       } catch {
       }
       const hasVisibleContent = subEntries.some(
-        (e) => !shouldIgnore(e.name, path9.relative(root, fullPath), root)
+        (e) => !shouldIgnore(e.name, path8.relative(root, fullPath), root)
       );
       if (hasVisibleContent) {
         const subLines = buildTree(root, fullPath, maxDepth, currentDepth + 1, folderOnly, includePattern, excludePattern);
@@ -3571,7 +3234,7 @@ function getPrefix(depth) {
 }
 function getFileSize(fullPath) {
   try {
-    const stat = fs9.statSync(fullPath);
+    const stat = fs8.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);
@@ -3582,8 +3245,8 @@ function getFileSize(fullPath) {
 }
 
 // src/tools/staticAnalysis.ts
-import fs10 from "fs";
-import path10 from "path";
+import fs9 from "fs";
+import path9 from "path";
 async function handleStaticAnalysis(params) {
   const { tool = "all", files, autoFix = false, timeout = 60 } = params;
   const root = getProjectRoot();
@@ -3662,7 +3325,10 @@ async function handleStaticAnalysis(params) {
 function detectAvailableTools(root) {
   const tools = [];
   const pkg = readPackageJson(root);
-  const allDeps = { ...pkg?.dependencies ?? {}, ...pkg?.devDependencies ?? {} };
+  const allDeps = {
+    ...pkg?.dependencies ?? {},
+    ...pkg?.devDependencies ?? {}
+  };
   const depNames = new Set(Object.keys(allDeps));
   const eslintConfigs = [
     ".eslintrc",
@@ -3673,11 +3339,11 @@ function detectAvailableTools(root) {
     "eslint.config.js",
     "eslint.config.mjs"
   ];
-  const hasEslintConfig = eslintConfigs.some((cfg) => fs10.existsSync(path10.join(root, cfg)));
+  const hasEslintConfig = eslintConfigs.some((cfg) => fs9.existsSync(path9.join(root, cfg)));
   if (hasEslintConfig && depNames.has("eslint")) {
     tools.push("eslint");
   }
-  if (fs10.existsSync(path10.join(root, "tsconfig.json")) && depNames.has("typescript")) {
+  if (fs9.existsSync(path9.join(root, "tsconfig.json")) && depNames.has("typescript")) {
     tools.push("tsc");
   }
   const prettierConfigs = [
@@ -3688,20 +3354,20 @@ function detectAvailableTools(root) {
     ".prettierrc.toml",
     "prettier.config.js"
   ];
-  const hasPrettierConfig = prettierConfigs.some((cfg) => fs10.existsSync(path10.join(root, cfg)));
+  const hasPrettierConfig = prettierConfigs.some((cfg) => fs9.existsSync(path9.join(root, cfg)));
   if (hasPrettierConfig && depNames.has("prettier")) {
     tools.push("prettier");
   }
-  if (fs10.existsSync(path10.join(root, "ruff.toml")) || fs10.existsSync(path10.join(root, ".ruff.toml"))) {
+  if (fs9.existsSync(path9.join(root, "ruff.toml")) || fs9.existsSync(path9.join(root, ".ruff.toml"))) {
     tools.push("ruff");
   }
   return tools;
 }
 function readPackageJson(root) {
   try {
-    const pkgPath = path10.join(root, "package.json");
-    if (fs10.existsSync(pkgPath)) {
-      return JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path9.join(root, "package.json");
+    if (fs9.existsSync(pkgPath)) {
+      return JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
     }
   } catch {
   }
@@ -3757,18 +3423,18 @@ function buildToolCommand(tool, files, autoFix) {
 }
 function detectPackageManagerPrefix() {
   const root = getProjectRoot();
-  if (fs10.existsSync(path10.join(root, "pnpm-lock.yaml"))) return "pnpm ";
-  if (fs10.existsSync(path10.join(root, "yarn.lock"))) return "yarn ";
+  if (fs9.existsSync(path9.join(root, "pnpm-lock.yaml"))) return "pnpm ";
+  if (fs9.existsSync(path9.join(root, "yarn.lock"))) return "yarn ";
   return "npx --no-install ";
 }
 function findBinary(root, binName) {
   const candidates = [
-    path10.join(root, "node_modules", ".bin", binName),
-    path10.join(root, "..", "node_modules", ".bin", binName)
+    path9.join(root, "node_modules", ".bin", binName),
+    path9.join(root, "..", "node_modules", ".bin", binName)
   ];
   for (const candidate of candidates) {
     try {
-      if (fs10.existsSync(candidate)) {
+      if (fs9.existsSync(candidate)) {
         return candidate;
       }
     } catch {
@@ -3792,7 +3458,7 @@ function parseToolOutput(tool, stdout, stderr, projectRoot) {
 }
 function resolveToolPath(filePath, projectRoot) {
   const trimmed = filePath.trim();
-  return path10.isAbsolute(trimmed) ? path10.relative(projectRoot, trimmed) : trimmed.replace(/^\.\//, "");
+  return path9.isAbsolute(trimmed) ? path9.relative(projectRoot, trimmed) : trimmed.replace(/^\.\//, "");
 }
 function parseEslintOutput(output, projectRoot) {
   const issues = [];
@@ -3974,80 +3640,140 @@ function formatToolNotAvailable(requested, available) {
   ].join("\n");
 }
 
-// src/tools/kumaReflect.ts
+// src/utils/kumaShared.ts
 import { execSync as execSync3 } from "child_process";
-async function handleReflect(params) {
+function getSessionStats(inputGoal) {
   const summary = sessionMemory.getSummary();
-  const goal = params.goal || summary.currentGoal || "";
+  const goal = inputGoal || summary.currentGoal || "";
   const modifiedFiles = sessionMemory.getModifiedFiles();
   const toolCalls = sessionMemory.getToolCallHistory(50);
   const failedFiles = sessionMemory.getFailedFiles();
   const loop = sessionMemory.detectLoop();
-  const unresolved = [];
-  for (const f of failedFiles) {
-    for (const ff of f.failures) {
-      if (!ff.resolved) {
-        unresolved.push({ task: f.task, error: ff.error.substring(0, 200) });
-      }
-    }
-  }
-  const hasRunTests = toolCalls.some(
-    (c) => c.toolName === "execute_safe_test"
-  );
-  let gitStat = "";
+  return {
+    goal,
+    modifiedFiles,
+    toolCalls,
+    toolCallCount: toolCalls.length,
+    failedFiles,
+    hasLoop: loop.isLooping,
+    loopMessage: loop.message,
+    hasRunTests: toolCalls.some((c) => c.toolName === "execute_safe_test")
+  };
+}
+function getGitDiffStat(timeout = 3e3) {
   try {
     const root = getProjectRoot();
-    gitStat = execSync3("git diff --stat", {
+    return execSync3("git diff --stat", {
       cwd: root,
       encoding: "utf-8",
-      timeout: 5e3
+      timeout
     }).trim();
   } catch {
+    return "";
   }
-  const drifts = [];
-  if (modifiedFiles.length > 0 && !hasRunTests) {
-    drifts.push(`${modifiedFiles.length} file(s) edited but no test run`);
-  }
-  if (loop.isLooping) {
-    drifts.push(loop.message);
-  }
-  if (unresolved.length > 0) {
-    drifts.push(`${unresolved.length} unresolved failure(s)`);
+}
+function getUnresolvedCount(failedFiles) {
+  let count = 0;
+  for (const f of failedFiles) {
+    for (const ff of f.failures) {
+      if (!ff.resolved) count++;
+    }
   }
-  if (gitStat) {
-    drifts.push(`Git diff: ${gitStat}`);
+  return count;
+}
+function getUnresolvedDetails(failedFiles) {
+  const result = [];
+  for (const f of failedFiles) {
+    for (const ff of f.failures) {
+      if (!ff.resolved) {
+        result.push({ task: f.task, error: ff.error.substring(0, 200) });
+      }
+    }
   }
-  const ladderViolations = [];
+  return result;
+}
+function checkLadderViolations(toolCalls, modifiedFiles, hasRunTests) {
+  const violations = [];
   const editCalls = toolCalls.filter(
     (c) => c.toolName === "precise_diff_editor" || c.toolName === "batch_file_writer"
   ).length;
   if (editCalls > 5) {
-    ladderViolations.push(
-      `${editCalls} file ops in a row \u2014 consider if all are needed`
-    );
+    violations.push(`${editCalls} file ops in a row \u2014 consider if all are needed`);
   }
   if (modifiedFiles.length > 5 && !hasRunTests) {
-    ladderViolations.push(
-      `${modifiedFiles.length} files modified without verification`
-    );
+    violations.push(`${modifiedFiles.length} files modified without verification`);
+  }
+  return violations;
+}
+function buildDriftMessages(modifiedFiles, hasRunTests, unresolvedCount, gitStat, loopMessage) {
+  const drifts = [];
+  if (modifiedFiles > 0 && !hasRunTests) {
+    drifts.push(`${modifiedFiles} file(s) edited but no test run`);
+  }
+  if (loopMessage) {
+    drifts.push(loopMessage);
+  }
+  if (unresolvedCount > 0) {
+    drifts.push(`${unresolvedCount} unresolved failure(s)`);
+  }
+  if (gitStat) {
+    drifts.push(`Git diff: ${gitStat}`);
+  }
+  return drifts;
+}
+function getPrioritySuggestion(goal, warnings, hasLoop, unresolvedCount, modifiedFiles, hasRunTests, editCalls) {
+  if (warnings.some((w) => w.severity === "high" && w.pattern === "script-patching")) {
+    return "Remove patch scripts and use precise_diff_editor for all file modifications";
+  }
+  if (hasLoop) {
+    return "Switch approach \u2014 current tool is not making progress";
+  }
+  if (warnings.some((w) => w.pattern === "no-test-after-edit") || modifiedFiles > 0 && !hasRunTests) {
+    return "Run tests to verify your changes before continuing";
+  }
+  if (unresolvedCount > 0) {
+    return "Fix unresolved failures before continuing";
+  }
+  if (warnings.some((w) => w.pattern === "bash-grep")) {
+    return "Use smart_grep for code search instead of bash grep";
+  }
+  if (warnings.some((w) => w.pattern === "excessive-edits") || editCalls > 10) {
+    return "Consider if refactoring can be simplified \u2014 fewer files = fewer bugs";
   }
-  const onTrack = !loop.isLooping && unresolved.length === 0 && (modifiedFiles.length === 0 || hasRunTests);
-  let suggestion;
   if (!goal) {
-    suggestion = "No goal set \u2014 use goal parameter or setGoal";
-  } else if (loop.isLooping) {
-    suggestion = "Switch approach \u2014 current tool is not making progress";
-  } else if (unresolved.length > 0) {
-    suggestion = "Fix unresolved failures before continuing";
-  } else if (modifiedFiles.length > 0 && !hasRunTests) {
-    suggestion = "Run tests to verify changes";
-  } else if (modifiedFiles.length === 0 && !toolCalls.some((c) => ["smart_file_picker", "smart_grep"].includes(c.toolName))) {
-    suggestion = "Start by exploring what exists before writing code";
-  } else if (editCalls > 10) {
-    suggestion = "Consider if refactoring can be simplified \u2014 fewer files = fewer bugs";
-  } else {
-    suggestion = "On track";
+    return "No goal set \u2014 use goal parameter or setGoal to track intent";
   }
+  if (modifiedFiles === 0) {
+    return "Start by exploring what exists before writing code";
+  }
+  return "On track \u2014 continue with current approach";
+}
+
+// src/tools/kumaReflect.ts
+async function handleReflect(params) {
+  const stats = getSessionStats(params.goal);
+  const unresolved = getUnresolvedDetails(stats.failedFiles);
+  const gitStat = getGitDiffStat(5e3);
+  const ladderViolations = checkLadderViolations(stats.toolCalls, stats.modifiedFiles, stats.hasRunTests);
+  const drifts = buildDriftMessages(
+    stats.modifiedFiles.length,
+    stats.hasRunTests,
+    unresolved.length,
+    gitStat,
+    stats.loopMessage
+  );
+  const onTrack = !stats.hasLoop && unresolved.length === 0 && (stats.modifiedFiles.length === 0 || stats.hasRunTests);
+  const suggestion = getPrioritySuggestion(
+    stats.goal,
+    [],
+    stats.hasLoop,
+    unresolved.length,
+    stats.modifiedFiles.length,
+    stats.hasRunTests,
+    stats.toolCalls.filter(
+      (c) => c.toolName === "precise_diff_editor" || c.toolName === "batch_file_writer"
+    ).length
+  );
   return JSON.stringify(
     {
       onTrack,
@@ -4055,12 +3781,12 @@ async function handleReflect(params) {
       ...ladderViolations.length > 0 ? { ladderViolations } : {},
       suggestion,
       stats: {
-        goal,
-        modifiedFiles: modifiedFiles.length,
-        toolCalls: toolCalls.length,
+        goal: stats.goal,
+        modifiedFiles: stats.modifiedFiles.length,
+        toolCalls: stats.toolCallCount,
         unresolvedFailures: unresolved.length,
-        hasLoop: loop.isLooping,
-        hasRunTests
+        hasLoop: stats.hasLoop,
+        hasRunTests: stats.hasRunTests
       }
     },
     null,
@@ -4068,12 +3794,9 @@ async function handleReflect(params) {
   );
 }
 
-// src/tools/kumaGuard.ts
-import { execSync as execSync6 } from "child_process";
-
 // src/guards/antiPatternDetector.ts
-import fs11 from "fs";
-import path11 from "path";
+import fs10 from "fs";
+import path10 from "path";
 import { execSync as execSync4 } from "child_process";
 var SCRIPT_PATCH_PATTERNS = [
   "writeFileSync",
@@ -4100,20 +3823,20 @@ function findPatchScripts(projectRoot) {
   const warnings = [];
   const recentFiles = scanRecentFiles(projectRoot);
   for (const file of recentFiles) {
-    const ext = path11.extname(file).toLowerCase();
+    const ext = path10.extname(file).toLowerCase();
     if (!SCRIPT_EXTENSIONS.includes(ext)) continue;
-    const relativePath = path11.relative(projectRoot, file);
+    const relativePath = path10.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 = fs10.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: ${path10.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
@@ -4147,15 +3870,15 @@ function detectBashGrepUsage() {
 function scanRecentFiles(projectRoot) {
   const recent = [];
   try {
-    const entries = fs11.readdirSync(projectRoot, { withFileTypes: true });
+    const entries = fs10.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 = fs10.statSync(path10.join(projectRoot, entry.name));
         if (now - stat.mtimeMs < recentThreshold || now - stat.ctimeMs < recentThreshold) {
-          recent.push(path11.join(projectRoot, entry.name));
+          recent.push(path10.join(projectRoot, entry.name));
         }
       } catch {
         continue;
@@ -4179,14 +3902,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 = path10.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 = path10.join(projectRoot, file);
+        if (fs10.existsSync(fullPath)) {
+          const content = fs10.readFileSync(fullPath, "utf-8").toLowerCase();
           const matchedPattern = SCRIPT_PATCH_PATTERNS.find((p) => content.includes(p.toLowerCase()));
           if (matchedPattern) {
             warnings.push({
@@ -4209,7 +3932,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 = path10.extname(file).toLowerCase();
         if (SCRIPT_EXTENSIONS.includes(ext)) {
           warnings.push({
             severity: "high",
@@ -4269,21 +3992,21 @@ function detectAllAntiPatterns() {
 }
 
 // src/engine/contextSnapshot.ts
-import fs12 from "fs";
-import path12 from "path";
+import fs11 from "fs";
+import path11 from "path";
 import { execSync as execSync5 } from "child_process";
 var SNAPSHOT_DIR = "context-snapshots";
 function snapshotDir() {
-  return path12.join(getProjectRoot(), ".kuma", SNAPSHOT_DIR);
+  return path11.join(getProjectRoot(), ".kuma", SNAPSHOT_DIR);
 }
 function ensureSnapshotDir() {
   const dir = snapshotDir();
-  if (!fs12.existsSync(dir)) {
-    fs12.mkdirSync(dir, { recursive: true });
+  if (!fs11.existsSync(dir)) {
+    fs11.mkdirSync(dir, { recursive: true });
   }
 }
 function snapshotFilePath(timestamp) {
-  return path12.join(snapshotDir(), `${timestamp}.json`);
+  return path11.join(snapshotDir(), `${timestamp}.json`);
 }
 function saveSnapshot(goal) {
   try {
@@ -4299,12 +4022,12 @@ function saveSnapshot(goal) {
     modifiedFiles: summary.modifiedFiles || [],
     unresolvedFailures: summary.unresolvedFailures || [],
     toolCallCount: summary.toolCallCount || 0,
-    gitDiffStat: getGitDiffStat(),
+    gitDiffStat: getGitDiffStat2(),
     completedSteps: summary.completedSteps || [],
     hasConventions: !!summary.hasConventions
   };
   try {
-    fs12.writeFileSync(snapshotFilePath(Date.now()), JSON.stringify(snapshot, null, 2), "utf-8");
+    fs11.writeFileSync(snapshotFilePath(Date.now()), JSON.stringify(snapshot, null, 2), "utf-8");
   } catch {
   }
   sessionMemory.recordToolCall("kuma_context", { action: "save", goal: snapshot.goal });
@@ -4312,12 +4035,12 @@ function saveSnapshot(goal) {
 }
 function listSnapshots() {
   const dir = snapshotDir();
-  if (!fs12.existsSync(dir)) return [];
+  if (!fs11.existsSync(dir)) return [];
   try {
-    const files = fs12.readdirSync(dir).filter((f) => f.endsWith(".json")).sort((a, b) => b.localeCompare(a));
+    const files = fs11.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 = fs11.readFileSync(path11.join(dir, f), "utf-8");
         return JSON.parse(content);
       } catch {
         return null;
@@ -4357,7 +4080,7 @@ function formatSnapshot(snapshot) {
   lines.push('\u{1F4A1} Use kuma_guard({ check: "context" }) to create a new snapshot.');
   return lines.join("\n");
 }
-function getGitDiffStat() {
+function getGitDiffStat2() {
   try {
     const root = getProjectRoot();
     const stdout = execSync5("git diff --stat", {
@@ -4374,9 +4097,8 @@ function getGitDiffStat() {
 // src/tools/kumaGuard.ts
 async function handleKumaGuard(params) {
   const { check = "all", goal: inputGoal } = params;
-  const summary = sessionMemory.getSummary();
-  const goal = inputGoal || summary.currentGoal || "";
-  sessionMemory.recordToolCall("kuma_guard", { check, goal });
+  sessionMemory.recordToolCall("kuma_guard", { check, goal: inputGoal });
+  const stats = getSessionStats(inputGoal);
   const warnings = [];
   if (check === "all" || check === "anti-pattern") {
     warnings.push(...detectAllAntiPatterns());
@@ -4391,44 +4113,26 @@ async function handleKumaGuard(params) {
     });
   }
   const drifts = [];
-  const toolCalls = sessionMemory.getToolCallHistory(50);
-  const hasRunTests = toolCalls.some((c) => c.toolName === "execute_safe_test");
   if (check === "all" || check === "drift") {
-    const modifiedFiles = sessionMemory.getModifiedFiles();
-    const failedFiles = sessionMemory.getFailedFiles();
-    let unresolvedCount = 0;
-    for (const f of failedFiles) {
-      for (const ff of f.failures) {
-        if (!ff.resolved) unresolvedCount++;
-      }
-    }
-    if (modifiedFiles.length > 0 && !hasRunTests) {
-      drifts.push(`${modifiedFiles.length} file(s) edited but no test run`);
+    const unresolvedCount = getUnresolvedCount(stats.failedFiles);
+    const gitStat = getGitDiffStat();
+    const editCalls = stats.toolCalls.filter(
+      (c) => c.toolName === "precise_diff_editor" || c.toolName === "batch_file_writer"
+    ).length;
+    drifts.push(...buildDriftMessages(
+      stats.modifiedFiles.length,
+      stats.hasRunTests,
+      unresolvedCount,
+      gitStat
+    ));
+    if (stats.modifiedFiles.length > 0 && !stats.hasRunTests) {
       warnings.push({
         severity: "medium",
         pattern: "no-test-after-edit",
-        message: `${modifiedFiles.length} file(s) modified without running tests`,
+        message: `${stats.modifiedFiles.length} file(s) modified without running tests`,
         suggestion: 'Run execute_safe_test({ task: "typecheck" }) to verify changes'
       });
     }
-    if (unresolvedCount > 0) {
-      drifts.push(`${unresolvedCount} unresolved failure(s)`);
-    }
-    try {
-      const root = getProjectRoot();
-      const gitStat = execSync6("git diff --stat", {
-        cwd: root,
-        encoding: "utf-8",
-        timeout: 3e3
-      }).trim();
-      if (gitStat) {
-        drifts.push(`Git diff: ${gitStat}`);
-      }
-    } catch {
-    }
-    const editCalls = toolCalls.filter(
-      (c) => c.toolName === "precise_diff_editor" || c.toolName === "batch_file_writer"
-    ).length;
     if (editCalls > 5) {
       warnings.push({
         severity: "low",
@@ -4439,7 +4143,7 @@ async function handleKumaGuard(params) {
     }
   }
   if (check === "context") {
-    const snapshot = saveSnapshot(goal);
+    const snapshot = saveSnapshot(stats.goal);
     if (!snapshot) {
       return "\u26A0\uFE0F Could not create context snapshot. The .kuma directory might not be accessible.";
     }
@@ -4459,7 +4163,7 @@ async function handleKumaGuard(params) {
     suggestion = "Use smart_grep for code search instead of bash grep";
   } else if (warnings.some((w) => w.pattern === "excessive-edits")) {
     suggestion = "Pause and review: are all these edits necessary?";
-  } else if (!goal) {
+  } else if (!stats.goal) {
     suggestion = "No goal set \u2014 use goal parameter or setGoal to track intent";
   } else {
     suggestion = "On track \u2014 continue with current approach";
@@ -4471,12 +4175,12 @@ async function handleKumaGuard(params) {
     drifts,
     suggestion,
     stats: {
-      goal,
-      modifiedFiles: summary.modifiedFiles.length,
-      toolCalls: summary.toolCallCount ?? 0,
-      unresolvedFailures: summary.unresolvedFailures ? summary.unresolvedFailures.length : 0,
+      goal: stats.goal,
+      modifiedFiles: stats.modifiedFiles.length,
+      toolCalls: stats.toolCallCount,
+      unresolvedFailures: getUnresolvedCount(stats.failedFiles),
       hasLoop: loop.isLooping,
-      hasRunTests
+      hasRunTests: stats.hasRunTests
     }
   };
   return JSON.stringify(report, null, 2);
@@ -4524,25 +4228,25 @@ async function handleKumaContext(params) {
 }
 
 // src/tools/kumaInit.ts
-import fs13 from "fs";
-import path13 from "path";
+import fs12 from "fs";
+import path12 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 = path12.join(root, ".kuma");
+  const memoriesDir = path12.join(kumaDir, "memories");
+  const initMdPath = path12.join(kumaDir, "init.md");
   sessionMemory.recordToolCall("kuma_init", { projectRoot: root });
   let rules = "";
-  if (fs13.existsSync(initMdPath)) {
-    rules = fs13.readFileSync(initMdPath, "utf-8");
+  if (fs12.existsSync(initMdPath)) {
+    rules = fs12.readFileSync(initMdPath, "utf-8");
   }
   const memories = [];
-  if (fs13.existsSync(memoriesDir)) {
+  if (fs12.existsSync(memoriesDir)) {
     try {
-      const files = fs13.readdirSync(memoriesDir).filter((f) => f.endsWith(".md"));
+      const files = fs12.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 = fs12.readFileSync(path12.join(memoriesDir, file), "utf-8");
           memories.push({ topic: file.replace(/\.md$/, ""), content });
         } catch {
         }
@@ -4587,8 +4291,8 @@ ${memoryList}`);
 
 // src/engine/lspClient.ts
 import { spawn as spawn2 } from "child_process";
-import path14 from "path";
-import fs14 from "fs";
+import path13 from "path";
+import fs13 from "fs";
 var LSPClient = class {
   process = null;
   requestId = 0;
@@ -4626,8 +4330,8 @@ var LSPClient = class {
       console.error(`[LSP] typescript-language-server not found. LSP features will fallback to regex.`);
       return;
     }
-    const tsconfigPath = path14.join(root, "tsconfig.json");
-    if (!fs14.existsSync(tsconfigPath)) {
+    const tsconfigPath = path13.join(root, "tsconfig.json");
+    if (!fs13.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"], {
@@ -4689,19 +4393,19 @@ var LSPClient = class {
   /** Resolve the typescript-language-server binary from local or global install */
   resolveLspBinary(projectRoot) {
     const candidates = [
-      path14.join(projectRoot, "node_modules", ".bin", "typescript-language-server"),
-      path14.join(projectRoot, "..", "node_modules", ".bin", "typescript-language-server")
+      path13.join(projectRoot, "node_modules", ".bin", "typescript-language-server"),
+      path13.join(projectRoot, "..", "node_modules", ".bin", "typescript-language-server")
     ];
     for (const candidate of candidates) {
-      if (fs14.existsSync(candidate)) {
+      if (fs13.existsSync(candidate)) {
         return candidate;
       }
     }
     try {
       const envPath = process.env.PATH ?? "";
-      for (const dir of envPath.split(path14.delimiter)) {
-        const binPath = path14.join(dir, "typescript-language-server");
-        if (fs14.existsSync(binPath)) {
+      for (const dir of envPath.split(path13.delimiter)) {
+        const binPath = path13.join(dir, "typescript-language-server");
+        if (fs13.existsSync(binPath)) {
           return binPath;
         }
       }
@@ -4723,7 +4427,7 @@ var LSPClient = class {
     this.openDocuments.add(filePath);
     let content;
     try {
-      content = fs14.readFileSync(filePath, "utf-8");
+      content = fs13.readFileSync(filePath, "utf-8");
     } catch {
       content = "";
     }
@@ -4940,8 +4644,8 @@ var LSPClient = class {
 var lspClient = new LSPClient();
 
 // src/tools/lspTools.ts
-import fs15 from "fs";
-import path15 from "path";
+import fs14 from "fs";
+import path14 from "path";
 async function handleFindReferences(params) {
   const { filePath, line, character } = params;
   const validation = validateFilePath(filePath);
@@ -4949,7 +4653,7 @@ async function handleFindReferences(params) {
     return `Error: ${validation.error.message}`;
   }
   const resolvedPath = validation.resolvedPath;
-  if (!fs15.existsSync(resolvedPath)) {
+  if (!fs14.existsSync(resolvedPath)) {
     return `Error: File not found: "${filePath}".`;
   }
   if (!lspClient.isAvailable()) {
@@ -4974,7 +4678,7 @@ No references found for symbol at this position.`;
     const enrichedRefs = references.map((ref) => {
       let lineContent = "";
       try {
-        const content = fs15.readFileSync(ref.filePath, "utf-8");
+        const content = fs14.readFileSync(ref.filePath, "utf-8");
         const lines2 = content.split("\n");
         lineContent = lines2[ref.line]?.trim() ?? "";
       } catch {
@@ -4990,11 +4694,11 @@ No references found for symbol at this position.`;
     const projectRoot = getProjectRoot();
     const lines = [
       `**Find References** \u2014 ${enrichedRefs.length} references found`,
-      `\u{1F4CD} File: ${path15.relative(projectRoot, resolvedPath)}:${line + 1}:${character + 1}`,
+      `\u{1F4CD} File: ${path14.relative(projectRoot, resolvedPath)}:${line + 1}:${character + 1}`,
       ""
     ];
     for (const [file, refs] of grouped) {
-      const relPath = path15.relative(projectRoot, file);
+      const relPath = path14.relative(projectRoot, file);
       lines.push(`**\u{1F4C4} ${relPath}:**`);
       for (const ref of refs) {
         const loc = `L${ref.line + 1}:${ref.character + 1}`;
@@ -5015,7 +4719,7 @@ async function handleGoToDefinition(params) {
     return `Error: ${validation.error.message}`;
   }
   const resolvedPath = validation.resolvedPath;
-  if (!fs15.existsSync(resolvedPath)) {
+  if (!fs14.existsSync(resolvedPath)) {
     return `Error: File not found: "${filePath}".`;
   }
   if (!lspClient.isAvailable()) {
@@ -5038,10 +4742,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 = path15.relative(projectRoot, definition.filePath);
+    const relPath = path14.relative(projectRoot, definition.filePath);
     let lineContent = "";
     try {
-      const content = fs15.readFileSync(definition.filePath, "utf-8");
+      const content = fs14.readFileSync(definition.filePath, "utf-8");
       const lines2 = content.split("\n");
       lineContent = lines2[definition.line]?.trim() ?? "";
     } catch {
@@ -5073,7 +4777,7 @@ async function handleRenameSymbol(params) {
     return `Error: ${validation.error.message}`;
   }
   const resolvedPath = validation.resolvedPath;
-  if (!fs15.existsSync(resolvedPath)) {
+  if (!fs14.existsSync(resolvedPath)) {
     return `Error: File not found: "${filePath}".`;
   }
   if (!lspClient.isAvailable()) {
@@ -5104,7 +4808,7 @@ Make sure:
     const fileChanges = [];
     for (const change of result.changes) {
       try {
-        const content = fs15.readFileSync(change.filePath, "utf-8");
+        const content = fs14.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;
@@ -5118,10 +4822,10 @@ Make sure:
             lines2[edit.line] = before + edit.newText + after;
           }
         }
-        fs15.writeFileSync(change.filePath, lines2.join("\n"), "utf-8");
+        fs14.writeFileSync(change.filePath, lines2.join("\n"), "utf-8");
         totalEdits += change.edits.length;
         fileChanges.push({
-          filePath: path15.relative(projectRoot, change.filePath),
+          filePath: path14.relative(projectRoot, change.filePath),
           editCount: change.edits.length
         });
       } catch (err) {
@@ -5148,14 +4852,14 @@ async function handleGetTypeInfo(params) {
     return `Error: ${validation.error.message}`;
   }
   const resolvedPath = validation.resolvedPath;
-  if (!fs15.existsSync(resolvedPath)) {
+  if (!fs14.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 = fs15.readFileSync(resolvedPath, "utf-8");
+      const fileContent = fs14.readFileSync(resolvedPath, "utf-8");
       const fileLines = fileContent.split("\n");
       const targetLine = fileLines[line];
       if (!targetLine) {
@@ -5163,7 +4867,7 @@ async function handleGetTypeInfo(params) {
       }
       const symbolName = extractSymbolAtPosition(resolvedPath, line, character);
       const projectRoot = getProjectRoot();
-      const relPath = path15.relative(projectRoot, resolvedPath);
+      const relPath = path14.relative(projectRoot, resolvedPath);
       const contextStart = Math.max(0, line - 3);
       const contextEnd = Math.min(fileLines.length, line + 4);
       const contextLines = [];
@@ -5198,7 +4902,7 @@ async function handleGetTypeInfo(params) {
 No type info for this position.`;
     }
     const projectRoot = getProjectRoot();
-    const relPath = path15.relative(projectRoot, resolvedPath);
+    const relPath = path14.relative(projectRoot, resolvedPath);
     const lines = [
       `\u{1F4CB} **Type Info** \u2014 \`${relPath}:${line + 1}:${character + 1}\``,
       "",
@@ -5239,7 +4943,7 @@ async function handleLspQuery(params) {
 }
 function extractSymbolAtPosition(filePath, line, character) {
   try {
-    const content = fs15.readFileSync(filePath, "utf-8");
+    const content = fs14.readFileSync(filePath, "utf-8");
     const lines = content.split("\n");
     const targetLine = lines[line];
     if (!targetLine) return null;
@@ -5270,7 +4974,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 = fs15.readFileSync(file, "utf-8");
+        const content = fs14.readFileSync(file, "utf-8");
         const lines2 = content.split("\n");
         for (let i = 0; i < lines2.length; i++) {
           if (regex.test(lines2[i])) {
@@ -5299,7 +5003,7 @@ No references found. Symbol may not be used in other files.`;
       ""
     ];
     if (grouped.size > 1) {
-      const fileList = [...grouped.keys()].map((f) => path15.relative(projectRoot, f)).join(", ");
+      const fileList = [...grouped.keys()].map((f) => path14.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("");
@@ -5316,7 +5020,7 @@ No references found. Symbol may not be used in other files.`;
       }
     }
     for (const [file, refs] of grouped) {
-      const relPath = path15.relative(projectRoot, file);
+      const relPath = path14.relative(projectRoot, file);
       lines.push(`**\u{1F4C4} ${relPath}:**`);
       for (const ref of refs) {
         lines.push(`  \u2514 L${ref.line} \u2014 ${ref.content}`);
@@ -5350,14 +5054,14 @@ async function fallbackGrepDefinition(symbolName) {
     ];
     for (const file of tsFiles) {
       try {
-        const content = fs15.readFileSync(file, "utf-8");
+        const content = fs14.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 = path15.relative(projectRoot, file);
+              const relPath = path14.relative(projectRoot, file);
               return [
                 `\u{1F4CD} **Go to Definition**`,
                 `\u{1F4C4} File: \`${relPath}\``,
@@ -5379,6 +5083,543 @@ Cannot find definition.`;
   }
 }
 
+// src/tools/kumaPolicy.ts
+import fs15 from "fs";
+import path15 from "path";
+var DEFAULT_POLICY = {
+  never_touch: [
+    ".env",
+    ".env.local",
+    ".env.production",
+    ".env.development",
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "node_modules/**"
+  ],
+  block_commands: [
+    "rm -rf",
+    "rm -fr",
+    "git push --force",
+    "git push -f",
+    "npm publish",
+    "yarn publish",
+    "pnpm publish",
+    "curl | bash",
+    "curl | sh"
+  ]
+};
+function loadPolicy() {
+  const root = getProjectRoot();
+  const ymlPath = path15.join(root, ".kuma", "policy.yml");
+  const yamlPath = path15.join(root, ".kuma", "policy.yaml");
+  let policyContent = null;
+  let policyPath = null;
+  if (fs15.existsSync(ymlPath)) {
+    policyContent = fs15.readFileSync(ymlPath, "utf-8");
+    policyPath = ymlPath;
+  } else if (fs15.existsSync(yamlPath)) {
+    policyContent = fs15.readFileSync(yamlPath, "utf-8");
+    policyPath = yamlPath;
+  }
+  if (!policyContent) {
+    return { ...DEFAULT_POLICY };
+  }
+  try {
+    return parseSimpleYaml(policyContent);
+  } catch (err) {
+    console.error(`[Policy] Failed to parse ${policyPath}: ${err}. Using defaults.`);
+    return { ...DEFAULT_POLICY };
+  }
+}
+function parseSimpleYaml(content) {
+  const policy = {};
+  const lines = content.split("\n");
+  let currentKey = null;
+  let currentArray = [];
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const keyMatch = line.match(/^(\w[\w_-]*):\s*(.*)/);
+    if (keyMatch) {
+      if (currentKey && currentArray.length > 0) {
+        setPolicyValue(policy, currentKey, currentArray);
+        currentArray = [];
+      }
+      currentKey = keyMatch[1];
+      const value = keyMatch[2].trim();
+      if (value === "" || value === "|") {
+        currentArray = [];
+      } else {
+        if (value.startsWith("[") && value.endsWith("]")) {
+          const items = value.slice(1, -1).split(",").map((s) => s.trim().replace(/^['"]|['"]$/g, ""));
+          setPolicyValue(policy, currentKey, items);
+        } else {
+          setPolicyValue(policy, currentKey, value.replace(/^['"]|['"]$/g, ""));
+        }
+        currentKey = null;
+      }
+    } else if (currentKey && line.startsWith("- ")) {
+      currentArray.push(line.slice(2).trim().replace(/^['"]|['"]$/g, ""));
+    }
+  }
+  if (currentKey && currentArray.length > 0) {
+    setPolicyValue(policy, currentKey, currentArray);
+  }
+  return policy;
+}
+function setPolicyValue(policy, key, value) {
+  switch (key) {
+    case "never_touch":
+      policy.never_touch = value;
+      break;
+    case "require_review":
+      policy.require_review = value;
+      break;
+    case "require_tests":
+      policy.require_tests = value;
+      break;
+    case "max_file_size":
+      policy.max_file_size = Number(value);
+      break;
+    case "block_commands":
+      policy.block_commands = value;
+      break;
+  }
+}
+function matchesGlob(pattern, filePath) {
+  const normalizedPattern = pattern.replace(/\\/g, "/");
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  let regexStr = "^";
+  for (let i = 0; i < normalizedPattern.length; i++) {
+    const ch = normalizedPattern[i];
+    if (ch === "*" && normalizedPattern[i + 1] === "*" && normalizedPattern[i + 2] === "/") {
+      regexStr += "(.+/)?";
+      i += 2;
+    } else if (ch === "*") {
+      regexStr += "[^/]*";
+    } else if (ch === "?") {
+      regexStr += "[^/]";
+    } else {
+      regexStr += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+  }
+  regexStr += "$";
+  try {
+    return new RegExp(regexStr).test(normalizedPath);
+  } catch {
+    return false;
+  }
+}
+function checkFilePathPolicy(filePath, policy) {
+  const violations = [];
+  const warnings = [];
+  if (policy.never_touch) {
+    for (const pattern of policy.never_touch) {
+      if (matchesGlob(pattern, filePath)) {
+        violations.push({
+          rule: "never_touch",
+          pattern,
+          message: `File "${filePath}" matches never_touch pattern "${pattern}"`,
+          severity: "error"
+        });
+      }
+    }
+  }
+  if (policy.max_file_size && policy.max_file_size > 0) {
+    try {
+      const root = getProjectRoot();
+      const fullPath = path15.join(root, filePath);
+      if (fs15.existsSync(fullPath)) {
+        const sizeKB = fs15.statSync(fullPath).size / 1024;
+        if (sizeKB > policy.max_file_size) {
+          violations.push({
+            rule: "max_file_size",
+            pattern: `${policy.max_file_size}KB`,
+            message: `File "${filePath}" is ${Math.round(sizeKB)}KB, exceeds max_file_size of ${policy.max_file_size}KB`,
+            severity: "error"
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  if (policy.require_review) {
+    for (const pattern of policy.require_review) {
+      if (matchesGlob(pattern, filePath)) {
+        warnings.push({
+          rule: "require_review",
+          message: `File "${filePath}" requires review (matches "${pattern}")`
+        });
+      }
+    }
+  }
+  return { violations, warnings };
+}
+
+// src/engine/kumaDb.ts
+import initSqlJs from "sql.js";
+import fs16 from "fs";
+import path16 from "path";
+var DB_FILENAME = "kuma.db";
+var dbInstance = null;
+var initPromise = null;
+async function getDb() {
+  if (dbInstance) return dbInstance;
+  if (initPromise) return initPromise;
+  initPromise = initDb();
+  return initPromise;
+}
+async function initDb() {
+  const SQL = await initSqlJs();
+  const kumaDir = getKumaDir();
+  const dbPath = path16.join(kumaDir, DB_FILENAME);
+  if (!fs16.existsSync(kumaDir)) {
+    fs16.mkdirSync(kumaDir, { recursive: true });
+  }
+  let db;
+  if (fs16.existsSync(dbPath)) {
+    const buffer = fs16.readFileSync(dbPath);
+    db = new SQL.Database(buffer);
+  } else {
+    db = new SQL.Database();
+  }
+  db.run("PRAGMA journal_mode=WAL");
+  db.run("PRAGMA synchronous=NORMAL");
+  createSchema(db);
+  saveDb(db);
+  dbInstance = db;
+  return db;
+}
+function saveDb(db) {
+  const d = db ?? dbInstance;
+  if (!d) return;
+  try {
+    const kumaDir = getKumaDir();
+    const dbPath = path16.join(kumaDir, DB_FILENAME);
+    const data = d.export();
+    const buffer = Buffer.from(data);
+    fs16.writeFileSync(dbPath, buffer);
+  } catch (err) {
+    console.error(`[KumaDB] Failed to save database: ${err}`);
+  }
+}
+function createSchema(db) {
+  db.run(`
+    CREATE TABLE IF NOT EXISTS nodes (
+      id TEXT PRIMARY KEY,
+      type TEXT NOT NULL CHECK(type IN ('function','file','api_route','db_table','test','class','interface','type','module','variable')),
+      name TEXT NOT NULL,
+      file_path TEXT,
+      metadata TEXT DEFAULT '{}',
+      created_at INTEGER NOT NULL DEFAULT (strftime('%s','now')),
+      updated_at INTEGER NOT NULL DEFAULT (strftime('%s','now'))
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS edges (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      source_id TEXT NOT NULL REFERENCES nodes(id),
+      target_id TEXT NOT NULL REFERENCES nodes(id),
+      type TEXT NOT NULL CHECK(type IN ('calls','imports','defines','tests','routes','implements','extends','depends_on','owns','modified_by')),
+      weight REAL DEFAULT 1.0,
+      metadata TEXT DEFAULT '{}',
+      created_at INTEGER NOT NULL DEFAULT (strftime('%s','now')),
+      UNIQUE(source_id, target_id, type)
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      started_at INTEGER NOT NULL,
+      ended_at INTEGER,
+      goal TEXT,
+      tool_calls INTEGER DEFAULT 0,
+      edits INTEGER DEFAULT 0,
+      rollbacks INTEGER DEFAULT 0,
+      failures INTEGER DEFAULT 0,
+      safety_score INTEGER
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS tool_calls (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id INTEGER REFERENCES sessions(id),
+      tool_name TEXT NOT NULL,
+      params TEXT,
+      success INTEGER DEFAULT 1,
+      duration_ms INTEGER,
+      created_at INTEGER NOT NULL DEFAULT (strftime('%s','now'))
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS experiences (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      tool_name TEXT NOT NULL,
+      params_hash TEXT NOT NULL,
+      success INTEGER NOT NULL DEFAULT 1,
+      duration_ms INTEGER,
+      error_pattern TEXT,
+      context_file TEXT,
+      context_action TEXT,
+      created_at INTEGER NOT NULL DEFAULT (strftime('%s','now'))
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS experience_patterns (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      antecedent_tool TEXT NOT NULL,
+      antecedent_hash TEXT NOT NULL,
+      consequent_tool TEXT NOT NULL,
+      confidence REAL DEFAULT 0.0,
+      count INTEGER DEFAULT 1,
+      avg_duration_ms INTEGER DEFAULT 0,
+      success_rate REAL DEFAULT 1.0,
+      last_seen_at INTEGER NOT NULL DEFAULT (strftime('%s','now')),
+      UNIQUE(antecedent_tool, antecedent_hash, consequent_tool)
+    )
+  `);
+  try {
+    db.run(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS nodes_fts USING fts5(
+        name,
+        metadata,
+        content='nodes',
+        content_rowid='rowid'
+      )
+    `);
+  } catch {
+    console.warn("[KumaDB] FTS5 not available, full-text search disabled");
+  }
+  db.run(`CREATE INDEX IF NOT EXISTS idx_nodes_type ON nodes(type)`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_nodes_name ON nodes(name)`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_id)`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_id)`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_edges_type ON edges(type)`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_tool_calls_session ON tool_calls(session_id)`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_tool_calls_created ON tool_calls(created_at)`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_experiences_tool ON experiences(tool_name)`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_experiences_hash ON experiences(params_hash)`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_experiences_created ON experiences(created_at)`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_patterns_antecedent ON experience_patterns(antecedent_tool)`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_patterns_confidence ON experience_patterns(confidence DESC)`);
+}
+
+// src/engine/safetyAudit.ts
+var SCHEMA_SQL = `
+  CREATE TABLE IF NOT EXISTS safety_audit (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    timestamp INTEGER NOT NULL,
+    tool_name TEXT NOT NULL,
+    action TEXT NOT NULL,
+    file_path TEXT,
+    risk_level TEXT NOT NULL DEFAULT 'low',
+    policy_violations INTEGER DEFAULT 0,
+    allowed INTEGER NOT NULL DEFAULT 1,
+    duration_ms INTEGER DEFAULT 0,
+    metadata TEXT DEFAULT '{}'
+  );
+  CREATE INDEX IF NOT EXISTS idx_audit_timestamp ON safety_audit(timestamp);
+  CREATE INDEX IF NOT EXISTS idx_audit_tool ON safety_audit(tool_name);
+  CREATE INDEX IF NOT EXISTS idx_audit_risk ON safety_audit(risk_level);
+  CREATE INDEX IF NOT EXISTS idx_audit_allowed ON safety_audit(allowed);
+`;
+var schemaEnsured = false;
+async function ensureSchema() {
+  if (schemaEnsured) return;
+  try {
+    const db = await getDb();
+    db.exec(SCHEMA_SQL);
+    saveDb();
+    schemaEnsured = true;
+  } catch (err) {
+    console.error(`[SafetyAudit] Failed to ensure schema: ${err}`);
+  }
+}
+async function recordAudit(entry) {
+  try {
+    await ensureSchema();
+    const db = await getDb();
+    db.run(`
+      INSERT INTO safety_audit (timestamp, tool_name, action, file_path, risk_level, policy_violations, allowed, duration_ms, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `, [
+      entry.timestamp,
+      entry.toolName,
+      entry.action,
+      entry.filePath || null,
+      entry.riskLevel,
+      entry.policyViolations,
+      entry.allowed ? 1 : 0,
+      entry.durationMs,
+      JSON.stringify(entry.metadata || {})
+    ]);
+    saveDb();
+  } catch (err) {
+    console.error(`[SafetyAudit] Failed to record audit: ${err}`);
+  }
+}
+
+// src/engine/kumaSafetyProxy.ts
+async function preCheck(toolName, params, opts = {}) {
+  const messages = [];
+  let policyViolations = 0;
+  let highestRisk = "low";
+  const blockThreshold = opts.blockRiskThreshold || "high";
+  const filePath = opts.extractFilePath?.(params);
+  if (filePath) {
+    const validation = validateFilePath(filePath);
+    if (!validation.valid) {
+      messages.push(`\u{1F6AB} Path blocked: ${validation.error.message}`);
+      policyViolations++;
+      highestRisk = "critical";
+    }
+  }
+  const policy = loadPolicy();
+  if (filePath) {
+    const { violations, warnings } = checkFilePathPolicy(filePath, policy);
+    policyViolations += violations.length;
+    for (const v of violations) {
+      messages.push(`\u{1F4DC} Policy violation (${v.rule}): ${v.message}`);
+      highestRisk = "critical";
+    }
+    for (const w of warnings) {
+      messages.push(`\u26A0\uFE0F Policy warning (${w.rule}): ${w.message}`);
+      if (highestRisk === "low") highestRisk = "medium";
+    }
+  }
+  const command = opts.extractCommand?.(params);
+  if (command) {
+    const dangerousPatterns = [
+      "rm -rf",
+      "rm -fr",
+      "git push",
+      "git commit",
+      "npm publish",
+      "yarn publish",
+      "pnpm publish",
+      "| bash",
+      "| sh",
+      "eval ",
+      "exec ",
+      "mkfs",
+      "dd if=",
+      "shred"
+    ];
+    const matched = dangerousPatterns.find((p) => command.toLowerCase().includes(p));
+    if (matched) {
+      messages.push(`\u{1F6AB} Command blocked: contains dangerous pattern "${matched}"`);
+      policyViolations++;
+      highestRisk = "critical";
+    }
+  }
+  try {
+    const db = await getDb();
+    const recentFailures = db.exec("SELECT COUNT(*) as c FROM failure_kb WHERE resolved = 0")[0]?.values[0][0] ?? 0;
+    if (recentFailures > 3 && (toolName.includes("edit") || toolName === "precise_diff_editor")) {
+      messages.push(`\u26A0\uFE0F ${recentFailures} unresolved failures \u2014 consider fixing them before editing`);
+      if (highestRisk === "low") highestRisk = "medium";
+    }
+  } catch {
+  }
+  try {
+    const summary = sessionMemory.getSummary();
+    const goal = summary.currentGoal;
+    if (!goal && (toolName === "precise_diff_editor" || toolName === "batch_file_writer")) {
+      messages.push("\u{1F4A1} No goal set \u2014 consider setting a goal with setGoal() to track intent");
+    }
+  } catch {
+  }
+  const riskLevel = highestRisk;
+  const thresholdLevels = ["low", "medium", "high", "critical"];
+  const thresholdIndex = thresholdLevels.indexOf(blockThreshold);
+  const riskIndex = thresholdLevels.indexOf(riskLevel);
+  const allowed = opts.blockOnViolation !== false ? riskIndex < thresholdIndex : policyViolations === 0;
+  return { allowed, riskLevel, policyViolations, messages };
+}
+function wrapWithSafety(toolName, handler, opts = {}) {
+  return async (params) => {
+    const startTime = Date.now();
+    const p = params;
+    const action = p.action || "execute";
+    try {
+      const verdict = await preCheck(toolName, p, opts);
+      const filePath = opts.extractFilePath?.(p);
+      if (!verdict.allowed) {
+        await recordAudit({
+          timestamp: Math.floor(startTime / 1e3),
+          toolName,
+          action,
+          filePath,
+          riskLevel: verdict.riskLevel,
+          policyViolations: verdict.policyViolations,
+          allowed: false,
+          durationMs: Date.now() - startTime,
+          metadata: { blocked: true, messages: verdict.messages }
+        });
+        return formatBlocked(verdict, toolName);
+      }
+      const result = await handler(params);
+      const durationMs = Date.now() - startTime;
+      await recordAudit({
+        timestamp: Math.floor(startTime / 1e3),
+        toolName,
+        action,
+        filePath,
+        riskLevel: verdict.riskLevel,
+        policyViolations: verdict.policyViolations,
+        allowed: true,
+        durationMs,
+        metadata: { success: true }
+      });
+      if (verdict.messages.length > 0) {
+        const warnings = verdict.messages.filter((m) => m.startsWith("\u26A0\uFE0F") || m.startsWith("\u{1F4A1}")).join("\n");
+        if (warnings) {
+          return `${result}
+
+\u{1F6E1}\uFE0F **Safety Context:**
+${warnings}`;
+        }
+      }
+      return result;
+    } catch (err) {
+      const durationMs = Date.now() - startTime;
+      await recordAudit({
+        timestamp: Math.floor(startTime / 1e3),
+        toolName,
+        action,
+        riskLevel: "critical",
+        policyViolations: 0,
+        allowed: false,
+        durationMs,
+        metadata: { error: String(err) }
+      });
+      return `\u26A0\uFE0F **Safety Proxy Error** \u2014 ${toolName} failed safety check:
+${err}`;
+    }
+  };
+}
+function formatBlocked(verdict, toolName) {
+  const icon = verdict.riskLevel === "critical" ? "\u{1F534}" : verdict.riskLevel === "high" ? "\u{1F7E0}" : "\u{1F7E1}";
+  const lines = [
+    `${icon} **Safety AI Layer \u2014 \u26D4 Blocked**`,
+    `\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`,
+    "",
+    `\u{1F3AF} Tool: **${toolName}**`,
+    `\u26A0\uFE0F Risk Level: **${verdict.riskLevel.toUpperCase()}**`,
+    `\u{1F4DC} Policy Violations: ${verdict.policyViolations}`,
+    "",
+    ...verdict.messages,
+    "",
+    "\u{1F4A1} **Resolution steps:**",
+    "  1. Review the policy violations above",
+    "  2. If editing: use precise_diff_editor with proper params",
+    "  3. If command: avoid dangerous patterns",
+    "  4. To bypass: kuma_safety({ action: 'override', tool: '...' })"
+  ];
+  return lines.join("\n");
+}
+
 // src/manifest.ts
 var MEMORY_TOPICS = ["decisions", "glossary", "architecture", "conventions", "known-issues"];
 function registerAllTools(server) {
@@ -5418,6 +5659,9 @@ function registerAllTools(server) {
       }
     }
   );
+  const safeEditHandler = wrapWithSafety("precise_diff_editor", handlePreciseDiffEditor, {
+    extractFilePath: (p) => p.filePath
+  });
   server.tool(
     "precise_diff_editor",
     "Edit code with safety net. Search-and-replace with fuzzy fallback + automatic versioned backup. Use action:'rollback' to undo edits.",
@@ -5433,11 +5677,13 @@ function registerAllTools(server) {
         invalid_type_error: 'precise_diff_editor: "edits" must be an ARRAY of { searchBlock, replaceBlock } objects.\n\n\u2705 Correct format:\n{\n  edits: [\n    { searchBlock: "old code", replaceBlock: "new code" }\n  ]\n}'
       }).min(1).max(10).optional().describe("Array of edits (max 10). Each edit has: searchBlock (code to find), replaceBlock (new code)"),
       dryRun: z.boolean().optional().default(false).describe("Preview changes without writing to disk. Set dryRun: true to preview first."),
-      version: z.union([z.number().min(1), z.literal("list")]).optional().describe("Backup version to restore (1=newest, omit=latest, 'list'=show versions)")
+      version: z.union([z.number().min(1), z.literal("list")]).optional().describe("Backup version to restore (1=newest, omit=latest, 'list'=show versions)"),
+      scope: z.enum(["file", "dir", "edit-id", "commit"]).optional().describe("Rollback scope: file (default), dir (directory). Requires filePath. edit-id (by edit ID). Requires editId. commit (git-based)."),
+      editId: z.string().optional().describe("Edit ID for edit-id scoped rollback. Use scope:'edit-id' with version:'list' to see all tracked edit IDs.")
     },
     async (params) => {
       try {
-        const result = await handlePreciseDiffEditor(params);
+        const result = await safeEditHandler(params);
         return { content: [{ type: "text", text: result }] };
       } catch (err) {
         return { content: [{ type: "text", text: `Error in precise_diff_editor: ${err}` }], isError: true };
@@ -5718,7 +5964,7 @@ function registerAllTools(server) {
       }
     }
   );
-  console.error("[Manifest] Registered 18 tools.");
+  console.error("[Manifest] Registered 19 tools.");
 }
 
 // src/index.ts
@@ -5819,22 +6065,23 @@ async function main() {
     });
     const output = formatInitResults(results);
     console.log(output);
-    const fs16 = await import("fs");
-    const path16 = await import("path");
-    const matchaSkills = path16.resolve(process.cwd(), "skills/matcha/SKILL.md");
-    const matchaAgents = path16.resolve(
+    const fs17 = await import("fs");
+    const path17 = await import("path");
+    const matchaSkills = path17.resolve(process.cwd(), "skills/matcha/SKILL.md");
+    const matchaAgents = path17.resolve(
       process.cwd(),
       ".agents/skills/matcha/SKILL.md"
     );
-    const matchaCursor = path16.resolve(
+    const matchaRootSkills = path17.resolve(
       process.cwd(),
-      ".cursor/rules/matcha.mdc"
+      "skills/matcha/SKILL.md"
     );
-    const matchaWindsurf = path16.resolve(
+    const matchaAgentsMd = path17.resolve(process.cwd(), "AGENTS.md");
+    const matchaWindsurfRules = path17.resolve(
       process.cwd(),
-      ".windsurf/rules/matcha.md"
+      ".windsurfrules"
     );
-    if (fs16.existsSync(matchaSkills) || fs16.existsSync(matchaAgents) || fs16.existsSync(matchaCursor) || fs16.existsSync(matchaWindsurf)) {
+    if (fs17.existsSync(matchaSkills) || fs17.existsSync(matchaAgents) || fs17.existsSync(matchaRootSkills) || fs17.existsSync(matchaAgentsMd) || fs17.existsSync(matchaWindsurfRules)) {
       console.error(
         "\n\u{1F375} Hey, I see matcha is installed \u2014 they pair well together!"
       );
@@ -5847,20 +6094,56 @@ async function main() {
   });
   (async () => {
     try {
-      const { generateInitMdContent } = await import("./init-AMRMKI4X.js");
-      const fs16 = await import("fs");
-      const path16 = await import("path");
-      const initMdPath = path16.resolve(process.cwd(), ".kuma/init.md");
-      if (!fs16.existsSync(initMdPath)) {
-        const kumaDir = path16.dirname(initMdPath);
-        if (!fs16.existsSync(kumaDir)) fs16.mkdirSync(kumaDir, { recursive: true });
-        fs16.writeFileSync(initMdPath, generateInitMdContent(), "utf-8");
+      const { generateInitMdContent } = await import("./init-WZADRE7F.js");
+      const fs17 = await import("fs");
+      const path17 = await import("path");
+      const initMdPath = path17.resolve(process.cwd(), ".kuma/init.md");
+      if (!fs17.existsSync(initMdPath)) {
+        const kumaDir = path17.dirname(initMdPath);
+        if (!fs17.existsSync(kumaDir)) fs17.mkdirSync(kumaDir, { recursive: true });
+        fs17.writeFileSync(initMdPath, generateInitMdContent(), "utf-8");
         console.error(`[${SERVER_NAME}] Auto-generated .kuma/init.md`);
       }
     } catch (err) {
       console.error(`[${SERVER_NAME}] Failed to auto-generate .kuma/init.md: ${err}`);
     }
   })();
+  (async () => {
+    try {
+      const { detectAgent, getSkillPath, getAgentLabel } = await import("./agentDetector-AHKFSZGQ.js");
+      const { generateSkill, getSecondaryFiles } = await import("./skillGenerator-F6YO4H5D.js");
+      const fs17 = await import("fs");
+      const path17 = await import("path");
+      const detection = detectAgent();
+      if (!detection.primary) {
+        console.error(`[${SERVER_NAME}] No AI agent detected \u2014 skipping auto-skill creation`);
+        return;
+      }
+      const agentType = detection.primary;
+      const skillPath = getSkillPath(agentType);
+      const fullPath = path17.resolve(process.cwd(), skillPath);
+      if (fs17.existsSync(fullPath)) {
+        console.error(`[${SERVER_NAME}] Skill exists for ${getAgentLabel(agentType)} \u2014 skipping`);
+        return;
+      }
+      const dir = path17.dirname(fullPath);
+      if (!fs17.existsSync(dir)) fs17.mkdirSync(dir, { recursive: true });
+      fs17.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 = path17.resolve(process.cwd(), sf.path);
+        const sfDir = path17.dirname(sfPath);
+        if (!fs17.existsSync(sfPath)) {
+          if (!fs17.existsSync(sfDir)) fs17.mkdirSync(sfDir, { recursive: true });
+          fs17.writeFileSync(sfPath, sf.content, "utf-8");
+          console.error(`[${SERVER_NAME}] Auto-created ${sf.path}`);
+        }
+      }
+    } catch (err) {
+      console.error(`[${SERVER_NAME}] Failed to auto-create skill file: ${err}`);
+    }
+  })();
   const server = new McpServer(
     {
       name: SERVER_NAME,