@swarmvaultai/engine 0.1.26 → 0.1.28

package/dist/index.js

@@ -21,19 +21,35 @@ import {
   uniqueBy,
   writeFileIfChanged,
   writeJsonFile
-} from "./chunk-LEUV6TWJ.js";
+} from "./chunk-EXD4RWT3.js";
 
 // src/agents.ts
+import crypto from "crypto";
 import fs from "fs/promises";
 import path from "path";
+import YAML from "yaml";
 var managedStart = "<!-- swarmvault:managed:start -->";
 var managedEnd = "<!-- swarmvault:managed:end -->";
 var legacyManagedStart = "<!-- vault:managed:start -->";
 var legacyManagedEnd = "<!-- vault:managed:end -->";
+var claudeHookMatcher = "Glob|Grep";
+var claudeHookCommand = "if [ -f wiki/graph/report.md ]; then echo 'swarmvault: Graph report exists. Read wiki/graph/report.md before broad raw-file searching.'; fi";
+var geminiSessionMatcher = "startup";
+var geminiSearchMatcher = "glob|grep|search|find";
+var copilotHookVersion = 1;
+var agentFileKinds = {
+  agents: "AGENTS.md",
+  claude: "CLAUDE.md",
+  gemini: "GEMINI.md",
+  cursor: ".cursor/rules/swarmvault.mdc",
+  aider: "CONVENTIONS.md",
+  copilot: ".github/copilot-instructions.md"
+};
 function buildManagedBlock(target) {
-  const body = [
+  const heading = target === "aider" ? "# SwarmVault Conventions" : target === "copilot" ? "# SwarmVault Repository Instructions" : "# SwarmVault Rules";
+  return [
     managedStart,
-    "# SwarmVault Rules",
+    heading,
     "",
     "- Read `swarmvault.schema.md` before compile or query style work. It is the canonical schema path.",
     "- Treat `raw/` as immutable source input.",
@@ -46,55 +62,75 @@ function buildManagedBlock(target) {
     managedEnd,
     ""
   ].join("\n");
-  if (target === "cursor") {
-    return body;
-  }
-  return body;
 }
-var claudeHookMatcher = "Glob|Grep";
-var claudeHookCommand = "if [ -f wiki/graph/report.md ]; then echo 'swarmvault: Graph report exists. Read wiki/graph/report.md before broad raw-file searching.'; fi";
-async function installClaudeHook(rootDir) {
-  const settingsPath = path.join(rootDir, ".claude", "settings.json");
-  await ensureDir(path.dirname(settingsPath));
-  let settings = {};
-  if (await fileExists(settingsPath)) {
-    try {
-      settings = JSON.parse(await fs.readFile(settingsPath, "utf8"));
-    } catch {
-      settings = {};
-    }
-  }
-  const hooks = settings.hooks ?? {};
-  const preToolUse = hooks.PreToolUse ?? [];
-  const exists = preToolUse.some((entry) => entry.matcher === claudeHookMatcher && JSON.stringify(entry).includes("swarmvault:"));
-  if (!exists) {
-    preToolUse.push({
-      matcher: claudeHookMatcher,
-      hooks: [{ type: "command", command: claudeHookCommand }]
-    });
-  }
-  settings.hooks = { ...hooks, PreToolUse: preToolUse };
-  await fs.writeFile(settingsPath, `${JSON.stringify(settings, null, 2)}
-`, "utf8");
-  return settingsPath;
+function supportsAgentHook(agent) {
+  return agent === "claude" || agent === "opencode" || agent === "gemini" || agent === "copilot";
 }
-function targetPathForAgent(rootDir, agent) {
+function primaryTargetPathForAgent(rootDir, agent) {
   switch (agent) {
     case "codex":
     case "goose":
     case "pi":
     case "opencode":
-      return path.join(rootDir, "AGENTS.md");
+      return path.join(rootDir, agentFileKinds.agents);
     case "claude":
-      return path.join(rootDir, "CLAUDE.md");
+      return path.join(rootDir, agentFileKinds.claude);
     case "gemini":
-      return path.join(rootDir, "GEMINI.md");
+      return path.join(rootDir, agentFileKinds.gemini);
     case "cursor":
-      return path.join(rootDir, ".cursor", "rules", "swarmvault.mdc");
+      return path.join(rootDir, agentFileKinds.cursor);
+    case "aider":
+      return path.join(rootDir, agentFileKinds.aider);
+    case "copilot":
+      return path.join(rootDir, agentFileKinds.copilot);
     default:
       throw new Error(`Unsupported agent ${String(agent)}`);
   }
 }
+function hookScriptPathForAgent(rootDir, agent) {
+  switch (agent) {
+    case "opencode":
+      return path.join(rootDir, ".opencode", "plugins", "swarmvault-graph-first.js");
+    case "gemini":
+      return path.join(rootDir, ".gemini", "hooks", "swarmvault-graph-first.js");
+    case "copilot":
+      return path.join(rootDir, ".github", "hooks", "swarmvault-graph-first.js");
+    default:
+      return null;
+  }
+}
+function hookConfigPathForAgent(rootDir, agent) {
+  switch (agent) {
+    case "claude":
+      return path.join(rootDir, ".claude", "settings.json");
+    case "gemini":
+      return path.join(rootDir, ".gemini", "settings.json");
+    case "copilot":
+      return path.join(rootDir, ".github", "hooks", "swarmvault-graph-first.json");
+    default:
+      return null;
+  }
+}
+function targetsForAgent(rootDir, agent, options = {}) {
+  const targets = [primaryTargetPathForAgent(rootDir, agent)];
+  if (agent === "copilot") {
+    targets.push(path.join(rootDir, agentFileKinds.agents));
+  }
+  if (agent === "aider") {
+    targets.push(path.join(rootDir, ".aider.conf.yml"));
+  }
+  if (options.hook && supportsAgentHook(agent)) {
+    const configPath = hookConfigPathForAgent(rootDir, agent);
+    const scriptPath = hookScriptPathForAgent(rootDir, agent);
+    if (configPath) {
+      targets.push(configPath);
+    }
+    if (scriptPath) {
+      targets.push(scriptPath);
+    }
+  }
+  return [...new Set(targets)];
+}
 async function upsertManagedBlock(filePath, block) {
   const existing = await fileExists(filePath) ? await fs.readFile(filePath, "utf8") : "";
   if (!existing) {
@@ -115,51 +151,510 @@ async function upsertManagedBlock(filePath, block) {
 ${block}
 `, "utf8");
 }
+async function writeOwnedFile(filePath, content, executable = false) {
+  await ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content, {
+    encoding: "utf8",
+    mode: executable ? 493 : 420
+  });
+  if (executable) {
+    await fs.chmod(filePath, 493);
+  }
+}
+async function readJsonWithWarnings(filePath, fallback, label) {
+  if (!await fileExists(filePath)) {
+    return { data: fallback, warnings: [] };
+  }
+  try {
+    const parsed = JSON.parse(await fs.readFile(filePath, "utf8"));
+    return { data: parsed, warnings: [] };
+  } catch {
+    return {
+      data: fallback,
+      warnings: [`Could not parse ${label}. Left the existing file unchanged.`]
+    };
+  }
+}
+async function installClaudeHook(rootDir) {
+  const settingsPath = path.join(rootDir, ".claude", "settings.json");
+  await ensureDir(path.dirname(settingsPath));
+  const { data: settings, warnings } = await readJsonWithWarnings(settingsPath, {}, ".claude/settings.json");
+  if (warnings.length > 0 && await fileExists(settingsPath)) {
+    return { path: settingsPath, warnings };
+  }
+  const hooks = settings.hooks ?? {};
+  const preToolUse = hooks.PreToolUse ?? [];
+  const exists = preToolUse.some((entry) => entry.matcher === claudeHookMatcher && JSON.stringify(entry).includes("swarmvault:"));
+  if (!exists) {
+    preToolUse.push({
+      matcher: claudeHookMatcher,
+      hooks: [{ type: "command", command: claudeHookCommand }]
+    });
+  }
+  settings.hooks = { ...hooks, PreToolUse: preToolUse };
+  await fs.writeFile(settingsPath, `${JSON.stringify(settings, null, 2)}
+`, "utf8");
+  return { path: settingsPath, warnings: [] };
+}
+function markerStateSnippet(agentKey) {
+  return `
+function markerState(cwd) {
+  const hash = crypto.createHash("sha256").update(cwd).digest("hex");
+  const dir = path.join(os.tmpdir(), "swarmvault-agent-hooks", "${agentKey}", hash);
+  return {
+    dir,
+    markerPath: path.join(dir, "report-read")
+  };
+}
+
+function isReportPath(value, cwd) {
+  if (typeof value !== "string" || value.length === 0) {
+    return false;
+  }
+  const reportSuffix = path.join("wiki", "graph", "report.md");
+  const normalized = value.replaceAll("\\\\", "/");
+  const reportNormalized = reportSuffix.replaceAll("\\\\", "/");
+  if (normalized.endsWith(reportNormalized)) {
+    return true;
+  }
+  return path.resolve(cwd, value) === path.resolve(cwd, reportSuffix);
+}
+
+function collectCandidatePaths(node, acc = []) {
+  if (typeof node === "string") {
+    acc.push(node);
+    return acc;
+  }
+  if (!node || typeof node !== "object") {
+    return acc;
+  }
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      collectCandidatePaths(item, acc);
+    }
+    return acc;
+  }
+  for (const [key, value] of Object.entries(node)) {
+    if (["path", "filePath", "file_path", "paths", "target", "targets"].includes(key)) {
+      collectCandidatePaths(value, acc);
+    }
+  }
+  return acc;
+}
+
+function resolveInputCwd(input) {
+  return path.resolve(
+    input?.cwd ??
+      input?.directory ??
+      input?.workspace?.cwd ??
+      input?.toolInput?.cwd ??
+      process.cwd()
+  );
+}
+
+function resolveToolName(input) {
+  return String(input?.toolName ?? input?.tool_name ?? input?.tool?.name ?? input?.name ?? "");
+}
+
+async function hasReport(cwd) {
+  try {
+    await fs.access(path.join(cwd, "wiki", "graph", "report.md"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function markReportRead(cwd) {
+  const state = markerState(cwd);
+  await fs.mkdir(state.dir, { recursive: true });
+  await fs.writeFile(state.markerPath, "seen\\n", "utf8");
+}
+
+async function hasSeenReport(cwd) {
+  const state = markerState(cwd);
+  try {
+    await fs.access(state.markerPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function resetSession(cwd) {
+  const state = markerState(cwd);
+  await fs.rm(state.dir, { recursive: true, force: true });
+}
+
+function isBroadSearchTool(toolName) {
+  return /grep|glob|search|find/i.test(toolName);
+}
+`;
+}
+function buildGeminiHookScript() {
+  return `#!/usr/bin/env node
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+${markerStateSnippet("gemini").trim()}
+
+async function readInput() {
+  let body = "";
+  for await (const chunk of process.stdin) {
+    body += chunk;
+  }
+  if (!body.trim()) {
+    return {};
+  }
+  try {
+    return JSON.parse(body);
+  } catch {
+    return {};
+  }
+}
+
+function emit(value) {
+  process.stdout.write(\`\${JSON.stringify(value)}\\n\`);
+}
+
+const mode = process.argv[2] ?? "";
+const input = await readInput();
+const cwd = resolveInputCwd(input);
+const reportNote = "SwarmVault graph report exists at wiki/graph/report.md. Read it before broad grep/glob searching.";
+
+if (!(await hasReport(cwd))) {
+  emit({});
+  process.exit(0);
+}
+
+if (mode === "session-start") {
+  await resetSession(cwd);
+  emit({
+    systemMessage: reportNote,
+    hookSpecificOutput: {
+      hookEventName: "SessionStart",
+      additionalContext: "SwarmVault graph report: wiki/graph/report.md"
+    }
+  });
+  process.exit(0);
+}
+
+const toolName = resolveToolName(input);
+if (collectCandidatePaths(input).some((value) => isReportPath(value, cwd))) {
+  await markReportRead(cwd);
+  emit({});
+  process.exit(0);
+}
+
+if (isBroadSearchTool(toolName) && !(await hasSeenReport(cwd))) {
+  emit({ systemMessage: reportNote });
+  process.exit(0);
+}
+
+emit({});
+`;
+}
+function buildCopilotHookScript() {
+  return `#!/usr/bin/env node
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+${markerStateSnippet("copilot").trim()}
+
+async function readInput() {
+  let body = "";
+  for await (const chunk of process.stdin) {
+    body += chunk;
+  }
+  if (!body.trim()) {
+    return {};
+  }
+  try {
+    return JSON.parse(body);
+  } catch {
+    return {};
+  }
+}
+
+function emit(value) {
+  if (value !== undefined) {
+    process.stdout.write(\`\${JSON.stringify(value)}\\n\`);
+  }
+}
+
+const mode = process.argv[2] ?? "";
+const input = await readInput();
+const cwd = resolveInputCwd(input);
+const reportNote = "SwarmVault graph report exists at wiki/graph/report.md. Read it before broad grep/glob searching.";
+
+if (!(await hasReport(cwd))) {
+  emit({});
+  process.exit(0);
+}
+
+if (mode === "session-start") {
+  await resetSession(cwd);
+  emit({});
+  process.exit(0);
+}
+
+const toolName = resolveToolName(input);
+if (collectCandidatePaths(input).some((value) => isReportPath(value, cwd))) {
+  await markReportRead(cwd);
+  emit({});
+  process.exit(0);
+}
+
+if (isBroadSearchTool(toolName) && !(await hasSeenReport(cwd))) {
+  emit({
+    permissionDecision: "deny",
+    permissionDecisionReason: reportNote
+  });
+  process.exit(0);
+}
+
+emit({});
+`;
+}
+function buildOpenCodePlugin() {
+  return `import path from "node:path";
+
+const reportRelativePath = path.join("wiki", "graph", "report.md");
+
+export const name = "swarmvault-graph-first";
+
+export default async function swarmvaultGraphFirst({ client }) {
+  let reportSeen = false;
+
+  async function hasReport(cwd) {
+    try {
+      await Bun.file(path.join(cwd, reportRelativePath)).arrayBuffer();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async function note(message) {
+    if (client?.app?.log) {
+      await client.app.log({
+        level: "info",
+        message
+      });
+    }
+  }
+
+  return {
+    async "session.created"(input) {
+      reportSeen = false;
+      const cwd = input?.session?.cwd ?? process.cwd();
+      if (await hasReport(cwd)) {
+        await note("SwarmVault graph report exists. Read wiki/graph/report.md before broad workspace searching.");
+      }
+    },
+    async "tool.execute.before"(input) {
+      const cwd = input?.session?.cwd ?? process.cwd();
+      if (!(await hasReport(cwd))) {
+        return;
+      }
+
+      const argsText = JSON.stringify(input?.args ?? {});
+      if (argsText.includes("wiki/graph/report.md")) {
+        reportSeen = true;
+        return;
+      }
+
+      if (!reportSeen && ["glob", "grep"].includes(String(input?.tool ?? ""))) {
+        await note("SwarmVault graph report exists. Read wiki/graph/report.md before broad workspace searching.");
+      }
+    }
+  };
+}
+`;
+}
+async function installGeminiHook(rootDir) {
+  const settingsPath = path.join(rootDir, ".gemini", "settings.json");
+  const scriptPath = path.join(rootDir, ".gemini", "hooks", "swarmvault-graph-first.js");
+  await writeOwnedFile(scriptPath, buildGeminiHookScript(), true);
+  const { data: settings, warnings } = await readJsonWithWarnings(settingsPath, {}, ".gemini/settings.json");
+  if (warnings.length > 0 && await fileExists(settingsPath)) {
+    return { paths: [settingsPath, scriptPath], warnings };
+  }
+  const hooks = settings.hooks ?? {};
+  const sessionStart = hooks.SessionStart ?? [];
+  const beforeTool = hooks.BeforeTool ?? [];
+  const sessionCommand = "node .gemini/hooks/swarmvault-graph-first.js session-start";
+  const beforeToolCommand = "node .gemini/hooks/swarmvault-graph-first.js before-tool";
+  if (!sessionStart.some((entry) => entry.matcher === geminiSessionMatcher && JSON.stringify(entry).includes("swarmvault-graph-first.js"))) {
+    sessionStart.push({
+      matcher: geminiSessionMatcher,
+      hooks: [{ name: "swarmvault-graph-first", type: "command", command: sessionCommand }]
+    });
+  }
+  if (!beforeTool.some((entry) => entry.matcher === geminiSearchMatcher && JSON.stringify(entry).includes("swarmvault-graph-first.js"))) {
+    beforeTool.push({
+      matcher: geminiSearchMatcher,
+      hooks: [{ name: "swarmvault-graph-first", type: "command", command: beforeToolCommand }]
+    });
+  }
+  settings.hooks = {
+    ...hooks,
+    SessionStart: sessionStart,
+    BeforeTool: beforeTool
+  };
+  await writeOwnedFile(settingsPath, `${JSON.stringify(settings, null, 2)}
+`);
+  return { paths: [settingsPath, scriptPath], warnings: [] };
+}
+async function mergeAiderConfig(rootDir) {
+  const configPath = path.join(rootDir, ".aider.conf.yml");
+  const readTarget = "CONVENTIONS.md";
+  if (!await fileExists(configPath)) {
+    const document = new YAML.Document();
+    document.set("read", [readTarget]);
+    await writeOwnedFile(configPath, `${document.toString()}`);
+    return { path: configPath, warnings: [] };
+  }
+  try {
+    const source = await fs.readFile(configPath, "utf8");
+    const document = YAML.parseDocument(source);
+    if (document.errors.length > 0) {
+      return {
+        path: configPath,
+        warnings: ["Could not parse .aider.conf.yml. Left the existing file unchanged; add `read: CONVENTIONS.md` manually."]
+      };
+    }
+    const currentRead = document.get("read", true);
+    const values = typeof currentRead === "string" ? [currentRead] : Array.isArray(currentRead) ? currentRead.filter((item) => typeof item === "string") : [];
+    if (!values.includes(readTarget)) {
+      document.set("read", [...values, readTarget]);
+      await writeOwnedFile(configPath, `${document.toString()}`);
+    }
+    return { path: configPath, warnings: [] };
+  } catch {
+    return {
+      path: configPath,
+      warnings: ["Could not parse .aider.conf.yml. Left the existing file unchanged; add `read: CONVENTIONS.md` manually."]
+    };
+  }
+}
+async function installCopilotHook(rootDir) {
+  const hooksDir = path.join(rootDir, ".github", "hooks");
+  const scriptPath = path.join(hooksDir, "swarmvault-graph-first.js");
+  const configPath = path.join(hooksDir, "swarmvault-graph-first.json");
+  await writeOwnedFile(scriptPath, buildCopilotHookScript(), true);
+  const config = {
+    version: copilotHookVersion,
+    hooks: {
+      sessionStart: [
+        {
+          type: "command",
+          bash: "node .github/hooks/swarmvault-graph-first.js session-start",
+          powershell: "node .github/hooks/swarmvault-graph-first.js session-start",
+          cwd: ".",
+          timeoutSec: 10
+        }
+      ],
+      preToolUse: [
+        {
+          matcher: "glob|grep",
+          type: "command",
+          bash: "node .github/hooks/swarmvault-graph-first.js pre-tool-use",
+          powershell: "node .github/hooks/swarmvault-graph-first.js pre-tool-use",
+          cwd: ".",
+          timeoutSec: 10
+        }
+      ]
+    }
+  };
+  await writeOwnedFile(configPath, `${JSON.stringify(config, null, 2)}
+`);
+  return { paths: [configPath, scriptPath], warnings: [] };
+}
+async function installOpenCodeHook(rootDir) {
+  const pluginPath = path.join(rootDir, ".opencode", "plugins", "swarmvault-graph-first.js");
+  await writeOwnedFile(pluginPath, buildOpenCodePlugin());
+  return { paths: [pluginPath], warnings: [] };
+}
+function stableKeyForAgent(rootDir, agent) {
+  if (agent === "codex" || agent === "goose" || agent === "pi") {
+    return `shared:${path.join(rootDir, agentFileKinds.agents)}`;
+  }
+  return `${agent}:${crypto.createHash("sha1").update(targetsForAgent(rootDir, agent, { hook: supportsAgentHook(agent) }).join("\n")).digest("hex")}`;
+}
 async function installAgent(rootDir, agent, options = {}) {
   await initWorkspace(rootDir);
-  const target = targetPathForAgent(rootDir, agent);
+  const target = primaryTargetPathForAgent(rootDir, agent);
+  const warnings = [];
   switch (agent) {
     case "codex":
     case "goose":
     case "pi":
     case "opencode":
-      await upsertManagedBlock(target, buildManagedBlock("agents"));
-      return target;
-    case "claude": {
+      await upsertManagedBlock(path.join(rootDir, agentFileKinds.agents), buildManagedBlock("agents"));
+      break;
+    case "claude":
       await upsertManagedBlock(target, buildManagedBlock("claude"));
-      if (options.claudeHook) {
-        await installClaudeHook(rootDir);
-      }
-      return target;
-    }
-    case "gemini": {
+      break;
+    case "gemini":
       await upsertManagedBlock(target, buildManagedBlock("gemini"));
-      return target;
-    }
-    case "cursor": {
-      const rulesDir = path.dirname(target);
-      await ensureDir(rulesDir);
-      await fs.writeFile(target, `${buildManagedBlock("cursor")}
-`, "utf8");
-      return target;
-    }
+      break;
+    case "cursor":
+      await writeOwnedFile(target, `${buildManagedBlock("cursor")}
+`);
+      break;
+    case "aider":
+      await upsertManagedBlock(target, buildManagedBlock("aider"));
+      break;
+    case "copilot":
+      await upsertManagedBlock(path.join(rootDir, agentFileKinds.agents), buildManagedBlock("agents"));
+      await upsertManagedBlock(target, buildManagedBlock("copilot"));
+      break;
     default:
       throw new Error(`Unsupported agent ${String(agent)}`);
   }
+  if (agent === "aider") {
+    const aiderResult = await mergeAiderConfig(rootDir);
+    warnings.push(...aiderResult.warnings);
+  }
+  if (options.hook && supportsAgentHook(agent)) {
+    if (agent === "claude") {
+      const result = await installClaudeHook(rootDir);
+      warnings.push(...result.warnings);
+    }
+    if (agent === "opencode") {
+      const result = await installOpenCodeHook(rootDir);
+      warnings.push(...result.warnings);
+    }
+    if (agent === "gemini") {
+      const result = await installGeminiHook(rootDir);
+      warnings.push(...result.warnings);
+    }
+    if (agent === "copilot") {
+      const result = await installCopilotHook(rootDir);
+      warnings.push(...result.warnings);
+    }
+  }
+  const targets = targetsForAgent(rootDir, agent, options);
+  return warnings.length > 0 ? { agent, target, targets, warnings } : { agent, target, targets };
 }
 async function installConfiguredAgents(rootDir) {
   const { config } = await initWorkspace(rootDir);
-  const dedupedTargets = /* @__PURE__ */ new Map();
+  const dedupedAgents = /* @__PURE__ */ new Map();
   for (const agent of config.agents) {
-    const target = targetPathForAgent(rootDir, agent);
-    if (!dedupedTargets.has(target)) {
-      dedupedTargets.set(target, agent);
+    const key = stableKeyForAgent(rootDir, agent);
+    if (!dedupedAgents.has(key)) {
+      dedupedAgents.set(key, agent);
     }
   }
   return Promise.all(
-    [...dedupedTargets.values()].map(
+    [...dedupedAgents.values()].map(
       (agent) => installAgent(rootDir, agent, {
-        claudeHook: agent === "claude"
+        hook: supportsAgentHook(agent)
       })
     )
   );
@@ -536,6 +1031,7 @@ async function exportGraphFormat(rootDir, format, outputPath) {
 // src/hooks.ts
 import fs3 from "fs/promises";
 import path3 from "path";
+import process2 from "process";
 var hookStart = "# >>> swarmvault hook >>>";
 var hookEnd = "# <<< swarmvault hook <<<";
 async function findNearestGitRoot(startPath) {
@@ -562,12 +1058,22 @@ async function findNearestGitRoot(startPath) {
 function shellQuote(value) {
   return `'${value.replace(/'/g, `'"'"'`)}'`;
 }
+function resolveSwarmvaultExecutableCandidate() {
+  const argvPath = process2.argv[1];
+  if (typeof argvPath === "string" && argvPath.trim() && (argvPath.includes(`${path3.sep}@swarmvaultai${path3.sep}cli${path3.sep}`) || argvPath.includes(`${path3.sep}packages${path3.sep}cli${path3.sep}`))) {
+    return path3.resolve(argvPath);
+  }
+  return "swarmvault";
+}
 function managedHookBlock(vaultRoot) {
+  const resolvedExecutable = resolveSwarmvaultExecutableCandidate();
   return [
     hookStart,
     `cd ${shellQuote(vaultRoot)} || exit 0`,
-    "if command -v swarmvault >/dev/null 2>&1; then",
-    "  swarmvault watch --repo --once >/dev/null 2>&1 || printf '[swarmvault hook] refresh failed\\n' >&2",
+    `swarmvault_bin=${shellQuote(resolvedExecutable)}`,
+    '[ ! -x "$swarmvault_bin" ] && swarmvault_bin=$(command -v swarmvault 2>/dev/null || true)',
+    'if [ -n "$swarmvault_bin" ] && [ -x "$swarmvault_bin" ]; then',
+    `  "$swarmvault_bin" watch --repo --once >/dev/null 2>&1 || printf '[swarmvault hook] refresh failed\\n' >&2`,
     "fi",
     hookEnd,
     ""
@@ -663,6 +1169,7 @@ async function uninstallGitHooks(rootDir) {
 // src/ingest.ts
 import fs9 from "fs/promises";
 import path10 from "path";
+import { pathToFileURL } from "url";
 import { Readability } from "@mozilla/readability";
 import matter3 from "gray-matter";
 import ignore from "ignore";
@@ -3342,6 +3849,9 @@ function inferKind(mimeType, filePath) {
   if (mimeType.includes("markdown")) {
     return "markdown";
   }
+  if (mimeType.includes("html")) {
+    return "html";
+  }
   if (mimeType.startsWith("text/")) {
     return "text";
   }
@@ -3351,9 +3861,6 @@ function inferKind(mimeType, filePath) {
   if (mimeType.startsWith("image/")) {
     return "image";
   }
-  if (mimeType.includes("html")) {
-    return "html";
-  }
   return "binary";
 }
 function titleFromText(fallback, content) {
@@ -4429,6 +4936,12 @@ async function prepareFileInput(rootDir, absoluteInput, repoRoot, sourceClass) {
     extractedText = payloadBytes.toString("utf8");
     title = titleFromText(path10.basename(absoluteInput, path10.extname(absoluteInput)), extractedText);
     extractionArtifact = createPlainTextExtractionArtifact(sourceKind, mimeType);
+  } else if (sourceKind === "html") {
+    const html = payloadBytes.toString("utf8");
+    const converted = await convertHtmlToMarkdown(html, pathToFileURL(absoluteInput).toString());
+    title = converted.title;
+    extractedText = converted.markdown;
+    extractionArtifact = createHtmlReadabilityExtractionArtifact(sourceKind, mimeType);
   } else if (sourceKind === "pdf") {
     title = path10.basename(absoluteInput, path10.extname(absoluteInput));
     const extracted = await extractPdfText({ mimeType, bytes: payloadBytes });
@@ -5681,7 +6194,7 @@ function summarizeRoleQuestions(results) {
 
 // src/web-search/registry.ts
 import path14 from "path";
-import { pathToFileURL } from "url";
+import { pathToFileURL as pathToFileURL2 } from "url";
 import { z as z4 } from "zod";
 
 // src/web-search/http-json.ts
@@ -5779,7 +6292,7 @@ async function createWebSearchAdapter(id, config, rootDir) {
         throw new Error(`Web search provider ${id} is type "custom" but no module path was configured.`);
       }
       const resolvedModule = path14.isAbsolute(config.module) ? config.module : path14.resolve(rootDir, config.module);
-      const loaded = await import(pathToFileURL(resolvedModule).href);
+      const loaded = await import(pathToFileURL2(resolvedModule).href);
       const parsed = customWebSearchModuleSchema.parse(loaded);
       return parsed.createAdapter(id, config, rootDir);
     }
@@ -9200,7 +9713,7 @@ async function resolveImageGenerationProvider(rootDir) {
   if (!providerConfig) {
     throw new Error(`No provider configured with id "${preferredProviderId}" for task "imageProvider".`);
   }
-  const { createProvider: createProvider2 } = await import("./registry-YGVTLIZH.js");
+  const { createProvider: createProvider2 } = await import("./registry-KLO5YIHP.js");
   return createProvider2(preferredProviderId, providerConfig, rootDir);
 }
 async function generateOutputArtifacts(rootDir, input) {
@@ -12475,7 +12988,7 @@ async function bootstrapDemo(rootDir, input) {
 }
 
 // src/mcp.ts
-var SERVER_VERSION = "0.1.26";
+var SERVER_VERSION = "0.1.28";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",
@@ -13133,7 +13646,7 @@ import mime2 from "mime-types";
 
 // src/watch.ts
 import path23 from "path";
-import process2 from "process";
+import process3 from "process";
 import chokidar from "chokidar";
 var MAX_BACKOFF_MS = 3e4;
 var BACKOFF_THRESHOLD = 3;
@@ -13398,7 +13911,7 @@ async function watchVault(rootDir, options = {}) {
       consecutiveFailures++;
       pending = true;
       if (consecutiveFailures >= CRITICAL_THRESHOLD) {
-        process2.stderr.write(
+        process3.stderr.write(
           `[swarmvault watch] ${consecutiveFailures} consecutive failures. Check vault state. Continuing at max backoff.
 `
         );