@hung319/opencode-hive 1.4.1 → 1.4.3

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,195 @@ 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;
+});
+
 // src/utils/context-compression.ts
 var exports_context_compression = {};
 __export(exports_context_compression, {
@@ -231,8 +450,8 @@ var init_context_compression = __esm(() => {
 });
 
 // src/index.ts
-import * as path8 from "path";
-import * as os2 from "os";
+import * as path9 from "path";
+import * as os4 from "os";
 
 // ../../node_modules/.bun/zod@4.1.8/node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -16266,6 +16485,877 @@ async function buildMemoryInjection(projectRoot) {
   return sections.join(`
 `);
 }
+function getTypedMemoryDir() {
+  return path2.join(os.homedir(), ".config", "opencode", "hive", "typed-memory");
+}
+function getDeletionsFile() {
+  return path2.join(getTypedMemoryDir(), "deletions.logfmt");
+}
+function parseTypedMemoryLine(line) {
+  const tsMatch = line.match(/ts=([^\s]+)/);
+  const typeMatch = line.match(/type=([^\s]+)/);
+  const scopeMatch = line.match(/scope=([^\s]+)/);
+  const contentMatch = line.match(/content="([^"]*(?:\\"[^"]*)*)"/);
+  const issueMatch = line.match(/issue=([^\s]+)/);
+  const tagsMatch = line.match(/tags=([^\s]+)/);
+  if (!tsMatch?.[1] || !typeMatch?.[1] || !scopeMatch?.[1])
+    return null;
+  return {
+    ts: tsMatch[1],
+    type: typeMatch[1],
+    scope: scopeMatch[1],
+    content: contentMatch?.[1]?.replace(/\\"/g, '"') || "",
+    issue: issueMatch?.[1],
+    tags: tagsMatch?.[1]?.split(",")
+  };
+}
+function formatTypedMemory(m) {
+  const date5 = m.ts.split("T")[0];
+  const tags = m.tags?.length ? ` [${m.tags.join(", ")}]` : "";
+  const issue2 = m.issue ? ` (${m.issue})` : "";
+  return `[${date5}] ${m.type}/${m.scope}: ${m.content}${issue2}${tags}`;
+}
+function scoreTypedMemoryMatch(memory, words) {
+  const searchable = `${memory.type} ${memory.scope} ${memory.content} ${memory.tags?.join(" ") || ""}`.toLowerCase();
+  let score = 0;
+  for (const word of words) {
+    if (searchable.includes(word))
+      score++;
+    if (memory.scope.toLowerCase() === word)
+      score += 2;
+    if (memory.type.toLowerCase() === word)
+      score += 2;
+  }
+  return score;
+}
+async function ensureTypedMemoryDir() {
+  const dir = getTypedMemoryDir();
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+}
+async function getAllTypedMemories() {
+  const dir = getTypedMemoryDir();
+  if (!fs2.existsSync(dir))
+    return [];
+  const files = fs2.readdirSync(dir).filter((f) => f.endsWith(".logfmt"));
+  if (!files.length)
+    return [];
+  const lines = [];
+  for (const filename of files) {
+    if (filename === "deletions.logfmt")
+      continue;
+    const filepath = path2.join(dir, filename);
+    const text = fs2.readFileSync(filepath, "utf-8");
+    lines.push(...text.trim().split(`
+`).filter(Boolean));
+  }
+  return lines.map(parseTypedMemoryLine).filter((m) => m !== null);
+}
+async function findTypedMemories(scope, type, query) {
+  const dir = getTypedMemoryDir();
+  if (!fs2.existsSync(dir))
+    return [];
+  const files = fs2.readdirSync(dir).filter((f) => f.endsWith(".logfmt"));
+  const matches = [];
+  for (const filename of files) {
+    if (filename === "deletions.logfmt")
+      continue;
+    const filepath = path2.join(dir, filename);
+    const text = fs2.readFileSync(filepath, "utf-8");
+    const lines = text.split(`
+`);
+    lines.forEach((line, lineIndex) => {
+      const memory = parseTypedMemoryLine(line);
+      if (!memory)
+        return;
+      if (scope && memory.scope !== scope)
+        return;
+      if (type && memory.type !== type)
+        return;
+      if (query) {
+        const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+        if (scoreTypedMemoryMatch(memory, words) === 0)
+          return;
+      }
+      matches.push({ filepath, lineIndex });
+    });
+  }
+  return matches;
+}
+async function logTypedMemoryDeletion(memory, reason) {
+  await ensureTypedMemoryDir();
+  const ts = new Date().toISOString();
+  const content = memory.content.replace(/"/g, "\\\"");
+  const escapedReason = reason.replace(/"/g, "\\\"");
+  const issue2 = memory.issue ? ` issue=${memory.issue}` : "";
+  const tags = memory.tags?.length ? ` tags=${memory.tags.join(",")}` : "";
+  const line = `ts=${ts} action=deleted original_ts=${memory.ts} type=${memory.type} scope=${memory.scope} content="${content}" reason="${escapedReason}"${issue2}${tags}
+`;
+  const file2 = getDeletionsFile();
+  const existing = fs2.existsSync(file2) ? fs2.readFileSync(file2, "utf-8") : "";
+  fs2.writeFileSync(file2, existing + line);
+}
+var hiveMemoryRecallTool = tool({
+  description: "Search typed memories by scope, type, or query. Retrieve learnings, decisions, preferences, and patterns.",
+  args: {
+    scope: tool.schema.string().optional().describe("Filter by scope (e.g., project, user, auth, api)"),
+    type: tool.schema.enum(["decision", "learning", "preference", "blocker", "context", "pattern"]).optional().describe("Filter by memory type"),
+    query: tool.schema.string().optional().describe("Search terms (matches type, scope, content)"),
+    limit: tool.schema.number().optional().describe("Maximum results (default: 20)")
+  },
+  async execute({ scope, type, query, limit = 20 }) {
+    await ensureTypedMemoryDir();
+    const allMemories = await getAllTypedMemories();
+    if (!allMemories.length) {
+      return JSON.stringify({
+        message: "No typed memories found. Use hive_memory_set to create one.",
+        total: 0,
+        results: []
+      }, null, 2);
+    }
+    let results = allMemories;
+    if (scope) {
+      results = results.filter((m) => m.scope === scope || m.scope.includes(scope));
+    }
+    if (type) {
+      results = results.filter((m) => m.type === type);
+    }
+    if (query) {
+      const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+      const scored = results.map((m) => ({ memory: m, score: scoreTypedMemoryMatch(m, words) })).filter((x) => x.score > 0).sort((a, b) => b.score - a.score);
+      results = scored.map((x) => x.memory);
+    }
+    const totalCount = allMemories.length;
+    const filteredCount = results.length;
+    const limited = results.slice(0, limit);
+    if (!limited.length) {
+      return JSON.stringify({
+        message: "No matching memories found.",
+        total: totalCount,
+        results: []
+      }, null, 2);
+    }
+    return JSON.stringify({
+      total: totalCount,
+      filtered: filteredCount,
+      returned: limited.length,
+      results: limited.map((m) => ({
+        type: m.type,
+        scope: m.scope,
+        content: m.content,
+        created: m.ts,
+        issue: m.issue,
+        tags: m.tags,
+        formatted: formatTypedMemory(m)
+      }))
+    }, null, 2);
+  }
+});
+var hiveMemoryUpdateTool = tool({
+  description: "Update a typed memory entry. Finds by scope and type, updates content.",
+  args: {
+    scope: tool.schema.string().describe("Scope of memory to update"),
+    type: tool.schema.enum(["decision", "learning", "preference", "blocker", "context", "pattern"]).describe("Type of memory"),
+    content: tool.schema.string().describe("New content"),
+    query: tool.schema.string().optional().describe("If multiple matches, filter by query")
+  },
+  async execute({ scope, type, content, query }) {
+    const matches = await findTypedMemories(scope, type);
+    if (matches.length === 0) {
+      return JSON.stringify({
+        success: false,
+        error: `No memories found for ${type} in ${scope}`
+      }, null, 2);
+    }
+    let target = matches[0];
+    if (matches.length > 1 && query) {
+      const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+      const scored = matches.map((m) => {
+        const memory = parseTypedMemoryLine(fs2.readFileSync(m.filepath, "utf-8").split(`
+`)[m.lineIndex]);
+        return { match: m, score: memory ? scoreTypedMemoryMatch(memory, words) : 0 };
+      }).filter((x) => x.score > 0).sort((a, b) => b.score - a.score);
+      if (scored.length === 0) {
+        return JSON.stringify({
+          success: false,
+          error: `Found ${matches.length} memories for ${type}/${scope}, but none matched query "${query}"`
+        }, null, 2);
+      }
+      target = scored[0].match;
+    }
+    const oldLine = fs2.readFileSync(target.filepath, "utf-8").split(`
+`)[target.lineIndex];
+    const oldMemory = parseTypedMemoryLine(oldLine);
+    if (oldMemory) {
+      await logTypedMemoryDeletion(oldMemory, `Updated to: ${content}`);
+    }
+    const ts = new Date().toISOString();
+    const lines = fs2.readFileSync(target.filepath, "utf-8").split(`
+`);
+    lines[target.lineIndex] = `ts=${ts} type=${type} scope=${scope} content="${content.replace(/"/g, "\\\"")}"`;
+    fs2.writeFileSync(target.filepath, lines.join(`
+`));
+    return JSON.stringify({
+      success: true,
+      scope,
+      type,
+      content,
+      message: `Updated ${type} in ${scope}`
+    }, null, 2);
+  }
+});
+var hiveMemoryForgetTool = tool({
+  description: "Delete a typed memory. Logs deletion for audit purposes.",
+  args: {
+    scope: tool.schema.string().describe("Scope of memory to delete"),
+    type: tool.schema.enum(["decision", "learning", "preference", "blocker", "context", "pattern"]).describe("Type of memory"),
+    reason: tool.schema.string().describe("Why this memory is being deleted")
+  },
+  async execute({ scope, type, reason }) {
+    const matches = await findTypedMemories(scope, type);
+    if (matches.length === 0) {
+      return JSON.stringify({
+        success: false,
+        error: `No memories found for ${type} in ${scope}`
+      }, null, 2);
+    }
+    let deleted = 0;
+    const deletedMemories = [];
+    for (const match of matches) {
+      const text = fs2.readFileSync(match.filepath, "utf-8");
+      const lines = text.split(`
+`);
+      const memory = parseTypedMemoryLine(lines[match.lineIndex]);
+      if (memory) {
+        await logTypedMemoryDeletion(memory, reason);
+        deletedMemories.push(memory);
+        deleted++;
+      }
+      lines.splice(match.lineIndex, 1);
+      fs2.writeFileSync(match.filepath, lines.join(`
+`));
+    }
+    return JSON.stringify({
+      success: true,
+      deleted,
+      scope,
+      type,
+      reason,
+      message: `Deleted ${deleted} ${type} memory(ies) from ${scope}. Deletion logged.`
+    }, null, 2);
+  }
+});
+
+// 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/agents/hive.ts
 var QUEEN_BEE_PROMPT = `# Zetta (Hybrid)
@@ -17614,61 +18704,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 path5 from "path";
+import * as os3 from "os";
 import * as path22 from "path";
+import * as fs5 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 fs42 from "fs";
+import * as fs52 from "fs";
 import * as fs7 from "fs/promises";
-import * as path32 from "path";
+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;
@@ -17776,7 +18868,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;
@@ -17949,7 +19041,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;
@@ -18107,7 +19199,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;
@@ -18278,14 +19370,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 };
   };
@@ -18293,10 +19385,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;
@@ -18316,15 +19408,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))
@@ -18333,7 +19425,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() {
@@ -18471,6 +19563,24 @@ var DEFAULT_HIVE_CONFIG = {
     includeActiveFeature: true,
     includePendingTasks: true,
     includeModifiedFiles: false
+  },
+  snip: {
+    enabled: false,
+    command: "snip"
+  },
+  smartTitle: {
+    enabled: false,
+    updateThreshold: 1
+  },
+  agentBooster: {
+    enabled: false,
+    serverUrl: "http://localhost:3001",
+    serverPort: 3001
+  },
+  vectorMemory: {
+    enabled: false,
+    indexPath: path5.join(os3.homedir(), ".config", "opencode", "hive", "vector-index"),
+    dimensions: 384
   }
 };
 var HIVE_DIR = ".hive";
@@ -18487,78 +19597,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 (!fs5.existsSync(dirPath)) {
+    fs5.mkdirSync(dirPath, { recursive: true });
   }
 }
 function fileExists(filePath) {
-  return fs3.existsSync(filePath);
+  return fs5.existsSync(filePath);
 }
 function readJson(filePath) {
-  if (!fs3.existsSync(filePath))
+  if (!fs5.existsSync(filePath))
     return null;
-  const content = fs3.readFileSync(filePath, "utf-8");
+  const content = fs5.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));
+  fs5.writeFileSync(filePath, JSON.stringify(data, null, 2));
 }
 var DEFAULT_LOCK_OPTIONS = {
   timeout: 5000,
@@ -18570,7 +19680,7 @@ function getLockPath(filePath) {
 }
 function isLockStale(lockPath, staleTTL) {
   try {
-    const stat2 = fs3.statSync(lockPath);
+    const stat2 = fs5.statSync(lockPath);
     const age = Date.now() - stat2.mtimeMs;
     return age > staleTTL;
   } catch {
@@ -18580,7 +19690,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,
@@ -18590,12 +19700,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 = fs5.openSync(lockPath, fs5.constants.O_CREAT | fs5.constants.O_EXCL | fs5.constants.O_WRONLY);
+      fs5.writeSync(fd, lockContent);
+      fs5.closeSync(fd);
       return () => {
         try {
-          fs3.unlinkSync(lockPath);
+          fs5.unlinkSync(lockPath);
         } catch {}
       };
     } catch (err) {
@@ -18605,7 +19715,7 @@ function acquireLockSync(filePath, options = {}) {
       } else if (error45.code === "EEXIST") {
         if (isLockStale(lockPath, opts.staleLockTTL)) {
           try {
-            fs3.unlinkSync(lockPath);
+            fs5.unlinkSync(lockPath);
             continue;
           } catch {}
         }
@@ -18621,14 +19731,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);
+    fs5.writeFileSync(tempPath, content);
+    fs5.renameSync(tempPath, filePath);
   } catch (error45) {
     try {
-      fs3.unlinkSync(tempPath);
+      fs5.unlinkSync(tempPath);
     } catch {}
     throw error45;
   }
@@ -18663,13 +19773,13 @@ function patchJsonLockedSync(filePath, patch, options = {}) {
   }
 }
 function readText(filePath) {
-  if (!fs3.existsSync(filePath))
+  if (!fs5.existsSync(filePath))
     return null;
-  return fs3.readFileSync(filePath, "utf-8");
+  return fs5.readFileSync(filePath, "utf-8");
 }
 function writeText(filePath, content) {
-  ensureDir(path3.dirname(filePath));
-  fs3.writeFileSync(filePath, content);
+  ensureDir(path22.dirname(filePath));
+  fs5.writeFileSync(filePath, content);
 }
 function detectContext(cwd) {
   const result = {
@@ -18689,7 +19799,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()) {
@@ -18865,7 +19975,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);
@@ -18881,7 +19991,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);
@@ -19127,20 +20237,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);
@@ -19148,7 +20258,7 @@ ${f.content}`).join(`
           dfs(depOrder);
         }
       }
-      path33.pop();
+      path43.pop();
       visited.set(taskOrder, 2);
     };
     for (const task of tasks) {
@@ -19234,12 +20344,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) {
@@ -19391,7 +20501,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) {
@@ -19451,7 +20561,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);
@@ -19462,19 +20572,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)
@@ -19482,8 +20592,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;
@@ -19494,8 +20604,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) || [];
@@ -19581,8 +20691,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)) {
@@ -19973,8 +21083,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path33) {
-      return /^\.(git)?$/.test(path33.trim());
+    parser(path43) {
+      return /^\.(git)?$/.test(path43.trim());
     }
   };
 }
@@ -20385,11 +21495,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
     });
   });
@@ -21055,14 +22165,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(" ");
@@ -21073,7 +22183,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;
@@ -21081,9 +22191,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;
       }
@@ -21095,7 +22205,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);
@@ -21104,7 +22214,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);
     }
   };
 }
@@ -21819,12 +22929,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] || "";
         }
@@ -21855,14 +22965,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));
     }
   }
 }
@@ -22146,8 +23256,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));
@@ -22440,8 +23550,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({
@@ -22706,8 +23816,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]);
@@ -22820,7 +23930,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));
@@ -22961,8 +24071,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));
@@ -23495,19 +24605,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);
       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}`;
@@ -23516,7 +24626,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 fs7.mkdir(path42.dirname(worktreePath), { recursive: true });
     const base = baseBranch || (await git.revparse(["HEAD"])).trim();
     const existing = await this.get(feature, step);
     if (existing) {
@@ -23611,7 +24721,7 @@ 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`]);
@@ -23623,7 +24733,7 @@ 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);
       const git = this.getGit();
@@ -23645,7 +24755,7 @@ 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);
       const git = this.getGit();
@@ -23714,7 +24824,7 @@ class WorktreeService {
     try {
       const features = feature ? [feature] : await fs7.readdir(worktreesDir);
       for (const feat of features) {
-        const featurePath = path32.join(worktreesDir, feat);
+        const featurePath = path42.join(worktreesDir, feat);
         const stat2 = await fs7.stat(featurePath).catch(() => null);
         if (!stat2?.isDirectory())
           continue;
@@ -23738,13 +24848,13 @@ class WorktreeService {
     const worktreesDir = this.getWorktreesDir();
     const features = feature ? [feature] : await fs7.readdir(worktreesDir).catch(() => []);
     for (const feat of features) {
-      const featurePath = path32.join(worktreesDir, feat);
+      const featurePath = path42.join(worktreesDir, feat);
       const stat2 = await fs7.stat(featurePath).catch(() => null);
       if (!stat2?.isDirectory())
         continue;
       const steps = await fs7.readdir(featurePath).catch(() => []);
       for (const step of steps) {
-        const worktreePath = path32.join(featurePath, step);
+        const worktreePath = path42.join(featurePath, step);
         const stepStat = await fs7.stat(worktreePath).catch(() => null);
         if (!stepStat?.isDirectory())
           continue;
@@ -23764,7 +24874,7 @@ 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);
       const git = this.getGit();
@@ -23935,7 +25045,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) {
@@ -23947,7 +25057,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) {
@@ -23956,7 +25066,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 {
@@ -23968,7 +25078,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;
@@ -23993,14 +25103,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);
@@ -24030,8 +25140,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;
@@ -24094,7 +25204,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 });
     }
@@ -24249,7 +25359,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);
@@ -24260,14 +25370,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 };
@@ -24327,7 +25437,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 {
@@ -24347,26 +25457,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";
   }
@@ -24447,19 +25557,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";
@@ -25021,10 +26131,10 @@ function applyContextBudget(files, config2 = {}) {
 
 // src/utils/prompt-file.ts
 import * as fs6 from "fs";
-import * as path5 from "path";
+import * as path6 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");
+  const promptDir = path6.join(hiveDir, "features", feature, "tasks", task);
+  const promptPath = path6.join(promptDir, "worker-prompt.md");
   if (!fs6.existsSync(promptDir)) {
     fs6.mkdirSync(promptDir, { recursive: true });
   }
@@ -25106,7 +26216,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);
@@ -25165,6 +26275,18 @@ No Hive skills available.` : base + formatSkillsXml(filteredSkills);
     }
   });
 }
