@hung319/opencode-hive 1.4.4 → 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);
@@ -854,8 +854,8 @@ var init_context_compression = __esm(() => {
 });
 
 // src/index.ts
-import * as path11 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 = {};
@@ -16213,50 +16213,333 @@ 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;
+// 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"
+      }
+    ]
+  },
+  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"
+      }
+    ]
+  },
+  rust: {
+    extensions: ["rs"],
+    primary: {
+      command: "rustup",
+      args: ["component", "add", "rust-analyzer"],
+      verifyCommand: "rust-analyzer --version"
+    },
+    alternatives: []
+  },
+  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)
+    };
   }
-  return { serverId };
 }
+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 with cross-file support.",
+  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 lsp = await getLspConnection(filePath);
-    if (!lsp) {
+    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,
-        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"
+        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}`,
-      server: lsp.serverId,
+      language: status.language,
       operation: "textDocument/rename",
       oldName,
       newName,
@@ -16265,73 +16548,123 @@ var lspRenameTool = tool({
   }
 });
 var lspGotoDefinitionTool = tool({
-  description: "Navigate to the definition of a symbol using LSP. Jump from a usage to its definition.",
+  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 lsp = await getLspConnection(filePath);
-    if (!lsp) {
+    const lang = getLanguageFromPath(filePath);
+    if (!lang) {
       return JSON.stringify({
         success: false,
-        error: `No LSP server available for file: ${filePath}`,
-        hint: "LSP servers are auto-detected based on file type."
+        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}`,
-      server: lsp.serverId,
-      operation: "textDocument/definition"
+      language: status.language,
+      operation: "textDocument/definition",
+      location: { filePath, line, character }
     }, null, 2);
   }
 });
 var lspFindReferencesTool = tool({
-  description: "Find all references to a symbol using LSP. Shows all places where a symbol is used or defined.",
+  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 lsp = await getLspConnection(filePath);
-    if (!lsp) {
+    const lang = getLanguageFromPath(filePath);
+    if (!lang) {
       return JSON.stringify({
         success: false,
-        error: `No LSP server available for file: ${filePath}`,
-        hint: "LSP servers are auto-detected based on file type."
+        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}`,
-      server: lsp.serverId,
+      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: `No LSP server available for file: ${filePath}`,
-        hint: "LSP servers are auto-detected based on file type."
+        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: `Get diagnostics for ${filePath}`,
-      server: lsp.serverId,
+      language: status.language,
       operation: "textDocument/diagnostic",
       severity,
       diagnostics: []
@@ -16339,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) {
@@ -16470,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(`---
@@ -16536,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;
@@ -16561,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 {}
@@ -16585,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,
@@ -16603,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 || "",
@@ -16630,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 = {
@@ -16728,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) {
@@ -16766,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,
@@ -16890,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]+)/);
@@ -16949,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));
@@ -16965,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(`
 `);
@@ -17153,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() {
@@ -17311,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,
@@ -17352,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({
@@ -17410,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;
@@ -17425,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") {
@@ -17529,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();
@@ -17550,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 };
 }
@@ -17562,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;
@@ -17597,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;
   }
@@ -17609,7 +18056,7 @@ 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;
   }
@@ -17626,7 +18073,7 @@ function getFallbackStats() {
   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);
       stats.total++;
       const type = entry.metadata.type || "unknown";
