@plumpslabs/kuma 2.1.2 → 2.1.4

package/dist/index.js

@@ -1,4 +1,14 @@
 #!/usr/bin/env node
+import {
+  ALL_CONFIG_TYPES,
+  ensureBackupDir,
+  formatInitResults,
+  getBackupPath,
+  getProjectRoot,
+  runInit,
+  validateFileExtension,
+  validateFilePath
+} from "./chunk-P5Y7IAUC.js";
 
 // src/index.ts
 import { readFileSync } from "fs";
@@ -11,157 +21,8 @@ import { z } from "zod";
 
 // src/tools/smartGrep.ts
 import fg from "fast-glob";
-import fs3 from "fs";
-import path3 from "path";
-
-// src/utils/pathValidator.ts
-import path from "path";
-import fs from "fs";
-function validateFilePath(filePath, projectRoot) {
-  try {
-    const root = projectRoot ?? getProjectRoot();
-    const resolvedRoot = path.resolve(root);
-    const normalizedRoot = path.normalize(resolvedRoot).toLowerCase();
-    let resolvedPath;
-    if (!path.isAbsolute(filePath)) {
-      const cwdPath = path.resolve(process.cwd(), filePath);
-      const normalizedCwdPath = path.normalize(cwdPath).toLowerCase();
-      if (fs.existsSync(cwdPath) && normalizedCwdPath.startsWith(normalizedRoot)) {
-        resolvedPath = cwdPath;
-      } else {
-        resolvedPath = path.resolve(resolvedRoot, filePath);
-      }
-    } else {
-      resolvedPath = path.resolve(resolvedRoot, filePath);
-    }
-    const normalizedPath = path.normalize(resolvedPath).toLowerCase();
-    if (!normalizedPath.startsWith(normalizedRoot)) {
-      return {
-        valid: false,
-        error: new Error(
-          `PATH_TRAVERSAL: Access denied. Path "${filePath}" resolves outside project root "${resolvedRoot}".`
-        )
-      };
-    }
-    if (normalizedPath.includes("..")) {
-      return {
-        valid: false,
-        error: new Error(
-          `PATH_TRAVERSAL: Path traversal detected in "${filePath}". Relative paths with ".." are not allowed.`
-        )
-      };
-    }
-    const blockedPatterns = [
-      "/etc/",
-      "/sys/",
-      "/proc/",
-      "/dev/",
-      "/boot/",
-      "/usr/",
-      "C:\\Windows",
-      "C:\\Program Files",
-      "C:\\Program Files (x86)",
-      "C:\\System32",
-      "~/.ssh",
-      "/root/"
-    ];
-    for (const pattern of blockedPatterns) {
-      if (normalizedPath.includes(pattern.toLowerCase())) {
-        return {
-          valid: false,
-          error: new Error(
-            `PATH_TRAVERSAL: Access to system directory "${pattern}" is blocked.`
-          )
-        };
-      }
-    }
-    try {
-      if (fs.existsSync(resolvedPath)) {
-        const realPath = fs.realpathSync(resolvedPath);
-        const normalizedRealPath = path.normalize(realPath).toLowerCase();
-        if (!normalizedRealPath.startsWith(normalizedRoot)) {
-          return {
-            valid: false,
-            error: new Error(
-              `PATH_TRAVERSAL: Symlink escape detected. Path "${filePath}" resolves to "${realPath}" which is outside project root "${resolvedRoot}".`
-            )
-          };
-        }
-      }
-    } catch {
-    }
-    if (normalizedPath.includes("node_modules")) {
-      return {
-        valid: true,
-        resolvedPath
-        // Warning will be handled by caller
-      };
-    }
-    return { valid: true, resolvedPath };
-  } catch (err) {
-    return {
-      valid: false,
-      error: err instanceof Error ? err : new Error(`Path validation error: ${String(err)}`)
-    };
-  }
-}
-function validateFileExtension(filePath) {
-  const allowedExtensions = [
-    ".ts",
-    ".tsx",
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-    ".json",
-    ".md",
-    ".css",
-    ".html",
-    ".htm",
-    ".env",
-    ".env.example",
-    ".env.local",
-    ".yml",
-    ".yaml",
-    ".toml",
-    ".svg",
-    ".png",
-    ".jpg",
-    ".gif",
-    ".sh",
-    ".bat",
-    ".ps1",
-    ".sql",
-    ".graphql",
-    ".gql",
-    ".vue",
-    ".svelte",
-    ".astro",
-    ".prisma",
-    ".proto",
-    ".txt",
-    ".log"
-  ];
-  const ext = path.extname(filePath).toLowerCase();
-  return allowedExtensions.includes(ext);
-}
-function getProjectRoot() {
-  return process.env.AGENT_PROJECT_ROOT ?? process.cwd();
-}
-function getBackupPath(filePath, timestamp) {
-  const ts = timestamp ?? Date.now();
-  const root = getProjectRoot();
-  const relativePath = path.relative(root, filePath);
-  return path.join(root, ".agent-backups", String(ts), relativePath);
-}
-function ensureBackupDir() {
-  const root = getProjectRoot();
-  const backupDir = path.join(root, ".agent-backups");
-  if (!fs.existsSync(backupDir)) {
-    fs.mkdirSync(backupDir, { recursive: true });
-  }
-  return backupDir;
-}
+import fs2 from "fs";
+import path2 from "path";
 
 // src/utils/tokenCounter.ts
 function estimateTokens(text) {
@@ -186,33 +47,33 @@ function limitLines(text, maxLines) {
 }
 
 // src/engine/sessionMemory.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs from "fs";
+import path from "path";
 var SessionMemory = class {
   state;
   initialized = false;
   init(config) {
-    const kumaDir = path2.join(config.projectRoot, ".kuma");
-    const sessionFile = path2.join(kumaDir, "memory.json");
-    const oldFile = path2.join(kumaDir, ".kuma-memory.json");
-    if (fs2.existsSync(oldFile) && !fs2.existsSync(sessionFile)) {
+    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 {
-        fs2.renameSync(oldFile, sessionFile);
+        fs.renameSync(oldFile, sessionFile);
         console.error("[SessionMemory] Migrated .kuma-memory.json \u2192 memory.json");
       } catch {
       }
     }
-    const oldSessionFile = path2.join(kumaDir, "session.json");
-    if (fs2.existsSync(oldSessionFile) && !fs2.existsSync(sessionFile)) {
+    const oldSessionFile = path.join(kumaDir, "session.json");
+    if (fs.existsSync(oldSessionFile) && !fs.existsSync(sessionFile)) {
       try {
-        fs2.renameSync(oldSessionFile, sessionFile);
+        fs.renameSync(oldSessionFile, sessionFile);
         console.error("[SessionMemory] Migrated session.json \u2192 memory.json");
       } catch {
       }
     }
-    if (fs2.existsSync(sessionFile)) {
+    if (fs.existsSync(sessionFile)) {
       try {
-        const raw = fs2.readFileSync(sessionFile, "utf-8");
+        const raw = fs.readFileSync(sessionFile, "utf-8");
         const parsed = JSON.parse(raw);
         this.state = {
           projectRoot: parsed.projectRoot || config.projectRoot,
@@ -250,23 +111,23 @@ var SessionMemory = class {
     console.error(`[SessionMemory] Initialized at ${new Date(config.startTime).toISOString()}`);
   }
   memoriesDir() {
-    return path2.join(this.state.projectRoot, ".kuma", "memories");
+    return path.join(this.state.projectRoot, ".kuma", "memories");
   }
   ensureMemoriesDir() {
     const dir = this.memoriesDir();
-    if (!fs2.existsSync(dir)) {
-      fs2.mkdirSync(dir, { recursive: true });
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
     }
   }
   memoryFilePath(topic) {
-    return path2.join(this.memoriesDir(), `${topic}.md`);
+    return path.join(this.memoriesDir(), `${topic}.md`);
   }
   getMemoryContent(topic) {
     this.ensureInit();
     this.ensureMemoriesDir();
     const filePath = this.memoryFilePath(topic);
-    if (fs2.existsSync(filePath)) {
-      return fs2.readFileSync(filePath, "utf-8");
+    if (fs.existsSync(filePath)) {
+      return fs.readFileSync(filePath, "utf-8");
     }
     return this.generateMemory(topic);
   }
@@ -277,7 +138,7 @@ var SessionMemory = class {
   }
   writeMemoryFile(topic, content) {
     const filePath = this.memoryFilePath(topic);
-    fs2.writeFileSync(filePath, content, "utf-8");
+    fs.writeFileSync(filePath, content, "utf-8");
   }
   generateMemory(topic) {
     switch (topic) {
@@ -376,9 +237,9 @@ No unresolved issues.`;
   save() {
     if (!this.initialized || !this.state) return;
     try {
-      const kumaDir = path2.join(this.state.projectRoot, ".kuma");
-      if (!fs2.existsSync(kumaDir)) {
-        fs2.mkdirSync(kumaDir, { recursive: true });
+      const kumaDir = path.join(this.state.projectRoot, ".kuma");
+      if (!fs.existsSync(kumaDir)) {
+        fs.mkdirSync(kumaDir, { recursive: true });
       }
       const serialized = {
         projectRoot: this.state.projectRoot,
@@ -392,7 +253,7 @@ No unresolved issues.`;
         toolCalls: this.state.toolCalls,
         conventions: this.state.conventions
       };
-      fs2.writeFileSync(path2.join(kumaDir, "memory.json"), JSON.stringify(serialized, null, 2), "utf-8");
+      fs.writeFileSync(path.join(kumaDir, "memory.json"), JSON.stringify(serialized, null, 2), "utf-8");
     } catch (err) {
       console.error(`[SessionMemory] Failed to save session: ${err}`);
     }
@@ -507,6 +368,68 @@ No unresolved issues.`;
   // ============================================================
   // 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.
@@ -562,14 +485,14 @@ No unresolved issues.`;
       }
     }
     const memoriesDir = this.memoriesDir();
-    if (fs2.existsSync(memoriesDir)) {
+    if (fs.existsSync(memoriesDir)) {
       try {
-        const files = fs2.readdirSync(memoriesDir);
+        const files = fs.readdirSync(memoriesDir);
         for (const file of files) {
           if (!file.endsWith(".md")) continue;
-          const filePath = path2.join(memoriesDir, file);
+          const filePath = path.join(memoriesDir, file);
           try {
-            const content = fs2.readFileSync(filePath, "utf-8");
+            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)) {
@@ -625,11 +548,11 @@ No unresolved issues.`;
         unresolvedFailures.push({ task: f.task, error });
       }
     }
-    const hasMemories = fs2.existsSync(this.memoriesDir());
+    const hasMemories = fs.existsSync(this.memoriesDir());
     let availableMemories = [];
     if (hasMemories) {
       try {
-        availableMemories = fs2.readdirSync(this.memoriesDir()).filter((f) => f.endsWith(".md")).map((f) => f.replace(/\.md$/, ""));
+        availableMemories = fs.readdirSync(this.memoriesDir()).filter((f) => f.endsWith(".md")).map((f) => f.replace(/\.md$/, ""));
       } catch {
       }
     }
@@ -771,7 +694,7 @@ async function handleSmartGrep(params) {
   }
   const projectRoot = getProjectRoot();
   try {
-    const searchPattern = targetFolder ? path3.join(targetFolder, "**/*").replace(/\\/g, "/") : "**/*";
+    const searchPattern = targetFolder ? path2.join(targetFolder, "**/*").replace(/\\/g, "/") : "**/*";
     let entries = await fg(searchPattern, {
       cwd: projectRoot,
       ignore: IGNORE_PATTERNS,
@@ -787,7 +710,7 @@ async function handleSmartGrep(params) {
         (e) => e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`
       );
       entries = entries.filter((entry) => {
-        const ext = path3.extname(entry).toLowerCase();
+        const ext = path2.extname(entry).toLowerCase();
         return normalizedExts.includes(ext);
       });
     }
@@ -803,11 +726,11 @@ async function handleSmartGrep(params) {
       if (results.length >= maxResults) break;
       filesScanned++;
       try {
-        const fullPath = path3.join(projectRoot, entry);
-        const stat = fs3.statSync(fullPath);
+        const fullPath = path2.join(projectRoot, entry);
+        const stat = fs2.statSync(fullPath);
         if (stat.size > 5e5) continue;
         if (isBinaryFile(fullPath)) continue;
-        const content = fs3.readFileSync(fullPath, "utf-8");
+        const content = fs2.readFileSync(fullPath, "utf-8");
         const lines = content.split("\n");
         for (let i = 0; i < lines.length; i++) {
           if (results.length >= maxResults) break;
@@ -876,9 +799,9 @@ ${r.content.split("\n").map((l) => `    ${l}`).join("\n")}`;
 function isBinaryFile(filePath) {
   try {
     const buffer = Buffer.alloc(512);
-    const fd = fs3.openSync(filePath, "r");
-    const bytesRead = fs3.readSync(fd, buffer, 0, 512, 0);
-    fs3.closeSync(fd);
+    const fd = fs2.openSync(filePath, "r");
+    const bytesRead = fs2.readSync(fd, buffer, 0, 512, 0);
+    fs2.closeSync(fd);
     for (let i = 0; i < bytesRead; i++) {
       if (buffer[i] === 0) return true;
     }
@@ -889,8 +812,8 @@ function isBinaryFile(filePath) {
 }
 
 // src/tools/smartFilePicker.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs3 from "fs";
+import path3 from "path";
 var MAX_FILE_SIZE = 1e6;
 var CHUNK_THRESHOLD = 300;
 async function handleSmartFilePicker(params) {
@@ -900,23 +823,23 @@ async function handleSmartFilePicker(params) {
     return "Error: " + validation.error.message;
   }
   const resolvedPath = validation.resolvedPath;
-  if (!fs4.existsSync(resolvedPath)) {
+  if (!fs3.existsSync(resolvedPath)) {
     const projectRoot = getProjectRoot();
     let suggestion;
-    if (!path4.isAbsolute(filePath)) {
-      const cwdPath = path4.resolve(process.cwd(), filePath);
+    if (!path3.isAbsolute(filePath)) {
+      const cwdPath = path3.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 = fs4.statSync(resolvedPath);
+  const stat = fs3.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 = fs4.readFileSync(resolvedPath, "utf-8");
+    const content = fs3.readFileSync(resolvedPath, "utf-8");
     const lines = content.split("\n");
     const totalLines = lines.length;
     sessionMemory.recordToolCall("smart_file_picker", {
@@ -1066,8 +989,8 @@ function extractKeyDeclarations(lines) {
 }
 
 // src/tools/preciseDiffEditor.ts
-import fs5 from "fs";
-import path5 from "path";
+import fs4 from "fs";
+import path4 from "path";
 
 // src/utils/errorHandler.ts
 var CircuitBreakerStore = class {
@@ -1142,12 +1065,12 @@ async function handlePreciseDiffEditor(params) {
 
 Try reading the file first with smart_file_picker to verify current content.`;
   }
-  if (!fs5.existsSync(resolvedPath)) {
+  if (!fs4.existsSync(resolvedPath)) {
     return `Error: File not found: "${filePath}".
 Use batch_file_writer to create a new file.`;
   }
   try {
-    const originalContent = fs5.readFileSync(resolvedPath, "utf-8");
+    const originalContent = fs4.readFileSync(resolvedPath, "utf-8");
     let currentContent = originalContent;
     const results = [];
     for (let i = 0; i < edits.length; i++) {
@@ -1155,7 +1078,7 @@ Use batch_file_writer to create a new file.`;
       const result = applyEdit(currentContent, edit, resolvedPath, i, dryRun);
       if (result.success) {
         if (!dryRun) {
-          fs5.writeFileSync(resolvedPath, result.details, "utf-8");
+          fs4.writeFileSync(resolvedPath, result.details, "utf-8");
           sessionMemory.recordToolCall("precise_diff_editor", {
             filePath,
             editIndex: i,
@@ -1345,9 +1268,9 @@ function findNearestLine(content, search) {
 function createBackup(filePath) {
   ensureBackupDir();
   const backupPath = getBackupPath(filePath);
-  const backupDir = path5.dirname(backupPath);
-  fs5.mkdirSync(backupDir, { recursive: true });
-  fs5.copyFileSync(filePath, backupPath);
+  const backupDir = path4.dirname(backupPath);
+  fs4.mkdirSync(backupDir, { recursive: true });
+  fs4.copyFileSync(filePath, backupPath);
   return backupPath;
 }
 function formatDryRunResult(results, filePath, originalContent) {
@@ -1433,7 +1356,7 @@ 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 = path5.relative(getProjectRoot(), r.backupPath);
+        const relativePath = path4.relative(getProjectRoot(), r.backupPath);
         lines.push(`    Backup: ${relativePath}`);
       }
     } else {
@@ -1468,15 +1391,15 @@ async function handleRollbackEdit(params) {
   }
   const resolvedPath = validation.resolvedPath;
   const root = getProjectRoot();
-  const relativePath = path5.relative(root, resolvedPath);
-  const backupRoot = path5.join(root, ".agent-backups");
-  if (!fs5.existsSync(backupRoot)) {
+  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.`;
   }
   try {
-    const dirs = fs5.readdirSync(backupRoot).filter((name) => {
-      const fullPath = path5.join(backupRoot, name);
-      return fs5.statSync(fullPath).isDirectory() && /^\d+$/.test(name);
+    const dirs = fs4.readdirSync(backupRoot).filter((name) => {
+      const fullPath = path4.join(backupRoot, name);
+      return fs4.statSync(fullPath).isDirectory() && /^\d+$/.test(name);
     });
     if (dirs.length === 0) {
       return `Error: No valid backup found in .agent-backups folder.`;
@@ -1484,8 +1407,8 @@ async function handleRollbackEdit(params) {
     dirs.sort((a, b) => Number(b) - Number(a));
     const backupVersions = [];
     for (const dir of dirs) {
-      const potentialBackupPath = path5.join(backupRoot, dir, relativePath);
-      if (fs5.existsSync(potentialBackupPath)) {
+      const potentialBackupPath = path4.join(backupRoot, dir, relativePath);
+      if (fs4.existsSync(potentialBackupPath)) {
         backupVersions.push({ dir, backupPath: potentialBackupPath });
       }
     }
@@ -1512,14 +1435,14 @@ async function handleRollbackEdit(params) {
       selectedIndex = version - 1;
     }
     const selected = backupVersions[selectedIndex];
-    fs5.copyFileSync(selected.backupPath, resolvedPath);
+    fs4.copyFileSync(selected.backupPath, resolvedPath);
     sessionMemory.recordToolCall("rollback_last_edit", {
       filePath,
       backupTimestamp: selected.dir,
       version: version ?? 1,
       success: true
     });
-    const relBackupPath = path5.relative(root, selected.backupPath);
+    const relBackupPath = path4.relative(root, selected.backupPath);
     return `\u2705 Rollback Successful!
 File "${filePath}" restored from backup: "${relBackupPath}".`;
   } catch (err) {
@@ -1528,8 +1451,8 @@ File "${filePath}" restored from backup: "${relBackupPath}".`;
 }
 
 // src/tools/batchFileWriter.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs5 from "fs";
+import path5 from "path";
 async function handleBatchFileWriter(params) {
   const { files } = params;
   if (files.length > 15) {
@@ -1556,22 +1479,22 @@ async function handleBatchFileWriter(params) {
         results.push({
           filePath: file.filePath,
           success: false,
-          error: `File extension not allowed: "${path6.extname(file.filePath)}". Allowed extensions: .ts, .js, .tsx, .jsx, .json, .md, .css, .html, .yml, .yaml, .toml, .sh, .env`
+          error: `File extension not allowed: "${path5.extname(file.filePath)}". Allowed extensions: .ts, .js, .tsx, .jsx, .json, .md, .css, .html, .yml, .yaml, .toml, .sh, .env`
         });
         continue;
       }
-      if (fs6.existsSync(resolvedPath)) {
+      if (fs5.existsSync(resolvedPath)) {
         ensureBackupDir();
         const backupPath = getBackupPath(file.filePath);
-        const backupDir = path6.dirname(backupPath);
-        fs6.mkdirSync(backupDir, { recursive: true });
-        fs6.copyFileSync(resolvedPath, backupPath);
+        const backupDir = path5.dirname(backupPath);
+        fs5.mkdirSync(backupDir, { recursive: true });
+        fs5.copyFileSync(resolvedPath, backupPath);
       }
-      const dir = path6.dirname(resolvedPath);
-      if (!fs6.existsSync(dir)) {
-        fs6.mkdirSync(dir, { recursive: true });
+      const dir = path5.dirname(resolvedPath);
+      if (!fs5.existsSync(dir)) {
+        fs5.mkdirSync(dir, { recursive: true });
       }
-      fs6.writeFileSync(resolvedPath, file.content, "utf-8");
+      fs5.writeFileSync(resolvedPath, file.content, "utf-8");
       sessionMemory.recordToolCall("batch_file_writer", {
         filePath: file.filePath,
         instructions: file.instructions,
@@ -1614,12 +1537,12 @@ function formatBatchResult(results, totalRequested) {
 }
 
 // src/tools/safeTerminalExec.ts
-import fs8 from "fs";
-import path8 from "path";
-
-// src/utils/conventionsDetector.ts
 import fs7 from "fs";
 import path7 from "path";
+
+// src/utils/conventionsDetector.ts
+import fs6 from "fs";
+import path6 from "path";
 var cachedConventions = null;
 async function detectConventions(forceRescan = false) {
   if (cachedConventions && !forceRescan) {
@@ -1645,7 +1568,7 @@ async function detectConventions(forceRescan = false) {
   return conventions;
 }
 function detectFramework(root) {
-  const pkg = readJsonSafe(path7.join(root, "package.json"));
+  const pkg = readJsonSafe(path6.join(root, "package.json"));
   if (pkg) {
     const pkgDeps = pkg.dependencies ?? {};
     const pkgDevDeps = pkg.devDependencies ?? {};
@@ -1690,11 +1613,11 @@ function detectFramework(root) {
 function scanSubProjectFrameworks(root) {
   const frameworks = [];
   try {
-    const entries = fs7.readdirSync(root, { withFileTypes: true });
+    const entries = fs6.readdirSync(root, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const subDir = path7.join(root, entry.name);
-      const subPkg = readJsonSafe(path7.join(subDir, "package.json"));
+      const subDir = path6.join(root, entry.name);
+      const subPkg = readJsonSafe(path6.join(subDir, "package.json"));
       if (!subPkg) continue;
       const subDeps = { ...subPkg.dependencies ?? {}, ...subPkg.devDependencies ?? {} };
       if (subDeps.next) frameworks.push("Next.js");
@@ -1713,7 +1636,7 @@ function scanSubProjectFrameworks(root) {
   return frameworks;
 }
 function detectProjectType(root) {
-  const pkg = readJsonSafe(path7.join(root, "package.json"));
+  const pkg = readJsonSafe(path6.join(root, "package.json"));
   if (pkg) {
     const pkgDeps = pkg.dependencies ?? {};
     const pkgDevDeps = pkg.devDependencies ?? {};
@@ -1737,8 +1660,8 @@ function detectProjectType(root) {
 }
 function detectWorkspaces(root) {
   const results = [];
-  const pkg = readJsonSafe(path7.join(root, "package.json"));
-  const pnpmWorkspace = readYamlLite(path7.join(root, "pnpm-workspace.yaml"));
+  const pkg = readJsonSafe(path6.join(root, "package.json"));
+  const pnpmWorkspace = readYamlLite(path6.join(root, "pnpm-workspace.yaml"));
   const patterns = /* @__PURE__ */ new Set();
   const pkgWorkspaces = pkg?.workspaces;
   if (Array.isArray(pkgWorkspaces)) {
@@ -1758,22 +1681,22 @@ function detectWorkspaces(root) {
   for (const pattern of patterns) {
     const match = pattern.match(/^([^*]+)\/\*$/);
     if (!match) continue;
-    const dir = path7.join(root, match[1]);
-    if (!fs7.existsSync(dir)) continue;
+    const dir = path6.join(root, match[1]);
+    if (!fs6.existsSync(dir)) continue;
     let entries = [];
     try {
-      entries = fs7.readdirSync(dir, { withFileTypes: true });
+      entries = fs6.readdirSync(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const pkgPath = path7.join(dir, entry.name, "package.json");
+      const pkgPath = path6.join(dir, entry.name, "package.json");
       const subPkg = readJsonSafe(pkgPath);
       if (!subPkg) continue;
-      const workspacePath = path7.join(dir, entry.name);
+      const workspacePath = path6.join(dir, entry.name);
       results.push({
-        path: path7.relative(root, workspacePath),
+        path: path6.relative(root, workspacePath),
         name: subPkg.name ?? entry.name,
         framework: detectFramework(workspacePath),
         packageManager: detectPackageManagerForDir(workspacePath)
@@ -1789,8 +1712,8 @@ function detectWorkspaces(root) {
 }
 function readYamlLite(filePath) {
   try {
-    if (!fs7.existsSync(filePath)) return null;
-    const text = fs7.readFileSync(filePath, "utf-8");
+    if (!fs6.existsSync(filePath)) return null;
+    const text = fs6.readFileSync(filePath, "utf-8");
     const packages = [];
     let inPackages = false;
     for (const rawLine of text.split("\n")) {
@@ -1811,7 +1734,7 @@ function readYamlLite(filePath) {
   }
 }
 function detectTestRunner(root) {
-  const pkg = readJsonSafe(path7.join(root, "package.json"));
+  const pkg = readJsonSafe(path6.join(root, "package.json"));
   if (!pkg) return "unknown";
   const pkgDeps2 = pkg.dependencies ?? {};
   const pkgDevDeps2 = pkg.devDependencies ?? {};
@@ -1832,7 +1755,7 @@ function detectTestRunner(root) {
   return "unknown";
 }
 function detectStyling(root) {
-  const pkg = readJsonSafe(path7.join(root, "package.json"));
+  const pkg = readJsonSafe(path6.join(root, "package.json"));
   if (!pkg) return "unknown";
   const pkgDeps3 = pkg.dependencies ?? {};
   const pkgDevDeps3 = pkg.devDependencies ?? {};
@@ -1845,22 +1768,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 = path7.join(root, "src");
-  if (fs7.existsSync(srcDir)) {
+  const srcDir = path6.join(root, "src");
+  if (fs6.existsSync(srcDir)) {
     const cssFiles = findFiles(srcDir, [".css", ".scss", ".less"]);
     if (cssFiles.length > 0) return "Plain CSS/SCSS";
   }
   return "unknown";
 }
 function detectImportAlias(root) {
-  const tsconfig = readJsonSafe(path7.join(root, "tsconfig.json"));
+  const tsconfig = readJsonSafe(path6.join(root, "tsconfig.json"));
   const tsconfigPaths = tsconfig?.compilerOptions;
   if (tsconfigPaths?.paths) {
     const paths = tsconfigPaths.paths;
     const alias = Object.keys(paths)[0];
     if (alias) return alias.replace("/*", "");
   }
-  const jsconfig = readJsonSafe(path7.join(root, "jsconfig.json"));
+  const jsconfig = readJsonSafe(path6.join(root, "jsconfig.json"));
   const jsconfigPaths = jsconfig?.compilerOptions;
   if (jsconfigPaths?.paths) {
     const paths = jsconfigPaths.paths;
@@ -1871,15 +1794,15 @@ function detectImportAlias(root) {
 }
 function detectLintRules(root) {
   const rules = [];
-  if (fs7.existsSync(path7.join(root, ".eslintrc"))) rules.push("ESLint (.eslintrc)");
-  if (fs7.existsSync(path7.join(root, ".eslintrc.js"))) rules.push("ESLint (.eslintrc.js)");
-  if (fs7.existsSync(path7.join(root, ".eslintrc.json"))) rules.push("ESLint (.eslintrc.json)");
-  if (fs7.existsSync(path7.join(root, "eslint.config.js"))) rules.push("ESLint (flat config)");
-  if (fs7.existsSync(path7.join(root, ".prettierrc"))) rules.push("Prettier");
-  if (fs7.existsSync(path7.join(root, ".prettierrc.json"))) rules.push("Prettier");
-  if (fs7.existsSync(path7.join(root, ".prettierrc.js"))) rules.push("Prettier");
-  if (fs7.existsSync(path7.join(root, ".stylelintrc"))) rules.push("StyleLint");
-  if (fs7.existsSync(path7.join(root, ".stylelintrc.json"))) rules.push("StyleLint");
+  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");
   return rules;
 }
 function detectPackageManager() {
@@ -1888,26 +1811,26 @@ function detectPackageManager() {
 }
 function detectPackageManagerForDir(dir) {
   const root = getProjectRoot();
-  let currentDir = path7.resolve(dir);
+  let currentDir = path6.resolve(dir);
   while (currentDir.startsWith(root)) {
-    if (fs7.existsSync(path7.join(currentDir, "pnpm-lock.yaml"))) return "pnpm";
-    if (fs7.existsSync(path7.join(currentDir, "yarn.lock"))) return "yarn";
-    if (fs7.existsSync(path7.join(currentDir, "package-lock.json"))) return "npm";
-    if (fs7.existsSync(path7.join(currentDir, "bun.lockb"))) return "bun";
+    if (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 (currentDir === root) break;
-    currentDir = path7.dirname(currentDir);
+    currentDir = path6.dirname(currentDir);
   }
   return "npm";
 }
 function detectModuleSystem(root) {
-  const pkg = readJsonSafe(path7.join(root, "package.json"));
+  const pkg = readJsonSafe(path6.join(root, "package.json"));
   if (pkg?.type === "module") return "esm";
-  const srcDir = path7.join(root, "src");
-  if (fs7.existsSync(srcDir)) {
+  const srcDir = path6.join(root, "src");
+  if (fs6.existsSync(srcDir)) {
     const tsFiles = findFiles(srcDir, [".ts", ".tsx", ".js", ".jsx", ".mjs"]);
     for (const file of tsFiles.slice(0, 20)) {
       try {
-        const content = fs7.readFileSync(file, "utf-8");
+        const content = fs6.readFileSync(file, "utf-8");
         if (content.includes("import ") || content.includes("export ")) return "esm";
       } catch {
         continue;
@@ -1917,9 +1840,9 @@ function detectModuleSystem(root) {
   return "cjs";
 }
 function detectLanguage(root) {
-  if (fs7.existsSync(path7.join(root, "tsconfig.json"))) return "typescript";
-  const srcDir = path7.join(root, "src");
-  if (fs7.existsSync(srcDir)) {
+  if (fs6.existsSync(path6.join(root, "tsconfig.json"))) return "typescript";
+  const srcDir = path6.join(root, "src");
+  if (fs6.existsSync(srcDir)) {
     const tsFiles = findFiles(srcDir, [".ts", ".tsx"]);
     if (tsFiles.length > 0) return "typescript";
   }
@@ -1927,7 +1850,7 @@ function detectLanguage(root) {
 }
 function detectFeatures(root) {
   const features = [];
-  const pkg = readJsonSafe(path7.join(root, "package.json"));
+  const pkg = readJsonSafe(path6.join(root, "package.json"));
   if (!pkg) return features;
   const pkgDeps4 = pkg.dependencies ?? {};
   const pkgDevDeps4 = pkg.devDependencies ?? {};
@@ -1951,25 +1874,25 @@ function detectFeatures(root) {
 }
 function readJsonSafe(filePath) {
   try {
-    if (fs7.existsSync(filePath)) {
-      return JSON.parse(fs7.readFileSync(filePath, "utf-8"));
+    if (fs6.existsSync(filePath)) {
+      return JSON.parse(fs6.readFileSync(filePath, "utf-8"));
     }
   } catch {
   }
   return null;
 }
 function hasCSSModules(root) {
-  const srcDir = path7.join(root, "src");
-  if (!fs7.existsSync(srcDir)) return false;
+  const srcDir = path6.join(root, "src");
+  if (!fs6.existsSync(srcDir)) return false;
   const files = findFiles(srcDir, [".module.css", ".module.scss", ".module.less"]);
   return files.length > 0;
 }
 function findFiles(dir, extensions) {
   const results = [];
   try {
-    const entries = fs7.readdirSync(dir, { withFileTypes: true });
+    const entries = fs6.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path7.join(dir, entry.name);
+      const fullPath = path6.join(dir, entry.name);
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
         results.push(...findFiles(fullPath, extensions));
       } else if (entry.isFile()) {
@@ -2160,7 +2083,7 @@ async function handleSafeTerminalExec(params) {
     const workspaces = conventions?.workspaces;
     const matched = workspaces?.find((w) => w.name === workspace || w.path === workspace);
     if (matched) {
-      workingDir = path8.resolve(projectRoot, matched.path);
+      workingDir = path7.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.
@@ -2168,13 +2091,13 @@ async function handleSafeTerminalExec(params) {
 Available workspaces: ${workspaces?.map((w) => `"${w.name}" (${w.path})`).join(", ") || "none detected"}`;
     }
   } else if (inputCwd) {
-    const resolved = path8.resolve(projectRoot, inputCwd);
-    const normalizedResolved = path8.normalize(resolved).toLowerCase();
-    const normalizedRoot = path8.normalize(projectRoot).toLowerCase();
+    const resolved = path7.resolve(projectRoot, inputCwd);
+    const normalizedResolved = path7.normalize(resolved).toLowerCase();
+    const normalizedRoot = path7.normalize(projectRoot).toLowerCase();
     if (!normalizedResolved.startsWith(normalizedRoot)) {
       return `\u{1F6AB} BLOCKED: Path "${inputCwd}" resolves outside project root "${projectRoot}".`;
     }
-    if (!fs8.existsSync(resolved)) {
+    if (!fs7.existsSync(resolved)) {
       return `\u26A0\uFE0F Directory "${inputCwd}" does not exist at "${resolved}".`;
     }
     workingDir = resolved;
@@ -2260,8 +2183,8 @@ function formatTimeoutResult(command, timeout) {
 }
 
 // src/agents/codeReviewer.ts
-import fs9 from "fs";
-import path9 from "path";
+import fs8 from "fs";
+import path8 from "path";
 import { execSync } from "child_process";
 var CODE_EXTENSIONS = [
   ".ts",
@@ -2275,7 +2198,19 @@ var CODE_EXTENSIONS = [
   ".rs",
   ".php",
   ".cs",
-  ".java"
+  ".java",
+  ".json",
+  ".jsonc",
+  ".yaml",
+  ".yml",
+  ".toml"
+];
+var CONFIG_EXTENSIONS = [
+  ".json",
+  ".jsonc",
+  ".yaml",
+  ".yml",
+  ".toml"
 ];
 function getGitChangedFiles() {
   try {
@@ -2293,7 +2228,7 @@ function getGitChangedFiles() {
       if (filePath.startsWith('"') && filePath.endsWith('"')) {
         filePath = filePath.substring(1, filePath.length - 1);
       }
-      const ext = path9.extname(filePath).toLowerCase();
+      const ext = path8.extname(filePath).toLowerCase();
       if (CODE_EXTENSIONS.includes(ext)) files.push(filePath);
     }
     return files.slice(0, 10);
@@ -2303,7 +2238,7 @@ function getGitChangedFiles() {
   }
 }
 async function handleCodeReviewer(params) {
-  const { files: inputFiles, focus = "correctness", customCriteria, format = "text" } = params;
+  const { files: inputFiles, focus = "correctness", customCriteria, format = "text", convention } = params;
   let files = inputFiles ?? [];
   let isAutoDetected = false;
   if (files.length === 0) {
@@ -2330,7 +2265,7 @@ Pass an explicit 'files' array to review specific files.`;
       continue;
     }
     const resolvedPath = validation.resolvedPath;
-    if (!fs9.existsSync(resolvedPath)) {
+    if (!fs8.existsSync(resolvedPath)) {
       allIssues.push({
         file: filePath,
         line: 0,
@@ -2342,7 +2277,7 @@ Pass an explicit 'files' array to review specific files.`;
       continue;
     }
     try {
-      const content = fs9.readFileSync(resolvedPath, "utf-8");
+      const content = fs8.readFileSync(resolvedPath, "utf-8");
       filesReviewed++;
       checkGeneral(filePath, content, allIssues);
       switch (focus) {
@@ -2362,6 +2297,9 @@ Pass an explicit 'files' array to review specific files.`;
           checkOverEngineering(filePath, content, allIssues);
           break;
       }
+      if (convention === "matcha") {
+        checkMatchaConventions(filePath, content, allIssues);
+      }
     } catch (err) {
       allIssues.push({
         file: filePath,
@@ -2389,6 +2327,7 @@ Pass an explicit 'files' array to review specific files.`;
       filesReviewed,
       filesRequested: files.length,
       focus,
+      convention,
       autoDetected: isAutoDetected,
       ...customCriteria ? { customCriteria } : {}
     };
@@ -2436,11 +2375,12 @@ function isTestFile(filePath) {
   return /\.(test|spec)\.[a-z]+$/i.test(filePath) || /__tests__/.test(filePath);
 }
 function isTsLike(filePath) {
-  const ext = path9.extname(filePath).toLowerCase();
+  const ext = path8.extname(filePath).toLowerCase();
   return ext === ".ts" || ext === ".tsx";
 }
 function checkGeneral(filePath, content, issues) {
   const lines = content.split("\n");
+  const ext = path8.extname(filePath).toLowerCase();
   if (content.length > 0 && !content.endsWith("\n")) {
     issues.push({
       file: filePath,
@@ -2461,6 +2401,9 @@ function checkGeneral(filePath, content, issues) {
       suggestion: "Extract cohesive sections into separate modules"
     });
   }
+  if (CONFIG_EXTENSIONS.includes(ext)) {
+    checkConfigFile(filePath, content, issues);
+  }
 }
 function checkCorrectness(filePath, content, issues) {
   const lines = content.split("\n");
@@ -2623,6 +2566,282 @@ function checkCorrectness(filePath, content, issues) {
     });
   }
 }
+function stripJsonComments(text) {
+  let result = text.replace(/\/\*[\s\S]*?\*\//g, "");
+  const lines = result.split("\n");
+  const cleaned = lines.map((line) => {
+    const commentIdx = line.indexOf("//");
+    if (commentIdx === -1) return line;
+    const before = line.substring(0, commentIdx);
+    const quoteCount = (before.match(/"/g) || []).length;
+    if (quoteCount % 2 === 0) {
+      return before;
+    }
+    return line;
+  });
+  return cleaned.join("\n");
+}
+function checkConfigFile(filePath, content, issues) {
+  const ext = path8.extname(filePath).toLowerCase();
+  const lines = content.split("\n");
+  if (ext === ".json" || ext === ".jsonc") {
+    checkJson(filePath, content, lines, issues);
+  } else if (ext === ".yaml" || ext === ".yml") {
+    checkYaml(filePath, content, lines, issues);
+  } else if (ext === ".toml") {
+    checkToml(filePath, content, lines, issues);
+  }
+}
+function checkJson(filePath, content, lines, issues) {
+  const ext = path8.extname(filePath).toLowerCase();
+  const isJsonc = ext === ".jsonc";
+  const contentToParse = isJsonc ? stripJsonComments(content) : content;
+  try {
+    JSON.parse(contentToParse);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (isJsonc && /\/\/|\/\*/.test(content)) {
+      issues.push({
+        file: filePath,
+        line: 1,
+        severity: "info",
+        rule: "jsonc/comments-stripped",
+        message: "JSON with Comments \u2014 comments were stripped for validation. Check the remaining syntax.",
+        suggestion: "If issues remain, check quotes, commas, braces after comment removal"
+      });
+      return;
+    }
+    const posMatch = msg.match(/position\s+(\d+)/i);
+    const lineMatch = msg.match(/line\s+(\d+)/i);
+    let errorLine = 1;
+    if (lineMatch) {
+      errorLine = parseInt(lineMatch[1], 10);
+    } else if (posMatch) {
+      const pos = parseInt(posMatch[1], 10);
+      let charCount = 0;
+      for (let i = 0; i < lines.length; i++) {
+        charCount += lines[i].length + 1;
+        if (charCount >= pos) {
+          errorLine = i + 1;
+          break;
+        }
+      }
+    }
+    issues.push({
+      file: filePath,
+      line: errorLine,
+      severity: "error",
+      rule: "json/parse-error",
+      message: `Invalid JSON: ${msg.substring(0, 120)}`,
+      suggestion: "Fix the syntax error \u2014 check quotes, commas, braces, and brackets"
+    });
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (!/,\s*$/.test(trimmed)) continue;
+    let nextNonEmpty = "";
+    for (let j = i + 1; j < lines.length; j++) {
+      const t = lines[j].trim();
+      if (t && !t.startsWith("//") && !t.startsWith("*") && !t.startsWith("#")) {
+        nextNonEmpty = t;
+        break;
+      }
+    }
+    if (nextNonEmpty === "]" || nextNonEmpty === "}" || nextNonEmpty === "]," || nextNonEmpty === "},") {
+      issues.push({
+        file: filePath,
+        line: i + 1,
+        severity: "error",
+        rule: "json/trailing-comma",
+        message: "Trailing comma before closing bracket/brace",
+        suggestion: "Remove the trailing comma after the last element"
+      });
+    }
+  }
+  try {
+    const parsed = JSON.parse(content);
+    findDuplicateKeys(parsed, "", filePath, issues, lines);
+  } catch {
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if ((/\s+'[a-zA-Z_][a-zA-Z0-9_]*'\s*:/.test(line) || /:\s*'[^']*'\s*[,}\]$]/.test(line)) && !/\/\//.test(line)) {
+      issues.push({
+        file: filePath,
+        line: i + 1,
+        severity: "warning",
+        rule: "json/single-quote",
+        message: "Single quotes used \u2014 JSON requires double quotes",
+        suggestion: `Replace ' with "`
+      });
+      break;
+    }
+  }
+}
+function findDuplicateKeys(obj, nestedPath, filePath, issues, lines) {
+  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) return;
+  const keys = Object.keys(obj);
+  const seen = /* @__PURE__ */ new Map();
+  for (const key of keys) {
+    if (seen.has(key)) {
+      const searchStr = `"${key}"`;
+      let lineNum = 1;
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i].includes(searchStr)) {
+          lineNum = i + 1;
+          break;
+        }
+      }
+      issues.push({
+        file: filePath,
+        line: lineNum,
+        severity: "warning",
+        rule: "json/duplicate-key",
+        message: `Duplicate key "${key}" in ${nestedPath || "root"}`,
+        suggestion: "Remove or rename the duplicate \u2014 last value wins in JSON"
+      });
+    }
+    seen.set(key, 1);
+  }
+  for (const key of keys) {
+    const deeperPath = nestedPath ? `${nestedPath}.${key}` : key;
+    findDuplicateKeys(obj[key], deeperPath, filePath, issues, lines);
+  }
+}
+function checkYaml(filePath, _content, lines, issues) {
+  let hasTabs = false;
+  let hasSpaces = false;
+  let inconsistentIndent = false;
+  for (let i = 0; i < lines.length; i++) {
+    const rawLine = lines[i];
+    const trimmed = rawLine.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    if (rawLine.startsWith("	")) hasTabs = true;
+    const spaceMatch = rawLine.match(/^( +)/);
+    if (spaceMatch) {
+      hasSpaces = true;
+      const indent = spaceMatch[1].length;
+      if (indent % 2 !== 0 && indent !== 0) {
+        inconsistentIndent = true;
+      }
+    }
+  }
+  if (hasTabs) {
+    issues.push({
+      file: filePath,
+      line: 1,
+      severity: "error",
+      rule: "yaml/tab-indent",
+      message: "YAML uses spaces for indentation \u2014 tabs are not allowed",
+      suggestion: "Replace tabs with spaces (2 spaces per indent level)"
+    });
+  }
+  if (inconsistentIndent) {
+    issues.push({
+      file: filePath,
+      line: 1,
+      severity: "warning",
+      rule: "yaml/inconsistent-indent",
+      message: "Indentation depth is not a multiple of 2 \u2014 may cause parsing issues",
+      suggestion: "Use consistent 2-space indentation throughout the file"
+    });
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (/^https?:\/\//.test(trimmed) || /:\s*https?:\/\//.test(trimmed)) {
+      issues.push({
+        file: filePath,
+        line: i + 1,
+        severity: "info",
+        rule: "yaml/unquoted-url",
+        message: "URL should be quoted to avoid colon parsing ambiguity",
+        suggestion: 'Wrap URL in quotes: "https://..."'
+      });
+    }
+    if (/^\s*\w+:\s*(yes|no|on|off)\s*$/.test(lines[i])) {
+      issues.push({
+        file: filePath,
+        line: i + 1,
+        severity: "info",
+        rule: "yaml/ambiguous-bool",
+        message: "Ambiguous boolean value \u2014 YAML interprets yes/no/on/off as booleans",
+        suggestion: "Use true/false instead for clarity, or quote the value"
+      });
+    }
+  }
+  if (hasTabs && hasSpaces) {
+    issues.push({
+      file: filePath,
+      line: 1,
+      severity: "error",
+      rule: "yaml/mixed-indent",
+      message: "Mixed tabs and spaces in indentation",
+      suggestion: "Use spaces only (2 spaces per level)"
+    });
+  }
+}
+function checkToml(filePath, _content, lines, issues) {
+  const seenKeys = /* @__PURE__ */ new Map();
+  const arrayTables = /* @__PURE__ */ new Set();
+  let currentTable = "";
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const isArrayTable = trimmed.startsWith("[[");
+    const tableMatch = trimmed.match(/^\[\[?(.+?)\]?\]$/);
+    if (tableMatch) {
+      currentTable = tableMatch[1];
+      if (isArrayTable) {
+        arrayTables.add(currentTable);
+      }
+      continue;
+    }
+    const kvMatch = trimmed.match(/^(\w+)\s*=/);
+    if (kvMatch) {
+      const fullKey = currentTable ? `${currentTable}.${kvMatch[1]}` : kvMatch[1];
+      const parentTable = currentTable.split(".").slice(0, -1).join(".");
+      const isInArrayTable = arrayTables.has(currentTable) || arrayTables.has(parentTable);
+      if (seenKeys.has(fullKey)) {
+        if (!isInArrayTable) {
+          const prevLine = seenKeys.get(fullKey);
+          issues.push({
+            file: filePath,
+            line: i + 1,
+            severity: "warning",
+            rule: "toml/duplicate-key",
+            message: `Duplicate key "${fullKey}" (first defined at line ${prevLine})`,
+            suggestion: "Remove or rename the duplicate \u2014 only last value is kept"
+          });
+        }
+      } else {
+        seenKeys.set(fullKey, i + 1);
+      }
+    }
+    if (/\{[^}]*\}/.test(trimmed)) {
+      const inlineContent = trimmed.match(/\{([^}]*)\}/);
+      if (inlineContent) {
+        const inlineKeys = inlineContent[1].match(/(\w+)\s*=/g);
+        if (inlineKeys) {
+          const inlineSeen = /* @__PURE__ */ new Set();
+          for (const k of inlineKeys) {
+            const keyName = k.replace(/\s*=\s*$/, "").trim();
+            if (inlineSeen.has(keyName)) {
+              issues.push({
+                file: filePath,
+                line: i + 1,
+                severity: "warning",
+                rule: "toml/duplicate-inline-key",
+                message: `Duplicate key "${keyName}" in inline table`,
+                suggestion: "Remove the duplicate key"
+              });
+            }
+            inlineSeen.add(keyName);
+          }
+        }
+      }
+    }
+  }
+}
 function checkConventions(filePath, content, issues) {
   const lines = content.split("\n");
   let hasTabs = false;
@@ -2915,8 +3134,8 @@ function collectBlockLines(lines, startIdx) {
   let depth = 0;
   let started = false;
   const block = [];
-  for (let j = startIdx; j < lines.length; j++) {
-    const line = lines[j];
+  for (let i = startIdx; i < lines.length; i++) {
+    const line = lines[i];
     block.push(line);
     for (const ch of line) {
       if (ch === "{") {
@@ -2933,6 +3152,73 @@ function extractBodyAfter(lines, match) {
   if (startIdx < 0) return "";
   return collectBlockLines(lines, startIdx).join("\n");
 }
+function checkMatchaConventions(filePath, content, issues) {
+  const lines = content.split("\n");
+  const text = content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+  for (let i = 0; i < lines.length; i++) {
+    const line = stripCommentsAndStrings(lines[i]);
+    const lineNum = i + 1;
+    if (/\b(?:const|let|var)\s+\w+\s*=\s*(?:[2-9]|\d{2,})\b/.test(line)) {
+      if (!/eslint-disable/.test(lines[i])) {
+        issues.push({
+          file: filePath,
+          line: lineNum,
+          severity: "info",
+          rule: "matcha/no-hardcoded-values",
+          message: "Possible hardcoded numeric value (magic number)",
+          suggestion: "Extract to a named constant"
+        });
+      }
+    }
+    const envMatch = line.match(/process\.env\.([A-Z0-9_]+)/);
+    if (envMatch) {
+      const envName = envMatch[1];
+      if (!envName.includes("_")) {
+        issues.push({
+          file: filePath,
+          line: lineNum,
+          severity: "warning",
+          rule: "matcha/env-prefix",
+          message: `Environment variable "${envName}" doesn't seem to have a prefix`,
+          suggestion: "Use an APPNAME_ prefix for environment variables"
+        });
+      }
+    }
+  }
+  const interfaceNames = [];
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(/^\s*(export\s+)?interface\s+(\w+)/);
+    if (m) interfaceNames.push(m[2]);
+  }
+  for (const iface of interfaceNames) {
+    const implCount = (text.match(new RegExp(`implements\\s+.*\\b${iface}\\b`, "g")) || []).length;
+    if (implCount <= 1) {
+      const lineNum = lines.findIndex((l) => l.includes(`interface ${iface}`)) + 1;
+      issues.push({
+        file: filePath,
+        line: lineNum,
+        severity: "info",
+        rule: "matcha/no-premature-abstraction",
+        message: `Interface "${iface}" has only 1 implementation \u2014 premature abstraction?`,
+        suggestion: "Wait for a 2nd use case before abstracting"
+      });
+    }
+  }
+  const funcBodies = findBlockBodies(lines, /^\s*(export\s+)?(async\s+)?function\s+\w+/);
+  for (const { body, nameLine, name } of funcBodies) {
+    const nonEmptyLines = body.split("\n").filter((l) => l.trim()).length;
+    if (nonEmptyLines > 40) {
+      issues.push({
+        file: filePath,
+        line: nameLine,
+        severity: "warning",
+        rule: "matcha/single-responsibility",
+        message: `Function "${name}" is ${nonEmptyLines} lines long \u2014 might be doing >1 thing`,
+        suggestion: "Extract into smaller, focused functions"
+      });
+    }
+  }
+}
 function formatReviewOutput(issues, filesReviewed, totalFiles, focus, customCriteria, autoDetected) {
   const errors = issues.filter((i) => i.severity === "error");
   const warnings = issues.filter((i) => i.severity === "warning");
@@ -3164,9 +3450,9 @@ async function handleGitDiff(params) {
 }
 
 // src/tools/projectStructure.ts
-import fs10 from "fs";
-import path10 from "path";
-var DEFAULT_IGNORE = [
+import fs9 from "fs";
+import path9 from "path";
+var DEFAULT_IGNORE = [
   "node_modules",
   ".git",
   ".kuma",
@@ -3202,7 +3488,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 = path10.basename(root);
+    const projectName = path9.basename(root);
     const lines = [
       "[Project Structure] - " + projectName,
       "Depth: " + clampedDepth + " | " + (folderOnly ? "Folders only" : "Files and folders"),
@@ -3225,7 +3511,7 @@ function buildTree(root, currentDir, maxDepth, currentDepth, folderOnly, include
   const lines = [];
   let entries = [];
   try {
-    entries = fs10.readdirSync(currentDir, { withFileTypes: true });
+    entries = fs9.readdirSync(currentDir, { withFileTypes: true });
   } catch {
     return lines;
   }
@@ -3234,12 +3520,12 @@ function buildTree(root, currentDir, maxDepth, currentDepth, folderOnly, include
     if (!a.isDirectory() && b.isDirectory()) return 1;
     return a.name.localeCompare(b.name);
   });
-  const relativeDir = path10.relative(root, currentDir) || ".";
+  const relativeDir = path9.relative(root, currentDir) || ".";
   const prefix = getPrefix(currentDepth);
   for (const entry of entries) {
     if (shouldIgnore(entry.name, relativeDir, root)) continue;
-    const fullPath = path10.join(currentDir, entry.name);
-    const relativePath = path10.relative(root, fullPath);
+    const fullPath = path9.join(currentDir, entry.name);
+    const relativePath = path9.relative(root, fullPath);
     if (includePattern && !entry.name.includes(includePattern) && !relativePath.includes(includePattern)) {
       if (!entry.isDirectory()) continue;
     }
@@ -3250,11 +3536,11 @@ function buildTree(root, currentDir, maxDepth, currentDepth, folderOnly, include
       lines.push(prefix + "[D] " + entry.name + "/");
       let subEntries = [];
       try {
-        subEntries = fs10.readdirSync(fullPath, { withFileTypes: true });
+        subEntries = fs9.readdirSync(fullPath, { withFileTypes: true });
       } catch {
       }
       const hasVisibleContent = subEntries.some(
-        (e) => !shouldIgnore(e.name, path10.relative(root, fullPath), root)
+        (e) => !shouldIgnore(e.name, path9.relative(root, fullPath), root)
       );
       if (hasVisibleContent) {
         const subLines = buildTree(root, fullPath, maxDepth, currentDepth + 1, folderOnly, includePattern, excludePattern);
@@ -3285,7 +3571,7 @@ function getPrefix(depth) {
 }
 function getFileSize(fullPath) {
   try {
-    const stat = fs10.statSync(fullPath);
+    const stat = fs9.statSync(fullPath);
     if (stat.size < 1024) return stat.size + "B";
     if (stat.size < 1024 * 1024) return (stat.size / 1024).toFixed(0) + "KB";
     const sizeMB = (stat.size / (1024 * 1024)).toFixed(1);
@@ -3296,8 +3582,8 @@ function getFileSize(fullPath) {
 }
 
 // src/tools/staticAnalysis.ts
-import fs11 from "fs";
-import path11 from "path";
+import fs10 from "fs";
+import path10 from "path";
 async function handleStaticAnalysis(params) {
   const { tool = "all", files, autoFix = false, timeout = 60 } = params;
   const root = getProjectRoot();
@@ -3315,7 +3601,26 @@ async function handleStaticAnalysis(params) {
   for (const t of toolsToRun) {
     const output = await runTool(t, root, files, autoFix, timeout);
     if (output === null) {
-      results.push({ tool: t, exitCode: -1, issues: [], summary: { errors: 0, warnings: 0, info: 0 } });
+      const cmd = buildToolCommand(t, files, autoFix);
+      const reason = cmd === null ? `Could not build command for tool "${t}" (unknown tool type)` : `Command "${cmd}" returned no output (tool may not be installed)`;
+      console.error(`[StaticAnalysis] ${reason}`);
+      allIssues.push({
+        file: `(${t} error)`,
+        line: 0,
+        column: 0,
+        severity: "error",
+        message: reason,
+        rule: t,
+        source: t
+      });
+      const result2 = {
+        tool: t,
+        exitCode: -1,
+        issues: [{ file: `(${t} error)`, line: 0, column: 0, severity: "error", message: reason, rule: t, source: t }],
+        summary: { errors: 1, warnings: 0, info: 0 }
+      };
+      results.push(result2);
+      sessionMemory.addFailedFile("static_analysis:" + t, reason);
       continue;
     }
     const issues = parseToolOutput(t, output.stdout, output.stderr, root);
@@ -3331,6 +3636,22 @@ async function handleStaticAnalysis(params) {
     };
     results.push(result);
     allIssues.push(...issues);
+    if (result.exitCode !== 0 && issues.length === 0 && output.stderr.trim()) {
+      const stderrLines = output.stderr.trim().split("\n").slice(0, 8);
+      console.error(`[StaticAnalysis] ${t} exited with code ${result.exitCode} (no parseable output):`);
+      for (const errLine of stderrLines) {
+        console.error(`[StaticAnalysis]   ${errLine}`);
+      }
+      allIssues.push({
+        file: `(${t} error)`,
+        line: 0,
+        column: 0,
+        severity: "error",
+        message: `Tool "${t}" exited with code ${result.exitCode}. Check stderr for details.`,
+        rule: t,
+        source: t
+      });
+    }
     if (result.summary.errors > 0 || result.summary.warnings > 0) {
       const errorMsg = result.summary.errors > 0 ? result.summary.errors + " error(s)" : result.summary.warnings + " warning(s)";
       sessionMemory.addFailedFile("static_analysis:" + t, errorMsg + " found");
@@ -3352,11 +3673,11 @@ function detectAvailableTools(root) {
     "eslint.config.js",
     "eslint.config.mjs"
   ];
-  const hasEslintConfig = eslintConfigs.some((cfg) => fs11.existsSync(path11.join(root, cfg)));
+  const hasEslintConfig = eslintConfigs.some((cfg) => fs10.existsSync(path10.join(root, cfg)));
   if (hasEslintConfig && depNames.has("eslint")) {
     tools.push("eslint");
   }
-  if (fs11.existsSync(path11.join(root, "tsconfig.json")) && depNames.has("typescript")) {
+  if (fs10.existsSync(path10.join(root, "tsconfig.json")) && depNames.has("typescript")) {
     tools.push("tsc");
   }
   const prettierConfigs = [
@@ -3367,20 +3688,20 @@ function detectAvailableTools(root) {
     ".prettierrc.toml",
     "prettier.config.js"
   ];
-  const hasPrettierConfig = prettierConfigs.some((cfg) => fs11.existsSync(path11.join(root, cfg)));
+  const hasPrettierConfig = prettierConfigs.some((cfg) => fs10.existsSync(path10.join(root, cfg)));
   if (hasPrettierConfig && depNames.has("prettier")) {
     tools.push("prettier");
   }
-  if (fs11.existsSync(path11.join(root, "ruff.toml")) || fs11.existsSync(path11.join(root, ".ruff.toml"))) {
+  if (fs10.existsSync(path10.join(root, "ruff.toml")) || fs10.existsSync(path10.join(root, ".ruff.toml"))) {
     tools.push("ruff");
   }
   return tools;
 }
 function readPackageJson(root) {
   try {
-    const pkgPath = path11.join(root, "package.json");
-    if (fs11.existsSync(pkgPath)) {
-      return JSON.parse(fs11.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path10.join(root, "package.json");
+    if (fs10.existsSync(pkgPath)) {
+      return JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
     }
   } catch {
   }
@@ -3400,10 +3721,16 @@ async function runTool(tool, cwd, files, autoFix, timeoutSeconds) {
 }
 function buildToolCommand(tool, files, autoFix) {
   const pm = detectPackageManagerPrefix();
+  const root = getProjectRoot();
   switch (tool) {
     case "eslint": {
       const fixFlag = autoFix ? " --fix" : "";
       const target = files ? files.join(" ") : ".";
+      const eslintBin = findBinary(root, "eslint");
+      if (!eslintBin) {
+        console.error(`[StaticAnalysis] eslint not found locally. Trying npx (auto-install).`);
+        return "npx eslint" + fixFlag + " " + target + " --format unix";
+      }
       return pm + "eslint" + fixFlag + " " + target + " --format unix";
     }
     case "tsc": {
@@ -3412,6 +3739,11 @@ function buildToolCommand(tool, files, autoFix) {
     case "prettier": {
       const fixFlag = autoFix ? " --write" : " --check";
       const target = files ? files.join(" ") : ".";
+      const prettierBin = findBinary(root, "prettier");
+      if (!prettierBin) {
+        console.error(`[StaticAnalysis] prettier not found locally. Trying npx (auto-install).`);
+        return "npx prettier" + fixFlag + " " + target;
+      }
       return pm + "prettier" + fixFlag + " " + target;
     }
     case "ruff": {
@@ -3425,10 +3757,25 @@ function buildToolCommand(tool, files, autoFix) {
 }
 function detectPackageManagerPrefix() {
   const root = getProjectRoot();
-  if (fs11.existsSync(path11.join(root, "pnpm-lock.yaml"))) return "pnpm ";
-  if (fs11.existsSync(path11.join(root, "yarn.lock"))) return "yarn ";
+  if (fs10.existsSync(path10.join(root, "pnpm-lock.yaml"))) return "pnpm ";
+  if (fs10.existsSync(path10.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)
+  ];
+  for (const candidate of candidates) {
+    try {
+      if (fs10.existsSync(candidate)) {
+        return candidate;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
 function parseToolOutput(tool, stdout, stderr, projectRoot) {
   switch (tool) {
     case "eslint":
@@ -3445,7 +3792,7 @@ function parseToolOutput(tool, stdout, stderr, projectRoot) {
 }
 function resolveToolPath(filePath, projectRoot) {
   const trimmed = filePath.trim();
-  return path11.isAbsolute(trimmed) ? path11.relative(projectRoot, trimmed) : trimmed.replace(/^\.\//, "");
+  return path10.isAbsolute(trimmed) ? path10.relative(projectRoot, trimmed) : trimmed.replace(/^\.\//, "");
 }
 function parseEslintOutput(output, projectRoot) {
   const issues = [];
@@ -3558,10 +3905,13 @@ function formatResults2(results, allIssues, toolsRun) {
   if (!hasIssues) {
     const failedTools = results.filter((r) => r.exitCode !== 0);
     if (failedTools.length > 0) {
-      lines.push("Tool(s) executed but reported no parseable issues.");
-      lines.push("Failed tools: " + failedTools.map((t) => t.tool + " (exit: " + t.exitCode + ")").join(", "));
+      lines.push("Tool(s) executed but failed:");
+      for (const ft of failedTools) {
+        lines.push(`  - ${ft.tool} (exit code: ${ft.exitCode})`);
+      }
       lines.push("");
-      lines.push("The tool may have encountered an error. Run it manually to see full output.");
+      lines.push("The tools may not be installed correctly or encountered an error.");
+      lines.push("Run the tool manually to see the full output.");
     } else {
       lines.push("All checks passed \u2014 no issues found.");
     }
@@ -3603,13 +3953,13 @@ function formatNoToolsDetected() {
     "No linters or checkers detected for this project.",
     "",
     "Detected tools include:",
-    "  - ESLint (check .eslintrc or eslint.config.*)",
-    "  - TypeScript (check tsconfig.json)",
-    "  - Prettier (check .prettierrc)",
-    "  - Ruff (check ruff.toml)",
+    "  - ESLint  \u2014 check .eslintrc or eslint.config.*",
+    "  - tsc     \u2014 check tsconfig.json",
+    "  - Prettier \u2014 check .prettierrc",
+    "  - Ruff    \u2014 check ruff.toml",
     "",
-    "Install and configure a linter to use this tool.",
-    "Then run project_conventions to refresh detection."
+    "Each needs both a config file AND the npm package installed.",
+    "Install a linter, then run project_conventions to refresh."
   ].join("\n");
 }
 function formatToolNotAvailable(requested, available) {
@@ -3722,8 +4072,8 @@ async function handleReflect(params) {
 import { execSync as execSync6 } from "child_process";
 
 // src/guards/antiPatternDetector.ts
-import fs12 from "fs";
-import path12 from "path";
+import fs11 from "fs";
+import path11 from "path";
 import { execSync as execSync4 } from "child_process";
 var SCRIPT_PATCH_PATTERNS = [
   "writeFileSync",
@@ -3750,20 +4100,20 @@ function findPatchScripts(projectRoot) {
   const warnings = [];
   const recentFiles = scanRecentFiles(projectRoot);
   for (const file of recentFiles) {
-    const ext = path12.extname(file).toLowerCase();
+    const ext = path11.extname(file).toLowerCase();
     if (!SCRIPT_EXTENSIONS.includes(ext)) continue;
-    const relativePath = path12.relative(projectRoot, file);
+    const relativePath = path11.relative(projectRoot, file);
     if (relativePath.startsWith("src") || relativePath.startsWith("test") || relativePath.startsWith("node_modules") || relativePath.startsWith(".")) {
       continue;
     }
     try {
-      const content = fs12.readFileSync(file, "utf-8").toLowerCase();
+      const content = fs11.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: ${path12.basename(file)}`,
+          message: `Created script file that modifies other files: ${path11.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
@@ -3797,15 +4147,15 @@ function detectBashGrepUsage() {
 function scanRecentFiles(projectRoot) {
   const recent = [];
   try {
-    const entries = fs12.readdirSync(projectRoot, { withFileTypes: true });
+    const entries = fs11.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 = fs12.statSync(path12.join(projectRoot, entry.name));
+        const stat = fs11.statSync(path11.join(projectRoot, entry.name));
         if (now - stat.mtimeMs < recentThreshold || now - stat.ctimeMs < recentThreshold) {
-          recent.push(path12.join(projectRoot, entry.name));
+          recent.push(path11.join(projectRoot, entry.name));
         }
       } catch {
         continue;
@@ -3829,14 +4179,14 @@ function detectGitPatchScripts(projectRoot) {
         const prefix = line.substring(0, 2);
         if (prefix !== "??" && prefix !== "A ") continue;
         const file = line.substring(3).trim();
-        const ext = path12.extname(file).toLowerCase();
+        const ext = path11.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 = path12.join(projectRoot, file);
-        if (fs12.existsSync(fullPath)) {
-          const content = fs12.readFileSync(fullPath, "utf-8").toLowerCase();
+        const fullPath = path11.join(projectRoot, file);
+        if (fs11.existsSync(fullPath)) {
+          const content = fs11.readFileSync(fullPath, "utf-8").toLowerCase();
           const matchedPattern = SCRIPT_PATCH_PATTERNS.find((p) => content.includes(p.toLowerCase()));
           if (matchedPattern) {
             warnings.push({
@@ -3859,7 +4209,7 @@ function detectGitPatchScripts(projectRoot) {
     if (deletedStdout) {
       const deletedFiles = deletedStdout.split("\n").filter(Boolean);
       for (const file of deletedFiles) {
-        const ext = path12.extname(file).toLowerCase();
+        const ext = path11.extname(file).toLowerCase();
         if (SCRIPT_EXTENSIONS.includes(ext)) {
           warnings.push({
             severity: "high",
@@ -3919,21 +4269,21 @@ function detectAllAntiPatterns() {
 }
 
 // src/engine/contextSnapshot.ts
-import fs13 from "fs";
-import path13 from "path";
+import fs12 from "fs";
+import path12 from "path";
 import { execSync as execSync5 } from "child_process";
 var SNAPSHOT_DIR = "context-snapshots";
 function snapshotDir() {
-  return path13.join(getProjectRoot(), ".kuma", SNAPSHOT_DIR);
+  return path12.join(getProjectRoot(), ".kuma", SNAPSHOT_DIR);
 }
 function ensureSnapshotDir() {
   const dir = snapshotDir();
-  if (!fs13.existsSync(dir)) {
-    fs13.mkdirSync(dir, { recursive: true });
+  if (!fs12.existsSync(dir)) {
+    fs12.mkdirSync(dir, { recursive: true });
   }
 }
 function snapshotFilePath(timestamp) {
-  return path13.join(snapshotDir(), `${timestamp}.json`);
+  return path12.join(snapshotDir(), `${timestamp}.json`);
 }
 function saveSnapshot(goal) {
   try {
@@ -3954,7 +4304,7 @@ function saveSnapshot(goal) {
     hasConventions: !!summary.hasConventions
   };
   try {
-    fs13.writeFileSync(snapshotFilePath(Date.now()), JSON.stringify(snapshot, null, 2), "utf-8");
+    fs12.writeFileSync(snapshotFilePath(Date.now()), JSON.stringify(snapshot, null, 2), "utf-8");
   } catch {
   }
   sessionMemory.recordToolCall("kuma_context", { action: "save", goal: snapshot.goal });
@@ -3962,12 +4312,12 @@ function saveSnapshot(goal) {
 }
 function listSnapshots() {
   const dir = snapshotDir();
-  if (!fs13.existsSync(dir)) return [];
+  if (!fs12.existsSync(dir)) return [];
   try {
-    const files = fs13.readdirSync(dir).filter((f) => f.endsWith(".json")).sort((a, b) => b.localeCompare(a));
+    const files = fs12.readdirSync(dir).filter((f) => f.endsWith(".json")).sort((a, b) => b.localeCompare(a));
     return files.map((f) => {
       try {
-        const content = fs13.readFileSync(path13.join(dir, f), "utf-8");
+        const content = fs12.readFileSync(path12.join(dir, f), "utf-8");
         return JSON.parse(content);
       } catch {
         return null;
@@ -4173,6 +4523,68 @@ async function handleKumaContext(params) {
   }
 }
 
+// src/tools/kumaInit.ts
+import fs13 from "fs";
+import path13 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");
+  sessionMemory.recordToolCall("kuma_init", { projectRoot: root });
+  let rules = "";
+  if (fs13.existsSync(initMdPath)) {
+    rules = fs13.readFileSync(initMdPath, "utf-8");
+  }
+  const memories = [];
+  if (fs13.existsSync(memoriesDir)) {
+    try {
+      const files = fs13.readdirSync(memoriesDir).filter((f) => f.endsWith(".md"));
+      for (const file of files) {
+        try {
+          const content = fs13.readFileSync(path13.join(memoriesDir, file), "utf-8");
+          memories.push({ topic: file.replace(/\.md$/, ""), content });
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  const sessionLoad = sessionMemory.loadSession();
+  const sections = [
+    "\u{1F9E0} **Kuma Context Loaded**",
+    "\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"
+  ];
+  const rulesLineCount = rules ? rules.split("\n").filter((l) => l.trim()).length : 0;
+  sections.push(`\u{1F4CB} **Rules:** ${rulesLineCount} lines from .kuma/init.md`);
+  if (memories.length > 0) {
+    const memoryList = memories.map((m) => `  \u2022 **${m.topic}** \u2014 ${m.content.split("\n").filter((l) => l.trim()).length} lines`).join("\n");
+    sections.push(`\u{1F4C1} **Memories (${memories.length}):**
+${memoryList}`);
+  } else {
+    sections.push("\u{1F4C1} **Memories:** none yet \u2014 run project_conventions() to generate");
+  }
+  if (sessionLoad.hasPrevSession) {
+    sections.push(
+      "\u{1F4CA} **Previous Session:**",
+      `  \u2022 \u{1F6E0}\uFE0F ${sessionLoad.toolCallCount} tool calls`,
+      `  \u2022 ${sessionLoad.hasConventions ? "\u2705 conventions detected" : "\u274C no conventions"}`
+    );
+  } else {
+    sections.push("\u{1F4CA} **Previous Session:** none \u2014 first session for this project");
+  }
+  sections.push(
+    "\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{1F4A1} **Next Steps:**",
+    "  \u2022 Previous session context has been loaded into session memory",
+    '  \u2022 Call `get_session_memory({topic: "..."})` for detailed memory',
+    "  \u2022 If project hasn't been scanned, run `project_conventions()`",
+    "  \u2022 Or continue working \u2014 session state is ready."
+  );
+  return sections.join("\n");
+}
+
 // src/engine/lspClient.ts
 import { spawn as spawn2 } from "child_process";
 import path14 from "path";
@@ -4295,7 +4707,8 @@ var LSPClient = class {
       }
     } catch {
     }
-    return null;
+    console.error(`[LSP] typescript-language-server not found locally. Trying npx fallback.`);
+    return "npx --yes typescript-language-server";
   }
   toUri(filePath) {
     return `file://${filePath}`;
@@ -4541,19 +4954,22 @@ async function handleFindReferences(params) {
   }
   if (!lspClient.isAvailable()) {
     sessionMemory.recordToolCall("lsp_query", { action: "refs", filePath, line, character, fallback: "regex" });
+    console.error(`[LSP] typescript-language-server not found. Using regex fallback for find_references.`);
     const symbolName = extractSymbolAtPosition(resolvedPath, line, character);
     if (!symbolName) {
-      return `\u26A0\uFE0F LSP unavailable and cannot read symbol at that position for fallback grep.
+      return `**Find References** \u2014 "${filePath}:${line + 1}:${character + 1}"
+Could not read symbol at this position.
 
-\u{1F4A1} Install typescript-language-server: npm install typescript-language-server --save-dev`;
+Try selecting a smaller/cleaner position, or install typescript-language-server for better results:
+  npm install typescript-language-server --save-dev`;
     }
     return fallbackGrepReferences(symbolName, resolvedPath, line, character);
   }
   try {
     const references = await lspClient.findReferences(resolvedPath, line, character);
     if (references.length === 0) {
-      return `\u{1F50D} **Find References** \u2014 "${filePath}:${line + 1}:${character + 1}"
-\u26A0\uFE0F No references found for symbol at this position.`;
+      return `**Find References** \u2014 "${filePath}:${line + 1}:${character + 1}"
+No references found for symbol at this position.`;
     }
     const enrichedRefs = references.map((ref) => {
       let lineContent = "";
@@ -4573,7 +4989,7 @@ async function handleFindReferences(params) {
     }
     const projectRoot = getProjectRoot();
     const lines = [
-      `\u{1F50D} **Find References** \u2014 ${enrichedRefs.length} references found`,
+      `**Find References** \u2014 ${enrichedRefs.length} references found`,
       `\u{1F4CD} File: ${path15.relative(projectRoot, resolvedPath)}:${line + 1}:${character + 1}`,
       ""
     ];
@@ -4589,7 +5005,7 @@ async function handleFindReferences(params) {
     lines.push("\u{1F4A1} Use smart_file_picker to read specific files.");
     return lines.join("\n");
   } catch (err) {
-    return `Error finding references: ${err instanceof Error ? err.message : String(err)}`;
+    return `**Find References** \u2014 error during lookup: ${err instanceof Error ? err.message : String(err)}`;
   }
 }
 async function handleGoToDefinition(params) {
@@ -4604,19 +5020,22 @@ async function handleGoToDefinition(params) {
   }
   if (!lspClient.isAvailable()) {
     sessionMemory.recordToolCall("lsp_query", { action: "def", filePath, line, character, fallback: "regex" });
+    console.error(`[LSP] typescript-language-server not found. Using regex fallback for go_to_definition.`);
     const symbolName = extractSymbolAtPosition(resolvedPath, line, character);
     if (!symbolName) {
-      return `\u26A0\uFE0F LSP unavailable and cannot read symbol at that position for fallback.
+      return `**Go to Definition** \u2014 "${filePath}:${line + 1}:${character + 1}"
+Could not read symbol at this position.
 
-\u{1F4A1} Install typescript-language-server: npm install typescript-language-server --save-dev`;
+Try selecting a smaller/cleaner position, or install typescript-language-server for better results:
+  npm install typescript-language-server --save-dev`;
     }
     return fallbackGrepDefinition(symbolName);
   }
   try {
     const definition = await lspClient.goToDefinition(resolvedPath, line, character);
     if (!definition) {
-      return `\u{1F50D} **Go to Definition** \u2014 "${filePath}:${line + 1}:${character + 1}"
-\u26A0\uFE0F Cannot find definition for symbol at this position.`;
+      return `**Go to Definition** \u2014 "${filePath}:${line + 1}:${character + 1}"
+Cannot find definition for symbol at this position.`;
     }
     const projectRoot = getProjectRoot();
     const relPath = path15.relative(projectRoot, definition.filePath);
@@ -4641,7 +5060,7 @@ async function handleGoToDefinition(params) {
     ];
     return lines.join("\n");
   } catch (err) {
-    return `Error finding definition: ${err instanceof Error ? err.message : String(err)}`;
+    return `**Go to Definition** \u2014 error during lookup: ${err instanceof Error ? err.message : String(err)}`;
   }
 }
 async function handleRenameSymbol(params) {
@@ -4659,11 +5078,13 @@ async function handleRenameSymbol(params) {
   }
   if (!lspClient.isAvailable()) {
     sessionMemory.recordToolCall("lsp_query", { action: "rename", filePath, line, character, newName, fallback: "none" });
-    return `\u26A0\uFE0F **Rename Symbol** unavailable without LSP server.
-Rename requires typescript-language-server to track references across all files.
-\u{1F4A1} Install: npm install typescript-language-server --save-dev
+    console.error(`[LSP] typescript-language-server not found. Rename requires LSP server.`);
+    return `**Rename Symbol** \u2014 cannot rename without language server.
+Rename needs typescript-language-server to track references across all files.
+
+Install: npm install typescript-language-server --save-dev
 
-Meanwhile, use smart_grep to find all references, then precise_diff_editor for manual editing.`;
+Meanwhile, use smart_grep to find all references, then precise_diff_editor to rename manually.`;
   }
   try {
     const result = await lspClient.renameSymbol(resolvedPath, line, character, newName);
@@ -4676,7 +5097,7 @@ Make sure:
 \`\`\``;
     }
     if (result.changes.length === 0) {
-      return "\u26A0\uFE0F No changes needed.";
+      return "No changes needed.";
     }
     const projectRoot = getProjectRoot();
     let totalEdits = 0;
@@ -4732,12 +5153,13 @@ async function handleGetTypeInfo(params) {
   }
   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 fileLines = fileContent.split("\n");
       const targetLine = fileLines[line];
       if (!targetLine) {
-        return `\u26A0\uFE0F **Type Info** \u2014 Line ${line + 1} does not exist in "${filePath}".`;
+        return `**Type Info** \u2014 Line ${line + 1} does not exist in "${filePath}".`;
       }
       const symbolName = extractSymbolAtPosition(resolvedPath, line, character);
       const projectRoot = getProjectRoot();
@@ -4754,29 +5176,26 @@ async function handleGetTypeInfo(params) {
         }
       }
       const resultLines = [
-        `\u{1F4CB} **Type Info** (fallback \u2014 LSP unavailable)`,
-        `\u{1F4C4} \`${relPath}:${line + 1}:${character + 1}\``,
-        symbolName ? `\u{1F524} **Symbol:** \`${symbolName}\`` : `\u26A0\uFE0F Could not extract symbol at this position.`,
+        `\u{1F4CB} **Type Info** \u2014 \`${relPath}:${line + 1}:${character + 1}\``,
+        symbolName ? `\u{1F524} **Symbol:** \`${symbolName}\`` : `Could not extract symbol at this position.`,
         "",
         "\u{1F4CE} Context:",
         "```",
         ...contextLines,
         "```",
         "",
-        `\u26A0\uFE0F Full type info requires typescript-language-server.`,
-        `\u{1F4A1} Install: npm install typescript-language-server --save-dev`,
-        `\u{1F4A1} Use smart_grep or smart_file_picker to read the file for more context.`
+        "Use smart_grep or smart_file_picker to read more context."
       ];
       return resultLines.join("\n");
     } catch (err) {
-      return `\u26A0\uFE0F **Type Info** unavailable without LSP server, and could not read file for fallback: ${err instanceof Error ? err.message : String(err)}`;
+      return `**Type Info** \u2014 could not read file for context: ${err instanceof Error ? err.message : String(err)}`;
     }
   }
   try {
     const hoverInfo = await lspClient.getTypeInfo(resolvedPath, line, character);
     if (!hoverInfo || !hoverInfo.contents) {
-      return `\u{1F4CB} **Type Info** \u2014 "${filePath}:${line + 1}:${character + 1}"
-\u26A0\uFE0F No type info for this position.`;
+      return `**Type Info** \u2014 "${filePath}:${line + 1}:${character + 1}"
+No type info for this position.`;
     }
     const projectRoot = getProjectRoot();
     const relPath = path15.relative(projectRoot, resolvedPath);
@@ -4864,8 +5283,8 @@ async function fallbackGrepReferences(symbolName, _filePath, _line, _character)
       }
     }
     if (results.length === 0) {
-      return `\u{1F50D} **Find References** (regex fallback) \u2014 "${symbolName}"
-\u26A0\uFE0F No references found. Symbol may not be used in other files.`;
+      return `**Find References** \u2014 "${symbolName}"
+No references found. Symbol may not be used in other files.`;
     }
     const grouped = /* @__PURE__ */ new Map();
     for (const r of results) {
@@ -4875,17 +5294,14 @@ async function fallbackGrepReferences(symbolName, _filePath, _line, _character)
     }
     const projectRoot = getProjectRoot();
     const lines = [
-      `\u{1F50D} **Find References** (regex fallback) \u2014 ${results.length} references found`,
+      `**Find References** \u2014 ${results.length} references found`,
       `\u{1F4CD} Symbol: "${symbolName}"`,
-      `\u26A0\uFE0F Regex results may be less accurate than LSP (includes comments/strings).`,
       ""
     ];
     if (grouped.size > 1) {
       const fileList = [...grouped.keys()].map((f) => path15.relative(projectRoot, f)).join(", ");
-      lines.push(`\u26A0\uFE0F **Ambiguity warning:** Found matches across ${grouped.size} different files (${fileList}).`);
-      lines.push(`   Regex fallback cannot distinguish between different scopes with the same symbol name.`);
-      lines.push(`   If you intended only one scope, clarify which file or location you mean.`);
-      lines.push(`   \u{1F4A1} Install typescript-language-server for scope-aware disambiguation.`);
+      lines.push(`**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("");
     } else if (results.length > 1) {
       const filePath = [...grouped.keys()][0];
@@ -4894,9 +5310,8 @@ async function fallbackGrepReferences(symbolName, _filePath, _line, _character)
       const minLine = Math.min(...matchLines);
       const maxLine = Math.max(...matchLines);
       if (maxLine - minLine > 15) {
-        lines.push(`\u26A0\uFE0F **Ambiguity warning:** Found ${results.length} matches for "${symbolName}" spanning lines ${minLine}-${maxLine} in the same file.`);
-        lines.push(`   They may be in different function scopes \u2014 regex cannot distinguish them.`);
-        lines.push(`   \u{1F4A1} Verify each match is the intended symbol before editing.`);
+        lines.push(`**Ambiguity note:** Found ${results.length} matches for "${symbolName}" spanning lines ${minLine}-${maxLine} in the same file.`);
+        lines.push(`   Verify each match is the intended symbol.`);
         lines.push("");
       }
     }
@@ -4908,7 +5323,7 @@ async function fallbackGrepReferences(symbolName, _filePath, _line, _character)
       }
       lines.push("");
     }
-    lines.push("\u{1F4A1} Install typescript-language-server for more accurate results.");
+    console.error(`[LSP] Regex fallback: found ${results.length} references for "${symbolName}".`);
     return lines.join("\n");
   } catch (err) {
     return `Error in fallback grep references: ${err instanceof Error ? err.message : String(err)}`;
@@ -4944,12 +5359,10 @@ async function fallbackGrepDefinition(symbolName) {
               const projectRoot = getProjectRoot();
               const relPath = path15.relative(projectRoot, file);
               return [
-                `\u{1F4CD} **Go to Definition** (regex fallback)`,
+                `\u{1F4CD} **Go to Definition**`,
                 `\u{1F4C4} File: \`${relPath}\``,
                 `\u{1F4CF} Line: ${i + 1}`,
-                `\u2514 ${trimmed.substring(0, 120)}`,
-                "",
-                `\u{1F4A1} Install typescript-language-server for more accurate results.`
+                `\u2514 ${trimmed.substring(0, 120)}`
               ].join("\n");
             }
           }
@@ -4958,9 +5371,9 @@ async function fallbackGrepDefinition(symbolName) {
         continue;
       }
     }
-    return `\u{1F4CD} **Go to Definition** (regex fallback) \u2014 "${symbolName}"
-\u26A0\uFE0F Cannot find definition.
-\u{1F4A1} Install typescript-language-server for more accurate results.`;
+    console.error(`[LSP] Regex fallback: no definition found for "${symbolName}".`);
+    return `**Go to Definition** \u2014 "${symbolName}"
+Cannot find definition.`;
   } catch (err) {
     return `Error in fallback grep definition: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -5290,811 +5703,22 @@ function registerAllTools(server) {
       }
     }
   );
-  console.error("[Manifest] Registered 17 tools.");
-}
-
-// src/cli/init.ts
-import fs16 from "fs";
-import path16 from "path";
-var ALL_CONFIG_TYPES = [
-  "claude",
-  "cursor",
-  "windsurf",
-  "copilot",
-  "cline",
-  "aider",
-  "antigravity",
-  "opencode",
-  "codex",
-  "qwen",
-  "kiro",
-  "openclaw",
-  "codewhale"
-];
-var CONFIG_LABELS = {
-  claude: "Claude Code (CLAUDE.md / plugin)",
-  cursor: "Cursor (.cursor/rules/*.mdc)",
-  windsurf: "Windsurf (.windsurfrules)",
-  copilot: "GitHub Copilot Editor (AGENTS.md + Skill)",
-  cline: "Cline (.clinerules/*.md)",
-  aider: "Aider (CONVENTIONS.md via .aider.conf.yml)",
-  antigravity: "Antigravity CLI (.agents/skills/)",
-  opencode: "OpenCode (opencode.json)",
-  codex: "Codex CLI (AGENTS.md + .codex/config.toml)",
-  qwen: "Qwen Code (AGENTS.md + settings.json)",
-  kiro: "Kiro (.kiro/steering/*.md)",
-  openclaw: "OpenClaw (skills/)",
-  codewhale: "CodeWhale (skills/ + .codewhale/mcp.json)"
-};
-function configFilePath(type) {
-  switch (type) {
-    case "claude":
-      return "CLAUDE.md";
-    case "cursor":
-      return ".cursor/rules/kuma.mdc";
-    case "windsurf":
-      return ".windsurfrules";
-    case "copilot":
-      return "AGENTS.md";
-    case "cline":
-      return ".clinerules/kuma.md";
-    case "aider":
-      return "CONVENTIONS.md";
-    case "antigravity":
-      return ".agents/skills/kuma/SKILL.md";
-    case "opencode":
-      return "opencode.json";
-    case "codex":
-      return "AGENTS.md";
-    case "qwen":
-      return "AGENTS.md";
-    case "kiro":
-      return ".kiro/steering/kuma.md";
-    case "openclaw":
-      return "skills/kuma/SKILL.md";
-    case "codewhale":
-      return "skills/kuma/SKILL.md";
-  }
-}
-var CORE_RULES = [
-  "## AI Agent Usage Guidelines",
-  "",
-  "Kuma MCP tools are available. Use them correctly:",
-  "",
-  "### Code Search",
-  "- Use the **smart_grep** tool to search code - NOT bash grep/ripgrep manually",
-  "- smart_grep returns line numbers + context, caches results, respects .gitignore",
-  `- **Example:** smart_grep({ query: "function handleAuth", extensions: ['ts'] })`,
-  "",
-  "### Reading Code",
-  "- Use the **smart_file_picker** tool to read files with smart chunking",
-  "- For large files, use startLine/endLine to read specific ranges",
-  '- **Example:** smart_file_picker({ filePath: "src/index.ts", chunkStrategy: "outline" })',
-  '- **Example:** smart_file_picker({ filePath: "src/index.ts", startLine: 10, endLine: 30 })',
-  "",
-  "### Editing Code",
-  "- Use the **precise_diff_editor** tool to edit files (fuzzy matching + auto-backup)",
-  "- DO NOT create Python/Node scripts to patch files; use precise_diff_editor directly",
-  "- DO NOT use bash sed/cat/awk to modify source files",
-  '- **Example:** precise_diff_editor({ filePath: "src/app.ts", edits: [{ searchBlock: "old code", replaceBlock: "new code" }] })',
-  '- **Example:** precise_diff_editor({ filePath: "src/app.ts", dryRun: true, edits: [...] })',
-  '- **Example:** precise_diff_editor({ filePath: "src/app.ts", action: "rollback" })',
-  "",
-  "### Creating Files",
-  "- Use the **batch_file_writer** tool to create new files (up to 15 at once)",
-  '- **Example:** batch_file_writer({ files: [{ filePath: "src/util.ts", content: "// code", instructions: "reason for creating" }] })',
-  "",
-  "### Running Tasks",
-  "- Use the **execute_safe_test** tool for test/build/lint/typecheck",
-  "- Always run typecheck after editing TypeScript files",
-  '- **Example:** execute_safe_test({ task: "typecheck" })',
-  '- **Example:** execute_safe_test({ task: "custom", customCommand: "npm run lint" })',
-  "",
-  "### Code Review",
-  "- Use the **code_reviewer** tool after changes",
-  "- Supports focus: correctness, security, performance, over-engineering",
-  '- **Example:** code_reviewer({ focus: "security" })',
-  '- **Example:** code_reviewer({ files: ["src/auth.ts"], format: "json" })',
-  "",
-  "### Git Operations",
-  "- Use the **git_diff** tool for structured diff output",
-  "- Use the **git_log** tool for commit history",
-  "- **Example:** git_log({ maxCount: 5 })",
-  "- **Example:** git_diff({ staged: true })",
-  "",
-  "### Session Awareness",
-  "- Use the **kuma_reflect** tool to check on-track/drift/loops",
-  "- Use the **kuma_guard** tool for deeper safety checks (anti-patterns, auto-detection)",
-  "- Use the **get_session_memory** tool to recall session state",
-  '- **Example:** kuma_reflect({ goal: "refactor auth" })',
-  '- **Example:** kuma_guard({ check: "all", goal: "refactor auth" })',
-  "",
-  "### LSP / Code Intelligence",
-  "- Use the **lsp_query** tool for go-to-definition, find references, type info",
-  '- **Example:** lsp_query({ filePath: "src/index.ts", line: 5, character: 10, action: "def" })',
-  '- **Example:** lsp_query({ filePath: "src/index.ts", line: 5, character: 10, action: "refs" })',
-  "",
-  "### Static Analysis",
-  "- Use the **static_analysis** tool to run ESLint/TSC/Prettier/Ruff",
-  '- **Example:** static_analysis({ tool: "eslint", autoFix: true })',
-  "",
-  "### Project Structure",
-  "- Use the **project_structure** tool to see project layout",
-  "- **Example:** project_structure({ depth: 2, folderOnly: true })",
-  "",
-  "### Write Memory",
-  "- Use the **write_memory** tool to persist decisions and glossary",
-  '- **Example:** write_memory({ topic: "decisions", content: "## Reason for using X" })',
-  "",
-  "### General Rules",
-  "- When you error, READ the error carefully before acting",
-  "- After 3+ edits without running tests, stop and verify",
-  "- If a tool fails, check the message - don't retry blindly",
-  "- Detect conventions first with the **project_conventions** tool",
-  "- **Example:** project_conventions({ forceRescan: true })"
-].join("\n");
-var KUMA_CORE_INSTRUCTIONS = CORE_RULES;
-function claudeTemplate() {
-  return [
-    "# Kuma AI Agent Guidelines",
-    "",
-    KUMA_CORE_INSTRUCTIONS,
-    "",
-    "## Workflow Pipeline",
-    "",
-    "For best results:",
-    "1. **project_conventions** - detect stack",
-    "2. **smart_grep** / **smart_file_picker** - understand code",
-    "3. **precise_diff_editor** / **batch_file_writer** - make changes",
-    "4. **execute_safe_test** - verify (typecheck + test)",
-    "5. **code_reviewer** - review changes"
-  ].join("\n");
-}
-function cursorRulesTemplate() {
-  return [
-    "---",
-    "description: Kuma MCP tool usage rules for AI coding agents",
-    "alwaysApply: true",
-    "---",
-    "",
-    "You are an expert engineer. Kuma MCP tools are available.",
-    "",
-    "## Critical Rules",
-    "",
-    KUMA_CORE_INSTRUCTIONS,
-    "",
-    "## NEVER",
-    "- Never create Python/Node scripts to patch code",
-    "- Never use bash sed/cat/awk to edit source files",
-    "- Never run git push/git commit through bash"
-  ].join("\n");
-}
-function windsurfRulesTemplate() {
-  return [
-    "# Windsurf Cascade Rules with Kuma",
-    "",
-    KUMA_CORE_INSTRUCTIONS
-  ].join("\n");
-}
-function copilotTemplate() {
-  return [
-    "## GitHub Copilot Editor",
-    "",
-    "Kuma MCP tools are available. Use them correctly:",
-    "",
-    KUMA_CORE_INSTRUCTIONS,
-    "",
-    "### Copilot Editor-Specific",
-    "- Copilot Editor reads AGENTS.md at project root for persistent instructions",
-    "- Configure MCP servers via VS Code settings (cmd+shift+P \u2192 Developer: Reload Window after adding Kuma)",
-    "- Use kuma_guard periodically to check for anti-patterns"
-  ].join("\n");
-}
-function clineRulesTemplate() {
-  return [
-    "---",
-    "description: Kuma MCP tool usage rules for AI coding agents",
-    "paths:",
-    '  - "*"',
-    "---",
-    "",
-    KUMA_CORE_INSTRUCTIONS
-  ].join("\n");
-}
-function aiderTemplate() {
-  return [
-    "# Kuma MCP - Aider Coding Conventions",
-    "",
-    "These conventions are loaded by Aider via the `read:` field in .aider.conf.yml",
-    "",
-    KUMA_CORE_INSTRUCTIONS
-  ].join("\n");
-}
-function opencodeTemplate() {
-  const config = {
-    mcp: {
-      kuma: {
-        type: "local",
-        command: ["npx", "-y", "@plumpslabs/kuma"],
-        enabled: true
-      }
+  server.tool(
+    "kuma_init",
+    "**Call this FIRST** in every new session. Loads project context: rules from .kuma/init.md, memories from .kuma/memories/, and previous session state. After this, you can work without re-detecting conventions.",
+    {
+      projectRoot: z.string().optional().describe("Project root path (auto-detected if omitted)")
     },
-    instructions: ["CLAUDE.md"]
-  };
-  const header = [
-    "// Generated by Kuma MCP - https://github.com/plumpslabs/kuma",
-    "// OpenCode config with Kuma MCP tools. Edit opencode.json to customize.",
-    ""
-  ].join("\n");
-  return header + JSON.stringify(config, null, 2) + "\n";
-}
-function codexTemplate() {
-  return [
-    "## Codex CLI (OpenAI)",
-    "",
-    "Kuma MCP tools are available. Use them correctly:",
-    "",
-    KUMA_CORE_INSTRUCTIONS,
-    "",
-    "### Codex-Specific",
-    "- Codex uses cascading AGENTS.md files (global ~/.codex/AGENTS.md -> project AGENTS.md)",
-    "- MCP config is in .codex/config.toml (auto-generated by kuma init)",
-    "- Use kuma_guard periodically to check for anti-patterns"
-  ].join("\n");
-}
-function codexConfigTomlTemplate() {
-  return [
-    "# Generated by Kuma MCP - https://github.com/plumpslabs/kuma",
-    "# Kuma MCP server config for Codex CLI",
-    "",
-    "[mcp_servers.kuma]",
-    'command = "npx"',
-    'args = ["-y", "@plumpslabs/kuma"]',
-    ""
-  ].join("\n");
-}
-function qwenTemplate() {
-  return [
-    "## Qwen Code",
-    "",
-    "Kuma MCP tools are available. Use them correctly:",
-    "",
-    KUMA_CORE_INSTRUCTIONS,
-    "",
-    "### Qwen-Specific",
-    "- Qwen reads AGENTS.md at project root for persistent instructions",
-    "- MCP config is in settings.json (auto-generated by kuma init)",
-    "- Use kuma_guard periodically to check for anti-patterns"
-  ].join("\n");
-}
-function qwenSettingsTemplate() {
-  const config = {
-    mcpServers: {
-      kuma: {
-        command: "npx",
-        args: ["-y", "@plumpslabs/kuma"],
-        env: {}
-      }
-    }
-  };
-  return JSON.stringify(config, null, 2) + "\n";
-}
-function kiroRulesTemplate() {
-  return [
-    "---",
-    "name: kuma-mcp",
-    "description: Kuma safety toolkit - use smart_grep for search, precise_diff_editor for edits",
-    "inclusion: always",
-    "---",
-    "",
-    "# Kuma MCP - Kiro Steering",
-    "",
-    KUMA_CORE_INSTRUCTIONS,
-    "",
-    "## Kiro-Specific",
-    "- Kiro reads steering files from .kiro/steering/ for project instructions",
-    "- Configure MCP servers via IDE settings or global Kiro config",
-    "- Use kuma_guard periodically to check for anti-patterns"
-  ].join("\n");
-}
-function openclawSkillTemplate() {
-  return [
-    "---",
-    "name: kuma-mcp",
-    "description: Kuma safety toolkit for AI coding agents. Use smart_grep for search, precise_diff_editor for edits, execute_safe_test for verification.",
-    "---",
-    "",
-    "# Kuma MCP - OpenClaw Skill",
-    "",
-    KUMA_CORE_INSTRUCTIONS,
-    "",
-    "## OpenClaw-Specific",
-    "- OpenClaw loads skills/ from workspace root or ~/.openclaw/skills for global",
-    "- Configure Kuma MCP server via ~/.openclaw/openclaw.json or agents standard",
-    "- Use kuma_guard periodically to check for anti-patterns",
-    "",
-    "## Verification",
-    "- After edits, run execute_safe_test to verify no breakage",
-    "- Use code_reviewer for correctness/security review",
-    "- Check kuma_reflect to confirm on-track"
-  ].join("\n");
-}
-function codewhaleTemplate() {
-  return [
-    "---",
-    "name: kuma-mcp",
-    "description: Kuma safety toolkit for AI coding agents. Use smart_grep for search, precise_diff_editor for edits, execute_safe_test for verification.",
-    "---",
-    "",
-    "# Kuma MCP - CodeWhale Skill",
-    "",
-    KUMA_CORE_INSTRUCTIONS,
-    "",
-    "## CodeWhale-Specific",
-    "- CodeWhale loads SKILL.md from skills/ (workspace-local), .agents/skills/, or ~/.codewhale/skills/",
-    "- MCP config is in ~/.codewhale/mcp.json or ~/.deepseek/mcp.json",
-    "- Use kuma_guard periodically to check for anti-patterns",
-    "",
-    "## Verification",
-    "- After edits, run execute_safe_test to verify no breakage",
-    "- Use code_reviewer for correctness/security review",
-    "- Check kuma_reflect to confirm on-track"
-  ].join("\n");
-}
-function antigravitySkillTemplate() {
-  return [
-    "---",
-    "name: kuma-mcp",
-    "description: Kuma safety toolkit for AI coding agents. Use smart_grep for search, precise_diff_editor for edits, execute_safe_test for verification.",
-    "---",
-    "",
-    "# Kuma MCP - Antigravity Skill",
-    "",
-    KUMA_CORE_INSTRUCTIONS,
-    "",
-    "## Verification",
-    "- After edits, run execute_safe_test to verify no breakage",
-    "- Use code_reviewer for correctness/security review",
-    "- Check kuma_reflect to confirm on-track"
-  ].join("\n");
-}
-function antigravityMcpConfigTemplate() {
-  const config = {
-    mcpServers: {
-      kuma: {
-        command: "npx",
-        args: ["-y", "@plumpslabs/kuma"],
-        env: {}
-      }
-    }
-  };
-  return JSON.stringify(config, null, 2) + "\n";
-}
-var TEMPLATES = {
-  claude: claudeTemplate,
-  cursor: cursorRulesTemplate,
-  windsurf: windsurfRulesTemplate,
-  copilot: copilotTemplate,
-  cline: clineRulesTemplate,
-  aider: aiderTemplate,
-  antigravity: antigravitySkillTemplate,
-  opencode: opencodeTemplate,
-  codex: codexTemplate,
-  qwen: qwenTemplate,
-  kiro: kiroRulesTemplate,
-  openclaw: openclawSkillTemplate,
-  codewhale: codewhaleTemplate
-};
-var APPEND_SEPARATOR = "\n\n---\n_Generated by Kuma MCP - https://github.com/plumpslabs/kuma_\n\n";
-function handleOpencodeSecondary(root, results) {
-  const claudePath = path16.resolve(root, "CLAUDE.md");
-  if (!fs16.existsSync(claudePath)) {
-    try {
-      fs16.writeFileSync(claudePath, [
-        "# Kuma MCP - OpenCode Instructions",
-        "",
-        KUMA_CORE_INSTRUCTIONS
-      ].join("\n"), "utf-8");
-      results.push({ type: "opencode", filePath: "CLAUDE.md", action: "created" });
-    } catch (err) {
-      results.push({
-        type: "opencode",
-        filePath: "CLAUDE.md",
-        action: "error",
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-}
-function handleCodexSecondary(root, results) {
-  const tomlPath = path16.resolve(root, ".codex/config.toml");
-  if (results.some((r) => r.filePath === ".codex/config.toml")) return;
-  try {
-    const dir = path16.dirname(tomlPath);
-    if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
-    if (fs16.existsSync(tomlPath)) {
-      const existingContent = fs16.readFileSync(tomlPath, "utf-8");
-      if (existingContent.includes("kuma")) {
-        results.push({ type: "codex", filePath: ".codex/config.toml", action: "skipped" });
-        return;
-      }
-      fs16.writeFileSync(tomlPath, existingContent.trimEnd() + "\n\n" + codexConfigTomlTemplate(), "utf-8");
-      results.push({ type: "codex", filePath: ".codex/config.toml", action: "appended" });
-    } else {
-      fs16.writeFileSync(tomlPath, codexConfigTomlTemplate(), "utf-8");
-      results.push({ type: "codex", filePath: ".codex/config.toml", action: "created" });
-    }
-  } catch (err) {
-    results.push({
-      type: "codex",
-      filePath: ".codex/config.toml",
-      action: "error",
-      error: err instanceof Error ? err.message : String(err)
-    });
-  }
-}
-function handleQwenSecondary(root, results) {
-  const settingsPath = path16.resolve(root, "settings.json");
-  if (results.some((r) => r.filePath === "settings.json")) return;
-  try {
-    if (fs16.existsSync(settingsPath)) {
-      const existingContent = fs16.readFileSync(settingsPath, "utf-8");
-      if (existingContent.includes("kuma")) {
-        if (!existingContent.includes("_Generated by Kuma MCP_")) {
-          try {
-            const parsed = JSON.parse(existingContent);
-            parsed.mcpServers = parsed.mcpServers || {};
-            if (!parsed.mcpServers.kuma) {
-              parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
-              fs16.writeFileSync(settingsPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
-              results.push({ type: "qwen", filePath: "settings.json", action: "appended" });
-              return;
-            }
-          } catch {
-          }
-        }
-        results.push({ type: "qwen", filePath: "settings.json", action: "skipped" });
-        return;
-      }
+    async (params) => {
       try {
-        const parsed = JSON.parse(existingContent);
-        parsed.mcpServers = parsed.mcpServers || {};
-        if (!parsed.mcpServers.kuma) {
-          parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
-          fs16.writeFileSync(settingsPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
-          results.push({ type: "qwen", filePath: "settings.json", action: "appended" });
-        }
-      } catch {
-      }
-    } else {
-      fs16.writeFileSync(settingsPath, qwenSettingsTemplate(), "utf-8");
-      results.push({ type: "qwen", filePath: "settings.json", action: "created" });
-    }
-  } catch (err) {
-    results.push({
-      type: "qwen",
-      filePath: "settings.json",
-      action: "error",
-      error: err instanceof Error ? err.message : String(err)
-    });
-  }
-}
-var AGENTS_MD_TYPES = ["codex", "qwen", "copilot"];
-function getAgentsMdHeader() {
-  return [
-    "# Kuma MCP - Combined Agent Instructions",
-    "",
-    "This file contains instructions for AI coding agents that read AGENTS.md.",
-    "Each section applies to a specific agent. Unused sections can be safely removed.",
-    "",
-    "---",
-    "_Generated by Kuma MCP - https://github.com/plumpslabs/kuma_",
-    ""
-  ].join("\n");
-}
-function getCombinedAgentsMd(selectedTypes) {
-  const sections = [getAgentsMdHeader()];
-  const agentOrder = ["codex", "qwen", "copilot"];
-  for (const t of agentOrder) {
-    if (selectedTypes.has(t)) {
-      sections.push(TEMPLATES[t]());
-    }
-  }
-  return sections.join("\n\n---\n\n");
-}
-function handleAntigravityMcpConfig(root, results) {
-  const mcpPath = path16.resolve(root, ".agents/mcp_config.json");
-  if (results.some((r) => r.filePath === ".agents/mcp_config.json")) return;
-  try {
-    const mcpDir = path16.dirname(mcpPath);
-    if (fs16.existsSync(mcpPath)) {
-      const existingContent = fs16.readFileSync(mcpPath, "utf-8");
-      if (existingContent.includes("kuma")) {
-        if (!existingContent.includes("_Generated by Kuma MCP_")) {
-          const trimmed = existingContent.trimEnd();
-          if (trimmed.endsWith("}")) {
-            const updated = trimmed.slice(0, -1).trimEnd() + ',\n  "_kuma_note": "Kuma MCP - Generated by kuma init"\n}\n';
-            fs16.writeFileSync(mcpPath, updated, "utf-8");
-            results.push({ type: "antigravity", filePath: ".agents/mcp_config.json", action: "appended" });
-          }
-        }
-        return;
-      }
-      const parsed = JSON.parse(existingContent);
-      parsed.mcpServers = parsed.mcpServers || {};
-      parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
-      fs16.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
-      results.push({ type: "antigravity", filePath: ".agents/mcp_config.json", action: "appended" });
-    } else {
-      if (!fs16.existsSync(mcpDir)) fs16.mkdirSync(mcpDir, { recursive: true });
-      fs16.writeFileSync(mcpPath, antigravityMcpConfigTemplate(), "utf-8");
-      results.push({ type: "antigravity", filePath: ".agents/mcp_config.json", action: "created" });
-    }
-  } catch (err) {
-    results.push({
-      type: "antigravity",
-      filePath: ".agents/mcp_config.json",
-      action: "error",
-      error: err instanceof Error ? err.message : String(err)
-    });
-  }
-}
-function handleAiderSecondary(root, results) {
-  const ymlPath = path16.resolve(root, ".aider.conf.yml");
-  if (results.some((r) => r.filePath === ".aider.conf.yml")) return;
-  try {
-    const conventionsRef = "read: CONVENTIONS.md";
-    if (fs16.existsSync(ymlPath)) {
-      const existingContent = fs16.readFileSync(ymlPath, "utf-8");
-      if (existingContent.includes("CONVENTIONS.md") || existingContent.includes("kuma")) {
-        results.push({ type: "aider", filePath: ".aider.conf.yml", action: "skipped" });
-        return;
-      }
-      const newContent = existingContent.trimEnd() + "\n\n# Kuma MCP conventions\n" + conventionsRef + "\n";
-      fs16.writeFileSync(ymlPath, newContent, "utf-8");
-      results.push({ type: "aider", filePath: ".aider.conf.yml", action: "appended" });
-    } else {
-      const content = [
-        "# Generated by Kuma MCP - https://github.com/plumpslabs/kuma",
-        "# Aider will read CONVENTIONS.md for coding conventions",
-        "",
-        conventionsRef,
-        ""
-      ].join("\n");
-      fs16.writeFileSync(ymlPath, content, "utf-8");
-      results.push({ type: "aider", filePath: ".aider.conf.yml", action: "created" });
-    }
-  } catch (err) {
-    results.push({
-      type: "aider",
-      filePath: ".aider.conf.yml",
-      action: "error",
-      error: err instanceof Error ? err.message : String(err)
-    });
-  }
-}
-function handleCopilotSecondary(root, results) {
-  const skillPath = path16.resolve(root, ".github/skills/kuma/SKILL.md");
-  if (results.some((r) => r.filePath === ".github/skills/kuma/SKILL.md")) return;
-  try {
-    const dir = path16.dirname(skillPath);
-    const content = [
-      "---",
-      "name: kuma-mcp",
-      "description: Kuma safety toolkit for AI coding agents. Use smart_grep for search, precise_diff_editor for edits, execute_safe_test for verification.",
-      "---",
-      "",
-      "# Kuma MCP - Copilot Editor Skill",
-      "",
-      KUMA_CORE_INSTRUCTIONS
-    ].join("\n");
-    if (fs16.existsSync(skillPath)) {
-      const existingContent = fs16.readFileSync(skillPath, "utf-8");
-      if (existingContent.includes("kuma")) {
-        results.push({ type: "copilot", filePath: ".github/skills/kuma/SKILL.md", action: "skipped" });
-        return;
-      }
-      fs16.writeFileSync(skillPath, existingContent.trimEnd() + "\n\n" + content, "utf-8");
-      results.push({ type: "copilot", filePath: ".github/skills/kuma/SKILL.md", action: "appended" });
-    } else {
-      if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
-      fs16.writeFileSync(skillPath, content, "utf-8");
-      results.push({ type: "copilot", filePath: ".github/skills/kuma/SKILL.md", action: "created" });
-    }
-  } catch (err) {
-    results.push({
-      type: "copilot",
-      filePath: ".github/skills/kuma/SKILL.md",
-      action: "error",
-      error: err instanceof Error ? err.message : String(err)
-    });
-  }
-}
-function handleOpenclawSecondary(root, results) {
-  const mcpPath = path16.resolve(root, ".agents/mcp_config.json");
-  if (results.some((r) => r.filePath === ".agents/mcp_config.json")) return;
-  try {
-    const dir = path16.dirname(mcpPath);
-    if (fs16.existsSync(mcpPath)) {
-      const existingContent = fs16.readFileSync(mcpPath, "utf-8");
-      if (existingContent.includes("kuma")) return;
-      const parsed = JSON.parse(existingContent);
-      parsed.mcpServers = parsed.mcpServers || {};
-      parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
-      fs16.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
-      results.push({ type: "openclaw", filePath: ".agents/mcp_config.json", action: "appended" });
-    } else {
-      if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
-      fs16.writeFileSync(mcpPath, antigravityMcpConfigTemplate(), "utf-8");
-      results.push({ type: "openclaw", filePath: ".agents/mcp_config.json", action: "created" });
-    }
-  } catch (err) {
-    results.push({
-      type: "openclaw",
-      filePath: ".agents/mcp_config.json",
-      action: "error",
-      error: err instanceof Error ? err.message : String(err)
-    });
-  }
-}
-function handleCodewhaleSecondary(root, results) {
-  const mcpPath = path16.resolve(root, ".codewhale/mcp.json");
-  if (results.some((r) => r.filePath === ".codewhale/mcp.json")) return;
-  try {
-    const dir = path16.dirname(mcpPath);
-    if (fs16.existsSync(mcpPath)) {
-      const existingContent = fs16.readFileSync(mcpPath, "utf-8");
-      if (existingContent.includes("kuma")) return;
-      const parsed = JSON.parse(existingContent);
-      parsed.mcpServers = parsed.mcpServers || {};
-      parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
-      fs16.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
-      results.push({ type: "codewhale", filePath: ".codewhale/mcp.json", action: "appended" });
-    } else {
-      if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
-      const config = {
-        mcpServers: {
-          kuma: {
-            command: "npx",
-            args: ["-y", "@plumpslabs/kuma"],
-            env: {}
-          }
-        }
-      };
-      fs16.writeFileSync(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
-      results.push({ type: "codewhale", filePath: ".codewhale/mcp.json", action: "created" });
-    }
-  } catch (err) {
-    results.push({
-      type: "codewhale",
-      filePath: ".codewhale/mcp.json",
-      action: "error",
-      error: err instanceof Error ? err.message : String(err)
-    });
-  }
-}
-function runInit(types, projectRoot) {
-  const root = projectRoot ?? getProjectRoot();
-  const selected = types.length > 0 ? types : ALL_CONFIG_TYPES;
-  const results = [];
-  const selectedSet = new Set(selected);
-  const agentsMdSelected = AGENTS_MD_TYPES.filter((t) => selectedSet.has(t));
-  let agentsMdHandled = false;
-  for (const type of selected) {
-    const relativePath = configFilePath(type);
-    const fullPath = path16.resolve(root, relativePath);
-    const getTemplate = TEMPLATES[type];
-    try {
-      if (AGENTS_MD_TYPES.includes(type) && !agentsMdHandled) {
-        agentsMdHandled = true;
-        const combinedContent = getCombinedAgentsMd(new Set(agentsMdSelected));
-        if (fs16.existsSync(fullPath)) {
-          const existingContent = fs16.readFileSync(fullPath, "utf-8");
-          if (existingContent.includes("_Generated by Kuma MCP_")) {
-            results.push({ type, filePath: relativePath, action: "skipped" });
-          } else {
-            fs16.writeFileSync(fullPath, existingContent.trimEnd() + "\n\n" + combinedContent, "utf-8");
-            results.push({ type, filePath: relativePath, action: "appended" });
-          }
-        } else {
-          const dir = path16.dirname(fullPath);
-          if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
-          fs16.writeFileSync(fullPath, combinedContent, "utf-8");
-          results.push({ type, filePath: relativePath, action: "created" });
-        }
-        if (selectedSet.has("codex")) handleCodexSecondary(root, results);
-        if (selectedSet.has("qwen")) handleQwenSecondary(root, results);
-        if (selectedSet.has("copilot")) handleCopilotSecondary(root, results);
-      } else if (AGENTS_MD_TYPES.includes(type) && agentsMdHandled) {
-        results.push({ type, filePath: relativePath, action: "skipped" });
-        continue;
-      } else {
-        const template = getTemplate();
-        if (fs16.existsSync(fullPath)) {
-          const existingContent = fs16.readFileSync(fullPath, "utf-8");
-          if (existingContent.includes("_Generated by Kuma MCP_")) {
-            if (type === "antigravity") {
-              handleAntigravityMcpConfig(root, results);
-            } else if (type === "openclaw") {
-              handleOpenclawSecondary(root, results);
-            } else if (type === "codewhale") {
-              handleCodewhaleSecondary(root, results);
-            }
-            results.push({ type, filePath: relativePath, action: "skipped" });
-            continue;
-          }
-          const newContent = existingContent.trimEnd() + APPEND_SEPARATOR + template;
-          fs16.writeFileSync(fullPath, newContent, "utf-8");
-          results.push({ type, filePath: relativePath, action: "appended" });
-        } else {
-          const dir = path16.dirname(fullPath);
-          if (!fs16.existsSync(dir)) {
-            fs16.mkdirSync(dir, { recursive: true });
-          }
-          fs16.writeFileSync(fullPath, template, "utf-8");
-          results.push({ type, filePath: relativePath, action: "created" });
-        }
-        if (type === "antigravity") {
-          handleAntigravityMcpConfig(root, results);
-        } else if (type === "openclaw") {
-          handleOpenclawSecondary(root, results);
-        } else if (type === "codewhale") {
-          handleCodewhaleSecondary(root, results);
-        } else if (type === "aider") {
-          handleAiderSecondary(root, results);
-        } else if (type === "opencode") {
-          handleOpencodeSecondary(root, results);
-        }
+        const result = await handleKumaInit(params);
+        return { content: [{ type: "text", text: result }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error in kuma_init: ${err}` }], isError: true };
       }
-    } catch (err) {
-      results.push({
-        type,
-        filePath: relativePath,
-        action: "error",
-        error: err instanceof Error ? err.message : String(err)
-      });
     }
-  }
-  return results;
-}
-function formatInitResults(results) {
-  const lines = [
-    "\u{1F43B} **Kuma Init - AI Agent Config Generator**",
-    ""
-  ];
-  for (const r of results) {
-    const label = CONFIG_LABELS[r.type];
-    switch (r.action) {
-      case "created":
-        lines.push("  \u2705 " + label);
-        lines.push("     \u2192 Created: " + r.filePath);
-        break;
-      case "appended":
-        lines.push("  \u2795 " + label);
-        lines.push("     \u2192 Appended to: " + r.filePath);
-        break;
-      case "skipped":
-        lines.push("  \u23ED " + label);
-        lines.push("     \u2192 Skipped (already has Kuma): " + r.filePath);
-        break;
-      case "error":
-        lines.push("  \u274C " + label);
-        lines.push("     \u2192 Error: " + (r.error ?? "unknown"));
-        break;
-    }
-  }
-  const created = results.filter((r) => r.action === "created").length;
-  const appended = results.filter((r) => r.action === "appended").length;
-  const skipped = results.filter((r) => r.action === "skipped").length;
-  const errors = results.filter((r) => r.action === "error").length;
-  lines.push(
-    "",
-    "\u{1F4CA} Summary: " + created + " created, " + appended + " appended, " + skipped + " skipped, " + errors + " errors",
-    "",
-    "\u{1F4A1} Config files teach your AI how to use Kuma tools.",
-    "\u{1F4A1} Run again to generate additional config files anytime."
   );
-  return lines.join("\n");
+  console.error("[Manifest] Registered 18 tools.");
 }
 
 // src/index.ts
@@ -6110,6 +5734,8 @@ Usage:
   npx @plumpslabs/kuma              Start MCP server (default)
   npx @plumpslabs/kuma init         Generate AI agent config files
   npx @plumpslabs/kuma init --all   Generate ALL config files
+  npx @plumpslabs/kuma init --merge Append to existing files (default)
+  npx @plumpslabs/kuma init --skip-existing Skip generation if file exists
   npx @plumpslabs/kuma init --claude --cursor  Generate specific files
   npx @plumpslabs/kuma init --help  Show this help
 
@@ -6178,20 +5804,63 @@ async function main() {
           }
         }
         if (selectedTypes.length === 0) {
-          console.error("\u26A0\uFE0F No valid flags provided. Use --help to see options.");
+          console.error(
+            "\u26A0\uFE0F No valid flags provided. Use --help to see options."
+          );
           process.exit(1);
         }
       }
     }
-    const results = runInit(selectedTypes, process.cwd());
+    const skipExisting = requestedFlags.includes("--skip-existing");
+    const results = runInit({
+      types: selectedTypes,
+      projectRoot: process.cwd(),
+      skipExisting
+    });
     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(
+      process.cwd(),
+      ".agents/skills/matcha/SKILL.md"
+    );
+    const matchaCursor = path16.resolve(
+      process.cwd(),
+      ".cursor/rules/matcha.mdc"
+    );
+    const matchaWindsurf = path16.resolve(
+      process.cwd(),
+      ".windsurf/rules/matcha.md"
+    );
+    if (fs16.existsSync(matchaSkills) || fs16.existsSync(matchaAgents) || fs16.existsSync(matchaCursor) || fs16.existsSync(matchaWindsurf)) {
+      console.error(
+        "\n\u{1F375} Hey, I see matcha is installed \u2014 they pair well together!"
+      );
+    }
     process.exit(0);
   }
   sessionMemory.init({
     projectRoot: process.cwd(),
     startTime: Date.now()
   });
+  (async () => {
+    try {
+      const { generateInitMdContent } = await import("./init-ZRT7JP5F.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");
+        console.error(`[${SERVER_NAME}] Auto-generated .kuma/init.md`);
+      }
+    } catch (err) {
+      console.error(`[${SERVER_NAME}] Failed to auto-generate .kuma/init.md: ${err}`);
+    }
+  })();
   const server = new McpServer(
     {
       name: SERVER_NAME,
@@ -6211,6 +5880,12 @@ async function main() {
   console.error(
     `[${SERVER_NAME}] Session started: ${(/* @__PURE__ */ new Date()).toISOString()}`
   );
+  console.error(
+    `[${SERVER_NAME}] Kuma Core v3 \u2014 .kuma/init.md is the single source of truth`
+  );
+  console.error(
+    `[${SERVER_NAME}] \u{1F9E0} Call kuma_init() at session start to load project context`
+  );
   await server.connect(transport);
   console.error(
     `[${SERVER_NAME}] Server connected via stdio. Waiting for requests...`
@@ -6219,18 +5894,42 @@ async function main() {
 function interactiveSelect() {
   const labels = [
     { type: "claude", label: "1) Claude Code (CLAUDE.md)" },
-    { type: "cursor", label: "2) Cursor (.cursor/rules/kuma.mdc)" },
+    {
+      type: "cursor",
+      label: "2) Cursor (.cursor/rules/kuma.mdc)"
+    },
     { type: "windsurf", label: "3) Windsurf (.windsurfrules)" },
-    { type: "copilot", label: "4) GitHub Copilot Editor (AGENTS.md + Skill)" },
+    {
+      type: "copilot",
+      label: "4) GitHub Copilot Editor (AGENTS.md + Skill)"
+    },
     { type: "cline", label: "5) Cline (.clinerules/kuma.md)" },
-    { type: "aider", label: "6) Aider (CONVENTIONS.md via .aider.conf.yml)" },
-    { type: "antigravity", label: "7) Antigravity CLI (.agents/skills/)" },
+    {
+      type: "aider",
+      label: "6) Aider (CONVENTIONS.md via .aider.conf.yml)"
+    },
+    {
+      type: "antigravity",
+      label: "7) Antigravity CLI (.agents/skills/)"
+    },
     { type: "opencode", label: "8) OpenCode (opencode.json)" },
-    { type: "codex", label: "9) Codex CLI - OpenAI (AGENTS.md + .codex/config.toml)" },
-    { type: "qwen", label: "10) Qwen Code (AGENTS.md + settings.json)" },
+    {
+      type: "codex",
+      label: "9) Codex CLI - OpenAI (AGENTS.md + .codex/config.toml)"
+    },
+    {
+      type: "qwen",
+      label: "10) Qwen Code (AGENTS.md + settings.json)"
+    },
     { type: "kiro", label: "11) Kiro (.kiro/steering/kuma.md)" },
-    { type: "openclaw", label: "12) OpenClaw (skills/kuma/SKILL.md)" },
-    { type: "codewhale", label: "13) CodeWhale (skills/kuma/SKILL.md + .codewhale/mcp.json)" }
+    {
+      type: "openclaw",
+      label: "12) OpenClaw (skills/kuma/SKILL.md)"
+    },
+    {
+      type: "codewhale",
+      label: "13) CodeWhale (skills/kuma/SKILL.md + .codewhale/mcp.json)"
+    }
   ];
   const rl = readline.createInterface({
     input: process.stdin,
@@ -6242,38 +5941,41 @@ function interactiveSelect() {
       console.error(l.label);
     }
     console.error("");
-    rl.question("Enter numbers separated by space (e.g. '1 3 5'), or 'all': ", (answer) => {
-      rl.close();
-      const input = answer.trim().toLowerCase();
-      if (input === "all") {
-        resolve(ALL_CONFIG_TYPES);
-        return;
-      }
-      const nums = input.split(/\s+/).map(Number).filter((n) => n >= 1 && n <= 13);
-      const typeMap = {
-        1: "claude",
-        2: "cursor",
-        3: "windsurf",
-        4: "copilot",
-        5: "cline",
-        6: "aider",
-        7: "antigravity",
-        8: "opencode",
-        9: "codex",
-        10: "qwen",
-        11: "kiro",
-        12: "openclaw",
-        13: "codewhale"
-      };
-      const selected = [];
-      for (const n of nums) {
-        const t = typeMap[n];
-        if (t && !selected.includes(t)) {
-          selected.push(t);
+    rl.question(
+      "Enter numbers separated by space (e.g. '1 3 5'), or 'all': ",
+      (answer) => {
+        rl.close();
+        const input = answer.trim().toLowerCase();
+        if (input === "all") {
+          resolve(ALL_CONFIG_TYPES);
+          return;
         }
+        const nums = input.split(/\s+/).map(Number).filter((n) => n >= 1 && n <= 13);
+        const typeMap = {
+          1: "claude",
+          2: "cursor",
+          3: "windsurf",
+          4: "copilot",
+          5: "cline",
+          6: "aider",
+          7: "antigravity",
+          8: "opencode",
+          9: "codex",
+          10: "qwen",
+          11: "kiro",
+          12: "openclaw",
+          13: "codewhale"
+        };
+        const selected = [];
+        for (const n of nums) {
+          const t = typeMap[n];
+          if (t && !selected.includes(t)) {
+            selected.push(t);
+          }
+        }
+        resolve(selected);
       }
-      resolve(selected);
-    });
+    );
   });
 }
 main().catch((err) => {