@hivelore/cli 0.33.0 → 0.34.1

package/dist/index.js

@@ -10,7 +10,7 @@ import {
   preCommitCheck,
   readPresumedCorrectTargets,
   runHaiveMcpStdio
-} from "./chunk-XDB7EKL4.js";
+} from "./chunk-X6UHROFL.js";
 import {
   registerMemoryPending
 } from "./chunk-OYJKHD22.js";
@@ -208,7 +208,7 @@ async function getHotFiles(root, daysBack, maxHotFiles, filePaths) {
       if (!f) continue;
       counts.set(f, (counts.get(f) ?? 0) + 1);
     }
-    let entries = [...counts.entries()].map(([path46, changes]) => ({ path: path46, changes }));
+    let entries = [...counts.entries()].map(([path47, changes]) => ({ path: path47, changes }));
     const lowerPaths = filePaths.map((p) => p.toLowerCase());
     if (lowerPaths.length > 0) {
       entries = entries.filter((e) => lowerPaths.some((p) => e.path.toLowerCase().includes(p)));
@@ -322,9 +322,9 @@ async function lintMemoriesAsync(root, options = {}) {
         message: "Reads like generic best practice a capable model already follows. Hivelore's value is UNGUESSABLE team knowledge \u2014 add the concrete, arbitrary specifics (exact names, values, formats, magic numbers) or consider removing it to keep briefings high-signal."
       });
     }