@@ -18153,7 +18600,7 @@ Choose "usage" to see which imports are actually used (great for refactoring), o
     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: path5 }) {
+  async execute({ mode, path: path6 }) {
     await initAstGrep();
     if (!astGrepModule) {
       return JSON.stringify({
@@ -18162,7 +18609,7 @@ Choose "usage" to see which imports are actually used (great for refactoring), o
       }, null, 2);
     }
     try {
-      const analyzePath = path5 || process.cwd();
+      const analyzePath = path6 || process.cwd();
       if (!fs5.existsSync(analyzePath)) {
         return JSON.stringify({
           success: false,
@@ -18224,14 +18671,14 @@ Choose "usage" to see which imports are actually used (great for refactoring), o
 
 // src/tools/hive-doctor.ts
 import * as fs6 from "fs";
-import * as path5 from "path";
+import * as path6 from "path";
 async function checkPackage(packageName) {
   try {
     const packageJsonPath = __require.resolve(`${packageName}/package.json`, {
       paths: [
         process.cwd(),
-        path5.join(process.cwd(), "node_modules"),
-        path5.join(process.cwd(), "packages/opencode-hive/node_modules")
+        path6.join(process.cwd(), "node_modules"),
+        path6.join(process.cwd(), "packages/opencode-hive/node_modules")
       ]
     });
     if (fs6.existsSync(packageJsonPath)) {
@@ -18244,8 +18691,8 @@ async function checkPackage(packageName) {
 function checkOptimizations() {
   const checks3 = [];
   const configPaths = [
-    path5.join(process.env.HOME || "", ".config/opencode/agent_hive.json"),
-    path5.join(process.env.HOME || "", ".config/opencode/agent_hive.jsonc")
+    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) {
@@ -18436,6 +18883,492 @@ var hiveDoctorQuickTool = tool({
   }
 });
 
+// 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 { installed: false };
+  }
+}
+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 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 };
+    }
+  }
+}
+var autoCrStatusTool = tool({
+  description: `Check auto-cr-cmd installation status.
+
+**Returns:**
+- installed: Whether auto-cr-cmd is available
+- version: Auto-CR version
+- ready: Whether it's ready to scan
+
+**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).
+
+**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: {
+    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({ path: path7, 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);
+    }
+    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({
+      success: true,
+      scanned: path7,
+      rawOutput: result.output
+    }, null, 2);
+  }
+});
+var autoCrDiffTool = tool({
+  description: `Scan git diff output for code issues using auto-cr.
+
+**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
+\`\`\`
+
+**Note:** This tool requires git diff output piped via stdin.`,
+  args: {
+    language: tool.schema.string().optional().default("en").describe("Output language (en or zh)")
+  },
+  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: 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 autoCrRulesTool = tool({
+  description: `List available auto-cr rules and their descriptions.
+
+**Returns:** All built-in rules with descriptions.`,
+  args: {},
+  async execute() {
+    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({
+      success: true,
+      rules,
+      totalRules: rules.length
+    }, null, 2);
+  }
+});
+
 // src/agents/hive.ts
 var QUEEN_BEE_PROMPT = `# Zetta (Hybrid)
 
@@ -19775,13 +20708,20 @@ var pareSearchMcp = {
   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,
-  pare_search: pareSearchMcp
+  pare_search: pareSearchMcp,
+  veil: veilMcp
 };
 var createBuiltinMcps = (disabledMcps = []) => {
   const disabled = new Set(disabledMcps);
@@ -19790,10 +20730,10 @@ var createBuiltinMcps = (disabledMcps = []) => {
 
 // ../hive-core/dist/index.js
 import { createRequire as createRequire2 } from "node:module";
-import * as path6 from "path";
+import * as path7 from "path";
 import * as os3 from "os";
 import * as path22 from "path";
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 import * as path32 from "path";
 import * as fs22 from "fs";
 import * as fs32 from "fs";
@@ -19802,18 +20742,18 @@ import * as fs52 from "fs";
 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;
@@ -20665,9 +21605,10 @@ var DEFAULT_HIVE_CONFIG = {
   },
   vectorMemory: {
     enabled: false,
-    indexPath: path6.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";
@@ -20739,22 +21680,22 @@ function getSubtaskReportPath(projectRoot, featureName, taskFolder, subtaskFolde
   return path22.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), REPORT_FILE);
 }
 function ensureDir(dirPath) {
-  if (!fs7.existsSync(dirPath)) {
-    fs7.mkdirSync(dirPath, { recursive: true });
+  if (!fs8.existsSync(dirPath)) {
+    fs8.mkdirSync(dirPath, { recursive: true });
   }
 }
 function fileExists(filePath) {
-  return fs7.existsSync(filePath);
+  return fs8.existsSync(filePath);
 }
 function readJson(filePath) {
-  if (!fs7.existsSync(filePath))
+  if (!fs8.existsSync(filePath))
     return null;
-  const content = fs7.readFileSync(filePath, "utf-8");
+  const content = fs8.readFileSync(filePath, "utf-8");
   return JSON.parse(content);
 }
 function writeJson(filePath, data) {
   ensureDir(path22.dirname(filePath));
-  fs7.writeFileSync(filePath, JSON.stringify(data, null, 2));
+  fs8.writeFileSync(filePath, JSON.stringify(data, null, 2));
 }
 var DEFAULT_LOCK_OPTIONS = {
   timeout: 5000,
@@ -20766,7 +21707,7 @@ function getLockPath(filePath) {
 }
 function isLockStale(lockPath, staleTTL) {
   try {
-    const stat2 = fs7.statSync(lockPath);
+    const stat2 = fs8.statSync(lockPath);
     const age = Date.now() - stat2.mtimeMs;
     return age > staleTTL;
   } catch {
@@ -20786,12 +21727,12 @@ function acquireLockSync(filePath, options = {}) {
   ensureDir(lockDir);
   while (true) {
     try {
-      const fd = fs7.openSync(lockPath, fs7.constants.O_CREAT | fs7.constants.O_EXCL | fs7.constants.O_WRONLY);
-      fs7.writeSync(fd, lockContent);
-      fs7.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 {
-          fs7.unlinkSync(lockPath);
+          fs8.unlinkSync(lockPath);
         } catch {}
       };
     } catch (err) {
@@ -20801,7 +21742,7 @@ function acquireLockSync(filePath, options = {}) {
       } else if (error45.code === "EEXIST") {
         if (isLockStale(lockPath, opts.staleLockTTL)) {
           try {
-            fs7.unlinkSync(lockPath);
+            fs8.unlinkSync(lockPath);
             continue;
           } catch {}
         }
@@ -20820,11 +21761,11 @@ function writeAtomic(filePath, content) {
   ensureDir(path22.dirname(filePath));
   const tempPath = `${filePath}.tmp.${process.pid}.${Date.now()}`;
   try {
-    fs7.writeFileSync(tempPath, content);
-    fs7.renameSync(tempPath, filePath);
+    fs8.writeFileSync(tempPath, content);
+    fs8.renameSync(tempPath, filePath);
   } catch (error45) {
     try {
-      fs7.unlinkSync(tempPath);
+      fs8.unlinkSync(tempPath);
     } catch {}
     throw error45;
   }
@@ -20859,13 +21800,13 @@ function patchJsonLockedSync(filePath, patch, options = {}) {
   }
 }
 function readText(filePath) {
-  if (!fs7.existsSync(filePath))
+  if (!fs8.existsSync(filePath))
     return null;
-  return fs7.readFileSync(filePath, "utf-8");
+  return fs8.readFileSync(filePath, "utf-8");
 }
 function writeText(filePath, content) {
   ensureDir(path22.dirname(filePath));
-  fs7.writeFileSync(filePath, content);
+  fs8.writeFileSync(filePath, content);
 }
 function detectContext(cwd) {
   const result = {
@@ -22956,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));
@@ -26150,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$/, ""),
@@ -26166,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;
@@ -26197,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 };
@@ -26226,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;
@@ -26290,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 });
     }
@@ -26678,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;
     }
   }
@@ -26692,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;
@@ -27277,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)
@@ -27302,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);
@@ -27384,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: path11.join(directory, ".hive")
+    hiveDir: path12.join(directory, ".hive")
   });
   const isOmoSlimEnabled = () => {
     return configService.isOmoSlimEnabled();
@@ -27415,7 +28536,7 @@ var plugin = async (ctx) => {
   };
   const checkBlocked = (feature) => {
     const fs12 = __require("fs");
-    const blockedPath = path11.join(directory, ".hive", "features", feature, "BLOCKED");
+    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
@@ -27569,9 +28690,9 @@ To unblock: Remove .hive/features/${feature}/BLOCKED`;
       spec: specContent,
       workerPrompt
     });
-    const hiveDir = path11.join(directory, ".hive");
+    const hiveDir = path12.join(directory, ".hive");
     const workerPromptPath = writeWorkerPromptFile(feature, task, workerPrompt, hiveDir);
-    const relativePromptPath = normalizePath(path11.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}`;
@@ -27979,7 +29100,7 @@ ${snapshot}
       if (sandboxConfig.mode !== "none") {
         const workdir = output.args?.workdir;
         if (workdir) {
-          const hiveWorktreeBase = path11.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;
@@ -28030,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,
@@ -28054,6 +29177,16 @@ ${snapshot}
       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",