@hung319/opencode-hive 1.4.2 → 1.4.4

package/dist/index.js

@@ -1,5 +1,35 @@
 import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
   this[name] = __returnValue.bind(null, newValue);
@@ -16,6 +46,599 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// ../../node_modules/.bun/@sparkleideas+agent-booster@0.2.34/node_modules/@sparkleideas/agent-booster/dist/index.js
+var require_dist = __commonJS((exports) => {
+  var __dirname = "/home/runner/work/agent-hive/agent-hive/node_modules/.bun/@sparkleideas+agent-booster@0.2.34/node_modules/@sparkleideas/agent-booster/dist";
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function() {
+    var ownKeys = function(o) {
+      ownKeys = Object.getOwnPropertyNames || function(o2) {
+        var ar = [];
+        for (var k in o2)
+          if (Object.prototype.hasOwnProperty.call(o2, k))
+            ar[ar.length] = k;
+        return ar;
+      };
+      return ownKeys(o);
+    };
+    return function(mod) {
+      if (mod && mod.__esModule)
+        return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k = ownKeys(mod), i = 0;i < k.length; i++)
+          if (k[i] !== "default")
+            __createBinding(result, mod, k[i]);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+  }();
+  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 AgentBoosterWasm;
+  try {
+    AgentBoosterWasm = __require(wasmPath);
+  } catch (e) {
+    throw new Error(`Failed to load WASM module from ${wasmPath}: ${e}`);
+  }
+
+  class AgentBooster {
+    constructor(config2 = {}) {
+      this.config = {
+        confidenceThreshold: config2.confidenceThreshold || 0.5,
+        maxChunks: config2.maxChunks || 100
+      };
+      this.wasmInstance = new AgentBoosterWasm.AgentBoosterWasm;
+    }
+    async apply(request) {
+      const startTime = Date.now();
+      try {
+        if (!request.edit || request.edit.trim().length === 0) {
+          throw new Error("Edit instruction cannot be empty. Provide specific code snippet or transformation.");
+        }
+        const vaguePhrases = [
+          "make it better",
+          "improve",
+          "optimize",
+          "fix",
+          "refactor",
+          "add feature",
+          "implement",
+          "create",
+          "design",
+          "build",
+          "handle",
+          "manage",
+          "process",
+          "support"
+        ];
+        const isVague = vaguePhrases.some((phrase) => request.edit.toLowerCase().includes(phrase) && !request.edit.includes("{") && !request.edit.includes("function") && !request.edit.includes("const") && !request.edit.includes("class"));
+        if (isVague) {
+          throw new Error(`Vague instruction detected: "${request.edit}". Agent Booster requires specific code snippets, not high-level instructions. Use an LLM for vague tasks.`);
+        }
+        const result = this.wasmInstance.apply_edit(request.code, request.edit, request.language || "javascript", this.config.confidenceThreshold);
+        const latency = Date.now() - startTime;
+        if (process.env.DEBUG_AGENT_BOOSTER) {
+          console.log("WASM result:", {
+            type: typeof result,
+            confidence: result.confidence,
+            strategy: result.strategy,
+            merged_code_length: result.merged_code?.length
+          });
+        }
+        const confidence = this.getConfidence(result);
+        const strategy = this.getStrategy(result);
+        const mergedCode = this.getMergedCode(result);
+        const inputTokens = Math.ceil(request.code.length / 4);
+        const outputTokens = Math.ceil(mergedCode.length / 4);
+        return {
+          output: mergedCode,
+          success: confidence > this.config.confidenceThreshold,
+          latency,
+          tokens: {
+            input: inputTokens,
+            output: outputTokens
+          },
+          confidence,
+          strategy: this.strategyToString(strategy)
+        };
+      } catch (error45) {
+        const latency = Date.now() - startTime;
+        if (process.env.DEBUG_AGENT_BOOSTER) {
+          console.error("Error in apply():", error45.message || error45);
+        }
+        return {
+          output: request.code,
+          success: false,
+          latency,
+          tokens: { input: 0, output: 0 },
+          confidence: 0,
+          strategy: "failed"
+        };
+      }
+    }
+    async batchApply(requests) {
+      return Promise.all(requests.map((req) => this.apply(req)));
+    }
+    getConfidence(result) {
+      if (typeof result === "object" && result !== null) {
+        if (typeof result.confidence === "number")
+          return result.confidence;
+        if (typeof result.get_confidence === "function")
+          return result.get_confidence();
+      }
+      return 0.5;
+    }
+    getStrategy(result) {
+      if (typeof result === "object" && result !== null) {
+        if (typeof result.strategy === "number")
+          return result.strategy;
+        if (typeof result.strategy === "string")
+          return result.strategy;
+        if (typeof result.get_strategy === "function")
+          return result.get_strategy();
+      }
+      return 2;
+    }
+    getMergedCode(result) {
+      if (typeof result === "object" && result !== null) {
+        if (typeof result.merged_code === "string")
+          return result.merged_code;
+        if (typeof result.get_merged_code === "function")
+          return result.get_merged_code();
+        if (typeof result.code === "string")
+          return result.code;
+      }
+      return "";
+    }
+    strategyToString(strategy) {
+      if (typeof strategy === "string")
+        return strategy;
+      const strategies = {
+        0: "exact_replace",
+        1: "fuzzy_replace",
+        2: "insert_after",
+        3: "insert_before",
+        4: "append"
+      };
+      return strategies[strategy] || "unknown";
+    }
+  }
+  exports.AgentBooster = AgentBooster;
+  async function apply(request) {
+    const booster = new AgentBooster;
+    return booster.apply(request);
+  }
+  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, {
@@ -231,8 +854,8 @@ var init_context_compression = __esm(() => {
 });
 
 // src/index.ts
-import * as path8 from "path";
-import * as os2 from "os";
+import * as path11 from "path";
+import * as os4 from "os";
 
 // ../../node_modules/.bun/zod@4.1.8/node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -16528,7 +17151,1292 @@ var hiveMemoryForgetTool = tool({
   }
 });
 