+var ENV_VAR_RE = /^([A-Za-z_][A-Za-z0-9_]*=[^\s]* +)*/;
+function prefixWithSnip(command, snipCommand = "snip") {
+  if (command.startsWith(`${snipCommand} `)) {
+    return command;
+  }
+  const splitMatch = command.match(/^(.*?)( &&| [|]| ;|;)(.*)$/);
+  const firstPart = splitMatch ? splitMatch[1] : command;
+  const rest = splitMatch ? splitMatch[2] + splitMatch[3] : "";
+  const envPrefix = (firstPart.match(ENV_VAR_RE) ?? [""])[0];
+  const bareCmd = firstPart.slice(envPrefix.length).trim();
+  return `${envPrefix}${snipCommand} ${bareCmd}${rest}`;
+}
 var plugin = async (ctx) => {
   const { directory, client } = ctx;
   const featureService = new FeatureService(directory);
@@ -25180,7 +26302,7 @@ var plugin = async (ctx) => {
   const effectiveAutoLoadSkills = configService.getAgentConfig("zetta").autoLoadSkills ?? [];
   const worktreeService = new WorktreeService({
     baseDir: directory,
-    hiveDir: path8.join(directory, ".hive")
+    hiveDir: path9.join(directory, ".hive")
   });
   const isOmoSlimEnabled = () => {
     return configService.isOmoSlimEnabled();
@@ -25207,7 +26329,7 @@ var plugin = async (ctx) => {
   };
   const checkBlocked = (feature) => {
     const fs9 = __require("fs");
-    const blockedPath = path8.join(directory, ".hive", "features", feature, "BLOCKED");
+    const blockedPath = path9.join(directory, ".hive", "features", feature, "BLOCKED");
     if (fs9.existsSync(blockedPath)) {
       const reason = fs9.readFileSync(blockedPath, "utf-8").trim();
       return `⛔ BLOCKED by Beekeeper
@@ -25361,9 +26483,9 @@ To unblock: Remove .hive/features/${feature}/BLOCKED`;
       spec: specContent,
       workerPrompt
     });
-    const hiveDir = path8.join(directory, ".hive");
+    const hiveDir = path9.join(directory, ".hive");
     const workerPromptPath = writeWorkerPromptFile(feature, task, workerPrompt, hiveDir);
-    const relativePromptPath = normalizePath(path8.relative(directory, workerPromptPath));
+    const relativePromptPath = normalizePath(path9.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}`;
@@ -25753,9 +26875,6 @@ ${snapshot}
       }
       if (input.tool !== "bash")
         return;
-      const sandboxConfig = configService.getSandboxConfig();
-      if (sandboxConfig.mode === "none")
-        return;
       const command = output.args?.command?.trim();
       if (!command)
         return;
@@ -25765,15 +26884,27 @@ ${snapshot}
         output.args.command = strippedCommand;
         return;
       }
-      const workdir = output.args?.workdir;
-      if (!workdir)
-        return;
-      const hiveWorktreeBase = path8.join(directory, ".hive", ".worktrees");
-      if (!workdir.startsWith(hiveWorktreeBase))
-        return;
-      const wrapped = DockerSandboxService.wrapCommand(workdir, command, sandboxConfig);
-      output.args.command = wrapped;
-      output.args.workdir = undefined;
+      const snipConfig = configService.get().snip;
+      let finalCommand = command;
+      if (snipConfig?.enabled) {
+        finalCommand = prefixWithSnip(command, snipConfig.command ?? "snip");
+      }
+      const sandboxConfig = configService.getSandboxConfig();
+      if (sandboxConfig.mode !== "none") {
+        const workdir = output.args?.workdir;
+        if (workdir) {
+          const hiveWorktreeBase = path9.join(directory, ".hive", ".worktrees");
+          if (workdir.startsWith(hiveWorktreeBase)) {
+            const wrapped = DockerSandboxService.wrapCommand(workdir, finalCommand, sandboxConfig);
+            output.args.command = wrapped;
+            output.args.workdir = undefined;
+            return;
+          }
+        }
+      }
+      if (snipConfig?.enabled && finalCommand !== command) {
+        output.args.command = finalCommand;
+      }
     },
     "tool.execute.after": async (input, output) => {
       const truncationConfig = configService.get().tokenTruncation;
@@ -25818,8 +26949,17 @@ ${snapshot}
       hive_memory_list: hiveMemoryListTool,
       hive_memory_set: hiveMemorySetTool,
       hive_memory_replace: hiveMemoryReplaceTool,
+      hive_memory_recall: hiveMemoryRecallTool,
+      hive_memory_update: hiveMemoryUpdateTool,
+      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,
       hive_skill: createHiveSkillTool(filteredSkills),
       hive_feature_create: tool({
         description: "Create a new feature and set it as active",
@@ -26787,9 +27927,52 @@ ${Object.entries(customAgentConfigs).sort(([left], [right]) => left.localeCompar
           }
         }
       }
+    },
+    event: async (input) => {
+      const smartTitleConfig = configService.get().smartTitle;
+      if (!smartTitleConfig?.enabled)
+        return;
+      const { event } = input;
+      if (event.type === "message.created" || event.type === "message-part.created") {
+        const sessionID = event.properties?.sessionID;
+        const role = event.properties?.role;
+        const content = event.properties?.content;
+        if (sessionID && role === "user" && content && !sessionFirstMessage.has(sessionID)) {
+          sessionFirstMessage.set(sessionID, content);
+        }
+      }
+      if (event.type === "session.idle") {
+        const sessionID = event.properties?.sessionID;
+        if (!sessionID)
+          return;
+        if (sessionID.includes("-worker-") || sessionID.includes("-sub-"))
+          return;
+        const currentCount = (sessionIdleCount.get(sessionID) || 0) + 1;
+        sessionIdleCount.set(sessionID, currentCount);
+        if (currentCount % (smartTitleConfig.updateThreshold ?? 1) !== 0)
+          return;
+        const firstMessage = sessionFirstMessage.get(sessionID);
+        if (firstMessage) {
+          const title = generateSmartTitle(firstMessage);
+          console.log(`[hive:smart-title] Title for ${sessionID}: "${title}"`);
+        }
+      }
     }
   };
 };
+var sessionIdleCount = new Map;
+var sessionFirstMessage = new Map;
+function generateSmartTitle(message) {
+  if (!message)
+    return "Untitled session";
+  let cleaned = message.trim();
+  cleaned = cleaned.replace(/^(user[:\s]*|human[:\s]*|hi[,!\s]*|hello[,!\s]*|hey[,!\s]*)/i, "");
+  if (cleaned.length > 50) {
+    cleaned = cleaned.slice(0, 47) + "...";
+  }
+  cleaned = cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+  return cleaned || "Untitled session";
+}
 var src_default = plugin;
 export {
   src_default as default