-    const suggestedAnchors = suggestAnchors(root, { filePath, memory: memory2 }, codeMap, trackedFiles);
-    const isUnanchoredSeed = fm.tags.includes("stack-pack") && fm.tags.includes("needs_anchor");
-    if (ANCHOR_TYPES.has(fm.type) && fm.anchor.paths.length === 0 && fm.status === "validated" && !isUnanchoredSeed) {
+    const isStackSeed = fm.tags.includes("stack-pack");
+    const suggestedAnchors = isStackSeed ? { paths: [], symbols: [] } : suggestAnchors(root, { filePath, memory: memory2 }, codeMap, trackedFiles);
+    if (ANCHOR_TYPES.has(fm.type) && fm.anchor.paths.length === 0 && fm.status === "validated" && !isStackSeed) {
       out.push({
         file: filePath,
         id: fm.id,
@@ -728,20 +728,7 @@ async function projectContextVersionStatus(root, paths) {
 async function refreshCodeMap(root, paths, force) {
   const existing = await loadCodeMap2(paths);
   if (existing && !force) return false;
-  const map = await buildCodeMap(root, {
-    includeUntracked: true,
-    excludeDirs: [
-      "node_modules",
-      "dist",
-      "build",
-      "out",
-      ".git",
-      ".next",
-      ".turbo",
-      ".vitest-cache",
-      "coverage"
-    ]
-  });
+  const map = await buildCodeMap(root, { includeUntracked: true });
   if (existing && existing.root === map.root && JSON.stringify(existing.files) === JSON.stringify(map.files)) {
     return false;
   }
@@ -1355,6 +1342,7 @@ import path6 from "path";
 import "commander";
 import {
   buildCodeMap as buildCodeMap2,
+  CODE_MAP_DEFAULT_EXCLUDE,
   codeMapPath,
   findProjectRoot as findProjectRoot4,
   loadCodeMap as loadCodeMap4,
@@ -1383,18 +1371,7 @@ function registerIndexCode(program2) {
     ui.info(`Indexing source files in ${root}\u2026`);
     const map = await buildCodeMap2(root, {
       includeUntracked: true,
-      excludeDirs: [
-        "node_modules",
-        "dist",
-        "build",
-        "out",
-        ".git",
-        ".next",
-        ".turbo",
-        ".vitest-cache",
-        "coverage",
-        ...extraExcludes
-      ]
+      excludeDirs: [...CODE_MAP_DEFAULT_EXCLUDE, ...extraExcludes]
     });
     await saveCodeMap2(paths, map);
     const fileCount = Object.keys(map.files).length;
@@ -1504,14 +1481,14 @@ function isCodeMapStale(root, generatedAt, files) {
 // src/commands/init.ts
 import { execFile as execFile2 } from "child_process";
 import { mkdir as mkdir6, readFile as readFile6, readdir as readdir2, writeFile as writeFile7 } from "fs/promises";
-import { existsSync as existsSync11 } from "fs";
-import path12 from "path";
+import { existsSync as existsSync12 } from "fs";
+import path13 from "path";
 import { spawnSync as spawnSync3 } from "child_process";
 import { promisify as promisify2 } from "util";
 import "commander";
 import {
   AUTOPILOT_DEFAULTS as AUTOPILOT_DEFAULTS2,
-  BRIDGE_TARGETS,
+  BRIDGE_TARGETS as BRIDGE_TARGETS2,
   buildCodeMap as buildCodeMap3,
   buildFrontmatter as buildFrontmatter2,
   detectStacksFromManifests,
@@ -1523,20 +1500,93 @@ import {
   serializeMemory as serializeMemory3
 } from "@hivelore/core";
 
+// src/utils/doc-files.ts
+import { readdirSync } from "fs";
+function findDocFile(root, stem) {
+  let entries;
+  try {
+    entries = readdirSync(root);
+  } catch {
+    return void 0;
+  }
+  const re = new RegExp(`^${stem}(\\.(md|markdown|txt|rst))?$`, "i");
+  return entries.find((e) => re.test(e));
+}
+
+// src/utils/bridge-detect.ts
+import { existsSync as existsSync6, readdirSync as readdirSync2 } from "fs";
+import { homedir } from "os";
+import path7 from "path";
+import { BRIDGE_TARGET_PATH, BRIDGE_TARGETS } from "@hivelore/core";
+var VSCODE_EXTENSION_SIGNALS = {
+  copilot: ["github.copilot"],
+  cline: ["saoudrizwan.claude-dev"],
+  roo: ["rooveterinaryinc.roo"],
+  cody: ["sourcegraph.cody"],
+  continue: ["continue.continue"]
+};
+var HOME_SIGNALS = {
+  claude: [".claude", ".claude.json"],
+  cursor: [".cursor"],
+  windsurf: [".codeium/windsurf", ".windsurf"],
+  gemini: [".gemini"],
+  continue: [".continue"],
+  aider: [".aider.conf.yml", ".aider"],
+  zed: [".config/zed", "Library/Application Support/Zed"],
+  copilot: [".config/github-copilot"]
+};
+var ENV_SIGNALS = {
+  claude: ["CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT"],
+  cursor: ["CURSOR_AGENT"],
+  gemini: ["GEMINI_CLI"],
+  aider: ["AIDER_MODEL"]
+};
+function vscodeExtensionIds(home) {
+  const ids = [];
+  for (const dir of [".vscode/extensions", ".vscode-server/extensions", ".vscode-oss/extensions"]) {
+    try {
+      ids.push(...readdirSync2(path7.join(home, dir)).map((e) => e.toLowerCase()));
+    } catch {
+    }
+  }
+  return ids;
+}
+function detectBridgeTargets(root, env = process.env, home = homedir()) {
+  const reasons = { agents: "universal" };
+  const extensions = vscodeExtensionIds(home);
+  for (const target of BRIDGE_TARGETS) {
+    if (target === "agents") continue;
+    if (existsSync6(path7.join(root, BRIDGE_TARGET_PATH[target]))) {
+      reasons[target] = "repo file";
+      continue;
+    }
+    const homeHit = (HOME_SIGNALS[target] ?? []).some((p) => existsSync6(path7.join(home, p)));
+    const envHit = (ENV_SIGNALS[target] ?? []).some((v) => env[v]);
+    const extHit = (VSCODE_EXTENSION_SIGNALS[target] ?? []).some(
+      (prefix) => extensions.some((id) => id.startsWith(prefix))
+    );
+    if (homeHit || envHit || extHit) reasons[target] = "installed";
+  }
+  return {
+    targets: BRIDGE_TARGETS.filter((t) => t in reasons),
+    reasons
+  };
+}
+
 // src/utils/bridge-files.ts
 import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import path7 from "path";
+import { existsSync as existsSync7 } from "fs";
+import path8 from "path";
 import {
   BRIDGE_MARKERS,
-  BRIDGE_TARGET_PATH,
+  BRIDGE_TARGET_PATH as BRIDGE_TARGET_PATH2,
   generateBridges,
   isRetiredMemory,
   loadMemoriesFromDir as loadMemoriesFromDir5
 } from "@hivelore/core";
 async function writeBridgeFiles(root, paths, opts) {
   const result = { created: [], updated: [], unchanged: [], skipped: [], warnings: [] };
-  if (!existsSync6(paths.memoriesDir)) return result;
+  if (!existsSync7(paths.memoriesDir)) return result;
   const allLoaded = await loadMemoriesFromDir5(paths.memoriesDir);
   const memories = allLoaded.map((l) => l.memory).filter((m) => !isRetiredMemory(m.frontmatter, m.body));
   const sensors = [];
@@ -1554,8 +1604,8 @@ async function writeBridgeFiles(root, paths, opts) {
   const maxMemories = Math.max(1, opts.maxMemories ?? 8);
   const outputs = generateBridges(memories, sensors, { maxMemories, targets: opts.targets });
   for (const output of outputs) {
-    const targetFile = path7.join(root, output.path);
-    const fileExists = existsSync6(targetFile);
+    const targetFile = path8.join(root, output.path);
+    const fileExists = existsSync7(targetFile);
     if (opts.onlyExisting && !fileExists) continue;
     if (opts.dryRun) {
       if (!fileExists) {
@@ -1574,7 +1624,7 @@ async function writeBridgeFiles(root, paths, opts) {
       }
       continue;
     }
-    await mkdir2(path7.dirname(targetFile), { recursive: true });
+    await mkdir2(path8.dirname(targetFile), { recursive: true });
     if (!fileExists) {
       await writeFile3(targetFile, output.content, "utf8");
       result.created.push(output.path);
@@ -1597,10 +1647,10 @@ async function writeBridgeFiles(root, paths, opts) {
   return result;
 }
 async function getBridgeFileStatuses(root, paths, opts) {
-  if (!existsSync6(paths.memoriesDir)) {
+  if (!existsSync7(paths.memoriesDir)) {
     return opts.targets.map((target) => ({
       target,
-      path: BRIDGE_TARGET_PATH[target],
+      path: BRIDGE_TARGET_PATH2[target],
       exists: false,
       state: "missing",
       wouldChange: false,
@@ -1627,8 +1677,8 @@ async function getBridgeFileStatuses(root, paths, opts) {
   });
   const statuses = [];
   for (const output of outputs) {
-    const targetFile = path7.join(root, output.path);
-    const exists = existsSync6(targetFile);
+    const targetFile = path8.join(root, output.path);
+    const exists = existsSync7(targetFile);
     if (!exists) {
       statuses.push({
         target: output.target,
@@ -1784,18 +1834,18 @@ function legacyManagedRange(text) {
 
 // src/commands/agent.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { mkdir as mkdir4, writeFile as writeFile5 } from "fs/promises";
 import os2 from "os";
-import path9 from "path";
+import path10 from "path";
 import { createInterface } from "readline/promises";
 import "commander";
 import { findProjectRoot as findProjectRoot5, resolveHaivePaths as resolveHaivePaths5 } from "@hivelore/core";
 
 // src/commands/init-mcp-setup.ts
 import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
-import path8 from "path";
+import { existsSync as existsSync8 } from "fs";
+import path9 from "path";
 import os from "os";
 var HOME = os.homedir();
 var HAIVE_MCP_ENTRY = {
@@ -1810,14 +1860,14 @@ function projectMcpEntry(root) {
   };
 }
 function cursorMcpPath() {
-  return path8.join(HOME, ".cursor", "mcp.json");
+  return path9.join(HOME, ".cursor", "mcp.json");
 }
 async function configureCursor() {
   const mcpPath = cursorMcpPath();
-  const cursorDir = path8.join(HOME, ".cursor");
-  if (!existsSync7(cursorDir)) return { client: "Cursor", status: "not_installed" };
+  const cursorDir = path9.join(HOME, ".cursor");
+  if (!existsSync8(cursorDir)) return { client: "Cursor", status: "not_installed" };
   let config = {};
-  if (existsSync7(mcpPath)) {
+  if (existsSync8(mcpPath)) {
     try {
       config = JSON.parse(await readFile4(mcpPath, "utf8"));
     } catch {
@@ -1832,16 +1882,16 @@ async function configureCursor() {
 }
 function vscodeMcpPath() {
   const candidates = [
-    path8.join(HOME, ".config", "Code", "User", "mcp.json"),
+    path9.join(HOME, ".config", "Code", "User", "mcp.json"),
     // Linux
-    path8.join(HOME, "Library", "Application Support", "Code", "User", "mcp.json"),
+    path9.join(HOME, "Library", "Application Support", "Code", "User", "mcp.json"),
     // macOS
-    path8.join(HOME, "AppData", "Roaming", "Code", "User", "mcp.json"),
+    path9.join(HOME, "AppData", "Roaming", "Code", "User", "mcp.json"),
     // Windows
-    path8.join(HOME, ".config", "Code - Insiders", "User", "mcp.json")
+    path9.join(HOME, ".config", "Code - Insiders", "User", "mcp.json")
   ];
   for (const c of candidates) {
-    if (existsSync7(path8.dirname(c))) return c;
+    if (existsSync8(path9.dirname(c))) return c;
   }
   return null;
 }
@@ -1849,7 +1899,7 @@ async function configureVSCode() {
   const mcpPath = vscodeMcpPath();
   if (!mcpPath) return { client: "VS Code", status: "not_installed" };
   let config = {};
-  if (existsSync7(mcpPath)) {
+  if (existsSync8(mcpPath)) {
     try {
       config = JSON.parse(await readFile4(mcpPath, "utf8"));
     } catch {
@@ -1858,24 +1908,24 @@ async function configureVSCode() {
   config.servers ??= {};
   if (config.servers["hivelore"] || config.servers["haive"]) return { client: "VS Code", status: "already_configured" };
   config.servers["hivelore"] = { ...HAIVE_MCP_ENTRY, type: "stdio" };
-  await mkdir3(path8.dirname(mcpPath), { recursive: true });
+  await mkdir3(path9.dirname(mcpPath), { recursive: true });
   await writeFile4(mcpPath, JSON.stringify(config, null, 2), "utf8");
   return { client: "VS Code", status: "configured", path: mcpPath };
 }
 function claudeConfigPath() {
-  const p = path8.join(HOME, ".claude.json");
-  if (existsSync7(p)) return p;
-  const p2 = path8.join(HOME, ".config", "claude", "claude.json");
-  if (existsSync7(path8.dirname(p2))) return p2;
+  const p = path9.join(HOME, ".claude.json");
+  if (existsSync8(p)) return p;
+  const p2 = path9.join(HOME, ".config", "claude", "claude.json");
+  if (existsSync8(path9.dirname(p2))) return p2;
   return null;
 }
 async function configureClaude() {
-  const cfgPath = claudeConfigPath() ?? path8.join(HOME, ".claude.json");
-  if (!existsSync7(cfgPath) && !existsSync7(path8.join(HOME, ".claude"))) {
+  const cfgPath = claudeConfigPath() ?? path9.join(HOME, ".claude.json");
+  if (!existsSync8(cfgPath) && !existsSync8(path9.join(HOME, ".claude"))) {
     return { client: "Claude Code", status: "not_installed" };
   }
   let config = {};
-  if (existsSync7(cfgPath)) {
+  if (existsSync8(cfgPath)) {
     try {
       config = JSON.parse(await readFile4(cfgPath, "utf8"));
     } catch {
@@ -1889,11 +1939,11 @@ async function configureClaude() {
 }
 function windsurfMcpPath() {
   const candidates = [
-    path8.join(HOME, ".codeium", "windsurf", "mcp_config.json"),
-    path8.join(HOME, ".windsurf", "mcp.json")
+    path9.join(HOME, ".codeium", "windsurf", "mcp_config.json"),
+    path9.join(HOME, ".windsurf", "mcp.json")
   ];
   for (const c of candidates) {
-    if (existsSync7(path8.dirname(c))) return c;
+    if (existsSync8(path9.dirname(c))) return c;
   }
   return null;
 }
@@ -1901,7 +1951,7 @@ async function configureWindsurf() {
   const mcpPath = windsurfMcpPath();
   if (!mcpPath) return { client: "Windsurf", status: "not_installed" };
   let config = {};
-  if (existsSync7(mcpPath)) {
+  if (existsSync8(mcpPath)) {
     try {
       config = JSON.parse(await readFile4(mcpPath, "utf8"));
     } catch {
@@ -1910,7 +1960,7 @@ async function configureWindsurf() {
   config.mcpServers ??= {};
   if (config.mcpServers["hivelore"] || config.mcpServers["haive"]) return { client: "Windsurf", status: "already_configured" };
   config.mcpServers["hivelore"] = HAIVE_MCP_ENTRY;
-  await mkdir3(path8.dirname(mcpPath), { recursive: true });
+  await mkdir3(path9.dirname(mcpPath), { recursive: true });
   await writeFile4(mcpPath, JSON.stringify(config, null, 2), "utf8");
   return { client: "Windsurf", status: "configured", path: mcpPath };
 }
@@ -1931,9 +1981,9 @@ async function configureProjectMcpClients(root) {
   const entry = projectMcpEntry(root);
   const results = [];
   try {
-    const cursorPath = path8.join(root, ".cursor", "mcp.json");
+    const cursorPath = path9.join(root, ".cursor", "mcp.json");
     let config = {};
-    if (existsSync7(cursorPath)) {
+    if (existsSync8(cursorPath)) {
       try {
         config = JSON.parse(await readFile4(cursorPath, "utf8"));
       } catch {
@@ -1942,16 +1992,16 @@ async function configureProjectMcpClients(root) {
     config.mcpServers ??= {};
     delete config.mcpServers["haive"];
     config.mcpServers["hivelore"] = entry;
-    await mkdir3(path8.dirname(cursorPath), { recursive: true });
+    await mkdir3(path9.dirname(cursorPath), { recursive: true });
     await writeFile4(cursorPath, JSON.stringify(config, null, 2) + "\n", "utf8");
     results.push({ client: "Cursor (project)", status: "configured", path: cursorPath });
   } catch (err) {
     results.push({ client: "Cursor (project)", status: "error", error: String(err) });
   }
   try {
-    const vscodePath = path8.join(root, ".vscode", "mcp.json");
+    const vscodePath = path9.join(root, ".vscode", "mcp.json");
     let config = {};
-    if (existsSync7(vscodePath)) {
+    if (existsSync8(vscodePath)) {
       try {
         config = JSON.parse(await readFile4(vscodePath, "utf8"));
       } catch {
@@ -1960,16 +2010,16 @@ async function configureProjectMcpClients(root) {
     config.servers ??= {};
     delete config.servers["haive"];
     config.servers["hivelore"] = { ...entry, type: "stdio" };
-    await mkdir3(path8.dirname(vscodePath), { recursive: true });
+    await mkdir3(path9.dirname(vscodePath), { recursive: true });
     await writeFile4(vscodePath, JSON.stringify(config, null, 2) + "\n", "utf8");
     results.push({ client: "VS Code (workspace)", status: "configured", path: vscodePath });
   } catch (err) {
     results.push({ client: "VS Code (workspace)", status: "error", error: String(err) });
   }
   try {
-    const mcpPath = path8.join(root, ".mcp.json");
+    const mcpPath = path9.join(root, ".mcp.json");
     let config = {};
-    if (existsSync7(mcpPath)) {
+    if (existsSync8(mcpPath)) {
       try {
         config = JSON.parse(await readFile4(mcpPath, "utf8"));
       } catch {
@@ -2044,9 +2094,9 @@ async function detectAgentMode(dir) {
   const root = findProjectRoot5(dir);
   const paths = resolveHaivePaths5(root);
   const projectMcp = [
-    { client: "Claude Code", path: path9.join(root, ".mcp.json"), present: existsSync8(path9.join(root, ".mcp.json")) },
-    { client: "Cursor", path: path9.join(root, ".cursor", "mcp.json"), present: existsSync8(path9.join(root, ".cursor", "mcp.json")) },
-    { client: "VS Code", path: path9.join(root, ".vscode", "mcp.json"), present: existsSync8(path9.join(root, ".vscode", "mcp.json")) }
+    { client: "Claude Code", path: path10.join(root, ".mcp.json"), present: existsSync9(path10.join(root, ".mcp.json")) },
+    { client: "Cursor", path: path10.join(root, ".cursor", "mcp.json"), present: existsSync9(path10.join(root, ".cursor", "mcp.json")) },
+    { client: "VS Code", path: path10.join(root, ".vscode", "mcp.json"), present: existsSync9(path10.join(root, ".vscode", "mcp.json")) }
   ];
   const installedAgents = [
     { agent: "Codex", command: "codex", installed: commandExists("codex"), mcp_configured: codexMcpConfigured() },
@@ -2061,7 +2111,7 @@ async function detectAgentMode(dir) {
   const recommendedCommand = recommendedMode === "mcp" ? "Restart your AI client, then call get_briefing before editing." : recommendedMode === "wrapped" && wrapperAgent ? `hivelore run -- ${wrapperAgent.command}` : 'hivelore briefing --task "..." --files "..."';
   return {
     root,
-    initialized: existsSync8(paths.haiveDir),
+    initialized: existsSync9(paths.haiveDir),
     project_mcp: projectMcp,
     installed_agents: installedAgents,
     recommended_mode: recommendedMode,
@@ -2069,9 +2119,9 @@ async function detectAgentMode(dir) {
   };
 }
 async function writeAgentModeRecord(paths, detection, skippedReason) {
-  const dir = path9.join(paths.runtimeDir, "enforcement");
+  const dir = path10.join(paths.runtimeDir, "enforcement");
   await mkdir4(dir, { recursive: true });
-  const file = path9.join(dir, "agent-mode.json");
+  const file = path10.join(dir, "agent-mode.json");
   const record = {
     selected_mode: detection.recommended_mode,
     recommended_command: detection.recommended_command,
@@ -2112,7 +2162,7 @@ async function configureCodexIfAvailable(root) {
     "mcp",
     "--stdio"
   ], { encoding: "utf8" });
-  if (result.status === 0) return { client: "Codex", status: "configured", path: path9.join(os2.homedir(), ".codex", "config.toml") };
+  if (result.status === 0) return { client: "Codex", status: "configured", path: path10.join(os2.homedir(), ".codex", "config.toml") };
   return { client: "Codex", status: "error", error: result.stderr || result.stdout || "codex mcp add failed" };
 }
 function commandExists(command) {
@@ -2139,7 +2189,7 @@ function printDetection(detection, json) {
   console.log(ui.dim(`  root: ${detection.root}`));
   console.log(`${detection.initialized ? ui.green("\u2713") : ui.red("\u2717")} project initialized`);
   for (const cfg of detection.project_mcp) {
-    console.log(`${cfg.present ? ui.green("\u2713") : ui.yellow("\u2022")} ${cfg.client} project MCP ${ui.dim(path9.relative(detection.root, cfg.path))}`);
+    console.log(`${cfg.present ? ui.green("\u2713") : ui.yellow("\u2022")} ${cfg.client} project MCP ${ui.dim(path10.relative(detection.root, cfg.path))}`);
   }
   for (const agent of detection.installed_agents) {
     const marker = agent.installed ? ui.green("\u2713") : ui.dim("\u2022");
@@ -2168,8 +2218,8 @@ function printSetupResult(result) {
 
 // src/commands/init-bootstrap.ts
 import { readdir, readFile as readFile5 } from "fs/promises";
-import { existsSync as existsSync9, readdirSync } from "fs";
-import path10 from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync3 } from "fs";
+import path11 from "path";
 var IGNORE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -2255,12 +2305,12 @@ function detectKeyDeps(allDeps) {
   return KEY_DEPS.filter((d) => allDeps[d] !== void 0);
 }
 function detectLanguage(root) {
-  if (existsSync9(path10.join(root, "tsconfig.json"))) return "TypeScript";
-  if (existsSync9(path10.join(root, "pyproject.toml")) || existsSync9(path10.join(root, "setup.py"))) return "Python";
-  if (existsSync9(path10.join(root, "go.mod"))) return "Go";
-  if (existsSync9(path10.join(root, "pom.xml")) || existsSync9(path10.join(root, "build.gradle"))) return "Java/Kotlin";
-  if (existsSync9(path10.join(root, "Cargo.toml"))) return "Rust";
-  if (existsSync9(path10.join(root, "package.json"))) {
+  if (existsSync10(path11.join(root, "tsconfig.json"))) return "TypeScript";
+  if (existsSync10(path11.join(root, "pyproject.toml")) || existsSync10(path11.join(root, "setup.py"))) return "Python";
+  if (existsSync10(path11.join(root, "go.mod"))) return "Go";
+  if (existsSync10(path11.join(root, "pom.xml")) || existsSync10(path11.join(root, "build.gradle"))) return "Java/Kotlin";
+  if (existsSync10(path11.join(root, "Cargo.toml"))) return "Rust";
+  if (existsSync10(path11.join(root, "package.json"))) {
     return hasSourceWithExt(root, [".ts", ".tsx", ".mts", ".cts"]) ? "TypeScript" : "JavaScript";
   }
   return "Unknown";
@@ -2270,7 +2320,7 @@ function hasSourceWithExt(root, exts) {
   const scanDir = (dir, depth) => {
     let entries;
     try {
-      entries = readdirSync(dir, { withFileTypes: true });
+      entries = readdirSync3(dir, { withFileTypes: true });
     } catch {
       return false;
     }
@@ -2280,7 +2330,7 @@ function hasSourceWithExt(root, exts) {
     if (depth <= 0) return false;
     for (const entry of entries) {
       if (entry.isDirectory() && !IGNORE_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
-        if (scanDir(path10.join(dir, entry.name), depth - 1)) return true;
+        if (scanDir(path11.join(dir, entry.name), depth - 1)) return true;
       }
     }
     return false;
@@ -2301,7 +2351,7 @@ function detectProjectType(frameworks, scripts, isMonorepo) {
   if (frameworks.includes("Express") || frameworks.includes("Fastify") || frameworks.includes("Hono")) return "Backend API";
   if (frameworks.includes("React") || frameworks.includes("Vue") || frameworks.includes("Svelte")) return "Frontend SPA";
   if (scripts["build"] && !scripts["dev"]) return "CLI tool / library";
-  if (existsSync9("pom.xml")) return "Java backend";
+  if (existsSync10("pom.xml")) return "Java backend";
   return "Application";
 }
 async function scanDirs(root, maxDepth = 2) {
@@ -2317,9 +2367,9 @@ async function scanDirs(root, maxDepth = 2) {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (IGNORE_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
-      const rel = path10.relative(root, path10.join(dir, entry.name));
+      const rel = path11.relative(root, path11.join(dir, entry.name));
       results.push(rel);
-      await walk(path10.join(dir, entry.name), depth + 1);
+      await walk(path11.join(dir, entry.name), depth + 1);
     }
   }
   await walk(root, 0);
@@ -2436,8 +2486,8 @@ function readmeExcerpt(readme) {
 }
 async function generateBootstrapContext(root) {
   let pkg = {};
-  const pkgPath = path10.join(root, "package.json");
-  if (existsSync9(pkgPath)) {
+  const pkgPath = path11.join(root, "package.json");
+  if (existsSync10(pkgPath)) {
     try {
       pkg = JSON.parse(await readFile5(pkgPath, "utf8"));
     } catch {
@@ -2449,18 +2499,15 @@ async function generateBootstrapContext(root) {
   const language = detectLanguage(root);
   const isMonorepo = pkg.workspaces !== void 0 && (Array.isArray(pkg.workspaces) ? pkg.workspaces.length > 0 : true);
   const projectType = detectProjectType(frameworks, pkg.scripts ?? {}, isMonorepo);
-  const projectName = pkg.name ?? path10.basename(root);
+  const projectName = pkg.name ?? path11.basename(root);
   const projectDesc = pkg.description ?? "";
   let readmeSummary = "";
-  for (const name of ["README.md", "readme.md", "README"]) {
-    const p = path10.join(root, name);
-    if (existsSync9(p)) {
-      try {
-        const content = await readFile5(p, "utf8");
-        readmeSummary = readmeExcerpt(content);
-        break;
-      } catch {
-      }
+  const readmeName = findDocFile(root, "readme");
+  if (readmeName) {
+    try {
+      const content = await readFile5(path11.join(root, readmeName), "utf8");
+      readmeSummary = readmeExcerpt(content);
+    } catch {
     }
   }
   const dirs = await scanDirs(root, 2);
@@ -2513,7 +2560,7 @@ async function generateBootstrapContext(root) {
     "",
     `## Gotchas`,
     `TODO \u2014 known traps, surprising behavior, things newcomers stub their toes on.`,
-    `(Run \`hivelore memory import-changelog\` or \`hivelore memory import README.md\` to seed these automatically.)`,
+    `(Seed these with \`hivelore memory import --from ${findDocFile(root, "changelog") ?? "CHANGELOG.md"} --changelog\` or \`hivelore memory import --from ${findDocFile(root, "readme") ?? "README.md"}\` via your AI client.)`,
     ""
   ];
   return lines.join("\n");
@@ -2521,8 +2568,8 @@ async function generateBootstrapContext(root) {
 
 // src/commands/init-stack-packs.ts
 import { mkdir as mkdir5, writeFile as writeFile6 } from "fs/promises";
-import { existsSync as existsSync10 } from "fs";
-import path11 from "path";
+import { existsSync as existsSync11 } from "fs";
+import path12 from "path";
 import {
   buildFrontmatter,
   loadMemoriesFromDir as loadMemoriesFromDir6,
@@ -3626,7 +3673,7 @@ async function seedStackPack(haivePaths, stack) {
   const existingTopics = /* @__PURE__ */ new Set();
   const existingSignatures = /* @__PURE__ */ new Set();
   const handWrittenSlugs = [];
-  if (existsSync10(haivePaths.memoriesDir)) {
+  if (existsSync11(haivePaths.memoriesDir)) {
     for (const { memory: memory2 } of await loadMemoriesFromDir6(haivePaths.memoriesDir)) {
       if (memory2.frontmatter.topic) existingTopics.add(memory2.frontmatter.topic);
       existingSignatures.add(memory2.frontmatter.id.replace(DATE_PREFIX, ""));
@@ -3671,7 +3718,7 @@ async function seedStackPack(haivePaths, stack) {
       ...sensor ? { sensor } : {}
     });
     const filePath = memoryFilePath(haivePaths, "team", fm.id);
-    if (existsSync10(filePath)) continue;
+    if (existsSync11(filePath)) continue;
     const ruleSlug = combinedSlug.startsWith(`${stack}-`) ? combinedSlug.slice(stack.length + 1) : combinedSlug;
     const titleCase = (s) => s.split("-").filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
     const heading = `${titleCase(stack)}: ${titleCase(ruleSlug)}`;
@@ -3681,7 +3728,7 @@ ${mem.body}`;
     const content = serializeMemory2({ frontmatter: fm, body: `${titledBody}
 
 ${SEED_FOOTER(stack)}` });
-    await mkdir5(path11.dirname(filePath), { recursive: true });
+    await mkdir5(path12.dirname(filePath), { recursive: true });
     await writeFile6(filePath, content, "utf8");
     existingTopics.add(topic);
     existingSignatures.add(signature);
@@ -3708,7 +3755,7 @@ ${SEED_FOOTER(stack)}` });
 
 // src/commands/init.ts
 var execFileAsync = promisify2(execFile2);
-var HAIVE_GITHUB_ACTION_REF = `v${"0.33.0"}`;
+var HAIVE_GITHUB_ACTION_REF = `v${"0.34.1"}`;
 var PROJECT_CONTEXT_TEMPLATE = `# Project context
 
 > Generated by \`hivelore init\`. Run \`hivelore init --bootstrap\` to auto-fill from your codebase,
@@ -3901,9 +3948,9 @@ function registerInit(program2) {
     "Initialize a Hivelore project \u2014 autopilot mode ON by default (zero human intervention).\n  Auto-bootstraps project-context.md from local files and seeds detected stack packs.\n  Seeds draft memories from git revert/hotfix history (--seed, on by default).\n  Add --manual to control memory approval and session recaps yourself.\n  Add --no-bootstrap and --stack none to disable the auto-features."
   ).option("-d, --dir <dir>", "project root", process.cwd()).option("--no-bridges", "do not generate any native agent bridge files").option(
     "--bridge-targets <list>",
-    `which agent bridges to generate: 'all' (default) | comma-list.
-  Available: ${BRIDGE_TARGETS.join(", ")}. Each carries top memories + block sensors.`,
-    "all"
+    `which agent bridges to generate: 'auto' (default \u2014 clients detected on this machine/repo, plus AGENTS.md) | 'all' | comma-list.
+  Available: ${BRIDGE_TARGETS2.join(", ")}. Each carries top memories + block sensors.`,
+    "auto"
   ).option("--with-ci", "write a GitHub Actions workflow (.github/workflows/haive-sync.yml) \u2014 included automatically in autopilot mode").option(
     "--manual",
     "opt out of autopilot: memories require manual approval, no auto-session recap, no auto-context"
@@ -3936,7 +3983,7 @@ function registerInit(program2) {
     "approve user-level AI client configuration prompts during agent setup",
     false
   ).option("--json", "emit a machine-readable summary on stdout (human logs go to stderr)", false).action(async (opts) => {
-    const root = path12.resolve(opts.dir);
+    const root = path13.resolve(opts.dir);
     const paths = resolveHaivePaths6(root);
     const autopilot = opts.manual !== true;
     const json = opts.json === true;
@@ -3953,9 +4000,10 @@ function registerInit(program2) {
       gitCommitsScanned: 0,
       gitRevertsFound: 0,
       gitRecurring: 0,
-      bridgesWritten: 0
+      bridgesWritten: 0,
+      bridgeTargets: []
     };
-    if (existsSync11(paths.haiveDir)) {
+    if (existsSync12(paths.haiveDir)) {
       ui.warn(`.ai/ already exists at ${paths.haiveDir} \u2014 leaving existing files in place.`);
     }
     await mkdir6(paths.personalDir, { recursive: true });
@@ -3963,8 +4011,8 @@ function registerInit(program2) {
     await mkdir6(paths.moduleDir, { recursive: true });
     await mkdir6(paths.modulesContextDir, { recursive: true });
     await ensureAiRuntimeLayout(paths.runtimeDir);
-    await ensureAiCacheLayout(path12.join(paths.haiveDir, ".cache"));
-    if (!existsSync11(paths.projectContext)) {
+    await ensureAiCacheLayout(path13.join(paths.haiveDir, ".cache"));
+    if (!existsSync12(paths.projectContext)) {
       if (wantBootstrap) {
         ui.info("Bootstrapping project context from local files\u2026");
         try {
@@ -3977,11 +4025,11 @@ function registerInit(program2) {
         }
       } else {
         await writeFile7(paths.projectContext, PROJECT_CONTEXT_TEMPLATE, "utf8");
-        ui.success(`Created ${path12.relative(root, paths.projectContext)}`);
+        ui.success(`Created ${path13.relative(root, paths.projectContext)}`);
       }
     }
-    const configExists = existsSync11(
-      path12.join(paths.haiveDir, "haive.config.json")
+    const configExists = existsSync12(
+      path13.join(paths.haiveDir, "haive.config.json")
     );
     if (!configExists) {
       await saveConfig2(paths, autopilot ? AUTOPILOT_DEFAULTS2 : { autopilot: false });
@@ -4031,11 +4079,14 @@ function registerInit(program2) {
       }
     }
     if (opts.bridges) {
-      const targets = resolveBridgeTargets(opts.bridgeTargets);
+      const targets = resolveBridgeTargets(opts.bridgeTargets, root);
       const res = await writeBridgeFiles(root, paths, { targets });
-      await writeCursorHaiveRule(root);
+      if (targets.includes("cursor")) {
+        await writeCursorHaiveRule(root);
+      }
       const made = res.created.length + res.updated.length;
       report.bridgesWritten = made;
+      report.bridgeTargets = targets;
       if (res.created.length > 0) {
         ui.success(`Generated ${res.created.length} agent bridge(s): ${res.created.join(", ")}`);
       }
@@ -4048,13 +4099,13 @@ function registerInit(program2) {
     }
     const wantCi = opts.withCi || autopilot;
     if (wantCi) {
-      const ciPath = path12.join(root, ".github", "workflows", "haive-sync.yml");
-      if (existsSync11(ciPath)) {
+      const ciPath = path13.join(root, ".github", "workflows", "haive-sync.yml");
+      if (existsSync12(ciPath)) {
         ui.info("CI workflow already exists \u2014 skipped");
       } else {
-        await mkdir6(path12.dirname(ciPath), { recursive: true });
+        await mkdir6(path13.dirname(ciPath), { recursive: true });
         await writeFile7(ciPath, CI_WORKFLOW, "utf8");
-        ui.success(`Created ${path12.relative(root, ciPath)}`);
+        ui.success(`Created ${path13.relative(root, ciPath)}`);
       }
     }
     if (autopilot) {
@@ -4094,7 +4145,7 @@ function registerInit(program2) {
         interactive: process.stdin.isTTY
       });
       for (const r of agentSetup.project_results) {
-        if (r.status === "configured" && r.path) ui.success(`hivelore MCP project config written (${path12.relative(root, r.path)})`);
+        if (r.status === "configured" && r.path) ui.success(`hivelore MCP project config written (${path13.relative(root, r.path)})`);
         else if (r.status === "error") ui.warn(`${r.client}: ${r.error}`);
       }
       for (const r of agentSetup.global_results) {
@@ -4160,10 +4211,18 @@ function registerInit(program2) {
         console.log(ui.dim("  Review .ai/project-context.md and fill in the TODO sections."));
         console.log(ui.dim("  Or invoke the MCP prompt `bootstrap_project` for a richer AI-generated version."));
       }
-      console.log();
-      console.log(ui.dim("  Seed more memories instantly:"));
-      console.log(ui.dim("    hivelore memory import-changelog   \u2014 from CHANGELOG.md"));
-      console.log(ui.dim("    hivelore memory import README.md   \u2014 from README / docs"));
+      const changelogFile = findDocFile(root, "changelog");
+      const readmeFile = findDocFile(root, "readme");
+      if (changelogFile || readmeFile) {
+        console.log();
+        console.log(ui.dim("  Seed more memories:"));
+        if (changelogFile) {
+          console.log(ui.dim(`    hivelore memory import --from ${changelogFile} --changelog   \u2014 extract breaking-change gotchas (no AI needed)`));
+        }
+        if (readmeFile) {
+          console.log(ui.dim(`    hivelore memory import --from ${readmeFile}   \u2014 prepare an import prompt for your AI client`));
+        }
+      }
     } else {
       console.log(ui.bold("Next steps:"));
       if (!wantBootstrap) {
@@ -4189,7 +4248,42 @@ async function resolveStacksToSeed(root, stackOpt) {
   return stackOpt.split(",").map((s) => s.trim().toLowerCase()).filter(isValidStack);
 }
 async function collectNestedPackageDeps(root) {
-  const SKIP = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "out", ".git", ".next", "coverage", "vendor"]);
+  const SKIP = /* @__PURE__ */ new Set([
+    "node_modules",
+    "dist",
+    "build",
+    "out",
+    ".git",
+    ".next",
+    "coverage",
+    "vendor",
+    // Fixture/demo trees describe what the project TESTS AGAINST, not what it is built with.
+    // Vite's playground/ pulls react+vue+tailwind+express into detection and seeds four
+    // irrelevant stack packs on a build-tool repo.
+    "playground",
+    "playgrounds",
+    "example",
+    "examples",
+    "fixtures",
+    "__fixtures__",
+    "e2e",
+    "test",
+    "tests",
+    "demo",
+    "demos",
+    "template",
+    "templates",
+    "bench",
+    "benchmarks",
+    "samples",
+    "sandbox",
+    // Doc sites are built with their own framework (VitePress→vue, Docusaurus→react) — that is
+    // the DOCS' stack, not the product's.
+    "docs",
+    "doc",
+    "website"
+  ]);
+  const SKIP_PREFIX = /^(template|example|fixture|demo|sample)s?-/;
   const merged = {};
   let found = false;
   async function scan(dir, depth) {
@@ -4201,10 +4295,10 @@ async function collectNestedPackageDeps(root) {
       return;
     }
     for (const entry of entries) {
-      if (!entry.isDirectory() || entry.name.startsWith(".") || SKIP.has(entry.name)) continue;
-      const sub = path12.join(dir, entry.name);
-      const pkgPath = path12.join(sub, "package.json");
-      if (existsSync11(pkgPath)) {
+      if (!entry.isDirectory() || entry.name.startsWith(".") || SKIP.has(entry.name) || SKIP_PREFIX.test(entry.name)) continue;
+      const sub = path13.join(dir, entry.name);
+      const pkgPath = path13.join(sub, "package.json");
+      if (existsSync12(pkgPath)) {
         try {
           const pkg = JSON.parse(await readFile6(pkgPath, "utf8"));
           Object.assign(merged, pkg.dependencies ?? {}, pkg.devDependencies ?? {});
@@ -4223,8 +4317,8 @@ async function autoDetectStacksFromRoot(root) {
   let requirementsTxt;
   let goMod;
   let pomXml;
-  const pkgPath = path12.join(root, "package.json");
-  if (existsSync11(pkgPath)) {
+  const pkgPath = path13.join(root, "package.json");
+  if (existsSync12(pkgPath)) {
     try {
       const pkg = JSON.parse(await readFile6(pkgPath, "utf8"));
       packageJsonDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
@@ -4234,8 +4328,8 @@ async function autoDetectStacksFromRoot(root) {
   const nestedDeps = await collectNestedPackageDeps(root);
   if (nestedDeps) packageJsonDeps = { ...packageJsonDeps ?? {}, ...nestedDeps };
   for (const name of ["requirements.txt", "requirements/base.txt", "requirements/prod.txt"]) {
-    const reqPath = path12.join(root, name);
-    if (existsSync11(reqPath)) {
+    const reqPath = path13.join(root, name);
+    if (existsSync12(reqPath)) {
       try {
         requirementsTxt = await readFile6(reqPath, "utf8");
         break;
@@ -4243,39 +4337,39 @@ async function autoDetectStacksFromRoot(root) {
       }
     }
   }
-  const goModPath = path12.join(root, "go.mod");
-  if (existsSync11(goModPath)) {
+  const goModPath = path13.join(root, "go.mod");
+  if (existsSync12(goModPath)) {
     try {
       goMod = await readFile6(goModPath, "utf8");
     } catch {
     }
   }
-  const pomPath = path12.join(root, "pom.xml");
-  if (existsSync11(pomPath)) {
+  const pomPath = path13.join(root, "pom.xml");
+  if (existsSync12(pomPath)) {
     try {
       pomXml = await readFile6(pomPath, "utf8");
     } catch {
     }
   }
   let composerJson;
-  const composerPath = path12.join(root, "composer.json");
-  if (existsSync11(composerPath)) {
+  const composerPath = path13.join(root, "composer.json");
+  if (existsSync12(composerPath)) {
     try {
       composerJson = await readFile6(composerPath, "utf8");
     } catch {
     }
   }
   let gemfile;
-  const gemfilePath = path12.join(root, "Gemfile");
-  if (existsSync11(gemfilePath)) {
+  const gemfilePath = path13.join(root, "Gemfile");
+  if (existsSync12(gemfilePath)) {
     try {
       gemfile = await readFile6(gemfilePath, "utf8");
     } catch {
     }
   }
-  const hasDockerfile = existsSync11(path12.join(root, "Dockerfile"));
-  const hasTurboJson = existsSync11(path12.join(root, "turbo.json"));
-  const hasNxJson = existsSync11(path12.join(root, "nx.json"));
+  const hasDockerfile = existsSync12(path13.join(root, "Dockerfile"));
+  const hasTurboJson = existsSync12(path13.join(root, "turbo.json"));
+  const hasNxJson = existsSync12(path13.join(root, "nx.json"));
   let hasCsproj = false;
   try {
     const entries = await readdir2(root);
@@ -4327,8 +4421,8 @@ async function seedFromGitHistory(root, paths, limit) {
 _Seeded from git ${p.kind} commit ${p.source_sha}. Review and validate (or delete) \u2014 not yet authoritative._
 `;
     const file = memoryFilePath2(paths, fm.scope, fm.id, fm.module);
-    if (existsSync11(file)) continue;
-    await mkdir6(path12.dirname(file), { recursive: true });
+    if (existsSync12(file)) continue;
+    await mkdir6(path13.dirname(file), { recursive: true });
     await writeFile7(file, serializeMemory3({ frontmatter: fm, body }), "utf8");
     written++;
   }
@@ -4369,7 +4463,7 @@ function printInitReport(r) {
     lines.push(`  Total ready : ${r.totalMemories} lesson(s), ${r.totalSensors} sensor(s) \u2014 0 written by hand`);
   }
   if (r.bridgesWritten > 0) {
-    lines.push(`  Reach       : ${r.bridgesWritten} agent bridge(s) generated (Cursor, Cline, Copilot, Roo, Gemini, \u2026)`);
+    lines.push(`  Reach       : ${r.bridgesWritten} agent bridge(s) generated (${r.bridgeTargets.join(", ")})`);
   }
   if (lines.length === 0) return;
   const width = Math.max(...lines.map((l) => l.length), 44);
@@ -4390,33 +4484,37 @@ function printInitReport(r) {
 }
 async function writeCursorHaiveRule(root) {
   const relPath = ".cursor/rules/haive-mcp-required.mdc";
-  const target = path12.join(root, relPath);
-  if (existsSync11(target)) {
+  const target = path13.join(root, relPath);
+  if (existsSync12(target)) {
     ui.info(`Cursor rule ${relPath} already exists \u2014 skipped`);
     return;
   }
-  await mkdir6(path12.dirname(target), { recursive: true });
+  await mkdir6(path13.dirname(target), { recursive: true });
   await writeFile7(target, CURSOR_HAIVE_RULE_MDC, "utf8");
   ui.success(`Created Cursor rule ${relPath}`);
 }
-function resolveBridgeTargets(opt) {
-  const raw = (opt ?? "all").trim().toLowerCase();
-  if (raw === "" || raw === "all") return [...BRIDGE_TARGETS];
+function resolveBridgeTargets(opt, root) {
+  const raw = (opt ?? "auto").trim().toLowerCase();
+  if (raw === "all") return [...BRIDGE_TARGETS2];
+  if (raw === "" || raw === "auto") {
+    const detection = detectBridgeTargets(root);
+    const named = detection.targets.map((t) => detection.reasons[t] === "repo file" ? `${t} (already in repo)` : t).join(", ");
+    ui.info(`Bridge targets (detected): ${named} \u2014 pass --bridge-targets all for every supported client`);
+    return detection.targets;
+  }
   const requested = raw.split(",").map((t) => t.trim()).filter(Boolean);
-  const valid = requested.filter((t) => BRIDGE_TARGETS.includes(t));
-  const invalid = requested.filter((t) => !BRIDGE_TARGETS.includes(t));
+  const valid = requested.filter((t) => BRIDGE_TARGETS2.includes(t));
+  const invalid = requested.filter((t) => !BRIDGE_TARGETS2.includes(t));
   if (invalid.length > 0) {
-    ui.warn(`Ignoring unknown bridge target(s): ${invalid.join(", ")}. Valid: ${BRIDGE_TARGETS.join(", ")}`);
+    ui.warn(`Ignoring unknown bridge target(s): ${invalid.join(", ")}. Valid: ${BRIDGE_TARGETS2.join(", ")}`);
   }
-  return valid.length > 0 ? valid : [...BRIDGE_TARGETS];
+  return valid.length > 0 ? valid : [...BRIDGE_TARGETS2];
 }
 var RUNTIME_README_BODY = `# .ai/.runtime \u2014 disposable local layer
 
 Not team truth. Use for machine-local session notes or tooling scratch files.
 Official memories belong in .ai/memories/ (versioned in Git).
 Only .gitignore and this README are meant to commit; everything else stays untracked.
-
-Session continuity (local): agents may append \`session-journal.ndjson\` via MCP \`runtime_journal_append\` or \`hivelore runtime journal append\`.
 `;
 var RUNTIME_GITIGNORE_BODY = `*
 !.gitignore
@@ -4424,27 +4522,27 @@ var RUNTIME_GITIGNORE_BODY = `*
 `;
 async function ensureAiRuntimeLayout(runtimeDir) {
   await mkdir6(runtimeDir, { recursive: true });
-  const gi = path12.join(runtimeDir, ".gitignore");
-  if (!existsSync11(gi)) {
+  const gi = path13.join(runtimeDir, ".gitignore");
+  if (!existsSync12(gi)) {
     await writeFile7(gi, RUNTIME_GITIGNORE_BODY, "utf8");
   }
-  const readme = path12.join(runtimeDir, "README.md");
-  if (!existsSync11(readme)) {
+  const readme = path13.join(runtimeDir, "README.md");
+  if (!existsSync12(readme)) {
     await writeFile7(readme, RUNTIME_README_BODY, "utf8");
   }
 }
 async function ensureAiCacheLayout(cacheDir) {
   await mkdir6(cacheDir, { recursive: true });
-  const gi = path12.join(cacheDir, ".gitignore");
-  if (!existsSync11(gi)) {
+  const gi = path13.join(cacheDir, ".gitignore");
+  if (!existsSync12(gi)) {
     await writeFile7(gi, "*\n!.gitignore\n", "utf8");
   }
 }
 async function ensureGitignoreEntries(root, patterns) {
   try {
-    const gitignorePath = path12.join(root, ".gitignore");
+    const gitignorePath = path13.join(root, ".gitignore");
     let existing = "";
-    if (existsSync11(gitignorePath)) {
+    if (existsSync12(gitignorePath)) {
       existing = await readFile6(gitignorePath, "utf8");
     }
     const lines = existing.split("\n");
@@ -4458,8 +4556,8 @@ async function ensureGitignoreEntries(root, patterns) {
 
 // src/commands/observe.ts
 import { appendFile, mkdir as mkdir7 } from "fs/promises";
-import { existsSync as existsSync12 } from "fs";
-import path13 from "path";
+import { existsSync as existsSync13 } from "fs";
+import path14 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot7, resolveHaivePaths as resolveHaivePaths7 } from "@hivelore/core";
 var MAX_STDIN_BYTES = 256 * 1024;
@@ -4566,7 +4664,7 @@ function registerObserve(program2) {
       })();
       if (!root) return;
       const paths = resolveHaivePaths7(root);
-      if (!existsSync12(paths.haiveDir)) return;
+      if (!existsSync13(paths.haiveDir)) return;
       const failureHint = detectFailure(payload);
       const observation = {
         ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -4577,10 +4675,10 @@ function registerObserve(program2) {
         files: extractFiles(payload),
         ...failureHint ? { failure_hint: true } : {}
       };
-      const cacheDir = path13.join(paths.haiveDir, ".cache");
+      const cacheDir = path14.join(paths.haiveDir, ".cache");
       await mkdir7(cacheDir, { recursive: true });
       await appendFile(
-        path13.join(cacheDir, "observations.jsonl"),
+        path14.join(cacheDir, "observations.jsonl"),
         JSON.stringify(observation) + "\n",
         "utf8"
       );
@@ -4611,8 +4709,8 @@ function registerMcp(program2) {
 // src/commands/sync.ts
 import { spawnSync as spawnSync4 } from "child_process";
 import { readFile as readFile7, writeFile as writeFile8, mkdir as mkdir8 } from "fs/promises";
-import { existsSync as existsSync13 } from "fs";
-import path14 from "path";
+import { existsSync as existsSync14 } from "fs";
+import path15 from "path";
 import "commander";
 import {
   DEFAULT_AUTO_PROMOTE_RULE,
@@ -4634,7 +4732,7 @@ import {
   verifyAnchor,
   watchContracts
 } from "@hivelore/core";
-import { BRIDGE_TARGETS as BRIDGE_TARGETS2 } from "@hivelore/core";
+import { BRIDGE_TARGETS as BRIDGE_TARGETS3 } from "@hivelore/core";
 var BRIDGE_START = "<!-- haive:memories-start -->";
 var BRIDGE_END = "<!-- haive:memories-end -->";
 function registerSync(program2) {
@@ -4649,7 +4747,7 @@ function registerSync(program2) {
   ).option("--bridge-file <path>", "bridge file to inject into (default: CLAUDE.md)").option("--bridge-max-memories <n>", "max memories to inject into bridge file", "5").option("--embed", "rebuild embeddings index after sync (requires @haive/embeddings)").option("--no-cross-repo", "skip cross-repo memory pull even if crossRepoSources is configured").option("--no-deps", "skip dependency version tracking").option("--no-contracts", "skip contract file diff checking").option("--no-bridges", "skip auto-refresh of existing native agent bridge files (.cursor/rules, .clinerules, \u2026)").option("--dry-run", "report what would change without writing any files").action(async (opts) => {
     const root = findProjectRoot9(opts.dir);
     const paths = resolveHaivePaths8(root);
-    if (!existsSync13(paths.memoriesDir)) {
+    if (!existsSync14(paths.memoriesDir)) {
       if (!opts.quiet) ui.warn(`No .ai/memories at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -4805,7 +4903,7 @@ function registerSync(program2) {
     if (opts.injectBridge) {
       const maxInject = Math.max(1, Number(opts.bridgeMaxMemories ?? 5));
       if (opts.bridgeFile) {
-        await injectBridge(path14.resolve(opts.bridgeFile), paths.memoriesDir, maxInject, root, opts.quiet);
+        await injectBridge(path15.resolve(opts.bridgeFile), paths.memoriesDir, maxInject, root, opts.quiet);
       } else if (!dryRun) {
         const res = await writeBridgeFiles(root, paths, {
           targets: ["claude", "agents"],
@@ -4834,7 +4932,7 @@ function registerSync(program2) {
     if (opts.noBridges !== true) {
       try {
         const res = await writeBridgeFiles(root, paths, {
-          targets: BRIDGE_TARGETS2,
+          targets: BRIDGE_TARGETS3,
           onlyExisting: true,
           dryRun
         });
@@ -4954,10 +5052,10 @@ Wait for **explicit confirmation** before acting.
                   topic: `dep-bump-${slugParts}`
                 });
                 if (!dryRun) {
-                  const teamDir = path14.join(paths.memoriesDir, "team");
+                  const teamDir = path15.join(paths.memoriesDir, "team");
                   await mkdir8(teamDir, { recursive: true });
                   await writeFile8(
-                    path14.join(teamDir, `${fm.id}.md`),
+                    path15.join(teamDir, `${fm.id}.md`),
                     serializeMemory4({ frontmatter: { ...fm, requires_human_approval: true }, body }),
                     "utf8"
                   );
@@ -5023,10 +5121,10 @@ Wait for **explicit confirmation** before acting.
               topic: `contract-breaking-${diff.contract}`
             });
             if (!dryRun) {
-              const teamDir = path14.join(paths.memoriesDir, "team");
+              const teamDir = path15.join(paths.memoriesDir, "team");
               await mkdir8(teamDir, { recursive: true });
               await writeFile8(
-                path14.join(teamDir, `${fm.id}.md`),
+                path15.join(teamDir, `${fm.id}.md`),
                 serializeMemory4({ frontmatter: { ...fm, requires_human_approval: true }, body }),
                 "utf8"
               );
@@ -5117,7 +5215,7 @@ function bridgeSummaryLine(body) {
   return oneLine.length > 140 ? oneLine.slice(0, 137) + "\u2026" : oneLine;
 }
 async function injectBridge(bridgeFile, memoriesDir, maxMemories, root, quiet) {
-  if (!existsSync13(memoriesDir)) return;
+  if (!existsSync14(memoriesDir)) return;
   const all = await loadMemoriesFromDir7(memoriesDir);
   const top = all.filter(({ memory: memory2 }) => {
     const s = memory2.frontmatter.status;
@@ -5143,17 +5241,17 @@ async function injectBridge(bridgeFile, memoriesDir, maxMemories, root, quiet) {
 ` + block + `
 
 ${BRIDGE_END}`;
-  const fileExists = existsSync13(bridgeFile);
+  const fileExists = existsSync14(bridgeFile);
   let existing = fileExists ? await readFile7(bridgeFile, "utf8") : "";
   existing = existing.replace(/\r\n/g, "\n");
   const startIdx = existing.indexOf(BRIDGE_START);
   const endIdx = existing.indexOf(BRIDGE_END);
   if (startIdx !== -1 && endIdx === -1) {
-    ui.warn(`${path14.relative(root, bridgeFile)}: found ${BRIDGE_START} without ${BRIDGE_END}. Fix the file manually before running --inject-bridge.`);
+    ui.warn(`${path15.relative(root, bridgeFile)}: found ${BRIDGE_START} without ${BRIDGE_END}. Fix the file manually before running --inject-bridge.`);
     return;
   }
   if (startIdx === -1 && endIdx !== -1) {
-    ui.warn(`${path14.relative(root, bridgeFile)}: found ${BRIDGE_END} without ${BRIDGE_START}. Fix the file manually before running --inject-bridge.`);
+    ui.warn(`${path15.relative(root, bridgeFile)}: found ${BRIDGE_END} without ${BRIDGE_START}. Fix the file manually before running --inject-bridge.`);
     return;
   }
   let updated;
@@ -5161,14 +5259,14 @@ ${BRIDGE_END}`;
     updated = existing.slice(0, startIdx) + injected + existing.slice(endIdx + BRIDGE_END.length);
   } else {
     if (!fileExists && !quiet) {
-      ui.info(`Creating ${path14.relative(root, bridgeFile)} with hivelore memory block.`);
+      ui.info(`Creating ${path15.relative(root, bridgeFile)} with hivelore memory block.`);
     }
     updated = existing + (existing.endsWith("\n") ? "" : "\n") + "\n" + injected + "\n";
   }
   await writeFile8(bridgeFile, updated, "utf8");
   if (!quiet) {
     console.log(
-      ui.dim(`bridge: injected ${top.length} memor${top.length === 1 ? "y" : "ies"} into ${path14.relative(root, bridgeFile)}`)
+      ui.dim(`bridge: injected ${top.length} memor${top.length === 1 ? "y" : "ies"} into ${path15.relative(root, bridgeFile)}`)
     );
   }
 }
@@ -5194,8 +5292,8 @@ function collectSinceChanges(root, ref) {
 // src/commands/memory-add.ts
 import { createHash } from "crypto";
 import { mkdir as mkdir9, readFile as readFile8, writeFile as writeFile9 } from "fs/promises";
-import { existsSync as existsSync14 } from "fs";
-import path15 from "path";
+import { existsSync as existsSync15 } from "fs";
+import path16 from "path";
 import { Option } from "commander";
 import {
   buildFrontmatter as buildFrontmatter4,
@@ -5237,7 +5335,7 @@ function registerMemoryAdd(memory2) {
     if (opts.body === void 0 && opts.content !== void 0) opts.body = opts.content;
     const root = findProjectRoot10(opts.dir);
     const paths = resolveHaivePaths9(root);
-    if (!existsSync14(paths.haiveDir)) {
+    if (!existsSync15(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -5254,7 +5352,7 @@ function registerMemoryAdd(memory2) {
     const inferredTags = autoTagsEnabled ? inferModulesFromPaths2(anchorPaths) : [];
     const mergedTags = Array.from(/* @__PURE__ */ new Set([...userTags, ...inferredTags]));
     if (anchorPaths.length > 0) {
-      const missing = anchorPaths.filter((p) => !existsSync14(path15.resolve(root, p)));
+      const missing = anchorPaths.filter((p) => !existsSync15(path16.resolve(root, p)));
       if (missing.length > 0) {
         ui.warn(`Anchor path${missing.length > 1 ? "s" : ""} not found in project:`);
         for (const p of missing) ui.warn(`  \u2717 ${p}`);
@@ -5267,7 +5365,7 @@ function registerMemoryAdd(memory2) {
     const slug = slugify(opts.slug ?? opts.title ?? opts.topic ?? opts.body ?? `${opts.type}-memory`);
     let body;
     if (opts.bodyFile !== void 0) {
-      if (!existsSync14(opts.bodyFile)) {
+      if (!existsSync15(opts.bodyFile)) {
         ui.error(`--body-file not found: ${opts.bodyFile}`);
         process.exitCode = 1;
         return;
@@ -5283,7 +5381,7 @@ TODO \u2014 write the memory body.
 `;
     }
     const scope = opts.scope ?? config.defaultScope ?? "personal";
-    if (existsSync14(paths.memoriesDir)) {
+    if (existsSync15(paths.memoriesDir)) {
       const incomingHash = createHash("sha256").update(body.trim()).digest("hex").slice(0, 12);
       const allForHash = await loadMemoriesFromDir8(paths.memoriesDir);
       const hashDup = allForHash.find(
@@ -5296,7 +5394,7 @@ TODO \u2014 write the memory body.
         return;
       }
     }
-    if (opts.topic && existsSync14(paths.memoriesDir)) {
+    if (opts.topic && existsSync15(paths.memoriesDir)) {
       const existing = await loadMemoriesFromDir8(paths.memoriesDir);
       const topicMatch = existing.find(
         ({ memory: memory3 }) => memory3.frontmatter.topic === opts.topic && memory3.frontmatter.scope === scope && (!opts.module || memory3.frontmatter.module === opts.module)
@@ -5316,7 +5414,7 @@ TODO \u2014 write the memory body.
           }
         };
         await writeFile9(topicMatch.filePath, serializeMemory5({ frontmatter: newFrontmatter, body }), "utf8");
-        ui.success(`Updated (topic upsert) ${path15.relative(root, topicMatch.filePath)}`);
+        ui.success(`Updated (topic upsert) ${path16.relative(root, topicMatch.filePath)}`);
         ui.info(`id=${fm.id}  revision=${revisionCount}`);
         printSensorLoopHint(opts.type, body, newFrontmatter.anchor.paths, Boolean(newFrontmatter.sensor));
         await runPostMemoryAutopilot(root, paths, config);
@@ -5340,13 +5438,13 @@ TODO \u2014 write the memory body.
     });
     if (frontmatter.status === "validated") frontmatter.validated_by = "auto";
     const file = memoryFilePath3(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir9(path15.dirname(file), { recursive: true });
-    if (existsSync14(file)) {
+    await mkdir9(path16.dirname(file), { recursive: true });
+    if (existsSync15(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
       return;
     }
-    if (existsSync14(paths.memoriesDir)) {
+    if (existsSync15(paths.memoriesDir)) {
       const existing = await loadMemoriesFromDir8(paths.memoriesDir);
       const slugTokens = slug.toLowerCase().split(/[-_\s]+/).filter(Boolean);
       const similar = existing.filter(({ memory: memory3 }) => {
@@ -5359,7 +5457,7 @@ TODO \u2014 write the memory body.
       }
     }
     await writeFile9(file, serializeMemory5({ frontmatter, body }), "utf8");
-    ui.success(`Created ${path15.relative(root, file)}`);
+    ui.success(`Created ${path16.relative(root, file)}`);
     ui.info(`id=${frontmatter.id}  scope=${frontmatter.scope}  status=${frontmatter.status}`);
     printSensorLoopHint(opts.type, body, anchorPaths, Boolean(frontmatter.sensor));
     await runPostMemoryAutopilot(root, paths, config);
@@ -5453,8 +5551,8 @@ function slugify(value) {
 }
 
 // src/commands/memory-list.ts
-import { existsSync as existsSync15 } from "fs";
-import path16 from "path";
+import { existsSync as existsSync16 } from "fs";
+import path17 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot11, resolveHaivePaths as resolveHaivePaths10 } from "@hivelore/core";
 function registerMemoryList(memory2) {
@@ -5466,7 +5564,7 @@ function registerMemoryList(memory2) {
     }
     const root = findProjectRoot11(opts.dir);
     const paths = resolveHaivePaths10(root);
-    if (!existsSync15(paths.memoriesDir)) {
+    if (!existsSync16(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -5505,7 +5603,7 @@ function registerMemoryList(memory2) {
       );
       const title = mem.body.match(/^#\s+(.+)$/m)?.[1]?.trim();
       if (title && title !== fm.id) console.log(`  ${title}`);
-      console.log(`  ${ui.dim(path16.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path17.relative(root, filePath))}`);
     }
     const totalLabel = clipped > 0 ? `
 ${displayed.length} of ${filtered.length} memories shown (use --limit to adjust)` : `
@@ -5543,8 +5641,8 @@ function matchesFilters(loaded, opts) {
 
 // src/commands/memory-promote.ts
 import { mkdir as mkdir10, unlink, writeFile as writeFile10 } from "fs/promises";
-import { existsSync as existsSync16 } from "fs";
-import path17 from "path";
+import { existsSync as existsSync17 } from "fs";
+import path18 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot12,
@@ -5556,7 +5654,7 @@ function registerMemoryPromote(memory2) {
   memory2.command("promote <id>").description("Promote a personal memory to team scope (status -> proposed)").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
     const root = findProjectRoot12(opts.dir);
     const paths = resolveHaivePaths11(root);
-    if (!existsSync16(paths.memoriesDir)) {
+    if (!existsSync17(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -5591,19 +5689,19 @@ function registerMemoryPromote(memory2) {
       body: found.memory.body
     };
     const newPath = memoryFilePath4(paths, "team", updated.frontmatter.id);
-    await mkdir10(path17.dirname(newPath), { recursive: true });
+    await mkdir10(path18.dirname(newPath), { recursive: true });
     await writeFile10(newPath, serializeMemory6(updated), "utf8");
     await unlink(found.filePath);
     ui.success(`Promoted ${id} to team scope (status=proposed)`);
-    ui.info(`Now at ${path17.relative(root, newPath)}`);
+    ui.info(`Now at ${path18.relative(root, newPath)}`);
     console.log(ui.dim(`\u2192 next: hivelore memory approve ${id}  (validate for team use)`));
   });
 }
 
 // src/commands/memory-approve.ts
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync18 } from "fs";
 import { writeFile as writeFile11 } from "fs/promises";
-import path18 from "path";
+import path19 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot13,
@@ -5614,7 +5712,7 @@ function registerMemoryApprove(memory2) {
   memory2.command("approve [id]").description("Mark a memory as 'validated'. Use --all to bulk-approve all proposed/draft memories.").option("--all", "approve all proposed and draft memories at once").option("--pending", "approve all memories with status 'proposed'").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
     const root = findProjectRoot13(opts.dir);
     const paths = resolveHaivePaths12(root);
-    if (!existsSync17(paths.memoriesDir)) {
+    if (!existsSync18(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -5668,15 +5766,15 @@ function registerMemoryApprove(memory2) {
     };
     await writeFile11(found.filePath, serializeMemory7(next), "utf8");
     ui.success(`Approved ${id} (status=validated, by=human)`);
-    ui.info(path18.relative(root, found.filePath));
+    ui.info(path19.relative(root, found.filePath));
   });
 }
 
 // src/commands/memory-update.ts
 import { spawn } from "child_process";
 import { readFile as readFile9, writeFile as writeFile12 } from "fs/promises";
-import { existsSync as existsSync18 } from "fs";
-import path19 from "path";
+import { existsSync as existsSync19 } from "fs";
+import path20 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot14,
@@ -5689,7 +5787,7 @@ function registerMemoryUpdate(memory2) {
     const root = findProjectRoot14(opts.dir);
     const paths = resolveHaivePaths13(root);
     if (opts.edit) {
-      const all = existsSync18(paths.memoriesDir) ? await loadMemoriesFromDir(paths.memoriesDir) : [];
+      const all = existsSync19(paths.memoriesDir) ? await loadMemoriesFromDir(paths.memoriesDir) : [];
       const found = all.find((m) => m.memory.frontmatter.id === id);
       if (!found) {
         ui.error(`No memory with id "${id}".`);
@@ -5697,7 +5795,7 @@ function registerMemoryUpdate(memory2) {
         return;
       }
       const editor = opts.editor ?? process.env.EDITOR ?? process.env.VISUAL ?? "vi";
-      ui.info(`Opening ${path19.relative(root, found.filePath)} with ${editor}\u2026`);
+      ui.info(`Opening ${path20.relative(root, found.filePath)} with ${editor}\u2026`);
       const code = await new Promise((resolve) => {
         const child = spawn(editor, [found.filePath], { stdio: "inherit" });
         child.on("exit", (c) => resolve(c ?? 0));
@@ -5714,7 +5812,7 @@ function registerMemoryUpdate(memory2) {
       }
       return;
     }
-    if (!existsSync18(paths.memoriesDir)) {
+    if (!existsSync19(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -5756,7 +5854,7 @@ function registerMemoryUpdate(memory2) {
     if (opts.author !== void 0) updated.push("author");
     let newBody;
     if (opts.bodyFile !== void 0) {
-      if (!existsSync18(opts.bodyFile)) {
+      if (!existsSync19(opts.bodyFile)) {
         ui.error(`--body-file not found: ${opts.bodyFile}`);
         process.exitCode = 1;
         return;
@@ -5782,7 +5880,7 @@ function registerMemoryUpdate(memory2) {
       serializeMemory8({ frontmatter: newFrontmatter, body: newBody }),
       "utf8"
     );
-    ui.success(`Updated ${path19.relative(root, loaded.filePath)}`);
+    ui.success(`Updated ${path20.relative(root, loaded.filePath)}`);
     ui.info(`fields: ${updated.join(", ")}`);
   });
 }
@@ -5801,8 +5899,8 @@ function parseCsv3(value) {
 }
 
 // src/commands/memory-tried.ts
-import { existsSync as existsSync19 } from "fs";
-import path20 from "path";
+import { existsSync as existsSync20 } from "fs";
+import path21 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot15,
@@ -5817,7 +5915,7 @@ function registerMemoryTried(memory2) {
   ).requiredOption("--what <text>", "what approach was tried (short, descriptive title)").requiredOption("--why-failed <text>", "why it failed or should NOT be used (include the exact error if possible)").option("--instead <text>", "the correct approach to use instead").option("--scope <scope>", "personal | team | module", "personal").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags").option("--paths <csv>", "anchor paths, comma-separated").option("--files <csv>", "alias for --paths (matches the MCP `files` parameter)").option("--author <author>", "author email or handle").option("--sensor-pattern <regex>", "one-shot: regex matching the FAULTY usage \u2014 validates + attaches a sensor in this call").option("--sensor-command <cmd>", "one-shot BEHAVIOUR sensor: a command (test/script) the gate runs when the diff touches --paths; non-zero exit = lesson fires").option("--sensor-kind <kind>", "with --sensor-command: shell | test (default test)").option("--sensor-timeout <ms>", "with --sensor-command: max runtime in ms (default 120000)").option("--sensor-absent <regex>", "one-shot: regex marking CORRECT usage nearby (excludes it from firing)").option("--sensor-severity <level>", "one-shot sensor severity: warn | block", "block").option("--sensor-message <text>", "one-shot: self-correction message shown when the sensor fires").option("--bad-example <code>", "one-shot: code snippet the sensor must fire on (validation)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot15(opts.dir);
     const paths = resolveHaivePaths14(root);
-    if (!existsSync19(paths.haiveDir)) {
+    if (!existsSync20(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -5863,7 +5961,7 @@ function registerMemoryTried(memory2) {
       process.exitCode = 1;
       return;
     }
-    ui.success(`Recorded: ${path20.relative(root, result.file_path)}`);
+    ui.success(`Recorded: ${path21.relative(root, result.file_path)}`);
     ui.info(`id=${result.id}  type=attempt  status=validated (auto-approved)`);
     if (result.sensor_result) {
       if (result.sensor_result.accepted) {
@@ -5887,8 +5985,8 @@ function registerMemoryTried(memory2) {
 
 // src/commands/memory-seed.ts
 import { readFile as readFile10 } from "fs/promises";
-import { existsSync as existsSync20 } from "fs";
-import path21 from "path";
+import { existsSync as existsSync21 } from "fs";
+import path22 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot16,
@@ -5897,7 +5995,7 @@ import {
 } from "@hivelore/core";
 async function readDependencyMap(root) {
   try {
-    const raw = await readFile10(path21.join(root, "package.json"), "utf8");
+    const raw = await readFile10(path22.join(root, "package.json"), "utf8");
     const pkg = JSON.parse(raw);
     return { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
   } catch {
@@ -5932,7 +6030,7 @@ function registerMemorySeed(memory2) {
       }
       return;
     }
-    if (!existsSync20(paths.haiveDir)) {
+    if (!existsSync21(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -5988,8 +6086,8 @@ function registerMemorySeed(memory2) {
 }
 
 // src/commands/memory-query.ts
-import { existsSync as existsSync21 } from "fs";
-import path22 from "path";
+import { existsSync as existsSync22 } from "fs";
+import path23 from "path";
 import "commander";
 import {
   extractSnippet,
@@ -6005,7 +6103,7 @@ function registerMemoryQuery(memory2) {
   memory2.command("search <text>").alias("query").description("Search memories by id, tag, or substring (AND, OR fallback). Mirrors MCP mem_search. Alias: query").option("-d, --dir <dir>", "project root").option("--limit <n>", "max results", "20").option("--scope <scope>", "personal | team | module").option("--status <csv>", "filter by status (draft,proposed,validated,stale,rejected)").option("--show-rejected", "include rejected memories (hidden by default)").action(async (text, opts) => {
     const root = findProjectRoot17(opts.dir);
     const paths = resolveHaivePaths16(root);
-    if (!existsSync21(paths.memoriesDir)) {
+    if (!existsSync22(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -6046,7 +6144,7 @@ function registerMemoryQuery(memory2) {
       const fm = mem.frontmatter;
       const statusBadge = ui.statusBadge(fm.status);
       console.log(`${ui.bold(fm.id)} ${ui.dim(fm.scope)} ${statusBadge}`);
-      console.log(`  ${ui.dim(path22.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path23.relative(root, filePath))}`);
       const snippet = extractSnippet(mem.body, snippetNeedle);
       if (snippet) console.log(`  ${snippet}`);
     }
@@ -6064,7 +6162,7 @@ ${top.length} of ${matches.length} match${matches.length === 1 ? "" : "es"}`)
 
 // src/commands/memory-reject.ts
 import { writeFile as writeFile13 } from "fs/promises";
-import { existsSync as existsSync22 } from "fs";
+import { existsSync as existsSync23 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot18,
@@ -6078,7 +6176,7 @@ function registerMemoryReject(memory2) {
   memory2.command("reject <id>").description("Record a rejection (blocks auto-promotion and lowers confidence)").option("-r, --reason <reason>", "why this memory is being rejected").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
     const root = findProjectRoot18(opts.dir);
     const paths = resolveHaivePaths17(root);
-    if (!existsSync22(paths.memoriesDir)) {
+    if (!existsSync23(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -6114,9 +6212,9 @@ function registerMemoryReject(memory2) {
 }
 
 // src/commands/memory-rm.ts
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 import { unlink as unlink2 } from "fs/promises";
-import path23 from "path";
+import path24 from "path";
 import { createInterface as createInterface2 } from "readline/promises";
 import "commander";
 import {
@@ -6129,7 +6227,7 @@ function registerMemoryRm(memory2) {
   memory2.command("delete <id>").alias("rm").description("Delete a memory file (and its usage entry by default). Mirrors MCP mem_delete. Alias: rm").option("-y, --yes", "skip the confirmation prompt").option("--keep-usage", "do not remove the usage.json entry").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
     const root = findProjectRoot19(opts.dir);
     const paths = resolveHaivePaths18(root);
-    if (!existsSync23(paths.memoriesDir)) {
+    if (!existsSync24(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -6141,7 +6239,7 @@ function registerMemoryRm(memory2) {
       process.exitCode = 1;
       return;
     }
-    const rel = path23.relative(root, found.filePath);
+    const rel = path24.relative(root, found.filePath);
     if (!opts.yes) {
       const rl = createInterface2({ input: process.stdin, output: process.stdout });
       const answer = (await rl.question(`Delete ${rel}? [y/N] `)).trim().toLowerCase();
@@ -6165,9 +6263,9 @@ function registerMemoryRm(memory2) {
 }
 
 // src/commands/memory-show.ts
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import { readFile as readFile11 } from "fs/promises";
-import path24 from "path";
+import path25 from "path";
 import "commander";
 import {
   deriveConfidence,
@@ -6180,7 +6278,7 @@ function registerMemoryShow(memory2) {
   memory2.command("get <id>").alias("show").description("Print a memory's frontmatter, body, and confidence/usage. Mirrors MCP mem_get. Alias: show").option("--raw", "print the raw file contents instead of a summary").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
     const root = findProjectRoot20(opts.dir);
     const paths = resolveHaivePaths19(root);
-    if (!existsSync24(paths.memoriesDir)) {
+    if (!existsSync25(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -6209,7 +6307,7 @@ function registerMemoryShow(memory2) {
     if (fm.verified_at) console.log(`${ui.dim("verified:")}   ${fm.verified_at}`);
     if (fm.stale_reason) console.log(`${ui.dim("stale:")}      ${fm.stale_reason}`);
     console.log(`${ui.dim("reads:")}      ${u.read_count}  ${ui.dim("rejections:")} ${u.rejected_count}`);
-    console.log(`${ui.dim("file:")}       ${path24.relative(root, found.filePath)}`);
+    console.log(`${ui.dim("file:")}       ${path25.relative(root, found.filePath)}`);
     if (fm.anchor.paths.length || fm.anchor.symbols.length) {
       console.log(ui.dim("anchor:"));
       if (fm.anchor.commit) console.log(`  ${ui.dim("commit:")}  ${fm.anchor.commit}`);
@@ -6224,8 +6322,8 @@ function registerMemoryShow(memory2) {
 }
 
 // src/commands/memory-stats.ts
-import { existsSync as existsSync25 } from "fs";
-import path25 from "path";
+import { existsSync as existsSync26 } from "fs";
+import path26 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence2,
@@ -6238,7 +6336,7 @@ function registerMemoryStats(memory2) {
   memory2.command("stats").description("Show usage stats and confidence levels per memory").option("--id <id>", "show stats for a single memory id").option("--hot", "only unvalidated (draft/proposed) memories read often \u2014 promotion candidates (absorbed `memory hot`)").option("--threshold <n>", "with --hot: minimum read_count to qualify", "3").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot21(opts.dir);
     const paths = resolveHaivePaths20(root);
-    if (!existsSync25(paths.memoriesDir)) {
+    if (!existsSync26(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -6269,13 +6367,13 @@ function registerMemoryStats(memory2) {
       console.log(
         `  ${ui.dim("status:")} ${fm.status}  ${ui.dim("reads:")} ${u.read_count}  ${ui.dim("rejections:")} ${u.rejected_count}`
       );
-      console.log(`  ${ui.dim(path25.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path26.relative(root, filePath))}`);
     }
   });
 }
 
 // src/commands/memory-impact.ts
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync27 } from "fs";
 import "commander";
 import {
   compareImpact,
@@ -6292,7 +6390,7 @@ function registerMemoryImpact(memory2) {
   ).option("--id <id>", "show impact for a single memory id").option("--prune", "list only prune candidates (dead weight worth reviewing)", false).option("--tier <tier>", "filter to a tier: high | medium | low | dormant").option("--json", "emit JSON", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot22(opts.dir);
     const paths = resolveHaivePaths21(root);
-    if (!existsSync26(paths.memoriesDir)) {
+    if (!existsSync27(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -6363,7 +6461,7 @@ function pad(value, width) {
 }
 
 // src/commands/memory-feedback.ts
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 import { writeFile as writeFile14 } from "fs/promises";
 import "commander";
 import {
@@ -6390,7 +6488,7 @@ function registerMemoryFeedback(memory2) {
     }
     const root = findProjectRoot23(opts.dir);
     const paths = resolveHaivePaths22(root);
-    if (!existsSync27(paths.memoriesDir)) {
+    if (!existsSync28(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -6431,8 +6529,8 @@ function registerMemoryFeedback(memory2) {
 
 // src/commands/memory-verify.ts
 import { writeFile as writeFile15 } from "fs/promises";
-import { existsSync as existsSync28 } from "fs";
-import path26 from "path";
+import { existsSync as existsSync29 } from "fs";
+import path27 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot24,
@@ -6446,7 +6544,7 @@ function registerMemoryVerify(memory2) {
   ).option("--id <id>", "verify a single memory by id").option("--all", "verify every memory (default if --id is omitted)").option("--update", "write status=stale or status=validated back to disk").option("--json", "emit machine-readable JSON (for CI / agents)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot24(opts.dir);
     const paths = resolveHaivePaths23(root);
-    if (!existsSync28(paths.memoriesDir)) {
+    if (!existsSync29(paths.memoriesDir)) {
       if (opts.json) {
         console.log(JSON.stringify({ error: "not-initialized", root }, null, 2));
       } else {
@@ -6474,7 +6572,7 @@ function registerMemoryVerify(memory2) {
     for (const { memory: mem, filePath } of targets) {
       const result = await verifyAnchor2(mem, { projectRoot: root });
       const isAnchored = mem.frontmatter.anchor.paths.length > 0 || mem.frontmatter.anchor.symbols.length > 0;
-      const rel = path26.relative(root, filePath);
+      const rel = path27.relative(root, filePath);
       if (!isAnchored) {
         anchorlessIds.push(mem.frontmatter.id);
         entries.push({ id: mem.frontmatter.id, status: "anchorless", path: rel });
@@ -6567,7 +6665,7 @@ function applyVerification(mem, result) {
 
 // src/commands/memory-import.ts
 import { readFile as readFile12 } from "fs/promises";
-import { existsSync as existsSync29 } from "fs";
+import { existsSync as existsSync30 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot25,
@@ -6584,12 +6682,12 @@ function registerMemoryImport(memory2) {
     }
     const root = findProjectRoot25(opts.dir);
     const paths = resolveHaivePaths24(root);
-    if (!existsSync29(paths.haiveDir)) {
+    if (!existsSync30(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
     }
-    if (!existsSync29(opts.from)) {
+    if (!existsSync30(opts.from)) {
       ui.error(`File not found: ${opts.from}`);
       process.exitCode = 1;
       return;
@@ -6622,9 +6720,9 @@ function registerMemoryImport(memory2) {
 }
 
 // src/commands/memory-digest.ts
-import { existsSync as existsSync30 } from "fs";
+import { existsSync as existsSync31 } from "fs";
 import { writeFile as writeFile16 } from "fs/promises";
-import path27 from "path";
+import path28 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence3,
@@ -6647,7 +6745,7 @@ function registerMemoryDigest(program2) {
   ).option("--days <n>", "look-back window in days (default: 7)", "7").option("--scope <scope>", "personal | team | module | all (default: team)", "team").option("--out <file>", "write digest to a file instead of stdout").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot26(opts.dir);
     const paths = resolveHaivePaths25(root);
-    if (!existsSync30(paths.memoriesDir)) {
+    if (!existsSync31(paths.memoriesDir)) {
       ui.error("No .ai/memories found. Run `hivelore init` first.");
       process.exitCode = 1;
       return;
@@ -6719,7 +6817,7 @@ function registerMemoryDigest(program2) {
     );
     const digest = lines.join("\n");
     if (opts.out) {
-      const outPath = path27.resolve(process.cwd(), opts.out);
+      const outPath = path28.resolve(process.cwd(), opts.out);
       await writeFile16(outPath, digest, "utf8");
       ui.success(`Digest written to ${opts.out}  (${recent.length} memor${recent.length === 1 ? "y" : "ies"})`);
     } else {
@@ -6730,9 +6828,9 @@ function registerMemoryDigest(program2) {
 
 // src/commands/session-end.ts
 import { writeFile as writeFile17, mkdir as mkdir11, readFile as readFile13, rm } from "fs/promises";
-import { existsSync as existsSync31 } from "fs";
+import { existsSync as existsSync32 } from "fs";
 import { spawn as spawn2 } from "child_process";
-import path28 from "path";
+import path29 from "path";
 import { Option as Option2 } from "commander";
 import {
   buildFrontmatter as buildFrontmatter5,
@@ -6749,8 +6847,8 @@ import {
   writeSessionHandoff
 } from "@hivelore/core";
 async function buildAutoRecap(paths) {
-  const obsFile = path28.join(paths.haiveDir, ".cache", "observations.jsonl");
-  if (!existsSync31(obsFile)) return await buildGitAutoRecap(paths);
+  const obsFile = path29.join(paths.haiveDir, ".cache", "observations.jsonl");
+  if (!existsSync32(obsFile)) return await buildGitAutoRecap(paths);
   const raw = await readFile13(obsFile, "utf8").catch(() => "");
   if (!raw.trim()) return await buildGitAutoRecap(paths);
   const lines = raw.split("\n").filter(Boolean);
@@ -6918,8 +7016,8 @@ function runGit(cwd, args) {
   });
 }
 async function observationStart(paths) {
-  const obsFile = path28.join(paths.haiveDir, ".cache", "observations.jsonl");
-  if (!existsSync31(obsFile)) return null;
+  const obsFile = path29.join(paths.haiveDir, ".cache", "observations.jsonl");
+  if (!existsSync32(obsFile)) return null;
   const raw = await readFile13(obsFile, "utf8").catch(() => "");
   let first = null;
   for (const line of raw.split("\n")) {
@@ -6935,7 +7033,7 @@ async function observationStart(paths) {
 }
 async function printCaughtForYou(paths, since, quiet) {
   if (quiet) return;
-  const memories = existsSync31(paths.memoriesDir) ? await loadMemoriesFromDir10(paths.memoriesDir) : [];
+  const memories = existsSync32(paths.memoriesDir) ? await loadMemoriesFromDir10(paths.memoriesDir) : [];
   const usage = await loadUsageIndex11(paths);
   const events = await loadPreventionEvents(paths);
   const summary = summarizeCaughtForYou(events, memories, usage, {
@@ -6973,7 +7071,7 @@ function registerSessionEnd(session2) {
   ).option("--goal <text>", "what you were trying to accomplish (1\u20132 sentences)").option("--accomplished <text>", "what was actually done (bullet list recommended)").addOption(new Option2("--summary <text>", "alias for --accomplished").hideHelp()).option("--discoveries <text>", "bugs, surprises, or inconsistencies found during this session").option("--files <csv>", "key files touched, comma-separated (used as anchor for staleness detection)").option("--next <text>", "what should happen next (for the next session or a teammate)").option("--scope <scope>", "personal | team | module (default: personal)", "personal").option("--module <name>", "module name (required when scope=module)").option("--auto", "synthesize the recap from .ai/.cache/observations.jsonl (used by Claude Code SessionEnd hook)").option("--quiet", "suppress non-error output (for hook use)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot27(opts.dir);
     const paths = resolveHaivePaths26(root);
-    if (!existsSync31(paths.haiveDir)) {
+    if (!existsSync32(paths.haiveDir)) {
       if (opts.auto || opts.quiet) return;
       ui.error(`No .ai/ found at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
@@ -7007,15 +7105,15 @@ function registerSessionEnd(session2) {
     });
     const topic = recapTopic(scope, opts.module);
     const filesTouched = parseCsv5(resolvedFiles).map((p) => normalizeAnchorPath(root, p));
-    const missingPaths = filesTouched.filter((p) => !existsSync31(path28.resolve(root, p)));
+    const missingPaths = filesTouched.filter((p) => !existsSync32(path29.resolve(root, p)));
     if (missingPaths.length > 0 && !opts.quiet) {
       ui.warn(`Anchor path${missingPaths.length > 1 ? "s" : ""} not found in project (will be stale):`);
       for (const p of missingPaths) ui.warn(`  \u2717 ${p}`);
     }
     const cleanupObservations = async () => {
       if (!opts.auto) return;
-      const obsFile = path28.join(paths.haiveDir, ".cache", "observations.jsonl");
-      if (existsSync31(obsFile)) await rm(obsFile).catch(() => {
+      const obsFile = path29.join(paths.haiveDir, ".cache", "observations.jsonl");
+      if (existsSync32(obsFile)) await rm(obsFile).catch(() => {
       });
     };
     const config = await loadConfig6(paths);
@@ -7039,7 +7137,7 @@ function registerSessionEnd(session2) {
       }
       return;
     }
-    if (existsSync31(paths.memoriesDir)) {
+    if (existsSync32(paths.memoriesDir)) {
       const existing = await loadMemoriesFromDir10(paths.memoriesDir);
       const topicMatch = existing.find(
         ({ memory: memory2 }) => memory2.frontmatter.topic === topic && memory2.frontmatter.scope === scope && (!opts.module || memory2.frontmatter.module === opts.module)
@@ -7060,7 +7158,7 @@ function registerSessionEnd(session2) {
         await cleanupObservations();
         if (!opts.quiet) {
           ui.success(`Session recap updated (revision #${revisionCount})`);
-          ui.info(`id=${fm.id}  file=${path28.relative(root, topicMatch.filePath)}`);
+          ui.info(`id=${fm.id}  file=${path29.relative(root, topicMatch.filePath)}`);
           await printCaughtForYou(paths, caughtSince, opts.quiet);
           ui.info("Tip: `hivelore stats --export-report` generates a usage JSON suitable for dashboards.");
         }
@@ -7078,12 +7176,12 @@ function registerSessionEnd(session2) {
       status: "validated"
     });
     const file = memoryFilePath5(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir11(path28.dirname(file), { recursive: true });
+    await mkdir11(path29.dirname(file), { recursive: true });
     await writeFile17(file, serializeMemory12({ frontmatter, body }), "utf8");
     await cleanupObservations();
     if (!opts.quiet) {
       ui.success(`Session recap created`);
-      ui.info(`id=${frontmatter.id}  scope=${scope}  file=${path28.relative(root, file)}`);
+      ui.info(`id=${frontmatter.id}  scope=${scope}  file=${path29.relative(root, file)}`);
       await printCaughtForYou(paths, caughtSince, opts.quiet);
       ui.info("Next session: call `get_briefing` \u2014 the recap will be surfaced automatically.");
       ui.info("Tip: export a local MCP usage rollup with `hivelore stats --export-report .ai/tool-usage-roi-report.json`.");
@@ -7096,17 +7194,17 @@ function parseCsv5(value) {
 }
 function normalizeAnchorPath(root, filePath) {
   if (!filePath) return filePath;
-  if (!path28.isAbsolute(filePath)) return filePath;
-  const rel = path28.relative(root, filePath);
+  if (!path29.isAbsolute(filePath)) return filePath;
+  const rel = path29.relative(root, filePath);
   if (rel.startsWith("..")) return filePath;
   return rel;
 }
 
 // src/commands/stats.ts
 import "commander";
-import { existsSync as existsSync32 } from "fs";
+import { existsSync as existsSync33 } from "fs";
 import { mkdir as mkdir12, writeFile as writeFile18 } from "fs/promises";
-import path29 from "path";
+import path30 from "path";
 import {
   aggregateUsage,
   findProjectRoot as findProjectRoot28,
@@ -7178,11 +7276,11 @@ function registerStats(program2) {
   });
 }
 async function writeRoiReport(paths, root, sinceRaw, outRelative) {
-  const outAbs = path29.isAbsolute(outRelative) ? path29.resolve(outRelative) : path29.resolve(root, outRelative);
+  const outAbs = path30.isAbsolute(outRelative) ? path30.resolve(outRelative) : path30.resolve(root, outRelative);
   const size = await usageLogSize(paths);
   let events = await readUsageEvents(paths);
   let memoryCount = { team: 0, personal: 0, total_skipped_session: 0 };
-  if (existsSync32(paths.memoriesDir)) {
+  if (existsSync33(paths.memoriesDir)) {
     const mems = await loadMemoriesFromDir11(paths.memoriesDir);
     for (const { memory: memory2 } of mems) {
       const fm = memory2.frontmatter;
@@ -7212,7 +7310,7 @@ async function writeRoiReport(paths, root, sinceRaw, outRelative) {
     ui.warn("Usage log missing or empty \u2014 report still written with partial data.");
     events = [];
   }
-  await mkdir12(path29.dirname(outAbs), { recursive: true });
+  await mkdir12(path30.dirname(outAbs), { recursive: true });
   const payload = {
     generated_at: (/* @__PURE__ */ new Date()).toISOString(),
     project_root: root,
@@ -7401,9 +7499,9 @@ function summarize(name, t0, payload, notes) {
 }
 
 // src/commands/benchmark.ts
-import { existsSync as existsSync33 } from "fs";
+import { existsSync as existsSync34 } from "fs";
 import { readdir as readdir3, readFile as readFile14, writeFile as writeFile19 } from "fs/promises";
-import path30 from "path";
+import path31 from "path";
 import "commander";
 import { estimateTokens as estimateTokens2, findProjectRoot as findProjectRoot30 } from "@hivelore/core";
 function registerBenchmark(program2) {
@@ -7418,9 +7516,9 @@ function registerBenchmark(program2) {
     }
     const markdown = renderMarkdown(root, summary, rows);
     if (opts.out) {
-      const outFile = path30.isAbsolute(opts.out) ? opts.out : path30.join(root, opts.out);
+      const outFile = path31.isAbsolute(opts.out) ? opts.out : path31.join(root, opts.out);
       await writeFile19(outFile, markdown, "utf8");
-      ui.success(`wrote ${path30.relative(process.cwd(), outFile)}`);
+      ui.success(`wrote ${path31.relative(process.cwd(), outFile)}`);
       return;
     }
     console.log(markdown);
@@ -7444,19 +7542,19 @@ function registerBenchmark(program2) {
 }
 function resolveBenchmarkRoot(dir) {
   const candidate = dir ?? "benchmarks/agent-benchmark";
-  if (path30.isAbsolute(candidate)) return candidate;
+  if (path31.isAbsolute(candidate)) return candidate;
   const projectRoot = findProjectRoot30(process.cwd());
-  return path30.join(projectRoot, candidate);
+  return path31.join(projectRoot, candidate);
 }
 async function collectRows(root) {
-  if (!existsSync33(root)) throw new Error(`Benchmark directory not found: ${root}`);
+  if (!existsSync34(root)) throw new Error(`Benchmark directory not found: ${root}`);
   const entries = await readdir3(root, { withFileTypes: true });
   const rows = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const fixtureDir = path30.join(root, entry.name);
-    const reportFile = path30.join(fixtureDir, "BENCHMARK_AGENT_REPORT.md");
-    if (!existsSync33(reportFile)) continue;
+    const fixtureDir = path31.join(root, entry.name);
+    const reportFile = path31.join(fixtureDir, "BENCHMARK_AGENT_REPORT.md");
+    if (!existsSync34(reportFile)) continue;
     const report = await readFile14(reportFile, "utf8");
     rows.push(parseAgentReport(entry.name, report));
   }
@@ -7549,8 +7647,8 @@ function escapeRegExp(value) {
 
 // src/commands/eval.ts
 import { mkdir as mkdir13, readFile as readFile15, writeFile as writeFile20 } from "fs/promises";
-import { existsSync as existsSync34 } from "fs";
-import path31 from "path";
+import { existsSync as existsSync35 } from "fs";
+import path32 from "path";
 import "commander";
 import {
   aggregateRetrieval,
@@ -7578,7 +7676,7 @@ function registerEval(program2) {
   ).option("--spec <file>", "JSON eval spec ({ retrieval: [...], sensors: [...] })").option("--semantic-only", "self-eval probes by title alone (no anchor files) \u2014 harder retrieval", false).option("-k, --top <n>", "briefing top-k considered a hit", "8").option("--json", "emit JSON", false).option("--out <file>", "write a Markdown report").option("--fail-under <score>", "exit non-zero if the overall score is below this (0\u2013100) \u2014 for CI gates").option("--fail-under-catch-rate <pct>", "exit non-zero if sensor catch-rate is below this percentage").option("--fail-under-gate-precision <pct>", "exit non-zero if gate precision is below this percentage").option("--baseline", "save this run as the baseline (.ai/eval/baseline.json) for future --compare", false).option("--compare", "diff this run against the saved baseline and print the delta", false).option("--baseline-file <path>", "baseline file to read/write (default: .ai/eval/baseline.json)").option("--fail-on-regression", "with --compare, exit non-zero if the score dropped vs the baseline", false).option("--regression-gate", "CI-safe gate: compare against the baseline IF one exists (fail on regression), else no-op", false).option("--record", "append this run's score to .ai/.cache/eval-history.jsonl (trend the harness over time)", false).option("--trend", "print the recorded score trend (sparkline + latest/best/delta) and exit", false).option("--ref <ref>", "version/commit label stored with a --record run").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot31(opts.dir);
     const paths = resolveHaivePaths29(root);
-    if (!existsSync34(paths.memoriesDir)) {
+    if (!existsSync35(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -7650,7 +7748,7 @@ function registerEval(program2) {
       });
       if (!opts.json) ui.success(`Recorded eval score ${report.score}/100 to history.`);
     }
-    const baselineFile = opts.baselineFile ? path31.isAbsolute(opts.baselineFile) ? opts.baselineFile : path31.join(root, opts.baselineFile) : path31.join(root, ".ai", "eval", "baseline.json");
+    const baselineFile = opts.baselineFile ? path32.isAbsolute(opts.baselineFile) ? opts.baselineFile : path32.join(root, opts.baselineFile) : path32.join(root, ".ai", "eval", "baseline.json");
     if (opts.baseline) {
       const snapshot = {
         saved_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -7659,18 +7757,18 @@ function registerEval(program2) {
         report,
         gate_precision: gatePrecision
       };
-      await mkdir13(path31.dirname(baselineFile), { recursive: true });
+      await mkdir13(path32.dirname(baselineFile), { recursive: true });
       await writeFile20(baselineFile, JSON.stringify(snapshot, null, 2), "utf8");
-      if (!opts.json) ui.success(`Saved baseline (score ${report.score}/100) \u2192 ${path31.relative(root, baselineFile)}`);
+      if (!opts.json) ui.success(`Saved baseline (score ${report.score}/100) \u2192 ${path32.relative(root, baselineFile)}`);
     }
     let delta = null;
     let gateDelta = null;
     if (opts.compare || opts.regressionGate) {
-      if (!existsSync34(baselineFile)) {
+      if (!existsSync35(baselineFile)) {
         if (opts.regressionGate) {
-          if (!opts.json) ui.info(`No baseline at ${path31.relative(root, baselineFile)} \u2014 regression gate skipped. Run \`hivelore eval --baseline\` to enable it.`);
+          if (!opts.json) ui.info(`No baseline at ${path32.relative(root, baselineFile)} \u2014 regression gate skipped. Run \`hivelore eval --baseline\` to enable it.`);
         } else {
-          ui.error(`No baseline at ${path31.relative(root, baselineFile)}. Run \`hivelore eval --baseline\` first.`);
+          ui.error(`No baseline at ${path32.relative(root, baselineFile)}. Run \`hivelore eval --baseline\` first.`);
           process.exitCode = 1;
           return;
         }
@@ -7713,9 +7811,9 @@ function registerEval(program2) {
     }
     const md = renderMarkdown2(root, k, resolvedSpec, report, gatePrecision, authoredScore);
     if (opts.out) {
-      const outFile = path31.isAbsolute(opts.out) ? opts.out : path31.join(root, opts.out);
+      const outFile = path32.isAbsolute(opts.out) ? opts.out : path32.join(root, opts.out);
       await writeFile20(outFile, md, "utf8");
-      ui.success(`wrote ${path31.relative(process.cwd(), outFile)}`);
+      ui.success(`wrote ${path32.relative(process.cwd(), outFile)}`);
     } else {
       console.log(md);
     }
@@ -7799,13 +7897,13 @@ function countCases(spec) {
 }
 async function resolveSpec(opts, root, memoriesDir) {
   if (opts.spec) {
-    const file = path31.resolve(opts.spec);
+    const file = path32.resolve(opts.spec);
     const raw = await readFile15(file, "utf8");
     const spec = JSON.parse(raw);
     return { spec, source: file, synthesized: 0, authored: countCases(spec) };
   }
-  const defaultSpec = path31.join(root, ".ai", "eval", "spec.json");
-  if (existsSync34(defaultSpec)) {
+  const defaultSpec = path32.join(root, ".ai", "eval", "spec.json");
+  if (existsSync35(defaultSpec)) {
     const raw = await readFile15(defaultSpec, "utf8");
     const explicit = JSON.parse(raw);
     const memories2 = await loadMemoriesFromDir(memoriesDir);
@@ -7932,8 +8030,8 @@ function renderMarkdown2(root, k, resolved, report, gatePrecision, authoredScore
 
 // src/commands/memory-suggest.ts
 import { mkdir as mkdir14, writeFile as writeFile21 } from "fs/promises";
-import { existsSync as existsSync35 } from "fs";
-import path32 from "path";
+import { existsSync as existsSync36 } from "fs";
+import path33 from "path";
 import "commander";
 import {
   MemoryTypeSchema,
@@ -8023,7 +8121,7 @@ function registerMemorySuggest(memory2) {
       }
       const created = [];
       const skipped = [];
-      const existing = existsSync35(paths.memoriesDir) ? await loadMemoriesFromDir12(paths.memoriesDir) : [];
+      const existing = existsSync36(paths.memoriesDir) ? await loadMemoriesFromDir12(paths.memoriesDir) : [];
       for (const s of top) {
         const slug = slugify2(s.query);
         if (!slug) {
@@ -8046,13 +8144,13 @@ function registerMemorySuggest(memory2) {
         });
         const body = renderTemplate(s, fm.id, status);
         const file = memoryFilePath6(paths, fm.scope, fm.id, fm.module);
-        await mkdir14(path32.dirname(file), { recursive: true });
-        if (existsSync35(file)) {
-          skipped.push({ query: s.query, reason: `file already exists at ${path32.relative(root, file)}` });
+        await mkdir14(path33.dirname(file), { recursive: true });
+        if (existsSync36(file)) {
+          skipped.push({ query: s.query, reason: `file already exists at ${path33.relative(root, file)}` });
           continue;
         }
         await writeFile21(file, serializeMemory13({ frontmatter: fm, body }), "utf8");
-        created.push({ id: fm.id, file: path32.relative(root, file), query: s.query });
+        created.push({ id: fm.id, file: path33.relative(root, file), query: s.query });
       }
       if (opts.json) {
         console.log(JSON.stringify({ created, skipped }, null, 2));
@@ -8150,8 +8248,8 @@ function truncate2(text, max) {
 }
 
 // src/commands/memory-conflict-candidates.ts
-import { existsSync as existsSync36 } from "fs";
-import path33 from "path";
+import { existsSync as existsSync37 } from "fs";
+import path34 from "path";
 import "commander";
 import {
   findLexicalConflictPairs,
@@ -8187,9 +8285,9 @@ function registerMemoryConflictCandidates(memory2) {
   });
 }
 async function runConflictCandidates(opts) {
-  const root = path33.resolve(opts.dir ?? process.cwd());
+  const root = path34.resolve(opts.dir ?? process.cwd());
   const paths = resolveHaivePaths31(findProjectRoot33(root));
-  if (!existsSync36(paths.memoriesDir)) {
+  if (!existsSync37(paths.memoriesDir)) {
     ui.error("No memories \u2014 run `hivelore init`.");
     process.exitCode = 1;
     return;
@@ -8223,9 +8321,9 @@ async function runConflictCandidates(opts) {
 }
 
 // src/commands/memory-archive.ts
-import { existsSync as existsSync37 } from "fs";
+import { existsSync as existsSync38 } from "fs";
 import { writeFile as writeFile22 } from "fs/promises";
-import path34 from "path";
+import path35 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot34,
@@ -8244,7 +8342,7 @@ function registerMemoryArchive(memory2) {
   ).option("--since <window>", "minimum age since last read (e.g. '180d', '6m'). Default: enforcement.decayAfterDays or 180d").option("--type <type>", "limit to a memory type (default 'attempt'). Pass 'all' to scan all types.", "attempt").option("--unread", "decay by unread-age ALONE (ignore anchor status) \u2014 more aggressive corpus hygiene", false).option("--apply", "actually rewrite files (default: dry run)", false).option("--json", "emit JSON instead of human-readable output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot34(opts.dir);
     const paths = resolveHaivePaths32(root);
-    if (!existsSync37(paths.memoriesDir)) {
+    if (!existsSync38(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -8269,7 +8367,7 @@ function registerMemoryArchive(memory2) {
       if (fm.status === "deprecated" || fm.status === "rejected") continue;
       const retired = retirementSignal2(fm, mem.body);
       const hasAnyAnchor = fm.anchor.paths.length + fm.anchor.symbols.length > 0;
-      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync37(path34.join(paths.root, p)));
+      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync38(path35.join(paths.root, p)));
       const isAnchorless = !hasAnyAnchor;
       if (!retired.retired && !opts.unread && !isAnchorless && !allPathsGone) continue;
       const u = getUsage8(usage, fm.id);
@@ -8344,9 +8442,9 @@ function parseDays(input) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync38, statSync as statSync2 } from "fs";
+import { existsSync as existsSync39, statSync as statSync2 } from "fs";
 import { readFile as readFile16, stat, writeFile as writeFile23 } from "fs/promises";
-import path35 from "path";
+import path36 from "path";
 import { execFileSync, execSync } from "child_process";
 import "commander";
 import {
@@ -8360,7 +8458,7 @@ import {
   isStackPackSeed as isStackPackSeed2,
   loadCodeMap as loadCodeMap6,
   loadConfig as loadConfig10,
-  loadMemoriesFromDir as loadMemoriesFromDir14,
+  loadMemoriesFromDirDetailed,
   loadUsageIndex as loadUsageIndex15,
   readUsageEvents as readUsageEvents3,
   resolveHaivePaths as resolveHaivePaths33
@@ -8375,7 +8473,7 @@ function registerDoctor(program2) {
     const findings = [];
     const repairs = [];
     const config = await loadConfig10(paths);
-    if (!existsSync38(paths.haiveDir)) {
+    if (!existsSync39(paths.haiveDir)) {
       if (opts.json) {
         console.log(JSON.stringify({
           initialized: false,
@@ -8400,7 +8498,7 @@ function registerDoctor(program2) {
         })
       );
     }
-    if (!existsSync38(paths.projectContext)) {
+    if (!existsSync39(paths.projectContext)) {
       findings.push({
         severity: "warn",
         code: "no-project-context",
@@ -8420,7 +8518,7 @@ function registerDoctor(program2) {
         });
       } else {
         const referenced = extractReferencedPaths(content);
-        const missing = referenced.filter((p) => !existsSync38(path35.resolve(root, p)));
+        const missing = referenced.filter((p) => !existsSync39(path36.resolve(root, p)));
         const grounded = referenced.length - missing.length;
         if (referenced.length >= 3 && grounded / referenced.length < 0.5) {
           findings.push({
@@ -8442,13 +8540,23 @@ function registerDoctor(program2) {
         });
       }
     }
-    const memories = existsSync38(paths.memoriesDir) ? await loadMemoriesFromDir14(paths.memoriesDir) : [];
+    const memoriesDetailed = existsSync39(paths.memoriesDir) ? await loadMemoriesFromDirDetailed(paths.memoriesDir) : { loaded: [], invalid: [] };
+    const memories = memoriesDetailed.loaded;
     const now = Date.now();
+    if (memoriesDetailed.invalid.length > 0) {
+      const listed = memoriesDetailed.invalid.slice(0, 5).map((f) => `${path36.relative(root, f.filePath)} (${f.error})`).join("; ");
+      findings.push({
+        severity: "warn",
+        code: "invalid-memory-files",
+        message: `${memoriesDetailed.invalid.length} memory file(s) failed to parse and are INVISIBLE to briefings and the gate: ${listed}`,
+        fix: "Fix the frontmatter (or delete the file) \u2014 a corrupt memory is a silently lost team lesson."
+      });
+    }
     if (memories.length === 0) {
       findings.push({
         severity: "info",
         code: "no-memories",
-        message: "No memories yet. Capture knowledge as agents work via mem_save / mem_observe / mem_tried."
+        message: "No memories yet. Capture knowledge as agents work via mem_save / mem_tried."
       });
     } else {
       const usage = await loadUsageIndex15(paths);
@@ -8458,7 +8566,7 @@ function registerDoctor(program2) {
           severity: "warn",
           code: "stale-memories",
           message: `${stale.length} memor${stale.length === 1 ? "y" : "ies"} marked stale (anchored code drifted).`,
-          fix: "hivelore memory verify --update    # re-check anchors\nhaive memory edit <id>           # manually refresh body"
+          fix: "hivelore memory verify --update    # re-check anchors\nhivelore memory update <id>        # manually refresh body"
         });
       }
       const proposed = memories.filter((m) => m.memory.frontmatter.status === "proposed");
@@ -8565,8 +8673,8 @@ function registerDoctor(program2) {
       const anchorPaths = s.paths.length > 0 ? s.paths : m.memory.frontmatter.anchor.paths;
       const targets = [];
       for (const rel of anchorPaths) {
-        const abs = path35.resolve(root, rel);
-        if (!existsSync38(abs)) continue;
+        const abs = path36.resolve(root, rel);
+        if (!existsSync39(abs)) continue;
         try {
           targets.push({ path: rel, content: await readFile16(abs, "utf8") });
         } catch {
@@ -8655,9 +8763,9 @@ function registerDoctor(program2) {
       }
     }
     if (config.enforcement?.requireBriefingFirst) {
-      const claudeSettings = path35.join(root, ".claude", "settings.local.json");
+      const claudeSettings = path36.join(root, ".claude", "settings.local.json");
       let hasClaudeEnforcement = false;
-      if (existsSync38(claudeSettings)) {
+      if (existsSync39(claudeSettings)) {
         try {
           const { readFile: readFile24 } = await import("fs/promises");
           const raw = await readFile24(claudeSettings, "utf8");
@@ -8683,7 +8791,7 @@ function registerDoctor(program2) {
         fix: "Edit .ai/haive.config.json: set autoSessionEnd: true (or re-run `hivelore init` without --manual)."
       });
     }
-    findings.push(...await collectInstallFindings(root, "0.33.0"));
+    findings.push(...await collectInstallFindings(root, "0.34.1"));
     findings.push(...await collectToolchainFindings(root));
     try {
       const legacyRaw = execSync("haive-mcp --version", {
@@ -8691,7 +8799,7 @@ function registerDoctor(program2) {
         timeout: 3e3,
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      const cliVersion = "0.33.0";
+      const cliVersion = "0.34.1";
       if (legacyRaw && legacyRaw !== cliVersion) {
         findings.push({
           severity: "warn",
@@ -8707,17 +8815,17 @@ npm uninstall -g @hivelore/mcp`
     }
     {
       const configPaths = [
-        path35.join(root, ".mcp.json"),
-        path35.join(root, ".cursor", "mcp.json"),
-        path35.join(root, ".vscode", "mcp.json")
+        path36.join(root, ".mcp.json"),
+        path36.join(root, ".cursor", "mcp.json"),
+        path36.join(root, ".vscode", "mcp.json")
       ];
       const staleConfigs = [];
       for (const cfgPath of configPaths) {
-        if (!existsSync38(cfgPath)) continue;
+        if (!existsSync39(cfgPath)) continue;
         try {
           const raw = await readFile16(cfgPath, "utf8");
           if (raw.includes('"haive-mcp"') || raw.includes("'haive-mcp'")) {
-            staleConfigs.push(path35.relative(root, cfgPath));
+            staleConfigs.push(path36.relative(root, cfgPath));
             if (opts.fix && !opts.dryRun) {
               const updated = raw.replace(/"command"\s*:\s*"haive-mcp"/g, '"command": "hivelore"').replace(/"args"\s*:\s*\[\]/g, '"args": ["mcp", "--stdio"]');
               await writeFile23(cfgPath, updated, "utf8");
@@ -9010,8 +9118,8 @@ which -a hivelore haive`
   const missingBins = /* @__PURE__ */ new Map();
   const staleBins = /* @__PURE__ */ new Map();
   for (const rel of integrationFiles) {
-    const file = path35.join(root, rel);
-    if (!existsSync38(file)) continue;
+    const file = path36.join(root, rel);
+    if (!existsSync39(file)) continue;
     const text = await readFile16(file, "utf8").catch(() => "");
     for (const bin of extractAbsoluteHaiveBins(text)) {
       const version = versionForBinary(bin);
@@ -9044,7 +9152,7 @@ which -a hivelore haive`
 async function collectToolchainFindings(root) {
   const findings = [];
   const pkg = await readJson(
-    path35.join(root, "package.json")
+    path36.join(root, "package.json")
   );
   const wantsPnpm = pkg?.packageManager?.startsWith("pnpm@") || Object.values(pkg?.scripts ?? {}).some((script) => /\bpnpm\b/.test(script));
   if (!wantsPnpm) return findings;
@@ -9063,10 +9171,10 @@ async function collectToolchainFindings(root) {
 }
 async function collectDistFreshnessFindings(root, expectedVersion) {
   const findings = [];
-  const isHaiveWorkspace = ["hivelore-monorepo", "haive-monorepo"].includes((await readJson(path35.join(root, "package.json")))?.name ?? "");
+  const isHaiveWorkspace = ["hivelore-monorepo", "haive-monorepo"].includes((await readJson(path36.join(root, "package.json")))?.name ?? "");
   if (!isHaiveWorkspace) return findings;
-  const cliDist = path35.join(root, "packages/cli/dist/index.js");
-  if (!existsSync38(cliDist)) {
+  const cliDist = path36.join(root, "packages/cli/dist/index.js");
+  if (!existsSync39(cliDist)) {
     findings.push({
       severity: "warn",
       code: "workspace-dist-missing",
@@ -9090,7 +9198,7 @@ async function collectDistFreshnessFindings(root, expectedVersion) {
     "packages/core/src/index.ts",
     "packages/mcp/src/server.ts",
     "packages/cli/src/index.ts"
-  ].map((rel) => path35.join(root, rel)).filter(existsSync38);
+  ].map((rel) => path36.join(root, rel)).filter(existsSync39);
   if (sourceFiles.length > 0) {
     const distMtime = statSync2(cliDist).mtimeMs;
     const newestSource = Math.max(...sourceFiles.map((file) => statSync2(file).mtimeMs));
@@ -9108,7 +9216,7 @@ async function collectDistFreshnessFindings(root, expectedVersion) {
 }
 async function collectWorkspaceVersionFindings(root, expectedVersion) {
   const findings = [];
-  const rootPkg = await readJson(path35.join(root, "package.json"));
+  const rootPkg = await readJson(path36.join(root, "package.json"));
   const workspacePackages = [
     "packages/core/package.json",
     "packages/embeddings/package.json",
@@ -9117,7 +9225,7 @@ async function collectWorkspaceVersionFindings(root, expectedVersion) {
   ];
   const existing = (await Promise.all(workspacePackages.map(async (rel) => ({
     rel,
-    pkg: await readJson(path35.join(root, rel))
+    pkg: await readJson(path36.join(root, rel))
   })))).filter((item) => item.pkg);
   const isHaiveWorkspace = rootPkg?.name === "hivelore-monorepo" || rootPkg?.name === "haive-monorepo" || existing.some((item) => item.pkg?.name?.startsWith("@hivelore/"));
   if (!isHaiveWorkspace) return findings;
@@ -9179,7 +9287,7 @@ function collectGlobalHivemoduleFindings(expectedVersion) {
   }
 }
 async function readJson(file) {
-  if (!existsSync38(file)) return null;
+  if (!existsSync39(file)) return null;
   try {
     return JSON.parse(await readFile16(file, "utf8"));
   } catch {
@@ -9408,23 +9516,23 @@ function runCommand(cmd, args, cwd) {
 }
 
 // src/commands/resolve-project.ts
-import path36 from "path";
+import path37 from "path";
 import "commander";
 import { resolveProjectInfo } from "@hivelore/core";
 function registerResolveProject(program2) {
   program2.command("resolve-project").description(
     "Print JSON for Hivelore project root resolution (HAIVE_PROJECT_ROOT, markers, .ai layout)."
   ).option("-d, --dir <dir>", "working directory", process.cwd()).action((opts) => {
-    const info = resolveProjectInfo({ cwd: path36.resolve(opts.dir) });
+    const info = resolveProjectInfo({ cwd: path37.resolve(opts.dir) });
     console.log(JSON.stringify({ ok: true, info }, null, 2));
   });
 }
 
 // src/commands/enforce.ts
 import { execFile as execFile4, execFileSync as execFileSync2, spawn as spawn4 } from "child_process";
-import { existsSync as existsSync40, statSync as statSync3 } from "fs";
+import { existsSync as existsSync41, statSync as statSync3 } from "fs";
 import { chmod, mkdir as mkdir16, readFile as readFile18, readdir as readdir4, rm as rm2, writeFile as writeFile25 } from "fs/promises";
-import path38 from "path";
+import path39 from "path";
 import { promisify as promisify4 } from "util";
 import "commander";
 import {
@@ -9441,7 +9549,7 @@ import {
   isRetiredMemory as isRetiredMemory2,
   loadConfig as loadConfig12,
   detectAgentContext,
-  loadMemoriesFromDir as loadMemoriesFromDir15,
+  loadMemoriesFromDir as loadMemoriesFromDir14,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
   readRecentBriefingMarker,
   recordPreventionHits,
@@ -9457,9 +9565,9 @@ import {
 } from "@hivelore/core";
 
 // src/utils/claude-hooks.ts
-import { existsSync as existsSync39 } from "fs";
+import { existsSync as existsSync40 } from "fs";
 import { mkdir as mkdir15, readFile as readFile17, writeFile as writeFile24 } from "fs/promises";
-import path37 from "path";
+import path38 from "path";
 var HAIVE_HOOK_TAG = "haive-enforcement";
 var POST_TOOL_USE_GROUP = {
   matcher: "Edit|Write|Bash",
@@ -9545,7 +9653,7 @@ function unpatchClaudeSettings(input) {
 async function installClaudeHooksAtPath(settingsPath) {
   let raw = null;
   let created = false;
-  if (existsSync39(settingsPath)) {
+  if (existsSync40(settingsPath)) {
     try {
       raw = JSON.parse(await readFile17(settingsPath, "utf8"));
     } catch {
@@ -9555,12 +9663,12 @@ async function installClaudeHooksAtPath(settingsPath) {
     created = true;
   }
   const patched = patchClaudeSettings(raw);
-  await mkdir15(path37.dirname(settingsPath), { recursive: true });
+  await mkdir15(path38.dirname(settingsPath), { recursive: true });
   await writeFile24(settingsPath, JSON.stringify(patched, null, 2) + "\n", "utf8");
   return { settingsPath, created };
 }
 async function uninstallClaudeHooksAtPath(settingsPath) {
-  if (!existsSync39(settingsPath)) {
+  if (!existsSync40(settingsPath)) {
     return { settingsPath, created: false };
   }
   const raw = JSON.parse(await readFile17(settingsPath, "utf8"));
@@ -9571,9 +9679,9 @@ async function uninstallClaudeHooksAtPath(settingsPath) {
 function defaultClaudeSettingsPath(scope, projectRoot) {
   if (scope === "user") {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-    return path37.join(home, ".claude", "settings.json");
+    return path38.join(home, ".claude", "settings.json");
   }
-  return path37.join(projectRoot, ".claude", "settings.local.json");
+  return path38.join(projectRoot, ".claude", "settings.local.json");
 }
 
 // src/utils/command-sensors.ts
@@ -9715,7 +9823,7 @@ function registerEnforce(program2) {
           ui.success(`Removed Hivelore hooks from ${result.settingsPath}`);
         } else {
           const result = await installClaudeHooksAtPath(settingsPath);
-          ui.success(`${result.created ? "Created" : "Patched"} Claude Code hooks (${path38.relative(root, result.settingsPath) || result.settingsPath})`);
+          ui.success(`${result.created ? "Created" : "Patched"} Claude Code hooks (${path39.relative(root, result.settingsPath) || result.settingsPath})`);
         }
       } catch (err) {
         ui.warn(`Claude Code hooks not ${opts.removeClaude ? "removed" : "installed"}: ${err instanceof Error ? err.message : String(err)}`);
@@ -9737,19 +9845,19 @@ function registerEnforce(program2) {
   enforce.command("cleanup").description("Remove generated Hivelore runtime/cache artifacts that should not appear in commits.").option("-d, --dir <dir>", "project root").option("--dry-run", "print what would be removed without deleting", false).action(async (opts) => {
     const root = findProjectRoot37(opts.dir);
     const paths = resolveHaivePaths35(root);
-    const cacheDir = path38.join(paths.haiveDir, ".cache");
-    if (existsSync40(cacheDir)) {
-      if (opts.dryRun) ui.info(`would clean ${path38.relative(root, cacheDir)} (preserving .gitignore)`);
+    const cacheDir = path39.join(paths.haiveDir, ".cache");
+    if (existsSync41(cacheDir)) {
+      if (opts.dryRun) ui.info(`would clean ${path39.relative(root, cacheDir)} (preserving .gitignore)`);
       else {
         const removed = await cleanupCacheDir(cacheDir);
-        ui.success(`cleaned ${path38.relative(root, cacheDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
+        ui.success(`cleaned ${path39.relative(root, cacheDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
       }
     }
-    if (existsSync40(paths.runtimeDir)) {
-      if (opts.dryRun) ui.info(`would clean ${path38.relative(root, paths.runtimeDir)} (preserving briefing markers)`);
+    if (existsSync41(paths.runtimeDir)) {
+      if (opts.dryRun) ui.info(`would clean ${path39.relative(root, paths.runtimeDir)} (preserving briefing markers)`);
       else {
         const removed = await cleanupRuntimeDir(paths.runtimeDir);
-        ui.success(`cleaned ${path38.relative(root, paths.runtimeDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
+        ui.success(`cleaned ${path39.relative(root, paths.runtimeDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
       }
     }
   });
@@ -9793,7 +9901,7 @@ function registerEnforce(program2) {
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
     const paths = resolveHaivePaths35(root);
-    if (!existsSync40(paths.haiveDir)) return;
+    if (!existsSync41(paths.haiveDir)) return;
     await mkdir16(paths.runtimeDir, { recursive: true });
     const sessionId = opts.sessionId ?? payload.session_id;
     const task = opts.task ?? payload.prompt ?? "Start an AI coding session in this Hivelore-initialized project.";
@@ -9856,7 +9964,7 @@ ${briefing.project_context.content.slice(0, 1800)}`);
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
     const paths = resolveHaivePaths35(root);
-    if (!existsSync40(paths.haiveDir)) return;
+    if (!existsSync41(paths.haiveDir)) return;
     if (!isWriteLikeTool(payload)) return;
     const config = await loadConfig12(paths);
     if (config.enforcement?.requireBriefingFirst === false) return;
@@ -9921,7 +10029,7 @@ function emitPreToolUseContext(text) {
 async function buildFinishReport(dir) {
   const root = findProjectRoot37(dir);
   const paths = resolveHaivePaths35(root);
-  const initialized = existsSync40(paths.haiveDir);
+  const initialized = existsSync41(paths.haiveDir);
   const config = initialized ? await loadConfig12(paths) : {};
   const mode = config.enforcement?.mode ?? "strict";
   const findings = [];
@@ -10113,8 +10221,8 @@ async function buildFinishReport(dir) {
 async function checkFailureCapture(paths, config) {
   const gate = config.enforcement?.failureCaptureGate ?? "warn";
   if (gate === "off") return [];
-  const obsFile = path38.join(paths.haiveDir, ".cache", "observations.jsonl");
-  if (!existsSync40(obsFile)) return [];
+  const obsFile = path39.join(paths.haiveDir, ".cache", "observations.jsonl");
+  if (!existsSync41(obsFile)) return [];
   const failures = [];
   try {
     const raw = await readFile18(obsFile, "utf8");
@@ -10131,7 +10239,7 @@ async function checkFailureCapture(paths, config) {
     return [];
   }
   if (failures.length === 0) return [];
-  const memories = existsSync40(paths.memoriesDir) ? await loadMemoriesFromDir15(paths.memoriesDir) : [];
+  const memories = existsSync41(paths.memoriesDir) ? await loadMemoriesFromDir14(paths.memoriesDir) : [];
   const captureTimes = memories.filter(({ memory: memory2 }) => ["attempt", "gotcha"].includes(memory2.frontmatter.type)).map(({ memory: memory2 }) => memory2.frontmatter.created_at);
   const uncaptured = findUncapturedFailures(failures, captureTimes);
   if (uncaptured.length === 0) {
@@ -10166,7 +10274,7 @@ function finishReport(root, initialized, mode, findings, config) {
 async function runWithEnforcement(command, args, opts) {
   const root = findProjectRoot37(opts.dir);
   const paths = resolveHaivePaths35(root);
-  if (!existsSync40(paths.haiveDir)) {
+  if (!existsSync41(paths.haiveDir)) {
     ui.error(`No .ai/ found at ${root}. Run \`hivelore init\` first.`);
     process.exit(1);
   }
@@ -10185,7 +10293,7 @@ async function runWithEnforcement(command, args, opts) {
     process.exit(2);
   }
   ui.info(`Hivelore briefing marker created for wrapped agent session: ${sessionId}`);
-  ui.info(`Briefing written to ${path38.relative(root, briefingFile)} and exported as HAIVE_BRIEFING_FILE`);
+  ui.info(`Briefing written to ${path39.relative(root, briefingFile)} and exported as HAIVE_BRIEFING_FILE`);
   const child = spawn4(command, args, {
     cwd: root,
     stdio: "inherit",
@@ -10237,9 +10345,9 @@ async function writeWrapperBriefing(paths, sessionId, task) {
     source: "haive-run",
     memoryIds: briefing.memories.map((m) => m.id)
   });
-  const dir = path38.join(paths.runtimeDir, "enforcement", "briefings");
+  const dir = path39.join(paths.runtimeDir, "enforcement", "briefings");
   await mkdir16(dir, { recursive: true });
-  const file = path38.join(dir, `${sessionId}.md`);
+  const file = path39.join(dir, `${sessionId}.md`);
   const parts = [
     "# Hivelore Briefing",
     "",
@@ -10277,7 +10385,7 @@ async function checkBootstrapComplete(paths, config, productionCodeChanged) {
     projectContextRaw = await readFile18(paths.projectContext, "utf8");
   } catch {
   }
-  const memories = existsSync40(paths.memoriesDir) ? await loadMemoriesFromDir15(paths.memoriesDir) : [];
+  const memories = existsSync41(paths.memoriesDir) ? await loadMemoriesFromDir14(paths.memoriesDir) : [];
   const codeMap = await loadCodeMap7(paths);
   const codeFiles = codeMap ? Object.keys(codeMap.files) : [];
   let existingModules = [];
@@ -10309,7 +10417,7 @@ ${renderBootstrapChecklist(assessment)}`,
 async function buildEnforcementReport(dir, stage, sessionId) {
   const root = findProjectRoot37(dir);
   const paths = resolveHaivePaths35(root);
-  const initialized = existsSync40(paths.haiveDir);
+  const initialized = existsSync41(paths.haiveDir);
   const config = initialized ? await loadConfig12(paths) : {};
   if (initialized) {
     await applyLightweightRepairs(root, paths);
@@ -10343,7 +10451,7 @@ async function buildEnforcementReport(dir, stage, sessionId) {
       findings: [{ severity: "info", code: "enforcement-off", message: "Hivelore enforcement is disabled." }]
     });
   }
-  findings.push(...await inspectIntegrationVersions(root, "0.33.0"));
+  findings.push(...await inspectIntegrationVersions(root, "0.34.1"));
   if (config.enforcement?.requireBriefingFirst !== false && stage !== "ci") {
     const hasBriefing = await hasRecentBriefingMarker(paths, sessionId);
     findings.push(hasBriefing ? { severity: "ok", code: "briefing-loaded", message: "A recent Hivelore briefing marker exists." } : {
@@ -10446,8 +10554,8 @@ function withCategories(report) {
 async function hasRecentSessionRecap(paths) {
   const handoffAge = await handoffAgeMs(paths.root);
   if (handoffAge !== null && handoffAge < SESSION_RECAP_TTL_MS) return true;
-  if (!existsSync40(paths.memoriesDir)) return false;
-  const all = await loadMemoriesFromDir15(paths.memoriesDir);
+  if (!existsSync41(paths.memoriesDir)) return false;
+  const all = await loadMemoriesFromDir14(paths.memoriesDir);
   return all.some(({ memory: memory2 }) => {
     const fm = memory2.frontmatter;
     const freshnessDate = fm.verified_at ?? fm.created_at;
@@ -10455,8 +10563,8 @@ async function hasRecentSessionRecap(paths) {
   });
 }
 async function verifyMemoryPolicy(paths, config) {
-  if (!existsSync40(paths.memoriesDir)) return [];
-  const all = await loadMemoriesFromDir15(paths.memoriesDir);
+  if (!existsSync41(paths.memoriesDir)) return [];
+  const all = await loadMemoriesFromDir14(paths.memoriesDir);
   const findings = [];
   const staleImportant = [];
   let verified = 0;
@@ -10493,12 +10601,12 @@ async function verifyMemoryPolicy(paths, config) {
   return findings;
 }
 async function verifyDecisionCoverage(paths, stage, sessionId) {
-  if (!existsSync40(paths.memoriesDir)) return [];
+  if (!existsSync41(paths.memoriesDir)) return [];
   const changedFiles = (await getChangedFiles(paths.root, stage)).filter((f) => !isGeneratedArtifact(f));
   if (changedFiles.length === 0) {
     return [{ severity: "info", code: "decision-coverage-no-changes", message: "No changed files to match against policy memories." }];
   }
-  const all = await loadMemoriesFromDir15(paths.memoriesDir);
+  const all = await loadMemoriesFromDir14(paths.memoriesDir);
   const changedSet = new Set(changedFiles);
   const policyTypes = /* @__PURE__ */ new Set(["decision", "gotcha", "architecture", "convention"]);
   const relevant = all.filter(({ memory: memory2 }) => {
@@ -10527,7 +10635,7 @@ async function verifyDecisionCoverage(paths, stage, sessionId) {
   const consulted = new Set(marker?.memory_ids ?? []);
   const missing = relevant.filter(({ memory: memory2, filePath }) => {
     if (consulted.has(memory2.frontmatter.id)) return false;
-    if (changedSet.has(path38.relative(paths.root, filePath))) return false;
+    if (changedSet.has(path39.relative(paths.root, filePath))) return false;
     return true;
   }).map(({ memory: memory2 }) => memory2);
   if (missing.length === 0) {
@@ -10592,7 +10700,7 @@ async function runPrecommitPolicy(paths, gate, stage) {
     (w) => w.level === "review" && !w.reasons.includes("sensor")
   );
   const REVIEW_SEEN_TTL_MS = 24 * 60 * 60 * 1e3;
-  const reviewSeenFile = path38.join(paths.runtimeDir, "enforcement", "review-seen.json");
+  const reviewSeenFile = path39.join(paths.runtimeDir, "enforcement", "review-seen.json");
   let reviewSeen = {};
   try {
     reviewSeen = JSON.parse(await readFile18(reviewSeenFile, "utf8"));
@@ -10619,7 +10727,7 @@ async function runPrecommitPolicy(paths, gate, stage) {
       for (const [id, at] of Object.entries(reviewSeen)) {
         if (!Number.isFinite(Date.parse(at)) || now - Date.parse(at) >= REVIEW_SEEN_TTL_MS) delete reviewSeen[id];
       }
-      await mkdir16(path38.dirname(reviewSeenFile), { recursive: true });
+      await mkdir16(path39.dirname(reviewSeenFile), { recursive: true });
       await writeFile25(reviewSeenFile, JSON.stringify(reviewSeen, null, 2), "utf8");
     } catch {
     }
@@ -10651,9 +10759,9 @@ async function runPrecommitPolicy(paths, gate, stage) {
   ];
 }
 async function runSensorGate(paths, diff) {
-  if (!diff || !existsSync40(paths.memoriesDir)) return [];
+  if (!diff || !existsSync41(paths.memoriesDir)) return [];
   try {
-    const loaded = await loadMemoriesFromDir15(paths.memoriesDir);
+    const loaded = await loadMemoriesFromDir14(paths.memoriesDir);
     const scannable = loaded.map((l) => l.memory).filter((m) => Boolean(m.frontmatter.sensor) && !isRetiredMemory2(m.frontmatter, m.body));
     if (scannable.length === 0) return [];
     const targets = sensorTargetsFromDiff(diff).filter((t) => isSensorScannablePath(t.path));
@@ -10766,16 +10874,16 @@ async function cleanupRuntimeDir(runtimeDir) {
   for (const entry of entries) {
     if (entry.name === ".gitignore" || entry.name === "README.md") continue;
     if (entry.name === "enforcement") {
-      removed += await cleanupEnforcementDir(path38.join(runtimeDir, entry.name));
+      removed += await cleanupEnforcementDir(path39.join(runtimeDir, entry.name));
       continue;
     }
-    await rm2(path38.join(runtimeDir, entry.name), { recursive: true, force: true });
+    await rm2(path39.join(runtimeDir, entry.name), { recursive: true, force: true });
     removed++;
   }
-  await writeFile25(path38.join(runtimeDir, ".gitignore"), "*\n!.gitignore\n!README.md\n", "utf8");
-  if (!existsSync40(path38.join(runtimeDir, "README.md"))) {
+  await writeFile25(path39.join(runtimeDir, ".gitignore"), "*\n!.gitignore\n!README.md\n", "utf8");
+  if (!existsSync41(path39.join(runtimeDir, "README.md"))) {
     await writeFile25(
-      path38.join(runtimeDir, "README.md"),
+      path39.join(runtimeDir, "README.md"),
       "# .ai/.runtime \u2014 disposable local layer\n\nRuntime data is local. Hivelore cleanup preserves briefing markers so enforcement state remains valid.\n",
       "utf8"
     );
@@ -10788,10 +10896,10 @@ async function cleanupCacheDir(cacheDir) {
   const entries = await readdir4(cacheDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.name === ".gitignore") continue;
-    await rm2(path38.join(cacheDir, entry.name), { recursive: true, force: true });
+    await rm2(path39.join(cacheDir, entry.name), { recursive: true, force: true });
     removed++;
   }
-  await writeFile25(path38.join(cacheDir, ".gitignore"), "*\n!.gitignore\n", "utf8");
+  await writeFile25(path39.join(cacheDir, ".gitignore"), "*\n!.gitignore\n", "utf8");
   return removed;
 }
 async function cleanupEnforcementDir(enforcementDir) {
@@ -10799,7 +10907,7 @@ async function cleanupEnforcementDir(enforcementDir) {
   const entries = await readdir4(enforcementDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.name === "briefings") continue;
-    await rm2(path38.join(enforcementDir, entry.name), { recursive: true, force: true });
+    await rm2(path39.join(enforcementDir, entry.name), { recursive: true, force: true });
     removed++;
   }
   return removed;
@@ -10817,8 +10925,8 @@ async function inspectIntegrationVersions(root, expectedVersion) {
   const missingBins = /* @__PURE__ */ new Map();
   const staleBins = /* @__PURE__ */ new Map();
   for (const rel of files) {
-    const file = path38.join(root, rel);
-    if (!existsSync40(file)) continue;
+    const file = path39.join(root, rel);
+    if (!existsSync41(file)) continue;
     const text = await readFile18(file, "utf8").catch(() => "");
     for (const bin of extractAbsoluteHaiveBins2(text)) {
       const version = versionForBinary2(bin);
@@ -10935,7 +11043,7 @@ async function resolveCiDiffRange(root) {
 }
 async function resolveGithubEventRange(root) {
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !existsSync40(eventPath)) return null;
+  if (!eventPath || !existsSync41(eventPath)) return null;
   try {
     const event = JSON.parse(await readFile18(eventPath, "utf8"));
     const prBase = cleanGitSha(event.pull_request?.base?.sha);
@@ -11040,7 +11148,7 @@ function isShippablePath(file) {
 }
 var CI_SKIP_DIRECTIVE = /\[skip ci\]|\[ci skip\]|\[no ci\]|\[skip actions\]|\*\*\*NO_CI\*\*\*|skip-checks: *true/i;
 async function checkCommitMessageSkipCi(root, msgfile) {
-  const file = path38.isAbsolute(msgfile) ? msgfile : path38.join(root, msgfile);
+  const file = path39.isAbsolute(msgfile) ? msgfile : path39.join(root, msgfile);
   const raw = await readFile18(file, "utf8").catch(() => "");
   const cleaned = raw.split("\n").filter((line) => !line.startsWith("#")).join("\n");
   if (!CI_SKIP_DIRECTIVE.test(cleaned)) return { block: false, message: "" };
@@ -11069,7 +11177,7 @@ async function inspectReleaseVersionState(root, upstream) {
 }
 async function readPackageVersion(root, relPath) {
   try {
-    const data = JSON.parse(await readFile18(path38.join(root, relPath), "utf8"));
+    const data = JSON.parse(await readFile18(path39.join(root, relPath), "utf8"));
     return typeof data.version === "string" ? data.version : void 0;
   } catch {
     return void 0;
@@ -11257,8 +11365,8 @@ function buildScore(findings, threshold = 80) {
   };
 }
 async function installGitEnforcement(root) {
-  const hooksDir = path38.join(root, ".git", "hooks");
-  if (!existsSync40(path38.join(root, ".git"))) {
+  const hooksDir = path39.join(root, ".git", "hooks");
+  if (!existsSync41(path39.join(root, ".git"))) {
     ui.warn("No .git directory found; git enforcement hooks skipped.");
     return;
   }
@@ -11314,8 +11422,8 @@ _hivelore sync --quiet --since ORIG_HEAD || true
     }
   ];
   for (const hook of hooks) {
-    const file = path38.join(hooksDir, hook.name);
-    if (existsSync40(file)) {
+    const file = path39.join(hooksDir, hook.name);
+    if (existsSync41(file)) {
       const current = await readFile18(file, "utf8").catch(() => "");
       if (current.includes(ENFORCE_HOOK_MARKER)) {
         await writeFile25(file, hook.body, "utf8");
@@ -11332,9 +11440,9 @@ ${hook.body}`, "utf8");
   ui.success("Installed git hooks: pre-commit, pre-push, commit-msg (blocking) + post-merge, post-rewrite (sync)");
 }
 async function installCiEnforcement(root) {
-  const workflowPath = path38.join(root, ".github", "workflows", "haive-enforcement.yml");
-  await mkdir16(path38.dirname(workflowPath), { recursive: true });
-  if (existsSync40(workflowPath)) {
+  const workflowPath = path39.join(root, ".github", "workflows", "haive-enforcement.yml");
+  await mkdir16(path39.dirname(workflowPath), { recursive: true });
+  if (existsSync41(workflowPath)) {
     ui.info("GitHub Actions enforcement workflow already exists \u2014 skipped");
     return;
   }
@@ -11365,7 +11473,7 @@ jobs:
           HAIVE_HEAD_SHA: \${{ github.event.pull_request.head.sha || github.sha }}
         run: hivelore enforce ci
 `, "utf8");
-  ui.success(`Created ${path38.relative(root, workflowPath)}`);
+  ui.success(`Created ${path39.relative(root, workflowPath)}`);
 }
 function printReport(report, json, explain = false) {
   if (json) {
@@ -11469,15 +11577,15 @@ function extractToolPaths(payload, root) {
 }
 function normalizeToolPath(file, root) {
   const normalized = file.replace(/\\/g, "/");
-  if (!path38.isAbsolute(normalized)) return normalized.replace(/^\.\//, "");
-  return path38.relative(root, normalized).replace(/\\/g, "/");
+  if (!path39.isAbsolute(normalized)) return normalized.replace(/^\.\//, "");
+  return path39.relative(root, normalized).replace(/\\/g, "/");
 }
 async function missingRequiredMemoriesForFiles(paths, files, sessionId) {
-  if (!existsSync40(paths.memoriesDir)) return [];
+  if (!existsSync41(paths.memoriesDir)) return [];
   const marker = await readRecentBriefingMarker(paths, sessionId);
   const consulted = new Set(marker?.memory_ids ?? []);
   const policyTypes = /* @__PURE__ */ new Set(["decision", "gotcha", "architecture", "convention", "attempt"]);
-  const all = await loadMemoriesFromDir15(paths.memoriesDir);
+  const all = await loadMemoriesFromDir14(paths.memoriesDir);
   return all.filter(({ memory: memory2 }) => {
     const fm = memory2.frontmatter;
     if (!policyTypes.has(fm.type)) return false;
@@ -11518,7 +11626,7 @@ async function readStdin2(maxBytes) {
 }
 var ATOMIC_STAGE_EXCLUDE = ["/.usage/", "/.runtime/", "/.cache/"];
 async function stageResyncedArtifacts(root, paths) {
-  const aiRel = path38.relative(root, paths.haiveDir);
+  const aiRel = path39.relative(root, paths.haiveDir);
   const out = await runCommand2("git", ["diff", "--name-only", "--", aiRel], root).catch(() => "");
   const toStage = out.split("\n").map((line) => line.trim()).filter(Boolean).filter((file) => !ATOMIC_STAGE_EXCLUDE.some((excl) => `/${file}`.includes(excl)));
   if (toStage.length === 0) return;
@@ -11545,9 +11653,9 @@ function runCommand2(cmd, args, cwd) {
 }
 
 // src/commands/release.ts
-import { existsSync as existsSync41 } from "fs";
+import { existsSync as existsSync42 } from "fs";
 import { readFile as readFile19, writeFile as writeFile26 } from "fs/promises";
-import path39 from "path";
+import path40 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot38 } from "@hivelore/core";
 import { execFile as execFile5 } from "child_process";
@@ -11561,7 +11669,7 @@ var VERSION_FILES2 = [
   "packages/embeddings/package.json"
 ];
 async function readCurrentVersion(root) {
-  const pkg = JSON.parse(await readFile19(path39.join(root, "package.json"), "utf8"));
+  const pkg = JSON.parse(await readFile19(path40.join(root, "package.json"), "utf8"));
   if (!pkg.version) throw new Error("Root package.json has no version field.");
   return pkg.version;
 }
@@ -11582,8 +11690,8 @@ function registerRelease(program2) {
     const current = await readCurrentVersion(root);
     const next = nextVersion(current, spec);
     for (const rel of VERSION_FILES2) {
-      const file = path39.join(root, rel);
-      if (!existsSync41(file)) {
+      const file = path40.join(root, rel);
+      if (!existsSync42(file)) {
         ui.warn(`skip ${rel} (missing)`);
         continue;
       }
@@ -11596,8 +11704,8 @@ function registerRelease(program2) {
       }
       await writeFile26(file, updated, "utf8");
     }
-    const changelog = path39.join(root, "CHANGELOG.md");
-    if (existsSync41(changelog)) {
+    const changelog = path40.join(root, "CHANGELOG.md");
+    if (existsSync42(changelog)) {
       const raw = await readFile19(changelog, "utf8");
       const heading = `## [${next}]${opts.title ? ` \u2014 ${opts.title}` : ""}`;
       if (!raw.includes(`## [${next}]`)) {
@@ -11620,8 +11728,8 @@ ${heading}
     const root = findProjectRoot38(opts.dir);
     const version = await readCurrentVersion(root);
     for (const rel of VERSION_FILES2.slice(1)) {
-      const file = path39.join(root, rel);
-      if (!existsSync41(file)) continue;
+      const file = path40.join(root, rel);
+      if (!existsSync42(file)) continue;
       const v = JSON.parse(await readFile19(file, "utf8")).version;
       if (v !== version) {
         ui.error(`${rel} is at ${v}, root at ${version} \u2014 lockstep broken; run \`hivelore release bump\` first.`);
@@ -11667,9 +11775,9 @@ function registerRun(program2) {
 
 // src/commands/sensors.ts
 import { execFile as execFile6 } from "child_process";
-import { existsSync as existsSync42 } from "fs";
+import { existsSync as existsSync43 } from "fs";
 import { chmod as chmod2, mkdir as mkdir17, readFile as readFile20, writeFile as writeFile27 } from "fs/promises";
-import path40 from "path";
+import path41 from "path";
 import { promisify as promisify6 } from "util";
 import "commander";
 import {
@@ -11678,7 +11786,7 @@ import {
   isRetiredMemory as isRetiredMemory3,
   judgeProposedSensor,
   loadConfig as loadConfig13,
-  loadMemoriesFromDir as loadMemoriesFromDir16,
+  loadMemoriesFromDir as loadMemoriesFromDir15,
   recordPreventionHits as recordPreventionHits2,
   resolveHaivePaths as resolveHaivePaths36,
   runSensors as runSensors2,
@@ -11724,7 +11832,7 @@ function registerSensors(program2) {
     const root = findProjectRoot39(opts.dir);
     const paths = resolveHaivePaths36(root);
     const memories = await runnableSensorMemories(paths);
-    const diff = opts.diffFile ? await readFile20(path40.resolve(root, opts.diffFile), "utf8") : await stagedDiff(root);
+    const diff = opts.diffFile ? await readFile20(path41.resolve(root, opts.diffFile), "utf8") : await stagedDiff(root);
     const targets = scannableSensorTargets(diff);
     const hits = runSensors2(memories, targets);
     const config = await loadConfig13(paths);
@@ -11812,7 +11920,7 @@ function registerSensors(program2) {
     }
     const root = findProjectRoot39(opts.dir);
     const paths = resolveHaivePaths36(root);
-    const loaded = existsSync42(paths.memoriesDir) ? await loadMemoriesFromDir16(paths.memoriesDir) : [];
+    const loaded = existsSync43(paths.memoriesDir) ? await loadMemoriesFromDir15(paths.memoriesDir) : [];
     const found = loaded.find(({ memory: memory2 }) => memory2.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory found with id ${id}`);
@@ -11877,7 +11985,7 @@ function registerSensors(program2) {
         return;
       }
       const root2 = findProjectRoot39(opts.dir);
-      const { proposeSensor } = await import("./server-LZKYO5O5.js");
+      const { proposeSensor } = await import("./server-FQ5C43MV.js");
       const out = await proposeSensor(
         {
           memory_id: id,
@@ -11920,7 +12028,7 @@ function registerSensors(program2) {
     }
     const root = findProjectRoot39(opts.dir);
     const paths = resolveHaivePaths36(root);
-    const loaded = existsSync42(paths.memoriesDir) ? await loadMemoriesFromDir16(paths.memoriesDir) : [];
+    const loaded = existsSync43(paths.memoriesDir) ? await loadMemoriesFromDir15(paths.memoriesDir) : [];
     const found = loaded.find(({ memory: memory2 }) => memory2.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory found with id ${id}`);
@@ -11974,13 +12082,13 @@ function registerSensors(program2) {
     const root = findProjectRoot39(opts.dir);
     const paths = resolveHaivePaths36(root);
     const rows = await sensorRows(paths);
-    const outDir = path40.resolve(root, opts.outDir ?? ".ai/generated");
+    const outDir = path41.resolve(root, opts.outDir ?? ".ai/generated");
     await mkdir17(outDir, { recursive: true });
-    const outPath = path40.join(outDir, format === "grep" ? "haive-sensors-grep.sh" : "haive-sensors-eslint.json");
+    const outPath = path41.join(outDir, format === "grep" ? "haive-sensors-grep.sh" : "haive-sensors-eslint.json");
     const content = format === "grep" ? renderGrepScript(rows) : JSON.stringify({ sensors: rows }, null, 2) + "\n";
     await writeFile27(outPath, content, "utf8");
     if (format === "grep") await chmod2(outPath, 493);
-    ui.success(`Exported ${rows.length} sensor(s): ${path40.relative(root, outPath)}`);
+    ui.success(`Exported ${rows.length} sensor(s): ${path41.relative(root, outPath)}`);
   });
 }
 function deriveProposedMessage(body, pattern, absent) {
@@ -12013,8 +12121,8 @@ async function sensorRows(paths) {
   });
 }
 async function runnableSensorMemories(paths, regexOnly = true) {
-  if (!existsSync42(paths.memoriesDir)) return [];
-  const loaded = await loadMemoriesFromDir16(paths.memoriesDir);
+  if (!existsSync43(paths.memoriesDir)) return [];
+  const loaded = await loadMemoriesFromDir15(paths.memoriesDir);
   return loaded.map(({ memory: memory2 }) => memory2).filter((memory2) => {
     const sensor = memory2.frontmatter.sensor;
     if (!sensor) return false;
@@ -12055,15 +12163,15 @@ function shellQuote(value) {
 }
 
 // src/commands/ingest.ts
-import { existsSync as existsSync43 } from "fs";
+import { existsSync as existsSync44 } from "fs";
 import { mkdir as mkdir18, readFile as readFile21, writeFile as writeFile28 } from "fs/promises";
-import path41 from "path";
+import path42 from "path";
 import "commander";
 import {
   draftsFromFindings,
   filterNewDrafts,
   findProjectRoot as findProjectRoot40,
-  loadMemoriesFromDir as loadMemoriesFromDir17,
+  loadMemoriesFromDir as loadMemoriesFromDir16,
   memoryFilePath as memoryFilePath7,
   parseFindings,
   resolveHaivePaths as resolveHaivePaths37,
@@ -12093,7 +12201,7 @@ function registerIngest(program2) {
     }
     const root = findProjectRoot40(opts.dir);
     const paths = resolveHaivePaths37(root);
-    if (!existsSync43(paths.haiveDir)) {
+    if (!existsSync44(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -12114,8 +12222,8 @@ function registerIngest(program2) {
         process.exitCode = 1;
         return;
       }
-      const reportPath = path41.resolve(root, file);
-      if (!existsSync43(reportPath)) {
+      const reportPath = path42.resolve(root, file);
+      if (!existsSync44(reportPath)) {
         ui.error(`Report file not found: ${reportPath}`);
         process.exitCode = 1;
         return;
@@ -12147,7 +12255,7 @@ function registerIngest(program2) {
       process.exitCode = 1;
       return;
     }
-    const existing = existsSync43(paths.memoriesDir) ? await loadMemoriesFromDir17(paths.memoriesDir) : [];
+    const existing = existsSync44(paths.memoriesDir) ? await loadMemoriesFromDir16(paths.memoriesDir) : [];
     const existingTopics = new Set(
       existing.map(({ memory: memory2 }) => memory2.frontmatter.topic).filter((t) => Boolean(t))
     );
@@ -12209,13 +12317,13 @@ function registerIngest(program2) {
       await writeDraft(paths, draft);
       created++;
     }
-    ui.success(`Created ${created} proposed memory(ies) under ${path41.relative(root, paths.memoriesDir)}/`);
+    ui.success(`Created ${created} proposed memory(ies) under ${path42.relative(root, paths.memoriesDir)}/`);
     ui.info("Review with `hivelore memory pending`; promote sensors with `hivelore sensors promote <id> --yes`.");
   });
 }
 async function writeDraft(paths, draft) {
   const file = memoryFilePath7(paths, draft.frontmatter.scope, draft.frontmatter.id, draft.frontmatter.module);
-  await mkdir18(path41.dirname(file), { recursive: true });
+  await mkdir18(path42.dirname(file), { recursive: true });
   await writeFile28(file, serializeMemory16({ frontmatter: draft.frontmatter, body: draft.body }), "utf8");
   return file;
 }
@@ -12257,13 +12365,13 @@ async function fetchSonarIssues(opts) {
 }
 
 // src/commands/dashboard.ts
-import { existsSync as existsSync44 } from "fs";
+import { existsSync as existsSync45 } from "fs";
 import "commander";
 import {
   buildDashboard,
   findProjectRoot as findProjectRoot41,
   loadConfig as loadConfig14,
-  loadMemoriesFromDir as loadMemoriesFromDir18,
+  loadMemoriesFromDir as loadMemoriesFromDir17,
   loadPreventionEvents as loadPreventionEvents3,
   loadUsageIndex as loadUsageIndex16,
   resolveHaivePaths as resolveHaivePaths38
@@ -12274,12 +12382,12 @@ function registerDashboard(program2) {
   ).option("--json", "emit the full report as JSON", false).option("--top <n>", "rows per top-list", "10").option("--dormant-days <n>", "dormancy window for impact scoring").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot41(opts.dir);
     const paths = resolveHaivePaths38(root);
-    if (!existsSync44(paths.haiveDir)) {
+    if (!existsSync45(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const memories = existsSync44(paths.memoriesDir) ? await loadMemoriesFromDir18(paths.memoriesDir) : [];
+    const memories = existsSync45(paths.memoriesDir) ? await loadMemoriesFromDir17(paths.memoriesDir) : [];
     const usage = await loadUsageIndex16(paths);
     const preventionEvents = await loadPreventionEvents3(paths);
     const config = await loadConfig14(paths);
@@ -12405,8 +12513,8 @@ function warnNum(n) {
 // src/commands/dev-link.ts
 import { execFile as execFile7 } from "child_process";
 import { cp, readFile as readFile22 } from "fs/promises";
-import { existsSync as existsSync45 } from "fs";
-import path42 from "path";
+import { existsSync as existsSync46 } from "fs";
+import path43 from "path";
 import { promisify as promisify7 } from "util";
 import "commander";
 import { findProjectRoot as findProjectRoot42 } from "@hivelore/core";
@@ -12415,7 +12523,7 @@ function registerDevLink(program2) {
   const dev = program2.commands.find((c) => c.name() === "dev") ?? program2.command("dev").description("Developer utilities for working on Hivelore itself.");
   dev.command("link").description("Hot-swap this repo's built dist into the global @hivelore (or legacy @hiveai) install so the global binary runs your local code.").option("-d, --dir <dir>", "repo root (default: discovered from cwd)").option("--json", "emit a machine-readable summary", false).action(async (opts) => {
     const root = findProjectRoot42(opts.dir);
-    if (!existsSync45(path42.join(root, "packages", "cli", "dist", "index.js"))) {
+    if (!existsSync46(path43.join(root, "packages", "cli", "dist", "index.js"))) {
       ui.error(`Not the Hivelore monorepo (no packages/cli/dist) at ${root}. Run \`pnpm -r build\` first, or pass --dir.`);
       process.exitCode = 1;
       return;
@@ -12424,9 +12532,9 @@ function registerDevLink(program2) {
     try {
       globalModules = (await exec5("npm", ["root", "-g"])).stdout.trim();
     } catch {
-      globalModules = path42.join(path42.dirname(path42.dirname(process.execPath)), "lib", "node_modules");
+      globalModules = path43.join(path43.dirname(path43.dirname(process.execPath)), "lib", "node_modules");
     }
-    const scopeDirs = ["@hivelore", "@hiveai"].map((scope) => path42.join(globalModules, scope)).filter((dir) => existsSync45(dir));
+    const scopeDirs = ["@hivelore", "@hiveai"].map((scope) => path43.join(globalModules, scope)).filter((dir) => existsSync46(dir));
     if (scopeDirs.length === 0) {
       ui.error(`No global @hivelore (or legacy @hiveai) install under ${globalModules}. Install once with \`npm i -g @hivelore/cli\`, then re-run.`);
       process.exitCode = 1;
@@ -12434,24 +12542,24 @@ function registerDevLink(program2) {
     }
     const linked = [];
     const copyDist = async (fromPkg, toDistDir) => {
-      const from = path42.join(root, "packages", fromPkg, "dist");
-      if (!existsSync45(from) || !existsSync45(path42.dirname(toDistDir))) return;
+      const from = path43.join(root, "packages", fromPkg, "dist");
+      if (!existsSync46(from) || !existsSync46(path43.dirname(toDistDir))) return;
       await cp(from, toDistDir, { recursive: true });
-      linked.push(path42.relative(globalModules, toDistDir));
+      linked.push(path43.relative(globalModules, toDistDir));
     };
     for (const globalHive of scopeDirs) {
-      const nestedScope = path42.basename(globalHive);
+      const nestedScope = path43.basename(globalHive);
       for (const pkg of ["cli", "mcp"]) {
-        await copyDist(pkg, path42.join(globalHive, pkg, "dist"));
+        await copyDist(pkg, path43.join(globalHive, pkg, "dist"));
         for (const nested of ["core", "embeddings"]) {
-          await copyDist(nested, path42.join(globalHive, pkg, "node_modules", nestedScope, nested, "dist"));
+          await copyDist(nested, path43.join(globalHive, pkg, "node_modules", nestedScope, nested, "dist"));
         }
       }
-      await copyDist("core", path42.join(globalHive, "core", "dist"));
+      await copyDist("core", path43.join(globalHive, "core", "dist"));
     }
     let version = "unknown";
     try {
-      version = JSON.parse(await readFile22(path42.join(root, "package.json"), "utf8")).version ?? "unknown";
+      version = JSON.parse(await readFile22(path43.join(root, "package.json"), "utf8")).version ?? "unknown";
     } catch {
     }
     if (opts.json) {
@@ -12462,7 +12570,7 @@ function registerDevLink(program2) {
       ui.warn("Nothing linked \u2014 no matching dist targets were found in the global install.");
       return;
     }
-    ui.success(`Linked local dist (v${version}) into the global install(s): ${scopeDirs.map((d) => path42.basename(d)).join(", ")}`);
+    ui.success(`Linked local dist (v${version}) into the global install(s): ${scopeDirs.map((d) => path43.basename(d)).join(", ")}`);
     for (const t of linked) console.log(`  ${ui.dim("\u2192")} ${t}`);
     console.log(ui.dim("The global binary now runs your local build (git hooks + MCP included)."));
   });
@@ -12470,8 +12578,8 @@ function registerDevLink(program2) {
 
 // src/commands/coverage.ts
 import { readFile as readFile23 } from "fs/promises";
-import { existsSync as existsSync46 } from "fs";
-import path43 from "path";
+import { existsSync as existsSync47 } from "fs";
+import path44 from "path";
 import "commander";
 import {
   findCoverageGaps,
@@ -12481,7 +12589,7 @@ import {
   tallyHotFiles
 } from "@hivelore/core";
 async function readAgentHotFiles(root, cacheFile, sinceMs) {
-  if (!existsSync46(cacheFile)) return [];
+  if (!existsSync47(cacheFile)) return [];
   const raw = await readFile23(cacheFile, "utf8").catch(() => "");
   const files = [];
   for (const line of raw.split("\n")) {
@@ -12495,7 +12603,7 @@ async function readAgentHotFiles(root, cacheFile, sinceMs) {
       }
       for (const f of obs.files ?? []) {
         if (typeof f !== "string" || !f) continue;
-        const rel = path43.isAbsolute(f) ? path43.relative(root, f) : f;
+        const rel = path44.isAbsolute(f) ? path44.relative(root, f) : f;
         if (rel.startsWith("..")) continue;
         files.push(rel);
       }
@@ -12539,7 +12647,7 @@ function registerCoverage(program2) {
     }) : null;
     const gitHotFiles = (radar?.hotFiles ?? []).filter((h) => !isNoisePath(h.path)).map((h) => ({ path: h.path, changes: h.changes, source: "git" }));
     const sinceMs = Date.now() - days * 864e5;
-    const agentHotFiles = useAgent ? (await readAgentHotFiles(root, path43.join(paths.haiveDir, ".cache", "observations.jsonl"), sinceMs)).filter((h) => !isNoisePath(h.path)) : [];
+    const agentHotFiles = useAgent ? (await readAgentHotFiles(root, path44.join(paths.haiveDir, ".cache", "observations.jsonl"), sinceMs)).filter((h) => !isNoisePath(h.path)) : [];
     const hotFiles = mergeHotFiles(gitHotFiles, agentHotFiles);
     const memories = await loadMemoriesFromDir(paths.memoriesDir);
     const gaps = findCoverageGaps(hotFiles, memories, { minChanges, limit });
@@ -12577,8 +12685,8 @@ function registerCoverage(program2) {
 
 // src/commands/merge-driver.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { readFileSync, writeFileSync, existsSync as existsSync47 } from "fs";
-import path44 from "path";
+import { readFileSync, writeFileSync, existsSync as existsSync48 } from "fs";
+import path45 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot44, mergeMemoryVersions } from "@hivelore/core";
 var GITATTRIBUTES_MARK = "# Hivelore merge driver";
@@ -12610,8 +12718,8 @@ function registerMergeDriver(program2) {
       process.exitCode = 1;
       return;
     }
-    const gaPath = path44.join(root, ".gitattributes");
-    let content = existsSync47(gaPath) ? readFileSync(gaPath, "utf8") : "";
+    const gaPath = path45.join(root, ".gitattributes");
+    let content = existsSync48(gaPath) ? readFileSync(gaPath, "utf8") : "";
     if (!content.includes(GITATTRIBUTES_MARK)) {
       if (content.length > 0 && !content.endsWith("\n")) content += "\n";
       content += GITATTRIBUTES_BLOCK + "\n";
@@ -12625,21 +12733,21 @@ function registerMergeDriver(program2) {
 }
 
 // src/commands/bridges.ts
-import { existsSync as existsSync48 } from "fs";
-import path45 from "path";
+import { existsSync as existsSync49 } from "fs";
+import path46 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot45,
   resolveHaivePaths as resolveHaivePaths40,
-  BRIDGE_TARGET_PATH as BRIDGE_TARGET_PATH2,
-  BRIDGE_TARGETS as BRIDGE_TARGETS3
+  BRIDGE_TARGET_PATH as BRIDGE_TARGET_PATH3,
+  BRIDGE_TARGETS as BRIDGE_TARGETS4
 } from "@hivelore/core";
 function registerBridges(program2) {
   const bridges = program2.command("bridges").description(
     "Generate native agent bridge files from the Hivelore corpus.\n  Bridges inject top validated memories and block sensors into agent-harness-specific\n  config files (.cursor/rules/haive-memories.mdc, .clinerules, .windsurfrules,\n  .continuerules, .sourcegraph/cody-rules.md, .rules, AGENTS.md,\n  .github/copilot-instructions.md).\n  This is the reach differentiator vs memories.sh: our bridges carry enforcement, not just injection.\n\n  Example:\n    hivelore bridges sync --all\n    hivelore bridges sync --only cline,windsurf\n"
   );
   bridges.command("sync").description(
-    "Regenerate bridge files idempotently (marker-based, preserves manual content outside markers).\n  Supported targets: " + BRIDGE_TARGETS3.join(", ") + "\n"
+    "Regenerate bridge files idempotently (marker-based, preserves manual content outside markers).\n  Supported targets: " + BRIDGE_TARGETS4.join(", ") + "\n"
   ).option("--all", "generate all supported bridge targets").option(
     "--only <targets>",
     "comma-separated list of targets to generate (e.g. cline,windsurf,agents)"
@@ -12647,7 +12755,7 @@ function registerBridges(program2) {
     const root = findProjectRoot45(opts.dir);
     const paths = resolveHaivePaths40(root);
     const dryRun = opts.dryRun === true;
-    if (!existsSync48(paths.memoriesDir)) {
+    if (!existsSync49(paths.memoriesDir)) {
       ui.warn(`No .ai/memories at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -12655,18 +12763,18 @@ function registerBridges(program2) {
     let targets;
     if (opts.only) {
       const requested = opts.only.split(",").map((t) => t.trim().toLowerCase()).filter(Boolean);
-      const invalid = requested.filter((t) => !BRIDGE_TARGETS3.includes(t));
+      const invalid = requested.filter((t) => !BRIDGE_TARGETS4.includes(t));
       if (invalid.length > 0) {
-        ui.error(`Unknown bridge target(s): ${invalid.join(", ")}. Valid: ${BRIDGE_TARGETS3.join(", ")}`);
+        ui.error(`Unknown bridge target(s): ${invalid.join(", ")}. Valid: ${BRIDGE_TARGETS4.join(", ")}`);
         process.exitCode = 1;
         return;
       }
       targets = requested;
     } else if (opts.all) {
-      targets = BRIDGE_TARGETS3;
+      targets = BRIDGE_TARGETS4;
     } else {
-      targets = BRIDGE_TARGETS3.filter(
-        (t) => existsSync48(path45.join(root, BRIDGE_TARGET_PATH2[t]))
+      targets = BRIDGE_TARGETS4.filter(
+        (t) => existsSync49(path46.join(root, BRIDGE_TARGET_PATH3[t]))
       );
       if (targets.length === 0) {
         ui.info(
@@ -12698,7 +12806,7 @@ function registerBridges(program2) {
     const root = findProjectRoot45(opts.dir);
     const paths = resolveHaivePaths40(root);
     const statuses = await getBridgeFileStatuses(root, paths, {
-      targets: BRIDGE_TARGETS3,
+      targets: BRIDGE_TARGETS4,
       maxMemories: Math.max(1, Number(opts.maxMemories ?? 8))
     });
     console.log(ui.bold("Hivelore bridge targets:"));
@@ -12714,7 +12822,7 @@ function registerBridges(program2) {
 
 // src/index.ts
 var program = new Command48();
-program.name("hivelore").description("Hivelore - repo-native memory and context policy for coding-agent harnesses").version("0.33.0").option("--advanced", "show maintenance and experimental commands in help").showSuggestionAfterError(true);
+program.name("hivelore").description("Hivelore - repo-native memory and context policy for coding-agent harnesses").version("0.34.1").option("--advanced", "show maintenance and experimental commands in help").showSuggestionAfterError(true);
 registerInit(program);
 registerResolveProject(program);
 registerEnforce(program);