@plumpslabs/kuma 2.0.5

package/dist/index.js

@@ -0,0 +1,4678 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFileSync } from "fs";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/manifest.ts
+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.`
+          )
+        };
+      }
+    }
+    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;
+}
+
+// src/utils/tokenCounter.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 3);
+}
+function truncateToTokenLimit(text, maxTokens) {
+  const estimatedTokens = estimateTokens(text);
+  if (estimatedTokens <= maxTokens) return text;
+  const maxChars = maxTokens * 3;
+  const truncated = text.slice(0, maxChars);
+  return truncated + `
+
+[...truncated: estimated ${estimatedTokens} tokens > limit of ${maxTokens} tokens]`;
+}
+function limitLines(text, maxLines) {
+  const lines = text.split("\n");
+  if (lines.length <= maxLines) return text;
+  const truncated = lines.slice(0, maxLines).join("\n");
+  return truncated + `
+
+[...${lines.length - maxLines} more lines truncated]`;
+}
+
+// src/engine/sessionMemory.ts
+import fs2 from "fs";
+import path2 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)) {
+      try {
+        fs2.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)) {
+      try {
+        fs2.renameSync(oldSessionFile, sessionFile);
+        console.error("[SessionMemory] Migrated session.json \u2192 memory.json");
+      } catch {
+      }
+    }
+    if (fs2.existsSync(sessionFile)) {
+      try {
+        const raw = fs2.readFileSync(sessionFile, "utf-8");
+        const parsed = JSON.parse(raw);
+        this.state = {
+          projectRoot: parsed.projectRoot || config.projectRoot,
+          startTime: parsed.startTime || config.startTime,
+          currentGoal: parsed.currentGoal || "",
+          completedSteps: parsed.completedSteps || [],
+          modifiedFiles: new Map(parsed.modifiedFiles || []),
+          failedFiles: new Map(parsed.failedFiles || []),
+          searchResults: new Map(parsed.searchResults || []),
+          dependencyGraph: new Map(parsed.dependencyGraph || []),
+          toolCalls: parsed.toolCalls || [],
+          conventions: parsed.conventions
+        };
+        this.initialized = true;
+        console.error(`[SessionMemory] Loaded persistent session memory.json`);
+        return;
+      } catch (err) {
+        console.error(`[SessionMemory] Failed to load persistent session: ${err}. Re-initializing.`);
+      }
+    }
+    this.state = {
+      projectRoot: config.projectRoot,
+      startTime: config.startTime,
+      currentGoal: "",
+      completedSteps: [],
+      modifiedFiles: /* @__PURE__ */ new Map(),
+      failedFiles: /* @__PURE__ */ new Map(),
+      searchResults: /* @__PURE__ */ new Map(),
+      dependencyGraph: /* @__PURE__ */ new Map(),
+      toolCalls: []
+    };
+    this.initialized = true;
+    this.save();
+    this.ensureMemoriesDir();
+    console.error(`[SessionMemory] Initialized at ${new Date(config.startTime).toISOString()}`);
+  }
+  memoriesDir() {
+    return path2.join(this.state.projectRoot, ".kuma", "memories");
+  }
+  ensureMemoriesDir() {
+    const dir = this.memoriesDir();
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+  }
+  memoryFilePath(topic) {
+    return path2.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");
+    }
+    return this.generateMemory(topic);
+  }
+  writeMemory(topic, content) {
+    this.ensureInit();
+    this.ensureMemoriesDir();
+    this.writeMemoryFile(topic, content);
+  }
+  writeMemoryFile(topic, content) {
+    const filePath = this.memoryFilePath(topic);
+    fs2.writeFileSync(filePath, content, "utf-8");
+  }
+  generateMemory(topic) {
+    switch (topic) {
+      case "architecture":
+        return this.generateArchitectureMd();
+      case "conventions":
+        return this.generateConventionsMd();
+      case "known-issues":
+        return this.generateKnownIssuesMd();
+      default:
+        return `# ${topic}
+
+(empty)`;
+    }
+  }
+  generateArchitectureMd() {
+    const conv = this.state.conventions;
+    if (!conv) return `# Architecture
+
+Run project_conventions first to auto-generate.`;
+    const stackKeys = ["framework", "projectType", "monorepo", "buildTool", "packageManager"];
+    const lines = [
+      "# Architecture",
+      "",
+      `Generated at ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      "",
+      "## Stack",
+      ""
+    ];
+    for (const key of stackKeys) {
+      if (conv[key] !== void 0) {
+        lines.push(`- **${key}**: ${JSON.stringify(conv[key])}`);
+      }
+    }
+    lines.push("", "## Project Layout", "");
+    if (conv.workspaces) {
+      lines.push(`- Monorepo workspaces: ${JSON.stringify(conv.workspaces)}`);
+    }
+    lines.push(`- Source root: ${conv.srcDir || "src/"}`);
+    return lines.join("\n");
+  }
+  generateConventionsMd() {
+    const conv = this.state.conventions;
+    if (!conv) return `# Conventions
+
+Run project_conventions first to auto-generate.`;
+    const styleKeys = ["testRunner", "styling", "importAlias", "lintConfig", "codeStyle"];
+    const lines = [
+      "# Conventions",
+      "",
+      `Generated at ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      "",
+      "## Code Style",
+      ""
+    ];
+    for (const key of styleKeys) {
+      if (conv[key] !== void 0) {
+        lines.push(`- **${key}**: ${JSON.stringify(conv[key])}`);
+      }
+    }
+    if (conv.testRunner) {
+      lines.push("", `## Testing
+
+- Test runner: ${conv.testRunner}`);
+    }
+    if (conv.importAlias) {
+      lines.push("", `## Imports
+
+- Alias: \`${conv.importAlias}\``);
+    }
+    return lines.join("\n");
+  }
+  generateKnownIssuesMd() {
+    const allFailures = this.getFailedFiles();
+    const unresolved = allFailures.filter((f) => f.failures.some((ff) => !ff.resolved));
+    if (unresolved.length === 0) return `# Known Issues
+
+No unresolved issues.`;
+    const lines = [
+      "# Known Issues",
+      "",
+      `Generated at ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      ""
+    ];
+    for (const f of unresolved) {
+      lines.push(`## ${f.task}`);
+      for (const ff of f.failures) {
+        if (!ff.resolved) {
+          lines.push(`- ${new Date(ff.timestamp).toISOString()}: ${ff.error}`);
+        }
+      }
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  save() {
+    if (!this.initialized || !this.state) return;
+    try {
+      const kumaDir = path2.join(this.state.projectRoot, ".kuma");
+      if (!fs2.existsSync(kumaDir)) {
+        fs2.mkdirSync(kumaDir, { recursive: true });
+      }
+      const serialized = {
+        projectRoot: this.state.projectRoot,
+        startTime: this.state.startTime,
+        currentGoal: this.state.currentGoal,
+        completedSteps: this.state.completedSteps,
+        modifiedFiles: Array.from(this.state.modifiedFiles.entries()),
+        failedFiles: Array.from(this.state.failedFiles.entries()),
+        searchResults: Array.from(this.state.searchResults.entries()),
+        dependencyGraph: Array.from(this.state.dependencyGraph.entries()),
+        toolCalls: this.state.toolCalls,
+        conventions: this.state.conventions
+      };
+      fs2.writeFileSync(path2.join(kumaDir, "memory.json"), JSON.stringify(serialized, null, 2), "utf-8");
+    } catch (err) {
+      console.error(`[SessionMemory] Failed to save session: ${err}`);
+    }
+  }
+  setGoal(goal) {
+    this.ensureInit();
+    this.state.currentGoal = goal;
+    this.save();
+  }
+  addCompletedStep(step) {
+    this.ensureInit();
+    if (!this.state.completedSteps.includes(step)) {
+      this.state.completedSteps.push(step);
+      this.save();
+    }
+  }
+  addModifiedFile(filePath) {
+    this.ensureInit();
+    const existing = this.state.modifiedFiles.get(filePath);
+    if (existing) {
+      existing.modifiedAt = Date.now();
+      existing.status = "modified";
+    } else {
+      this.state.modifiedFiles.set(filePath, {
+        filePath,
+        modifiedAt: Date.now(),
+        status: "modified"
+      });
+    }
+    this.save();
+  }
+  addCreatedFile(filePath) {
+    this.ensureInit();
+    this.state.modifiedFiles.set(filePath, {
+      filePath,
+      modifiedAt: Date.now(),
+      status: "created"
+    });
+    this.save();
+  }
+  addFailedFile(task, error) {
+    this.ensureInit();
+    const trimmedError = error?.trim() ?? "";
+    if (!trimmedError) return;
+    const truncatedError = trimmedError.substring(0, 500);
+    const failures = this.state.failedFiles.get(task) ?? [];
+    const lastUnresolved = [...failures].reverse().find((f) => !f.resolved);
+    if (lastUnresolved && lastUnresolved.error === truncatedError) return;
+    failures.push({
+      task,
+      error: truncatedError,
+      timestamp: Date.now(),
+      resolved: false
+    });
+    this.state.failedFiles.set(task, failures);
+    this.save();
+    this.ensureMemoriesDir();
+    this.writeMemoryFile("known-issues", this.generateKnownIssuesMd());
+  }
+  markFailureResolved(task) {
+    this.ensureInit();
+    const failures = this.state.failedFiles.get(task);
+    if (failures) {
+      let changed = false;
+      for (const f of failures) {
+        if (!f.resolved) {
+          f.resolved = true;
+          changed = true;
+        }
+      }
+      if (changed) {
+        this.save();
+        this.ensureMemoriesDir();
+        this.writeMemoryFile("known-issues", this.generateKnownIssuesMd());
+      }
+    }
+  }
+  addSearchResult(query, files) {
+    this.ensureInit();
+    this.state.searchResults.set(query, files);
+    this.save();
+  }
+  addDependency(file, dependsOn) {
+    this.ensureInit();
+    const deps = this.state.dependencyGraph.get(file) ?? [];
+    if (!deps.includes(dependsOn)) {
+      deps.push(dependsOn);
+      this.state.dependencyGraph.set(file, deps);
+      this.save();
+    }
+  }
+  recordToolCall(toolName, params) {
+    this.ensureInit();
+    this.state.toolCalls.push({
+      toolName,
+      params,
+      timestamp: Date.now()
+    });
+    if (this.state.toolCalls.length > 100) {
+      this.state.toolCalls = this.state.toolCalls.slice(-100);
+    }
+    this.save();
+  }
+  setConventions(conventions) {
+    this.ensureInit();
+    this.state.conventions = conventions;
+    this.save();
+    this.ensureMemoriesDir();
+    this.writeMemoryFile("architecture", this.generateArchitectureMd());
+    this.writeMemoryFile("conventions", this.generateConventionsMd());
+  }
+  // ============================================================
+  // KEYWORD SEARCH — Search session memory content
+  // ============================================================
+  /**
+   * Search through tool call history, memory files, search results,
+   * errors, and file modifications for a keyword.
+   */
+  searchMemory(query, limit = 20) {
+    this.ensureInit();
+    const results = [];
+    const q = query.toLowerCase();
+    for (const call of this.state.toolCalls) {
+      const paramStr = JSON.stringify(call.params);
+      if (call.toolName.toLowerCase().includes(q) || paramStr.toLowerCase().includes(q)) {
+        results.push({
+          type: `tool:${call.toolName}`,
+          content: `${call.toolName}(${JSON.stringify(call.params).substring(0, 200)})`,
+          timestamp: call.timestamp
+        });
+      }
+    }
+    for (const [queryStr, files] of this.state.searchResults) {
+      if (queryStr.toLowerCase().includes(q) || files.some((f) => f.toLowerCase().includes(q))) {
+        results.push({
+          type: "search",
+          content: `Query: "${queryStr}" \u2192 ${files.slice(0, 5).join(", ")}${files.length > 5 ? ` (+${files.length - 5} more)` : ""}`
+        });
+      }
+    }
+    for (const [, mod] of this.state.modifiedFiles) {
+      if (mod.filePath.toLowerCase().includes(q)) {
+        results.push({
+          type: `file:${mod.status}`,
+          content: `${mod.status.toUpperCase()}: ${mod.filePath}`,
+          timestamp: mod.modifiedAt
+        });
+      }
+    }
+    for (const [task, failures] of this.state.failedFiles) {
+      for (const f of failures) {
+        if (task.toLowerCase().includes(q) || f.error.toLowerCase().includes(q)) {
+          results.push({
+            type: `failure:${task}`,
+            content: `[${f.resolved ? "RESOLVED" : "UNRESOLVED"}] ${task}: ${f.error.substring(0, 200)}`,
+            timestamp: f.timestamp
+          });
+        }
+      }
+    }
+    for (const [file, deps] of this.state.dependencyGraph) {
+      if (file.toLowerCase().includes(q)) {
+        results.push({
+          type: "dependency",
+          content: `${file} depends on: ${deps.join(", ")}`
+        });
+      }
+    }
+    const memoriesDir = this.memoriesDir();
+    if (fs2.existsSync(memoriesDir)) {
+      try {
+        const files = fs2.readdirSync(memoriesDir);
+        for (const file of files) {
+          if (!file.endsWith(".md")) continue;
+          const filePath = path2.join(memoriesDir, file);
+          try {
+            const content = fs2.readFileSync(filePath, "utf-8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+              if (lines[i].toLowerCase().includes(q)) {
+                const topicName = file.replace(/\.md$/, "");
+                results.push({
+                  type: `memory:${topicName}`,
+                  content: `[${topicName}] L${i + 1}: ${lines[i].trim().substring(0, 150)}`
+                });
+                if (results.filter((r) => r.type.startsWith("memory")).length >= 5) break;
+              }
+            }
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    results.sort((a, b) => {
+      if (a.timestamp && b.timestamp) return b.timestamp - a.timestamp;
+      if (a.timestamp) return -1;
+      if (b.timestamp) return 1;
+      return 0;
+    });
+    return results.slice(0, limit);
+  }
+  pruneMemory() {
+    this.ensureInit();
+    this.state.toolCalls = this.state.toolCalls.slice(-3);
+    this.state.searchResults.clear();
+    this.state.completedSteps = [];
+    this.save();
+  }
+  getSummary(topic) {
+    this.ensureInit();
+    if (topic) {
+      const content = this.getMemoryContent(topic);
+      return { topic, content };
+    }
+    const unresolvedFailures = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const [, failures] of this.state.failedFiles) {
+      for (const f of failures) {
+        if (f.resolved) continue;
+        const error = f.error.substring(0, 200);
+        if (!error.trim()) continue;
+        const key = `${f.task}::${error}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        unresolvedFailures.push({ task: f.task, error });
+      }
+    }
+    const hasMemories = fs2.existsSync(this.memoriesDir());
+    let availableMemories = [];
+    if (hasMemories) {
+      try {
+        availableMemories = fs2.readdirSync(this.memoriesDir()).filter((f) => f.endsWith(".md")).map((f) => f.replace(/\.md$/, ""));
+      } catch {
+      }
+    }
+    return {
+      projectRoot: this.state.projectRoot,
+      sessionDuration: Math.round((Date.now() - this.state.startTime) / 1e3) + "s",
+      currentGoal: this.state.currentGoal,
+      completedSteps: this.state.completedSteps,
+      modifiedFiles: Array.from(this.state.modifiedFiles.values()),
+      unresolvedFailures,
+      toolCallCount: this.state.toolCalls.length,
+      recentSearches: Array.from(this.state.searchResults.keys()).slice(-5),
+      hasConventions: !!this.state.conventions,
+      ...availableMemories.length > 0 ? { availableMemories } : {},
+      ...availableMemories.length > 0 ? { hint: `Use get_session_memory({ topic: "<name>" }) to load a specific memory. Topics: ${availableMemories.join(", ")}` } : {}
+    };
+  }
+  getModifiedFiles() {
+    this.ensureInit();
+    return Array.from(this.state.modifiedFiles.values());
+  }
+  getFailedFiles() {
+    this.ensureInit();
+    const result = [];
+    for (const [task, failures] of this.state.failedFiles) {
+      result.push({ task, failures });
+    }
+    return result;
+  }
+  getToolCallHistory(limit = 10) {
+    this.ensureInit();
+    return this.state.toolCalls.slice(-limit);
+  }
+  detectLoop() {
+    this.ensureInit();
+    const recentCalls = this.state.toolCalls.slice(-10);
+    if (recentCalls.length < 6) return { isLooping: false };
+    const toolCounts = /* @__PURE__ */ new Map();
+    for (const call of recentCalls) {
+      toolCounts.set(call.toolName, (toolCounts.get(call.toolName) ?? 0) + 1);
+    }
+    for (const [toolName, count] of toolCounts) {
+      if (count >= 4) {
+        return {
+          isLooping: true,
+          toolName,
+          message: `Detected potential loop: "${toolName}" called ${count} times in last ${recentCalls.length} tool calls. Consider a different approach.`
+        };
+      }
+    }
+    return { isLooping: false };
+  }
+  ensureInit() {
+    if (!this.initialized) {
+      this.init({
+        projectRoot: process.cwd(),
+        startTime: Date.now()
+      });
+    }
+  }
+};
+var sessionMemory = new SessionMemory();
+function getSessionMemory(topic) {
+  return sessionMemory.getSummary(topic);
+}
+function searchSessionMemory(params) {
+  const { query, limit = 20 } = params;
+  sessionMemory.recordToolCall("search_session_memory", { query, limit });
+  const results = sessionMemory.searchMemory(query, limit);
+  if (results.length === 0) {
+    return `\u{1F50D} **Search Memory** \u2014 No results for "${query}".`;
+  }
+  const lines = [
+    `\u{1F50D} **Search Memory** \u2014 ${results.length} results for "${query}"`,
+    ""
+  ];
+  for (const r of results) {
+    const icon = r.type.startsWith("tool:") ? "\u{1F6E0}\uFE0F" : r.type.startsWith("file:") ? r.type.includes("created") ? "\u2728" : "\u{1F4DD}" : r.type.startsWith("failure") ? "\u274C" : r.type.startsWith("memory") ? "\u{1F9E0}" : r.type === "search" ? "\u{1F50E}" : r.type === "dependency" ? "\u{1F517}" : "\u{1F4C4}";
+    const timeStr = r.timestamp ? new Date(r.timestamp).toLocaleTimeString() : "";
+    lines.push(`${icon} ${timeStr ? `[${timeStr}] ` : ""}${r.content}`);
+  }
+  lines.push("", `\u{1F4A1} Use get_session_memory({topic: "..."}) to load a specific memory topic.`);
+  return lines.join("\n");
+}
+function handleWriteMemory(params) {
+  const { topic, content, mode = "append" } = params;
+  const existing = sessionMemory.getMemoryContent(topic);
+  let finalContent = content;
+  if (mode === "prepend") {
+    finalContent = content + "\n\n" + existing;
+  } else if (mode === "append") {
+    finalContent = existing + "\n\n" + content;
+  }
+  sessionMemory.writeMemory(topic, finalContent);
+  sessionMemory.recordToolCall("write_memory", { topic, mode });
+  return `\u2705 Memory "${topic}" updated (mode: ${mode}).`;
+}
+
+// src/tools/smartGrep.ts
+var IGNORE_PATTERNS = [
+  "**/node_modules/**",
+  "**/.next/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.git/**",
+  "**/.cache/**",
+  "**/.agent-backups/**",
+  "**/*.min.js",
+  "**/*.bundle.js",
+  "**/*.map",
+  "**/package-lock.json",
+  "**/yarn.lock",
+  "**/pnpm-lock.yaml",
+  "**/*.svg",
+  "**/*.png",
+  "**/*.jpg",
+  "**/*.jpeg",
+  "**/*.gif",
+  "**/*.ico",
+  "**/*.woff",
+  "**/*.woff2",
+  "**/*.ttf",
+  "**/*.eot",
+  "**/coverage/**",
+  "**/.nyc_output/**"
+];
+var grepCache = /* @__PURE__ */ new Map();
+var CACHE_TTL_MS = 3e4;
+async function handleSmartGrep(params) {
+  const { query, targetFolder, maxResults = 30, extensions } = params;
+  if (!query || query.length < 1) {
+    return "Error: 'query' parameter is required.";
+  }
+  const cacheKey = `${query}:${targetFolder ?? "root"}:${maxResults}:${extensions ? extensions.join(",") : ""}`;
+  const cached = grepCache.get(cacheKey);
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+    sessionMemory.recordToolCall("smart_grep", { query, cached: true });
+    return cached.results;
+  }
+  const projectRoot = getProjectRoot();
+  try {
+    const searchPattern = targetFolder ? path3.join(targetFolder, "**/*").replace(/\\/g, "/") : "**/*";
+    let entries = await fg(searchPattern, {
+      cwd: projectRoot,
+      ignore: IGNORE_PATTERNS,
+      onlyFiles: true,
+      absolute: false,
+      deep: targetFolder ? 3 : 10,
+      // Batasi kedalaman
+      dot: false
+      // Skip dotfiles
+    });
+    if (extensions && extensions.length > 0) {
+      const normalizedExts = extensions.map(
+        (e) => e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`
+      );
+      entries = entries.filter((entry) => {
+        const ext = path3.extname(entry).toLowerCase();
+        return normalizedExts.includes(ext);
+      });
+    }
+    if (entries.length === 0) {
+      const msg = `No files found${targetFolder ? ` in folder "${targetFolder}"` : ""}${extensions ? ` with extensions [${extensions.join(", ")}]` : ""}.`;
+      grepCache.set(cacheKey, { results: msg, timestamp: Date.now() });
+      return msg;
+    }
+    const regex = createRegex(query);
+    const results = [];
+    let filesScanned = 0;
+    for (const entry of entries) {
+      if (results.length >= maxResults) break;
+      filesScanned++;
+      try {
+        const fullPath = path3.join(projectRoot, entry);
+        const stat = fs3.statSync(fullPath);
+        if (stat.size > 5e5) continue;
+        if (isBinaryFile(fullPath)) continue;
+        const content = fs3.readFileSync(fullPath, "utf-8");
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          if (results.length >= maxResults) break;
+          const line = lines[i];
+          if (regex.test(line)) {
+            const contextLines = [];
+            if (i > 0)
+              contextLines.push(`${i}: ${lines[i - 1].substring(0, 200)}`);
+            contextLines.push(`${i + 1}: ${line.substring(0, 200)}`);
+            if (i < lines.length - 1)
+              contextLines.push(`${i + 2}: ${lines[i + 1].substring(0, 200)}`);
+            results.push({
+              file: entry,
+              line: i + 1,
+              content: contextLines.join("\n")
+            });
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+    const formatted = formatResults(results, query, filesScanned);
+    grepCache.set(cacheKey, { results: formatted, timestamp: Date.now() });
+    sessionMemory.recordToolCall("smart_grep", {
+      query,
+      matchCount: results.length,
+      filesScanned
+    });
+    sessionMemory.addSearchResult(
+      query,
+      results.map((r) => r.file)
+    );
+    return formatted;
+  } catch (err) {
+    return `Error searching "${query}": ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+function createRegex(query) {
+  try {
+    if (/[.\\+*?[\](){}^$|]/.test(query)) {
+      return new RegExp(query, "i");
+    }
+  } catch {
+  }
+  return new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
+}
+function formatResults(results, query, filesScanned) {
+  if (results.length === 0) {
+    return `\u{1F50D} No matches for "${query}" (${filesScanned} files scanned).`;
+  }
+  const lines = [
+    `\u{1F50D} Smart Grep: "${query}"`,
+    `\u{1F4C1} ${results.length} matches from ${filesScanned} files scanned`,
+    "",
+    ...results.map((r, i) => {
+      const filePath = r.file;
+      return `[${i + 1}] \u{1F4C4} ${filePath}:${r.line}
+${r.content.split("\n").map((l) => `    ${l}`).join("\n")}`;
+    }),
+    "",
+    `\u{1F4A1} Use smart_file_picker to open a specific file.`
+  ];
+  return limitLines(lines.join("\n"), 150);
+}
+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);
+    for (let i = 0; i < bytesRead; i++) {
+      if (buffer[i] === 0) return true;
+    }
+    return false;
+  } catch {
+    return true;
+  }
+}
+
+// src/tools/smartFilePicker.ts
+import fs4 from "fs";
+import path4 from "path";
+var MAX_FILE_SIZE = 1e6;
+var CHUNK_THRESHOLD = 300;
+async function handleSmartFilePicker(params) {
+  const { filePath, startLine, endLine, chunkStrategy = "smart" } = params;
+  const validation = validateFilePath(filePath);
+  if (!validation.valid) {
+    return "Error: " + validation.error.message;
+  }
+  const resolvedPath = validation.resolvedPath;
+  if (!fs4.existsSync(resolvedPath)) {
+    const projectRoot = getProjectRoot();
+    let suggestion;
+    if (!path4.isAbsolute(filePath)) {
+      const cwdPath = path4.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);
+  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 lines = content.split("\n");
+    const totalLines = lines.length;
+    sessionMemory.recordToolCall("smart_file_picker", { filePath, chunkStrategy, totalLines });
+    if (startLine !== void 0 || endLine !== void 0) {
+      const start = startLine ?? 1;
+      const end = endLine ?? totalLines;
+      const selectedLines = lines.slice(start - 1, end);
+      return formatOutput(filePath, selectedLines, start, totalLines, false);
+    }
+    if (totalLines <= CHUNK_THRESHOLD || chunkStrategy === "full") {
+      return formatOutput(filePath, lines, 1, totalLines, false);
+    }
+    switch (chunkStrategy) {
+      case "outline":
+        return handleOutlineStrategy(filePath, lines, totalLines);
+      case "smart":
+        return handleSmartStrategy(filePath, lines, totalLines);
+      default:
+        return formatOutput(filePath, lines.slice(0, CHUNK_THRESHOLD), 1, totalLines, true);
+    }
+  } catch (err) {
+    return 'Error reading file "' + filePath + '": ' + (err instanceof Error ? err.message : String(err));
+  }
+}
+function formatOutput(filePath, lines, startLine, totalLines, truncated) {
+  const header = [
+    "File: " + filePath,
+    totalLines + " total lines",
+    truncated ? "Showing " + lines.length + " lines (file >" + CHUNK_THRESHOLD + " lines). Use startLine/endLine for a specific range." : "",
+    ""
+  ].filter(Boolean).join("\n");
+  const body = lines.map((line, i) => {
+    const lineNum = startLine + i;
+    return String(lineNum).padStart(4, " ") + " | " + line;
+  }).join("\n");
+  const full = header + "\n" + body;
+  return truncateToTokenLimit(full, 2e3);
+}
+async function handleOutlineStrategy(filePath, lines, totalLines) {
+  const importLines = [];
+  const exportLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.startsWith("//") || line.startsWith("#") || line.startsWith("/*") || line.startsWith("*")) continue;
+    if (line.startsWith("import ") || line.startsWith("from ") || line.startsWith("require(")) {
+      importLines.push(line);
+      continue;
+    }
+    if (line.startsWith("export ") || line.startsWith("function ") || line.startsWith("const ") || line.startsWith("let ") || line.startsWith("var ") || line.startsWith("class ") || line.startsWith("interface ") || line.startsWith("type ") || line.startsWith("enum ") || line.startsWith("def ") || line.startsWith("async function ") || line.startsWith("async def ")) {
+      exportLines.push({ line: i + 1, text: line.substring(0, 150) });
+    }
+  }
+  const result = [
+    "File: " + filePath,
+    totalLines + " total lines (OUTLINE MODE - signatures and imports only)",
+    "",
+    "Imports:",
+    ...importLines.slice(0, 30).map((l) => "  " + l.substring(0, 150)),
+    importLines.length > 30 ? "  ...and " + (importLines.length - 30) + " more imports" : "",
+    "",
+    "Exports & Declarations:",
+    ...exportLines.map((e) => "  [L" + e.line + "] " + e.text),
+    "",
+    "Pass startLine/endLine to read a specific range.",
+    'Or use chunkStrategy: "full" to read the entire file.'
+  ].filter(Boolean).join("\n");
+  return truncateToTokenLimit(result, 1500);
+}
+async function handleSmartStrategy(filePath, lines, totalLines) {
+  const headerEnd = Math.min(findHeaderEnd(lines), 50);
+  const tailStart = Math.max(totalLines - 30, headerEnd);
+  const smartLines = [];
+  for (let i = 0; i < headerEnd; i++) {
+    smartLines.push({ line: i + 1, text: lines[i] });
+  }
+  if (headerEnd < tailStart) {
+    smartLines.push({ line: -1, text: "" });
+    smartLines.push({ line: -1, text: "  ... " + (tailStart - headerEnd) + " lines hidden ..." });
+    smartLines.push({ line: -1, text: "" });
+  }
+  const keyDeclarations = extractKeyDeclarations(lines.slice(headerEnd, tailStart));
+  for (const decl of keyDeclarations) {
+    smartLines.push({ line: decl.line + 1 + headerEnd, text: decl.text });
+  }
+  if (keyDeclarations.length > 0 && headerEnd < tailStart) {
+    smartLines.push({ line: -1, text: "" });
+  }
+  for (let i = tailStart; i < totalLines; i++) {
+    smartLines.push({ line: i + 1, text: lines[i] });
+  }
+  const header = [
+    "File: " + filePath,
+    totalLines + " total lines (SMART MODE - header + signatures + tail)",
+    "Pass startLine/endLine to read a specific range.",
+    'Or use chunkStrategy: "full" to read the entire file.',
+    ""
+  ].join("\n");
+  const body = smartLines.map((s) => {
+    if (s.line === -1) return s.text;
+    return String(s.line).padStart(4, " ") + " | " + s.text;
+  }).join("\n");
+  const full = header + "\n" + body;
+  return truncateToTokenLimit(full, 3e3);
+}
+function findHeaderEnd(lines) {
+  let lastImportLine = 0;
+  for (let i = 0; i < Math.min(lines.length, 80); i++) {
+    const line = lines[i].trim();
+    if (line.startsWith("import ") || line.startsWith("from ") || line.startsWith("require(") || line.startsWith("//") || line.startsWith("#") || line.startsWith("/*") || line.startsWith("*") || line === "") {
+      if (!line.startsWith("//") && !line.startsWith("#") && !line.startsWith("/*") && !line.startsWith("*") && line !== "") {
+        lastImportLine = i;
+      }
+    } else {
+      if (lastImportLine > 0) break;
+    }
+  }
+  return Math.max(lastImportLine + 1, 10);
+}
+function extractKeyDeclarations(lines) {
+  const decls = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line || line.startsWith("//") || line.startsWith("#")) continue;
+    if (/^(export\s+)?(async\s+)?(function|class|interface|type|enum|const|let|var|def)\s/.test(line)) {
+      decls.push({ line: i, text: line.substring(0, 150) });
+    }
+  }
+  return decls;
+}
+
+// src/tools/preciseDiffEditor.ts
+import fs5 from "fs";
+import path5 from "path";
+
+// src/utils/errorHandler.ts
+var CircuitBreakerStore = class {
+  store = /* @__PURE__ */ new Map();
+  MAX_ATTEMPTS = 3;
+  RESET_TIMEOUT_MS = 6e4;
+  // Reset after 1 min
+  check(toolName, params) {
+    const key = this.makeKey(toolName, params);
+    const state = this.store.get(key);
+    if (!state) {
+      this.store.set(key, {
+        toolName,
+        attemptCount: 1,
+        lastAttempt: /* @__PURE__ */ new Date(),
+        lastParams: JSON.stringify(params),
+        isOpen: false
+      });
+      return { allowed: true };
+    }
+    if (state.isOpen) {
+      if (state.lastAttempt && Date.now() - state.lastAttempt.getTime() > this.RESET_TIMEOUT_MS) {
+        this.store.delete(key);
+        return { allowed: true };
+      }
+      return { allowed: false, reason: `Circuit breaker open for ${toolName} after ${state.attemptCount} attempts. Reset in ${Math.ceil((this.RESET_TIMEOUT_MS - (Date.now() - state.lastAttempt.getTime())) / 1e3)}s` };
+    }
+    state.attemptCount++;
+    state.lastAttempt = /* @__PURE__ */ new Date();
+    if (state.attemptCount >= this.MAX_ATTEMPTS) {
+      state.isOpen = true;
+      return { allowed: false, reason: `Circuit breaker TRIPPED for ${toolName} after ${state.attemptCount} identical attempts. Trying same approach again won't work.` };
+    }
+    return { allowed: true };
+  }
+  reset(toolName) {
+    for (const [key, state] of this.store.entries()) {
+      if (state.toolName === toolName) {
+        this.store.delete(key);
+      }
+    }
+  }
+  makeKey(toolName, params) {
+    const simplified = { ...params };
+    delete simplified.timestamp;
+    return `${toolName}:${JSON.stringify(simplified)}`;
+  }
+  getAttemptCount(toolName, params) {
+    const key = this.makeKey(toolName, params);
+    return this.store.get(key)?.attemptCount ?? 0;
+  }
+};
+var circuitBreaker = new CircuitBreakerStore();
+
+// src/tools/preciseDiffEditor.ts
+async function handlePreciseDiffEditor(params) {
+  const { filePath, edits, dryRun = false, action } = params;
+  if (action === "rollback") {
+    return handleRollbackEdit({ filePath, version: params.version });
+  }
+  if (!edits || edits.length === 0) {
+    return "Error: 'edits' required for edit mode, or use action: 'rollback' for rollback.";
+  }
+  const validation = validateFilePath(filePath);
+  if (!validation.valid) {
+    return `Error: ${validation.error.message}`;
+  }
+  const resolvedPath = validation.resolvedPath;
+  const cbResult = circuitBreaker.check("precise_diff_editor", { filePath });
+  if (!cbResult.allowed) {
+    return `\u26A0\uFE0F ${cbResult.reason}
+
+Try reading the file first with smart_file_picker to verify current content.`;
+  }
+  if (!fs5.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");
+    let currentContent = originalContent;
+    const results = [];
+    for (let i = 0; i < edits.length; i++) {
+      const edit = edits[i];
+      const result = applyEdit(currentContent, edit, resolvedPath, i, dryRun);
+      if (result.success) {
+        if (!dryRun) {
+          fs5.writeFileSync(resolvedPath, result.details, "utf-8");
+          sessionMemory.recordToolCall("precise_diff_editor", {
+            filePath,
+            editIndex: i,
+            success: true,
+            matched: result.matched
+          });
+          sessionMemory.addModifiedFile(filePath);
+        }
+        currentContent = result.details;
+      }
+      results.push(result);
+    }
+    if (dryRun) {
+      return formatDryRunResult(results, filePath, originalContent);
+    }
+    return formatDiffResult(results, filePath);
+  } catch (err) {
+    return `Error editing file "${filePath}": ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+function applyEdit(content, edit, filePath, editIndex, dryRun = false) {
+  const { searchBlock, replaceBlock, allowMultiple = false, fuzzyThreshold = 0.85 } = edit;
+  const exactCount = countOccurrences(content, searchBlock);
+  if (exactCount > 0) {
+    const backupPath = dryRun ? void 0 : createBackup(filePath);
+    const newContent = allowMultiple ? replaceAll(content, searchBlock, replaceBlock) : content.replace(searchBlock, replaceBlock);
+    return {
+      success: true,
+      matched: exactCount,
+      replaced: allowMultiple ? exactCount : 1,
+      backupPath,
+      details: newContent
+    };
+  }
+  const normSearchLines = normalizeLines(searchBlock);
+  const normContentLines = normalizeLines(content);
+  const matchIndex = normContentLines.findIndex(
+    (_, i) => i + normSearchLines.length <= normContentLines.length && normContentLines.slice(i, i + normSearchLines.length).every((line, j) => line === normSearchLines[j])
+  );
+  if (matchIndex >= 0) {
+    const backupPath = dryRun ? void 0 : createBackup(filePath);
+    const origLines = content.split("\n");
+    const replaceLines = replaceBlock.split("\n");
+    const newLines = [
+      ...origLines.slice(0, matchIndex),
+      ...replaceLines,
+      ...origLines.slice(matchIndex + normSearchLines.length)
+    ];
+    const newContent = newLines.join("\n");
+    return {
+      success: true,
+      matched: 1,
+      replaced: 1,
+      backupPath,
+      details: newContent
+    };
+  }
+  const fuzzyResult = findFuzzyMatch(content, searchBlock, fuzzyThreshold);
+  if (fuzzyResult) {
+    const backupPath = dryRun ? void 0 : createBackup(filePath);
+    const newContent = content.replace(fuzzyResult.match, replaceBlock);
+    return {
+      success: true,
+      matched: 1,
+      replaced: 1,
+      backupPath,
+      details: newContent
+    };
+  }
+  const nearestLine = findNearestLine(content, searchBlock);
+  return {
+    success: false,
+    matched: 0,
+    replaced: 0,
+    error: `DIFF_MISMATCH: searchBlock not found in file "${filePath}" (edit #${editIndex + 1}).`,
+    details: nearestLine ? `Nearest line with similar content found at line ${nearestLine.line}:
+\`\`\`
+${nearestLine.content}
+\`\`\`
+Check whether:
+1. Spacing/indentation matches (try 1:1 matching)
+2. searchBlock content is exactly the same as what's in the file
+3. File was not modified by a previous edit
+
+\u{1F4A1} Read the file first with smart_file_picker to verify current content.` : "No similar lines found. The file may have completely different content than expected."
+  };
+}
+function countOccurrences(content, search) {
+  if (search === "") return 0;
+  let count = 0;
+  let pos = 0;
+  while (true) {
+    pos = content.indexOf(search, pos);
+    if (pos === -1) break;
+    count++;
+    pos += search.length;
+  }
+  return count;
+}
+function replaceAll(content, search, replace) {
+  return content.split(search).join(replace);
+}
+function normalizeLines(text) {
+  return text.split("\n").map((line) => line.trim().replace(/[ \t]+/g, " "));
+}
+function findFuzzyMatch(content, search, threshold) {
+  const searchLines = search.split("\n").filter((l) => l.trim());
+  const contentLines = content.split("\n");
+  if (searchLines.length === 0) return null;
+  const normalizedSearch = normalizeLines(search).join("\n");
+  let bestMatch = null;
+  let bestSimilarity = 0;
+  for (let i = 0; i <= contentLines.length - searchLines.length; i++) {
+    const candidate = contentLines.slice(i, i + searchLines.length).join("\n");
+    const normalizedCandidate = normalizeLines(candidate).join("\n");
+    const similarity = calculateSimilarity(normalizedSearch, normalizedCandidate);
+    if (similarity > bestSimilarity) {
+      bestSimilarity = similarity;
+      bestMatch = candidate;
+    }
+  }
+  if (bestMatch && bestSimilarity >= threshold) {
+    return { match: bestMatch, similarity: bestSimilarity };
+  }
+  return null;
+}
+function calculateSimilarity(a, b) {
+  const longer = a.length > b.length ? a : b;
+  const shorter = a.length > b.length ? b : a;
+  if (longer.length === 0) return 1;
+  const distance = levenshteinDistance(longer, shorter);
+  return 1 - distance / longer.length;
+}
+function levenshteinDistance(a, b) {
+  const matrix = [];
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          // substitution
+          matrix[i][j - 1] + 1,
+          // insertion
+          matrix[i - 1][j] + 1
+          // deletion
+        );
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+function findNearestLine(content, search) {
+  const lines = content.split("\n");
+  const searchTrimmed = search.trim();
+  const searchWords = new Set(searchTrimmed.split(/\s+/).filter((w) => w.length > 3));
+  if (searchWords.size < 2) return null;
+  let bestLine = -1;
+  let bestScore = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const lineWords = new Set(lines[i].split(/\s+/).filter((w) => w.length > 3));
+    let matchCount = 0;
+    for (const word of searchWords) {
+      if (lineWords.has(word)) matchCount++;
+    }
+    const score = matchCount / searchWords.size;
+    if (score > bestScore) {
+      bestScore = score;
+      bestLine = i;
+    }
+  }
+  if (bestLine >= 0 && bestScore > 0.3) {
+    return {
+      line: bestLine + 1,
+      content: lines[bestLine].substring(0, 300)
+    };
+  }
+  return null;
+}
+function createBackup(filePath) {
+  ensureBackupDir();
+  const backupPath = getBackupPath(filePath);
+  const backupDir = path5.dirname(backupPath);
+  fs5.mkdirSync(backupDir, { recursive: true });
+  fs5.copyFileSync(filePath, backupPath);
+  return backupPath;
+}
+function formatDryRunResult(results, filePath, originalContent) {
+  const lines = [
+    `\u{1F50D} **DRY RUN** \u2014 ${filePath}`,
+    `\u26A0\uFE0F File not modified (dryRun=true). Preview of changes from ${results.length} edits:`,
+    ""
+  ];
+  let prevContent = originalContent;
+  for (let i = 0; i < results.length; i++) {
+    const r = results[i];
+    if (r.success) {
+      lines.push(`**Edit #${i + 1}:** \u2705 Matched: ${r.matched}x`);
+      const prevLines = prevContent.split("\n");
+      const newLines = r.details.split("\n");
+      let diffStart = 0;
+      while (diffStart < prevLines.length && diffStart < newLines.length && prevLines[diffStart] === newLines[diffStart]) {
+        diffStart++;
+      }
+      let pEnd = prevLines.length - 1;
+      let nEnd = newLines.length - 1;
+      while (pEnd > diffStart && nEnd > diffStart && prevLines[pEnd] === newLines[nEnd]) {
+        pEnd--;
+        nEnd--;
+      }
+      lines.push("```diff");
+      if (diffStart > pEnd && diffStart > nEnd) {
+        lines.push("  (no visible change)");
+      } else {
+        const contextStart = Math.max(0, diffStart - 1);
+        const contextEnd = Math.min(newLines.length, nEnd + 2);
+        if (diffStart <= pEnd) {
+          for (let j = contextStart; j <= pEnd; j++) {
+            if (j < diffStart) {
+              lines.push(`  ${prevLines[j]}`);
+            } else {
+              lines.push(`- ${prevLines[j]}`);
+            }
+          }
+        }
+        if (diffStart <= nEnd) {
+          for (let j = diffStart; j < contextEnd && j < newLines.length; j++) {
+            if (j <= nEnd) {
+              lines.push(`+ ${newLines[j]}`);
+            } else {
+              lines.push(`  ${newLines[j]}`);
+            }
+          }
+        }
+      }
+      lines.push("```");
+      lines.push("");
+      prevContent = r.details;
+    } else {
+      lines.push(`**Edit #${i + 1}:** \u274C ${r.error}`, "");
+    }
+  }
+  const finalLines = prevContent.split("\n");
+  const origLineCount = originalContent.split("\n").length;
+  const diff = finalLines.length - origLineCount;
+  const sign = diff >= 0 ? "+" : "";
+  lines.push(`\u{1F4CA} **Net change:** ${sign}${diff} lines (${origLineCount} \u2192 ${finalLines.length})`);
+  lines.push(
+    "",
+    `\u{1F4A1} **Remove dryRun** or set \`dryRun: false\` to write changes to file.`
+  );
+  return lines.join("\n");
+}
+function formatDiffResult(results, filePath) {
+  const successCount = results.filter((r) => r.success).length;
+  const failCount = results.filter((r) => !r.success).length;
+  const history = sessionMemory.getToolCallHistory(50);
+  const callCount = history.filter((c) => c.toolName === "precise_diff_editor").length;
+  const isFirstEdit = callCount <= 1;
+  const lines = [
+    ...isFirstEdit ? ["\u{1F4A1} **The Ladder:** 1. Does this code need to exist? 2. Does stdlib cover it? 3. Is there a one-liner? 4. Only then, write it.\n"] : [],
+    `\u{1F4DD} Diff Editor \u2014 ${filePath}`,
+    `\u2705 ${successCount} edits successful | \u274C ${failCount} edits failed`,
+    ""
+  ];
+  for (let i = 0; i < results.length; i++) {
+    const r = results[i];
+    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);
+        lines.push(`    Backup: ${relativePath}`);
+      }
+    } else {
+      lines.push(`[${i + 1}] \u274C ${r.error}`);
+      if (r.details) {
+        lines.push(`    ${r.details.replace(/\n/g, "\n    ")}`);
+      }
+    }
+  }
+  lines.push(
+    "",
+    `\u{1F4A1} Use smart_file_picker to read the file and verify edit results.`,
+    `\u{1F4A1} Or execute_safe_test({task: "typecheck"}) to check if edits broke anything.`
+  );
+  return lines.join("\n");
+}
+function formatRelativeTime(timestamp) {
+  const diff = Date.now() - timestamp;
+  const minutes = Math.floor(diff / 6e4);
+  if (minutes < 1) return "just now";
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+async function handleRollbackEdit(params) {
+  const { filePath, version } = params;
+  const validation = validateFilePath(filePath);
+  if (!validation.valid) {
+    return `Error: ${validation.error.message}`;
+  }
+  const resolvedPath = validation.resolvedPath;
+  const root = getProjectRoot();
+  const relativePath = path5.relative(root, resolvedPath);
+  const backupRoot = path5.join(root, ".agent-backups");
+  if (!fs5.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);
+    });
+    if (dirs.length === 0) {
+      return `Error: No valid backup found in .agent-backups folder.`;
+    }
+    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)) {
+        backupVersions.push({ dir, backupPath: potentialBackupPath });
+      }
+    }
+    if (backupVersions.length === 0) {
+      return `Error: No backup history found for file "${filePath}".`;
+    }
+    if (version === "list") {
+      const lines = [`\u{1F4CB} Backup Versions for "${filePath}":`];
+      backupVersions.forEach((v, i) => {
+        const ts = Number(v.dir);
+        const date = new Date(ts).toISOString();
+        const relative = formatRelativeTime(ts);
+        lines.push(`  [${i + 1}] ${date} (${relative})`);
+      });
+      lines.push("");
+      lines.push(`\u{1F4A1} Use rollback_last_edit({ filePath: "${filePath}", version: <N> }) to restore a specific version.`);
+      return lines.join("\n");
+    }
+    let selectedIndex = 0;
+    if (typeof version === "number") {
+      if (version < 1 || version > backupVersions.length) {
+        return `Error: Version ${version} is invalid. ${backupVersions.length} backups available (1-${backupVersions.length}).`;
+      }
+      selectedIndex = version - 1;
+    }
+    const selected = backupVersions[selectedIndex];
+    fs5.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);
+    return `\u2705 Rollback Successful!
+File "${filePath}" restored from backup: "${relBackupPath}".`;
+  } catch (err) {
+    return `Error performing rollback for "${filePath}": ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+
+// src/tools/batchFileWriter.ts
+import fs6 from "fs";
+import path6 from "path";
+async function handleBatchFileWriter(params) {
+  const { files } = params;
+  if (files.length > 15) {
+    return `Error: Maximum 15 files per batch. You sent ${files.length} files.`;
+  }
+  const results = [];
+  for (const file of files) {
+    if (!file.content || file.content.trim().length === 0) {
+      results.push({ filePath: file.filePath, success: false, error: "File content must not be empty." });
+      continue;
+    }
+    if (!file.instructions || file.instructions.trim().length === 0) {
+      results.push({ filePath: file.filePath, success: false, error: "File creation reason (instructions) is required." });
+      continue;
+    }
+    try {
+      const validation = validateFilePath(file.filePath);
+      if (!validation.valid) {
+        results.push({ filePath: file.filePath, success: false, error: validation.error.message });
+        continue;
+      }
+      const resolvedPath = validation.resolvedPath;
+      if (!validateFileExtension(file.filePath)) {
+        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`
+        });
+        continue;
+      }
+      if (fs6.existsSync(resolvedPath)) {
+        ensureBackupDir();
+        const backupPath = getBackupPath(file.filePath);
+        const backupDir = path6.dirname(backupPath);
+        fs6.mkdirSync(backupDir, { recursive: true });
+        fs6.copyFileSync(resolvedPath, backupPath);
+      }
+      const dir = path6.dirname(resolvedPath);
+      if (!fs6.existsSync(dir)) {
+        fs6.mkdirSync(dir, { recursive: true });
+      }
+      fs6.writeFileSync(resolvedPath, file.content, "utf-8");
+      sessionMemory.recordToolCall("batch_file_writer", {
+        filePath: file.filePath,
+        instructions: file.instructions,
+        size: file.content.length
+      });
+      results.push({ filePath: file.filePath, success: true });
+    } catch (err) {
+      results.push({
+        filePath: file.filePath,
+        success: false,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  const totalRequested = files.length;
+  return formatBatchResult(results, totalRequested);
+}
+function formatBatchResult(results, totalRequested) {
+  const successCount = results.filter((r) => r.success).length;
+  const failCount = results.filter((r) => !r.success).length;
+  const lines = [
+    ...totalRequested && totalRequested > 3 ? [`\u{1F4A1} **The Ladder:** Are all ${totalRequested} files needed? Could any be combined or skipped?
+`] : [],
+    `\u{1F4DD} Batch File Writer`,
+    `\u2705 ${successCount} files created | \u274C ${failCount} files failed`,
+    ""
+  ];
+  for (const r of results) {
+    if (r.success) {
+      lines.push(`\u2705 ${r.filePath} \u2014 created successfully`);
+    } else {
+      lines.push(`\u274C ${r.filePath} \u2014 ${r.error}`);
+    }
+  }
+  if (failCount === 0 && successCount > 0) {
+    lines.push("", "\u2705 All files created successfully.");
+    lines.push('\u{1F4A1} Run execute_safe_test({task: "typecheck"}) to verify.');
+  }
+  return lines.join("\n");
+}
+
+// src/tools/safeTerminalExec.ts
+import { spawn } from "child_process";
+var TASK_COMMANDS = {
+  test: "npm test",
+  build: "npm run build",
+  lint: "npm run lint",
+  typecheck: "npx tsc --noEmit"
+};
+var DANGEROUS_PATTERNS = [
+  "rm -rf",
+  "rm -fr",
+  "del /f",
+  "rd /s",
+  "rmdir /s",
+  "git push",
+  "git commit",
+  "npm publish",
+  "npx publish",
+  "yarn publish",
+  "pnpm publish",
+  "> /dev/sda",
+  "format",
+  "mkfs",
+  "dd if=",
+  ":(){ :|:& };:",
+  // fork bomb
+  "curl ",
+  "wget "
+];
+async function handleSafeTerminalExec(params) {
+  const { task, customCommand, timeout = 60 } = params;
+  if (task === "custom" && !customCommand) {
+    return "Error: Task 'custom' requires the 'customCommand' parameter.";
+  }
+  let command;
+  if (task === "custom") {
+    command = customCommand;
+  } else {
+    command = TASK_COMMANDS[task];
+  }
+  const cbResult = circuitBreaker.check("safe_terminal_exec", { task, command });
+  if (!cbResult.allowed) {
+    return `\u26A0\uFE0F Circuit breaker: ${cbResult.reason}
+
+Fix the code first before running the task again.`;
+  }
+  const dangerousPattern = DANGEROUS_PATTERNS.find((p) => command.toLowerCase().includes(p.toLowerCase()));
+  if (dangerousPattern) {
+    return `\u{1F6AB} BLOCKED: Command contains a dangerous pattern: "${dangerousPattern}".
+This command is not permitted.`;
+  }
+  const projectRoot = getProjectRoot();
+  try {
+    sessionMemory.recordToolCall("execute_safe_test", { task, command });
+    const result = await executeWithTimeout(command, projectRoot, timeout);
+    const output = formatExecResult(result, command, task);
+    if (result.exitCode !== 0) {
+      sessionMemory.addFailedFile(task, result.stderr || result.stdout);
+    }
+    return output;
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    const isTimeout = errorMsg.toLowerCase().includes("timeout");
+    if (isTimeout) {
+      return formatTimeoutResult(command, timeout);
+    }
+    return `Error running "${command}": ${errorMsg}`;
+  }
+}
+async function executeWithTimeout(command, cwd, timeoutSeconds) {
+  return new Promise((resolve, reject) => {
+    const parts = command.split(" ");
+    const cmd = parts[0];
+    const args = parts.slice(1);
+    const proc = spawn(cmd, args, {
+      cwd,
+      shell: process.platform === "win32",
+      // Use shell on Windows
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: timeoutSeconds * 1e3
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    const timeoutId = setTimeout(() => {
+      timedOut = true;
+      proc.kill("SIGTERM");
+      if (process.platform === "win32") {
+        try {
+          spawn("taskkill", ["/pid", String(proc.pid), "/f", "/t"], { stdio: "ignore" });
+        } catch {
+        }
+      }
+    }, timeoutSeconds * 1e3);
+    proc.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      clearTimeout(timeoutId);
+      resolve({
+        stdout: truncateOutput(stdout, 5e3),
+        stderr: truncateOutput(stderr, 2e3),
+        exitCode: code ?? -1,
+        timedOut
+      });
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timeoutId);
+      reject(err);
+    });
+  });
+}
+function truncateOutput(output, maxChars) {
+  if (output.length <= maxChars) return output;
+  return output.slice(0, maxChars) + `
+
+[...truncated, ${output.length - maxChars} more characters]`;
+}
+function formatExecResult(result, command, task) {
+  const status = result.exitCode === 0 ? "\u2705 PASS" : "\u274C FAIL";
+  const lines = [
+    `\u{1F4BB} ${status} \u2014 Task: ${task}`,
+    `$ ${command}`,
+    `Exit code: ${result.exitCode}`,
+    `Duration: ${result.timedOut ? "TIMEOUT" : "completed"}`,
+    ""
+  ];
+  if (result.stdout.trim()) {
+    lines.push("\u{1F4E4} STDOUT:", "```", result.stdout, "```", "");
+  }
+  if (result.stderr.trim()) {
+    lines.push("\u{1F4E4} STDERR:", "```", result.stderr, "```", "");
+  }
+  if (result.exitCode !== 0) {
+    lines.push(
+      "\u{1F4A1} Recovery steps:",
+      "  1. Read the error above \u2014 which file is failing?",
+      "  2. Use smart_file_picker to open the failing file",
+      "  3. Fix it with precise_diff_editor",
+      "  4. Re-run the task to verify"
+    );
+  } else {
+    lines.push("\u2705 All checks passed.");
+  }
+  return lines.join("\n");
+}
+function formatTimeoutResult(command, timeout) {
+  return [
+    `\u23F0 TIMEOUT \u2014 "${command}" exceeded the ${timeout}s limit.`,
+    "",
+    "Possible causes:",
+    "  1. Infinite loop in code",
+    "  2. Test suite too slow (needs optimization)",
+    "  3. Background process blocking",
+    "",
+    "Suggestions:",
+    "  - Inspect the code for infinite loops",
+    "  - Increase the timeout (max 180s)",
+    "  - Run the command manually for diagnostics"
+  ].join("\n");
+}
+
+// src/agents/codeReviewer.ts
+import fs7 from "fs";
+import path7 from "path";
+import { execSync } from "child_process";
+var CODE_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".go",
+  ".rs",
+  ".php",
+  ".cs",
+  ".java"
+];
+function getGitChangedFiles() {
+  try {
+    const root = getProjectRoot();
+    const stdout = execSync("git status --porcelain", {
+      cwd: root,
+      encoding: "utf-8"
+    });
+    const files = [];
+    for (const line of stdout.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const parts = trimmed.split(/\s+/);
+      let filePath = parts.slice(1).join(" ");
+      if (filePath.startsWith('"') && filePath.endsWith('"')) {
+        filePath = filePath.substring(1, filePath.length - 1);
+      }
+      const ext = path7.extname(filePath).toLowerCase();
+      if (CODE_EXTENSIONS.includes(ext)) files.push(filePath);
+    }
+    return files.slice(0, 10);
+  } catch (err) {
+    console.error(`[CodeReviewer] Failed to list git-changed files: ${err}`);
+    return [];
+  }
+}
+async function handleCodeReviewer(params) {
+  const { files: inputFiles, focus = "correctness", customCriteria, format = "text" } = params;
+  let files = inputFiles ?? [];
+  let isAutoDetected = false;
+  if (files.length === 0) {
+    files = getGitChangedFiles();
+    isAutoDetected = true;
+    if (files.length === 0) {
+      return `\u2139\uFE0F No code files (TS/JS/Python/Go/Rust/PHP/C#/Java) detected as changed in git status.
+Pass an explicit 'files' array to review specific files.`;
+    }
+  }
+  const allIssues = [];
+  let filesReviewed = 0;
+  for (const filePath of files) {
+    const validation = validateFilePath(filePath);
+    if (!validation.valid) {
+      allIssues.push({
+        file: filePath,
+        line: 0,
+        severity: "error",
+        rule: "path/invalid",
+        message: `Invalid path: ${validation.error.message}`,
+        suggestion: "Fix the file path"
+      });
+      continue;
+    }
+    const resolvedPath = validation.resolvedPath;
+    if (!fs7.existsSync(resolvedPath)) {
+      allIssues.push({
+        file: filePath,
+        line: 0,
+        severity: "error",
+        rule: "path/not-found",
+        message: "File not found",
+        suggestion: "Verify the file path"
+      });
+      continue;
+    }
+    try {
+      const content = fs7.readFileSync(resolvedPath, "utf-8");
+      filesReviewed++;
+      checkGeneral(filePath, content, allIssues);
+      switch (focus) {
+        case "correctness":
+          checkCorrectness(filePath, content, allIssues);
+          break;
+        case "conventions":
+          checkConventions(filePath, content, allIssues);
+          break;
+        case "security":
+          checkSecurity(filePath, content, allIssues);
+          break;
+        case "performance":
+          checkPerformance(filePath, content, allIssues);
+          break;
+        case "over-engineering":
+          checkOverEngineering(filePath, content, allIssues);
+          break;
+      }
+    } catch (err) {
+      allIssues.push({
+        file: filePath,
+        line: 0,
+        severity: "error",
+        rule: "io/read-failed",
+        message: `Error reading file: ${err}`,
+        suggestion: ""
+      });
+    }
+  }
+  sessionMemory.recordToolCall("code_reviewer", {
+    filesReviewed,
+    focus,
+    issuesFound: allIssues.length,
+    errors: allIssues.filter((i) => i.severity === "error").length,
+    autoDetected: isAutoDetected
+  });
+  if (format === "json") {
+    const jsonSummary = {
+      totalIssues: allIssues.length,
+      errors: allIssues.filter((i) => i.severity === "error").length,
+      warnings: allIssues.filter((i) => i.severity === "warning").length,
+      info: allIssues.filter((i) => i.severity === "info").length,
+      filesReviewed,
+      filesRequested: files.length,
+      focus,
+      autoDetected: isAutoDetected,
+      ...customCriteria ? { customCriteria } : {}
+    };
+    const issuesByFile = {};
+    for (const issue of allIssues) {
+      if (!issuesByFile[issue.file]) issuesByFile[issue.file] = [];
+      issuesByFile[issue.file].push(issue);
+    }
+    return JSON.stringify({ summary: jsonSummary, issuesByFile, issues: allIssues }, null, 2);
+  }
+  return formatReviewOutput(allIssues, filesReviewed, files.length, focus, customCriteria, isAutoDetected);
+}
+function stripCommentsAndStrings(line) {
+  let result = "";
+  let i = 0;
+  let inString = null;
+  while (i < line.length) {
+    const ch = line[i];
+    const next = line[i + 1];
+    if (inString) {
+      if (ch === "\\" && i + 1 < line.length) {
+        i += 2;
+        continue;
+      }
+      if (ch === inString) {
+        inString = null;
+        i++;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (ch === "/" && next === "/") break;
+    if (ch === '"' || ch === "'" || ch === "`") {
+      inString = ch;
+      i++;
+      continue;
+    }
+    result += ch;
+    i++;
+  }
+  return result;
+}
+function isTestFile(filePath) {
+  return /\.(test|spec)\.[a-z]+$/i.test(filePath) || /__tests__/.test(filePath);
+}
+function isTsLike(filePath) {
+  const ext = path7.extname(filePath).toLowerCase();
+  return ext === ".ts" || ext === ".tsx";
+}
+function checkGeneral(filePath, content, issues) {
+  const lines = content.split("\n");
+  if (content.length > 0 && !content.endsWith("\n")) {
+    issues.push({
+      file: filePath,
+      line: lines.length,
+      severity: "info",
+      rule: "style/final-newline",
+      message: "File does not end with a newline",
+      suggestion: "Add a trailing newline"
+    });
+  }
+  if (lines.length > 500) {
+    issues.push({
+      file: filePath,
+      line: 1,
+      severity: "info",
+      rule: "complexity/file-too-long",
+      message: `File is ${lines.length} lines \u2014 consider splitting`,
+      suggestion: "Extract cohesive sections into separate modules"
+    });
+  }
+}
+function checkCorrectness(filePath, content, issues) {
+  const lines = content.split("\n");
+  const isTest = isTestFile(filePath);
+  const isTs = isTsLike(filePath);
+  let braceDepth = 0;
+  let maxDepth = 0;
+  let maxDepthLine = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const rawLine = lines[i];
+    const line = stripCommentsAndStrings(rawLine);
+    const lineNum = i + 1;
+    for (const ch of line) {
+      if (ch === "{") braceDepth++;
+      else if (ch === "}") braceDepth = Math.max(0, braceDepth - 1);
+      if (braceDepth > maxDepth) {
+        maxDepth = braceDepth;
+        maxDepthLine = lineNum;
+      }
+    }
+    if (!isTest && /\bconsole\.(log|debug|info)\s*\(/.test(line)) {
+      issues.push({
+        file: filePath,
+        line: lineNum,
+        severity: "warning",
+        rule: "correctness/console-log",
+        message: "Leftover console.log",
+        suggestion: "Remove or replace with a structured logger"
+      });
+    }
+    if (/\b(TODO|FIXME|HACK|XXX)\b/.test(rawLine)) {
+      issues.push({
+        file: filePath,
+        line: lineNum,
+        severity: "info",
+        rule: "correctness/todo",
+        message: "Unresolved TODO/FIXME/HACK marker",
+        suggestion: "Resolve or file a tracked issue and link it"
+      });
+    }
+    if (isTs) {
+      if (/:\s*any\b/.test(line) && !/eslint-disable/.test(rawLine)) {
+        issues.push({
+          file: filePath,
+          line: lineNum,
+          severity: "warning",
+          rule: "ts/no-any",
+          message: "'any' type annotation",
+          suggestion: "Replace with a specific type or 'unknown'"
+        });
+      }
+      if (/\bas\s+any\b/.test(line)) {
+        issues.push({
+          file: filePath,
+          line: lineNum,
+          severity: "error",
+          rule: "ts/no-as-any",
+          message: "'as any' cast bypasses the type system",
+          suggestion: "Narrow with a type guard or cast to 'unknown' then validate"
+        });
+      }
+      if (/\)\s*as\s+\w[^;]*\bas\s+\w/.test(line)) {
+        issues.push({
+          file: filePath,
+          line: lineNum,
+          severity: "warning",
+          rule: "ts/double-cast",
+          message: "Chained 'as' casts indicate a type-modeling problem",
+          suggestion: "Fix the upstream type or use a type guard"
+        });
+      }
+      if (/[a-zA-Z_$\]\)]\s*!\s*\./.test(line) && !/!==|!=/.test(line)) {
+        issues.push({
+          file: filePath,
+          line: lineNum,
+          severity: "warning",
+          rule: "ts/non-null-assertion",
+          message: "Non-null assertion (!) suppresses null checks",
+          suggestion: "Use optional chaining or an explicit guard"
+        });
+      }
+      if (/@ts-ignore\b/.test(rawLine)) {
+        issues.push({
+          file: filePath,
+          line: lineNum,
+          severity: "warning",
+          rule: "ts/ts-ignore",
+          message: "@ts-ignore silently suppresses type errors",
+          suggestion: "Use @ts-expect-error with a reason, or fix the underlying type"
+        });
+      }
+      if (/:\s*Function\b/.test(line)) {
+        issues.push({
+          file: filePath,
+          line: lineNum,
+          severity: "warning",
+          rule: "ts/no-unsafe-function",
+          message: "'Function' type is unsafe (loses signature)",
+          suggestion: "Use a specific signature like (x: T) => U"
+        });
+      }
+    }
+    if (/catch\s*\([^)]*\)\s*{\s*}/.test(line)) {
+      issues.push({
+        file: filePath,
+        line: lineNum,
+        severity: "error",
+        rule: "correctness/empty-catch",
+        message: "Empty catch swallows the error",
+        suggestion: "Log the error or rethrow \u2014 silent catch hides bugs"
+      });
+    }
+    if (/(password|secret|api[_-]?key|token|bearer)\s*[:=]\s*['"][^'"]{6,}['"]/i.test(line) && !/process\.env|import\.meta\.env|getenv|os\.environ/.test(line)) {
+      issues.push({
+        file: filePath,
+        line: lineNum,
+        severity: "error",
+        rule: "security/hardcoded-secret",
+        message: "Possible hardcoded secret",
+        suggestion: "Read from an environment variable instead"
+      });
+    }
+    const asyncFnMatch = line.match(/\basync\s+(function\b|\([^)]*\)\s*=>|[a-zA-Z_$][\w$]*\s*\()/);
+    if (asyncFnMatch) {
+      const body = lines.slice(i, Math.min(i + 40, lines.length)).join("\n");
+      if (!/\bawait\b/.test(body) && !/return\s+\w+\s*\(/.test(body)) {
+        issues.push({
+          file: filePath,
+          line: lineNum,
+          severity: "info",
+          rule: "correctness/async-without-await",
+          message: "async function without await",
+          suggestion: "Drop 'async' or add the awaited call"
+        });
+      }
+    }
+    if (isTs || /\.(js|jsx|mjs|cjs)$/i.test(filePath)) {
+      if (/[^=!<>]==[^=]/.test(line) || /!=[^=]/.test(line)) {
+        issues.push({
+          file: filePath,
+          line: lineNum,
+          severity: "warning",
+          rule: "correctness/loose-equality",
+          message: "Loose equality (==/!=) \u2014 prefer strict equality",
+          suggestion: "Use === / !=="
+        });
+      }
+    }
+    if (isTs && /^\s*[a-zA-Z_$][\w$]*\([^)]*\)\.[a-zA-Z]/.test(line) === false) {
+    }
+  }
+  if (maxDepth >= 5) {
+    issues.push({
+      file: filePath,
+      line: maxDepthLine,
+      severity: "warning",
+      rule: "complexity/deep-nesting",
+      message: `Code nests ${maxDepth} levels deep`,
+      suggestion: "Extract helper functions or use early returns"
+    });
+  }
+}
+function checkConventions(filePath, content, issues) {
+  const lines = content.split("\n");
+  let hasTabs = false;
+  let hasSpaces = false;
+  for (let i = 0; i < Math.min(lines.length, 50); i++) {
+    if (lines[i].startsWith("	")) hasTabs = true;
+    if (/^ {2,}/.test(lines[i])) hasSpaces = true;
+  }
+  if (hasTabs && hasSpaces) {
+    issues.push({
+      file: filePath,
+      line: 1,
+      severity: "warning",
+      rule: "style/mixed-indent",
+      message: "Mixed indentation (tabs and spaces)",
+      suggestion: "Pick one (typically 2 spaces for JS/TS)"
+    });
+  }
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].length > 200) {
+      issues.push({
+        file: filePath,
+        line: i + 1,
+        severity: "info",
+        rule: "style/line-length",
+        message: `Line is ${lines[i].length} chars`,
+        suggestion: "Wrap lines over ~120 chars"
+      });
+      break;
+    }
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const line = stripCommentsAndStrings(lines[i]);
+    const classMatch = line.match(/\bclass\s+([a-zA-Z_$][\w$]*)/);
+    if (classMatch && !/^[A-Z]/.test(classMatch[1])) {
+      issues.push({
+        file: filePath,
+        line: i + 1,
+        severity: "warning",
+        rule: "naming/class-pascalcase",
+        message: `Class "${classMatch[1]}" should be PascalCase`,
+        suggestion: `Rename to "${classMatch[1].charAt(0).toUpperCase() + classMatch[1].slice(1)}"`
+      });
+    }
+    const funcMatch = line.match(/\bfunction\s+([A-Z][a-zA-Z0-9_$]*)\s*\(/);
+    if (funcMatch && !/React|Component/.test(line)) {
+      issues.push({
+        file: filePath,
+        line: i + 1,
+        severity: "info",
+        rule: "naming/function-camelcase",
+        message: `Function "${funcMatch[1]}" starts with uppercase (component?)`,
+        suggestion: "Use camelCase for regular functions"
+      });
+    }
+  }
+}
+function checkSecurity(filePath, content, issues) {
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const rawLine = lines[i];
+    const line = stripCommentsAndStrings(rawLine);
+    const lineNum = i + 1;
+    if (/\beval\s*\(/.test(line)) {
+      issues.push({
+        file: filePath,
+        line: lineNum,
+        severity: "error",
+        rule: "security/no-eval",
+        message: "eval() is a security risk",
+        suggestion: "Use JSON.parse or a real parser"
+      });
+    }
+    if (/\.innerHTML\s*=/.test(line)) {
+      issues.push({
+        file: filePath,
+        line: lineNum,
+        severity: "warning",
+        rule: "security/innerhtml",
+        message: "innerHTML can lead to XSS",
+        suggestion: "Use textContent or sanitize with DOMPurify"
+      });
+    }
+    if (/\.query\s*\(\s*[`'"][^`'"]*(SELECT|INSERT|UPDATE|DELETE)/i.test(line) && /\$\{|\+\s*\w/.test(line)) {
+      issues.push({
+        file: filePath,
+        line: lineNum,
+        severity: "error",
+        rule: "security/sql-injection",
+        message: "SQL query built via string interpolation",
+        suggestion: "Use parameterized queries or an ORM"
+      });
+    }
+    if (/\b(exec|execSync|spawn|spawnSync)\s*\(/.test(line) && /\$\{|\+\s*\w/.test(line) && !/\/\/\s*reviewed/i.test(rawLine)) {
+      issues.push({
+        file: filePath,
+        line: lineNum,
+        severity: "warning",
+        rule: "security/shell-injection",
+        message: "Shell command built from interpolated input",
+        suggestion: "Sanitize input or use array-form spawn with explicit args"
+      });
+    }
+    if (/['"]http:\/\/(?!localhost|127\.|0\.0\.0\.0)/.test(rawLine)) {
+      issues.push({
+        file: filePath,
+        line: lineNum,
+        severity: "info",
+        rule: "security/insecure-http",
+        message: "Insecure http:// URL",
+        suggestion: "Use https:// where possible"
+      });
+    }
+  }
+}
+function checkPerformance(filePath, content, issues) {
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = stripCommentsAndStrings(lines[i]);
+    const lineNum = i + 1;
+    if (/\b(for|while)\s*\(/.test(line) && i > 0 && /\b(for|while)\s*\(/.test(stripCommentsAndStrings(lines[i - 1]))) {
+      issues.push({
+        file: filePath,
+        line: lineNum,
+        severity: "warning",
+        rule: "perf/nested-loops",
+        message: "Nested loops \u2014 potential O(n\xB2)",
+        suggestion: "Use Map/Set lookups or a single-pass algorithm"
+      });
+    }
+    if (/\.(filter|map|reduce|find)\s*\(/.test(line) && i > 0 && /\bfor\s*\(/.test(stripCommentsAndStrings(lines[i - 1]))) {
+      issues.push({
+        file: filePath,
+        line: lineNum,
+        severity: "info",
+        rule: "perf/array-in-loop",
+        message: "Array method inside a loop",
+        suggestion: "Hoist the computation outside the loop if possible"
+      });
+    }
+    if (/\.\.\./.test(line) && /\b(for|while|forEach|map|reduce)\b/.test(line)) {
+      issues.push({
+        file: filePath,
+        line: lineNum,
+        severity: "info",
+        rule: "perf/spread-in-loop",
+        message: "Spread inside a loop is O(n)",
+        suggestion: "Use push() or concat() to grow arrays in loops"
+      });
+    }
+    if (/\b(readFileSync|writeFileSync|existsSync)\s*\(/.test(line) && /\b(for|while|forEach|map)\b/.test(lines[Math.max(0, i - 2)] + lines[Math.max(0, i - 1)] + lines[i])) {
+      issues.push({
+        file: filePath,
+        line: lineNum,
+        severity: "warning",
+        rule: "perf/sync-io-in-loop",
+        message: "Synchronous I/O inside a loop",
+        suggestion: "Use the async variant and await in parallel where safe"
+      });
+    }
+  }
+}
+function checkOverEngineering(filePath, content, issues) {
+  const lines = content.split("\n");
+  const text = content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+  const classBodies = findBlockBodies(lines, /^\s*(export\s+)?(abstract\s+)?class\s+\w+/);
+  for (const { body, nameLine, name } of classBodies) {
+    const methodCount = (body.match(/^\s*(public|private|protected|static|async)?\s*\w+\s*\([^)]*\)\s*{/gm) || []).length;
+    if (methodCount <= 1 && body.length > 0) {
+      const trimmed = body.trim();
+      const nonEmptyLines = trimmed ? trimmed.split("\n").filter((l) => l.trim()).length : 0;
+      if (nonEmptyLines <= 3) {
+        issues.push({
+          file: filePath,
+          line: nameLine,
+          severity: "info",
+          rule: "over-engineering/wrapper-class",
+          message: `Class "${name}" has only 1 method \u2014 likely a wrapper that could be a plain function`,
+          suggestion: "Replace with a standalone function or a utility module export"
+        });
+      }
+    }
+  }
+  const factoryMatches = text.matchAll(/^\s*(export\s+)?function\s+(create\w+|make\w+|build\w+|factory\w+)\s*\(/gm);
+  for (const match of factoryMatches) {
+    const funcName = match[2];
+    const body = extractBodyAfter(lines, match);
+    const creationCount = (body.match(/\bnew\s+\w+/g) || []).length;
+    if (creationCount <= 1) {
+      issues.push({
+        file: filePath,
+        line: lines.findIndex((l) => l.includes(funcName)) + 1,
+        severity: "warning",
+        rule: "over-engineering/single-product-factory",
+        message: `Factory "${funcName}" produces only 1 product \u2014 unnecessary abstraction`,
+        suggestion: "Inline the construction or drop the factory pattern"
+      });
+    }
+  }
+  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: "over-engineering/single-impl-interface",
+        message: `Interface "${iface}" has only 1 implementation \u2014 unnecessary unless more planned`,
+        suggestion: "Remove the interface or inline the type"
+      });
+    }
+  }
+  const configObjPattern = /^\s*(export\s+)?(const|let|var)\s+(\w+)\s*[=:]\s*\{/;
+  for (let i = 0; i < lines.length; i++) {
+    const cm = lines[i].match(configObjPattern);
+    if (!cm || !/config|setting|option|default/i.test(cm[3])) continue;
+    const configName = cm[3];
+    const refs = (text.match(new RegExp(`\\b${configName}\\b`, "g")) || []).length;
+    if (refs <= 2) {
+      issues.push({
+        file: filePath,
+        line: i + 1,
+        severity: "info",
+        rule: "over-engineering/unused-config",
+        message: `Config "${configName}" is referenced ${refs === 0 ? "nowhere" : `only ${refs - 1}x outside definition`}`,
+        suggestion: refs === 0 ? "Remove the dead config" : "Inline the value or remove if unused elsewhere"
+      });
+    }
+  }
+  const stdlibPatterns = [
+    { pattern: /function\s+\w+\s*\([^)]*\)\s*\{[^}]*fs\.readFileSync[^}]*\}/, rule: "over-engineering/hand-rolled-file-read", msg: "Hand-rolled file reader \u2014 use fs.readFileSync directly", suggestion: "Call fs.readFileSync directly instead of wrapping" },
+    { pattern: /function\s+\w+\s*\([^)]*\)\s*\{[^}]*crypto\.createHash[^}]*\}/, rule: "over-engineering/hand-rolled-hash", msg: "Hand-rolled hash \u2014 use crypto directly", suggestion: "Call crypto.createHash directly" },
+    { pattern: /function\s+uuid\s*\(|function\s+generateId\s*\(/, rule: "over-engineering/hand-rolled-uuid", msg: "Hand-rolled UUID \u2014 use crypto.randomUUID()", suggestion: "Replace with crypto.randomUUID() (Node 19+) or the uuid package" },
+    { pattern: /function\s+debounce\s*\(|function\s+throttle\s*\(/, rule: "over-engineering/hand-rolled-debounce", msg: "Hand-rolled debounce/throttle \u2014 utility lib or native", suggestion: "Use lodash.debounce or a 3-line inline version" }
+  ];
+  for (const sp of stdlibPatterns) {
+    const sl = text.match(sp.pattern);
+    if (sl) {
+      const matchIndex = sl.index ?? 0;
+      const preText = text.substring(0, matchIndex);
+      const lineNum = preText.split("\n").length;
+      issues.push({
+        file: filePath,
+        line: lineNum,
+        severity: "info",
+        rule: sp.rule,
+        message: sp.msg,
+        suggestion: sp.suggestion
+      });
+    }
+  }
+  const exportDecls = [];
+  for (let i = 0; i < lines.length; i++) {
+    const ed = lines[i].match(/^\s*export\s+(const|let|var|function|class)\s+(\w+)/);
+    if (ed) exportDecls.push({ name: ed[2], line: i + 1 });
+  }
+  for (const decl of exportDecls) {
+    const refCount = (text.match(new RegExp(`\\b${decl.name}\\b`, "g")) || []).length;
+    const isReactComponent = /^[A-Z]/.test(decl.name) && /return\s+<|React\./.test(text);
+    if (refCount <= 1 && decl.name !== "default" && !isReactComponent) {
+      issues.push({
+        file: filePath,
+        line: decl.line,
+        severity: "info",
+        rule: "over-engineering/unused-export",
+        message: `"${decl.name}" is exported but referenced only in its declaration`,
+        suggestion: "Check if it is imported elsewhere; if not, remove or inline"
+      });
+    }
+  }
+}
+function findBlockBodies(lines, startPattern) {
+  const results = [];
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(startPattern);
+    if (!m) continue;
+    const name = m[0].match(/class\s+(\w+)/)?.[1] ?? "Unknown";
+    const body = collectBlockLines(lines, i);
+    results.push({ body: body.join("\n"), nameLine: i + 1, name });
+  }
+  return results;
+}
+function collectBlockLines(lines, startIdx) {
+  let depth = 0;
+  let started = false;
+  const block = [];
+  for (let j = startIdx; j < lines.length; j++) {
+    const line = lines[j];
+    block.push(line);
+    for (const ch of line) {
+      if (ch === "{") {
+        depth++;
+        started = true;
+      } else if (ch === "}") depth--;
+    }
+    if (started && depth <= 0) break;
+  }
+  return block;
+}
+function extractBodyAfter(lines, match) {
+  const startIdx = lines.findIndex((l) => l.includes(match[0].trim().split(/\s+/).pop() ?? ""));
+  if (startIdx < 0) return "";
+  return collectBlockLines(lines, startIdx).join("\n");
+}
+function formatReviewOutput(issues, filesReviewed, totalFiles, focus, customCriteria, autoDetected) {
+  const errors = issues.filter((i) => i.severity === "error");
+  const warnings = issues.filter((i) => i.severity === "warning");
+  const infos = issues.filter((i) => i.severity === "info");
+  const lines = [
+    `\u{1F50D} **Code Review \u2014 Focus: ${focus}**`,
+    ...focus === "over-engineering" ? ["\u{1F4A1} **The Ladder:** 1. Does this code need to exist? 2. Does stdlib cover it? 3. Is there a one-liner? 4. Only then, write it."] : [],
+    ...autoDetected ? [`\u{1F4C2} Auto-detected ${totalFiles} changed file(s) from git`] : [],
+    ...customCriteria ? [`\u{1F4CB} **Custom Criteria:** ${customCriteria}`] : [],
+    `\u{1F4C1} ${filesReviewed}/${totalFiles} files reviewed`,
+    `\u{1F534} ${errors.length} errors | \u{1F7E1} ${warnings.length} warnings | \u{1F535} ${infos.length} info`,
+    ""
+  ];
+  if (issues.length === 0) {
+    lines.push("\u2705 No issues found.");
+    return lines.join("\n");
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const existing = grouped.get(issue.file) ?? [];
+    existing.push(issue);
+    grouped.set(issue.file, existing);
+  }
+  for (const [file, fileIssues] of grouped) {
+    lines.push(`**\u{1F4C4} ${file}:**`);
+    for (const issue of fileIssues) {
+      const icon = issue.severity === "error" ? "\u{1F534}" : issue.severity === "warning" ? "\u{1F7E1}" : "\u{1F535}";
+      lines.push(`  ${icon} [L${issue.line}] [${issue.rule}] ${issue.message}`);
+      if (issue.suggestion) lines.push(`     \u{1F4A1} ${issue.suggestion}`);
+    }
+    lines.push("");
+  }
+  if (errors.length > 0) {
+    lines.push("\u26A0\uFE0F Fix errors first, then warnings.");
+    lines.push("\u{1F4A1} Use precise_diff_editor to apply fixes.");
+  } else if (warnings.length > 0) {
+    lines.push("\u{1F4A1} Address warnings before merging.");
+  } else {
+    lines.push("\u2705 Only informational issues \u2014 ready for testing.");
+  }
+  return lines.join("\n");
+}
+
+// src/utils/conventionsDetector.ts
+import fs8 from "fs";
+import path8 from "path";
+var cachedConventions = null;
+async function detectConventions(forceRescan = false) {
+  if (cachedConventions && !forceRescan) {
+    return cachedConventions;
+  }
+  const projectRoot = getProjectRoot();
+  const workspaces = detectWorkspaces(projectRoot);
+  const conventions = {
+    framework: detectFramework(projectRoot),
+    projectType: detectProjectType(projectRoot),
+    testRunner: detectTestRunner(projectRoot),
+    styling: detectStyling(projectRoot),
+    importAlias: detectImportAlias(projectRoot),
+    lintRules: detectLintRules(projectRoot),
+    packageManager: detectPackageManager(),
+    moduleSystem: detectModuleSystem(projectRoot),
+    language: detectLanguage(projectRoot),
+    features: detectFeatures(projectRoot),
+    isMonorepo: workspaces.length > 0,
+    workspaces
+  };
+  cachedConventions = conventions;
+  return conventions;
+}
+function detectFramework(root) {
+  const pkg = readJsonSafe(path8.join(root, "package.json"));
+  if (pkg) {
+    const pkgDeps = pkg.dependencies ?? {};
+    const pkgDevDeps = pkg.devDependencies ?? {};
+    const deps = { ...pkgDeps, ...pkgDevDeps };
+    if (deps.next) return "Next.js";
+    if (deps["@remix-run/react"]) return "Remix";
+    if (deps.gatsby) return "Gatsby";
+    if (deps.nuxt || deps["@nuxt/core"]) return "Nuxt.js";
+    if (deps.vue) return "Vue";
+    if (deps.react) return "React";
+    if (deps.svelte) return "Svelte";
+    if (deps.astro) return "Astro";
+    if (deps.solid || deps["solid-js"]) return "SolidJS";
+    if (deps.qwik || deps["@builder.io/qwik"]) return "Qwik";
+    if (deps.vite) return "Vite";
+    if (deps["@nestjs/core"]) return "NestJS";
+    if (deps.fastify) return "Fastify";
+    if (deps.express) return "Express";
+    if (deps.koa) return "Koa";
+    if (deps.hono) return "Hono";
+    if (deps["@hapi/hapi"]) return "Hapi";
+    if (deps["@modelcontextprotocol/sdk"]) return "MCP Server";
+    if (deps["@anthropic-ai/claude-agent-sdk"]) return "Claude Agent SDK";
+    if (deps.commander) return "Commander CLI";
+    if (deps.yargs) return "Yargs CLI";
+    if (deps["@oclif/core"] || deps.oclif) return "Oclif CLI";
+    if (deps.ink) return "Ink (React CLI)";
+    if (pkg.bin) return "CLI Tool";
+    if (pkg.main || pkg.exports) return "Library";
+  }
+  const subFrameworks = scanSubProjectFrameworks(root);
+  if (subFrameworks.length > 0) {
+    const freq = /* @__PURE__ */ new Map();
+    for (const fw of subFrameworks) {
+      freq.set(fw, (freq.get(fw) ?? 0) + 1);
+    }
+    const [topFw] = [...freq.entries()].sort((a, b) => b[1] - a[1])[0] ?? [];
+    if (topFw) return `${topFw} (monorepo)`;
+  }
+  return "unknown";
+}
+function scanSubProjectFrameworks(root) {
+  const frameworks = [];
+  try {
+    const entries = fs8.readdirSync(root, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+      const subDir = path8.join(root, entry.name);
+      const subPkg = readJsonSafe(path8.join(subDir, "package.json"));
+      if (!subPkg) continue;
+      const subDeps = { ...subPkg.dependencies ?? {}, ...subPkg.devDependencies ?? {} };
+      if (subDeps.next) frameworks.push("Next.js");
+      else if (subDeps.react) frameworks.push("React");
+      else if (subDeps.vue) frameworks.push("Vue");
+      else if (subDeps.svelte) frameworks.push("Svelte");
+      else if (subDeps.astro) frameworks.push("Astro");
+      else if (subDeps["@nestjs/core"]) frameworks.push("NestJS");
+      else if (subDeps.express) frameworks.push("Express");
+      else if (subDeps.hono) frameworks.push("Hono");
+      else if (subDeps.vite) frameworks.push("Vite");
+      else if (subDeps["@modelcontextprotocol/sdk"]) frameworks.push("MCP Server");
+    }
+  } catch {
+  }
+  return frameworks;
+}
+function detectProjectType(root) {
+  const pkg = readJsonSafe(path8.join(root, "package.json"));
+  if (pkg) {
+    const pkgDeps = pkg.dependencies ?? {};
+    const pkgDevDeps = pkg.devDependencies ?? {};
+    const deps = { ...pkgDeps, ...pkgDevDeps };
+    if (deps["@modelcontextprotocol/sdk"]) return "mcp-server";
+    if (deps.next || deps.react || deps.vue || deps.svelte || deps.astro || deps.gatsby || deps.nuxt || deps["@remix-run/react"] || deps.solid) {
+      return "web-app";
+    }
+    if (deps.express || deps.fastify || deps.koa || deps.hono || deps["@nestjs/core"] || deps["@hapi/hapi"]) {
+      return "backend";
+    }
+    if (deps.commander || deps.yargs || deps["@oclif/core"] || deps.oclif || deps.ink) {
+      return "cli";
+    }
+    if (pkg.bin) return "cli";
+    if (pkg.main || pkg.exports) return "library";
+  }
+  const subFrameworks = scanSubProjectFrameworks(root);
+  if (subFrameworks.length > 0) return "web-app";
+  return "unknown";
+}
+function detectWorkspaces(root) {
+  const results = [];
+  const pkg = readJsonSafe(path8.join(root, "package.json"));
+  const pnpmWorkspace = readYamlLite(path8.join(root, "pnpm-workspace.yaml"));
+  const patterns = /* @__PURE__ */ new Set();
+  const pkgWorkspaces = pkg?.workspaces;
+  if (Array.isArray(pkgWorkspaces)) {
+    for (const p of pkgWorkspaces) if (typeof p === "string") patterns.add(p);
+  } else if (pkgWorkspaces && typeof pkgWorkspaces === "object") {
+    const packages = pkgWorkspaces.packages;
+    if (Array.isArray(packages)) {
+      for (const p of packages) if (typeof p === "string") patterns.add(p);
+    }
+  }
+  if (Array.isArray(pnpmWorkspace?.packages)) {
+    for (const p of pnpmWorkspace.packages) if (typeof p === "string") patterns.add(p);
+  }
+  patterns.add("apps/*");
+  patterns.add("packages/*");
+  patterns.add("services/*");
+  for (const pattern of patterns) {
+    const match = pattern.match(/^([^*]+)\/\*$/);
+    if (!match) continue;
+    const dir = path8.join(root, match[1]);
+    if (!fs8.existsSync(dir)) continue;
+    let entries = [];
+    try {
+      entries = fs8.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+      const pkgPath = path8.join(dir, entry.name, "package.json");
+      const subPkg = readJsonSafe(pkgPath);
+      if (!subPkg) continue;
+      results.push({
+        path: path8.relative(root, path8.join(dir, entry.name)),
+        name: subPkg.name ?? entry.name,
+        framework: detectFramework(path8.join(dir, entry.name))
+      });
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return results.filter((w) => {
+    if (seen.has(w.path)) return false;
+    seen.add(w.path);
+    return true;
+  });
+}
+function readYamlLite(filePath) {
+  try {
+    if (!fs8.existsSync(filePath)) return null;
+    const text = fs8.readFileSync(filePath, "utf-8");
+    const packages = [];
+    let inPackages = false;
+    for (const rawLine of text.split("\n")) {
+      const line = rawLine.replace(/#.*$/, "").trimEnd();
+      if (/^packages:\s*$/.test(line)) {
+        inPackages = true;
+        continue;
+      }
+      if (inPackages) {
+        const m = line.match(/^\s*-\s*['"]?([^'"]+)['"]?\s*$/);
+        if (m) packages.push(m[1]);
+        else if (/^\S/.test(line)) inPackages = false;
+      }
+    }
+    return { packages };
+  } catch {
+    return null;
+  }
+}
+function detectTestRunner(root) {
+  const pkg = readJsonSafe(path8.join(root, "package.json"));
+  if (!pkg) return "unknown";
+  const pkgDeps2 = pkg.dependencies ?? {};
+  const pkgDevDeps2 = pkg.devDependencies ?? {};
+  const deps = { ...pkgDeps2, ...pkgDevDeps2 };
+  if (deps.vitest) return "Vitest";
+  if (deps.jest) return "Jest";
+  if (deps.mocha) return "Mocha";
+  if (deps.ava) return "AVA";
+  if (deps.cypress) return "Cypress";
+  if (deps.playwright) return "Playwright";
+  if (deps["@testing-library/react"]) return "React Testing Library";
+  const scripts = pkg.scripts ?? {};
+  if (scripts.test) {
+    if (scripts.test.includes("vitest")) return "Vitest";
+    if (scripts.test.includes("jest")) return "Jest";
+    if (scripts.test.includes("mocha")) return "Mocha";
+  }
+  return "unknown";
+}
+function detectStyling(root) {
+  const pkg = readJsonSafe(path8.join(root, "package.json"));
+  if (!pkg) return "unknown";
+  const pkgDeps3 = pkg.dependencies ?? {};
+  const pkgDevDeps3 = pkg.devDependencies ?? {};
+  const deps = { ...pkgDeps3, ...pkgDevDeps3 };
+  if (deps.tailwindcss) return "Tailwind CSS";
+  if (deps["styled-components"]) return "Styled Components";
+  if (deps["@emotion/react"]) return "Emotion";
+  if (deps.linaria) return "Linaria";
+  if (deps.sass || deps["node-sass"]) return "SCSS";
+  if (deps.less) return "Less";
+  if (deps["@vanilla-extract/css"]) return "Vanilla Extract";
+  if (deps.cssmodules || hasCSSModules(root)) return "CSS Modules";
+  const srcDir = path8.join(root, "src");
+  if (fs8.existsSync(srcDir)) {
+    const cssFiles = findFiles(srcDir, [".css", ".scss", ".less"]);
+    if (cssFiles.length > 0) return "Plain CSS/SCSS";
+  }
+  return "unknown";
+}
+function detectImportAlias(root) {
+  const tsconfig = readJsonSafe(path8.join(root, "tsconfig.json"));
+  const tsconfigPaths = tsconfig?.compilerOptions;
+  if (tsconfigPaths?.paths) {
+    const paths = tsconfigPaths.paths;
+    const alias = Object.keys(paths)[0];
+    if (alias) return alias.replace("/*", "");
+  }
+  const jsconfig = readJsonSafe(path8.join(root, "jsconfig.json"));
+  const jsconfigPaths = jsconfig?.compilerOptions;
+  if (jsconfigPaths?.paths) {
+    const paths = jsconfigPaths.paths;
+    const alias = Object.keys(paths)[0];
+    if (alias) return alias.replace("/*", "");
+  }
+  return void 0;
+}
+function detectLintRules(root) {
+  const rules = [];
+  if (fs8.existsSync(path8.join(root, ".eslintrc"))) rules.push("ESLint (.eslintrc)");
+  if (fs8.existsSync(path8.join(root, ".eslintrc.js"))) rules.push("ESLint (.eslintrc.js)");
+  if (fs8.existsSync(path8.join(root, ".eslintrc.json"))) rules.push("ESLint (.eslintrc.json)");
+  if (fs8.existsSync(path8.join(root, "eslint.config.js"))) rules.push("ESLint (flat config)");
+  if (fs8.existsSync(path8.join(root, ".prettierrc"))) rules.push("Prettier");
+  if (fs8.existsSync(path8.join(root, ".prettierrc.json"))) rules.push("Prettier");
+  if (fs8.existsSync(path8.join(root, ".prettierrc.js"))) rules.push("Prettier");
+  if (fs8.existsSync(path8.join(root, ".stylelintrc"))) rules.push("StyleLint");
+  if (fs8.existsSync(path8.join(root, ".stylelintrc.json"))) rules.push("StyleLint");
+  return rules;
+}
+function detectPackageManager() {
+  const root = getProjectRoot();
+  if (fs8.existsSync(path8.join(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs8.existsSync(path8.join(root, "yarn.lock"))) return "yarn";
+  if (fs8.existsSync(path8.join(root, "package-lock.json"))) return "npm";
+  if (fs8.existsSync(path8.join(root, "bun.lockb"))) return "bun";
+  return "npm";
+}
+function detectModuleSystem(root) {
+  const pkg = readJsonSafe(path8.join(root, "package.json"));
+  if (pkg?.type === "module") return "esm";
+  const srcDir = path8.join(root, "src");
+  if (fs8.existsSync(srcDir)) {
+    const tsFiles = findFiles(srcDir, [".ts", ".tsx", ".js", ".jsx", ".mjs"]);
+    for (const file of tsFiles.slice(0, 20)) {
+      try {
+        const content = fs8.readFileSync(file, "utf-8");
+        if (content.includes("import ") || content.includes("export ")) return "esm";
+      } catch {
+        continue;
+      }
+    }
+  }
+  return "cjs";
+}
+function detectLanguage(root) {
+  if (fs8.existsSync(path8.join(root, "tsconfig.json"))) return "typescript";
+  const srcDir = path8.join(root, "src");
+  if (fs8.existsSync(srcDir)) {
+    const tsFiles = findFiles(srcDir, [".ts", ".tsx"]);
+    if (tsFiles.length > 0) return "typescript";
+  }
+  return "javascript";
+}
+function detectFeatures(root) {
+  const features = [];
+  const pkg = readJsonSafe(path8.join(root, "package.json"));
+  if (!pkg) return features;
+  const pkgDeps4 = pkg.dependencies ?? {};
+  const pkgDevDeps4 = pkg.devDependencies ?? {};
+  const deps = { ...pkgDeps4, ...pkgDevDeps4 };
+  if (deps["@prisma/client"] || deps.prisma) features.push("Prisma ORM");
+  if (deps.typeorm) features.push("TypeORM");
+  if (deps["drizzle-orm"]) features.push("Drizzle ORM");
+  if (deps.graphql || deps["@graphql-tools"]) features.push("GraphQL");
+  if (deps.trpc || deps["@trpc/client"]) features.push("tRPC");
+  if (deps["socket.io"] || deps.ws) features.push("WebSockets");
+  if (deps["@reduxjs/toolkit"] || deps.redux) features.push("Redux");
+  if (deps.zustand) features.push("Zustand");
+  if (deps["react-router"] || deps["react-router-dom"]) features.push("React Router");
+  if (deps["next-auth"] || deps["next-auth/react"]) features.push("NextAuth");
+  if (deps["@tanstack/react-query"]) features.push("React Query");
+  if (deps.jest || deps.vitest) features.push("Unit Testing");
+  if (deps.cypress || deps.playwright) features.push("E2E Testing");
+  if (deps.storybook || deps["@storybook/react"]) features.push("Storybook");
+  if (deps.i18next || deps["react-i18next"]) features.push("i18n");
+  return features;
+}
+function readJsonSafe(filePath) {
+  try {
+    if (fs8.existsSync(filePath)) {
+      return JSON.parse(fs8.readFileSync(filePath, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function hasCSSModules(root) {
+  const srcDir = path8.join(root, "src");
+  if (!fs8.existsSync(srcDir)) return false;
+  const files = findFiles(srcDir, [".module.css", ".module.scss", ".module.less"]);
+  return files.length > 0;
+}
+function findFiles(dir, extensions) {
+  const results = [];
+  try {
+    const entries = fs8.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path8.join(dir, entry.name);
+      if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+        results.push(...findFiles(fullPath, extensions));
+      } else if (entry.isFile()) {
+        if (extensions.some((ext) => entry.name.endsWith(ext))) {
+          results.push(fullPath);
+        }
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+
+// src/agents/projectConventions.ts
+async function handleProjectConventions(params) {
+  const { forceRescan = false } = params;
+  try {
+    const conventions = await detectConventions(forceRescan);
+    const conventionsRecord = conventions;
+    sessionMemory.setConventions(conventionsRecord);
+    sessionMemory.recordToolCall("project_conventions", { forceRescan });
+    return formatConventionsOutput(conventionsRecord);
+  } catch (err) {
+    return `Error detecting conventions: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+function formatConventionsOutput(conventions) {
+  const lines = [
+    "\u{1F4CB} **Project Conventions Detected**",
+    "\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501",
+    "",
+    `\u{1F3D7}\uFE0F **Framework:** ${conventions.framework || "unknown"}`,
+    `\u{1F3AF} **Project Type:** ${conventions.projectType || "unknown"}`,
+    `\u{1F9EA} **Test Runner:** ${conventions.testRunner || "unknown"}`,
+    `\u{1F3A8} **Styling:** ${conventions.styling || "unknown"}`,
+    `\u{1F4E6} **Package Manager:** ${conventions.packageManager || "unknown"}`,
+    `\u{1F524} **Module System:** ${conventions.moduleSystem || "unknown"}`,
+    `\u{1F4BB} **Language:** ${conventions.language || "unknown"}`,
+    "",
+    conventions.importAlias ? `\u{1F517} **Import Alias:** \`${conventions.importAlias}\`` : "\u{1F517} **Import Alias:** Not detected (use relative imports)",
+    ""
+  ];
+  if (conventions.isMonorepo && Array.isArray(conventions.workspaces) && conventions.workspaces.length > 0) {
+    lines.push(`\u{1F9E9} **Monorepo:** yes \u2014 ${conventions.workspaces.length} workspace(s)`);
+    for (const ws of conventions.workspaces) {
+      lines.push(`  - \`${ws.path}\` (${ws.name}) \u2014 ${ws.framework}`);
+    }
+    lines.push("");
+  }
+  if (conventions.features && Array.isArray(conventions.features) && conventions.features.length > 0) {
+    lines.push("\u2B50 **Key Features:**");
+    for (const feature of conventions.features) {
+      lines.push(`  - ${feature}`);
+    }
+    lines.push("");
+  }
+  if (conventions.lintRules && Array.isArray(conventions.lintRules) && conventions.lintRules.length > 0) {
+    lines.push("\u{1F4D0} **Lint/Format Tools:**");
+    for (const rule of conventions.lintRules) {
+      lines.push(`  - ${rule}`);
+    }
+    lines.push("");
+  }
+  lines.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\u2501\u2501\u2501\u2501");
+  lines.push("\u{1F4A1} Use these conventions to keep code consistent.");
+  lines.push("\u{1F4A1} Re-run with forceRescan: true after adding new dependencies.");
+  return lines.join("\n");
+}
+
+// src/tools/gitLog.ts
+import child_process from "child_process";
+async function handleGitLog(params) {
+  const { maxCount = 10, filePath } = params;
+  const root = getProjectRoot();
+  try {
+    let command = `git log -n ${maxCount} --oneline`;
+    if (filePath) {
+      command += ` -- "${filePath}"`;
+    }
+    const stdout = child_process.execSync(command, {
+      cwd: root,
+      encoding: "utf-8"
+    });
+    sessionMemory.recordToolCall("git_log", { maxCount, filePath });
+    if (!stdout.trim()) {
+      return `\u2139\uFE0F No commit history found${filePath ? ` for file "${filePath}"` : ""}.`;
+    }
+    return `\u{1F4DC} **Git Commit History**:
+
+${stdout}`;
+  } catch (err) {
+    return `Error: Failed to get git log: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+
+// src/tools/gitDiff.ts
+import child_process2 from "child_process";
+async function handleGitDiff(params) {
+  const { filePath, staged = false, contextLines = 3, baseRef, targetRef } = params;
+  const root = getProjectRoot();
+  try {
+    let command = "git diff";
+    if (staged) {
+      command += " --cached";
+    }
+    command += " -U" + Math.max(1, Math.min(contextLines, 20));
+    if (baseRef) {
+      command += " " + baseRef;
+      if (targetRef) {
+        command += ".." + targetRef;
+      }
+    }
+    if (filePath) {
+      command += ' -- "' + filePath + '"';
+    }
+    const stdout = child_process2.execSync(command, {
+      cwd: root,
+      encoding: "utf-8",
+      maxBuffer: 2 * 1024 * 1024
+    });
+    sessionMemory.recordToolCall("git_diff", { filePath, staged, baseRef, targetRef });
+    if (!stdout.trim()) {
+      if (staged) {
+        return "No staged changes found" + (filePath ? ' for "' + filePath + '".' : ".");
+      }
+      return "No uncommitted changes found" + (filePath ? ' for "' + filePath + '".' : ".");
+    }
+    const lines = stdout.split("\n");
+    const result = [];
+    let currentFile = "";
+    let fileChanges = 0;
+    let totalAdditions = 0;
+    let totalDeletions = 0;
+    result.push("**Git Diff**");
+    if (staged) result.push("Staged changes");
+    if (baseRef) result.push(baseRef + (targetRef ? ".." + targetRef : ""));
+    if (filePath) result.push("File: " + filePath);
+    result.push("");
+    for (const line of lines) {
+      const fileMatch = line.match(/^diff --git a\/(.+) b\/(.+)$/);
+      if (fileMatch) {
+        if (currentFile && fileChanges > 0) {
+          result.push("  " + fileChanges + " chunk(s) modified");
+          result.push("");
+        }
+        currentFile = fileMatch[1];
+        fileChanges = 0;
+        result.push("--- " + currentFile + " ---");
+        continue;
+      }
+      if (line.startsWith("new file mode")) {
+        result.push("  [New file]");
+        continue;
+      }
+      if (line.startsWith("deleted file mode")) {
+        result.push("  [Deleted file]");
+        continue;
+      }
+      if (line.startsWith("rename from") || line.startsWith("rename to")) {
+        continue;
+      }
+      if (line.startsWith("index ")) {
+        continue;
+      }
+      if (line.startsWith("--- ") || line.startsWith("+++ ")) {
+        continue;
+      }
+      const chunkMatch = line.match(/^@@ -(\d+),?\d* \+(\d+),?\d* @@(.*)$/);
+      if (chunkMatch) {
+        fileChanges++;
+        const desc = chunkMatch[3] ? " -- " + chunkMatch[3].trim() : "";
+        result.push("  Chunk " + fileChanges + ": L" + chunkMatch[1] + " -> L" + chunkMatch[2] + desc);
+        continue;
+      }
+      if (line.startsWith("+") && !line.startsWith("+++")) {
+        totalAdditions++;
+        result.push("  + " + line.substring(1).substring(0, 150));
+      } else if (line.startsWith("-") && !line.startsWith("---")) {
+        totalDeletions++;
+        result.push("  - " + line.substring(1).substring(0, 150));
+      }
+    }
+    if (currentFile && fileChanges > 0) {
+      result.push("  " + fileChanges + " chunk(s) modified");
+    }
+    result.push("");
+    result.push("-----------------------------");
+    result.push("Summary: +" + totalAdditions + " / -" + totalDeletions + " lines across " + result.filter((l) => l.startsWith("--- ")).length + " file(s)");
+    result.push("");
+    result.push("Use precise_diff_editor to revert specific changes if needed.");
+    return result.join("\n");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("not a git repository")) {
+      return "Not a git repository. Git diff requires an initialized git repo.\nRun `git init` to get started.";
+    }
+    return "Error: Failed to get git diff: " + msg;
+  }
+}
+
+// src/tools/projectStructure.ts
+import fs9 from "fs";
+import path9 from "path";
+var DEFAULT_IGNORE = [
+  "node_modules",
+  ".git",
+  ".kuma",
+  ".agent-backups",
+  "dist",
+  ".next",
+  "build",
+  "coverage",
+  ".cache",
+  ".turbo",
+  ".nyc_output",
+  "__pycache__",
+  ".DS_Store",
+  "*.log"
+];
+async function handleProjectStructure(params) {
+  const {
+    depth = 3,
+    folderOnly = false,
+    includePattern,
+    excludePattern
+  } = params;
+  const root = getProjectRoot();
+  const clampedDepth = Math.max(1, Math.min(depth, 6));
+  sessionMemory.recordToolCall("project_structure", { depth: clampedDepth, folderOnly });
+  try {
+    const tree = buildTree(root, root, clampedDepth, 0, folderOnly, includePattern, excludePattern);
+    const projectName = path9.basename(root);
+    const lines = [
+      "[Project Structure] - " + projectName,
+      "Depth: " + clampedDepth + " | " + (folderOnly ? "Folders only" : "Files and folders"),
+      "",
+      projectName + "/",
+      ...tree,
+      "",
+      "Increase depth (max 6) for deeper structure.",
+      "Use folderOnly: true for high-level overview."
+    ];
+    return lines.join("\n");
+  } catch (err) {
+    return "Error building project structure: " + (err instanceof Error ? err.message : String(err));
+  }
+}
+function buildTree(root, currentDir, maxDepth, currentDepth, folderOnly, includePattern, excludePattern) {
+  if (currentDepth >= maxDepth) return [];
+  const lines = [];
+  let entries = [];
+  try {
+    entries = fs9.readdirSync(currentDir, { withFileTypes: true });
+  } catch {
+    return lines;
+  }
+  entries.sort((a, b) => {
+    if (a.isDirectory() && !b.isDirectory()) return -1;
+    if (!a.isDirectory() && b.isDirectory()) return 1;
+    return a.name.localeCompare(b.name);
+  });
+  const relativeDir = path9.relative(root, currentDir) || ".";
+  const prefix = getPrefix(currentDepth);
+  for (const entry of entries) {
+    if (shouldIgnore(entry.name, relativeDir, root)) continue;
+    const fullPath = path9.join(currentDir, entry.name);
+    const relativePath = path9.relative(root, fullPath);
+    if (includePattern && !entry.name.includes(includePattern) && !relativePath.includes(includePattern)) {
+      if (!entry.isDirectory()) continue;
+    }
+    if (excludePattern && (entry.name.includes(excludePattern) || relativePath.includes(excludePattern))) {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      lines.push(prefix + "[D] " + entry.name + "/");
+      let subEntries = [];
+      try {
+        subEntries = fs9.readdirSync(fullPath, { withFileTypes: true });
+      } catch {
+      }
+      const hasVisibleContent = subEntries.some(
+        (e) => !shouldIgnore(e.name, path9.relative(root, fullPath), root)
+      );
+      if (hasVisibleContent) {
+        const subLines = buildTree(root, fullPath, maxDepth, currentDepth + 1, folderOnly, includePattern, excludePattern);
+        lines.push(...subLines);
+      } else {
+        if (currentDepth + 1 < maxDepth) {
+          const childPrefix = getPrefix(currentDepth + 1);
+          lines.push(childPrefix + "(empty)");
+        }
+      }
+    } else if (!folderOnly) {
+      const size = getFileSize(fullPath);
+      lines.push(prefix + "[F] " + entry.name + (size ? " (" + size + ")" : ""));
+    }
+  }
+  return lines;
+}
+function shouldIgnore(name, _relativeDir, _root) {
+  if (name.startsWith(".") && name !== ".env" && name !== ".env.example") return true;
+  if (DEFAULT_IGNORE.some((pattern) => {
+    if (pattern.startsWith("*")) return name.endsWith(pattern.slice(1));
+    return name === pattern;
+  })) return true;
+  return false;
+}
+function getPrefix(depth) {
+  return "  ".repeat(depth) + "|- ";
+}
+function getFileSize(fullPath) {
+  try {
+    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);
+    return sizeMB + "MB";
+  } catch {
+    return null;
+  }
+}
+
+// src/tools/staticAnalysis.ts
+import { spawn as spawn2 } from "child_process";
+import fs10 from "fs";
+import path10 from "path";
+async function handleStaticAnalysis(params) {
+  const { tool = "all", files, autoFix = false, timeout = 60 } = params;
+  const root = getProjectRoot();
+  sessionMemory.recordToolCall("static_analysis", { tool, files, autoFix });
+  const availableTools = detectAvailableTools(root);
+  if (availableTools.length === 0) {
+    return formatNoToolsDetected();
+  }
+  const toolsToRun = tool === "all" ? availableTools : availableTools.filter((t) => t === tool);
+  if (toolsToRun.length === 0) {
+    return formatToolNotAvailable(tool, availableTools);
+  }
+  const allIssues = [];
+  const results = [];
+  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 } });
+      continue;
+    }
+    const issues = parseToolOutput(t, output.stdout, output.stderr, root);
+    const result = {
+      tool: t,
+      exitCode: output.exitCode,
+      issues,
+      summary: {
+        errors: issues.filter((i) => i.severity === "error").length,
+        warnings: issues.filter((i) => i.severity === "warning").length,
+        info: issues.filter((i) => i.severity === "info").length
+      }
+    };
+    results.push(result);
+    allIssues.push(...issues);
+    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");
+    }
+  }
+  return formatResults2(results, allIssues, toolsToRun);
+}
+function detectAvailableTools(root) {
+  const tools = [];
+  const pkg = readPackageJson(root);
+  const allDeps = { ...pkg?.dependencies ?? {}, ...pkg?.devDependencies ?? {} };
+  const depNames = new Set(Object.keys(allDeps));
+  const eslintConfigs = [
+    ".eslintrc",
+    ".eslintrc.js",
+    ".eslintrc.json",
+    ".eslintrc.yaml",
+    ".eslintrc.yml",
+    "eslint.config.js",
+    "eslint.config.mjs"
+  ];
+  const hasEslintConfig = eslintConfigs.some((cfg) => fs10.existsSync(path10.join(root, cfg)));
+  if (hasEslintConfig && depNames.has("eslint")) {
+    tools.push("eslint");
+  }
+  if (fs10.existsSync(path10.join(root, "tsconfig.json")) && depNames.has("typescript")) {
+    tools.push("tsc");
+  }
+  const prettierConfigs = [
+    ".prettierrc",
+    ".prettierrc.json",
+    ".prettierrc.js",
+    ".prettierrc.yaml",
+    ".prettierrc.toml",
+    "prettier.config.js"
+  ];
+  const hasPrettierConfig = prettierConfigs.some((cfg) => fs10.existsSync(path10.join(root, cfg)));
+  if (hasPrettierConfig && depNames.has("prettier")) {
+    tools.push("prettier");
+  }
+  if (fs10.existsSync(path10.join(root, "ruff.toml")) || fs10.existsSync(path10.join(root, ".ruff.toml"))) {
+    tools.push("ruff");
+  }
+  return tools;
+}
+function readPackageJson(root) {
+  try {
+    const pkgPath = path10.join(root, "package.json");
+    if (fs10.existsSync(pkgPath)) {
+      return JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+async function runTool(tool, cwd, files, autoFix, timeoutSeconds) {
+  const cmd = buildToolCommand(tool, files, autoFix);
+  if (!cmd) return null;
+  return new Promise((resolve) => {
+    const parts = cmd.split(" ");
+    const command = parts[0];
+    const args = parts.slice(1);
+    const proc = spawn2(command, args, {
+      cwd,
+      shell: process.platform === "win32",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    const timeoutId = setTimeout(() => {
+      proc.kill("SIGTERM");
+      if (process.platform === "win32") {
+        try {
+          spawn2("taskkill", ["/pid", String(proc.pid), "/f", "/t"], { stdio: "ignore" });
+        } catch {
+        }
+      }
+    }, (timeoutSeconds ?? 60) * 1e3);
+    proc.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      clearTimeout(timeoutId);
+      resolve({
+        stdout,
+        stderr,
+        exitCode: code ?? -1
+      });
+    });
+    proc.on("error", () => {
+      clearTimeout(timeoutId);
+      resolve(null);
+    });
+  });
+}
+function buildToolCommand(tool, files, autoFix) {
+  const pm = detectPackageManagerPrefix();
+  switch (tool) {
+    case "eslint": {
+      const fixFlag = autoFix ? " --fix" : "";
+      const target = files ? files.join(" ") : ".";
+      return pm + "eslint" + fixFlag + " " + target + " --format unix";
+    }
+    case "tsc": {
+      return pm + "tsc --noEmit";
+    }
+    case "prettier": {
+      const fixFlag = autoFix ? " --write" : " --check";
+      const target = files ? files.join(" ") : ".";
+      return pm + "prettier" + fixFlag + " " + target;
+    }
+    case "ruff": {
+      const fixFlag = autoFix ? " --fix" : "";
+      const target = files ? files.join(" ") : ".";
+      return "ruff check" + fixFlag + " " + target;
+    }
+    default:
+      return null;
+  }
+}
+function detectPackageManagerPrefix() {
+  const root = getProjectRoot();
+  if (fs10.existsSync(path10.join(root, "pnpm-lock.yaml"))) return "pnpm ";
+  if (fs10.existsSync(path10.join(root, "yarn.lock"))) return "yarn ";
+  return "npx --no-install ";
+}
+function parseToolOutput(tool, stdout, stderr, projectRoot) {
+  switch (tool) {
+    case "eslint":
+      return parseEslintOutput(stdout, projectRoot);
+    case "tsc":
+      return parseTscOutput(stderr || stdout, projectRoot);
+    case "prettier":
+      return parsePrettierOutput(stdout, projectRoot);
+    case "ruff":
+      return parseRuffOutput(stdout, projectRoot);
+    default:
+      return [];
+  }
+}
+function resolveToolPath(filePath, projectRoot) {
+  const trimmed = filePath.trim();
+  return path10.isAbsolute(trimmed) ? path10.relative(projectRoot, trimmed) : trimmed.replace(/^\.\//, "");
+}
+function parseEslintOutput(output, projectRoot) {
+  const issues = [];
+  const lineRegex = /^(.+?):(\d+):(\d+):\s+(error|warning)\s+(.+?)(?:\s*\[([^\]]+)\])?\s*$/;
+  for (const line of output.split("\n")) {
+    const match = line.match(lineRegex);
+    if (match) {
+      const [, filePath, lineStr, colStr, severity, message, rule] = match;
+      issues.push({
+        file: resolveToolPath(filePath, projectRoot),
+        line: parseInt(lineStr, 10),
+        column: parseInt(colStr, 10),
+        severity: severity === "error" ? "error" : "warning",
+        message: message.trim(),
+        rule: rule?.trim() || void 0,
+        source: "eslint"
+      });
+    }
+  }
+  return issues;
+}
+function parseTscOutput(output, projectRoot) {
+  const issues = [];
+  const lineRegex = /^(.+)\((\d+),(\d+)\):\s+(error|warning)\s+(TS\d+):\s+(.+)$/;
+  for (const line of output.split("\n")) {
+    let match = line.match(lineRegex);
+    if (match) {
+      const [, filePath, lineStr, colStr, _severity, code, message] = match;
+      issues.push({
+        file: resolveToolPath(filePath, projectRoot),
+        line: parseInt(lineStr, 10) || 1,
+        column: parseInt(colStr, 10) || 1,
+        severity: "error",
+        message: message.trim(),
+        rule: code.trim(),
+        source: "tsc"
+      });
+      continue;
+    }
+    const fallbackRegex = /^(.+)\((\d+),(\d+)\):\s+(.+)$/;
+    match = line.match(fallbackRegex);
+    if (match) {
+      const [, filePath, lineStr, colStr, message] = match;
+      issues.push({
+        file: resolveToolPath(filePath, projectRoot),
+        line: parseInt(lineStr, 10) || 1,
+        column: parseInt(colStr, 10) || 1,
+        severity: "error",
+        message: message.trim(),
+        source: "tsc"
+      });
+    }
+  }
+  return issues;
+}
+function parsePrettierOutput(output, projectRoot) {
+  const issues = [];
+  const lineRegex = /^(.+?)(?::(\d+):(\d+))?\s+\[error\]\s*(.+)?$/;
+  for (const line of output.split("\n")) {
+    const match = line.match(lineRegex);
+    if (match) {
+      const filePath = match[1].trim();
+      if (!filePath || filePath.startsWith("[")) continue;
+      issues.push({
+        file: resolveToolPath(filePath, projectRoot),
+        line: match[2] ? parseInt(match[2], 10) : 1,
+        column: match[3] ? parseInt(match[3], 10) : 1,
+        severity: "warning",
+        message: match[4]?.trim() || "Formatting issue",
+        rule: "prettier",
+        source: "prettier"
+      });
+    }
+  }
+  return issues;
+}
+function parseRuffOutput(output, projectRoot) {
+  const issues = [];
+  const lineRegex = /^(.+?):(\d+):(\d+):\s+(\w+)\s+(.+)$/;
+  for (const line of output.split("\n")) {
+    const match = line.match(lineRegex);
+    if (match) {
+      const [, filePath, lineStr, colStr, rule, message] = match;
+      issues.push({
+        file: resolveToolPath(filePath, projectRoot),
+        line: parseInt(lineStr, 10) || 1,
+        column: parseInt(colStr, 10) || 1,
+        severity: "warning",
+        message: message.trim(),
+        rule: rule.trim(),
+        source: "ruff"
+      });
+    }
+  }
+  return issues;
+}
+function formatResults2(results, allIssues, toolsRun) {
+  const totalErrors = allIssues.filter((i) => i.severity === "error").length;
+  const totalWarnings = allIssues.filter((i) => i.severity === "warning").length;
+  const totalInfo = allIssues.filter((i) => i.severity === "info").length;
+  const toolsStr = toolsRun.join(", ");
+  const hasIssues = totalErrors > 0 || totalWarnings > 0 || totalInfo > 0;
+  const lines = [
+    "**Static Analysis**",
+    "Tools: " + toolsStr,
+    "",
+    "Summary: " + totalErrors + " error(s), " + totalWarnings + " warning(s), " + totalInfo + " info",
+    ""
+  ];
+  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("");
+      lines.push("The tool may have encountered an error. Run it manually to see full output.");
+    } else {
+      lines.push("All checks passed \u2014 no issues found.");
+    }
+    lines.push("");
+    lines.push("Use precise_diff_editor or batch_file_writer for the next changes.");
+    return lines.join("\n");
+  }
+  const byFile = /* @__PURE__ */ new Map();
+  for (const issue of allIssues) {
+    const existing = byFile.get(issue.file) ?? [];
+    existing.push(issue);
+    byFile.set(issue.file, existing);
+  }
+  for (const [file, fileIssues] of byFile) {
+    lines.push("--- " + file + " ---");
+    for (const issue of fileIssues) {
+      const severityTag = issue.severity === "error" ? "[ERROR]" : issue.severity === "warning" ? "[WARN]" : "[INFO]";
+      const loc = "L" + issue.line + ":" + issue.column;
+      const ruleStr = issue.rule ? " (" + issue.rule + ")" : "";
+      lines.push("  " + severityTag + " " + loc + " \u2014 " + issue.message + ruleStr);
+    }
+    lines.push("");
+  }
+  lines.push("--- Per Tool ---");
+  for (const result of results) {
+    lines.push(
+      "  " + result.tool + ": " + result.summary.errors + "E / " + result.summary.warnings + "W / " + result.summary.info + "I (exit: " + result.exitCode + ")"
+    );
+  }
+  lines.push("");
+  lines.push("Use smart_file_picker to open a specific file and fix issues.");
+  lines.push("Re-run static_analysis to verify fixes.");
+  return lines.join("\n");
+}
+function formatNoToolsDetected() {
+  return [
+    "**Static Analysis**",
+    "",
+    "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)",
+    "",
+    "Install and configure a linter to use this tool.",
+    "Then run project_conventions to refresh detection."
+  ].join("\n");
+}
+function formatToolNotAvailable(requested, available) {
+  return [
+    "**Static Analysis**",
+    "",
+    'Tool "' + requested + '" is not available for this project.',
+    "",
+    "Available tools: " + (available.length > 0 ? available.join(", ") : "none"),
+    "",
+    "Run static_analysis with tool: 'all' (default) to run all available tools."
+  ].join("\n");
+}
+
+// src/tools/kumaReflect.ts
+import { execSync as execSync2 } from "child_process";
+async function handleReflect(params) {
+  const summary = sessionMemory.getSummary();
+  const goal = params.goal || summary.currentGoal || "";
+  const modifiedFiles = sessionMemory.getModifiedFiles();
+  const toolCalls = sessionMemory.getToolCallHistory(50);
+  const failedFiles = sessionMemory.getFailedFiles();
+  const loop = sessionMemory.detectLoop();
+  const unresolved = [];
+  for (const f of failedFiles) {
+    for (const ff of f.failures) {
+      if (!ff.resolved) {
+        unresolved.push({ task: f.task, error: ff.error.substring(0, 200) });
+      }
+    }
+  }
+  const hasRunTests = toolCalls.some(
+    (c) => c.toolName === "execute_safe_test"
+  );
+  let gitStat = "";
+  try {
+    const root = getProjectRoot();
+    gitStat = execSync2("git diff --stat", {
+      cwd: root,
+      encoding: "utf-8",
+      timeout: 5e3
+    }).trim();
+  } catch {
+  }
+  const drifts = [];
+  if (modifiedFiles.length > 0 && !hasRunTests) {
+    drifts.push(`${modifiedFiles.length} file(s) edited but no test run`);
+  }
+  if (loop.isLooping) {
+    drifts.push(loop.message);
+  }
+  if (unresolved.length > 0) {
+    drifts.push(`${unresolved.length} unresolved failure(s)`);
+  }
+  if (gitStat) {
+    drifts.push(`Git diff: ${gitStat}`);
+  }
+  const ladderViolations = [];
+  const editCalls = toolCalls.filter(
+    (c) => c.toolName === "precise_diff_editor" || c.toolName === "batch_file_writer"
+  ).length;
+  if (editCalls > 5) {
+    ladderViolations.push(
+      `${editCalls} file ops in a row \u2014 consider if all are needed`
+    );
+  }
+  if (modifiedFiles.length > 5 && !hasRunTests) {
+    ladderViolations.push(
+      `${modifiedFiles.length} files modified without verification`
+    );
+  }
+  const onTrack = !loop.isLooping && unresolved.length === 0 && (modifiedFiles.length === 0 || hasRunTests);
+  let suggestion;
+  if (!goal) {
+    suggestion = "No goal set \u2014 use goal parameter or setGoal";
+  } else if (loop.isLooping) {
+    suggestion = "Switch approach \u2014 current tool is not making progress";
+  } else if (unresolved.length > 0) {
+    suggestion = "Fix unresolved failures before continuing";
+  } else if (modifiedFiles.length > 0 && !hasRunTests) {
+    suggestion = "Run tests to verify changes";
+  } else if (modifiedFiles.length === 0 && !toolCalls.some((c) => ["smart_file_picker", "smart_grep"].includes(c.toolName))) {
+    suggestion = "Start by exploring what exists before writing code";
+  } else if (editCalls > 10) {
+    suggestion = "Consider if refactoring can be simplified \u2014 fewer files = fewer bugs";
+  } else {
+    suggestion = "On track";
+  }
+  return JSON.stringify(
+    {
+      onTrack,
+      ...drifts.length > 0 ? { drift: drifts.join("; ") } : {},
+      ...ladderViolations.length > 0 ? { ladderViolations } : {},
+      suggestion,
+      stats: {
+        goal,
+        modifiedFiles: modifiedFiles.length,
+        toolCalls: toolCalls.length,
+        unresolvedFailures: unresolved.length,
+        hasLoop: loop.isLooping,
+        hasRunTests
+      }
+    },
+    null,
+    2
+  );
+}
+
+// src/engine/lspClient.ts
+import { spawn as spawn3 } from "child_process";
+import path11 from "path";
+import fs11 from "fs";
+var LSPClient = class {
+  process = null;
+  requestId = 0;
+  pending = /* @__PURE__ */ new Map();
+  buffer = Buffer.alloc(0);
+  initialized = false;
+  initPromise = null;
+  openDocuments = /* @__PURE__ */ new Set();
+  _isAvailable = true;
+  /** Check whether LSP is available (binary installed) */
+  isAvailable() {
+    return this._isAvailable;
+  }
+  async ensureInitialized() {
+    if (this._isAvailable !== void 0 && !this._isAvailable) return;
+    if (this.initialized && this.process) return;
+    if (this.initPromise) {
+      try {
+        await this.initPromise;
+        return;
+      } catch {
+        this.initPromise = null;
+      }
+    }
+    this.initPromise = this.initialize();
+    return this.initPromise;
+  }
+  async initialize() {
+    const root = getProjectRoot();
+    const lspBinary = this.resolveLspBinary(root);
+    if (!lspBinary) {
+      this._isAvailable = false;
+      this.initialized = false;
+      this.initPromise = null;
+      console.error(`[LSP] typescript-language-server not found. LSP features will fallback to regex.`);
+      return;
+    }
+    const tsconfigPath = path11.join(root, "tsconfig.json");
+    if (!fs11.existsSync(tsconfigPath)) {
+      console.error(`[LSP] Warning: tsconfig.json not found at "${root}". Running in implicit project mode.`);
+    }
+    this.process = spawn3(lspBinary, ["--stdio", "--log-level=4"], {
+      cwd: root,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env }
+    });
+    this.process.stdout?.on("data", (data) => {
+      this.buffer = Buffer.concat([this.buffer, data]);
+      this.processBuffer();
+    });
+    this.process.stderr?.on("data", (data) => {
+      console.error(`[LSP] ${data.toString().trim()}`);
+    });
+    this.process.on("exit", (code) => {
+      console.error(`[LSP] Process exited with code ${code}`);
+      this.initialized = false;
+      this.process = null;
+      this.initPromise = null;
+      this.openDocuments.clear();
+      this.buffer = Buffer.alloc(0);
+      for (const [, pending] of this.pending) {
+        pending.reject(new Error(`LSP server exited (code ${code})`));
+      }
+      this.pending.clear();
+    });
+    this.process.on("error", (err) => {
+      console.error(`[LSP] Process error: ${err.message}. LSP features will fallback to regex.`);
+      this._isAvailable = false;
+      this.process = null;
+      this.initialized = false;
+      this.initPromise = null;
+      this.openDocuments.clear();
+      for (const [, pending] of this.pending) {
+        pending.reject(new Error(`LSP server error: ${err.message}`));
+      }
+      this.pending.clear();
+    });
+    const rootUri = this.toUri(root);
+    const initResult = await this.sendRequestRaw("initialize", {
+      processId: null,
+      rootPath: root,
+      rootUri,
+      capabilities: {
+        textDocument: {
+          references: {},
+          definition: {},
+          rename: { prepareSupport: true },
+          hover: {
+            contentFormat: ["markdown", "plaintext"]
+          }
+        }
+      }
+    });
+    console.error(`[LSP] Initialized. Server capabilities: ${Object.keys(initResult.capabilities ?? {}).length} items`);
+    this.sendNotification("initialized", {});
+    this.initialized = true;
+  }
+  /** Resolve the typescript-language-server binary from local or global install */
+  resolveLspBinary(projectRoot) {
+    const candidates = [
+      path11.join(projectRoot, "node_modules", ".bin", "typescript-language-server"),
+      path11.join(projectRoot, "..", "node_modules", ".bin", "typescript-language-server")
+    ];
+    for (const candidate of candidates) {
+      if (fs11.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    try {
+      const envPath = process.env.PATH ?? "";
+      for (const dir of envPath.split(path11.delimiter)) {
+        const binPath = path11.join(dir, "typescript-language-server");
+        if (fs11.existsSync(binPath)) {
+          return binPath;
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
+  toUri(filePath) {
+    return `file://${filePath}`;
+  }
+  fromUri(uri) {
+    return uri.replace(/^file:\/\//, "");
+  }
+  /** Open a document so the LSP server knows about it */
+  async openDocument(filePath) {
+    await this.ensureInitialized();
+    if (this.openDocuments.has(filePath)) return;
+    this.openDocuments.add(filePath);
+    let content;
+    try {
+      content = fs11.readFileSync(filePath, "utf-8");
+    } catch {
+      content = "";
+    }
+    this.sendNotification("textDocument/didOpen", {
+      textDocument: {
+        uri: this.toUri(filePath),
+        languageId: "typescript",
+        version: 1,
+        text: content
+      }
+    });
+  }
+  // ============================================================
+  // LSP METHODS
+  // ============================================================
+  /** Find all references to a symbol at a position */
+  async findReferences(filePath, line, character) {
+    await this.ensureInitialized();
+    await this.openDocument(filePath);
+    const result = await this.sendRequestRaw("textDocument/references", {
+      textDocument: { uri: this.toUri(filePath) },
+      position: { line, character },
+      context: { includeDeclaration: true }
+    });
+    if (!result || !Array.isArray(result)) return [];
+    return result.map((ref) => ({
+      filePath: this.fromUri(ref.uri),
+      line: ref.range.start.line,
+      character: ref.range.start.character,
+      lineContent: ""
+    }));
+  }
+  /** Get the definition location of a symbol */
+  async goToDefinition(filePath, line, character) {
+    await this.ensureInitialized();
+    await this.openDocument(filePath);
+    const result = await this.sendRequestRaw("textDocument/definition", {
+      textDocument: { uri: this.toUri(filePath) },
+      position: { line, character }
+    });
+    if (!result) return null;
+    const loc = Array.isArray(result) ? result[0] : result;
+    if (!loc) return null;
+    return {
+      uri: loc.uri,
+      filePath: this.fromUri(loc.uri),
+      line: loc.range.start.line,
+      character: loc.range.start.character
+    };
+  }
+  /** Rename a symbol across all files */
+  async renameSymbol(filePath, line, character, newName) {
+    await this.ensureInitialized();
+    await this.openDocument(filePath);
+    try {
+      await this.sendRequestRaw("textDocument/prepareRename", {
+        textDocument: { uri: this.toUri(filePath) },
+        position: { line, character }
+      });
+      const result = await this.sendRequestRaw("textDocument/rename", {
+        textDocument: { uri: this.toUri(filePath) },
+        position: { line, character },
+        newName
+      });
+      if (!result) {
+        return { changes: [], success: false, error: "No rename result returned" };
+      }
+      const changes = [];
+      const rawChanges = result.changes ?? {};
+      for (const [uri, edits] of Object.entries(rawChanges)) {
+        changes.push({
+          filePath: this.fromUri(uri),
+          edits: edits.map((edit) => ({
+            line: edit.range.start.line,
+            character: edit.range.start.character,
+            endLine: edit.range.end.line,
+            endCharacter: edit.range.end.character,
+            newText: edit.newText
+          }))
+        });
+      }
+      return { changes, success: true };
+    } catch (err) {
+      return {
+        changes: [],
+        success: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  /** Get type information at a position */
+  async getTypeInfo(filePath, line, character) {
+    await this.ensureInitialized();
+    await this.openDocument(filePath);
+    const result = await this.sendRequestRaw("textDocument/hover", {
+      textDocument: { uri: this.toUri(filePath) },
+      position: { line, character }
+    });
+    if (!result) return null;
+    let contents = "";
+    if (typeof result.contents === "string") {
+      contents = result.contents;
+    } else if (Array.isArray(result.contents)) {
+      contents = result.contents.map((c) => c.value ?? c).join("\n---\n");
+    } else if (result.contents && typeof result.contents === "object" && "value" in result.contents) {
+      contents = result.contents.value;
+    } else {
+      contents = JSON.stringify(result.contents);
+    }
+    return {
+      contents,
+      range: result.range
+    };
+  }
+  /** Clean shutdown */
+  async shutdown() {
+    if (!this.process) return;
+    try {
+      await this.sendRequestRaw("shutdown", {});
+      this.sendNotification("exit", {});
+    } catch {
+    }
+    this.process.kill();
+    this.process = null;
+    this.initialized = false;
+    this.initPromise = null;
+    this.openDocuments.clear();
+  }
+  // ============================================================
+  // JSON-RPC LOW-LEVEL
+  // ============================================================
+  sendRequestRaw(method, params) {
+    return new Promise((resolve, reject) => {
+      const id = ++this.requestId;
+      this.pending.set(id, { resolve, reject });
+      const message = JSON.stringify({
+        jsonrpc: "2.0",
+        id,
+        method,
+        params
+      });
+      if (!this.process?.stdin?.writable) {
+        this.pending.delete(id);
+        reject(new Error("LSP server not running"));
+        return;
+      }
+      const header = `Content-Length: ${Buffer.byteLength(message, "utf-8")}\r
+\r
+`;
+      this.process.stdin.write(header + message);
+    });
+  }
+  sendNotification(method, params) {
+    const message = JSON.stringify({
+      jsonrpc: "2.0",
+      method,
+      params
+    });
+    if (!this.process?.stdin?.writable) {
+      console.error(`[LSP] Cannot send notification ${method}: server not running`);
+      return;
+    }
+    const header = `Content-Length: ${Buffer.byteLength(message, "utf-8")}\r
+\r
+`;
+    this.process.stdin.write(header + message);
+  }
+  /** Parse LSP buffer. Messages are in format: Content-Length: N\r\n\r\n<JSON> */
+  processBuffer() {
+    const headerEnd = "\r\n\r\n";
+    while (true) {
+      const headerIdx = this.buffer.indexOf(headerEnd);
+      if (headerIdx === -1) break;
+      const header = this.buffer.subarray(0, headerIdx).toString("utf-8");
+      const lengthMatch = header.match(/Content-Length:\s*(\d+)/i);
+      if (!lengthMatch) {
+        this.buffer = this.buffer.subarray(headerIdx + 4);
+        continue;
+      }
+      const contentLength = parseInt(lengthMatch[1], 10);
+      const messageStart = headerIdx + 4;
+      const messageEnd = messageStart + contentLength;
+      if (this.buffer.length < messageEnd) break;
+      const content = this.buffer.subarray(messageStart, messageEnd).toString("utf-8");
+      this.buffer = this.buffer.subarray(messageEnd);
+      try {
+        const msg = JSON.parse(content);
+        this.handleMessage(msg);
+      } catch (err) {
+        console.error(`[LSP] Failed to parse message: ${err}`);
+      }
+    }
+  }
+  handleMessage(msg) {
+    if (msg.id && typeof msg.id === "number") {
+      const pending = this.pending.get(msg.id);
+      if (!pending) {
+        console.error(`[LSP] No pending request for id ${msg.id}`);
+        return;
+      }
+      this.pending.delete(msg.id);
+      if (msg.error) {
+        pending.reject(new Error(JSON.stringify(msg.error)));
+      } else {
+        pending.resolve(msg.result);
+      }
+    }
+    if (!msg.id) {
+      if (msg.method === "textDocument/publishDiagnostics") {
+      }
+    }
+  }
+};
+var lspClient = new LSPClient();
+
+// src/tools/lspTools.ts
+import fs12 from "fs";
+import path12 from "path";
+async function handleFindReferences(params) {
+  const { filePath, line, character } = params;
+  const validation = validateFilePath(filePath);
+  if (!validation.valid) {
+    return `Error: ${validation.error.message}`;
+  }
+  const resolvedPath = validation.resolvedPath;
+  if (!fs12.existsSync(resolvedPath)) {
+    return `Error: File not found: "${filePath}".`;
+  }
+  if (!lspClient.isAvailable()) {
+    sessionMemory.recordToolCall("lsp_query", { action: "refs", filePath, line, character, fallback: "regex" });
+    const symbolName = extractSymbolAtPosition(resolvedPath, line, character);
+    if (!symbolName) {
+      return `\u26A0\uFE0F LSP unavailable and cannot read symbol at that position for fallback grep.
+
+\u{1F4A1} Install typescript-language-server: 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.`;
+    }
+    const enrichedRefs = references.map((ref) => {
+      let lineContent = "";
+      try {
+        const content = fs12.readFileSync(ref.filePath, "utf-8");
+        const lines2 = content.split("\n");
+        lineContent = lines2[ref.line]?.trim() ?? "";
+      } catch {
+      }
+      return { ...ref, lineContent };
+    });
+    const grouped = /* @__PURE__ */ new Map();
+    for (const ref of enrichedRefs) {
+      const existing = grouped.get(ref.filePath) ?? [];
+      existing.push(ref);
+      grouped.set(ref.filePath, existing);
+    }
+    const projectRoot = getProjectRoot();
+    const lines = [
+      `\u{1F50D} **Find References** \u2014 ${enrichedRefs.length} references found`,
+      `\u{1F4CD} File: ${path12.relative(projectRoot, resolvedPath)}:${line + 1}:${character + 1}`,
+      ""
+    ];
+    for (const [file, refs] of grouped) {
+      const relPath = path12.relative(projectRoot, file);
+      lines.push(`**\u{1F4C4} ${relPath}:**`);
+      for (const ref of refs) {
+        const loc = `L${ref.line + 1}:${ref.character + 1}`;
+        lines.push(`  \u2514 ${loc} \u2014 ${ref.lineContent.substring(0, 120)}`);
+      }
+      lines.push("");
+    }
+    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)}`;
+  }
+}
+async function handleGoToDefinition(params) {
+  const { filePath, line, character } = params;
+  const validation = validateFilePath(filePath);
+  if (!validation.valid) {
+    return `Error: ${validation.error.message}`;
+  }
+  const resolvedPath = validation.resolvedPath;
+  if (!fs12.existsSync(resolvedPath)) {
+    return `Error: File not found: "${filePath}".`;
+  }
+  if (!lspClient.isAvailable()) {
+    sessionMemory.recordToolCall("lsp_query", { action: "def", filePath, line, character, fallback: "regex" });
+    const symbolName = extractSymbolAtPosition(resolvedPath, line, character);
+    if (!symbolName) {
+      return `\u26A0\uFE0F LSP unavailable and cannot read symbol at that position for fallback.
+
+\u{1F4A1} Install typescript-language-server: 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.`;
+    }
+    const projectRoot = getProjectRoot();
+    const relPath = path12.relative(projectRoot, definition.filePath);
+    let lineContent = "";
+    try {
+      const content = fs12.readFileSync(definition.filePath, "utf-8");
+      const lines2 = content.split("\n");
+      lineContent = lines2[definition.line]?.trim() ?? "";
+    } catch {
+    }
+    const lines = [
+      `\u{1F4CD} **Go to Definition**`,
+      `\u{1F4C4} File: \`${relPath}\``,
+      `\u{1F4CF} Line: ${definition.line + 1}:${definition.character + 1}`,
+      `\u2514 ${lineContent}`,
+      "",
+      `\u{1F4A1} Use smart_file_picker(${JSON.stringify({
+        filePath: relPath,
+        startLine: Math.max(1, definition.line + 1 - 5),
+        endLine: definition.line + 1 + 5
+      })}) to read context around the definition.`
+    ];
+    return lines.join("\n");
+  } catch (err) {
+    return `Error finding definition: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+async function handleRenameSymbol(params) {
+  const { filePath, line, character, newName } = params;
+  if (!newName || newName.trim().length === 0) {
+    return "Error: Parameter 'newName' must not be empty.";
+  }
+  const validation = validateFilePath(filePath);
+  if (!validation.valid) {
+    return `Error: ${validation.error.message}`;
+  }
+  const resolvedPath = validation.resolvedPath;
+  if (!fs12.existsSync(resolvedPath)) {
+    return `Error: File not found: "${filePath}".`;
+  }
+  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
+
+Meanwhile, use smart_grep to find all references, then precise_diff_editor for manual editing.`;
+  }
+  try {
+    const result = await lspClient.renameSymbol(resolvedPath, line, character, newName);
+    if (!result.success) {
+      return `\u274C **Rename Symbol** failed: ${result.error ?? "Unknown error"}
+\`\`\`
+Make sure:
+1. Position (line: ${line + 1}, character: ${character + 1}) is exactly on the symbol you want to rename
+2. The symbol is valid for renaming
+\`\`\``;
+    }
+    if (result.changes.length === 0) {
+      return "\u26A0\uFE0F No changes needed.";
+    }
+    const projectRoot = getProjectRoot();
+    let totalEdits = 0;
+    const fileChanges = [];
+    for (const change of result.changes) {
+      try {
+        const content = fs12.readFileSync(change.filePath, "utf-8");
+        const lines2 = content.split("\n");
+        const sortedEdits = [...change.edits].sort((a, b) => {
+          if (b.line !== a.line) return b.line - a.line;
+          return b.character - a.character;
+        });
+        for (const edit of sortedEdits) {
+          const lineStr = lines2[edit.line];
+          if (lineStr) {
+            const before = lineStr.substring(0, edit.character);
+            const after = lineStr.substring(edit.endCharacter);
+            lines2[edit.line] = before + edit.newText + after;
+          }
+        }
+        fs12.writeFileSync(change.filePath, lines2.join("\n"), "utf-8");
+        totalEdits += change.edits.length;
+        fileChanges.push({
+          filePath: path12.relative(projectRoot, change.filePath),
+          editCount: change.edits.length
+        });
+      } catch (err) {
+        console.error(`[Rename] Failed to apply edits to ${change.filePath}: ${err}`);
+      }
+    }
+    const lines = [
+      `\u270F\uFE0F **Rename Symbol** \u2705 Success \u2014 ${newName}`,
+      `\u{1F4CA} ${totalEdits} changes in ${fileChanges.length} files:`,
+      "",
+      ...fileChanges.map((f) => `  \u{1F4C4} \`${f.filePath}\` \u2014 ${f.editCount} edit`),
+      "",
+      `\u{1F4A1} Run execute_safe_test({task: "typecheck"}) to verify.`
+    ];
+    return lines.join("\n");
+  } catch (err) {
+    return `Error renaming symbol: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+async function handleGetTypeInfo(params) {
+  const { filePath, line, character } = params;
+  const validation = validateFilePath(filePath);
+  if (!validation.valid) {
+    return `Error: ${validation.error.message}`;
+  }
+  const resolvedPath = validation.resolvedPath;
+  if (!fs12.existsSync(resolvedPath)) {
+    return `Error: File not found: "${filePath}".`;
+  }
+  if (!lspClient.isAvailable()) {
+    sessionMemory.recordToolCall("lsp_query", { action: "type", filePath, line, character, fallback: "line-context" });
+    try {
+      const fileContent = fs12.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}".`;
+      }
+      const symbolName = extractSymbolAtPosition(resolvedPath, line, character);
+      const projectRoot = getProjectRoot();
+      const relPath = path12.relative(projectRoot, resolvedPath);
+      const contextStart = Math.max(0, line - 3);
+      const contextEnd = Math.min(fileLines.length, line + 4);
+      const contextLines = [];
+      for (let i = contextStart; i < contextEnd; i++) {
+        const prefix = i === line ? "\u2192" : " ";
+        const marker = i === line && symbolName ? " ".repeat(character) + "^".repeat(Math.min(symbolName.length, 20)) : "";
+        contextLines.push(`${prefix} L${i + 1}: ${fileLines[i].replace(/\t/g, " ")}`);
+        if (marker) {
+          contextLines.push(`  ${marker}`);
+        }
+      }
+      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{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.`
+      ];
+      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)}`;
+    }
+  }
+  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.`;
+    }
+    const projectRoot = getProjectRoot();
+    const relPath = path12.relative(projectRoot, resolvedPath);
+    const lines = [
+      `\u{1F4CB} **Type Info** \u2014 \`${relPath}:${line + 1}:${character + 1}\``,
+      "",
+      "```typescript",
+      hoverInfo.contents,
+      "```"
+    ];
+    if (hoverInfo.range) {
+      const r = hoverInfo.range;
+      lines.push(
+        "",
+        `\u{1F4CD} Range: L${r.start.line + 1}:${r.start.character + 1} \u2014 L${r.end.line + 1}:${r.end.character + 1}`
+      );
+    }
+    return lines.join("\n");
+  } catch (err) {
+    return `Error getting type info: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+async function handleLspQuery(params) {
+  const { filePath, line, character, action, newName } = params;
+  if (action === "def") {
+    return handleGoToDefinition({ filePath, line, character });
+  }
+  if (action === "refs") {
+    return handleFindReferences({ filePath, line, character });
+  }
+  if (action === "type") {
+    return handleGetTypeInfo({ filePath, line, character });
+  }
+  if (action === "rename") {
+    if (!newName || newName.trim().length === 0) {
+      return "Error: Parameter 'newName' required for rename action.";
+    }
+    return handleRenameSymbol({ filePath, line, character, newName });
+  }
+  return `Error: Action "${action}" not supported.`;
+}
+function extractSymbolAtPosition(filePath, line, character) {
+  try {
+    const content = fs12.readFileSync(filePath, "utf-8");
+    const lines = content.split("\n");
+    const targetLine = lines[line];
+    if (!targetLine) return null;
+    const before = targetLine.slice(0, character);
+    const after = targetLine.slice(character);
+    const leftMatch = before.match(/(\w+)$/);
+    const rightMatch = after.match(/^(\w+)/);
+    const left = leftMatch ? leftMatch[1] : "";
+    const right = rightMatch ? rightMatch[1] : "";
+    const symbol = left + right;
+    return symbol.length > 0 ? symbol : null;
+  } catch {
+    return null;
+  }
+}
+async function fallbackGrepReferences(symbolName, _filePath, _line, _character) {
+  try {
+    const { default: fg2 } = await import("fast-glob");
+    const root = getProjectRoot();
+    const tsFiles = await fg2(["**/*.{ts,tsx,js,jsx}"], {
+      cwd: root,
+      ignore: ["node_modules/**", "dist/**", ".git/**"],
+      onlyFiles: true,
+      absolute: true
+    });
+    const results = [];
+    const escapedSymbol = symbolName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`\\b${escapedSymbol}\\b`, "g");
+    for (const file of tsFiles.slice(0, 100)) {
+      try {
+        const content = fs12.readFileSync(file, "utf-8");
+        const lines2 = content.split("\n");
+        for (let i = 0; i < lines2.length; i++) {
+          if (regex.test(lines2[i])) {
+            results.push({ file, line: i + 1, content: lines2[i].trim().substring(0, 120) });
+          }
+        }
+        if (results.length >= 50) break;
+      } catch {
+        continue;
+      }
+    }
+    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.`;
+    }
+    const grouped = /* @__PURE__ */ new Map();
+    for (const r of results) {
+      const existing = grouped.get(r.file) ?? [];
+      existing.push(r);
+      grouped.set(r.file, existing);
+    }
+    const projectRoot = getProjectRoot();
+    const lines = [
+      `\u{1F50D} **Find References** (regex fallback) \u2014 ${results.length} references found`,
+      `\u{1F4CD} Symbol: "${symbolName}"`,
+      `\u26A0\uFE0F Regex results may be less accurate than LSP (includes comments/strings).`,
+      ""
+    ];
+    for (const [file, refs] of grouped) {
+      const relPath = path12.relative(projectRoot, file);
+      lines.push(`**\u{1F4C4} ${relPath}:**`);
+      for (const ref of refs) {
+        lines.push(`  \u2514 L${ref.line} \u2014 ${ref.content}`);
+      }
+      lines.push("");
+    }
+    lines.push("\u{1F4A1} Install typescript-language-server for more accurate results.");
+    return lines.join("\n");
+  } catch (err) {
+    return `Error in fallback grep references: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+async function fallbackGrepDefinition(symbolName) {
+  try {
+    const { default: fg2 } = await import("fast-glob");
+    const root = getProjectRoot();
+    const tsFiles = await fg2(["**/*.{ts,tsx,js,jsx}"], {
+      cwd: root,
+      ignore: ["node_modules/**", "dist/**", ".git/**"],
+      onlyFiles: true,
+      absolute: true
+    });
+    const escapedSymbol = symbolName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const declPatterns = [
+      new RegExp(`^(export\\s+)?(async\\s+)?function\\s+${escapedSymbol}\\b`),
+      new RegExp(`^(export\\s+)?(default\\s+)?(abstract\\s+)?class\\s+${escapedSymbol}\\b`),
+      new RegExp(`^(export\\s+)?interface\\s+${escapedSymbol}\\b`),
+      new RegExp(`^(export\\s+)?type\\s+${escapedSymbol}\\b`),
+      new RegExp(`^(export\\s+)?(const|let|var)\\s+${escapedSymbol}\\b`),
+      new RegExp(`^(export\\s+)?enum\\s+${escapedSymbol}\\b`)
+    ];
+    for (const file of tsFiles) {
+      try {
+        const content = fs12.readFileSync(file, "utf-8");
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          const trimmed = lines[i].trim();
+          for (const pattern of declPatterns) {
+            if (pattern.test(trimmed)) {
+              const projectRoot = getProjectRoot();
+              const relPath = path12.relative(projectRoot, file);
+              return [
+                `\u{1F4CD} **Go to Definition** (regex fallback)`,
+                `\u{1F4C4} File: \`${relPath}\``,
+                `\u{1F4CF} Line: ${i + 1}`,
+                `\u2514 ${trimmed.substring(0, 120)}`,
+                "",
+                `\u{1F4A1} Install typescript-language-server for more accurate results.`
+              ].join("\n");
+            }
+          }
+        }
+      } catch {
+        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.`;
+  } catch (err) {
+    return `Error in fallback grep definition: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+
+// src/manifest.ts
+var MEMORY_TOPICS = ["decisions", "glossary", "architecture", "conventions", "known-issues"];
+function registerAllTools(server) {
+  server.tool(
+    "smart_grep",
+    "Narrow down to the specific code you need. Locates functions or text patterns \u2014 returns filename, line number, and 3 lines of context.",
+    {
+      query: z.string().min(1).describe("Regex pattern to search for"),
+      targetFolder: z.string().optional().describe("Target folder (default: project root, max depth 3)"),
+      maxResults: z.number().min(1).max(100).optional().default(30).describe("Max results to return"),
+      extensions: z.array(z.string()).optional().describe("Filter results by file extensions (e.g. ['ts', 'js'])")
+    },
+    async (params) => {
+      try {
+        const result = await handleSmartGrep(params);
+        return { content: [{ type: "text", text: result }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error in smart_grep: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "smart_file_picker",
+    "Read only what you need. Opens a file with smart chunking \u2014 signatures + imports for large files, full content for small ones.",
+    {
+      filePath: z.string().min(1).describe("Path to the file to read"),
+      startLine: z.number().min(1).optional().describe("Start line (1-indexed)"),
+      endLine: z.number().min(1).optional().describe("End line (1-indexed)"),
+      chunkStrategy: z.enum(["full", "smart", "outline"]).optional().default("smart").describe("Read strategy: full=entire file, smart=signatures+imports, outline=exported symbols only")
+    },
+    async (params) => {
+      try {
+        const result = await handleSmartFilePicker(params);
+        return { content: [{ type: "text", text: result }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error in smart_file_picker: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "precise_diff_editor",
+    "Edit code with safety net. Search-and-replace with fuzzy fallback + automatic versioned backup. Use action:'rollback' to undo edits.",
+    {
+      filePath: z.string().min(1).describe("Path to the file to edit"),
+      action: z.enum(["rollback"]).optional().describe("Set to 'rollback' to restore from backup"),
+      edits: z.array(z.object({
+        searchBlock: z.string().min(1).describe("Code block to replace (MUST be exact or fuzzy match)"),
+        replaceBlock: z.string().describe("Replacement code block"),
+        allowMultiple: z.boolean().optional().default(false).describe("Allow multiple replacements"),
+        fuzzyThreshold: z.number().min(0).max(1).optional().default(0.85).describe("Fuzzy match threshold (0.0-1.0)")
+      })).min(1).max(10).optional().describe("Array of edits (max 10)"),
+      dryRun: z.boolean().optional().default(false).describe("Preview changes without writing to disk"),
+      version: z.union([z.number().min(1), z.literal("list")]).optional().describe("Backup version to restore (1=newest, omit=latest, 'list'=show versions)")
+    },
+    async (params) => {
+      try {
+        const result = await handlePreciseDiffEditor(params);
+        return { content: [{ type: "text", text: result }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error in precise_diff_editor: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "batch_file_writer",
+    "Create files in batch (up to 15). Before creating many, question whether each one needs to exist or could be merged into an existing module.",
+    {
+      files: z.array(z.object({
+        filePath: z.string().min(1).describe("File path to create"),
+        content: z.string().describe("File content"),
+        instructions: z.string().min(1).describe("Reason for creating the file")
+      })).min(1).max(15).describe("Array of files to create (max 15)")
+    },
+    async (params) => {
+      try {
+        const result = await handleBatchFileWriter(params);
+        return { content: [{ type: "text", text: result }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error in batch_file_writer: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "execute_safe_test",
+    "Run tests, lint, or typecheck with timeout protection and circuit breaker. Use after every edit to verify you didn't break anything.",
+    {
+      task: z.enum(["test", "build", "lint", "typecheck", "custom"]).describe("Task to execute"),
+      customCommand: z.string().optional().describe("Custom command (only if task='custom')"),
+      timeout: z.number().min(5).max(180).optional().default(60).describe("Timeout in seconds (default: 60s, max: 180s)")
+    },
+    async (params) => {
+      try {
+        const result = await handleSafeTerminalExec(params);
+        return { content: [{ type: "text", text: result }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error in execute_safe_test: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "code_reviewer",
+    "Senior code review that catches what the writer missed. Supports focus modes: correctness, conventions, security, performance, and over-engineering.",
+    {
+      files: z.array(z.string().min(1)).max(10).optional().describe("Files to review (auto-detects via git diff if omitted)"),
+      focus: z.enum(["correctness", "conventions", "security", "performance", "over-engineering"]).optional().default("correctness").describe("Review focus"),
+      customCriteria: z.string().optional().describe("Custom review criteria"),
+      format: z.enum(["text", "json"]).optional().default("text").describe("Output format")
+    },
+    async (params) => {
+      try {
+        const result = await handleCodeReviewer(params);
+        return { content: [{ type: "text", text: result }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error in code_reviewer: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "project_conventions",
+    "Know your stack before you code. Detects framework, test runner, package manager, import alias, monorepo workspaces.",
+    {
+      forceRescan: z.boolean().optional().default(false).describe("Force rescan (ignore cache)")
+    },
+    async (params) => {
+      try {
+        const result = await handleProjectConventions(params);
+        return { content: [{ type: "text", text: result }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error in project_conventions: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "get_session_memory",
+    "Check what you've done this session: modified files, unresolved failures, tool history, memories. Accepts optional topic to load a specific memory file.",
+    {
+      topic: z.enum(MEMORY_TOPICS).optional().describe("Load a specific memory topic (decisions, glossary, architecture, conventions, known-issues)")
+    },
+    async (params) => {
+      try {
+        const memory = getSessionMemory(params.topic);
+        return { content: [{ type: "text", text: JSON.stringify(memory, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error getting session memory: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "lsp_query",
+    "Jump to definition, find references, inspect types, or rename symbols. Uses TypeScript Language Server \u2014 falls back to regex when LSP is unavailable.",
+    {
+      filePath: z.string().min(1).describe("Path to the file containing the symbol"),
+      line: z.number().min(0).describe("Line number (0-indexed)"),
+      character: z.number().min(0).describe("Character position (0-indexed)"),
+      action: z.enum(["def", "refs", "type", "rename"]).describe("Action: def/go to definition, refs/find references, type/get type info, rename/rename symbol"),
+      newName: z.string().optional().describe("New name (required for action:'rename')")
+    },
+    async (params) => {
+      try {
+        const result = await handleLspQuery(params);
+        return { content: [{ type: "text", text: result }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error in lsp_query: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "git_log",
+    "Gets structured git commit history for the project or a specific file.",
+    {
+      maxCount: z.number().min(1).max(100).optional().default(10).describe("Max number of commits to return"),
+      filePath: z.string().optional().describe("Filter history to a specific file")
+    },
+    async (params) => {
+      try {
+        const result = await handleGitLog(params);
+        return { content: [{ type: "text", text: result }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error in git_log: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "kuma_reflect",
+    "Reflect on your current session: on-track/off-track detection, drift warnings, loop detection, and a concrete suggestion for the next action.",
+    {
+      goal: z.string().optional().describe("Optional goal to check against (falls back to session goal)")
+    },
+    async (params) => {
+      try {
+        const result = await handleReflect(params);
+        return { content: [{ type: "text", text: result }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error in kuma_reflect: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "write_memory",
+    "Persist project knowledge to `.kuma/memories/`. Use for decisions (ADR) and glossary (domain terms). Auto-generated topics (architecture, conventions, known-issues) update automatically.",
+    {
+      topic: z.enum(["decisions", "glossary"]).describe("Memory topic: 'decisions' (ADR) or 'glossary' (domain terms)"),
+      content: z.string().min(1).describe("Markdown content to write"),
+      mode: z.enum(["append", "prepend", "overwrite"]).optional().default("append").describe("Write mode: append (default), prepend, or overwrite")
+    },
+    async (params) => {
+      try {
+        const result = handleWriteMemory(params);
+        return { content: [{ type: "text", text: result }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error in write_memory: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "git_diff",
+    "Shows structured git diff output (staged or unstaged). Supports file filter, ref ranges, and context line control.",
+    {
+      filePath: z.string().optional().describe("Filter diff to a specific file"),
+      staged: z.boolean().optional().default(false).describe("Show staged changes (--cached)"),
+      contextLines: z.number().min(1).max(20).optional().default(3).describe("Number of context lines per chunk"),
+      baseRef: z.string().optional().describe("Base git ref for comparing (e.g. main, HEAD~1)"),
+      targetRef: z.string().optional().describe("Target git ref (defaults to HEAD if baseRef is set)")
+    },
+    async (params) => {
+      try {
+        const result = await handleGitDiff(params);
+        return { content: [{ type: "text", text: result }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error in git_diff: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "project_structure",
+    "Displays a tree view of the project's directory layout. Helps AI understand where files live before reading or editing.",
+    {
+      depth: z.number().min(1).max(6).optional().default(3).describe("Max directory depth to show (1-6)"),
+      folderOnly: z.boolean().optional().default(false).describe("Show folders only (no files)"),
+      includePattern: z.string().optional().describe("Only show items containing this string"),
+      excludePattern: z.string().optional().describe("Exclude items containing this string")
+    },
+    async (params) => {
+      try {
+        const result = await handleProjectStructure(params);
+        return { content: [{ type: "text", text: result }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error in project_structure: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "search_session_memory",
+    "Search through session memory by keyword. Covers tool call history, memory files, errors, modified files, and search results.",
+    {
+      query: z.string().min(1).describe("Keyword to search for in session memory"),
+      limit: z.number().min(1).max(100).optional().default(20).describe("Maximum results to return")
+    },
+    async (params) => {
+      try {
+        const result = searchSessionMemory(params);
+        return { content: [{ type: "text", text: result }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error in search_session_memory: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "static_analysis",
+    "Runs available linters/checkers (ESLint, TypeScript, Prettier, Ruff) and parses output into structured results. Auto-detects tools from project config.",
+    {
+      tool: z.enum(["eslint", "tsc", "prettier", "ruff", "all"]).optional().default("all").describe("Which tool to run (default: auto-detect all available)"),
+      files: z.array(z.string()).optional().describe("Specific files to check (default: whole project)"),
+      autoFix: z.boolean().optional().default(false).describe("Auto-fix fixable issues (eslint --fix, prettier --write)"),
+      timeout: z.number().min(5).max(180).optional().default(60).describe("Timeout in seconds per tool")
+    },
+    async (params) => {
+      try {
+        const result = await handleStaticAnalysis(params);
+        return { content: [{ type: "text", text: result }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error in static_analysis: ${err}` }], isError: true };
+      }
+    }
+  );
+  console.error("[Manifest] Registered 16 tools.");
+}
+
+// src/index.ts
+var SERVER_NAME = "kuma";
+var SERVER_VERSION = JSON.parse(
+  readFileSync(new URL("../package.json", import.meta.url), "utf-8")
+).version;
+async function main() {
+  sessionMemory.init({
+    projectRoot: process.cwd(),
+    startTime: Date.now()
+  });
+  const server = new McpServer(
+    {
+      name: SERVER_NAME,
+      version: SERVER_VERSION
+    },
+    {
+      // Capabilities declaration
+      capabilities: {
+        tools: {},
+        resources: {}
+      }
+    }
+  );
+  registerAllTools(server);
+  const transport = new StdioServerTransport();
+  console.error(`[${SERVER_NAME} v${SERVER_VERSION}] Starting MCP server...`);
+  console.error(`[${SERVER_NAME}] Project root: ${process.cwd()}`);
+  console.error(
+    `[${SERVER_NAME}] Session started: ${(/* @__PURE__ */ new Date()).toISOString()}`
+  );
+  await server.connect(transport);
+  console.error(
+    `[${SERVER_NAME}] Server connected via stdio. Waiting for requests...`
+  );
+}
+main().catch((err) => {
+  console.error(`[${SERVER_NAME}] Fatal error:`, err);
+  process.exit(1);
+});