@hung319/opencode-hive 1.4.3 → 1.5.1

package/dist/index.js

@@ -96,8 +96,8 @@ var require_dist = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.AgentBooster = undefined;
   exports.apply = apply;
-  var path3 = __importStar(__require("path"));
-  var wasmPath = path3.join(__dirname, "../wasm/agent_booster_wasm.js");
+  var path4 = __importStar(__require("path"));
+  var wasmPath = path4.join(__dirname, "../wasm/agent_booster_wasm.js");
   var AgentBoosterWasm;
   try {
     AgentBoosterWasm = __require(wasmPath);
@@ -235,6 +235,410 @@ var require_dist = __commonJS((exports) => {
   exports.default = AgentBooster;
 });
 
+// ../../node_modules/.bun/@ast-grep+napi-linux-x64-musl@0.41.1/node_modules/@ast-grep/napi-linux-x64-musl/ast-grep-napi.linux-x64-musl.node
+var require_ast_grep_napi_linux_x64_musl = __commonJS((exports, module) => {
+  module.exports = __require("./ast-grep-napi.linux-x64-musl-qnd01z8b.node");
+});
+
+// ../../node_modules/.bun/@ast-grep+napi-linux-x64-gnu@0.41.1/node_modules/@ast-grep/napi-linux-x64-gnu/ast-grep-napi.linux-x64-gnu.node
+var require_ast_grep_napi_linux_x64_gnu = __commonJS((exports, module) => {
+  module.exports = __require("./ast-grep-napi.linux-x64-gnu-qdwfscvp.node");
+});
+
+// ../../node_modules/.bun/@ast-grep+napi@0.41.1/node_modules/@ast-grep/napi/index.js
+var require_napi = __commonJS((exports, module) => {
+  var __filename = "/home/runner/work/agent-hive/agent-hive/node_modules/.bun/@ast-grep+napi@0.41.1/node_modules/@ast-grep/napi/index.js";
+  var { createRequire: createRequire2 } = __require("node:module");
+  __require = createRequire2(__filename);
+  var { readFileSync: readFileSync5 } = __require("node:fs");
+  var nativeBinding = null;
+  var loadErrors = [];
+  var isMusl = () => {
+    let musl = false;
+    if (process.platform === "linux") {
+      musl = isMuslFromFilesystem();
+      if (musl === null) {
+        musl = isMuslFromReport();
+      }
+      if (musl === null) {
+        musl = isMuslFromChildProcess();
+      }
+    }
+    return musl;
+  };
+  var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+  var isMuslFromFilesystem = () => {
+    try {
+      return readFileSync5("/usr/bin/ldd", "utf-8").includes("musl");
+    } catch {
+      return null;
+    }
+  };
+  var isMuslFromReport = () => {
+    let report = null;
+    if (typeof process.report?.getReport === "function") {
+      process.report.excludeNetwork = true;
+      report = process.report.getReport();
+    }
+    if (!report) {
+      return null;
+    }
+    if (report.header && report.header.glibcVersionRuntime) {
+      return false;
+    }
+    if (Array.isArray(report.sharedObjects)) {
+      if (report.sharedObjects.some(isFileMusl)) {
+        return true;
+      }
+    }
+    return false;
+  };
+  var isMuslFromChildProcess = () => {
+    try {
+      return __require("child_process").execSync("ldd --version", { encoding: "utf8" }).includes("musl");
+    } catch (e) {
+      return false;
+    }
+  };
+  function requireNative() {
+    if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+      try {
+        nativeBinding = __require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+      } catch (err) {
+        loadErrors.push(err);
+      }
+    } else if (process.platform === "android") {
+      if (process.arch === "arm64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.android-arm64.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-android-arm64");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else if (process.arch === "arm") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.android-arm-eabi.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-android-arm-eabi");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`));
+      }
+    } else if (process.platform === "win32") {
+      if (process.arch === "x64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.win32-x64-msvc.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-win32-x64-msvc");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else if (process.arch === "ia32") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.win32-ia32-msvc.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-win32-ia32-msvc");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else if (process.arch === "arm64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.win32-arm64-msvc.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-win32-arm64-msvc");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`));
+      }
+    } else if (process.platform === "darwin") {
+      try {
+        return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.darwin-universal.node");})();
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-darwin-universal");})();
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      if (process.arch === "x64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.darwin-x64.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-darwin-x64");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else if (process.arch === "arm64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.darwin-arm64.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-darwin-arm64");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`));
+      }
+    } else if (process.platform === "freebsd") {
+      if (process.arch === "x64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.freebsd-x64.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-freebsd-x64");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else if (process.arch === "arm64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.freebsd-arm64.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-freebsd-arm64");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`));
+      }
+    } else if (process.platform === "linux") {
+      if (process.arch === "x64") {
+        if (isMusl()) {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-x64-musl.node");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            return require_ast_grep_napi_linux_x64_musl();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        } else {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-x64-gnu.node");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            return require_ast_grep_napi_linux_x64_gnu();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        }
+      } else if (process.arch === "arm64") {
+        if (isMusl()) {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-arm64-musl.node");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-linux-arm64-musl");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        } else {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-arm64-gnu.node");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-linux-arm64-gnu");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        }
+      } else if (process.arch === "arm") {
+        if (isMusl()) {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-arm-musleabihf.node");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-linux-arm-musleabihf");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        } else {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-arm-gnueabihf.node");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-linux-arm-gnueabihf");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        }
+      } else if (process.arch === "riscv64") {
+        if (isMusl()) {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-riscv64-musl.node");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-linux-riscv64-musl");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        } else {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-riscv64-gnu.node");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-linux-riscv64-gnu");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        }
+      } else if (process.arch === "ppc64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-ppc64-gnu.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-linux-ppc64-gnu");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else if (process.arch === "s390x") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-s390x-gnu.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-linux-s390x-gnu");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`));
+      }
+    } else if (process.platform === "openharmony") {
+      if (process.arch === "arm64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-arm64-ohos.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-linux-arm64-ohos");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else if (process.arch === "x64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-x64-ohos.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-linux-x64-ohos");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else if (process.arch === "arm") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-arm-ohos.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-linux-arm-ohos");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`));
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`));
+    }
+  }
+  nativeBinding = requireNative();
+  if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+    try {
+      nativeBinding = (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.wasi.cjs");})();
+    } catch (err) {
+      if (process.env.NAPI_RS_FORCE_WASI) {
+        loadErrors.push(err);
+      }
+    }
+    if (!nativeBinding) {
+      try {
+        nativeBinding = (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-wasm32-wasi");})();
+      } catch (err) {
+        if (process.env.NAPI_RS_FORCE_WASI) {
+          loadErrors.push(err);
+        }
+      }
+    }
+  }
+  if (!nativeBinding) {
+    if (loadErrors.length > 0) {
+      throw new Error(`Cannot find native binding. ` + `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` + "Please try `npm i` again after removing both package-lock.json and node_modules directory.", { cause: loadErrors });
+    }
+    throw new Error(`Failed to load native binding`);
+  }
+  module.exports = nativeBinding;
+  module.exports.SgNode = nativeBinding.SgNode;
+  module.exports.SgRoot = nativeBinding.SgRoot;
+  module.exports.findInFiles = nativeBinding.findInFiles;
+  module.exports.kind = nativeBinding.kind;
+  module.exports.Lang = nativeBinding.Lang;
+  module.exports.parse = nativeBinding.parse;
+  module.exports.parseAsync = nativeBinding.parseAsync;
+  module.exports.parseFiles = nativeBinding.parseFiles;
+  module.exports.pattern = nativeBinding.pattern;
+  module.exports.registerDynamicLanguage = nativeBinding.registerDynamicLanguage;
+  module.exports.css = nativeBinding.css;
+  module.exports.html = nativeBinding.html;
+  module.exports.js = nativeBinding.js;
+  module.exports.jsx = nativeBinding.jsx;
+  module.exports.ts = nativeBinding.ts;
+  module.exports.tsx = nativeBinding.tsx;
+});
+
 // src/utils/context-compression.ts
 var exports_context_compression = {};
 __export(exports_context_compression, {
@@ -450,8 +854,8 @@ var init_context_compression = __esm(() => {
 });
 
 // src/index.ts
-import * as path9 from "path";
-import * as os4 from "os";
+import * as path12 from "path";
+import * as os5 from "os";
 
 // ../../node_modules/.bun/zod@4.1.8/node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -15809,125 +16213,458 @@ var ptyListTool = tool({
   }
 });
 
-// src/tools/lsp.ts
-async function getLspConnection(filePath) {
-  const ext = filePath.split(".").pop()?.toLowerCase() || "";
-  const serverMap = {
-    ts: "typescript",
-    tsx: "typescript",
-    js: "typescript",
-    jsx: "typescript",
-    py: "pylance",
-    rs: "rust-analyzer",
-    go: "gopls",
-    java: "eclipse-jdtls",
-    cpp: "clangd",
-    c: "clangd",
-    h: "clangd",
-    cs: "omnisharp"
-  };
-  const serverId = serverMap[ext];
-  if (!serverId) {
-    return null;
-  }
-  return { serverId };
-}
-var lspRenameTool = tool({
-  description: "Rename a symbol across all files using LSP. Provides IDE-like rename refactoring with cross-file support.",
-  args: {
-    filePath: tool.schema.string().describe("Path to the file containing the symbol"),
-    oldName: tool.schema.string().describe("Current name of the symbol to rename"),
-    newName: tool.schema.string().describe("New name for the symbol")
+// src/tools/lsp-manager.ts
+import { execSync } from "child_process";
+import * as path2 from "path";
+var LSP_DATABASE = {
+  typescript: {
+    extensions: ["ts", "tsx", "js", "jsx", "mjs", "cjs"],
+    primary: {
+      command: "npm",
+      args: ["install", "-g", "typescript-language-server", "typescript"],
+      verifyCommand: "typescript-language-server --version"
+    },
+    alternatives: [
+      {
+        command: "npm",
+        args: ["install", "-g", "@volarjs/typescript-language-server"],
+        verifyCommand: "volar-server --version"
+      }
+    ]
   },
-  async execute({ filePath, oldName, newName }) {
-    const lsp = await getLspConnection(filePath);
-    if (!lsp) {
-      return JSON.stringify({
-        success: false,
-        error: `No LSP server available for file: ${filePath}`,
-        hint: "LSP servers are auto-detected based on file type.",
-        alternative: "Use ast_grep_rewrite_code() tool for pattern-based renaming"
-      }, null, 2);
-    }
-    return JSON.stringify({
-      success: true,
-      message: `Rename "${oldName}" to "${newName}" in ${filePath}`,
-      server: lsp.serverId,
-      operation: "textDocument/rename",
-      oldName,
-      newName,
-      filePath
-    }, null, 2);
-  }
-});
-var lspGotoDefinitionTool = tool({
-  description: "Navigate to the definition of a symbol using LSP. Jump from a usage to its definition.",
-  args: {
-    filePath: tool.schema.string().describe("Path to the file containing the symbol"),
-    line: tool.schema.number().describe("Line number (1-based)"),
-    character: tool.schema.number().describe("Character position (0-based)")
+  python: {
+    extensions: ["py", "pyw", "pyi"],
+    primary: {
+      command: "pip",
+      args: ["install", "pyright"],
+      verifyCommand: "pyright --version"
+    },
+    alternatives: [
+      {
+        command: "pip",
+        args: ["install", "ruff-lsp"],
+        verifyCommand: "ruff-lsp --version"
+      },
+      {
+        command: "pip",
+        args: ["install", "jedi-language-server"],
+        verifyCommand: "jedi-language-server --version"
+      }
+    ]
   },
-  async execute({ filePath, line, character }) {
-    const lsp = await getLspConnection(filePath);
-    if (!lsp) {
-      return JSON.stringify({
-        success: false,
-        error: `No LSP server available for file: ${filePath}`,
-        hint: "LSP servers are auto-detected based on file type."
-      }, null, 2);
-    }
-    return JSON.stringify({
-      success: true,
-      message: `Go to definition at ${filePath}:${line}:${character}`,
-      server: lsp.serverId,
-      operation: "textDocument/definition"
-    }, null, 2);
-  }
-});
-var lspFindReferencesTool = tool({
-  description: "Find all references to a symbol using LSP. Shows all places where a symbol is used or defined.",
-  args: {
-    filePath: tool.schema.string().describe("Path to the file containing the symbol"),
-    line: tool.schema.number().describe("Line number (1-based)"),
-    character: tool.schema.number().describe("Character position (0-based)")
+  rust: {
+    extensions: ["rs"],
+    primary: {
+      command: "rustup",
+      args: ["component", "add", "rust-analyzer"],
+      verifyCommand: "rust-analyzer --version"
+    },
+    alternatives: []
   },
-  async execute({ filePath, line, character }) {
-    const lsp = await getLspConnection(filePath);
-    if (!lsp) {
-      return JSON.stringify({
-        success: false,
-        error: `No LSP server available for file: ${filePath}`,
-        hint: "LSP servers are auto-detected based on file type."
-      }, null, 2);
-    }
-    return JSON.stringify({
-      success: true,
-      message: `Find references at ${filePath}:${line}:${character}`,
-      server: lsp.serverId,
-      operation: "textDocument/references",
-      references: []
+  go: {
+    extensions: ["go"],
+    primary: {
+      command: "go",
+      args: ["install", "golang.org/x/tools/gopls@latest"],
+      verifyCommand: "gopls version"
+    },
+    alternatives: []
+  },
+  java: {
+    extensions: ["java"],
+    primary: {
+      command: "sdk",
+      args: ["install", "java", "21.0.3-tem"],
+      verifyCommand: "jdtls --version"
+    },
+    alternatives: []
+  },
+  cpp: {
+    extensions: ["cpp", "cc", "cxx", "c", "h", "hpp", "hh"],
+    primary: {
+      command: "apt",
+      args: ["install", "clangd"],
+      verifyCommand: "clangd --version"
+    },
+    alternatives: [
+      {
+        command: "apt",
+        args: ["install", "ccls"],
+        verifyCommand: "ccls --version"
+      }
+    ]
+  },
+  csharp: {
+    extensions: ["cs"],
+    primary: {
+      command: "dotnet",
+      args: ["tool", "install", "--global", "OmniSharp"],
+      verifyCommand: "omniSharp --version"
+    },
+    alternatives: []
+  },
+  ruby: {
+    extensions: ["rb"],
+    primary: {
+      command: "gem",
+      args: ["install", "solargraph"],
+      verifyCommand: "solargraph --version"
+    },
+    alternatives: []
+  },
+  php: {
+    extensions: ["php"],
+    primary: {
+      command: "composer",
+      args: ["global", "require", "phpactor/phpactor"],
+      verifyCommand: "phpactor --version"
+    },
+    alternatives: []
+  },
+  vue: {
+    extensions: ["vue"],
+    primary: {
+      command: "npm",
+      args: ["install", "-g", "volar"],
+      verifyCommand: "volar-server --version"
+    },
+    alternatives: []
+  },
+  svelte: {
+    extensions: ["svelte"],
+    primary: {
+      command: "npm",
+      args: ["install", "-g", "svelte-language-server"],
+      verifyCommand: "svelte-language-server --version"
+    },
+    alternatives: []
+  }
+};
+function getLanguageFromPath(filePath) {
+  const ext = path2.extname(filePath).slice(1).toLowerCase();
+  for (const [lang, config2] of Object.entries(LSP_DATABASE)) {
+    if (config2.extensions.includes(ext)) {
+      return lang;
+    }
+  }
+  return null;
+}
+async function checkLspServer(config2) {
+  const cmd = config2.verifyCommand || `${config2.command} --version`;
+  try {
+    execSync(cmd, { stdio: "ignore", timeout: 5000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureLspInstalled(language) {
+  const config2 = LSP_DATABASE[language];
+  if (!config2) {
+    return {
+      success: false,
+      installed: null,
+      error: `No LSP configuration for language: ${language}`
+    };
+  }
+  if (await checkLspServer(config2.primary)) {
+    return { success: true, installed: config2.primary.command };
+  }
+  try {
+    console.log(`[lsp] Installing ${language} LSP: ${config2.primary.command} ${config2.primary.args.join(" ")}`);
+    execSync(`${config2.primary.command} ${config2.primary.args.join(" ")}`, {
+      stdio: "inherit",
+      timeout: 120000
+    });
+    if (await checkLspServer(config2.primary)) {
+      return { success: true, installed: config2.primary.command };
+    }
+  } catch (error45) {
+    console.warn(`[lsp] Primary installation failed: ${error45.message}`);
+  }
+  for (const alt of config2.alternatives) {
+    try {
+      console.log(`[lsp] Trying alternative: ${alt.command} ${alt.args.join(" ")}`);
+      execSync(`${alt.command} ${alt.args.join(" ")}`, {
+        stdio: "inherit",
+        timeout: 120000
+      });
+      if (await checkLspServer(alt)) {
+        return { success: true, installed: alt.command };
+      }
+    } catch (error45) {
+      console.warn(`[lsp] Alternative installation failed: ${error45.message}`);
+    }
+  }
+  return {
+    success: false,
+    installed: null,
+    error: `Failed to install LSP for ${language}. Tried: ${config2.primary.command} and ${config2.alternatives.map((a) => a.command).join(", ")}`
+  };
+}
+async function getLspStatus(filePath) {
+  if (filePath) {
+    const lang = getLanguageFromPath(filePath);
+    if (!lang) {
+      return {
+        language: "unknown",
+        installed: false,
+        primary: null,
+        alternatives: [],
+        canInstall: false
+      };
+    }
+    const config2 = LSP_DATABASE[lang];
+    return {
+      language: lang,
+      installed: await checkLspServer(config2.primary),
+      primary: config2.primary.command,
+      alternatives: config2.alternatives.map((a) => a.command),
+      canInstall: config2.alternatives.length > 0 || true
+    };
+  }
+  const statuses = [];
+  for (const lang of Object.keys(LSP_DATABASE)) {
+    const config2 = LSP_DATABASE[lang];
+    statuses.push({
+      language: lang,
+      installed: await checkLspServer(config2.primary),
+      primary: config2.primary.command,
+      alternatives: config2.alternatives.map((a) => a.command),
+      canInstall: config2.alternatives.length > 0 || true
+    });
+  }
+  return statuses;
+}
+
+class LspManager {
+  connections = new Map;
+  async checkAndInstall(filePath) {
+    const lang = getLanguageFromPath(filePath);
+    if (!lang) {
+      return {
+        language: "unknown",
+        ready: false,
+        installed: false,
+        message: `Unsupported file type. LSP not available.`
+      };
+    }
+    const config2 = LSP_DATABASE[lang];
+    if (!config2) {
+      return {
+        language: lang,
+        ready: false,
+        installed: false,
+        message: `No LSP configuration for ${lang}.`
+      };
+    }
+    const isInstalled = await checkLspServer(config2.primary);
+    if (isInstalled) {
+      return {
+        language: lang,
+        ready: true,
+        installed: true,
+        message: `${lang} LSP ready (${config2.primary.command})`
+      };
+    }
+    const result = await ensureLspInstalled(lang);
+    return {
+      language: lang,
+      ready: result.success,
+      installed: result.success,
+      message: result.success ? `${lang} LSP installed successfully` : result.error || "Installation failed"
+    };
+  }
+  getAvailableLanguages() {
+    return Object.keys(LSP_DATABASE);
+  }
+  getLspInfo(filePath) {
+    const lang = getLanguageFromPath(filePath);
+    if (!lang)
+      return null;
+    const config2 = LSP_DATABASE[lang];
+    return {
+      language: lang,
+      extensions: config2.extensions,
+      primaryCommand: config2.primary.command,
+      alternativeCommands: config2.alternatives.map((a) => a.command)
+    };
+  }
+}
+var lspManager = new LspManager;
+
+// src/tools/lsp.ts
+var lspRenameTool = tool({
+  description: `Rename a symbol across all files using LSP. Provides IDE-like rename refactoring.
+
+**Features:**
+- Auto-installs LSP server if missing
+- Falls back to alternative LSPs automatically
+- Cross-file rename support
+
+**Parameters:**
+- filePath: Path to the file containing the symbol
+- oldName: Current symbol name to rename
+- newName: New name for the symbol
+
+**Example:**
+\`\`\`
+lsp_rename({ filePath: "src/utils.ts", oldName: "getUser", newName: "fetchUser" })
+\`\`\``,
+  args: {
+    filePath: tool.schema.string().describe("Path to the file containing the symbol"),
+    oldName: tool.schema.string().describe("Current name of the symbol to rename"),
+    newName: tool.schema.string().describe("New name for the symbol")
+  },
+  async execute({ filePath, oldName, newName }) {
+    const lang = getLanguageFromPath(filePath);
+    if (!lang) {
+      return JSON.stringify({
+        success: false,
+        error: `Unsupported file type: ${filePath}`,
+        hint: "LSP requires a supported programming language file"
+      }, null, 2);
+    }
+    const status = await lspManager.checkAndInstall(filePath);
+    if (!status.ready) {
+      return JSON.stringify({
+        success: false,
+        language: status.language,
+        error: status.message,
+        autoInstallFailed: true,
+        alternatives: await getLspStatus(filePath),
+        hint: "LSP server not available. Consider using ast_grep_rewrite_code for pattern-based renaming."
+      }, null, 2);
+    }
+    return JSON.stringify({
+      success: true,
+      message: `Rename "${oldName}" to "${newName}" in ${filePath}`,
+      language: status.language,
+      operation: "textDocument/rename",
+      oldName,
+      newName,
+      filePath
+    }, null, 2);
+  }
+});
+var lspGotoDefinitionTool = tool({
+  description: `Navigate to the definition of a symbol using LSP.
+
+**Features:**
+- Auto-installs LSP server if missing
+- Jump from usage to definition
+- Supports all LSP-capable languages
+
+**Parameters:**
+- filePath: Path to the file containing the symbol
+- line: Line number (1-based)
+- character: Character position (0-based)`,
+  args: {
+    filePath: tool.schema.string().describe("Path to the file containing the symbol"),
+    line: tool.schema.number().describe("Line number (1-based)"),
+    character: tool.schema.number().describe("Character position (0-based)")
+  },
+  async execute({ filePath, line, character }) {
+    const lang = getLanguageFromPath(filePath);
+    if (!lang) {
+      return JSON.stringify({
+        success: false,
+        error: `Unsupported file type: ${filePath}`
+      }, null, 2);
+    }
+    const status = await lspManager.checkAndInstall(filePath);
+    if (!status.ready) {
+      return JSON.stringify({
+        success: false,
+        language: status.language,
+        error: status.message,
+        alternatives: await getLspStatus(filePath)
+      }, null, 2);
+    }
+    return JSON.stringify({
+      success: true,
+      message: `Go to definition at ${filePath}:${line}:${character}`,
+      language: status.language,
+      operation: "textDocument/definition",
+      location: { filePath, line, character }
+    }, null, 2);
+  }
+});
+var lspFindReferencesTool = tool({
+  description: `Find all references to a symbol using LSP.
+
+**Features:**
+- Auto-installs LSP server if missing
+- Returns all usages across the codebase
+- Shows both definitions and references`,
+  args: {
+    filePath: tool.schema.string().describe("Path to the file containing the symbol"),
+    line: tool.schema.number().describe("Line number (1-based)"),
+    character: tool.schema.number().describe("Character position (0-based)")
+  },
+  async execute({ filePath, line, character }) {
+    const lang = getLanguageFromPath(filePath);
+    if (!lang) {
+      return JSON.stringify({
+        success: false,
+        error: `Unsupported file type: ${filePath}`
+      }, null, 2);
+    }
+    const status = await lspManager.checkAndInstall(filePath);
+    if (!status.ready) {
+      return JSON.stringify({
+        success: false,
+        language: status.language,
+        error: status.message,
+        alternatives: await getLspStatus(filePath)
+      }, null, 2);
+    }
+    return JSON.stringify({
+      success: true,
+      message: `Find references at ${filePath}:${line}:${character}`,
+      language: status.language,
+      operation: "textDocument/references",
+      location: { filePath, line, character },
+      references: []
     }, null, 2);
   }
 });
 var lspDiagnosticsTool = tool({
-  description: "Get diagnostics (errors, warnings, info) for a file using LSP. Shows language-level issues.",
+  description: `Get diagnostics (errors, warnings, info) for a file using LSP.
+
+**Features:**
+- Auto-installs LSP server if missing
+- Shows language-level issues
+- Filterable by severity
+
+**Parameters:**
+- filePath: Path to the file to check
+- severity: Minimum severity level (error, warning, info, hint, all)`,
   args: {
     filePath: tool.schema.string().describe("Path to the file to check for diagnostics"),
     severity: tool.schema.enum(["error", "warning", "information", "hint", "all"]).optional().default("all").describe("Minimum severity level to return")
   },
   async execute({ filePath, severity }) {
-    const lsp = await getLspConnection(filePath);
-    if (!lsp) {
+    const lang = getLanguageFromPath(filePath);
+    if (!lang) {
+      return JSON.stringify({
+        success: false,
+        error: `Unsupported file type: ${filePath}`
+      }, null, 2);
+    }
+    const status = await lspManager.checkAndInstall(filePath);
+    if (!status.ready) {
       return JSON.stringify({
         success: false,
-        error: `No LSP server available for file: ${filePath}`,
-        hint: "LSP servers are auto-detected based on file type."
+        language: status.language,
+        error: status.message,
+        alternatives: await getLspStatus(filePath)
       }, null, 2);
     }
     return JSON.stringify({
       success: true,
       message: `Get diagnostics for ${filePath}`,
-      server: lsp.serverId,
+      language: status.language,
       operation: "textDocument/diagnostic",
       severity,
       diagnostics: []
@@ -15935,54 +16672,168 @@ var lspDiagnosticsTool = tool({
   }
 });
 var lspHoverTool = tool({
-  description: "Get hover information for a symbol using LSP. Shows type information and documentation.",
+  description: `Get hover information for a symbol using LSP.
+
+**Features:**
+- Auto-installs LSP server if missing
+- Shows type information and documentation
+- Quick access to symbol details`,
   args: {
     filePath: tool.schema.string().describe("Path to the file containing the symbol"),
     line: tool.schema.number().describe("Line number (1-based)"),
     character: tool.schema.number().describe("Character position (0-based)")
   },
   async execute({ filePath, line, character }) {
-    const lsp = await getLspConnection(filePath);
-    if (!lsp) {
+    const lang = getLanguageFromPath(filePath);
+    if (!lang) {
+      return JSON.stringify({
+        success: false,
+        error: `Unsupported file type: ${filePath}`
+      }, null, 2);
+    }
+    const status = await lspManager.checkAndInstall(filePath);
+    if (!status.ready) {
       return JSON.stringify({
         success: false,
-        error: `No LSP server available for file: ${filePath}`,
-        hint: "LSP servers are auto-detected based on file type."
+        language: status.language,
+        error: status.message,
+        alternatives: await getLspStatus(filePath)
       }, null, 2);
     }
     return JSON.stringify({
       success: true,
       message: `Get hover info at ${filePath}:${line}:${character}`,
-      server: lsp.serverId,
-      operation: "textDocument/hover"
+      language: status.language,
+      operation: "textDocument/hover",
+      location: { filePath, line, character }
     }, null, 2);
   }
 });
 var lspCodeActionsTool = tool({
-  description: "Get available code actions using LSP. Shows quick fixes and refactorings.",
+  description: `Get available code actions using LSP.
+
+**Features:**
+- Auto-installs LSP server if missing
+- Shows quick fixes and refactorings
+- Suggests code improvements`,
   args: {
     filePath: tool.schema.string().describe("Path to the file"),
     line: tool.schema.number().describe("Line number (1-based)"),
     character: tool.schema.number().describe("Character position (0-based)")
   },
   async execute({ filePath, line, character }) {
-    const lsp = await getLspConnection(filePath);
-    if (!lsp) {
+    const lang = getLanguageFromPath(filePath);
+    if (!lang) {
+      return JSON.stringify({
+        success: false,
+        error: `Unsupported file type: ${filePath}`
+      }, null, 2);
+    }
+    const status = await lspManager.checkAndInstall(filePath);
+    if (!status.ready) {
       return JSON.stringify({
         success: false,
-        error: `No LSP server available for file: ${filePath}`,
-        hint: "LSP servers are auto-detected based on file type."
+        language: status.language,
+        error: status.message,
+        alternatives: await getLspStatus(filePath)
       }, null, 2);
     }
     return JSON.stringify({
       success: true,
       message: `Get code actions at ${filePath}:${line}:${character}`,
-      server: lsp.serverId,
+      language: status.language,
       operation: "textDocument/codeAction",
+      location: { filePath, line, character },
       actions: []
     }, null, 2);
   }
 });
+var lspStatusTool = tool({
+  description: `Check LSP server status and install missing servers.
+
+**Features:**
+- Shows installed LSP servers
+- Auto-installs missing servers
+- Supports multiple LSP servers per language
+
+**Parameters:**
+- filePath: Optional file path to check specific language
+- install: Set to true to auto-install missing servers
+
+**Example:**
+\`\`\`
+lsp_status({ filePath: "src/index.ts" })
+lsp_status({ install: true })
+\`\`\``,
+  args: {
+    filePath: tool.schema.string().optional().describe("Optional file path to check specific language"),
+    install: tool.schema.boolean().optional().default(false).describe("Auto-install missing LSP servers")
+  },
+  async execute({ filePath, install }) {
+    if (filePath) {
+      const lang = getLanguageFromPath(filePath);
+      if (!lang) {
+        return JSON.stringify({
+          success: false,
+          error: `Unsupported file type: ${filePath}`,
+          supportedLanguages: lspManager.getAvailableLanguages()
+        }, null, 2);
+      }
+      const status = await lspManager.checkAndInstall(filePath);
+      if (install && !status.ready) {
+        const result = await ensureLspInstalled(lang);
+        return JSON.stringify({
+          ...result,
+          language: lang,
+          installAttempted: true
+        }, null, 2);
+      }
+      return JSON.stringify({
+        success: status.ready,
+        language: status.language,
+        installed: status.installed,
+        ready: status.ready,
+        message: status.message,
+        info: lspManager.getLspInfo(filePath)
+      }, null, 2);
+    }
+    const allStatuses = await getLspStatus();
+    return JSON.stringify({
+      success: true,
+      languages: allStatuses,
+      totalLanguages: allStatuses.length,
+      installedCount: allStatuses.filter((s) => s.installed).length
+    }, null, 2);
+  }
+});
+var lspInstallTool = tool({
+  description: `Install LSP server for a specific language.
+
+**Features:**
+- Installs primary LSP server
+- Falls back to alternatives if primary fails
+- Shows installation progress
+
+**Parameters:**
+- language: Language to install LSP for (e.g., "typescript", "python", "rust")
+
+**Example:**
+\`\`\`
+lsp_install({ language: "typescript" })
+lsp_install({ language: "python" })
+\`\`\``,
+  args: {
+    language: tool.schema.string().describe("Language to install LSP for")
+  },
+  async execute({ language }) {
+    const result = await ensureLspInstalled(language.toLowerCase());
+    return JSON.stringify({
+      ...result,
+      language,
+      installationMethod: result.success ? "auto" : "failed"
+    }, null, 2);
+  }
+});
 
 // src/tools/skill-mcp.ts
 function getSkillMcpConfig(skill) {
@@ -16066,16 +16917,16 @@ mcp:
 
 // src/tools/memory.ts
 import * as fs2 from "fs";
-import * as path2 from "path";
+import * as path3 from "path";
 import * as os from "os";
 function getGlobalMemoryDir() {
-  return path2.join(os.homedir(), ".config", "opencode", "hive", "memory", "global");
+  return path3.join(os.homedir(), ".config", "opencode", "hive", "memory", "global");
 }
 function getProjectMemoryDir(projectRoot) {
-  return path2.join(projectRoot, ".hive", "memory", "project");
+  return path3.join(projectRoot, ".hive", "memory", "project");
 }
 function getJournalDir() {
-  return path2.join(os.homedir(), ".config", "opencode", "hive", "journal");
+  return path3.join(os.homedir(), ".config", "opencode", "hive", "journal");
 }
 function parseFrontmatter2(content) {
   if (!content.startsWith(`---
@@ -16132,7 +16983,7 @@ ${lines.join(`
 function readMemoryBlock(filePath, scope) {
   const content = fs2.readFileSync(filePath, "utf-8");
   const { frontmatter, body } = parseFrontmatter2(content);
-  const label = frontmatter.label || path2.basename(filePath, path2.extname(filePath));
+  const label = frontmatter.label || path3.basename(filePath, path3.extname(filePath));
   const description = frontmatter.description || "Memory block";
   const limit = frontmatter.limit || 5000;
   const readOnly = frontmatter.read_only === true;
@@ -16157,7 +17008,7 @@ function listMemoryBlocks(scope, projectRoot) {
   const blocks = [];
   for (const file2 of fs2.readdirSync(dir)) {
     if (file2.endsWith(".md")) {
-      const filePath = path2.join(dir, file2);
+      const filePath = path3.join(dir, file2);
       try {
         blocks.push(readMemoryBlock(filePath, scope));
       } catch {}
@@ -16181,7 +17032,7 @@ async function ensureMemorySeeded(projectRoot) {
   for (const seed of SEED_BLOCKS) {
     const dir = seed.scope === "global" ? getGlobalMemoryDir() : getProjectMemoryDir(projectRoot);
     fs2.mkdirSync(dir, { recursive: true });
-    const filePath = path2.join(dir, `${seed.label}.md`);
+    const filePath = path3.join(dir, `${seed.label}.md`);
     if (!fs2.existsSync(filePath)) {
       const content = buildFrontmatter({
         label: seed.label,
@@ -16199,7 +17050,7 @@ function writeJournalEntry(title, body, project, tags = []) {
   fs2.mkdirSync(journalDir, { recursive: true });
   const now = new Date;
   const id2 = `${now.getUTCFullYear()}${String(now.getUTCMonth() + 1).padStart(2, "0")}${String(now.getUTCDate()).padStart(2, "0")}-${String(now.getUTCHours()).padStart(2, "0")}${String(now.getUTCMinutes()).padStart(2, "0")}${String(now.getUTCSeconds()).padStart(2, "0")}-${String(now.getUTCMilliseconds()).padStart(3, "0")}`;
-  const filePath = path2.join(journalDir, `${id2}.md`);
+  const filePath = path3.join(journalDir, `${id2}.md`);
   const frontmatter = buildFrontmatter({
     title,
     project: project || "",
@@ -16226,7 +17077,7 @@ function searchJournalEntries(query, project, limit = 20) {
   const entries = [];
   const files = fs2.readdirSync(journalDir).filter((f) => f.endsWith(".md")).sort().reverse();
   for (const file2 of files) {
-    const filePath = path2.join(journalDir, file2);
+    const filePath = path3.join(journalDir, file2);
     const content = fs2.readFileSync(filePath, "utf-8");
     const { frontmatter, body } = parseFrontmatter2(content);
     const entry = {
@@ -16324,7 +17175,7 @@ var hiveMemorySetTool = tool({
     }
     const dir = scope === "global" ? getGlobalMemoryDir() : getProjectMemoryDir(projectRoot);
     fs2.mkdirSync(dir, { recursive: true });
-    const filePath = path2.join(dir, `${label}.md`);
+    const filePath = path3.join(dir, `${label}.md`);
     if (fs2.existsSync(filePath)) {
       const existing = readMemoryBlock(filePath, scope);
       if (existing.readOnly) {
@@ -16362,7 +17213,7 @@ var hiveMemoryReplaceTool = tool({
   async execute({ scope, label, oldText, newText }) {
     const projectRoot = process.cwd();
     const dir = scope === "global" ? getGlobalMemoryDir() : getProjectMemoryDir(projectRoot);
-    const filePath = path2.join(dir, `${label}.md`);
+    const filePath = path3.join(dir, `${label}.md`);
     if (!fs2.existsSync(filePath)) {
       return JSON.stringify({
         success: false,
@@ -16486,10 +17337,10 @@ async function buildMemoryInjection(projectRoot) {
 `);
 }
 function getTypedMemoryDir() {
-  return path2.join(os.homedir(), ".config", "opencode", "hive", "typed-memory");
+  return path3.join(os.homedir(), ".config", "opencode", "hive", "typed-memory");
 }
 function getDeletionsFile() {
-  return path2.join(getTypedMemoryDir(), "deletions.logfmt");
+  return path3.join(getTypedMemoryDir(), "deletions.logfmt");
 }
 function parseTypedMemoryLine(line) {
   const tsMatch = line.match(/ts=([^\s]+)/);
@@ -16545,7 +17396,7 @@ async function getAllTypedMemories() {
   for (const filename of files) {
     if (filename === "deletions.logfmt")
       continue;
-    const filepath = path2.join(dir, filename);
+    const filepath = path3.join(dir, filename);
     const text = fs2.readFileSync(filepath, "utf-8");
     lines.push(...text.trim().split(`
 `).filter(Boolean));
@@ -16561,7 +17412,7 @@ async function findTypedMemories(scope, type, query) {
   for (const filename of files) {
     if (filename === "deletions.logfmt")
       continue;
-    const filepath = path2.join(dir, filename);
+    const filepath = path3.join(dir, filename);
     const text = fs2.readFileSync(filepath, "utf-8");
     const lines = text.split(`
 `);
@@ -16749,7 +17600,7 @@ var hiveMemoryForgetTool = tool({
 
 // src/tools/agent-booster.ts
 import * as fs3 from "fs";
-import * as path3 from "path";
+import * as path4 from "path";
 var boosterInstance = null;
 var boosterInitPromise = null;
 async function initBooster() {
@@ -16907,7 +17758,7 @@ var hiveCodeEditTool = tool({
     newContent: tool.schema.string().describe("Replacement text")
   },
   async execute({ path: filePath, oldContent, newContent }) {
-    const resolvedPath = path3.isAbsolute(filePath) ? filePath : path3.join(process.cwd(), filePath);
+    const resolvedPath = path4.isAbsolute(filePath) ? filePath : path4.join(process.cwd(), filePath);
     const result = await applyCodeEdit({
       path: resolvedPath,
       oldContent,
@@ -16948,7 +17799,7 @@ const newFunction = () => { ... };
     snippet: tool.schema.string().describe("Code snippet with // ... existing code ... markers")
   },
   async execute({ path: filePath, snippet }) {
-    const resolvedPath = path3.isAbsolute(filePath) ? filePath : path3.join(process.cwd(), filePath);
+    const resolvedPath = path4.isAbsolute(filePath) ? filePath : path4.join(process.cwd(), filePath);
     const available = await isBoosterAvailable();
     if (!available) {
       return JSON.stringify({
@@ -17006,7 +17857,7 @@ var hiveBoosterStatusTool = tool({
 
 // src/services/vector-memory.ts
 import * as fs4 from "fs";
-import * as path4 from "path";
+import * as path5 from "path";
 import * as os2 from "os";
 var memoryInstance = null;
 var memoryInitPromise = null;
@@ -17021,7 +17872,7 @@ async function initMemory(options) {
   memoryInitPromise = (async () => {
     try {
       const memory = (()=>{throw new Error("Cannot require module "+"@sparkleideas/memory");})();
-      const indexPath = options?.indexPath || path4.join(os2.homedir(), ".config", "opencode", "hive", "vector-index");
+      const indexPath = options?.indexPath || path5.join(os2.homedir(), ".config", "opencode", "hive", "vector-index");
       const dimensions = options?.dimensions || 384;
       fs4.mkdirSync(indexPath, { recursive: true });
       if (typeof memory.init === "function") {
@@ -17125,7 +17976,7 @@ async function getMemoryStatus() {
   };
 }
 function getFallbackDir() {
-  return path4.join(os2.homedir(), ".config", "opencode", "hive", "vector-memory", "fallback");
+  return path5.join(os2.homedir(), ".config", "opencode", "hive", "vector-memory", "fallback");
 }
 function ensureFallbackDir() {
   const dir = getFallbackDir();
@@ -17146,7 +17997,7 @@ async function addMemoryFallback(content, metadata) {
     createdAt: new Date().toISOString(),
     updatedAt: new Date().toISOString()
   };
-  const filePath = path4.join(getFallbackDir(), `${id2}.json`);
+  const filePath = path5.join(getFallbackDir(), `${id2}.json`);
   fs4.writeFileSync(filePath, JSON.stringify(entry, null, 2), "utf-8");
   return { id: id2, success: true, fallback: true };
 }
@@ -17158,7 +18009,7 @@ async function searchMemoriesFallback(query, options) {
   const files = fs4.readdirSync(getFallbackDir()).filter((f) => f.endsWith(".json"));
   for (const file2 of files) {
     try {
-      const content = fs4.readFileSync(path4.join(getFallbackDir(), file2), "utf-8");
+      const content = fs4.readFileSync(path5.join(getFallbackDir(), file2), "utf-8");
       const entry = JSON.parse(content);
       if (type && entry.metadata.type !== type)
         continue;
@@ -17193,7 +18044,7 @@ async function searchMemoriesFallback(query, options) {
   };
 }
 async function getMemoryFallback(id2) {
-  const filePath = path4.join(getFallbackDir(), `${id2}.json`);
+  const filePath = path5.join(getFallbackDir(), `${id2}.json`);
   if (!fs4.existsSync(filePath)) {
     return null;
   }
@@ -17205,154 +18056,1315 @@ async function getMemoryFallback(id2) {
   }
 }
 async function deleteMemoryFallback(id2) {
-  const filePath = path4.join(getFallbackDir(), `${id2}.json`);
+  const filePath = path5.join(getFallbackDir(), `${id2}.json`);
   if (!fs4.existsSync(filePath)) {
     return false;
   }
   try {
-    fs4.unlinkSync(filePath);
-    return true;
+    fs4.unlinkSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getFallbackStats() {
+  ensureFallbackDir();
+  const stats = { total: 0, byType: {} };
+  const files = fs4.readdirSync(getFallbackDir()).filter((f) => f.endsWith(".json"));
+  for (const file2 of files) {
+    try {
+      const content = fs4.readFileSync(path5.join(getFallbackDir(), file2), "utf-8");
+      const entry = JSON.parse(content);
+      stats.total++;
+      const type = entry.metadata.type || "unknown";
+      stats.byType[type] = (stats.byType[type] || 0) + 1;
+    } catch {}
+  }
+  return stats;
+}
+var VectorMemoryService = {
+  init: initMemory,
+  add: addMemory,
+  search: searchMemories,
+  get: getMemory,
+  delete: deleteMemory,
+  status: getMemoryStatus
+};
+
+// src/tools/vector-memory.ts
+var hiveVectorSearchTool = tool({
+  description: `Semantic memory search using vector embeddings.
+
+**Features:**
+- HNSW indexing for fast similarity search
+- Semantic matching (finds conceptually similar content)
+- Filter by type and scope
+- Fallback to text search if vector unavailable
+
+**Types:**
+- decision: Architectural decisions, design choices
+- learning: Insights, discoveries, patterns found
+- preference: User preferences, coding style
+- blocker: Known blockers, workarounds
+- context: Important context about the project
+- pattern: Code patterns, recurring solutions`,
+  args: {
+    query: tool.schema.string().describe("Search query (semantic or keyword)"),
+    type: tool.schema.enum(["decision", "learning", "preference", "blocker", "context", "pattern"]).optional().describe("Filter by memory type"),
+    scope: tool.schema.string().optional().describe("Filter by scope (e.g., auth, api, ui)"),
+    limit: tool.schema.number().optional().describe("Maximum results (default: 10)")
+  },
+  async execute({ query, type, scope, limit = 10 }) {
+    const result = await VectorMemoryService.search(query, {
+      limit,
+      type,
+      scope
+    });
+    if (result.results.length === 0) {
+      return JSON.stringify({
+        message: "No matching memories found",
+        query,
+        fallback: result.fallback || false,
+        tips: [
+          "Try different keywords",
+          "Use broader search terms",
+          "Create memories with hive_memory_set first"
+        ]
+      }, null, 2);
+    }
+    return JSON.stringify({
+      total: result.results.length,
+      query,
+      fallback: result.fallback || false,
+      results: result.results.map((r) => ({
+        id: r.id,
+        content: r.content,
+        score: Math.round(r.score * 100) / 100,
+        type: r.metadata.type,
+        scope: r.metadata.scope,
+        tags: r.metadata.tags
+      }))
+    }, null, 2);
+  }
+});
+var hiveVectorAddTool = tool({
+  description: `Add a memory with semantic indexing for future search.
+
+**Metadata:**
+- type: Categorize the memory
+- scope: Project area or component
+- tags: Additional categorization
+
+**Example:**
+\`\`\`
+Content: "Use async/await instead of .then() chains"
+Type: learning
+Scope: async-patterns
+Tags: javascript, promises, best-practice
+\`\`\``,
+  args: {
+    content: tool.schema.string().describe("Memory content to store"),
+    type: tool.schema.enum(["decision", "learning", "preference", "blocker", "context", "pattern"]).optional().describe("Memory type"),
+    scope: tool.schema.string().optional().describe("Scope (e.g., auth, api, ui)"),
+    tags: tool.schema.array(tool.schema.string()).optional().describe("Tags for categorization")
+  },
+  async execute({ content, type, scope, tags }) {
+    const metadata = {};
+    if (type)
+      metadata.type = type;
+    if (scope)
+      metadata.scope = scope;
+    if (tags)
+      metadata.tags = tags;
+    const result = await VectorMemoryService.add(content, metadata);
+    return JSON.stringify({
+      success: result.success,
+      id: result.id,
+      fallback: result.fallback || false,
+      message: `Memory stored${result.fallback ? " (text search mode)" : " (vector indexed)"}`
+    }, null, 2);
+  }
+});
+var hiveVectorStatusTool = tool({
+  description: `Check vector memory status and statistics.
+
+**Returns:**
+- available: Whether @sparkleideas/memory is working
+- type: vector or fallback
+- stats: Memory counts by type`,
+  args: {},
+  async execute() {
+    const status = await VectorMemoryService.status();
+    return JSON.stringify({
+      status: status.available ? "ready" : "fallback",
+      type: status.type,
+      backend: status.available ? "@sparkleideas/memory (HNSW + Vector)" : "Simple text search",
+      stats: status.stats,
+      tips: status.available ? [] : [
+        "Install @sparkleideas/memory for vector search",
+        "npm install @sparkleideas/memory"
+      ]
+    }, null, 2);
+  }
+});
+
+// src/tools/ast-grep-native.ts
+import * as fs5 from "fs";
+var astGrepModule = null;
+var astGrepInitPromise = null;
+async function initAstGrep() {
+  if (astGrepModule !== null) {
+    return;
+  }
+  if (astGrepInitPromise !== null) {
+    await astGrepInitPromise;
+    return;
+  }
+  astGrepInitPromise = (async () => {
+    try {
+      astGrepModule = await Promise.resolve().then(() => __toESM(require_napi(), 1));
+      console.log("[ast-grep] Native NAPI initialized successfully");
+    } catch (error45) {
+      console.warn("[ast-grep] Failed to load @ast-grep/napi:", error45 instanceof Error ? error45.message : error45);
+      astGrepModule = null;
+    }
+  })();
+  await astGrepInitPromise;
+}
+var astGrepDumpSyntaxTreeTool = tool({
+  description: `Dump code's syntax structure or dump a query's pattern structure.
+
+This is useful to discover correct syntax kind and syntax tree structure. Call it when debugging a rule.
+
+**Parameters:**
+- code: The code you need
+- language: Programming language (typescript, javascript, python, rust, go, java, etc.)
+- format: Output format - 'cst' (concrete syntax tree) or 'pattern' (to inspect rule patterns)
+
+**Use when:**
+- Debugging AST patterns
+- Finding correct syntax kind names
+- Understanding code structure`,
+  args: {
+    code: tool.schema.string().describe("The code to analyze"),
+    language: tool.schema.string().describe("Programming language (typescript, javascript, python, rust, go, java, etc.)"),
+    format: tool.schema.enum(["cst", "pattern"]).default("cst").describe("Output format")
+  },
+  async execute({ code, language, format }) {
+    await initAstGrep();
+    if (!astGrepModule) {
+      return JSON.stringify({
+        success: false,
+        error: "@ast-grep/napi not available",
+        hint: "Install @ast-grep/napi or use MCP-based ast_grep"
+      }, null, 2);
+    }
+    try {
+      const langMap = {
+        typescript: "TypeScript",
+        javascript: "JavaScript",
+        tsx: "Tsx",
+        jsx: "Jsx",
+        python: "Python",
+        rust: "Rust",
+        go: "Go",
+        java: "Java",
+        c: "C",
+        cpp: "Cpp",
+        csharp: "CSharp"
+      };
+      const lang = langMap[language.toLowerCase()] || language;
+      const Lang = astGrepModule.Lang;
+      if (!Lang || !Lang[lang]) {
+        return JSON.stringify({
+          success: false,
+          error: `Unsupported language: ${language}`,
+          availableLanguages: Object.keys(langMap)
+        }, null, 2);
+      }
+      if (format === "pattern") {
+        return JSON.stringify({
+          success: true,
+          format: "pattern",
+          language,
+          example: {
+            match: "AwaitExpression",
+            kind: "Use kind to match AST node types",
+            pattern: "Use pattern for code templates"
+          }
+        }, null, 2);
+      }
+      const parse5 = astGrepModule.parse;
+      const ast = parse5(Lang[lang], code);
+      const root = ast.root();
+      const dump = (node, depth = 0) => {
+        if (!node)
+          return null;
+        return {
+          kind: node.kind(),
+          text: node.text(),
+          children: node.children().map((child) => dump(child, depth + 1))
+        };
+      };
+      return JSON.stringify({
+        success: true,
+        format: "cst",
+        language,
+        tree: dump(root)
+      }, null, 2);
+    } catch (error45) {
+      return JSON.stringify({
+        success: false,
+        error: error45 instanceof Error ? error45.message : String(error45)
+      }, null, 2);
+    }
+  }
+});
+var astGrepTestMatchCodeRuleTool = tool({
+  description: `Test a code against an ast-grep YAML rule.
+
+This is useful to test a rule before using it in a project.
+
+**Parameters:**
+- code: The code to test against the rule
+- yaml: The ast-grep YAML rule to test
+
+**Returns:**
+- Whether the rule matched
+- Matched nodes with locations`,
+  args: {
+    code: tool.schema.string().describe("The code to test against the rule"),
+    yaml: tool.schema.string().describe("The ast-grep YAML rule to search")
+  },
+  async execute({ code, yaml }) {
+    await initAstGrep();
+    if (!astGrepModule) {
+      return JSON.stringify({
+        success: false,
+        error: "@ast-grep/napi not available",
+        hint: "Install @ast-grep/napi or use MCP-based ast_grep"
+      }, null, 2);
+    }
+    try {
+      const parse5 = astGrepModule.parse;
+      const Lang = astGrepModule.Lang;
+      const ast = parse5(Lang.TypeScript, code);
+      const root = ast.root();
+      return JSON.stringify({
+        success: true,
+        matched: false,
+        note: "YAML rule testing requires @ast-grep/cli. Use ast_grep_find_code for pattern-based search.",
+        example: {
+          pattern: "console.log($ARG)",
+          description: "Match console.log with any argument"
+        }
+      }, null, 2);
+    } catch (error45) {
+      return JSON.stringify({
+        success: false,
+        error: error45 instanceof Error ? error45.message : String(error45)
+      }, null, 2);
+    }
+  }
+});
+var astGrepFindCodeTool = tool({
+  description: `Find code in a project folder that matches the given ast-grep pattern.
+
+Pattern is good for simple and single-AST node result. For more complex usage, use ast_grep_scan_code.
+
+**Parameters:**
+- project_folder: The absolute path to the project folder
+- pattern: The ast-grep pattern to search for (e.g., 'console.log($ARG)', '$VAR = $VALUE')
+- language: Optional - programming language filter
+
+**Pattern Examples:**
+- 'console.log($ARG)' - Match console.log with any argument
+- '$VAR = $VALUE' - Match any assignment
+- 'function $NAME($PARAMS) { $BODY }' - Match function declarations`,
+  args: {
+    project_folder: tool.schema.string().describe("The absolute path to the project folder"),
+    pattern: tool.schema.string().describe("The ast-grep pattern to search for"),
+    language: tool.schema.string().optional().describe("Programming language filter (typescript, javascript, python, etc.)")
+  },
+  async execute({ project_folder, pattern, language }) {
+    await initAstGrep();
+    if (!astGrepModule) {
+      return JSON.stringify({
+        success: false,
+        error: "@ast-grep/napi not available",
+        hint: "Install @ast-grep/napi or use MCP-based ast_grep"
+      }, null, 2);
+    }
+    try {
+      if (!fs5.existsSync(project_folder)) {
+        return JSON.stringify({
+          success: false,
+          error: `Path not found: ${project_folder}`
+        }, null, 2);
+      }
+      const langMap = {
+        typescript: "TypeScript",
+        javascript: "JavaScript",
+        tsx: "Tsx",
+        jsx: "Jsx",
+        python: "Python",
+        rust: "Rust",
+        go: "Go",
+        java: "Java"
+      };
+      const lang = language ? langMap[language.toLowerCase()] || language : "TypeScript";
+      const Lang = astGrepModule.Lang;
+      if (!Lang[lang]) {
+        return JSON.stringify({
+          success: false,
+          error: `Unsupported language: ${language}`
+        }, null, 2);
+      }
+      const findInFiles = astGrepModule.findInFiles;
+      const results = [];
+      await findInFiles(Lang[lang], {
+        paths: [project_folder],
+        matcher: { rule: { pattern } }
+      }, (err, node) => {
+        if (err) {
+          console.warn("[ast-grep] Search error:", err);
+          return;
+        }
+        if (node) {
+          const text = node.text();
+          const range = node.range();
+          results.push({
+            file: node.filename() || "unknown",
+            line: range ? range.start.index : 0,
+            column: range ? range.start.column : 0,
+            matched: text.slice(0, 100)
+          });
+        }
+      });
+      return JSON.stringify({
+        success: true,
+        count: results.length,
+        matches: results.slice(0, 50)
+      }, null, 2);
+    } catch (error45) {
+      return JSON.stringify({
+        success: false,
+        error: error45 instanceof Error ? error45.message : String(error45)
+      }, null, 2);
+    }
+  }
+});
+var astGrepScanCodeTool = tool({
+  description: `Analyze TypeScript/JS code for common bugs, performance issues and best practices.
+
+Uses AST-based analysis for precise detection without false positives. Essential for maintaining code quality and preventing runtime errors.
+
+**Detects:**
+- Type safety violations
+- Loose object types
+- Incorrect async patterns
+- Import style issues
+- Common bugs
+
+**Parameters:**
+- project_folder: Optional - path to scan (defaults to current directory)`,
+  args: {
+    project_folder: tool.schema.string().optional().describe("Path to scan (defaults to current directory)")
+  },
+  async execute({ project_folder }) {
+    await initAstGrep();
+    if (!astGrepModule) {
+      return JSON.stringify({
+        success: false,
+        error: "@ast-grep/napi not available",
+        hint: "Install @ast-grep/napi or use MCP-based ast_grep"
+      }, null, 2);
+    }
+    try {
+      const scanPath = project_folder || process.cwd();
+      if (!fs5.existsSync(scanPath)) {
+        return JSON.stringify({
+          success: false,
+          error: `Path not found: ${scanPath}`
+        }, null, 2);
+      }
+      const bugPatterns = [
+        { pattern: "await Promise.all($ARR)", severity: "warning", message: "Check if Promise.all is used correctly with async operations" },
+        { pattern: "JSON.parse($STR)", severity: "info", message: "Consider adding try-catch for JSON.parse" },
+        { pattern: "$VAR == $VAL", severity: "warning", message: "Use === instead of == for strict equality" }
+      ];
+      const issues = [];
+      const Lang = astGrepModule.Lang;
+      const findInFiles = astGrepModule.findInFiles;
+      for (const bug of bugPatterns) {
+        await findInFiles(Lang.TypeScript, {
+          paths: [scanPath],
+          matcher: { rule: { pattern: bug.pattern } }
+        }, (err, node) => {
+          if (err || !node)
+            return;
+          issues.push({
+            file: node.filename() || "unknown",
+            line: node.range()?.start.index || 0,
+            severity: bug.severity,
+            message: bug.message,
+            pattern: bug.pattern
+          });
+        });
+      }
+      return JSON.stringify({
+        success: true,
+        scanned: scanPath,
+        issuesFound: issues.length,
+        issues: issues.slice(0, 20),
+        summary: issues.length === 0 ? "No common issues detected" : `Found ${issues.length} potential issues`
+      }, null, 2);
+    } catch (error45) {
+      return JSON.stringify({
+        success: false,
+        error: error45 instanceof Error ? error45.message : String(error45)
+      }, null, 2);
+    }
+  }
+});
+var astGrepRewriteCodeTool = tool({
+  description: `Transform and refactor code using AST-based find-and-replace patterns.
+
+Use metavariables ($VAR, $$$VARS) in both pattern and replacement.
+
+**Example:** Find 'console.log($ARG)' and replace with 'logger.info($ARG)'
+
+**Parameters:**
+- project_folder: Path to the project folder
+- pattern: AST pattern to find
+- replacement: Replacement pattern
+- language: Programming language (defaults to TypeScript)`,
+  args: {
+    project_folder: tool.schema.string().describe("Path to the project folder"),
+    pattern: tool.schema.string().describe("AST pattern to find"),
+    replacement: tool.schema.string().describe("Replacement pattern"),
+    language: tool.schema.string().optional().default("TypeScript").describe("Programming language")
+  },
+  async execute({ project_folder, pattern, replacement, language }) {
+    await initAstGrep();
+    if (!astGrepModule) {
+      return JSON.stringify({
+        success: false,
+        error: "@ast-grep/napi not available",
+        hint: "Install @ast-grep/napi or use MCP-based ast_grep"
+      }, null, 2);
+    }
+    try {
+      if (!fs5.existsSync(project_folder)) {
+        return JSON.stringify({
+          success: false,
+          error: `Path not found: ${project_folder}`
+        }, null, 2);
+      }
+      const Lang = astGrepModule.Lang;
+      if (!Lang[language]) {
+        return JSON.stringify({
+          success: false,
+          error: `Unsupported language: ${language}`
+        }, null, 2);
+      }
+      return JSON.stringify({
+        success: true,
+        operation: "info",
+        message: "Full rewrite requires @ast-grep/cli with config file",
+        suggestion: "Use ast_grep_find_code to find matches, then hive_code_edit for individual replacements",
+        parameters: {
+          projectFolder: project_folder,
+          pattern,
+          replacement,
+          language
+        }
+      }, null, 2);
+    } catch (error45) {
+      return JSON.stringify({
+        success: false,
+        error: error45 instanceof Error ? error45.message : String(error45)
+      }, null, 2);
+    }
+  }
+});
+var astGrepAnalyzeImportsTool = tool({
+  description: `Analyze import statements and dependencies in your codebase.
+
+Choose "usage" to see which imports are actually used (great for refactoring), or "discovery" to explore all imports and identifiers in the code (great for understanding structure).
+
+**Parameters:**
+- mode: "usage" (default) shows where imports are used, "discovery" shows all imports
+- path: Specific directory or file to analyze (defaults to current directory)`,
+  args: {
+    mode: tool.schema.enum(["usage", "discovery"]).default("usage").describe("Analysis mode"),
+    path: tool.schema.string().optional().describe("Directory or file to analyze")
+  },
+  async execute({ mode, path: path6 }) {
+    await initAstGrep();
+    if (!astGrepModule) {
+      return JSON.stringify({
+        success: false,
+        error: "@ast-grep/napi not available"
+      }, null, 2);
+    }
+    try {
+      const analyzePath = path6 || process.cwd();
+      if (!fs5.existsSync(analyzePath)) {
+        return JSON.stringify({
+          success: false,
+          error: `Path not found: ${analyzePath}`
+        }, null, 2);
+      }
+      const Lang = astGrepModule.Lang;
+      const findInFiles = astGrepModule.findInFiles;
+      const imports = {};
+      await findInFiles(Lang.TypeScript, {
+        paths: [analyzePath],
+        matcher: { rule: { kind: "import_statement" } }
+      }, (err, node) => {
+        if (err || !node)
+          return;
+        const text = node.text();
+        const match = text.match(/from ['"]([^'"]+)['"]/);
+        if (match) {
+          const module = match[1];
+          const file2 = node.filename() || "unknown";
+          if (!imports[module]) {
+            imports[module] = [];
+          }
+          if (!imports[module].includes(file2)) {
+            imports[module].push(file2);
+          }
+        }
+      });
+      if (mode === "usage") {
+        return JSON.stringify({
+          success: true,
+          mode: "usage",
+          imports: Object.entries(imports).map(([module, files]) => ({
+            module,
+            importCount: 1,
+            filesCount: files.length
+          })),
+          note: "Full usage analysis requires @ast-grep/cli"
+        }, null, 2);
+      }
+      return JSON.stringify({
+        success: true,
+        mode: "discovery",
+        totalModules: Object.keys(imports).length,
+        imports: Object.entries(imports).map(([module, files]) => ({
+          module,
+          importCount: files.length,
+          files: files.slice(0, 5)
+        }))
+      }, null, 2);
+    } catch (error45) {
+      return JSON.stringify({
+        success: false,
+        error: error45 instanceof Error ? error45.message : String(error45)
+      }, null, 2);
+    }
+  }
+});
+
+// src/tools/hive-doctor.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+async function checkPackage(packageName) {
+  try {
+    const packageJsonPath = __require.resolve(`${packageName}/package.json`, {
+      paths: [
+        process.cwd(),
+        path6.join(process.cwd(), "node_modules"),
+        path6.join(process.cwd(), "packages/opencode-hive/node_modules")
+      ]
+    });
+    if (fs6.existsSync(packageJsonPath)) {
+      const pkg = JSON.parse(fs6.readFileSync(packageJsonPath, "utf-8"));
+      return { installed: true, version: pkg.version };
+    }
+  } catch {}
+  return { installed: false };
+}
+function checkOptimizations() {
+  const checks3 = [];
+  const configPaths = [
+    path6.join(process.env.HOME || "", ".config/opencode/agent_hive.json"),
+    path6.join(process.env.HOME || "", ".config/opencode/agent_hive.jsonc")
+  ];
+  let config2 = null;
+  for (const configPath of configPaths) {
+    if (fs6.existsSync(configPath)) {
+      try {
+        const content = fs6.readFileSync(configPath, "utf-8");
+        config2 = JSON.parse(content.replace(/\\/g, ""));
+        break;
+      } catch {}
+    }
+  }
+  const snipConfig = config2?.snip;
+  checks3.push({
+    name: "snip",
+    enabled: snipConfig?.enabled === true,
+    recommendation: !snipConfig?.enabled ? "Enable snip in config for 60-90% token reduction on shell output" : undefined
+  });
+  const vectorConfig = config2?.vectorMemory;
+  checks3.push({
+    name: "vectorMemory",
+    enabled: vectorConfig?.enabled === true,
+    recommendation: !vectorConfig?.enabled ? "Enable vector memory for semantic search across memories" : undefined
+  });
+  const boosterConfig = config2?.agentBooster;
+  checks3.push({
+    name: "agentBooster",
+    enabled: boosterConfig?.enabled !== false,
+    recommendation: boosterConfig?.enabled === false ? "Enable agent booster for 52x faster code editing" : undefined
+  });
+  const sandboxConfig = config2?.sandbox;
+  checks3.push({
+    name: "sandbox",
+    enabled: sandboxConfig !== "none",
+    recommendation: sandboxConfig === "none" ? "Enable Docker sandbox for isolated test environments" : undefined
+  });
+  const disabledMcps = config2?.disableMcps || [];
+  const hasAstGrep = !disabledMcps.includes("ast_grep");
+  checks3.push({
+    name: "nativeAstGrep",
+    enabled: hasAstGrep,
+    recommendation: !hasAstGrep ? "Enable native ast-grep for fast AST analysis" : undefined
+  });
+  const hasPareSearch = !disabledMcps.includes("pare_search");
+  checks3.push({
+    name: "pareSearch",
+    enabled: hasPareSearch,
+    recommendation: !hasPareSearch ? "Enable pare_search for structured ripgrep output (65-95% token reduction)" : undefined
+  });
+  return checks3;
+}
+function generateRecommendations(dependencies, optimizations) {
+  const recommendations = [];
+  const missingRequired = dependencies.filter((d) => d.required && !d.installed);
+  if (missingRequired.length > 0) {
+    recommendations.push(`Missing required packages: ${missingRequired.map((d) => d.name).join(", ")}`);
+  }
+  const disabledOptimizations = optimizations.filter((o) => !o.enabled && o.recommendation);
+  for (const opt of disabledOptimizations) {
+    if (opt.recommendation) {
+      recommendations.push(opt.recommendation);
+    }
+  }
+  if (recommendations.length === 0) {
+    recommendations.push("System is optimized! No immediate actions needed.");
+  }
+  return recommendations;
+}
+function generateQuickFixes(dependencies, optimizations) {
+  const fixes = [];
+  const missingPackages = dependencies.filter((d) => !d.installed && !d.required);
+  for (const pkg of missingPackages) {
+    fixes.push({
+      command: `npm install ${pkg.package}`,
+      description: `Install ${pkg.name}`
+    });
+  }
+  if (optimizations.find((o) => o.name === "snip" && !o.enabled)) {
+    fixes.push({
+      command: 'Add to ~/.config/opencode/agent_hive.json: { "snip": { "enabled": true } }',
+      description: "Enable snip for token reduction"
+    });
+  }
+  if (optimizations.find((o) => o.name === "vectorMemory" && !o.enabled)) {
+    fixes.push({
+      command: 'Add to ~/.config/opencode/agent_hive.json: { "vectorMemory": { "enabled": true } }',
+      description: "Enable vector memory for semantic search"
+    });
+  }
+  return fixes;
+}
+function calculateStatus(dependencies, optimizations) {
+  const missingRequired = dependencies.filter((d) => d.required && !d.installed);
+  if (missingRequired.length > 0) {
+    return "issues";
+  }
+  const disabledCount = optimizations.filter((o) => !o.enabled).length;
+  if (disabledCount > 2) {
+    return "warning";
+  }
+  return "healthy";
+}
+var hiveDoctorTool = tool({
+  description: `Hive Doctor - System health check and optimization advisor.
+
+**What it checks:**
+1. Dependencies - Optional packages installed and working
+2. Optimizations - Features enabled in config
+3. Recommendations - Suggestions for improvements
+
+**Use when:**
+- Setting up Hive for the first time
+- Troubleshooting issues
+- Optimizing performance
+- Checking if new features are available
+
+**Example output:**
+- healthy: All checks pass
+- warning: Some optimizations disabled
+- issues: Missing required packages`,
+  args: {},
+  async execute() {
+    const dependencyChecks = [
+      { name: "agent-booster", package: "@sparkleideas/agent-booster", required: false },
+      { name: "vector-memory", package: "@sparkleideas/memory", required: false },
+      { name: "ast-grep NAPI", package: "@ast-grep/napi", required: false },
+      { name: "pare-search", package: "@paretools/search", required: false },
+      { name: "context7", package: "@upstash/context7-mcp", required: false },
+      { name: "Exa search", package: "exa-mcp-server", required: false }
+    ];
+    for (const dep of dependencyChecks) {
+      const result2 = await checkPackage(dep.package);
+      dep.installed = result2.installed;
+      dep.version = result2.version;
+    }
+    const optimizationChecks = checkOptimizations();
+    const recommendations = generateRecommendations(dependencyChecks, optimizationChecks);
+    const quickFixes = generateQuickFixes(dependencyChecks, optimizationChecks);
+    const status = calculateStatus(dependencyChecks, optimizationChecks);
+    const result = {
+      status,
+      timestamp: new Date().toISOString(),
+      checks: {
+        dependencies: {
+          total: dependencyChecks.length,
+          installed: dependencyChecks.filter((d) => d.installed).length,
+          packages: dependencyChecks
+        },
+        optimizations: {
+          total: optimizationChecks.length,
+          enabled: optimizationChecks.filter((o) => o.enabled).length,
+          features: optimizationChecks
+        }
+      },
+      recommendations,
+      quickFixes
+    };
+    return JSON.stringify(result, null, 2);
+  }
+});
+var hiveDoctorQuickTool = tool({
+  description: `Quick health check - shows status summary only.
+
+**Returns:**
+- healthy: All systems go
+- warning: Some optimizations disabled
+- issues: Action required`,
+  args: {},
+  async execute() {
+    const keyPackages = [
+      "@ast-grep/napi",
+      "@sparkleideas/agent-booster",
+      "@paretools/search"
+    ];
+    const results = {};
+    let healthy = true;
+    for (const pkg of keyPackages) {
+      const result = await checkPackage(pkg);
+      results[pkg] = result.installed;
+      if (!result.installed) {
+        healthy = false;
+      }
+    }
+    return JSON.stringify({
+      status: healthy ? "healthy" : "warning",
+      packages: results,
+      runFullCheck: "Use hive_doctor for detailed analysis"
+    }, null, 2);
+  }
+});
+
+// src/tools/dora.ts
+import { execSync as execSync2 } from "child_process";
+function checkDoraStatus() {
+  try {
+    const output = execSync2("dora --version", { encoding: "utf-8" });
+    const version2 = output.trim();
+    const indexExists = __require("fs").existsSync(".dora/dora.db");
+    return { installed: true, version: version2, indexed: indexExists };
+  } catch {
+    return { installed: false, indexed: false };
+  }
+}
+function runDoraCommand(args2) {
+  try {
+    const output = execSync2(`dora ${args2.join(" ")}`, {
+      encoding: "utf-8",
+      maxBuffer: 10 * 1024 * 1024
+    });
+    return { success: true, output };
+  } catch (error45) {
+    return { success: false, error: error45.message || "Command failed" };
+  }
+}
+var doraStatusTool = tool({
+  description: `Check dora installation status and index state.
+
+**Returns:**
+- installed: Whether dora CLI is available
+- version: Dora version
+- indexed: Whether codebase has been indexed
+
+**Requirements:**
+- Install dora: \`bun install -g @butttons/dora\`
+- Install SCIP indexer: \`npm install -g @sourcegraph/scip-typescript\`
+- Initialize: \`dora init && dora index\`
+
+**Note:** Indexing is required once per codebase. After that, dora works instantly.`,
+  args: {},
+  async execute() {
+    const status = checkDoraStatus();
+    if (!status.installed) {
+      return JSON.stringify({
+        status: "not_installed",
+        message: "Dora CLI not found",
+        installation: {
+          step1: "bun install -g @butttons/dora",
+          step2: "npm install -g @sourcegraph/scip-typescript",
+          step3: "dora init && dora index"
+        }
+      }, null, 2);
+    }
+    if (!status.indexed) {
+      return JSON.stringify({
+        status: "not_indexed",
+        version: status.version,
+        message: "Codebase not indexed",
+        nextStep: "Run: dora init && dora index"
+      }, null, 2);
+    }
+    return JSON.stringify({
+      status: "ready",
+      version: status.version,
+      indexed: true,
+      message: "Dora is ready"
+    }, null, 2);
+  }
+});
+var doraSymbolTool = tool({
+  description: `Find symbol definitions using dora (SCIP-based).
+
+**Parameters:**
+- name: Symbol name to search for
+- kind: Filter by symbol kind (function, class, method, etc.)
+
+**Example:**
+\`\`\`
+dora_symbol({ name: "getUserById" })
+\`\`\`
+
+**Note:** Requires dora to be installed and indexed.`,
+  args: {
+    name: tool.schema.string().describe("Symbol name to search for"),
+    kind: tool.schema.string().optional().describe("Filter by symbol kind (function, class, method, etc.)")
+  },
+  async execute({ name, kind }) {
+    const status = checkDoraStatus();
+    if (!status.installed || !status.indexed) {
+      return JSON.stringify({
+        success: false,
+        error: "Dora not ready. Run dora_status first.",
+        hint: "Install and index: dora init && dora index"
+      }, null, 2);
+    }
+    const args2 = ["symbol", name];
+    if (kind) {
+      args2.push("--kind", kind);
+    }
+    const result = runDoraCommand(args2);
+    if (!result.success) {
+      return JSON.stringify({
+        success: false,
+        error: result.error,
+        hint: "Symbol may not exist or not indexed"
+      }, null, 2);
+    }
+    return JSON.stringify({
+      success: true,
+      symbol: name,
+      output: result.output
+    }, null, 2);
+  }
+});
+var doraFileTool = tool({
+  description: `Get file dependencies and information using dora.
+
+**Parameters:**
+- path: File path to analyze
+
+**Example:**
+\`\`\`
+dora_file({ path: "src/index.ts" })
+\`\`\`
+
+**Returns:** File metadata, exports, and dependencies.`,
+  args: {
+    path: tool.schema.string().describe("File path to analyze")
+  },
+  async execute({ path: path7 }) {
+    const status = checkDoraStatus();
+    if (!status.installed || !status.indexed) {
+      return JSON.stringify({
+        success: false,
+        error: "Dora not ready. Run dora_status first."
+      }, null, 2);
+    }
+    const result = runDoraCommand(["file", path7]);
+    if (!result.success) {
+      return JSON.stringify({
+        success: false,
+        error: result.error,
+        hint: "File may not exist or not indexed"
+      }, null, 2);
+    }
+    return JSON.stringify({
+      success: true,
+      path: path7,
+      output: result.output
+    }, null, 2);
+  }
+});
+var doraReferencesTool = tool({
+  description: `Find all references to a symbol using dora.
+
+**Parameters:**
+- name: Symbol name to find references for
+
+**Example:**
+\`\`\`
+dora_references({ name: "UserService" })
+\`\`\`
+
+**Note:** Returns all usages across the codebase.`,
+  args: {
+    name: tool.schema.string().describe("Symbol name to find references for")
+  },
+  async execute({ name }) {
+    const status = checkDoraStatus();
+    if (!status.installed || !status.indexed) {
+      return JSON.stringify({
+        success: false,
+        error: "Dora not ready. Run dora_status first."
+      }, null, 2);
+    }
+    const result = runDoraCommand(["references", name]);
+    if (!result.success) {
+      return JSON.stringify({
+        success: false,
+        error: result.error
+      }, null, 2);
+    }
+    return JSON.stringify({
+      success: true,
+      symbol: name,
+      output: result.output
+    }, null, 2);
+  }
+});
+var doraCyclesTool = tool({
+  description: `Detect circular dependencies in the codebase using dora.
+
+**Example:**
+\`\`\`
+dora_cycles()
+\`\`\`
+
+**Returns:** List of circular dependency paths if found.`,
+  args: {},
+  async execute() {
+    const status = checkDoraStatus();
+    if (!status.installed || !status.indexed) {
+      return JSON.stringify({
+        success: false,
+        error: "Dora not ready. Run dora_status first."
+      }, null, 2);
+    }
+    const result = runDoraCommand(["cycles"]);
+    if (!result.success) {
+      return JSON.stringify({
+        success: false,
+        error: result.error
+      }, null, 2);
+    }
+    return JSON.stringify({
+      success: true,
+      cycles: result.output
+    }, null, 2);
+  }
+});
+var doraUnusedTool = tool({
+  description: `Find unused/dead code in the codebase using dora.
+
+**Example:**
+\`\`\`
+dora_unused()
+\`\`\`
+
+**Returns:** List of symbols with zero references.`,
+  args: {},
+  async execute() {
+    const status = checkDoraStatus();
+    if (!status.installed || !status.indexed) {
+      return JSON.stringify({
+        success: false,
+        error: "Dora not ready. Run dora_status first."
+      }, null, 2);
+    }
+    const result = runDoraCommand(["unused"]);
+    if (!result.success) {
+      return JSON.stringify({
+        success: false,
+        error: result.error
+      }, null, 2);
+    }
+    return JSON.stringify({
+      success: true,
+      unused: result.output
+    }, null, 2);
+  }
+});
+
+// src/tools/auto-cr.ts
+import { execSync as execSync3 } from "child_process";
+import * as fs7 from "fs";
+function checkAutoCrStatus() {
+  try {
+    const output = execSync3("auto-cr-cmd --version", { encoding: "utf-8" });
+    const version2 = output.trim();
+    return { installed: true, version: version2 };
   } catch {
-    return false;
+    return { installed: false };
   }
 }
-function getFallbackStats() {
-  ensureFallbackDir();
-  const stats = { total: 0, byType: {} };
-  const files = fs4.readdirSync(getFallbackDir()).filter((f) => f.endsWith(".json"));
-  for (const file2 of files) {
+function runAutoCr(args2) {
+  try {
+    const allArgs = [...args2, "--output", "json"];
+    const output = execSync3(`auto-cr-cmd ${allArgs.join(" ")}`, {
+      encoding: "utf-8",
+      maxBuffer: 50 * 1024 * 1024
+    });
     try {
-      const content = fs4.readFileSync(path4.join(getFallbackDir(), file2), "utf-8");
-      const entry = JSON.parse(content);
-      stats.total++;
-      const type = entry.metadata.type || "unknown";
-      stats.byType[type] = (stats.byType[type] || 0) + 1;
-    } catch {}
+      const json2 = JSON.parse(output);
+      return { success: true, output, json: json2 };
+    } catch {
+      return { success: true, output };
+    }
+  } catch (error45) {
+    const stderr = error45.stderr || "";
+    const stdout = error45.stdout || "";
+    const combined = stdout + stderr;
+    try {
+      const json2 = JSON.parse(combined);
+      return { success: true, output: combined, json: json2 };
+    } catch {
+      return { success: false, error: combined || error45.message };
+    }
   }
-  return stats;
 }
-var VectorMemoryService = {
-  init: initMemory,
-  add: addMemory,
-  search: searchMemories,
-  get: getMemory,
-  delete: deleteMemory,
-  status: getMemoryStatus
-};
+var autoCrStatusTool = tool({
+  description: `Check auto-cr-cmd installation status.
 
-// src/tools/vector-memory.ts
-var hiveVectorSearchTool = tool({
-  description: `Semantic memory search using vector embeddings.
+**Returns:**
+- installed: Whether auto-cr-cmd is available
+- version: Auto-CR version
+- ready: Whether it's ready to scan
 
-**Features:**
-- HNSW indexing for fast similarity search
-- Semantic matching (finds conceptually similar content)
-- Filter by type and scope
-- Fallback to text search if vector unavailable
+**Installation:**
+\`\`\`bash
+npm install auto-cr-cmd
+# or
+pnpm add auto-cr-cmd
+\`\`\``,
+  args: {},
+  async execute() {
+    const status = checkAutoCrStatus();
+    if (!status.installed) {
+      return JSON.stringify({
+        status: "not_installed",
+        message: "auto-cr-cmd not found",
+        installation: "npm install auto-cr-cmd"
+      }, null, 2);
+    }
+    return JSON.stringify({
+      status: "ready",
+      version: status.version,
+      message: "Auto-CR is ready to scan",
+      rules: [
+        "no-deep-relative-imports",
+        "no-circular-dependencies",
+        "no-swallowed-errors",
+        "no-catastrophic-regex",
+        "no-deep-clone-in-loop",
+        "no-n2-array-lookup"
+      ]
+    }, null, 2);
+  }
+});
+var autoCrScanTool = tool({
+  description: `Scan directory for code issues using auto-cr (SWC-based static analysis).
 
-**Types:**
-- decision: Architectural decisions, design choices
-- learning: Insights, discoveries, patterns found
-- preference: User preferences, coding style
-- blocker: Known blockers, workarounds
-- context: Important context about the project
-- pattern: Code patterns, recurring solutions`,
+**Parameters:**
+- path: Directory path to scan (defaults to ./src)
+- language: Output language (en/zh, defaults to en)
+
+**Rules detected:**
+- no-deep-relative-imports: Import paths exceeding depth limit
+- no-circular-dependencies: Circular module dependencies
+- no-swallowed-errors: try-catch blocks that swallow errors
+- no-catastrophic-regex: Potentially catastrophic regex patterns
+- no-deep-clone-in-loop: Performance anti-patterns
+- no-n2-array-lookup: O(n²) array operations
+
+**Example:**
+\`\`\`
+auto_cr_scan({ path: "./src" })
+\`\`\``,
   args: {
-    query: tool.schema.string().describe("Search query (semantic or keyword)"),
-    type: tool.schema.enum(["decision", "learning", "preference", "blocker", "context", "pattern"]).optional().describe("Filter by memory type"),
-    scope: tool.schema.string().optional().describe("Filter by scope (e.g., auth, api, ui)"),
-    limit: tool.schema.number().optional().describe("Maximum results (default: 10)")
+    path: tool.schema.string().optional().default("./src").describe("Directory path to scan"),
+    language: tool.schema.string().optional().default("en").describe("Output language (en or zh)")
   },
-  async execute({ query, type, scope, limit = 10 }) {
-    const result = await VectorMemoryService.search(query, {
-      limit,
-      type,
-      scope
-    });
-    if (result.results.length === 0) {
+  async execute({ path: path7, language }) {
+    const status = checkAutoCrStatus();
+    if (!status.installed) {
       return JSON.stringify({
-        message: "No matching memories found",
-        query,
-        fallback: result.fallback || false,
-        tips: [
-          "Try different keywords",
-          "Use broader search terms",
-          "Create memories with hive_memory_set first"
-        ]
+        success: false,
+        error: "auto-cr-cmd not installed",
+        hint: "npm install auto-cr-cmd"
+      }, null, 2);
+    }
+    if (!fs7.existsSync(path7)) {
+      return JSON.stringify({
+        success: false,
+        error: `Path not found: ${path7}`
+      }, null, 2);
+    }
+    const result = runAutoCr(["--language", language, path7]);
+    if (!result.success && !result.json) {
+      return JSON.stringify({
+        success: false,
+        error: result.error || "Scan failed"
+      }, null, 2);
+    }
+    if (result.json) {
+      const { summary, files, notifications } = result.json;
+      return JSON.stringify({
+        success: true,
+        scanned: path7,
+        summary: {
+          filesScanned: summary?.scannedFiles || 0,
+          filesWithErrors: summary?.filesWithErrors || 0,
+          filesWithWarnings: summary?.filesWithWarnings || 0,
+          totalViolations: summary?.violationTotals?.total || 0
+        },
+        files: files?.map((f) => ({
+          path: f.filePath,
+          violations: f.totalViolations,
+          errors: f.severityCounts?.error || 0,
+          warnings: f.severityCounts?.warning || 0,
+          details: f.violations?.map((v) => ({
+            rule: v.ruleName,
+            severity: v.severity,
+            message: v.message,
+            line: v.line
+          }))
+        })),
+        notifications: notifications || []
       }, null, 2);
     }
     return JSON.stringify({
-      total: result.results.length,
-      query,
-      fallback: result.fallback || false,
-      results: result.results.map((r) => ({
-        id: r.id,
-        content: r.content,
-        score: Math.round(r.score * 100) / 100,
-        type: r.metadata.type,
-        scope: r.metadata.scope,
-        tags: r.metadata.tags
-      }))
+      success: true,
+      scanned: path7,
+      rawOutput: result.output
     }, null, 2);
   }
 });
-var hiveVectorAddTool = tool({
-  description: `Add a memory with semantic indexing for future search.
+var autoCrDiffTool = tool({
+  description: `Scan git diff output for code issues using auto-cr.
 
-**Metadata:**
-- type: Categorize the memory
-- scope: Project area or component
-- tags: Additional categorization
+**Use case:** Run in CI to check only changed files.
 
 **Example:**
+\`\`\`bash
+git diff --name-only -z | xargs -0 auto-cr-cmd --stdin --output json
 \`\`\`
-Content: "Use async/await instead of .then() chains"
-Type: learning
-Scope: async-patterns
-Tags: javascript, promises, best-practice
-\`\`\``,
+
+**Note:** This tool requires git diff output piped via stdin.`,
   args: {
-    content: tool.schema.string().describe("Memory content to store"),
-    type: tool.schema.enum(["decision", "learning", "preference", "blocker", "context", "pattern"]).optional().describe("Memory type"),
-    scope: tool.schema.string().optional().describe("Scope (e.g., auth, api, ui)"),
-    tags: tool.schema.array(tool.schema.string()).optional().describe("Tags for categorization")
+    language: tool.schema.string().optional().default("en").describe("Output language (en or zh)")
   },
-  async execute({ content, type, scope, tags }) {
-    const metadata = {};
-    if (type)
-      metadata.type = type;
-    if (scope)
-      metadata.scope = scope;
-    if (tags)
-      metadata.tags = tags;
-    const result = await VectorMemoryService.add(content, metadata);
+  async execute({ language }) {
+    const status = checkAutoCrStatus();
+    if (!status.installed) {
+      return JSON.stringify({
+        success: false,
+        error: "auto-cr-cmd not installed",
+        hint: "npm install auto-cr-cmd"
+      }, null, 2);
+    }
     return JSON.stringify({
-      success: result.success,
-      id: result.id,
-      fallback: result.fallback || false,
-      message: `Memory stored${result.fallback ? " (text search mode)" : " (vector indexed)"}`
+      success: true,
+      message: "Use git diff with auto-cr directly",
+      example: "git diff --name-only -z | xargs -0 npx auto-cr-cmd --stdin --output json"
     }, null, 2);
   }
 });
-var hiveVectorStatusTool = tool({
-  description: `Check vector memory status and statistics.
+var autoCrRulesTool = tool({
+  description: `List available auto-cr rules and their descriptions.
 
-**Returns:**
-- available: Whether @sparkleideas/memory is working
-- type: vector or fallback
-- stats: Memory counts by type`,
+**Returns:** All built-in rules with descriptions.`,
   args: {},
   async execute() {
-    const status = await VectorMemoryService.status();
+    const rules = [
+      {
+        name: "no-deep-relative-imports",
+        severity: "error",
+        description: "Import paths should not exceed maximum depth",
+        example: "Use path aliases (@shared/utils) instead of ../../../../shared/utils"
+      },
+      {
+        name: "no-circular-dependencies",
+        severity: "warning",
+        description: "Detect circular module dependencies",
+        example: "A imports B, B imports A creates a cycle"
+      },
+      {
+        name: "no-swallowed-errors",
+        severity: "warning",
+        description: "try-catch blocks that swallow errors without rethrowing",
+        example: "catch (e) {} without logging or rethrowing"
+      },
+      {
+        name: "no-catastrophic-regex",
+        severity: "error",
+        description: "Potentially catastrophic regex backtracking",
+        example: "Regex with nested quantifiers that can hang"
+      },
+      {
+        name: "no-deep-clone-in-loop",
+        severity: "warning",
+        description: "Performance: deep clone operations inside loops",
+        example: "for loop calling JSON.parse(JSON.stringify())"
+      },
+      {
+        name: "no-n2-array-lookup",
+        severity: "warning",
+        description: "O(n²) array operations",
+        example: "Nested for loops accessing array elements"
+      }
+    ];
     return JSON.stringify({
-      status: status.available ? "ready" : "fallback",
-      type: status.type,
-      backend: status.available ? "@sparkleideas/memory (HNSW + Vector)" : "Simple text search",
-      stats: status.stats,
-      tips: status.available ? [] : [
-        "Install @sparkleideas/memory for vector search",
-        "npm install @sparkleideas/memory"
-      ]
+      success: true,
+      rules,
+      totalRules: rules.length
     }, null, 2);
   }
 });
@@ -18690,12 +20702,26 @@ var astGrepMcp = {
   command: ["npx", "-y", "@notprolands/ast-grep-mcp"]
 };
 
+// src/mcp/pare-search.ts
+var pareSearchMcp = {
+  type: "local",
+  command: ["npx", "-y", "@paretools/search"]
+};
+
+// src/mcp/veil.ts
+var veilMcp = {
+  type: "local",
+  command: ["npx", "-y", "@ushiradineth/veil@latest", "mcp", "server"]
+};
+
 // src/mcp/index.ts
 var allBuiltinMcps = {
   websearch: websearchMcp,
   context7: context7Mcp,
   grep_app: grepAppMcp,
-  ast_grep: astGrepMcp
+  ast_grep: astGrepMcp,
+  pare_search: pareSearchMcp,
+  veil: veilMcp
 };
 var createBuiltinMcps = (disabledMcps = []) => {
   const disabled = new Set(disabledMcps);
@@ -18704,30 +20730,30 @@ var createBuiltinMcps = (disabledMcps = []) => {
 
 // ../hive-core/dist/index.js
 import { createRequire as createRequire2 } from "node:module";
-import * as path5 from "path";
+import * as path7 from "path";
 import * as os3 from "os";
 import * as path22 from "path";
-import * as fs5 from "fs";
+import * as fs8 from "fs";
 import * as path32 from "path";
 import * as fs22 from "fs";
 import * as fs32 from "fs";
 import * as fs42 from "fs";
 import * as fs52 from "fs";
-import * as fs7 from "fs/promises";
+import * as fs72 from "fs/promises";
 import * as path42 from "path";
 import { Buffer as Buffer2 } from "node:buffer";
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { normalize } from "node:path";
 import { EventEmitter } from "node:events";
-import * as fs8 from "fs";
+import * as fs82 from "fs";
 import * as path52 from "path";
 import * as fs10 from "fs";
-import * as path7 from "path";
+import * as path72 from "path";
 import * as fs11 from "fs";
 import * as path8 from "path";
 import { existsSync as existsSync52 } from "fs";
 import { join as join92, sep } from "path";
-import { execSync } from "child_process";
+import { execSync as execSync4 } from "child_process";
 var __create2 = Object.create;
 var __getProtoOf2 = Object.getPrototypeOf;
 var __defProp2 = Object.defineProperty;
@@ -19579,9 +21605,10 @@ var DEFAULT_HIVE_CONFIG = {
   },
   vectorMemory: {
     enabled: false,
-    indexPath: path5.join(os3.homedir(), ".config", "opencode", "hive", "vector-index"),
+    indexPath: path7.join(os3.homedir(), ".config", "opencode", "hive", "vector-index"),
     dimensions: 384
-  }
+  },
+  autoInstallDeps: true
 };
 var HIVE_DIR = ".hive";
 var FEATURES_DIR = "features";
@@ -19653,22 +21680,22 @@ function getSubtaskReportPath(projectRoot, featureName, taskFolder, subtaskFolde
   return path22.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), REPORT_FILE);
 }
 function ensureDir(dirPath) {
-  if (!fs5.existsSync(dirPath)) {
-    fs5.mkdirSync(dirPath, { recursive: true });
+  if (!fs8.existsSync(dirPath)) {
+    fs8.mkdirSync(dirPath, { recursive: true });
   }
 }
 function fileExists(filePath) {
-  return fs5.existsSync(filePath);
+  return fs8.existsSync(filePath);
 }
 function readJson(filePath) {
-  if (!fs5.existsSync(filePath))
+  if (!fs8.existsSync(filePath))
     return null;
-  const content = fs5.readFileSync(filePath, "utf-8");
+  const content = fs8.readFileSync(filePath, "utf-8");
   return JSON.parse(content);
 }
 function writeJson(filePath, data) {
   ensureDir(path22.dirname(filePath));
-  fs5.writeFileSync(filePath, JSON.stringify(data, null, 2));
+  fs8.writeFileSync(filePath, JSON.stringify(data, null, 2));
 }
 var DEFAULT_LOCK_OPTIONS = {
   timeout: 5000,
@@ -19680,7 +21707,7 @@ function getLockPath(filePath) {
 }
 function isLockStale(lockPath, staleTTL) {
   try {
-    const stat2 = fs5.statSync(lockPath);
+    const stat2 = fs8.statSync(lockPath);
     const age = Date.now() - stat2.mtimeMs;
     return age > staleTTL;
   } catch {
@@ -19700,12 +21727,12 @@ function acquireLockSync(filePath, options = {}) {
   ensureDir(lockDir);
   while (true) {
     try {
-      const fd = fs5.openSync(lockPath, fs5.constants.O_CREAT | fs5.constants.O_EXCL | fs5.constants.O_WRONLY);
-      fs5.writeSync(fd, lockContent);
-      fs5.closeSync(fd);
+      const fd = fs8.openSync(lockPath, fs8.constants.O_CREAT | fs8.constants.O_EXCL | fs8.constants.O_WRONLY);
+      fs8.writeSync(fd, lockContent);
+      fs8.closeSync(fd);
       return () => {
         try {
-          fs5.unlinkSync(lockPath);
+          fs8.unlinkSync(lockPath);
         } catch {}
       };
     } catch (err) {
@@ -19715,7 +21742,7 @@ function acquireLockSync(filePath, options = {}) {
       } else if (error45.code === "EEXIST") {
         if (isLockStale(lockPath, opts.staleLockTTL)) {
           try {
-            fs5.unlinkSync(lockPath);
+            fs8.unlinkSync(lockPath);
             continue;
           } catch {}
         }
@@ -19734,11 +21761,11 @@ function writeAtomic(filePath, content) {
   ensureDir(path22.dirname(filePath));
   const tempPath = `${filePath}.tmp.${process.pid}.${Date.now()}`;
   try {
-    fs5.writeFileSync(tempPath, content);
-    fs5.renameSync(tempPath, filePath);
+    fs8.writeFileSync(tempPath, content);
+    fs8.renameSync(tempPath, filePath);
   } catch (error45) {
     try {
-      fs5.unlinkSync(tempPath);
+      fs8.unlinkSync(tempPath);
     } catch {}
     throw error45;
   }
@@ -19773,13 +21800,13 @@ function patchJsonLockedSync(filePath, patch, options = {}) {
   }
 }
 function readText(filePath) {
-  if (!fs5.existsSync(filePath))
+  if (!fs8.existsSync(filePath))
     return null;
-  return fs5.readFileSync(filePath, "utf-8");
+  return fs8.readFileSync(filePath, "utf-8");
 }
 function writeText(filePath, content) {
   ensureDir(path22.dirname(filePath));
-  fs5.writeFileSync(filePath, content);
+  fs8.writeFileSync(filePath, content);
 }
 function detectContext(cwd) {
   const result = {
@@ -21870,7 +23897,7 @@ var init_git_executor_chain = __esm2({
               rejection = reason || rejection;
             }
           });
-          const spawned = spawn(command, args2, spawnOptions);
+          const spawned = spawn2(command, args2, spawnOptions);
           spawned.stdout.on("data", onDataReceived(stdOut, "stdOut", logger, outputLogger.step("stdOut")));
           spawned.stderr.on("data", onDataReceived(stdErr, "stdErr", logger, outputLogger.step("stdErr")));
           spawned.on("error", onErrorReceived(stdErr, logger));
@@ -24614,7 +26641,7 @@ class WorktreeService {
     const featurePath = path42.join(this.config.hiveDir, "features", feature);
     const tasksPath = path42.join(featurePath, "tasks", step, "status.json");
     try {
-      await fs7.access(tasksPath);
+      await fs72.access(tasksPath);
       return tasksPath;
     } catch {}
     return path42.join(featurePath, "execution", step, "status.json");
@@ -24626,7 +26653,7 @@ class WorktreeService {
     const worktreePath = this.getWorktreePath(feature, step);
     const branchName = this.getBranchName(feature, step);
     const git = this.getGit();
-    await fs7.mkdir(path42.dirname(worktreePath), { recursive: true });
+    await fs72.mkdir(path42.dirname(worktreePath), { recursive: true });
     const base = baseBranch || (await git.revparse(["HEAD"])).trim();
     const existing = await this.get(feature, step);
     if (existing) {
@@ -24655,7 +26682,7 @@ class WorktreeService {
     const worktreePath = this.getWorktreePath(feature, step);
     const branchName = this.getBranchName(feature, step);
     try {
-      await fs7.access(worktreePath);
+      await fs72.access(worktreePath);
       const worktreeGit = this.getGit(worktreePath);
       const commit = (await worktreeGit.revparse(["HEAD"])).trim();
       return {
@@ -24675,7 +26702,7 @@ class WorktreeService {
     let base = baseCommit;
     if (!base) {
       try {
-        const status = JSON.parse(await fs7.readFile(statusPath, "utf-8"));
+        const status = JSON.parse(await fs72.readFile(statusPath, "utf-8"));
         base = status.baseCommit;
       } catch {}
     }
@@ -24725,7 +26752,7 @@ class WorktreeService {
     const base = baseBranch || "HEAD~1";
     const worktreeGit = this.getGit(worktreePath);
     const diff = await worktreeGit.diff([`${base}...HEAD`]);
-    await fs7.writeFile(patchPath, diff);
+    await fs72.writeFile(patchPath, diff);
     return patchPath;
   }
   async applyDiff(feature, step, baseBranch) {
@@ -24735,13 +26762,13 @@ class WorktreeService {
     }
     const patchPath = path42.join(this.config.hiveDir, ".worktrees", feature, `${step}.patch`);
     try {
-      await fs7.writeFile(patchPath, diffContent);
+      await fs72.writeFile(patchPath, diffContent);
       const git = this.getGit();
       await git.applyPatch(patchPath);
-      await fs7.unlink(patchPath).catch(() => {});
+      await fs72.unlink(patchPath).catch(() => {});
       return { success: true, filesAffected: filesChanged };
     } catch (error45) {
-      await fs7.unlink(patchPath).catch(() => {});
+      await fs72.unlink(patchPath).catch(() => {});
       const err = error45;
       return {
         success: false,
@@ -24757,13 +26784,13 @@ class WorktreeService {
     }
     const patchPath = path42.join(this.config.hiveDir, ".worktrees", feature, `${step}.patch`);
     try {
-      await fs7.writeFile(patchPath, diffContent);
+      await fs72.writeFile(patchPath, diffContent);
       const git = this.getGit();
       await git.applyPatch(patchPath, ["-R"]);
-      await fs7.unlink(patchPath).catch(() => {});
+      await fs72.unlink(patchPath).catch(() => {});
       return { success: true, filesAffected: filesChanged };
     } catch (error45) {
-      await fs7.unlink(patchPath).catch(() => {});
+      await fs72.unlink(patchPath).catch(() => {});
       const err = error45;
       return {
         success: false,
@@ -24782,7 +26809,7 @@ class WorktreeService {
     return [...new Set(files)];
   }
   async revertFromSavedDiff(diffPath) {
-    const diffContent = await fs7.readFile(diffPath, "utf-8");
+    const diffContent = await fs72.readFile(diffPath, "utf-8");
     if (!diffContent.trim()) {
       return { success: true, filesAffected: [] };
     }
@@ -24807,7 +26834,7 @@ class WorktreeService {
     try {
       await git.raw(["worktree", "remove", worktreePath, "--force"]);
     } catch {
-      await fs7.rm(worktreePath, { recursive: true, force: true });
+      await fs72.rm(worktreePath, { recursive: true, force: true });
     }
     try {
       await git.raw(["worktree", "prune"]);
@@ -24822,13 +26849,13 @@ class WorktreeService {
     const worktreesDir = this.getWorktreesDir();
     const results = [];
     try {
-      const features = feature ? [feature] : await fs7.readdir(worktreesDir);
+      const features = feature ? [feature] : await fs72.readdir(worktreesDir);
       for (const feat of features) {
         const featurePath = path42.join(worktreesDir, feat);
-        const stat2 = await fs7.stat(featurePath).catch(() => null);
+        const stat2 = await fs72.stat(featurePath).catch(() => null);
         if (!stat2?.isDirectory())
           continue;
-        const steps = await fs7.readdir(featurePath).catch(() => []);
+        const steps = await fs72.readdir(featurePath).catch(() => []);
         for (const step of steps) {
           const info = await this.get(feat, step);
           if (info) {
@@ -24846,16 +26873,16 @@ class WorktreeService {
       await git.raw(["worktree", "prune"]);
     } catch {}
     const worktreesDir = this.getWorktreesDir();
-    const features = feature ? [feature] : await fs7.readdir(worktreesDir).catch(() => []);
+    const features = feature ? [feature] : await fs72.readdir(worktreesDir).catch(() => []);
     for (const feat of features) {
       const featurePath = path42.join(worktreesDir, feat);
-      const stat2 = await fs7.stat(featurePath).catch(() => null);
+      const stat2 = await fs72.stat(featurePath).catch(() => null);
       if (!stat2?.isDirectory())
         continue;
-      const steps = await fs7.readdir(featurePath).catch(() => []);
+      const steps = await fs72.readdir(featurePath).catch(() => []);
       for (const step of steps) {
         const worktreePath = path42.join(featurePath, step);
-        const stepStat = await fs7.stat(worktreePath).catch(() => null);
+        const stepStat = await fs72.stat(worktreePath).catch(() => null);
         if (!stepStat?.isDirectory())
           continue;
         try {
@@ -24876,13 +26903,13 @@ class WorktreeService {
     }
     const patchPath = path42.join(this.config.hiveDir, ".worktrees", feature, `${step}-check.patch`);
     try {
-      await fs7.writeFile(patchPath, diffContent);
+      await fs72.writeFile(patchPath, diffContent);
       const git = this.getGit();
       await git.applyPatch(patchPath, ["--check"]);
-      await fs7.unlink(patchPath).catch(() => {});
+      await fs72.unlink(patchPath).catch(() => {});
       return [];
     } catch (error45) {
-      await fs7.unlink(patchPath).catch(() => {});
+      await fs72.unlink(patchPath).catch(() => {});
       const err = error45;
       const stderr = err.message || "";
       const conflicts2 = stderr.split(`
@@ -24895,7 +26922,7 @@ class WorktreeService {
   }
   async checkConflictsFromSavedDiff(diffPath, reverse = false) {
     try {
-      await fs7.access(diffPath);
+      await fs72.access(diffPath);
     } catch {
       return [];
     }
@@ -24918,7 +26945,7 @@ class WorktreeService {
   async commitChanges(feature, step, message) {
     const worktreePath = this.getWorktreePath(feature, step);
     try {
-      await fs7.access(worktreePath);
+      await fs72.access(worktreePath);
     } catch {
       return { committed: false, sha: "", message: "Worktree not found" };
     }
@@ -25064,10 +27091,10 @@ class ContextService {
     const contextPath = getContextPath(this.projectRoot, featureName);
     if (!fileExists(contextPath))
       return [];
-    const files = fs8.readdirSync(contextPath, { withFileTypes: true }).filter((f) => f.isFile() && f.name.endsWith(".md")).map((f) => f.name);
+    const files = fs82.readdirSync(contextPath, { withFileTypes: true }).filter((f) => f.isFile() && f.name.endsWith(".md")).map((f) => f.name);
     return files.map((name) => {
       const filePath = path52.join(contextPath, name);
-      const stat2 = fs8.statSync(filePath);
+      const stat2 = fs82.statSync(filePath);
       const content = readText(filePath) || "";
       return {
         name: name.replace(/\.md$/, ""),
@@ -25080,7 +27107,7 @@ class ContextService {
     const contextPath = getContextPath(this.projectRoot, featureName);
     const filePath = path52.join(contextPath, this.normalizeFileName(fileName));
     if (fileExists(filePath)) {
-      fs8.unlinkSync(filePath);
+      fs82.unlinkSync(filePath);
       return true;
     }
     return false;
@@ -25111,8 +27138,8 @@ ${f.content}`);
       const archiveName = `${timestamp}_${ctx.name}.md`;
       const src = path52.join(contextPath, `${ctx.name}.md`);
       const dest = path52.join(archiveDir, archiveName);
-      fs8.copyFileSync(src, dest);
-      fs8.unlinkSync(src);
+      fs82.copyFileSync(src, dest);
+      fs82.unlinkSync(src);
       archived.push(ctx.name);
     }
     return { archived, archivePath: archiveDir };
@@ -25140,8 +27167,8 @@ class ConfigService {
   cachedCustomAgentConfigs = null;
   constructor() {
     const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-    const configDir = path7.join(homeDir, ".config", "opencode");
-    this.configPath = path7.join(configDir, "agent_hive.json");
+    const configDir = path72.join(homeDir, ".config", "opencode");
+    this.configPath = path72.join(configDir, "agent_hive.json");
   }
   getPath() {
     return this.configPath;
@@ -25204,7 +27231,7 @@ class ConfigService {
         ...updates.customAgents
       } : current.customAgents
     };
-    const configDir = path7.dirname(this.configPath);
+    const configDir = path72.dirname(this.configPath);
     if (!fs10.existsSync(configDir)) {
       fs10.mkdirSync(configDir, { recursive: true });
     }
@@ -25592,10 +27619,10 @@ class DockerSandboxService {
   static ensureContainer(worktreePath, image) {
     const name = this.containerName(worktreePath);
     try {
-      execSync(`docker inspect --format='{{.State.Running}}' ${name}`, { stdio: "pipe" });
+      execSync4(`docker inspect --format='{{.State.Running}}' ${name}`, { stdio: "pipe" });
       return name;
     } catch {
-      execSync(`docker run -d --name ${name} -v ${worktreePath}:/app -w /app ${image} tail -f /dev/null`, { stdio: "pipe" });
+      execSync4(`docker run -d --name ${name} -v ${worktreePath}:/app -w /app ${image} tail -f /dev/null`, { stdio: "pipe" });
       return name;
     }
   }
@@ -25606,12 +27633,12 @@ class DockerSandboxService {
   static stopContainer(worktreePath) {
     const name = this.containerName(worktreePath);
     try {
-      execSync(`docker rm -f ${name}`, { stdio: "ignore" });
+      execSync4(`docker rm -f ${name}`, { stdio: "ignore" });
     } catch {}
   }
   static isDockerAvailable() {
     try {
-      execSync("docker info", { stdio: "ignore" });
+      execSync4("docker info", { stdio: "ignore" });
       return true;
     } catch {
       return false;
@@ -26130,15 +28157,15 @@ function applyContextBudget(files, config2 = {}) {
 }
 
 // src/utils/prompt-file.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs9 from "fs";
+import * as path9 from "path";
 function writeWorkerPromptFile(feature, task, prompt, hiveDir) {
-  const promptDir = path6.join(hiveDir, "features", feature, "tasks", task);
-  const promptPath = path6.join(promptDir, "worker-prompt.md");
-  if (!fs6.existsSync(promptDir)) {
-    fs6.mkdirSync(promptDir, { recursive: true });
+  const promptDir = path9.join(hiveDir, "features", feature, "tasks", task);
+  const promptPath = path9.join(promptDir, "worker-prompt.md");
+  if (!fs9.existsSync(promptDir)) {
+    fs9.mkdirSync(promptDir, { recursive: true });
   }
-  fs6.writeFileSync(promptPath, prompt, "utf-8");
+  fs9.writeFileSync(promptPath, prompt, "utf-8");
   return promptPath;
 }
 
@@ -26191,6 +28218,183 @@ function buildCompactionPrompt() {
   return COMPACTION_RESUME_PROMPT;
 }
 
+// src/utils/dep-installer.ts
+import { execSync as execSync5 } from "child_process";
+import * as path11 from "path";
+import * as os4 from "os";
+var PLUGIN_TOOLS = [
+  {
+    name: "btca",
+    npmPackage: "btca-cli",
+    installCommand: ["npm", "install", "-g", "btca-cli"],
+    verifyCommand: "btca --version",
+    description: "Bluetooth Classic Audio control",
+    required: false
+  },
+  {
+    name: "dora",
+    npmPackage: "@butttons/dora",
+    installCommand: ["npm", "install", "-g", "@butttons/dora"],
+    verifyCommand: "dora --version",
+    description: "SCIP-based code navigation",
+    required: false
+  },
+  {
+    name: "auto-cr",
+    npmPackage: "auto-cr-cmd",
+    installCommand: ["npm", "install", "-g", "auto-cr-cmd"],
+    verifyCommand: "auto-cr-cmd --version",
+    description: "SWC-based automated code review",
+    required: false
+  },
+  {
+    name: "scip-typescript",
+    npmPackage: "@sourcegraph/scip-typescript",
+    installCommand: ["npm", "install", "-g", "@sourcegraph/scip-typescript"],
+    verifyCommand: "scip-typescript --version",
+    description: "TypeScript SCIP indexer (for dora)",
+    required: false
+  },
+  {
+    name: "typescript-language-server",
+    npmPackage: "typescript-language-server",
+    installCommand: ["npm", "install", "-g", "typescript-language-server", "typescript"],
+    verifyCommand: "typescript-language-server --version",
+    description: "TypeScript/JavaScript LSP server",
+    required: false
+  },
+  {
+    name: "pyright",
+    npmPackage: "pyright",
+    installCommand: ["pip", "install", "pyright"],
+    verifyCommand: "pyright --version",
+    description: "Python LSP server",
+    required: false
+  }
+];
+
+class DependencyInstaller {
+  installDir;
+  cache = new Map;
+  cacheTimeout = 60000;
+  constructor(installDir) {
+    this.installDir = installDir || path11.join(os4.homedir(), ".local");
+  }
+  getBinDir() {
+    return path11.join(this.installDir, "bin");
+  }
+  commandExists(cmd) {
+    try {
+      execSync5(`which ${cmd}`, { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  verifyTool(config2) {
+    try {
+      execSync5(config2.verifyCommand, { stdio: "ignore", timeout: 5000 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async install(config2) {
+    console.log(`[dep-installer] Installing ${config2.name}...`);
+    try {
+      const [cmd, ...args2] = config2.installCommand;
+      const fullCmd = `${cmd} ${args2.join(" ")}`;
+      execSync5(fullCmd, {
+        stdio: "inherit",
+        timeout: 120000,
+        env: {
+          ...process.env,
+          ...cmd === "npm" ? { npm_config_prefix: this.installDir } : {}
+        }
+      });
+      const verified = this.verifyTool(config2);
+      if (verified) {
+        console.log(`[dep-installer] ✓ ${config2.name} installed successfully`);
+        this.cache.set(config2.name, { installed: true, checked: Date.now() });
+        return { success: true, output: `${config2.name} installed and verified` };
+      } else {
+        return { success: false, error: "Installation completed but verification failed" };
+      }
+    } catch (error45) {
+      console.warn(`[dep-installer] ✗ ${config2.name} installation failed: ${error45.message}`);
+      return { success: false, error: error45.message };
+    }
+  }
+  isInstalled(toolName) {
+    const cached2 = this.cache.get(toolName);
+    if (cached2 && Date.now() - cached2.checked < this.cacheTimeout) {
+      return cached2.installed;
+    }
+    const config2 = PLUGIN_TOOLS.find((t) => t.name === toolName);
+    if (!config2)
+      return false;
+    const installed = this.verifyTool(config2);
+    this.cache.set(toolName, { installed, checked: Date.now() });
+    return installed;
+  }
+  getStatus() {
+    return PLUGIN_TOOLS.map((config2) => ({
+      name: config2.name,
+      installed: this.isInstalled(config2.name),
+      description: config2.description,
+      required: config2.required
+    }));
+  }
+  async ensureRequired() {
+    const installed = [];
+    const missing = [];
+    const errors3 = {};
+    for (const config2 of PLUGIN_TOOLS) {
+      if (config2.required && !this.isInstalled(config2.name)) {
+        const result = await this.install(config2);
+        if (result.success) {
+          installed.push(config2.name);
+        } else {
+          missing.push(config2.name);
+          errors3[config2.name] = result.error || "Installation failed";
+        }
+      }
+    }
+    return { installed, missing, errors: errors3 };
+  }
+  async installAll() {
+    const success2 = [];
+    const failed = {};
+    for (const config2 of PLUGIN_TOOLS) {
+      if (!this.isInstalled(config2.name)) {
+        const result = await this.install(config2);
+        if (result.success) {
+          success2.push(config2.name);
+        } else {
+          failed[config2.name] = result.error || "Installation failed";
+        }
+      } else {
+        success2.push(config2.name);
+      }
+    }
+    return { success: success2, failed };
+  }
+  async installTool(toolName) {
+    const config2 = PLUGIN_TOOLS.find((t) => t.name === toolName);
+    if (!config2) {
+      return { success: false, error: `Unknown tool: ${toolName}. Available: ${PLUGIN_TOOLS.map((t) => t.name).join(", ")}` };
+    }
+    if (this.isInstalled(toolName)) {
+      return { success: true, output: `${toolName} is already installed` };
+    }
+    return this.install(config2);
+  }
+}
+var dependencyInstaller = new DependencyInstaller;
+async function ensurePluginDeps() {
+  dependencyInstaller.ensureRequired().catch(console.error);
+}
+
 // src/index.ts
 function formatSkillsXml(skills) {
   if (skills.length === 0)
@@ -26216,7 +28420,7 @@ async function buildAutoLoadedSkillsContent(agentName, configService, projectRoo
   if (autoLoadSkills.length === 0) {
     return "";
   }
-  const homeDir = process.env.HOME || os4.homedir();
+  const homeDir = process.env.HOME || os5.homedir();
   const skillTemplates = [];
   for (const skillId of autoLoadSkills) {
     const builtinSkill = BUILTIN_SKILLS.find((entry) => entry.name === skillId);
@@ -26298,11 +28502,14 @@ var plugin = async (ctx) => {
   const disabledMcps = configService.getDisabledMcps();
   const disabledSkills = configService.getDisabledSkills();
   const builtinMcps = createBuiltinMcps(disabledMcps);
+  if (configService.get().autoInstallDeps !== false) {
+    ensurePluginDeps();
+  }
   const filteredSkills = getFilteredSkills(disabledSkills);
   const effectiveAutoLoadSkills = configService.getAgentConfig("zetta").autoLoadSkills ?? [];
   const worktreeService = new WorktreeService({
     baseDir: directory,
-    hiveDir: path9.join(directory, ".hive")
+    hiveDir: path12.join(directory, ".hive")
   });
   const isOmoSlimEnabled = () => {
     return configService.isOmoSlimEnabled();
@@ -26328,10 +28535,10 @@ var plugin = async (ctx) => {
     }
   };
   const checkBlocked = (feature) => {
-    const fs9 = __require("fs");
-    const blockedPath = path9.join(directory, ".hive", "features", feature, "BLOCKED");
-    if (fs9.existsSync(blockedPath)) {
-      const reason = fs9.readFileSync(blockedPath, "utf-8").trim();
+    const fs12 = __require("fs");
+    const blockedPath = path12.join(directory, ".hive", "features", feature, "BLOCKED");
+    if (fs12.existsSync(blockedPath)) {
+      const reason = fs12.readFileSync(blockedPath, "utf-8").trim();
       return `⛔ BLOCKED by Beekeeper
 
 ${reason || "(No reason provided)"}
@@ -26483,9 +28690,9 @@ To unblock: Remove .hive/features/${feature}/BLOCKED`;
       spec: specContent,
       workerPrompt
     });
-    const hiveDir = path9.join(directory, ".hive");
+    const hiveDir = path12.join(directory, ".hive");
     const workerPromptPath = writeWorkerPromptFile(feature, task, workerPrompt, hiveDir);
-    const relativePromptPath = normalizePath(path9.relative(directory, workerPromptPath));
+    const relativePromptPath = normalizePath(path12.relative(directory, workerPromptPath));
     const PREVIEW_MAX_LENGTH = 200;
     const workerPromptPreview = workerPrompt.length > PREVIEW_MAX_LENGTH ? workerPrompt.slice(0, PREVIEW_MAX_LENGTH) + "..." : workerPrompt;
     const taskToolPrompt = `Follow instructions in @${relativePromptPath}`;
@@ -26893,7 +29100,7 @@ ${snapshot}
       if (sandboxConfig.mode !== "none") {
         const workdir = output.args?.workdir;
         if (workdir) {
-          const hiveWorktreeBase = path9.join(directory, ".hive", ".worktrees");
+          const hiveWorktreeBase = path12.join(directory, ".hive", ".worktrees");
           if (workdir.startsWith(hiveWorktreeBase)) {
             const wrapped = DockerSandboxService.wrapCommand(workdir, finalCommand, sandboxConfig);
             output.args.command = wrapped;
@@ -26944,6 +29151,8 @@ ${snapshot}
       lsp_diagnostics: lspDiagnosticsTool,
       lsp_hover: lspHoverTool,
       lsp_code_actions: lspCodeActionsTool,
+      lsp_status: lspStatusTool,
+      lsp_install: lspInstallTool,
       skill_mcp: skillMcpTool,
       list_skill_mcps: listSkillMcpsTool,
       hive_memory_list: hiveMemoryListTool,
@@ -26960,6 +29169,24 @@ ${snapshot}
       hive_vector_search: hiveVectorSearchTool,
       hive_vector_add: hiveVectorAddTool,
       hive_vector_status: hiveVectorStatusTool,
+      ast_grep_dump_syntax_tree: astGrepDumpSyntaxTreeTool,
+      ast_grep_test_match_code_rule: astGrepTestMatchCodeRuleTool,
+      ast_grep_find_code: astGrepFindCodeTool,
+      ast_grep_scan_code: astGrepScanCodeTool,
+      ast_grep_rewrite_code: astGrepRewriteCodeTool,
+      ast_grep_analyze_imports: astGrepAnalyzeImportsTool,
+      hive_doctor: hiveDoctorTool,
+      hive_doctor_quick: hiveDoctorQuickTool,
+      dora_status: doraStatusTool,
+      dora_symbol: doraSymbolTool,
+      dora_file: doraFileTool,
+      dora_references: doraReferencesTool,
+      dora_cycles: doraCyclesTool,
+      dora_unused: doraUnusedTool,
+      auto_cr_status: autoCrStatusTool,
+      auto_cr_scan: autoCrScanTool,
+      auto_cr_diff: autoCrDiffTool,
+      auto_cr_rules: autoCrRulesTool,
       hive_skill: createHiveSkillTool(filteredSkills),
       hive_feature_create: tool({
         description: "Create a new feature and set it as active",