-// src/agents/hive.ts
+// src/tools/agent-booster.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+var boosterInstance = null;
+var boosterInitPromise = null;
+async function initBooster() {
+  if (boosterInstance !== null) {
+    return;
+  }
+  if (boosterInitPromise !== null) {
+    await boosterInitPromise;
+    return;
+  }
+  boosterInitPromise = (async () => {
+    try {
+      const booster = require_dist();
+      if (booster && typeof booster.init === "function") {
+        await booster.init();
+        boosterInstance = booster;
+      } else if (booster && typeof booster.default === "function") {
+        boosterInstance = booster.default;
+      } else {
+        boosterInstance = booster || {};
+      }
+      console.log("[agent-booster] Initialized successfully");
+    } catch (error45) {
+      console.warn("[agent-booster] Failed to initialize:", error45 instanceof Error ? error45.message : error45);
+      boosterInstance = null;
+    }
+  })();
+  await boosterInitPromise;
+}
+async function applyWithBooster(edit) {
+  await initBooster();
+  if (!boosterInstance) {
+    return {
+      success: false,
+      path: edit.path,
+      error: "Agent booster not available",
+      fallback: true
+    };
+  }
+  try {
+    if (!fs3.existsSync(edit.path)) {
+      return {
+        success: false,
+        path: edit.path,
+        error: `File not found: ${edit.path}`
+      };
+    }
+    const currentContent = fs3.readFileSync(edit.path, "utf-8");
+    if (typeof boosterInstance.fastApply === "function") {
+      const result = await boosterInstance.fastApply({
+        path: edit.path,
+        old: edit.oldContent,
+        new: edit.newContent
+      });
+      return {
+        success: result.success ?? true,
+        path: edit.path,
+        applied: result.applied ?? "Applied via agent-booster"
+      };
+    }
+    if (currentContent.includes(edit.oldContent)) {
+      const newContent = currentContent.replace(edit.oldContent, edit.newContent);
+      fs3.writeFileSync(edit.path, newContent, "utf-8");
+      return {
+        success: true,
+        path: edit.path,
+        applied: "Applied via fallback (string replace)"
+      };
+    }
+    return {
+      success: false,
+      path: edit.path,
+      error: "oldContent not found in file"
+    };
+  } catch (error45) {
+    return {
+      success: false,
+      path: edit.path,
+      error: error45 instanceof Error ? error45.message : String(error45),
+      fallback: true
+    };
+  }
+}
+async function applyCodeEdit(edit) {
+  const boosterResult = await applyWithBooster(edit);
+  if (boosterResult.success) {
+    return boosterResult;
+  }
+  try {
+    if (!fs3.existsSync(edit.path)) {
+      return {
+        success: false,
+        path: edit.path,
+        error: `File not found: ${edit.path}`
+      };
+    }
+    const currentContent = fs3.readFileSync(edit.path, "utf-8");
+    if (!currentContent.includes(edit.oldContent)) {
+      return {
+        success: false,
+        path: edit.path,
+        error: "oldContent not found in file"
+      };
+    }
+    const newContent = currentContent.replace(edit.oldContent, edit.newContent);
+    fs3.writeFileSync(edit.path, newContent, "utf-8");
+    return {
+      success: true,
+      path: edit.path,
+      applied: "Applied via native fallback"
+    };
+  } catch (error45) {
+    return {
+      success: false,
+      path: edit.path,
+      error: error45 instanceof Error ? error45.message : String(error45)
+    };
+  }
+}
+async function isBoosterAvailable() {
+  await initBooster();
+  return boosterInstance !== null;
+}
+async function getBoosterStatus() {
+  const available = await isBoosterAvailable();
+  if (!available) {
+    return { available: false };
+  }
+  try {
+    const booster = await Promise.resolve().then(() => __toESM(require_dist(), 1));
+    return {
+      available: true,
+      version: booster.version || "unknown"
+    };
+  } catch {
+    return { available: true };
+  }
+}
+var hiveCodeEditTool = tool({
+  description: `Ultra-fast code editing using agent-booster (52x faster than Morph, FREE).
+
+**Features:**
+- 52x faster than Morph LLM
+- No API key required
+- Rust+WASM powered
+- Graceful fallback to native edit
+
+**Usage:**
+- oldContent: Exact text to replace (must match file content)
+- newContent: Replacement text
+- Automatically falls back to native edit if agent-booster unavailable`,
+  args: {
+    path: tool.schema.string().describe("Absolute or relative path to the file to edit"),
+    oldContent: tool.schema.string().describe("Exact text to find and replace"),
+    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 result = await applyCodeEdit({
+      path: resolvedPath,
+      oldContent,
+      newContent
+    });
+    if (!result.success) {
+      return JSON.stringify({
+        success: false,
+        error: result.error,
+        hint: "Ensure oldContent matches exactly. Check for whitespace differences."
+      }, null, 2);
+    }
+    return JSON.stringify({
+      success: true,
+      path: result.path,
+      applied: result.applied,
+      message: `Edit applied successfully`
+    }, null, 2);
+  }
+});
+var hiveLazyEditTool = tool({
+  description: `Fast code editing with lazy markers using agent-booster.
+
+**Lazy Markers:**
+Use \`// ... existing code ...\` to indicate unchanged sections.
+Agent-booster intelligently merges your partial code into the full file.
+
+**Example:**
+\`\`\`
+// ... existing code ...
+const newFunction = () => { ... };
+// ... existing code ...
+\`\`\`
+
+**Note:** Requires @sparkleideas/agent-booster to be installed and enabled.`,
+  args: {
+    path: tool.schema.string().describe("File path"),
+    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 available = await isBoosterAvailable();
+    if (!available) {
+      return JSON.stringify({
+        success: false,
+        error: "agent-booster not available",
+        hint: "Install @sparkleideas/agent-booster or use hive_code_edit for native editing"
+      }, null, 2);
+    }
+    try {
+      if (typeof boosterInstance.lazyApply === "function") {
+        const result = await boosterInstance.lazyApply({
+          path: resolvedPath,
+          snippet
+        });
+        return JSON.stringify({
+          success: result.success ?? true,
+          path: resolvedPath,
+          message: result.message || "Lazy edit applied"
+        }, null, 2);
+      }
+      return JSON.stringify({
+        success: false,
+        error: "Lazy apply not supported",
+        hint: "Update @sparkleideas/agent-booster for lazy edit support"
+      }, null, 2);
+    } catch (error45) {
+      return JSON.stringify({
+        success: false,
+        error: error45 instanceof Error ? error45.message : String(error45)
+      }, null, 2);
+    }
+  }
+});
+var hiveBoosterStatusTool = tool({
+  description: `Check agent-booster availability and status.
+
+**Returns:**
+- available: Whether agent-booster is installed and working
+- version: Agent-booster version (if available)
+- speed: Performance comparison vs native editing`,
+  args: {},
+  async execute() {
+    const status = await getBoosterStatus();
+    return JSON.stringify({
+      ...status,
+      performance: {
+        agentBooster: "52x faster than Morph",
+        native: "baseline",
+        savings: "60-90% tokens on large files"
+      },
+      installation: status.available ? "Ready" : "Run: npm install @sparkleideas/agent-booster"
+    }, null, 2);
+  }
+});
+
+// src/services/vector-memory.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import * as os2 from "os";
+var memoryInstance = null;
+var memoryInitPromise = null;
+async function initMemory(options) {
+  if (memoryInstance !== null) {
+    return;
+  }
+  if (memoryInitPromise !== null) {
+    await memoryInitPromise;
+    return;
+  }
+  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 dimensions = options?.dimensions || 384;
+      fs4.mkdirSync(indexPath, { recursive: true });
+      if (typeof memory.init === "function") {
+        await memory.init({
+          indexPath,
+          dimensions
+        });
+      } else if (memory.default && typeof memory.default.init === "function") {
+        memoryInstance = memory.default;
+        await memoryInstance.init({
+          indexPath,
+          dimensions
+        });
+      } else {
+        memoryInstance = memory;
+      }
+      console.log("[vector-memory] Initialized successfully");
+    } catch (error45) {
+      console.warn("[vector-memory] Failed to initialize:", error45 instanceof Error ? error45.message : error45);
+      memoryInstance = null;
+    }
+  })();
+  await memoryInitPromise;
+}
+async function addMemory(content, metadata = {}) {
+  await initMemory();
+  if (memoryInstance) {
+    try {
+      const id2 = await memoryInstance.add({
+        content,
+        metadata
+      });
+      return { id: id2, success: true };
+    } catch (error45) {
+      console.warn("[vector-memory] Failed to add with vector:", error45 instanceof Error ? error45.message : error45);
+    }
+  }
+  return addMemoryFallback(content, metadata);
+}
+async function searchMemories(query, options = {}) {
+  const { limit = 10, type, scope, minScore = 0 } = options;
+  await initMemory();
+  if (memoryInstance && typeof memoryInstance.search === "function") {
+    try {
+      const searchResults = await memoryInstance.search(query, {
+        limit,
+        filter: { type, scope },
+        minScore
+      });
+      return {
+        results: searchResults.map((r) => ({
+          id: r.id,
+          content: r.content,
+          score: r.score || r.similarity || 0,
+          metadata: r.metadata || {}
+        }))
+      };
+    } catch (error45) {
+      console.warn("[vector-memory] Failed to search with vector:", error45 instanceof Error ? error45.message : error45);
+    }
+  }
+  return searchMemoriesFallback(query, { limit, type, scope });
+}
+async function getMemory(id2) {
+  await initMemory();
+  if (memoryInstance && typeof memoryInstance.get === "function") {
+    try {
+      const entry = await memoryInstance.get(id2);
+      return entry;
+    } catch {}
+  }
+  return getMemoryFallback(id2);
+}
+async function deleteMemory(id2) {
+  await initMemory();
+  if (memoryInstance && typeof memoryInstance.delete === "function") {
+    try {
+      await memoryInstance.delete(id2);
+      return true;
+    } catch {}
+  }
+  return deleteMemoryFallback(id2);
+}
+async function getMemoryStatus() {
+  await initMemory();
+  if (memoryInstance) {
+    try {
+      const stats = await memoryInstance.stats?.() || {};
+      return {
+        available: true,
+        type: "vector",
+        stats
+      };
+    } catch {}
+  }
+  const fallbackStats = getFallbackStats();
+  return {
+    available: false,
+    type: "fallback",
+    stats: fallbackStats
+  };
+}
+function getFallbackDir() {
+  return path4.join(os2.homedir(), ".config", "opencode", "hive", "vector-memory", "fallback");
+}
+function ensureFallbackDir() {
+  const dir = getFallbackDir();
+  if (!fs4.existsSync(dir)) {
+    fs4.mkdirSync(dir, { recursive: true });
+  }
+}
+function generateId() {
+  return `mem_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+}
+async function addMemoryFallback(content, metadata) {
+  ensureFallbackDir();
+  const id2 = generateId();
+  const entry = {
+    id: id2,
+    content,
+    metadata,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString()
+  };
+  const filePath = path4.join(getFallbackDir(), `${id2}.json`);
+  fs4.writeFileSync(filePath, JSON.stringify(entry, null, 2), "utf-8");
+  return { id: id2, success: true, fallback: true };
+}
+async function searchMemoriesFallback(query, options) {
+  ensureFallbackDir();
+  const { limit = 10, type, scope } = options;
+  const queryLower = query.toLowerCase();
+  const results = [];
+  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 entry = JSON.parse(content);
+      if (type && entry.metadata.type !== type)
+        continue;
+      if (scope && entry.metadata.scope !== scope)
+        continue;
+      const contentLower = entry.content.toLowerCase();
+      let score = 0;
+      if (contentLower.includes(queryLower)) {
+        score = queryLower.length / contentLower.length;
+      }
+      if (entry.metadata.tags) {
+        for (const tag of entry.metadata.tags) {
+          if (tag.toLowerCase().includes(queryLower)) {
+            score = Math.max(score, 0.8);
+          }
+        }
+      }
+      if (score > 0) {
+        results.push({
+          id: entry.id,
+          content: entry.content,
+          score,
+          metadata: entry.metadata
+        });
+      }
+    } catch {}
+  }
+  results.sort((a, b) => b.score - a.score);
+  return {
+    results: results.slice(0, limit),
+    fallback: true
+  };
+}
+async function getMemoryFallback(id2) {
+  const filePath = path4.join(getFallbackDir(), `${id2}.json`);
+  if (!fs4.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const content = fs4.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function deleteMemoryFallback(id2) {
+  const filePath = path4.join(getFallbackDir(), `${id2}.json`);
+  if (!fs4.existsSync(filePath)) {
+    return false;
+  }
+  try {
+    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(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 {}
+  }
+  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: path5 }) {
+    await initAstGrep();
+    if (!astGrepModule) {
+      return JSON.stringify({
+        success: false,
+        error: "@ast-grep/napi not available"
+      }, null, 2);
+    }
+    try {
+      const analyzePath = path5 || 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 path5 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")
+      ]
+    });
+    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 = [
+    path5.join(process.env.HOME || "", ".config/opencode/agent_hive.json"),
+    path5.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/agents/hive.ts
 var QUEEN_BEE_PROMPT = `# Zetta (Hybrid)
 
 Hybrid agent: plans AND orchestrates. Phase-aware, skills on-demand.
@@ -17861,12 +19769,19 @@ 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/index.ts
 var allBuiltinMcps = {
   websearch: websearchMcp,
   context7: context7Mcp,
   grep_app: grepAppMcp,
-  ast_grep: astGrepMcp
+  ast_grep: astGrepMcp,
+  pare_search: pareSearchMcp
 };
 var createBuiltinMcps = (disabledMcps = []) => {
   const disabled = new Set(disabledMcps);
@@ -17875,61 +19790,63 @@ var createBuiltinMcps = (disabledMcps = []) => {
 
 // ../hive-core/dist/index.js
 import { createRequire as createRequire2 } from "node:module";
-import * as path3 from "path";
-import * as fs3 from "fs";
+import * as path6 from "path";
+import * as os3 from "os";
 import * as path22 from "path";
+import * as fs7 from "fs";
+import * as path32 from "path";
 import * as fs22 from "fs";
 import * as fs32 from "fs";
-import * as fs4 from "fs";
-import * as fs5 from "fs";
-import * as fs7 from "fs/promises";
-import * as path32 from "path";
+import * as fs42 from "fs";
+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 { normalize } from "node:path";
 import { EventEmitter } from "node:events";
 import * as fs8 from "fs";
-import * as path4 from "path";
+import * as path52 from "path";
 import * as fs10 from "fs";
-import * as path6 from "path";
-import * as fs11 from "fs";
 import * as path7 from "path";
-import { existsSync as existsSync5 } from "fs";
-import { join as join82, sep } 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";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
+var __create2 = Object.create;
+var __getProtoOf2 = Object.getPrototypeOf;
 var __defProp2 = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+function __accessProp2(key) {
   return this[key];
 }
-var __toESMCache_node;
-var __toESMCache_esm;
-var __toESM = (mod, isNodeMode, target) => {
+var __toESMCache_node2;
+var __toESMCache_esm2;
+var __toESM2 = (mod, isNodeMode, target) => {
   var canCache = mod != null && typeof mod === "object";
   if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cache = isNodeMode ? __toESMCache_node2 ??= new WeakMap : __toESMCache_esm2 ??= new WeakMap;
     var cached2 = cache.get(mod);
     if (cached2)
       return cached2;
   }
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  target = mod != null ? __create2(__getProtoOf2(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
+  for (let key of __getOwnPropNames2(mod))
+    if (!__hasOwnProp2.call(to, key))
       __defProp2(to, key, {
-        get: __accessProp.bind(mod, key),
+        get: __accessProp2.bind(mod, key),
         enumerable: true
       });
   if (canCache)
     cache.set(mod, to);
   return to;
 };
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __commonJS2 = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __require2 = /* @__PURE__ */ createRequire2(import.meta.url);
-var require_ms = __commonJS((exports, module) => {
+var require_ms = __commonJS2((exports, module) => {
   var s = 1000;
   var m = s * 60;
   var h = m * 60;
@@ -18037,7 +19954,7 @@ var require_ms = __commonJS((exports, module) => {
     return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
   }
 });
-var require_common = __commonJS((exports, module) => {
+var require_common = __commonJS2((exports, module) => {
   function setup(env) {
     createDebug.debug = createDebug;
     createDebug.default = createDebug;
@@ -18210,7 +20127,7 @@ var require_common = __commonJS((exports, module) => {
   }
   module.exports = setup;
 });
-var require_browser = __commonJS((exports, module) => {
+var require_browser = __commonJS2((exports, module) => {
   exports.formatArgs = formatArgs;
   exports.save = save;
   exports.load = load;
@@ -18368,7 +20285,7 @@ var require_browser = __commonJS((exports, module) => {
     }
   };
 });
-var require_node = __commonJS((exports, module) => {
+var require_node = __commonJS2((exports, module) => {
   var tty = __require2("tty");
   var util = __require2("util");
   exports.init = init;
@@ -18539,14 +20456,14 @@ var require_node = __commonJS((exports, module) => {
     return util.inspect(v, this.inspectOpts);
   };
 });
-var require_src = __commonJS((exports, module) => {
+var require_src = __commonJS2((exports, module) => {
   if (typeof process === "undefined" || process.type === "renderer" || false || process.__nwjs) {
     module.exports = require_browser();
   } else {
     module.exports = require_node();
   }
 });
-var require_src2 = __commonJS((exports) => {
+var require_src2 = __commonJS2((exports) => {
   var __importDefault = exports && exports.__importDefault || function(mod) {
     return mod && mod.__esModule ? mod : { default: mod };
   };
@@ -18554,10 +20471,10 @@ var require_src2 = __commonJS((exports) => {
   var fs_1 = __require2("fs");
   var debug_1 = __importDefault(require_src());
   var log = debug_1.default("@kwsites/file-exists");
-  function check2(path33, isFile, isDirectory) {
-    log(`checking %s`, path33);
+  function check2(path43, isFile, isDirectory) {
+    log(`checking %s`, path43);
     try {
-      const stat2 = fs_1.statSync(path33);
+      const stat2 = fs_1.statSync(path43);
       if (stat2.isFile() && isFile) {
         log(`[OK] path represents a file`);
         return true;
@@ -18577,15 +20494,15 @@ var require_src2 = __commonJS((exports) => {
       throw e;
     }
   }
-  function exists(path33, type = exports.READABLE) {
-    return check2(path33, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+  function exists(path43, type = exports.READABLE) {
+    return check2(path43, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
   }
   exports.exists = exists;
   exports.FILE = 1;
   exports.FOLDER = 2;
   exports.READABLE = exports.FILE + exports.FOLDER;
 });
-var require_dist = __commonJS((exports) => {
+var require_dist2 = __commonJS2((exports) => {
   function __export2(m) {
     for (var p in m)
       if (!exports.hasOwnProperty(p))
@@ -18594,7 +20511,7 @@ var require_dist = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   __export2(require_src2());
 });
-var require_dist2 = __commonJS((exports) => {
+var require_dist22 = __commonJS2((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.createDeferred = exports.deferred = undefined;
   function deferred() {
@@ -18740,6 +20657,16 @@ var DEFAULT_HIVE_CONFIG = {
   smartTitle: {
     enabled: false,
     updateThreshold: 1
+  },
+  agentBooster: {
+    enabled: false,
+    serverUrl: "http://localhost:3001",
+    serverPort: 3001
+  },
+  vectorMemory: {
+    enabled: false,
+    indexPath: path6.join(os3.homedir(), ".config", "opencode", "hive", "vector-index"),
+    dimensions: 384
   }
 };
 var HIVE_DIR = ".hive";
@@ -18756,78 +20683,78 @@ function normalizePath(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function getHivePath(projectRoot) {
-  return path3.join(projectRoot, HIVE_DIR);
+  return path22.join(projectRoot, HIVE_DIR);
 }
 function getFeaturesPath(projectRoot) {
-  return path3.join(getHivePath(projectRoot), FEATURES_DIR);
+  return path22.join(getHivePath(projectRoot), FEATURES_DIR);
 }
 function getFeaturePath(projectRoot, featureName) {
-  return path3.join(getFeaturesPath(projectRoot), featureName);
+  return path22.join(getFeaturesPath(projectRoot), featureName);
 }
 function getPlanPath(projectRoot, featureName) {
-  return path3.join(getFeaturePath(projectRoot, featureName), PLAN_FILE);
+  return path22.join(getFeaturePath(projectRoot, featureName), PLAN_FILE);
 }
 function getCommentsPath(projectRoot, featureName) {
-  return path3.join(getFeaturePath(projectRoot, featureName), COMMENTS_FILE);
+  return path22.join(getFeaturePath(projectRoot, featureName), COMMENTS_FILE);
 }
 function getFeatureJsonPath(projectRoot, featureName) {
-  return path3.join(getFeaturePath(projectRoot, featureName), FEATURE_FILE);
+  return path22.join(getFeaturePath(projectRoot, featureName), FEATURE_FILE);
 }
 function getContextPath(projectRoot, featureName) {
-  return path3.join(getFeaturePath(projectRoot, featureName), CONTEXT_DIR);
+  return path22.join(getFeaturePath(projectRoot, featureName), CONTEXT_DIR);
 }
 function getTasksPath(projectRoot, featureName) {
-  return path3.join(getFeaturePath(projectRoot, featureName), TASKS_DIR);
+  return path22.join(getFeaturePath(projectRoot, featureName), TASKS_DIR);
 }
 function getTaskPath(projectRoot, featureName, taskFolder) {
-  return path3.join(getTasksPath(projectRoot, featureName), taskFolder);
+  return path22.join(getTasksPath(projectRoot, featureName), taskFolder);
 }
 function getTaskStatusPath(projectRoot, featureName, taskFolder) {
-  return path3.join(getTaskPath(projectRoot, featureName, taskFolder), STATUS_FILE);
+  return path22.join(getTaskPath(projectRoot, featureName, taskFolder), STATUS_FILE);
 }
 function getTaskReportPath(projectRoot, featureName, taskFolder) {
-  return path3.join(getTaskPath(projectRoot, featureName, taskFolder), REPORT_FILE);
+  return path22.join(getTaskPath(projectRoot, featureName, taskFolder), REPORT_FILE);
 }
 function getTaskSpecPath(projectRoot, featureName, taskFolder) {
-  return path3.join(getTaskPath(projectRoot, featureName, taskFolder), "spec.md");
+  return path22.join(getTaskPath(projectRoot, featureName, taskFolder), "spec.md");
 }
 function getApprovedPath(projectRoot, featureName) {
-  return path3.join(getFeaturePath(projectRoot, featureName), APPROVED_FILE);
+  return path22.join(getFeaturePath(projectRoot, featureName), APPROVED_FILE);
 }
 var SUBTASKS_DIR = "subtasks";
 var SPEC_FILE = "spec.md";
 function getSubtasksPath(projectRoot, featureName, taskFolder) {
-  return path3.join(getTaskPath(projectRoot, featureName, taskFolder), SUBTASKS_DIR);
+  return path22.join(getTaskPath(projectRoot, featureName, taskFolder), SUBTASKS_DIR);
 }
 function getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder) {
-  return path3.join(getSubtasksPath(projectRoot, featureName, taskFolder), subtaskFolder);
+  return path22.join(getSubtasksPath(projectRoot, featureName, taskFolder), subtaskFolder);
 }
 function getSubtaskStatusPath(projectRoot, featureName, taskFolder, subtaskFolder) {
-  return path3.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), STATUS_FILE);
+  return path22.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), STATUS_FILE);
 }
 function getSubtaskSpecPath(projectRoot, featureName, taskFolder, subtaskFolder) {
-  return path3.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), SPEC_FILE);
+  return path22.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), SPEC_FILE);
 }
 function getSubtaskReportPath(projectRoot, featureName, taskFolder, subtaskFolder) {
-  return path3.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), REPORT_FILE);
+  return path22.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), REPORT_FILE);
 }
 function ensureDir(dirPath) {
-  if (!fs3.existsSync(dirPath)) {
-    fs3.mkdirSync(dirPath, { recursive: true });
+  if (!fs7.existsSync(dirPath)) {
+    fs7.mkdirSync(dirPath, { recursive: true });
   }
 }
 function fileExists(filePath) {
-  return fs3.existsSync(filePath);
+  return fs7.existsSync(filePath);
 }
 function readJson(filePath) {
-  if (!fs3.existsSync(filePath))
+  if (!fs7.existsSync(filePath))
     return null;
-  const content = fs3.readFileSync(filePath, "utf-8");
+  const content = fs7.readFileSync(filePath, "utf-8");
   return JSON.parse(content);
 }
 function writeJson(filePath, data) {
-  ensureDir(path3.dirname(filePath));
-  fs3.writeFileSync(filePath, JSON.stringify(data, null, 2));
+  ensureDir(path22.dirname(filePath));
+  fs7.writeFileSync(filePath, JSON.stringify(data, null, 2));
 }
 var DEFAULT_LOCK_OPTIONS = {
   timeout: 5000,
@@ -18839,7 +20766,7 @@ function getLockPath(filePath) {
 }
 function isLockStale(lockPath, staleTTL) {
   try {
-    const stat2 = fs3.statSync(lockPath);
+    const stat2 = fs7.statSync(lockPath);
     const age = Date.now() - stat2.mtimeMs;
     return age > staleTTL;
   } catch {
@@ -18849,7 +20776,7 @@ function isLockStale(lockPath, staleTTL) {
 function acquireLockSync(filePath, options = {}) {
   const opts = { ...DEFAULT_LOCK_OPTIONS, ...options };
   const lockPath = getLockPath(filePath);
-  const lockDir = path3.dirname(lockPath);
+  const lockDir = path22.dirname(lockPath);
   const startTime = Date.now();
   const lockContent = JSON.stringify({
     pid: process.pid,
@@ -18859,12 +20786,12 @@ function acquireLockSync(filePath, options = {}) {
   ensureDir(lockDir);
   while (true) {
     try {
-      const fd = fs3.openSync(lockPath, fs3.constants.O_CREAT | fs3.constants.O_EXCL | fs3.constants.O_WRONLY);
-      fs3.writeSync(fd, lockContent);
-      fs3.closeSync(fd);
+      const fd = fs7.openSync(lockPath, fs7.constants.O_CREAT | fs7.constants.O_EXCL | fs7.constants.O_WRONLY);
+      fs7.writeSync(fd, lockContent);
+      fs7.closeSync(fd);
       return () => {
         try {
-          fs3.unlinkSync(lockPath);
+          fs7.unlinkSync(lockPath);
         } catch {}
       };
     } catch (err) {
@@ -18874,7 +20801,7 @@ function acquireLockSync(filePath, options = {}) {
       } else if (error45.code === "EEXIST") {
         if (isLockStale(lockPath, opts.staleLockTTL)) {
           try {
-            fs3.unlinkSync(lockPath);
+            fs7.unlinkSync(lockPath);
             continue;
           } catch {}
         }
@@ -18890,14 +20817,14 @@ function acquireLockSync(filePath, options = {}) {
   }
 }
 function writeAtomic(filePath, content) {
-  ensureDir(path3.dirname(filePath));
+  ensureDir(path22.dirname(filePath));
   const tempPath = `${filePath}.tmp.${process.pid}.${Date.now()}`;
   try {
-    fs3.writeFileSync(tempPath, content);
-    fs3.renameSync(tempPath, filePath);
+    fs7.writeFileSync(tempPath, content);
+    fs7.renameSync(tempPath, filePath);
   } catch (error45) {
     try {
-      fs3.unlinkSync(tempPath);
+      fs7.unlinkSync(tempPath);
     } catch {}
     throw error45;
   }
@@ -18932,13 +20859,13 @@ function patchJsonLockedSync(filePath, patch, options = {}) {
   }
 }
 function readText(filePath) {
-  if (!fs3.existsSync(filePath))
+  if (!fs7.existsSync(filePath))
     return null;
-  return fs3.readFileSync(filePath, "utf-8");
+  return fs7.readFileSync(filePath, "utf-8");
 }
 function writeText(filePath, content) {
-  ensureDir(path3.dirname(filePath));
-  fs3.writeFileSync(filePath, content);
+  ensureDir(path22.dirname(filePath));
+  fs7.writeFileSync(filePath, content);
 }
 function detectContext(cwd) {
   const result = {
@@ -18958,7 +20885,7 @@ function detectContext(cwd) {
     result.projectRoot = worktreeMatch[1];
     return result;
   }
-  const gitPath = path22.join(cwd, ".git");
+  const gitPath = path32.join(cwd, ".git");
   if (fs22.existsSync(gitPath)) {
     const stat2 = fs22.statSync(gitPath);
     if (stat2.isFile()) {
@@ -19134,7 +21061,7 @@ class PlanService {
     }
     const approvedPath = getApprovedPath(this.projectRoot, featureName);
     const timestamp = new Date().toISOString();
-    fs4.writeFileSync(approvedPath, `Approved at ${timestamp}
+    fs42.writeFileSync(approvedPath, `Approved at ${timestamp}
 `);
     const featurePath = getFeatureJsonPath(this.projectRoot, featureName);
     const feature = readJson(featurePath);
@@ -19150,7 +21077,7 @@ class PlanService {
   revokeApproval(featureName) {
     const approvedPath = getApprovedPath(this.projectRoot, featureName);
     if (fileExists(approvedPath)) {
-      fs4.unlinkSync(approvedPath);
+      fs42.unlinkSync(approvedPath);
     }
     const featurePath = getFeatureJsonPath(this.projectRoot, featureName);
     const feature = readJson(featurePath);
@@ -19396,20 +21323,20 @@ ${f.content}`).join(`
       return [task.order - 1];
     };
     const visited = new Map;
-    const path33 = [];
+    const path43 = [];
     const dfs = (taskOrder) => {
       const state = visited.get(taskOrder);
       if (state === 2) {
         return;
       }
       if (state === 1) {
-        const cycleStart = path33.indexOf(taskOrder);
-        const cyclePath = [...path33.slice(cycleStart), taskOrder];
+        const cycleStart = path43.indexOf(taskOrder);
+        const cyclePath = [...path43.slice(cycleStart), taskOrder];
         const cycleDesc = cyclePath.join(" -> ");
         throw new Error(`Invalid dependency graph in plan.md: Cycle detected in task dependencies: ${cycleDesc}. ` + `Tasks cannot have circular dependencies. Please fix the "Depends on:" lines in plan.md.`);
       }
       visited.set(taskOrder, 1);
-      path33.push(taskOrder);
+      path43.push(taskOrder);
       const task = taskByOrder.get(taskOrder);
       if (task) {
         const deps = getDependencies(task);
@@ -19417,7 +21344,7 @@ ${f.content}`).join(`
           dfs(depOrder);
         }
       }
-      path33.pop();
+      path43.pop();
       visited.set(taskOrder, 2);
     };
     for (const task of tasks) {
@@ -19503,12 +21430,12 @@ ${f.content}`).join(`
     const tasksPath = getTasksPath(this.projectRoot, featureName);
     if (!fileExists(tasksPath))
       return [];
-    return fs5.readdirSync(tasksPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+    return fs52.readdirSync(tasksPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
   }
   deleteTask(featureName, taskFolder) {
     const taskPath = getTaskPath(this.projectRoot, featureName, taskFolder);
     if (fileExists(taskPath)) {
-      fs5.rmSync(taskPath, { recursive: true });
+      fs52.rmSync(taskPath, { recursive: true });
     }
   }
   getNextOrder(existingFolders) {
@@ -19660,7 +21587,7 @@ _Add detailed instructions here_
     }
     const subtaskPath = getSubtaskPath(this.projectRoot, featureName, taskFolder, subtaskFolder);
     if (fileExists(subtaskPath)) {
-      fs5.rmSync(subtaskPath, { recursive: true });
+      fs52.rmSync(subtaskPath, { recursive: true });
     }
   }
   getSubtask(featureName, taskFolder, subtaskId) {
@@ -19720,7 +21647,7 @@ _Add detailed instructions here_
     const subtasksPath = getSubtasksPath(this.projectRoot, featureName, taskFolder);
     if (!fileExists(subtasksPath))
       return [];
-    return fs5.readdirSync(subtasksPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+    return fs52.readdirSync(subtasksPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
   }
   findSubtaskFolder(featureName, taskFolder, subtaskId) {
     const folders = this.listSubtaskFolders(featureName, taskFolder);
@@ -19731,19 +21658,19 @@ _Add detailed instructions here_
     return name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
   }
 }
-var import_file_exists = __toESM(require_dist(), 1);
-var import_debug = __toESM(require_src(), 1);
-var import_promise_deferred = __toESM(require_dist2(), 1);
-var import_promise_deferred2 = __toESM(require_dist2(), 1);
+var import_file_exists = __toESM2(require_dist2(), 1);
+var import_debug = __toESM2(require_src(), 1);
+var import_promise_deferred = __toESM2(require_dist22(), 1);
+var import_promise_deferred2 = __toESM2(require_dist22(), 1);
 var __defProp22 = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames2 = Object.getOwnPropertyNames;
-var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __getOwnPropNames22 = Object.getOwnPropertyNames;
+var __hasOwnProp22 = Object.prototype.hasOwnProperty;
 var __esm2 = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
+  return fn && (res = (0, fn[__getOwnPropNames22(fn)[0]])(fn = 0)), res;
 };
-var __commonJS2 = (cb, mod) => function __require22() {
-  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+var __commonJS22 = (cb, mod) => function __require22() {
+  return mod || (0, cb[__getOwnPropNames22(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __export2 = (target, all) => {
   for (var name in all)
@@ -19751,8 +21678,8 @@ var __export2 = (target, all) => {
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames2(from))
-      if (!__hasOwnProp2.call(to, key) && key !== except)
+    for (let key of __getOwnPropNames22(from))
+      if (!__hasOwnProp22.call(to, key) && key !== except)
         __defProp22(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
   return to;
@@ -19763,8 +21690,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path33) {
-  return path33 instanceof String && cache.has(path33);
+function isPathSpec(path43) {
+  return path43 instanceof String && cache.has(path43);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -19850,8 +21777,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = `
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path33) {
-  return import_file_exists.exists(path33, import_file_exists.FOLDER);
+function folderExists(path43) {
+  return import_file_exists.exists(path43, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -20242,8 +22169,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path33) {
-      return /^\.(git)?$/.test(path33.trim());
+    parser(path43) {
+      return /^\.(git)?$/.test(path43.trim());
     }
   };
 }
@@ -20654,11 +22581,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set;
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path33, line, preview] = input.split(NULL);
-    paths.add(path33);
-    (results[path33] = results[path33] || []).push({
+    const [path43, line, preview] = input.split(NULL);
+    paths.add(path43);
+    (results[path43] = results[path43] || []).push({
       line: asNumber(line),
-      path: path33,
+      path: path43,
       preview
     });
   });
@@ -21324,14 +23251,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path33, text) {
+function parseInit(bare, path43, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path33, false, result[1]);
+    return new InitSummary(bare, path43, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path33, true, result[1]);
+    return new InitSummary(bare, path43, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -21342,7 +23269,7 @@ function parseInit(bare, path33, text) {
       break;
     }
   }
-  return new InitSummary(bare, path33, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path43, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -21350,9 +23277,9 @@ var reInitResponseRegex;
 var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     InitSummary = class {
-      constructor(bare, path33, existing, gitDir) {
+      constructor(bare, path43, existing, gitDir) {
         this.bare = bare;
-        this.path = path33;
+        this.path = path43;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -21364,7 +23291,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path33, customArgs) {
+function initTask(bare = false, path43, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -21373,7 +23300,7 @@ function initTask(bare = false, path33, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path33, text);
+      return parseInit(commands.includes("--bare"), path43, text);
     }
   };
 }
@@ -22088,12 +24015,12 @@ var init_FileStatusSummary = __esm2({
   "src/lib/responses/FileStatusSummary.ts"() {
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path33, index, working_dir) {
-        this.path = path33;
+      constructor(path43, index, working_dir) {
+        this.path = path43;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path33) || [null, path33, path33];
+          const detail = fromPathRegex.exec(path43) || [null, path43, path43];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -22124,14 +24051,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path33) {
+  function data(index, workingDir, path43) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path33);
+      handler(result, path43);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path33, index, workingDir));
+      result.files.push(new FileStatusSummary(path43, index, workingDir));
     }
   }
 }
@@ -22415,8 +24342,8 @@ var init_simple_git_api = __esm2({
         }
         return this._runTask(configurationErrorTask("Git.cwd: workingDirectory must be supplied as a string"), next);
       }
-      hashObject(path33, write) {
-        return this._runTask(hashObjectTask(path33, write === true), trailingFunctionArgument(arguments));
+      hashObject(path43, write) {
+        return this._runTask(hashObjectTask(path43, write === true), trailingFunctionArgument(arguments));
       }
       init(bare) {
         return this._runTask(initTask(bare === true, this._executor.cwd, getTrailingOptions(arguments)), trailingFunctionArgument(arguments));
@@ -22709,8 +24636,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path33 = input.trim().replace(/^["']|["']$/g, "");
-  return path33 && normalize(path33);
+  const path43 = input.trim().replace(/^["']|["']$/g, "");
+  return path43 && normalize(path43);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -22975,8 +24902,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path33) {
-  return subModuleTask(["add", repo, path33]);
+function addSubModuleTask(repo, path43) {
+  return subModuleTask(["add", repo, path43]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -23089,7 +25016,7 @@ var init_tag = __esm2({
     init_TagList();
   }
 });
-var require_git = __commonJS2({
+var require_git = __commonJS22({
   "src/git.js"(exports, module) {
     var { GitExecutor: GitExecutor2 } = (init_git_executor(), __toCommonJS(git_executor_exports));
     var { SimpleGitApi: SimpleGitApi2 } = (init_simple_git_api(), __toCommonJS(simple_git_api_exports));
@@ -23230,8 +25157,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path33, then) {
-      return this._runTask(addSubModuleTask2(repo, path33), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path43, then) {
+      return this._runTask(addSubModuleTask2(repo, path43), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args2, then) {
       return this._runTask(updateSubModuleTask2(getTrailingOptions2(arguments, true)), trailingFunctionArgument2(arguments));
@@ -23764,19 +25691,19 @@ class WorktreeService {
     return esm_default(cwd || this.config.baseDir);
   }
   getWorktreesDir() {
-    return path32.join(this.config.hiveDir, ".worktrees");
+    return path42.join(this.config.hiveDir, ".worktrees");
   }
   getWorktreePath(feature, step) {
-    return path32.join(this.getWorktreesDir(), feature, step);
+    return path42.join(this.getWorktreesDir(), feature, step);
   }
   async getStepStatusPath(feature, step) {
-    const featurePath = path32.join(this.config.hiveDir, "features", feature);
-    const tasksPath = path32.join(featurePath, "tasks", step, "status.json");
+    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 path32.join(featurePath, "execution", step, "status.json");
+    return path42.join(featurePath, "execution", step, "status.json");
   }
   getBranchName(feature, step) {
     return `hive/${feature}/${step}`;
@@ -23785,7 +25712,7 @@ class WorktreeService {
     const worktreePath = this.getWorktreePath(feature, step);
     const branchName = this.getBranchName(feature, step);
     const git = this.getGit();
-    await fs7.mkdir(path32.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) {
@@ -23814,7 +25741,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 {
@@ -23834,7 +25761,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 {}
     }
@@ -23880,11 +25807,11 @@ class WorktreeService {
   }
   async exportPatch(feature, step, baseBranch) {
     const worktreePath = this.getWorktreePath(feature, step);
-    const patchPath = path32.join(worktreePath, "..", `${step}.patch`);
+    const patchPath = path42.join(worktreePath, "..", `${step}.patch`);
     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) {
@@ -23892,15 +25819,15 @@ class WorktreeService {
     if (!hasDiff) {
       return { success: true, filesAffected: [] };
     }
-    const patchPath = path32.join(this.config.hiveDir, ".worktrees", feature, `${step}.patch`);
+    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,
@@ -23914,15 +25841,15 @@ class WorktreeService {
     if (!hasDiff) {
       return { success: true, filesAffected: [] };
     }
-    const patchPath = path32.join(this.config.hiveDir, ".worktrees", feature, `${step}.patch`);
+    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,
@@ -23941,7 +25868,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: [] };
     }
@@ -23966,7 +25893,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"]);
@@ -23981,13 +25908,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 = path32.join(worktreesDir, feat);
-        const stat2 = await fs7.stat(featurePath).catch(() => null);
+        const featurePath = path42.join(worktreesDir, feat);
+        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) {
@@ -24005,16 +25932,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 = path32.join(worktreesDir, feat);
-      const stat2 = await fs7.stat(featurePath).catch(() => null);
+      const featurePath = path42.join(worktreesDir, feat);
+      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 = path32.join(featurePath, step);
-        const stepStat = await fs7.stat(worktreePath).catch(() => null);
+        const worktreePath = path42.join(featurePath, step);
+        const stepStat = await fs72.stat(worktreePath).catch(() => null);
         if (!stepStat?.isDirectory())
           continue;
         try {
@@ -24033,15 +25960,15 @@ class WorktreeService {
     if (!hasDiff) {
       return [];
     }
-    const patchPath = path32.join(this.config.hiveDir, ".worktrees", feature, `${step}-check.patch`);
+    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(`
@@ -24054,7 +25981,7 @@ class WorktreeService {
   }
   async checkConflictsFromSavedDiff(diffPath, reverse = false) {
     try {
-      await fs7.access(diffPath);
+      await fs72.access(diffPath);
     } catch {
       return [];
     }
@@ -24077,7 +26004,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" };
     }
@@ -24204,7 +26131,7 @@ class ContextService {
   write(featureName, fileName, content) {
     const contextPath = getContextPath(this.projectRoot, featureName);
     ensureDir(contextPath);
-    const filePath = path4.join(contextPath, this.normalizeFileName(fileName));
+    const filePath = path52.join(contextPath, this.normalizeFileName(fileName));
     writeText(filePath, content);
     const totalChars = this.list(featureName).reduce((sum, c) => sum + c.content.length, 0);
     if (totalChars > 20000) {
@@ -24216,7 +26143,7 @@ class ContextService {
   }
   read(featureName, fileName) {
     const contextPath = getContextPath(this.projectRoot, featureName);
-    const filePath = path4.join(contextPath, this.normalizeFileName(fileName));
+    const filePath = path52.join(contextPath, this.normalizeFileName(fileName));
     return readText(filePath);
   }
   list(featureName) {
@@ -24225,7 +26152,7 @@ class ContextService {
       return [];
     const files = fs8.readdirSync(contextPath, { withFileTypes: true }).filter((f) => f.isFile() && f.name.endsWith(".md")).map((f) => f.name);
     return files.map((name) => {
-      const filePath = path4.join(contextPath, name);
+      const filePath = path52.join(contextPath, name);
       const stat2 = fs8.statSync(filePath);
       const content = readText(filePath) || "";
       return {
@@ -24237,7 +26164,7 @@ class ContextService {
   }
   delete(featureName, fileName) {
     const contextPath = getContextPath(this.projectRoot, featureName);
-    const filePath = path4.join(contextPath, this.normalizeFileName(fileName));
+    const filePath = path52.join(contextPath, this.normalizeFileName(fileName));
     if (fileExists(filePath)) {
       fs8.unlinkSync(filePath);
       return true;
@@ -24262,14 +26189,14 @@ ${f.content}`);
     if (contexts.length === 0)
       return { archived: [], archivePath: "" };
     const contextPath = getContextPath(this.projectRoot, featureName);
-    const archiveDir = path4.join(contextPath, "..", "archive");
+    const archiveDir = path52.join(contextPath, "..", "archive");
     ensureDir(archiveDir);
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
     const archived = [];
     for (const ctx of contexts) {
       const archiveName = `${timestamp}_${ctx.name}.md`;
-      const src = path4.join(contextPath, `${ctx.name}.md`);
-      const dest = path4.join(archiveDir, archiveName);
+      const src = path52.join(contextPath, `${ctx.name}.md`);
+      const dest = path52.join(archiveDir, archiveName);
       fs8.copyFileSync(src, dest);
       fs8.unlinkSync(src);
       archived.push(ctx.name);
@@ -24299,8 +26226,8 @@ class ConfigService {
   cachedCustomAgentConfigs = null;
   constructor() {
     const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-    const configDir = path6.join(homeDir, ".config", "opencode");
-    this.configPath = path6.join(configDir, "agent_hive.json");
+    const configDir = path7.join(homeDir, ".config", "opencode");
+    this.configPath = path7.join(configDir, "agent_hive.json");
   }
   getPath() {
     return this.configPath;
@@ -24363,7 +26290,7 @@ class ConfigService {
         ...updates.customAgents
       } : current.customAgents
     };
-    const configDir = path6.dirname(this.configPath);
+    const configDir = path7.dirname(this.configPath);
     if (!fs10.existsSync(configDir)) {
       fs10.mkdirSync(configDir, { recursive: true });
     }
@@ -24518,7 +26445,7 @@ class AgentsMdService {
     this.contextService = contextService;
   }
   async init() {
-    const agentsMdPath = path7.join(this.rootDir, "AGENTS.md");
+    const agentsMdPath = path8.join(this.rootDir, "AGENTS.md");
     const existed = fileExists(agentsMdPath);
     if (existed) {
       const existing = readText(agentsMdPath);
@@ -24529,14 +26456,14 @@ class AgentsMdService {
   }
   async sync(featureName) {
     const contexts = this.contextService.list(featureName);
-    const agentsMdPath = path7.join(this.rootDir, "AGENTS.md");
+    const agentsMdPath = path8.join(this.rootDir, "AGENTS.md");
     const current = await fs11.promises.readFile(agentsMdPath, "utf-8").catch(() => "");
     const findings = this.extractFindings(contexts);
     const proposals = this.generateProposals(findings, current);
     return { proposals, diff: this.formatDiff(current, proposals) };
   }
   apply(content) {
-    const agentsMdPath = path7.join(this.rootDir, "AGENTS.md");
+    const agentsMdPath = path8.join(this.rootDir, "AGENTS.md");
     const isNew = !fileExists(agentsMdPath);
     writeText(agentsMdPath, content);
     return { path: agentsMdPath, chars: content.length, isNew };
@@ -24596,7 +26523,7 @@ class AgentsMdService {
     return this.generateTemplate(detections);
   }
   async detectProjectInfo() {
-    const packageJsonPath = path7.join(this.rootDir, "package.json");
+    const packageJsonPath = path8.join(this.rootDir, "package.json");
     let packageJson = null;
     if (fileExists(packageJsonPath)) {
       try {
@@ -24616,26 +26543,26 @@ class AgentsMdService {
     return info;
   }
   detectPackageManager() {
-    if (fileExists(path7.join(this.rootDir, "bun.lockb")))
+    if (fileExists(path8.join(this.rootDir, "bun.lockb")))
       return "bun";
-    if (fileExists(path7.join(this.rootDir, "pnpm-lock.yaml")))
+    if (fileExists(path8.join(this.rootDir, "pnpm-lock.yaml")))
       return "pnpm";
-    if (fileExists(path7.join(this.rootDir, "yarn.lock")))
+    if (fileExists(path8.join(this.rootDir, "yarn.lock")))
       return "yarn";
-    if (fileExists(path7.join(this.rootDir, "package-lock.json")))
+    if (fileExists(path8.join(this.rootDir, "package-lock.json")))
       return "npm";
     return "npm";
   }
   detectLanguage() {
-    if (fileExists(path7.join(this.rootDir, "tsconfig.json")))
+    if (fileExists(path8.join(this.rootDir, "tsconfig.json")))
       return "TypeScript";
-    if (fileExists(path7.join(this.rootDir, "package.json")))
+    if (fileExists(path8.join(this.rootDir, "package.json")))
       return "JavaScript";
-    if (fileExists(path7.join(this.rootDir, "requirements.txt")))
+    if (fileExists(path8.join(this.rootDir, "requirements.txt")))
       return "Python";
-    if (fileExists(path7.join(this.rootDir, "go.mod")))
+    if (fileExists(path8.join(this.rootDir, "go.mod")))
       return "Go";
-    if (fileExists(path7.join(this.rootDir, "Cargo.toml")))
+    if (fileExists(path8.join(this.rootDir, "Cargo.toml")))
       return "Rust";
     return "Unknown";
   }
@@ -24716,19 +26643,19 @@ class AgentsMdService {
 
 class DockerSandboxService {
   static detectImage(worktreePath) {
-    if (existsSync5(join82(worktreePath, "Dockerfile"))) {
+    if (existsSync52(join92(worktreePath, "Dockerfile"))) {
       return null;
     }
-    if (existsSync5(join82(worktreePath, "package.json"))) {
+    if (existsSync52(join92(worktreePath, "package.json"))) {
       return "node:22-slim";
     }
-    if (existsSync5(join82(worktreePath, "requirements.txt")) || existsSync5(join82(worktreePath, "pyproject.toml"))) {
+    if (existsSync52(join92(worktreePath, "requirements.txt")) || existsSync52(join92(worktreePath, "pyproject.toml"))) {
       return "python:3.12-slim";
     }
-    if (existsSync5(join82(worktreePath, "go.mod"))) {
+    if (existsSync52(join92(worktreePath, "go.mod"))) {
       return "golang:1.22-slim";
     }
-    if (existsSync5(join82(worktreePath, "Cargo.toml"))) {
+    if (existsSync52(join92(worktreePath, "Cargo.toml"))) {
       return "rust:1.77-slim";
     }
     return "ubuntu:24.04";
@@ -25289,15 +27216,15 @@ function applyContextBudget(files, config2 = {}) {
 }
 
 // src/utils/prompt-file.ts
-import * as fs6 from "fs";
-import * as path5 from "path";
+import * as fs9 from "fs";
+import * as path9 from "path";
 function writeWorkerPromptFile(feature, task, prompt, hiveDir) {
-  const promptDir = path5.join(hiveDir, "features", feature, "tasks", task);
-  const promptPath = path5.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;
 }
 
@@ -25375,7 +27302,7 @@ async function buildAutoLoadedSkillsContent(agentName, configService, projectRoo
   if (autoLoadSkills.length === 0) {
     return "";
   }
-  const homeDir = process.env.HOME || os2.homedir();
+  const homeDir = process.env.HOME || os4.homedir();
   const skillTemplates = [];
   for (const skillId of autoLoadSkills) {
     const builtinSkill = BUILTIN_SKILLS.find((entry) => entry.name === skillId);
@@ -25461,7 +27388,7 @@ var plugin = async (ctx) => {
   const effectiveAutoLoadSkills = configService.getAgentConfig("zetta").autoLoadSkills ?? [];
   const worktreeService = new WorktreeService({
     baseDir: directory,
-    hiveDir: path8.join(directory, ".hive")
+    hiveDir: path11.join(directory, ".hive")
   });
   const isOmoSlimEnabled = () => {
     return configService.isOmoSlimEnabled();
@@ -25487,10 +27414,10 @@ var plugin = async (ctx) => {
     }
   };
   const checkBlocked = (feature) => {
-    const fs9 = __require("fs");
-    const blockedPath = path8.join(directory, ".hive", "features", feature, "BLOCKED");
-    if (fs9.existsSync(blockedPath)) {
-      const reason = fs9.readFileSync(blockedPath, "utf-8").trim();
+    const fs12 = __require("fs");
+    const blockedPath = path11.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)"}
@@ -25642,9 +27569,9 @@ To unblock: Remove .hive/features/${feature}/BLOCKED`;
       spec: specContent,
       workerPrompt
     });
-    const hiveDir = path8.join(directory, ".hive");
+    const hiveDir = path11.join(directory, ".hive");
     const workerPromptPath = writeWorkerPromptFile(feature, task, workerPrompt, hiveDir);
-    const relativePromptPath = normalizePath(path8.relative(directory, workerPromptPath));
+    const relativePromptPath = normalizePath(path11.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}`;
@@ -26052,7 +27979,7 @@ ${snapshot}
       if (sandboxConfig.mode !== "none") {
         const workdir = output.args?.workdir;
         if (workdir) {
-          const hiveWorktreeBase = path8.join(directory, ".hive", ".worktrees");
+          const hiveWorktreeBase = path11.join(directory, ".hive", ".worktrees");
           if (workdir.startsWith(hiveWorktreeBase)) {
             const wrapped = DockerSandboxService.wrapCommand(workdir, finalCommand, sandboxConfig);
             output.args.command = wrapped;
@@ -26113,6 +28040,20 @@ ${snapshot}
       hive_memory_forget: hiveMemoryForgetTool,
       hive_journal_write: hiveJournalWriteTool,
       hive_journal_search: hiveJournalSearchTool,
+      hive_code_edit: hiveCodeEditTool,
+      hive_lazy_edit: hiveLazyEditTool,
+      hive_booster_status: hiveBoosterStatusTool,
+      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,
       hive_skill: createHiveSkillTool(filteredSkills),
       hive_feature_create: tool({
         description: "Create a new feature and set it as active",