@hiveai/cli 0.18.0 → 0.19.0

package/dist/index.js

@@ -1378,14 +1378,15 @@ async function reportIndexStatus(root, paths, asJson) {
 
 // src/commands/init.ts
 import { execFile as execFile2 } from "child_process";
-import { mkdir as mkdir5, readFile as readFile5, readdir as readdir2, writeFile as writeFile6 } from "fs/promises";
-import { existsSync as existsSync10 } from "fs";
-import path10 from "path";
+import { mkdir as mkdir6, readFile as readFile6, readdir as readdir2, writeFile as writeFile7 } from "fs/promises";
+import { existsSync as existsSync11 } from "fs";
+import path11 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,
   buildCodeMap as buildCodeMap3,
   buildFrontmatter as buildFrontmatter2,
   detectStacksFromManifests,
@@ -1397,20 +1398,101 @@ import {
   serializeMemory as serializeMemory3
 } from "@hiveai/core";
 
+// 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 path6 from "path";
+import {
+  BRIDGE_MARKERS,
+  generateBridges,
+  isRetiredMemory,
+  loadMemoriesFromDir as loadMemoriesFromDir4
+} from "@hiveai/core";
+async function writeBridgeFiles(root, paths, opts) {
+  const result = { created: [], updated: [], unchanged: [] };
+  if (!existsSync6(paths.memoriesDir)) return result;
+  const allLoaded = await loadMemoriesFromDir4(paths.memoriesDir);
+  const memories = allLoaded.map((l) => l.memory).filter((m) => !isRetiredMemory(m.frontmatter, m.body));
+  const sensors = [];
+  for (const m of memories) {
+    const sensor = m.frontmatter.sensor;
+    if (!sensor || sensor.severity !== "block") continue;
+    sensors.push({
+      id: m.frontmatter.id,
+      severity: "block",
+      message: sensor.message,
+      ...sensor.pattern ? { pattern: sensor.pattern } : {},
+      paths: sensor.paths.length > 0 ? sensor.paths : m.frontmatter.anchor.paths
+    });
+  }
+  const maxMemories = Math.max(1, opts.maxMemories ?? 8);
+  const outputs = generateBridges(memories, sensors, { maxMemories, targets: opts.targets });
+  for (const output of outputs) {
+    const targetFile = path6.join(root, output.path);
+    const fileExists = existsSync6(targetFile);
+    if (opts.onlyExisting && !fileExists) continue;
+    if (opts.dryRun) {
+      (fileExists ? result.updated : result.created).push(output.path);
+      continue;
+    }
+    await mkdir2(path6.dirname(targetFile), { recursive: true });
+    if (!fileExists) {
+      await writeFile3(targetFile, output.content, "utf8");
+      result.created.push(output.path);
+      continue;
+    }
+    let existing = (await readFile3(targetFile, "utf8")).replace(/\r\n/g, "\n");
+    const withMemories = replaceMarkerBlock(
+      existing,
+      BRIDGE_MARKERS.memoriesStart,
+      BRIDGE_MARKERS.memoriesEnd,
+      extractMarkerBlock(output.content, BRIDGE_MARKERS.memoriesStart, BRIDGE_MARKERS.memoriesEnd)
+    );
+    const sensorsBlockContent = extractMarkerBlock(
+      output.content,
+      BRIDGE_MARKERS.sensorsStart,
+      BRIDGE_MARKERS.sensorsEnd
+    );
+    const withSensors = sensorsBlockContent ? replaceMarkerBlock(withMemories, BRIDGE_MARKERS.sensorsStart, BRIDGE_MARKERS.sensorsEnd, sensorsBlockContent) : withMemories;
+    if (withSensors === existing) {
+      result.unchanged.push(output.path);
+      continue;
+    }
+    await writeFile3(targetFile, withSensors, "utf8");
+    result.updated.push(output.path);
+  }
+  return result;
+}
+function extractMarkerBlock(text, startMarker, endMarker) {
+  const startIdx = text.indexOf(startMarker);
+  const endIdx = text.indexOf(endMarker);
+  if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) return null;
+  return text.slice(startIdx, endIdx + endMarker.length);
+}
+function replaceMarkerBlock(existing, startMarker, endMarker, replacement) {
+  if (!replacement) return existing;
+  const startIdx = existing.indexOf(startMarker);
+  const endIdx = existing.indexOf(endMarker);
+  if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) {
+    return existing + (existing.endsWith("\n") ? "" : "\n") + "\n" + replacement + "\n";
+  }
+  return existing.slice(0, startIdx) + replacement + existing.slice(endIdx + endMarker.length);
+}
+
 // src/commands/agent.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync7 } from "fs";
-import { mkdir as mkdir3, writeFile as writeFile4 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
+import { mkdir as mkdir4, writeFile as writeFile5 } from "fs/promises";
 import os2 from "os";
-import path7 from "path";
+import path8 from "path";
 import { createInterface } from "readline/promises";
 import "commander";
 import { findProjectRoot as findProjectRoot6, resolveHaivePaths as resolveHaivePaths5 } from "@hiveai/core";
 
 // src/commands/init-mcp-setup.ts
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import path6 from "path";
+import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir3 } from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
+import path7 from "path";
 import os from "os";
 var HOME = os.homedir();
 var HAIVE_MCP_ENTRY = {
@@ -1425,38 +1507,38 @@ function projectMcpEntry(root) {
   };
 }
 function cursorMcpPath() {
-  return path6.join(HOME, ".cursor", "mcp.json");
+  return path7.join(HOME, ".cursor", "mcp.json");
 }
 async function configureCursor() {
   const mcpPath = cursorMcpPath();
-  const cursorDir = path6.join(HOME, ".cursor");
-  if (!existsSync6(cursorDir)) return { client: "Cursor", status: "not_installed" };
+  const cursorDir = path7.join(HOME, ".cursor");
+  if (!existsSync7(cursorDir)) return { client: "Cursor", status: "not_installed" };
   let config = {};
-  if (existsSync6(mcpPath)) {
+  if (existsSync7(mcpPath)) {
     try {
-      config = JSON.parse(await readFile3(mcpPath, "utf8"));
+      config = JSON.parse(await readFile4(mcpPath, "utf8"));
     } catch {
     }
   }
   config.mcpServers ??= {};
   if (config.mcpServers["haive"]) return { client: "Cursor", status: "already_configured" };
   config.mcpServers["haive"] = HAIVE_MCP_ENTRY;
-  await mkdir2(cursorDir, { recursive: true });
-  await writeFile3(mcpPath, JSON.stringify(config, null, 2), "utf8");
+  await mkdir3(cursorDir, { recursive: true });
+  await writeFile4(mcpPath, JSON.stringify(config, null, 2), "utf8");
   return { client: "Cursor", status: "configured", path: mcpPath };
 }
 function vscodeMcpPath() {
   const candidates = [
-    path6.join(HOME, ".config", "Code", "User", "mcp.json"),
+    path7.join(HOME, ".config", "Code", "User", "mcp.json"),
     // Linux
-    path6.join(HOME, "Library", "Application Support", "Code", "User", "mcp.json"),
+    path7.join(HOME, "Library", "Application Support", "Code", "User", "mcp.json"),
     // macOS
-    path6.join(HOME, "AppData", "Roaming", "Code", "User", "mcp.json"),
+    path7.join(HOME, "AppData", "Roaming", "Code", "User", "mcp.json"),
     // Windows
-    path6.join(HOME, ".config", "Code - Insiders", "User", "mcp.json")
+    path7.join(HOME, ".config", "Code - Insiders", "User", "mcp.json")
   ];
   for (const c of candidates) {
-    if (existsSync6(path6.dirname(c))) return c;
+    if (existsSync7(path7.dirname(c))) return c;
   }
   return null;
 }
@@ -1464,51 +1546,51 @@ async function configureVSCode() {
   const mcpPath = vscodeMcpPath();
   if (!mcpPath) return { client: "VS Code", status: "not_installed" };
   let config = {};
-  if (existsSync6(mcpPath)) {
+  if (existsSync7(mcpPath)) {
     try {
-      config = JSON.parse(await readFile3(mcpPath, "utf8"));
+      config = JSON.parse(await readFile4(mcpPath, "utf8"));
     } catch {
     }
   }
   config.servers ??= {};
   if (config.servers["haive"]) return { client: "VS Code", status: "already_configured" };
   config.servers["haive"] = { ...HAIVE_MCP_ENTRY, type: "stdio" };
-  await mkdir2(path6.dirname(mcpPath), { recursive: true });
-  await writeFile3(mcpPath, JSON.stringify(config, null, 2), "utf8");
+  await mkdir3(path7.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 = path6.join(HOME, ".claude.json");
-  if (existsSync6(p)) return p;
-  const p2 = path6.join(HOME, ".config", "claude", "claude.json");
-  if (existsSync6(path6.dirname(p2))) return p2;
+  const p = path7.join(HOME, ".claude.json");
+  if (existsSync7(p)) return p;
+  const p2 = path7.join(HOME, ".config", "claude", "claude.json");
+  if (existsSync7(path7.dirname(p2))) return p2;
   return null;
 }
 async function configureClaude() {
-  const cfgPath = claudeConfigPath() ?? path6.join(HOME, ".claude.json");
-  if (!existsSync6(cfgPath) && !existsSync6(path6.join(HOME, ".claude"))) {
+  const cfgPath = claudeConfigPath() ?? path7.join(HOME, ".claude.json");
+  if (!existsSync7(cfgPath) && !existsSync7(path7.join(HOME, ".claude"))) {
     return { client: "Claude Code", status: "not_installed" };
   }
   let config = {};
-  if (existsSync6(cfgPath)) {
+  if (existsSync7(cfgPath)) {
     try {
-      config = JSON.parse(await readFile3(cfgPath, "utf8"));
+      config = JSON.parse(await readFile4(cfgPath, "utf8"));
     } catch {
     }
   }
   config.mcpServers ??= {};
   if (config.mcpServers["haive"]) return { client: "Claude Code", status: "already_configured" };
   config.mcpServers["haive"] = { ...HAIVE_MCP_ENTRY, type: "stdio" };
-  await writeFile3(cfgPath, JSON.stringify(config, null, 2), "utf8");
+  await writeFile4(cfgPath, JSON.stringify(config, null, 2), "utf8");
   return { client: "Claude Code", status: "configured", path: cfgPath };
 }
 function windsurfMcpPath() {
   const candidates = [
-    path6.join(HOME, ".codeium", "windsurf", "mcp_config.json"),
-    path6.join(HOME, ".windsurf", "mcp.json")
+    path7.join(HOME, ".codeium", "windsurf", "mcp_config.json"),
+    path7.join(HOME, ".windsurf", "mcp.json")
   ];
   for (const c of candidates) {
-    if (existsSync6(path6.dirname(c))) return c;
+    if (existsSync7(path7.dirname(c))) return c;
   }
   return null;
 }
@@ -1516,17 +1598,17 @@ async function configureWindsurf() {
   const mcpPath = windsurfMcpPath();
   if (!mcpPath) return { client: "Windsurf", status: "not_installed" };
   let config = {};
-  if (existsSync6(mcpPath)) {
+  if (existsSync7(mcpPath)) {
     try {
-      config = JSON.parse(await readFile3(mcpPath, "utf8"));
+      config = JSON.parse(await readFile4(mcpPath, "utf8"));
     } catch {
     }
   }
   config.mcpServers ??= {};
   if (config.mcpServers["haive"]) return { client: "Windsurf", status: "already_configured" };
   config.mcpServers["haive"] = HAIVE_MCP_ENTRY;
-  await mkdir2(path6.dirname(mcpPath), { recursive: true });
-  await writeFile3(mcpPath, JSON.stringify(config, null, 2), "utf8");
+  await mkdir3(path7.dirname(mcpPath), { recursive: true });
+  await writeFile4(mcpPath, JSON.stringify(config, null, 2), "utf8");
   return { client: "Windsurf", status: "configured", path: mcpPath };
 }
 async function autoConfigureMcpClients() {
@@ -1546,51 +1628,51 @@ async function configureProjectMcpClients(root) {
   const entry = projectMcpEntry(root);
   const results = [];
   try {
-    const cursorPath = path6.join(root, ".cursor", "mcp.json");
+    const cursorPath = path7.join(root, ".cursor", "mcp.json");
     let config = {};
-    if (existsSync6(cursorPath)) {
+    if (existsSync7(cursorPath)) {
       try {
-        config = JSON.parse(await readFile3(cursorPath, "utf8"));
+        config = JSON.parse(await readFile4(cursorPath, "utf8"));
       } catch {
       }
     }
     config.mcpServers ??= {};
     config.mcpServers["haive"] = entry;
-    await mkdir2(path6.dirname(cursorPath), { recursive: true });
-    await writeFile3(cursorPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+    await mkdir3(path7.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 = path6.join(root, ".vscode", "mcp.json");
+    const vscodePath = path7.join(root, ".vscode", "mcp.json");
     let config = {};
-    if (existsSync6(vscodePath)) {
+    if (existsSync7(vscodePath)) {
       try {
-        config = JSON.parse(await readFile3(vscodePath, "utf8"));
+        config = JSON.parse(await readFile4(vscodePath, "utf8"));
       } catch {
       }
     }
     config.servers ??= {};
     config.servers["haive"] = { ...entry, type: "stdio" };
-    await mkdir2(path6.dirname(vscodePath), { recursive: true });
-    await writeFile3(vscodePath, JSON.stringify(config, null, 2) + "\n", "utf8");
+    await mkdir3(path7.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 = path6.join(root, ".mcp.json");
+    const mcpPath = path7.join(root, ".mcp.json");
     let config = {};
-    if (existsSync6(mcpPath)) {
+    if (existsSync7(mcpPath)) {
       try {
-        config = JSON.parse(await readFile3(mcpPath, "utf8"));
+        config = JSON.parse(await readFile4(mcpPath, "utf8"));
       } catch {
       }
     }
     config.mcpServers ??= {};
     config.mcpServers["haive"] = { ...entry, type: "stdio" };
-    await writeFile3(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+    await writeFile4(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf8");
     results.push({ client: "Claude Code (project)", status: "configured", path: mcpPath });
   } catch (err) {
     results.push({ client: "Claude Code (project)", status: "error", error: String(err) });
@@ -1656,9 +1738,9 @@ async function detectAgentMode(dir) {
   const root = findProjectRoot6(dir);
   const paths = resolveHaivePaths5(root);
   const projectMcp = [
-    { client: "Claude Code", path: path7.join(root, ".mcp.json"), present: existsSync7(path7.join(root, ".mcp.json")) },
-    { client: "Cursor", path: path7.join(root, ".cursor", "mcp.json"), present: existsSync7(path7.join(root, ".cursor", "mcp.json")) },
-    { client: "VS Code", path: path7.join(root, ".vscode", "mcp.json"), present: existsSync7(path7.join(root, ".vscode", "mcp.json")) }
+    { client: "Claude Code", path: path8.join(root, ".mcp.json"), present: existsSync8(path8.join(root, ".mcp.json")) },
+    { client: "Cursor", path: path8.join(root, ".cursor", "mcp.json"), present: existsSync8(path8.join(root, ".cursor", "mcp.json")) },
+    { client: "VS Code", path: path8.join(root, ".vscode", "mcp.json"), present: existsSync8(path8.join(root, ".vscode", "mcp.json")) }
   ];
   const installedAgents = [
     { agent: "Codex", command: "codex", installed: commandExists("codex"), mcp_configured: codexMcpConfigured() },
@@ -1673,7 +1755,7 @@ async function detectAgentMode(dir) {
   const recommendedCommand = recommendedMode === "mcp" ? "Restart your AI client, then call get_briefing before editing." : recommendedMode === "wrapped" && wrapperAgent ? `haive run -- ${wrapperAgent.command}` : 'haive briefing --task "..." --files "..."';
   return {
     root,
-    initialized: existsSync7(paths.haiveDir),
+    initialized: existsSync8(paths.haiveDir),
     project_mcp: projectMcp,
     installed_agents: installedAgents,
     recommended_mode: recommendedMode,
@@ -1681,9 +1763,9 @@ async function detectAgentMode(dir) {
   };
 }
 async function writeAgentModeRecord(paths, detection, skippedReason) {
-  const dir = path7.join(paths.runtimeDir, "enforcement");
-  await mkdir3(dir, { recursive: true });
-  const file = path7.join(dir, "agent-mode.json");
+  const dir = path8.join(paths.runtimeDir, "enforcement");
+  await mkdir4(dir, { recursive: true });
+  const file = path8.join(dir, "agent-mode.json");
   const record = {
     selected_mode: detection.recommended_mode,
     recommended_command: detection.recommended_command,
@@ -1696,7 +1778,7 @@ async function writeAgentModeRecord(paths, detection, skippedReason) {
       ...skippedReason ? [skippedReason] : []
     ]
   };
-  await writeFile4(file, JSON.stringify(record, null, 2) + "\n", "utf8");
+  await writeFile5(file, JSON.stringify(record, null, 2) + "\n", "utf8");
   return file;
 }
 async function confirmGlobalSetup() {
@@ -1724,7 +1806,7 @@ async function configureCodexIfAvailable(root) {
     "mcp",
     "--stdio"
   ], { encoding: "utf8" });
-  if (result.status === 0) return { client: "Codex", status: "configured", path: path7.join(os2.homedir(), ".codex", "config.toml") };
+  if (result.status === 0) return { client: "Codex", status: "configured", path: path8.join(os2.homedir(), ".codex", "config.toml") };
   return { client: "Codex", status: "error", error: result.stderr || result.stdout || "codex mcp add failed" };
 }
 function commandExists(command) {
@@ -1751,7 +1833,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(path7.relative(detection.root, cfg.path))}`);
+    console.log(`${cfg.present ? ui.green("\u2713") : ui.yellow("\u2022")} ${cfg.client} project MCP ${ui.dim(path8.relative(detection.root, cfg.path))}`);
   }
   for (const agent of detection.installed_agents) {
     const marker = agent.installed ? ui.green("\u2713") : ui.dim("\u2022");
@@ -1779,9 +1861,9 @@ function printSetupResult(result) {
 }
 
 // src/commands/init-bootstrap.ts
-import { readdir, readFile as readFile4 } from "fs/promises";
-import { existsSync as existsSync8, readdirSync } from "fs";
-import path8 from "path";
+import { readdir, readFile as readFile5 } from "fs/promises";
+import { existsSync as existsSync9, readdirSync } from "fs";
+import path9 from "path";
 var IGNORE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -1867,12 +1949,12 @@ function detectKeyDeps(allDeps) {
   return KEY_DEPS.filter((d) => allDeps[d] !== void 0);
 }
 function detectLanguage(root) {
-  if (existsSync8(path8.join(root, "tsconfig.json"))) return "TypeScript";
-  if (existsSync8(path8.join(root, "pyproject.toml")) || existsSync8(path8.join(root, "setup.py"))) return "Python";
-  if (existsSync8(path8.join(root, "go.mod"))) return "Go";
-  if (existsSync8(path8.join(root, "pom.xml")) || existsSync8(path8.join(root, "build.gradle"))) return "Java/Kotlin";
-  if (existsSync8(path8.join(root, "Cargo.toml"))) return "Rust";
-  if (existsSync8(path8.join(root, "package.json"))) {
+  if (existsSync9(path9.join(root, "tsconfig.json"))) return "TypeScript";
+  if (existsSync9(path9.join(root, "pyproject.toml")) || existsSync9(path9.join(root, "setup.py"))) return "Python";
+  if (existsSync9(path9.join(root, "go.mod"))) return "Go";
+  if (existsSync9(path9.join(root, "pom.xml")) || existsSync9(path9.join(root, "build.gradle"))) return "Java/Kotlin";
+  if (existsSync9(path9.join(root, "Cargo.toml"))) return "Rust";
+  if (existsSync9(path9.join(root, "package.json"))) {
     return hasSourceWithExt(root, [".ts", ".tsx", ".mts", ".cts"]) ? "TypeScript" : "JavaScript";
   }
   return "Unknown";
@@ -1892,7 +1974,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(path8.join(dir, entry.name), depth - 1)) return true;
+        if (scanDir(path9.join(dir, entry.name), depth - 1)) return true;
       }
     }
     return false;
@@ -1913,7 +1995,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 (existsSync8("pom.xml")) return "Java backend";
+  if (existsSync9("pom.xml")) return "Java backend";
   return "Application";
 }
 async function scanDirs(root, maxDepth = 2) {
@@ -1929,9 +2011,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 = path8.relative(root, path8.join(dir, entry.name));
+      const rel = path9.relative(root, path9.join(dir, entry.name));
       results.push(rel);
-      await walk(path8.join(dir, entry.name), depth + 1);
+      await walk(path9.join(dir, entry.name), depth + 1);
     }
   }
   await walk(root, 0);
@@ -2048,10 +2130,10 @@ function readmeExcerpt(readme) {
 }
 async function generateBootstrapContext(root) {
   let pkg = {};
-  const pkgPath = path8.join(root, "package.json");
-  if (existsSync8(pkgPath)) {
+  const pkgPath = path9.join(root, "package.json");
+  if (existsSync9(pkgPath)) {
     try {
-      pkg = JSON.parse(await readFile4(pkgPath, "utf8"));
+      pkg = JSON.parse(await readFile5(pkgPath, "utf8"));
     } catch {
     }
   }
@@ -2061,14 +2143,14 @@ 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 ?? path8.basename(root);
+  const projectName = pkg.name ?? path9.basename(root);
   const projectDesc = pkg.description ?? "";
   let readmeSummary = "";
   for (const name of ["README.md", "readme.md", "README"]) {
-    const p = path8.join(root, name);
-    if (existsSync8(p)) {
+    const p = path9.join(root, name);
+    if (existsSync9(p)) {
       try {
-        const content = await readFile4(p, "utf8");
+        const content = await readFile5(p, "utf8");
         readmeSummary = readmeExcerpt(content);
         break;
       } catch {
@@ -2132,9 +2214,9 @@ async function generateBootstrapContext(root) {
 }
 
 // src/commands/init-stack-packs.ts
-import { mkdir as mkdir4, writeFile as writeFile5 } from "fs/promises";
-import { existsSync as existsSync9 } from "fs";
-import path9 from "path";
+import { mkdir as mkdir5, writeFile as writeFile6 } from "fs/promises";
+import { existsSync as existsSync10 } from "fs";
+import path10 from "path";
 import {
   buildFrontmatter,
   memoryFilePath,
@@ -3213,7 +3295,7 @@ function autoDetectStacks(deps) {
 async function seedStackPack(haivePaths, stack) {
   const memories = PACKS[stack];
   if (!memories) return { memories: 0, sensors: 0 };
-  await mkdir4(haivePaths.teamDir, { recursive: true });
+  await mkdir5(haivePaths.teamDir, { recursive: true });
   let memCount = 0;
   let sensorCount = 0;
   for (const mem of memories) {
@@ -3238,12 +3320,12 @@ async function seedStackPack(haivePaths, stack) {
       ...sensor ? { sensor } : {}
     });
     const filePath = memoryFilePath(haivePaths, "team", fm.id);
-    if (existsSync9(filePath)) continue;
+    if (existsSync10(filePath)) continue;
     const content = serializeMemory2({ frontmatter: fm, body: `${mem.body}
 
 ${SEED_FOOTER(stack)}` });
-    await mkdir4(path9.dirname(filePath), { recursive: true });
-    await writeFile5(filePath, content, "utf8");
+    await mkdir5(path10.dirname(filePath), { recursive: true });
+    await writeFile6(filePath, content, "utf8");
     memCount++;
     if (sensor) sensorCount++;
   }
@@ -3252,7 +3334,7 @@ ${SEED_FOOTER(stack)}` });
 
 // src/commands/init.ts
 var execFileAsync = promisify2(execFile2);
-var HAIVE_GITHUB_ACTION_REF = `v${"0.18.0"}`;
+var HAIVE_GITHUB_ACTION_REF = `v${"0.19.0"}`;
 var PROJECT_CONTEXT_TEMPLATE = `# Project context
 
 > Generated by \`haive init\`. Run \`haive init --bootstrap\` to auto-fill from your codebase,
@@ -3274,28 +3356,6 @@ TODO \u2014 domain terms and what they mean here.
 ## Gotchas
 TODO \u2014 known traps, surprising behavior, things newcomers stub their toes on.
 `;
-var BRIDGE_BODY = `<!-- hAIve bridge file \u2014 do not edit by hand. -->
-
-This repo uses **hAIve** for shared context. The map:
-
-- \`.ai/project-context.md\` \u2014 project overview, architecture, conventions.
-- \`.ai/memories/\` \u2014 decisions, gotchas, conventions, failed attempts (personal/team/module).
-- The breadcrumbs injected below (if any) are the top current memories.
-
-## Working through hAIve
-
-1. **Before editing** for a goal, call \`get_briefing\` (task + files/symbols) to load ranked context \u2014 or \`mem_relevant_to\` if project context is already loaded this session.
-2. **When an approach fails**, call \`mem_tried\` right away so the next agent skips the dead end.
-3. **Before closing** a substantive session, run the \`post_task\` prompt to capture what was learned.
-4. **Before final response**, run \`haive enforce finish\`. If it blocks, commit/push, bump/tag shippable releases, wait for GitHub Actions to pass when applicable, then rerun it.
-
-If the haive MCP server is not available, tell the developer rather than silently skipping it.
-
-## Safety
-
-- If \`get_briefing\` returns \`action_required\`, surface each item to the developer (use its \`developer_message\`) and wait for confirmation before changing code.
-- Never act autonomously on a cross-repo breaking change (dep bump, contract/API diff) \u2014 ask first.
-`;
 var CURSOR_HAIVE_RULE_MDC = `---
 description: Require hAIve MCP (get_briefing / mem_relevant_to) before substantive repo edits
 alwaysApply: true
@@ -3465,7 +3525,12 @@ jobs:
 function registerInit(program2) {
   program2.command("init").description(
     "Initialize a hAIve 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 CLAUDE.md / AGENTS.md / .cursorrules / copilot-instructions.md / .cursor/rules/haive-mcp-required.mdc").option("--with-ci", "write a GitHub Actions workflow (.github/workflows/haive-sync.yml) \u2014 included automatically in autopilot mode").option(
+  ).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"
+  ).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"
   ).option(
@@ -3497,7 +3562,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 = path10.resolve(opts.dir);
+    const root = path11.resolve(opts.dir);
     const paths = resolveHaivePaths6(root);
     const autopilot = opts.manual !== true;
     const json = opts.json === true;
@@ -3513,35 +3578,36 @@ function registerInit(program2) {
       gitSeedsWritten: 0,
       gitCommitsScanned: 0,
       gitRevertsFound: 0,
-      gitRecurring: 0
+      gitRecurring: 0,
+      bridgesWritten: 0
     };
-    if (existsSync10(paths.haiveDir)) {
+    if (existsSync11(paths.haiveDir)) {
       ui.warn(`.ai/ already exists at ${paths.haiveDir} \u2014 leaving existing files in place.`);
     }
-    await mkdir5(paths.personalDir, { recursive: true });
-    await mkdir5(paths.teamDir, { recursive: true });
-    await mkdir5(paths.moduleDir, { recursive: true });
-    await mkdir5(paths.modulesContextDir, { recursive: true });
+    await mkdir6(paths.personalDir, { recursive: true });
+    await mkdir6(paths.teamDir, { recursive: true });
+    await mkdir6(paths.moduleDir, { recursive: true });
+    await mkdir6(paths.modulesContextDir, { recursive: true });
     await ensureAiRuntimeLayout(paths.runtimeDir);
-    await ensureAiCacheLayout(path10.join(paths.haiveDir, ".cache"));
-    if (!existsSync10(paths.projectContext)) {
+    await ensureAiCacheLayout(path11.join(paths.haiveDir, ".cache"));
+    if (!existsSync11(paths.projectContext)) {
       if (wantBootstrap) {
         ui.info("Bootstrapping project context from local files\u2026");
         try {
           const context = await generateBootstrapContext(root);
-          await writeFile6(paths.projectContext, context, "utf8");
+          await writeFile7(paths.projectContext, context, "utf8");
           ui.success("Created .ai/project-context.md (auto-bootstrapped from local files)");
         } catch (err) {
           ui.warn(`Bootstrap failed (${String(err)}) \u2014 writing default template instead`);
-          await writeFile6(paths.projectContext, PROJECT_CONTEXT_TEMPLATE, "utf8");
+          await writeFile7(paths.projectContext, PROJECT_CONTEXT_TEMPLATE, "utf8");
         }
       } else {
-        await writeFile6(paths.projectContext, PROJECT_CONTEXT_TEMPLATE, "utf8");
-        ui.success(`Created ${path10.relative(root, paths.projectContext)}`);
+        await writeFile7(paths.projectContext, PROJECT_CONTEXT_TEMPLATE, "utf8");
+        ui.success(`Created ${path11.relative(root, paths.projectContext)}`);
       }
     }
-    const configExists = existsSync10(
-      path10.join(paths.haiveDir, "haive.config.json")
+    const configExists = existsSync11(
+      path11.join(paths.haiveDir, "haive.config.json")
     );
     if (!configExists) {
       await saveConfig2(paths, autopilot ? AUTOPILOT_DEFAULTS2 : { autopilot: false });
@@ -3549,13 +3615,6 @@ function registerInit(program2) {
         `Created .ai/haive.config.json (mode: ${autopilot ? "autopilot" : "standard"})`
       );
     }
-    if (opts.bridges) {
-      await writeBridge(root, "CLAUDE.md");
-      await writeBridge(root, "AGENTS.md");
-      await writeBridge(root, ".cursorrules");
-      await writeBridge(root, path10.join(".github", "copilot-instructions.md"));
-      await writeCursorHaiveRule(root);
-    }
     const stacksToSeed = await resolveStacksToSeed(root, wantStack);
     if (stacksToSeed.length > 0) {
       let totalSeeded = 0;
@@ -3597,15 +3656,31 @@ function registerInit(program2) {
         ui.info("Git seeding: no revert/hotfix signals found \u2014 run `haive memory seed-git` later.");
       }
     }
+    if (opts.bridges) {
+      const targets = resolveBridgeTargets(opts.bridgeTargets);
+      const res = await writeBridgeFiles(root, paths, { targets });
+      await writeCursorHaiveRule(root);
+      const made = res.created.length + res.updated.length;
+      report.bridgesWritten = made;
+      if (res.created.length > 0) {
+        ui.success(`Generated ${res.created.length} agent bridge(s): ${res.created.join(", ")}`);
+      }
+      if (res.updated.length > 0) {
+        ui.info(`Refreshed ${res.updated.length} existing bridge(s): ${res.updated.join(", ")}`);
+      }
+      if (made === 0) {
+        ui.info("Bridges already up to date.");
+      }
+    }
     const wantCi = opts.withCi || autopilot;
     if (wantCi) {
-      const ciPath = path10.join(root, ".github", "workflows", "haive-sync.yml");
-      if (existsSync10(ciPath)) {
+      const ciPath = path11.join(root, ".github", "workflows", "haive-sync.yml");
+      if (existsSync11(ciPath)) {
         ui.info("CI workflow already exists \u2014 skipped");
       } else {
-        await mkdir5(path10.dirname(ciPath), { recursive: true });
-        await writeFile6(ciPath, CI_WORKFLOW, "utf8");
-        ui.success(`Created ${path10.relative(root, ciPath)}`);
+        await mkdir6(path11.dirname(ciPath), { recursive: true });
+        await writeFile7(ciPath, CI_WORKFLOW, "utf8");
+        ui.success(`Created ${path11.relative(root, ciPath)}`);
       }
     }
     if (autopilot) {
@@ -3645,7 +3720,7 @@ function registerInit(program2) {
         interactive: process.stdin.isTTY
       });
       for (const r of agentSetup.project_results) {
-        if (r.status === "configured" && r.path) ui.success(`haive MCP project config written (${path10.relative(root, r.path)})`);
+        if (r.status === "configured" && r.path) ui.success(`haive MCP project config written (${path11.relative(root, r.path)})`);
         else if (r.status === "error") ui.warn(`${r.client}: ${r.error}`);
       }
       for (const r of agentSetup.global_results) {
@@ -3682,6 +3757,7 @@ function registerInit(program2) {
         git_seeds_written: report.gitSeedsWritten,
         git_recurring: report.gitRecurring,
         bridges: opts.bridges !== false,
+        bridges_written: report.bridgesWritten,
         ci: opts.withCi || autopilot
       }, null, 2));
       return;
@@ -3743,57 +3819,57 @@ async function autoDetectStacksFromRoot(root) {
   let requirementsTxt;
   let goMod;
   let pomXml;
-  const pkgPath = path10.join(root, "package.json");
-  if (existsSync10(pkgPath)) {
+  const pkgPath = path11.join(root, "package.json");
+  if (existsSync11(pkgPath)) {
     try {
-      const pkg = JSON.parse(await readFile5(pkgPath, "utf8"));
+      const pkg = JSON.parse(await readFile6(pkgPath, "utf8"));
       packageJsonDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
     } catch {
     }
   }
   for (const name of ["requirements.txt", "requirements/base.txt", "requirements/prod.txt"]) {
-    const reqPath = path10.join(root, name);
-    if (existsSync10(reqPath)) {
+    const reqPath = path11.join(root, name);
+    if (existsSync11(reqPath)) {
       try {
-        requirementsTxt = await readFile5(reqPath, "utf8");
+        requirementsTxt = await readFile6(reqPath, "utf8");
         break;
       } catch {
       }
     }
   }
-  const goModPath = path10.join(root, "go.mod");
-  if (existsSync10(goModPath)) {
+  const goModPath = path11.join(root, "go.mod");
+  if (existsSync11(goModPath)) {
     try {
-      goMod = await readFile5(goModPath, "utf8");
+      goMod = await readFile6(goModPath, "utf8");
     } catch {
     }
   }
-  const pomPath = path10.join(root, "pom.xml");
-  if (existsSync10(pomPath)) {
+  const pomPath = path11.join(root, "pom.xml");
+  if (existsSync11(pomPath)) {
     try {
-      pomXml = await readFile5(pomPath, "utf8");
+      pomXml = await readFile6(pomPath, "utf8");
     } catch {
     }
   }
   let composerJson;
-  const composerPath = path10.join(root, "composer.json");
-  if (existsSync10(composerPath)) {
+  const composerPath = path11.join(root, "composer.json");
+  if (existsSync11(composerPath)) {
     try {
-      composerJson = await readFile5(composerPath, "utf8");
+      composerJson = await readFile6(composerPath, "utf8");
     } catch {
     }
   }
   let gemfile;
-  const gemfilePath = path10.join(root, "Gemfile");
-  if (existsSync10(gemfilePath)) {
+  const gemfilePath = path11.join(root, "Gemfile");
+  if (existsSync11(gemfilePath)) {
     try {
-      gemfile = await readFile5(gemfilePath, "utf8");
+      gemfile = await readFile6(gemfilePath, "utf8");
     } catch {
     }
   }
-  const hasDockerfile = existsSync10(path10.join(root, "Dockerfile"));
-  const hasTurboJson = existsSync10(path10.join(root, "turbo.json"));
-  const hasNxJson = existsSync10(path10.join(root, "nx.json"));
+  const hasDockerfile = existsSync11(path11.join(root, "Dockerfile"));
+  const hasTurboJson = existsSync11(path11.join(root, "turbo.json"));
+  const hasNxJson = existsSync11(path11.join(root, "nx.json"));
   let hasCsproj = false;
   try {
     const entries = await readdir2(root);
@@ -3845,9 +3921,9 @@ 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 (existsSync10(file)) continue;
-    await mkdir5(path10.dirname(file), { recursive: true });
-    await writeFile6(file, serializeMemory3({ frontmatter: fm, body }), "utf8");
+    if (existsSync11(file)) continue;
+    await mkdir6(path11.dirname(file), { recursive: true });
+    await writeFile7(file, serializeMemory3({ frontmatter: fm, body }), "utf8");
     written++;
   }
   return { scanned: commits.length, found: proposals.length, recurring, written };
@@ -3886,6 +3962,9 @@ function printInitReport(r) {
   if (r.totalMemories > 0) {
     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)`);
+  }
   if (lines.length === 0) return;
   const width = Math.max(...lines.map((l) => l.length), 44);
   const bar = "\u2500".repeat(width + 2);
@@ -3900,29 +3979,30 @@ function printInitReport(r) {
     console.log(ui.dim("  Review draft seeds: haive memory pending   (validate or delete each one)"));
   }
   console.log(
-    ui.dim("  Reach: every agent gets this corpus \u2014 run `haive bridges sync --all` (Cursor, Cline, Windsurf, Roo, Gemini, Copilot, \u2026)")
+    ui.dim("  Reach: bridges auto-refresh on `haive sync`; regenerate any time with `haive bridges sync --all`.")
   );
 }
 async function writeCursorHaiveRule(root) {
   const relPath = ".cursor/rules/haive-mcp-required.mdc";
-  const target = path10.join(root, relPath);
-  if (existsSync10(target)) {
+  const target = path11.join(root, relPath);
+  if (existsSync11(target)) {
     ui.info(`Cursor rule ${relPath} already exists \u2014 skipped`);
     return;
   }
-  await mkdir5(path10.dirname(target), { recursive: true });
-  await writeFile6(target, CURSOR_HAIVE_RULE_MDC, "utf8");
+  await mkdir6(path11.dirname(target), { recursive: true });
+  await writeFile7(target, CURSOR_HAIVE_RULE_MDC, "utf8");
   ui.success(`Created Cursor rule ${relPath}`);
 }
-async function writeBridge(root, relPath) {
-  const target = path10.join(root, relPath);
-  if (existsSync10(target)) {
-    ui.info(`Bridge ${relPath} already exists \u2014 skipped`);
-    return;
+function resolveBridgeTargets(opt) {
+  const raw = (opt ?? "all").trim().toLowerCase();
+  if (raw === "" || raw === "all") return [...BRIDGE_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));
+  if (invalid.length > 0) {
+    ui.warn(`Ignoring unknown bridge target(s): ${invalid.join(", ")}. Valid: ${BRIDGE_TARGETS.join(", ")}`);
   }
-  await mkdir5(path10.dirname(target), { recursive: true });
-  await writeFile6(target, BRIDGE_BODY, "utf8");
-  ui.success(`Created bridge ${relPath}`);
+  return valid.length > 0 ? valid : [...BRIDGE_TARGETS];
 }
 var RUNTIME_README_BODY = `# .ai/.runtime \u2014 disposable local layer
 
@@ -3937,50 +4017,50 @@ var RUNTIME_GITIGNORE_BODY = `*
 !README.md
 `;
 async function ensureAiRuntimeLayout(runtimeDir) {
-  await mkdir5(runtimeDir, { recursive: true });
-  const gi = path10.join(runtimeDir, ".gitignore");
-  if (!existsSync10(gi)) {
-    await writeFile6(gi, RUNTIME_GITIGNORE_BODY, "utf8");
+  await mkdir6(runtimeDir, { recursive: true });
+  const gi = path11.join(runtimeDir, ".gitignore");
+  if (!existsSync11(gi)) {
+    await writeFile7(gi, RUNTIME_GITIGNORE_BODY, "utf8");
   }
-  const readme = path10.join(runtimeDir, "README.md");
-  if (!existsSync10(readme)) {
-    await writeFile6(readme, RUNTIME_README_BODY, "utf8");
+  const readme = path11.join(runtimeDir, "README.md");
+  if (!existsSync11(readme)) {
+    await writeFile7(readme, RUNTIME_README_BODY, "utf8");
   }
 }
 async function ensureAiCacheLayout(cacheDir) {
-  await mkdir5(cacheDir, { recursive: true });
-  const gi = path10.join(cacheDir, ".gitignore");
-  if (!existsSync10(gi)) {
-    await writeFile6(gi, "*\n!.gitignore\n", "utf8");
+  await mkdir6(cacheDir, { recursive: true });
+  const gi = path11.join(cacheDir, ".gitignore");
+  if (!existsSync11(gi)) {
+    await writeFile7(gi, "*\n!.gitignore\n", "utf8");
   }
 }
 async function ensureGitignoreEntries(root, patterns) {
   try {
-    const gitignorePath = path10.join(root, ".gitignore");
+    const gitignorePath = path11.join(root, ".gitignore");
     let existing = "";
-    if (existsSync10(gitignorePath)) {
-      existing = await readFile5(gitignorePath, "utf8");
+    if (existsSync11(gitignorePath)) {
+      existing = await readFile6(gitignorePath, "utf8");
     }
     const lines = existing.split("\n");
     const missing = patterns.filter((p) => !lines.some((l) => l.trim() === p));
     if (missing.length === 0) return;
     const toAppend = (existing.endsWith("\n") || existing === "" ? "" : "\n") + "# hAIve project-level MCP configs (machine-specific absolute paths)\n" + missing.join("\n") + "\n";
-    await writeFile6(gitignorePath, existing + toAppend, "utf8");
+    await writeFile7(gitignorePath, existing + toAppend, "utf8");
   } catch {
   }
 }
 
 // src/commands/install-hooks.ts
-import { mkdir as mkdir7, writeFile as writeFile8, chmod, readFile as readFile7 } from "fs/promises";
-import { existsSync as existsSync12 } from "fs";
-import path12 from "path";
+import { mkdir as mkdir8, writeFile as writeFile9, chmod, readFile as readFile8 } from "fs/promises";
+import { existsSync as existsSync13 } from "fs";
+import path13 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot8 } from "@hiveai/core";
 
 // src/utils/claude-hooks.ts
-import { existsSync as existsSync11 } from "fs";
-import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile7 } from "fs/promises";
-import path11 from "path";
+import { existsSync as existsSync12 } from "fs";
+import { mkdir as mkdir7, readFile as readFile7, writeFile as writeFile8 } from "fs/promises";
+import path12 from "path";
 var HAIVE_HOOK_TAG = "haive-enforcement";
 var POST_TOOL_USE_GROUP = {
   matcher: "Edit|Write|Bash",
@@ -4066,9 +4146,9 @@ function unpatchClaudeSettings(input) {
 async function installClaudeHooksAtPath(settingsPath) {
   let raw = null;
   let created = false;
-  if (existsSync11(settingsPath)) {
+  if (existsSync12(settingsPath)) {
     try {
-      raw = JSON.parse(await readFile6(settingsPath, "utf8"));
+      raw = JSON.parse(await readFile7(settingsPath, "utf8"));
     } catch {
       throw new Error(`${settingsPath} exists but is not valid JSON. Fix it manually first.`);
     }
@@ -4076,25 +4156,25 @@ async function installClaudeHooksAtPath(settingsPath) {
     created = true;
   }
   const patched = patchClaudeSettings(raw);
-  await mkdir6(path11.dirname(settingsPath), { recursive: true });
-  await writeFile7(settingsPath, JSON.stringify(patched, null, 2) + "\n", "utf8");
+  await mkdir7(path12.dirname(settingsPath), { recursive: true });
+  await writeFile8(settingsPath, JSON.stringify(patched, null, 2) + "\n", "utf8");
   return { settingsPath, created };
 }
 async function uninstallClaudeHooksAtPath(settingsPath) {
-  if (!existsSync11(settingsPath)) {
+  if (!existsSync12(settingsPath)) {
     return { settingsPath, created: false };
   }
-  const raw = JSON.parse(await readFile6(settingsPath, "utf8"));
+  const raw = JSON.parse(await readFile7(settingsPath, "utf8"));
   const cleaned = unpatchClaudeSettings(raw);
-  await writeFile7(settingsPath, JSON.stringify(cleaned, null, 2) + "\n", "utf8");
+  await writeFile8(settingsPath, JSON.stringify(cleaned, null, 2) + "\n", "utf8");
   return { settingsPath, created: false };
 }
 function defaultClaudeSettingsPath(scope, projectRoot) {
   if (scope === "user") {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-    return path11.join(home, ".claude", "settings.json");
+    return path12.join(home, ".claude", "settings.json");
   }
-  return path11.join(projectRoot, ".claude", "settings.local.json");
+  return path12.join(projectRoot, ".claude", "settings.local.json");
 }
 
 // src/commands/install-hooks.ts
@@ -4151,27 +4231,27 @@ fi
 ];
 async function installGitHooks(opts) {
   const root = findProjectRoot8(opts.dir);
-  const gitDir = path12.join(root, ".git");
-  if (!existsSync12(gitDir)) {
+  const gitDir = path13.join(root, ".git");
+  if (!existsSync13(gitDir)) {
     ui.error(`No .git directory at ${root}.`);
     process.exitCode = 1;
     return;
   }
-  const hooksDir = path12.join(gitDir, "hooks");
-  await mkdir7(hooksDir, { recursive: true });
+  const hooksDir = path13.join(gitDir, "hooks");
+  await mkdir8(hooksDir, { recursive: true });
   let installed = 0;
   let skipped = 0;
   for (const { name, body } of HOOKS) {
-    const file = path12.join(hooksDir, name);
-    if (existsSync12(file) && !opts.force) {
-      const existing = await readFile7(file, "utf8");
+    const file = path13.join(hooksDir, name);
+    if (existsSync13(file) && !opts.force) {
+      const existing = await readFile8(file, "utf8");
       if (!existing.includes(HOOK_MARKER)) {
         ui.warn(`${name} already exists and was not written by hAIve. Re-run with --force to overwrite.`);
         skipped++;
         continue;
       }
     }
-    await writeFile8(file, body, "utf8");
+    await writeFile9(file, body, "utf8");
     await chmod(file, 493);
     installed++;
   }
@@ -4226,9 +4306,9 @@ function registerInstallHooks(program2) {
 }
 
 // src/commands/observe.ts
-import { appendFile, mkdir as mkdir8 } from "fs/promises";
-import { existsSync as existsSync13 } from "fs";
-import path13 from "path";
+import { appendFile, mkdir as mkdir9 } from "fs/promises";
+import { existsSync as existsSync14 } from "fs";
+import path14 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot9, resolveHaivePaths as resolveHaivePaths7 } from "@hiveai/core";
 var MAX_STDIN_BYTES = 256 * 1024;
@@ -4335,7 +4415,7 @@ function registerObserve(program2) {
       })();
       if (!root) return;
       const paths = resolveHaivePaths7(root);
-      if (!existsSync13(paths.haiveDir)) return;
+      if (!existsSync14(paths.haiveDir)) return;
       const failureHint = detectFailure(payload);
       const observation = {
         ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -4346,10 +4426,10 @@ function registerObserve(program2) {
         files: extractFiles(payload),
         ...failureHint ? { failure_hint: true } : {}
       };
-      const cacheDir = path13.join(paths.haiveDir, ".cache");
-      await mkdir8(cacheDir, { recursive: true });
+      const cacheDir = path14.join(paths.haiveDir, ".cache");
+      await mkdir9(cacheDir, { recursive: true });
       await appendFile(
-        path13.join(cacheDir, "observations.jsonl"),
+        path14.join(cacheDir, "observations.jsonl"),
         JSON.stringify(observation) + "\n",
         "utf8"
       );
@@ -4366,16 +4446,16 @@ import { findProjectRoot as findProjectRoot11 } from "@hiveai/core";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { findProjectRoot as findProjectRoot10, resolveHaivePaths as resolveHaivePaths8 } from "@hiveai/core";
-import { mkdir as mkdir9, writeFile as writeFile9 } from "fs/promises";
-import { existsSync as existsSync14 } from "fs";
-import path14 from "path";
+import { mkdir as mkdir10, writeFile as writeFile10 } from "fs/promises";
+import { existsSync as existsSync15 } from "fs";
+import path15 from "path";
 import { z } from "zod";
-import { readFile as readFile8, readdir as readdir3 } from "fs/promises";
+import { readFile as readFile9, readdir as readdir3 } from "fs/promises";
 import { existsSync as existsSync22 } from "fs";
 import path22 from "path";
 import { z as z2 } from "zod";
 import { existsSync as existsSync32 } from "fs";
-import { loadMemoriesFromDir as loadMemoriesFromDir4 } from "@hiveai/core";
+import { loadMemoriesFromDir as loadMemoriesFromDir5 } from "@hiveai/core";
 import { z as z3 } from "zod";
 import { createHash } from "crypto";
 import { mkdir as mkdir22, writeFile as writeFile22 } from "fs/promises";
@@ -4416,7 +4496,7 @@ import { z as z6 } from "zod";
 import { writeFile as writeFile42 } from "fs/promises";
 import { existsSync as existsSync72 } from "fs";
 import {
-  loadMemoriesFromDir as loadMemoriesFromDir5,
+  loadMemoriesFromDir as loadMemoriesFromDir52,
   loadUsageIndex as loadUsageIndex22,
   recordRejection,
   saveUsageIndex,
@@ -4486,7 +4566,7 @@ import {
 } from "@hiveai/core";
 import { z as z14 } from "zod";
 import { mkdir as mkdir32, writeFile as writeFile82 } from "fs/promises";
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync152 } from "fs";
 import path52 from "path";
 import {
   buildFrontmatter as buildFrontmatter22,
@@ -4507,7 +4587,7 @@ import {
   serializeMemory as serializeMemory8
 } from "@hiveai/core";
 import { z as z16 } from "zod";
-import { mkdir as mkdir52, writeFile as writeFile10 } from "fs/promises";
+import { mkdir as mkdir52, writeFile as writeFile102 } from "fs/promises";
 import { existsSync as existsSync17 } from "fs";
 import path72 from "path";
 import {
@@ -4552,7 +4632,7 @@ import {
   inferModulesFromPaths as inferModulesFromPaths2,
   isAutoPromoteEligible,
   isDecaying,
-  isRetiredMemory,
+  isRetiredMemory as isRetiredMemory2,
   literalMatchesAllTokens as literalMatchesAllTokens22,
   literalMatchesAnyToken as literalMatchesAnyToken22,
   loadCodeMap as loadCodeMap5,
@@ -4617,7 +4697,7 @@ import {
   deriveConfidence as deriveConfidence6,
   diffHasDistinctiveOverlap,
   getUsage as getUsage8,
-  isRetiredMemory as isRetiredMemory2,
+  isRetiredMemory as isRetiredMemory22,
   loadMemoriesFromDir as loadMemoriesFromDir19,
   loadUsageIndex as loadUsageIndex10,
   literalMatchesAnyToken as literalMatchesAnyToken3,
@@ -4703,15 +4783,15 @@ var BootstrapProjectSaveInputSchema = {
   overwrite: z.boolean().default(false).describe("Overwrite an existing file instead of failing")
 };
 async function bootstrapProjectSave(input, ctx) {
-  const target = input.module ? path14.join(ctx.paths.modulesContextDir, input.module, "context.md") : ctx.paths.projectContext;
-  const exists = existsSync14(target);
+  const target = input.module ? path15.join(ctx.paths.modulesContextDir, input.module, "context.md") : ctx.paths.projectContext;
+  const exists = existsSync15(target);
   if (exists && !input.overwrite) {
     throw new Error(
       `${target} already exists. Pass overwrite=true to replace it.`
     );
   }
-  await mkdir9(path14.dirname(target), { recursive: true });
-  await writeFile9(target, input.content, "utf8");
+  await mkdir10(path15.dirname(target), { recursive: true });
+  await writeFile10(target, input.content, "utf8");
   return {
     file_path: target,
     action: exists ? "overwritten" : "created"
@@ -4724,14 +4804,14 @@ var GetProjectContextInputSchema = {
 async function getProjectContext(input, ctx) {
   const out = { root_context: null };
   if (existsSync22(ctx.paths.projectContext)) {
-    out.root_context = await readFile8(ctx.paths.projectContext, "utf8");
+    out.root_context = await readFile9(ctx.paths.projectContext, "utf8");
   }
   if (input.module) {
     const modFile = path22.join(ctx.paths.modulesContextDir, input.module, "context.md");
     if (existsSync22(modFile)) {
       out.module_context = {
         name: input.module,
-        content: await readFile8(modFile, "utf8")
+        content: await readFile9(modFile, "utf8")
       };
     }
   }
@@ -4758,7 +4838,7 @@ async function memList(input, ctx) {
   if (!existsSync32(ctx.paths.memoriesDir)) {
     return { memories: [] };
   }
-  const all = await loadMemoriesFromDir4(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir5(ctx.paths.memoriesDir);
   const filtered = all.filter(({ memory: memory2 }) => {
     const fm = memory2.frontmatter;
     if (input.scope && fm.scope !== input.scope) return false;
@@ -5252,7 +5332,7 @@ async function memReject(input, ctx) {
   if (!existsSync72(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const memories = await loadMemoriesFromDir5(ctx.paths.memoriesDir);
+  const memories = await loadMemoriesFromDir52(ctx.paths.memoriesDir);
   const loaded = memories.find((m) => m.memory.frontmatter.id === input.id);
   if (!loaded) throw new Error(`No memory with id "${input.id}".`);
   await writeFile42(
@@ -5645,7 +5725,7 @@ var MemTriedInputSchema = {
   author: z15.string().optional().describe("Author handle or email")
 };
 async function memTried(input, ctx) {
-  if (!existsSync15(ctx.paths.haiveDir)) {
+  if (!existsSync152(ctx.paths.haiveDir)) {
     throw new Error(`No .ai/ directory at ${ctx.paths.root}. Run 'haive init' first.`);
   }
   const slug = input.what.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim().split(/\s+/).slice(0, 5).join("-");
@@ -5671,7 +5751,7 @@ async function memTried(input, ctx) {
   }
   const file = memoryFilePath22(ctx.paths, frontmatter.scope, frontmatter.id, frontmatter.module);
   await mkdir32(path52.dirname(file), { recursive: true });
-  if (existsSync15(file)) {
+  if (existsSync152(file)) {
     throw new Error(`Memory already exists at ${file}`);
   }
   await writeFile82(file, serializeMemory7({ frontmatter, body }), "utf8");
@@ -5805,7 +5885,7 @@ async function memObserve(input, ctx) {
   if (existsSync17(file)) {
     throw new Error(`Memory already exists at ${file}`);
   }
-  await writeFile10(file, serializeMemory9({ frontmatter, body }), "utf8");
+  await writeFile102(file, serializeMemory9({ frontmatter, body }), "utf8");
   return { id: frontmatter.id, scope: frontmatter.scope, file_path: file };
 }
 function pendingDistillPath(ctx) {
@@ -6257,7 +6337,7 @@ async function getBriefing(input, ctx) {
       const s = memory2.frontmatter.status;
       if (s === "rejected" || s === "deprecated") return false;
       if (!input.include_stale && s === "stale") return false;
-      if (!input.include_stale && isRetiredMemory(memory2.frontmatter, memory2.body)) return false;
+      if (!input.include_stale && isRetiredMemory2(memory2.frontmatter, memory2.body)) return false;
       if (memory2.frontmatter.type === "session_recap") return false;
       return true;
     });
@@ -7125,7 +7205,7 @@ async function antiPatternsCheck(input, ctx) {
     const t = memory2.frontmatter.type;
     if (t !== "attempt" && t !== "gotcha") return false;
     const s = memory2.frontmatter.status;
-    return s !== "rejected" && s !== "deprecated" && s !== "stale" && !isRetiredMemory2(memory2.frontmatter, memory2.body);
+    return s !== "rejected" && s !== "deprecated" && s !== "stale" && !isRetiredMemory22(memory2.frontmatter, memory2.body);
   });
   if (negative.length === 0) {
     return { scanned: 0, warnings: [], notice: "No attempt/gotcha memories found yet." };
@@ -8491,7 +8571,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
   };
 }
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.18.0";
+var SERVER_VERSION = "0.19.0";
 function jsonResult(data) {
   return {
     content: [
@@ -9523,8 +9603,8 @@ function registerMcp(program2) {
 
 // src/commands/sync.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { readFile as readFile10, writeFile as writeFile16, mkdir as mkdir11 } from "fs/promises";
-import { existsSync as existsSync34 } from "fs";
+import { readFile as readFile10, writeFile as writeFile15, mkdir as mkdir11 } from "fs/promises";
+import { existsSync as existsSync33 } from "fs";
 import path16 from "path";
 import "commander";
 import {
@@ -9537,7 +9617,7 @@ import {
   isStackPackSeed,
   loadCodeMap as loadCodeMap6,
   loadConfig as loadConfig4,
-  loadMemoriesFromDir as loadMemoriesFromDir26,
+  loadMemoriesFromDir as loadMemoriesFromDir25,
   loadUsageIndex as loadUsageIndex13,
   pullCrossRepoSources,
   resolveHaivePaths as resolveHaivePaths9,
@@ -9547,90 +9627,7 @@ import {
   verifyAnchor as verifyAnchor2,
   watchContracts
 } from "@hiveai/core";
-import { BRIDGE_TARGETS } from "@hiveai/core";
-
-// src/utils/bridge-files.ts
-import { mkdir as mkdir10, readFile as readFile9, writeFile as writeFile15 } from "fs/promises";
-import { existsSync as existsSync33 } from "fs";
-import path15 from "path";
-import {
-  BRIDGE_MARKERS,
-  generateBridges,
-  isRetiredMemory as isRetiredMemory3,
-  loadMemoriesFromDir as loadMemoriesFromDir25
-} from "@hiveai/core";
-async function writeBridgeFiles(root, paths, opts) {
-  const result = { created: [], updated: [], unchanged: [] };
-  if (!existsSync33(paths.memoriesDir)) return result;
-  const allLoaded = await loadMemoriesFromDir25(paths.memoriesDir);
-  const memories = allLoaded.map((l) => l.memory).filter((m) => !isRetiredMemory3(m.frontmatter, m.body));
-  const sensors = [];
-  for (const m of memories) {
-    const sensor = m.frontmatter.sensor;
-    if (!sensor || sensor.severity !== "block") continue;
-    sensors.push({
-      id: m.frontmatter.id,
-      severity: "block",
-      message: sensor.message,
-      ...sensor.pattern ? { pattern: sensor.pattern } : {},
-      paths: sensor.paths.length > 0 ? sensor.paths : m.frontmatter.anchor.paths
-    });
-  }
-  const maxMemories = Math.max(1, opts.maxMemories ?? 8);
-  const outputs = generateBridges(memories, sensors, { maxMemories, targets: opts.targets });
-  for (const output of outputs) {
-    const targetFile = path15.join(root, output.path);
-    const fileExists = existsSync33(targetFile);
-    if (opts.onlyExisting && !fileExists) continue;
-    if (opts.dryRun) {
-      (fileExists ? result.updated : result.created).push(output.path);
-      continue;
-    }
-    await mkdir10(path15.dirname(targetFile), { recursive: true });
-    if (!fileExists) {
-      await writeFile15(targetFile, output.content, "utf8");
-      result.created.push(output.path);
-      continue;
-    }
-    let existing = (await readFile9(targetFile, "utf8")).replace(/\r\n/g, "\n");
-    const withMemories = replaceMarkerBlock(
-      existing,
-      BRIDGE_MARKERS.memoriesStart,
-      BRIDGE_MARKERS.memoriesEnd,
-      extractMarkerBlock(output.content, BRIDGE_MARKERS.memoriesStart, BRIDGE_MARKERS.memoriesEnd)
-    );
-    const sensorsBlockContent = extractMarkerBlock(
-      output.content,
-      BRIDGE_MARKERS.sensorsStart,
-      BRIDGE_MARKERS.sensorsEnd
-    );
-    const withSensors = sensorsBlockContent ? replaceMarkerBlock(withMemories, BRIDGE_MARKERS.sensorsStart, BRIDGE_MARKERS.sensorsEnd, sensorsBlockContent) : withMemories;
-    if (withSensors === existing) {
-      result.unchanged.push(output.path);
-      continue;
-    }
-    await writeFile15(targetFile, withSensors, "utf8");
-    result.updated.push(output.path);
-  }
-  return result;
-}
-function extractMarkerBlock(text, startMarker, endMarker) {
-  const startIdx = text.indexOf(startMarker);
-  const endIdx = text.indexOf(endMarker);
-  if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) return null;
-  return text.slice(startIdx, endIdx + endMarker.length);
-}
-function replaceMarkerBlock(existing, startMarker, endMarker, replacement) {
-  if (!replacement) return existing;
-  const startIdx = existing.indexOf(startMarker);
-  const endIdx = existing.indexOf(endMarker);
-  if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) {
-    return existing + (existing.endsWith("\n") ? "" : "\n") + "\n" + replacement + "\n";
-  }
-  return existing.slice(0, startIdx) + replacement + existing.slice(endIdx + endMarker.length);
-}
-
-// src/commands/sync.ts
+import { BRIDGE_TARGETS as BRIDGE_TARGETS2 } from "@hiveai/core";
 var BRIDGE_START = "<!-- haive:memories-start -->";
 var BRIDGE_END = "<!-- haive:memories-end -->";
 function registerSync(program2) {
@@ -9645,7 +9642,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 = findProjectRoot12(opts.dir);
     const paths = resolveHaivePaths9(root);
-    if (!existsSync34(paths.memoriesDir)) {
+    if (!existsSync33(paths.memoriesDir)) {
       if (!opts.quiet) ui.warn(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -9664,12 +9661,12 @@ function registerSync(program2) {
     let promoted = 0;
     let autoApproved = 0;
     if (opts.verify !== false) {
-      const memories = await loadMemoriesFromDir26(paths.memoriesDir);
+      const memories = await loadMemoriesFromDir25(paths.memoriesDir);
       for (const { memory: memory2, filePath } of memories) {
         if (memory2.frontmatter.type === "session_recap") {
           if (memory2.frontmatter.status === "stale") {
             if (!dryRun) {
-              await writeFile16(
+              await writeFile15(
                 filePath,
                 serializeMemory13({
                   frontmatter: {
@@ -9694,7 +9691,7 @@ function registerSync(program2) {
         if (result.stale) {
           if (memory2.frontmatter.status !== "stale") {
             if (!dryRun) {
-              await writeFile16(
+              await writeFile15(
                 filePath,
                 serializeMemory13({
                   frontmatter: {
@@ -9712,7 +9709,7 @@ function registerSync(program2) {
           }
         } else if (memory2.frontmatter.status === "stale") {
           if (!dryRun) {
-            await writeFile16(
+            await writeFile15(
               filePath,
               serializeMemory13({
                 frontmatter: {
@@ -9731,7 +9728,7 @@ function registerSync(program2) {
       }
     }
     if (opts.promote !== false) {
-      const memories = await loadMemoriesFromDir26(paths.memoriesDir);
+      const memories = await loadMemoriesFromDir25(paths.memoriesDir);
       const usage = await loadUsageIndex13(paths);
       const nowMs = Date.now();
       for (const { memory: memory2, filePath } of memories) {
@@ -9742,7 +9739,7 @@ function registerSync(program2) {
           maxRejections: DEFAULT_AUTO_PROMOTE_RULE2.maxRejections
         })) {
           if (!dryRun) {
-            await writeFile16(
+            await writeFile15(
               filePath,
               serializeMemory13({ frontmatter: { ...fm, status: "validated" }, body: memory2.body }),
               "utf8"
@@ -9755,7 +9752,7 @@ function registerSync(program2) {
           const ageHours = (nowMs - new Date(fm.created_at).getTime()) / (1e3 * 60 * 60);
           if (ageHours >= autoApproveDelayHours) {
             if (!dryRun) {
-              await writeFile16(
+              await writeFile15(
                 filePath,
                 serializeMemory13({
                   frontmatter: {
@@ -9783,7 +9780,7 @@ function registerSync(program2) {
       for (const repair of repairs) log(ui.dim(`autopilot: ${repair.message}`));
     }
     const sinceReport = opts.since ? collectSinceChanges(root, opts.since) : null;
-    const draftMemories = (await loadMemoriesFromDir26(paths.memoriesDir)).filter(
+    const draftMemories = (await loadMemoriesFromDir25(paths.memoriesDir)).filter(
       (m) => m.memory.frontmatter.status === "draft"
     );
     const draftCount = draftMemories.length;
@@ -9806,14 +9803,14 @@ function registerSync(program2) {
       } else {
         const agentsMd = path16.join(root, "AGENTS.md");
         bridgeTargets = [path16.join(root, "CLAUDE.md")];
-        if (existsSync34(agentsMd)) bridgeTargets.push(agentsMd);
+        if (existsSync33(agentsMd)) bridgeTargets.push(agentsMd);
       }
       for (const bridgeFile of bridgeTargets) {
         await injectBridge(bridgeFile, paths.memoriesDir, maxInject, root, opts.quiet);
       }
     }
     if (opts.noBridges !== true) {
-      const nativeTargets = BRIDGE_TARGETS.filter(
+      const nativeTargets = BRIDGE_TARGETS2.filter(
         (t) => t !== "claude" && t !== "agents"
       );
       try {
@@ -9849,7 +9846,7 @@ function registerSync(program2) {
       }
     }
     if (!opts.quiet) {
-      const allForDecay = await loadMemoriesFromDir26(paths.memoriesDir);
+      const allForDecay = await loadMemoriesFromDir25(paths.memoriesDir);
       const usageForDecay = await loadUsageIndex13(paths);
       const decaying = allForDecay.filter(({ memory: memory2 }) => {
         const fm = memory2.frontmatter;
@@ -9939,7 +9936,7 @@ Wait for **explicit confirmation** before acting.
                 if (!dryRun) {
                   const teamDir = path16.join(paths.memoriesDir, "team");
                   await mkdir11(teamDir, { recursive: true });
-                  await writeFile16(
+                  await writeFile15(
                     path16.join(teamDir, `${fm.id}.md`),
                     serializeMemory13({ frontmatter: { ...fm, requires_human_approval: true }, body }),
                     "utf8"
@@ -10008,7 +10005,7 @@ Wait for **explicit confirmation** before acting.
             if (!dryRun) {
               const teamDir = path16.join(paths.memoriesDir, "team");
               await mkdir11(teamDir, { recursive: true });
-              await writeFile16(
+              await writeFile15(
                 path16.join(teamDir, `${fm.id}.md`),
                 serializeMemory13({ frontmatter: { ...fm, requires_human_approval: true }, body }),
                 "utf8"
@@ -10100,8 +10097,8 @@ function bridgeSummaryLine(body) {
   return oneLine.length > 140 ? oneLine.slice(0, 137) + "\u2026" : oneLine;
 }
 async function injectBridge(bridgeFile, memoriesDir, maxMemories, root, quiet) {
-  if (!existsSync34(memoriesDir)) return;
-  const all = await loadMemoriesFromDir26(memoriesDir);
+  if (!existsSync33(memoriesDir)) return;
+  const all = await loadMemoriesFromDir25(memoriesDir);
   const top = all.filter(({ memory: memory2 }) => {
     const s = memory2.frontmatter.status;
     if (memory2.frontmatter.type === "session_recap") return false;
@@ -10126,7 +10123,7 @@ async function injectBridge(bridgeFile, memoriesDir, maxMemories, root, quiet) {
 ` + block + `
 
 ${BRIDGE_END}`;
-  const fileExists = existsSync34(bridgeFile);
+  const fileExists = existsSync33(bridgeFile);
   let existing = fileExists ? await readFile10(bridgeFile, "utf8") : "";
   existing = existing.replace(/\r\n/g, "\n");
   const startIdx = existing.indexOf(BRIDGE_START);
@@ -10148,7 +10145,7 @@ ${BRIDGE_END}`;
     }
     updated = existing + (existing.endsWith("\n") ? "" : "\n") + "\n" + injected + "\n";
   }
-  await writeFile16(bridgeFile, updated, "utf8");
+  await writeFile15(bridgeFile, updated, "utf8");
   if (!quiet) {
     console.log(
       ui.dim(`bridge: injected ${top.length} memor${top.length === 1 ? "y" : "ies"} into ${path16.relative(root, bridgeFile)}`)
@@ -10176,8 +10173,8 @@ function collectSinceChanges(root, ref) {
 
 // src/commands/memory-add.ts
 import { createHash as createHash2 } from "crypto";
-import { mkdir as mkdir12, readFile as readFile11, writeFile as writeFile17 } from "fs/promises";
-import { existsSync as existsSync35 } from "fs";
+import { mkdir as mkdir12, readFile as readFile11, writeFile as writeFile16 } from "fs/promises";
+import { existsSync as existsSync34 } from "fs";
 import path17 from "path";
 import "commander";
 import {
@@ -10185,7 +10182,7 @@ import {
   findProjectRoot as findProjectRoot13,
   inferModulesFromPaths as inferModulesFromPaths3,
   loadConfig as loadConfig5,
-  loadMemoriesFromDir as loadMemoriesFromDir27,
+  loadMemoriesFromDir as loadMemoriesFromDir26,
   memoryFilePath as memoryFilePath7,
   resolveHaivePaths as resolveHaivePaths10,
   serializeMemory as serializeMemory14,
@@ -10219,7 +10216,7 @@ function registerMemoryAdd(memory2) {
   ).requiredOption("--type <type>", "skill | convention | decision | gotcha | architecture | glossary | attempt").option("--slug <slug>", "short kebab-case identifier used in the file name (auto-derived from --title/--body when omitted)").option("--title <text>", "memory title \u2014 becomes the first heading of the body").option("--scope <scope>", "personal | team | module (default: config default; team in autopilot)").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags for easier retrieval").option("--domain <domain>", "domain (e.g. transactions)").option("--author <author>", "author email or handle").option("--paths <csv>", "anchor to source files \u2014 used for staleness detection by haive sync").option("--files <csv>", "alias for --paths (matches the MCP `files` parameter)").option("--symbols <csv>", "anchor to specific symbols (class/function names)").option("--commit <sha>", "anchor to a specific commit SHA").option("--body <text>", "memory body content (Markdown) \u2014 overrides --title default body").option("--body-file <path>", "read memory body from a Markdown file \u2014 for long content").option("--no-auto-tag", "disable automatic tag suggestions inferred from anchor paths").option("--topic <key>", "stable key for upsert: if a memory with this topic+scope already exists, update it in-place (revision_count++)").option("--activation-keyword <csv>", "skill only: comma-separated keywords that trigger progressive disclosure of this skill").option("--activation-glob <csv>", "skill only: comma-separated path globs that trigger this skill").option("--activation-always", "skill only: always surface this skill (no triggers needed)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot13(opts.dir);
     const paths = resolveHaivePaths10(root);
-    if (!existsSync35(paths.haiveDir)) {
+    if (!existsSync34(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -10236,7 +10233,7 @@ function registerMemoryAdd(memory2) {
     const inferredTags = autoTagsEnabled ? inferModulesFromPaths3(anchorPaths) : [];
     const mergedTags = Array.from(/* @__PURE__ */ new Set([...userTags, ...inferredTags]));
     if (anchorPaths.length > 0) {
-      const missing = anchorPaths.filter((p) => !existsSync35(path17.resolve(root, p)));
+      const missing = anchorPaths.filter((p) => !existsSync34(path17.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}`);
@@ -10249,7 +10246,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 (!existsSync35(opts.bodyFile)) {
+      if (!existsSync34(opts.bodyFile)) {
         ui.error(`--body-file not found: ${opts.bodyFile}`);
         process.exitCode = 1;
         return;
@@ -10265,9 +10262,9 @@ TODO \u2014 write the memory body.
 `;
     }
     const scope = opts.scope ?? config.defaultScope ?? "personal";
-    if (existsSync35(paths.memoriesDir)) {
+    if (existsSync34(paths.memoriesDir)) {
       const incomingHash = createHash2("sha256").update(body.trim()).digest("hex").slice(0, 12);
-      const allForHash = await loadMemoriesFromDir27(paths.memoriesDir);
+      const allForHash = await loadMemoriesFromDir26(paths.memoriesDir);
       const hashDup = allForHash.find(
         ({ memory: memory3 }) => createHash2("sha256").update(memory3.body.trim()).digest("hex").slice(0, 12) === incomingHash && memory3.frontmatter.scope === scope
       );
@@ -10278,8 +10275,8 @@ TODO \u2014 write the memory body.
         return;
       }
     }
-    if (opts.topic && existsSync35(paths.memoriesDir)) {
-      const existing = await loadMemoriesFromDir27(paths.memoriesDir);
+    if (opts.topic && existsSync34(paths.memoriesDir)) {
+      const existing = await loadMemoriesFromDir26(paths.memoriesDir);
       const topicMatch = existing.find(
         ({ memory: memory3 }) => memory3.frontmatter.topic === opts.topic && memory3.frontmatter.scope === scope && (!opts.module || memory3.frontmatter.module === opts.module)
       );
@@ -10299,7 +10296,7 @@ TODO \u2014 write the memory body.
         };
         const suggestedSensor = !newFrontmatter.sensor ? suggestSensorForCliMemory(opts.type, body, newFrontmatter.anchor.paths) : null;
         if (suggestedSensor) newFrontmatter.sensor = suggestedSensor;
-        await writeFile17(topicMatch.filePath, serializeMemory14({ frontmatter: newFrontmatter, body }), "utf8");
+        await writeFile16(topicMatch.filePath, serializeMemory14({ frontmatter: newFrontmatter, body }), "utf8");
         ui.success(`Updated (topic upsert) ${path17.relative(root, topicMatch.filePath)}`);
         ui.info(`id=${fm.id}  revision=${revisionCount}`);
         if (suggestedSensor) ui.info(`sensor=regex warn autogen pattern=${JSON.stringify(suggestedSensor.pattern)}`);
@@ -10325,13 +10322,13 @@ TODO \u2014 write the memory body.
     });
     const file = memoryFilePath7(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
     await mkdir12(path17.dirname(file), { recursive: true });
-    if (existsSync35(file)) {
+    if (existsSync34(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
       return;
     }
-    if (existsSync35(paths.memoriesDir)) {
-      const existing = await loadMemoriesFromDir27(paths.memoriesDir);
+    if (existsSync34(paths.memoriesDir)) {
+      const existing = await loadMemoriesFromDir26(paths.memoriesDir);
       const slugTokens = slug.toLowerCase().split(/[-_\s]+/).filter(Boolean);
       const similar = existing.filter(({ memory: memory3 }) => {
         const id = memory3.frontmatter.id.toLowerCase();
@@ -10342,7 +10339,7 @@ TODO \u2014 write the memory body.
         ui.warn("Consider updating one of these with `haive memory update` instead.");
       }
     }
-    await writeFile17(file, serializeMemory14({ frontmatter, body }), "utf8");
+    await writeFile16(file, serializeMemory14({ frontmatter, body }), "utf8");
     ui.success(`Created ${path17.relative(root, file)}`);
     ui.info(`id=${frontmatter.id}  scope=${frontmatter.scope}  status=${frontmatter.status}`);
     if (frontmatter.sensor?.autogen) {
@@ -10422,14 +10419,14 @@ function slugify(value) {
 }
 
 // src/commands/memory-list.ts
-import { existsSync as existsSync36 } from "fs";
+import { existsSync as existsSync35 } from "fs";
 import path18 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot14, resolveHaivePaths as resolveHaivePaths11 } from "@hiveai/core";
 
 // src/utils/fs.ts
 import {
-  loadMemoriesFromDir as loadMemoriesFromDir28,
+  loadMemoriesFromDir as loadMemoriesFromDir27,
   loadMemory,
   listMarkdownFilesRecursive
 } from "@hiveai/core";
@@ -10439,12 +10436,12 @@ function registerMemoryList(memory2) {
   memory2.command("list").description("List memories with optional filters").option("--scope <scope>", "personal | team | module").option("--type <type>", "filter by type").option("--tag <tag>", "filter by tag").option("--module <name>", "filter by module name").option("--status <csv>", "filter by status (draft,proposed,validated,stale,rejected,deprecated)").option("--show-rejected", "include rejected memories (hidden by default)").option("--limit <n>", "max memories to display").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot14(opts.dir);
     const paths = resolveHaivePaths11(root);
-    if (!existsSync36(paths.memoriesDir)) {
+    if (!existsSync35(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir28(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const statusFilter = opts.status ? opts.status.split(",").map((s) => s.trim()) : null;
     const limit = opts.limit ? Math.max(1, parseInt(opts.limit, 10)) : void 0;
     const filtered = all.filter((m) => {
@@ -10513,8 +10510,8 @@ function matchesFilters(loaded, opts) {
 }
 
 // src/commands/memory-promote.ts
-import { mkdir as mkdir13, unlink as unlink2, writeFile as writeFile18 } from "fs/promises";
-import { existsSync as existsSync37 } from "fs";
+import { mkdir as mkdir13, unlink as unlink2, writeFile as writeFile17 } from "fs/promises";
+import { existsSync as existsSync36 } from "fs";
 import path19 from "path";
 import "commander";
 import {
@@ -10527,12 +10524,12 @@ 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 = findProjectRoot15(opts.dir);
     const paths = resolveHaivePaths12(root);
-    if (!existsSync37(paths.memoriesDir)) {
+    if (!existsSync36(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const teamAndModule = await loadMemoriesFromDir28(paths.memoriesDir);
+    const teamAndModule = await loadMemoriesFromDir27(paths.memoriesDir);
     const alreadyShared = teamAndModule.find(
       (m) => m.memory.frontmatter.id === id && (m.memory.frontmatter.scope === "team" || m.memory.frontmatter.scope === "module")
     );
@@ -10546,7 +10543,7 @@ function registerMemoryPromote(memory2) {
       }
       return;
     }
-    const all = await loadMemoriesFromDir28(paths.personalDir);
+    const all = await loadMemoriesFromDir27(paths.personalDir);
     const found = all.find((m) => m.memory.frontmatter.id === id);
     if (!found) {
       ui.error(`No personal memory with id "${id}". (Promotion only applies to personal scope.)`);
@@ -10563,7 +10560,7 @@ function registerMemoryPromote(memory2) {
     };
     const newPath = memoryFilePath8(paths, "team", updated.frontmatter.id);
     await mkdir13(path19.dirname(newPath), { recursive: true });
-    await writeFile18(newPath, serializeMemory15(updated), "utf8");
+    await writeFile17(newPath, serializeMemory15(updated), "utf8");
     await unlink2(found.filePath);
     ui.success(`Promoted ${id} to team scope (status=proposed)`);
     ui.info(`Now at ${path19.relative(root, newPath)}`);
@@ -10572,8 +10569,8 @@ function registerMemoryPromote(memory2) {
 }
 
 // src/commands/memory-approve.ts
-import { existsSync as existsSync38 } from "fs";
-import { writeFile as writeFile19 } from "fs/promises";
+import { existsSync as existsSync37 } from "fs";
+import { writeFile as writeFile18 } from "fs/promises";
 import path20 from "path";
 import "commander";
 import {
@@ -10585,12 +10582,12 @@ 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 = findProjectRoot16(opts.dir);
     const paths = resolveHaivePaths13(root);
-    if (!existsSync38(paths.memoriesDir)) {
+    if (!existsSync37(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir28(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     if (opts.all || opts.pending) {
       const candidates = all.filter((m) => {
         const s = m.memory.frontmatter.status;
@@ -10607,7 +10604,7 @@ function registerMemoryApprove(memory2) {
           frontmatter: { ...found2.memory.frontmatter, status: "validated" },
           body: found2.memory.body
         };
-        await writeFile19(found2.filePath, serializeMemory16(next2), "utf8");
+        await writeFile18(found2.filePath, serializeMemory16(next2), "utf8");
         count++;
       }
       ui.success(`Approved ${count} memor${count === 1 ? "y" : "ies"} (status=validated)`);
@@ -10636,15 +10633,15 @@ function registerMemoryApprove(memory2) {
       frontmatter: { ...found.memory.frontmatter, status: "validated" },
       body: found.memory.body
     };
-    await writeFile19(found.filePath, serializeMemory16(next), "utf8");
+    await writeFile18(found.filePath, serializeMemory16(next), "utf8");
     ui.success(`Approved ${id} (status=validated)`);
     ui.info(path20.relative(root, found.filePath));
   });
 }
 
 // src/commands/memory-update.ts
-import { readFile as readFile12, writeFile as writeFile20 } from "fs/promises";
-import { existsSync as existsSync39 } from "fs";
+import { readFile as readFile12, writeFile as writeFile19 } from "fs/promises";
+import { existsSync as existsSync38 } from "fs";
 import path21 from "path";
 import "commander";
 import {
@@ -10656,12 +10653,12 @@ function registerMemoryUpdate(memory2) {
   memory2.command("update <id>").description("Update body, tags, or anchor of an existing memory (preserves id and usage history)").option("--type <type>", "change the memory type (convention | decision | gotcha | architecture | glossary | skill | attempt)").option("--title <text>", "new title \u2014 replaces the first heading of the body").option("--body <text>", "new Markdown body \u2014 replaces the existing body").option("--body-file <path>", "read new body from a Markdown file \u2014 for long content").option("--tags <csv>", "new tags, comma-separated \u2014 fully replaces existing tags").option("--paths <csv>", "new anchor paths, comma-separated").option("--files <csv>", "alias for --paths (matches the MCP `files` parameter)").option("--symbols <csv>", "new anchor symbols, comma-separated").option("--commit <sha>", "new anchor commit SHA").option("--domain <domain>", "new domain label").option("--author <author>", "new author handle or email").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
     const root = findProjectRoot17(opts.dir);
     const paths = resolveHaivePaths14(root);
-    if (!existsSync39(paths.memoriesDir)) {
+    if (!existsSync38(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const memories = await loadMemoriesFromDir28(paths.memoriesDir);
+    const memories = await loadMemoriesFromDir27(paths.memoriesDir);
     const loaded = memories.find((m) => m.memory.frontmatter.id === id);
     if (!loaded) {
       ui.error(`No memory with id "${id}".`);
@@ -10698,7 +10695,7 @@ function registerMemoryUpdate(memory2) {
     if (opts.author !== void 0) updated.push("author");
     let newBody;
     if (opts.bodyFile !== void 0) {
-      if (!existsSync39(opts.bodyFile)) {
+      if (!existsSync38(opts.bodyFile)) {
         ui.error(`--body-file not found: ${opts.bodyFile}`);
         process.exitCode = 1;
         return;
@@ -10719,7 +10716,7 @@ function registerMemoryUpdate(memory2) {
       ui.warn("Nothing to update \u2014 provide at least one option.");
       return;
     }
-    await writeFile20(
+    await writeFile19(
       loaded.filePath,
       serializeMemory17({ frontmatter: newFrontmatter, body: newBody }),
       "utf8"
@@ -10743,8 +10740,8 @@ function parseCsv3(value) {
 }
 
 // src/commands/memory-auto-promote.ts
-import { writeFile as writeFile21 } from "fs/promises";
-import { existsSync as existsSync40 } from "fs";
+import { writeFile as writeFile20 } from "fs/promises";
+import { existsSync as existsSync39 } from "fs";
 import path23 from "path";
 import "commander";
 import {
@@ -10764,7 +10761,7 @@ function registerMemoryAutoPromote(memory2) {
   ).option("--apply", "actually write status=validated to disk (default: dry-run)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot18(opts.dir);
     const paths = resolveHaivePaths15(root);
-    if (!existsSync40(paths.memoriesDir)) {
+    if (!existsSync39(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -10773,7 +10770,7 @@ function registerMemoryAutoPromote(memory2) {
       minReads: Number(opts.minReads ?? DEFAULT_AUTO_PROMOTE_RULE3.minReads),
       maxRejections: Number(opts.maxRejections ?? DEFAULT_AUTO_PROMOTE_RULE3.maxRejections)
     };
-    const memories = await loadMemoriesFromDir28(paths.memoriesDir);
+    const memories = await loadMemoriesFromDir27(paths.memoriesDir);
     const usage = await loadUsageIndex14(paths);
     const eligible = memories.filter(
       ({ memory: memory3 }) => isAutoPromoteEligible3(memory3.frontmatter, getUsage12(usage, memory3.frontmatter.id), rule)
@@ -10796,7 +10793,7 @@ function registerMemoryAutoPromote(memory2) {
           frontmatter: { ...mem.frontmatter, status: "validated" },
           body: mem.body
         };
-        await writeFile21(filePath, serializeMemory18(next), "utf8");
+        await writeFile20(filePath, serializeMemory18(next), "utf8");
         written++;
       }
     }
@@ -10807,7 +10804,7 @@ function registerMemoryAutoPromote(memory2) {
 
 // src/commands/memory-edit.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync41 } from "fs";
+import { existsSync as existsSync40 } from "fs";
 import { readFile as readFile13 } from "fs/promises";
 import path24 from "path";
 import "commander";
@@ -10820,12 +10817,12 @@ function registerMemoryEdit(memory2) {
   memory2.command("edit <id>").description("Open a memory in $EDITOR and re-validate when you save").option("-e, --editor <cmd>", "editor command (defaults to $EDITOR or 'vi')").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
     const root = findProjectRoot19(opts.dir);
     const paths = resolveHaivePaths16(root);
-    if (!existsSync41(paths.memoriesDir)) {
+    if (!existsSync40(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir28(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const found = all.find((m) => m.memory.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory with id "${id}".`);
@@ -10860,7 +10857,7 @@ function runEditor(editor, file) {
 }
 
 // src/commands/memory-for-files.ts
-import { existsSync as existsSync43 } from "fs";
+import { existsSync as existsSync41 } from "fs";
 import path25 from "path";
 import "commander";
 import {
@@ -10876,12 +10873,12 @@ function registerMemoryForFiles(memory2) {
   memory2.command("for-files <files...>").description("Show memories relevant to the given files (anchor overlap, module, domain)").option("-d, --dir <dir>", "project root").action(async (files, opts) => {
     const root = findProjectRoot20(opts.dir);
     const paths = resolveHaivePaths17(root);
-    if (!existsSync43(paths.memoriesDir)) {
+    if (!existsSync41(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir28(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const usage = await loadUsageIndex15(paths);
     const inferred = inferModulesFromPaths4(files);
     const byAnchor = [];
@@ -10988,7 +10985,7 @@ function printGroup(root, label, loaded, usage) {
 }
 
 // src/commands/memory-hot.ts
-import { existsSync as existsSync44 } from "fs";
+import { existsSync as existsSync43 } from "fs";
 import path26 from "path";
 import "commander";
 import {
@@ -11003,13 +11000,13 @@ function registerMemoryHot(memory2) {
   ).option("--threshold <n>", "minimum read_count to qualify (default: 3)", "3").option("--status <status>", "limit to one status (default: draft + proposed)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot21(opts.dir);
     const paths = resolveHaivePaths18(root);
-    if (!existsSync44(paths.memoriesDir)) {
+    if (!existsSync43(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
     const threshold = Math.max(1, Number(opts.threshold ?? 3));
-    const all = await loadMemoriesFromDir28(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const usage = await loadUsageIndex16(paths);
     const candidates = all.filter(({ memory: mem }) => {
       const fm = mem.frontmatter;
@@ -11041,8 +11038,8 @@ function registerMemoryHot(memory2) {
 }
 
 // src/commands/memory-tried.ts
-import { mkdir as mkdir14, writeFile as writeFile23 } from "fs/promises";
-import { existsSync as existsSync45 } from "fs";
+import { mkdir as mkdir14, writeFile as writeFile21 } from "fs/promises";
+import { existsSync as existsSync44 } from "fs";
 import path27 from "path";
 import "commander";
 import {
@@ -11072,7 +11069,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("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot22(opts.dir);
     const paths = resolveHaivePaths19(root);
-    if (!existsSync45(paths.haiveDir)) {
+    if (!existsSync44(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -11100,12 +11097,12 @@ function registerMemoryTried(memory2) {
     }
     const file = memoryFilePath9(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
     await mkdir14(path27.dirname(file), { recursive: true });
-    if (existsSync45(file)) {
+    if (existsSync44(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
       return;
     }
-    await writeFile23(file, serializeMemory19({ frontmatter, body }), "utf8");
+    await writeFile21(file, serializeMemory19({ frontmatter, body }), "utf8");
     ui.success(`Recorded: ${path27.relative(root, file)}`);
     ui.info(`id=${frontmatter.id}  type=attempt  status=validated (auto-approved)`);
     if (sensor) ui.info(`sensor=regex warn autogen pattern=${JSON.stringify(sensor.pattern)}`);
@@ -11118,7 +11115,7 @@ function parseCsv4(value) {
 
 // src/commands/memory-seed.ts
 import { readFile as readFile14 } from "fs/promises";
-import { existsSync as existsSync46 } from "fs";
+import { existsSync as existsSync45 } from "fs";
 import path28 from "path";
 import "commander";
 import {
@@ -11158,7 +11155,7 @@ function registerMemorySeed(memory2) {
       }
       return;
     }
-    if (!existsSync46(paths.haiveDir)) {
+    if (!existsSync45(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -11214,7 +11211,7 @@ function registerMemorySeed(memory2) {
 }
 
 // src/commands/memory-pending.ts
-import { existsSync as existsSync47 } from "fs";
+import { existsSync as existsSync46 } from "fs";
 import path29 from "path";
 import "commander";
 import {
@@ -11227,12 +11224,12 @@ function registerMemoryPending(memory2) {
   memory2.command("pending").description("List draft and proposed memories awaiting review (sorted by reads desc).\n\n  draft = created but not yet activated \xB7 proposed = promoted, awaiting team validation").option("--scope <scope>", "filter by scope (personal | team | module)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot24(opts.dir);
     const paths = resolveHaivePaths21(root);
-    if (!existsSync47(paths.memoriesDir)) {
+    if (!existsSync46(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir28(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const usage = await loadUsageIndex17(paths);
     const filterFn = ({ memory: mem }) => {
       if (mem.frontmatter.status !== "proposed" && mem.frontmatter.status !== "draft") return false;
@@ -11285,7 +11282,7 @@ function registerMemoryPending(memory2) {
 }
 
 // src/commands/memory-query.ts
-import { existsSync as existsSync48 } from "fs";
+import { existsSync as existsSync47 } from "fs";
 import path30 from "path";
 import "commander";
 import {
@@ -11302,7 +11299,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 = findProjectRoot25(opts.dir);
     const paths = resolveHaivePaths22(root);
-    if (!existsSync48(paths.memoriesDir)) {
+    if (!existsSync47(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -11313,7 +11310,7 @@ function registerMemoryQuery(memory2) {
       return;
     }
     const statusFilter = opts.status ? opts.status.split(",").map((s) => s.trim()) : null;
-    const all = await loadMemoriesFromDir28(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const passesFilters2 = (mem) => {
       const fm = mem.frontmatter;
       if (opts.scope && fm.scope !== opts.scope) return false;
@@ -11360,8 +11357,8 @@ ${top.length} of ${matches.length} match${matches.length === 1 ? "" : "es"}`)
 }
 
 // src/commands/memory-reject.ts
-import { writeFile as writeFile24 } from "fs/promises";
-import { existsSync as existsSync49 } from "fs";
+import { writeFile as writeFile23 } from "fs/promises";
+import { existsSync as existsSync48 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot26,
@@ -11375,19 +11372,19 @@ 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 = findProjectRoot26(opts.dir);
     const paths = resolveHaivePaths23(root);
-    if (!existsSync49(paths.memoriesDir)) {
+    if (!existsSync48(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const memories = await loadMemoriesFromDir28(paths.memoriesDir);
+    const memories = await loadMemoriesFromDir27(paths.memoriesDir);
     const loaded = memories.find((m) => m.memory.frontmatter.id === id);
     if (!loaded) {
       ui.error(`No memory with id "${id}".`);
       process.exitCode = 1;
       return;
     }
-    await writeFile24(
+    await writeFile23(
       loaded.filePath,
       serializeMemory20({
         frontmatter: {
@@ -11411,7 +11408,7 @@ function registerMemoryReject(memory2) {
 }
 
 // src/commands/memory-rm.ts
-import { existsSync as existsSync50 } from "fs";
+import { existsSync as existsSync49 } from "fs";
 import { unlink as unlink3 } from "fs/promises";
 import path31 from "path";
 import { createInterface as createInterface2 } from "readline/promises";
@@ -11426,12 +11423,12 @@ 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 = findProjectRoot27(opts.dir);
     const paths = resolveHaivePaths24(root);
-    if (!existsSync50(paths.memoriesDir)) {
+    if (!existsSync49(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir28(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const found = all.find((m) => m.memory.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory with id "${id}".`);
@@ -11462,7 +11459,7 @@ function registerMemoryRm(memory2) {
 }
 
 // src/commands/memory-show.ts
-import { existsSync as existsSync51 } from "fs";
+import { existsSync as existsSync50 } from "fs";
 import { readFile as readFile15 } from "fs/promises";
 import path33 from "path";
 import "commander";
@@ -11477,12 +11474,12 @@ 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 = findProjectRoot28(opts.dir);
     const paths = resolveHaivePaths25(root);
-    if (!existsSync51(paths.memoriesDir)) {
+    if (!existsSync50(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir28(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const found = all.find((m) => m.memory.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory with id "${id}".`);
@@ -11521,7 +11518,7 @@ function registerMemoryShow(memory2) {
 }
 
 // src/commands/memory-stats.ts
-import { existsSync as existsSync53 } from "fs";
+import { existsSync as existsSync51 } from "fs";
 import path34 from "path";
 import "commander";
 import {
@@ -11535,12 +11532,12 @@ 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("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot29(opts.dir);
     const paths = resolveHaivePaths26(root);
-    if (!existsSync53(paths.memoriesDir)) {
+    if (!existsSync51(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir28(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const usage = await loadUsageIndex21(paths);
     const target = opts.id ? all.filter((m) => m.memory.frontmatter.id === opts.id) : all;
     if (target.length === 0) {
@@ -11566,7 +11563,7 @@ function registerMemoryStats(memory2) {
 }
 
 // src/commands/memory-impact.ts
-import { existsSync as existsSync54 } from "fs";
+import { existsSync as existsSync53 } from "fs";
 import "commander";
 import {
   compareImpact,
@@ -11583,12 +11580,12 @@ 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 = findProjectRoot30(opts.dir);
     const paths = resolveHaivePaths27(root);
-    if (!existsSync54(paths.memoriesDir)) {
+    if (!existsSync53(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir28(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const usageIndex = await loadUsageIndex23(paths);
     let rows = all.filter((m) => !opts.id || m.memory.frontmatter.id === opts.id).map(({ memory: mem }) => {
       const fm = mem.frontmatter;
@@ -11654,8 +11651,8 @@ function pad(value, width) {
 }
 
 // src/commands/memory-feedback.ts
-import { existsSync as existsSync55 } from "fs";
-import { writeFile as writeFile25 } from "fs/promises";
+import { existsSync as existsSync54 } from "fs";
+import { writeFile as writeFile24 } from "fs/promises";
 import "commander";
 import {
   applyFeedbackAdjustment as applyFeedbackAdjustment2,
@@ -11681,12 +11678,12 @@ function registerMemoryFeedback(memory2) {
     }
     const root = findProjectRoot31(opts.dir);
     const paths = resolveHaivePaths28(root);
-    if (!existsSync55(paths.memoriesDir)) {
+    if (!existsSync54(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir28(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const target = all.find((m) => m.memory.frontmatter.id === id);
     if (!target) {
       ui.error(`No memory with id '${id}'.`);
@@ -11703,7 +11700,7 @@ function registerMemoryFeedback(memory2) {
     const adjustedFrontmatter = applyFeedbackAdjustment2(target.memory.frontmatter, adjustment);
     if (adjustedFrontmatter !== target.memory.frontmatter) {
       target.memory.frontmatter = adjustedFrontmatter;
-      await writeFile25(target.filePath, serializeMemory21(target.memory), "utf8");
+      await writeFile24(target.filePath, serializeMemory21(target.memory), "utf8");
     }
     const impact = computeImpact4(target.memory.frontmatter, usage);
     if (opts.json) {
@@ -11721,8 +11718,8 @@ function registerMemoryFeedback(memory2) {
 }
 
 // src/commands/memory-verify.ts
-import { writeFile as writeFile26 } from "fs/promises";
-import { existsSync as existsSync56 } from "fs";
+import { writeFile as writeFile25 } from "fs/promises";
+import { existsSync as existsSync55 } from "fs";
 import path35 from "path";
 import "commander";
 import {
@@ -11737,7 +11734,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 = findProjectRoot32(opts.dir);
     const paths = resolveHaivePaths29(root);
-    if (!existsSync56(paths.memoriesDir)) {
+    if (!existsSync55(paths.memoriesDir)) {
       if (opts.json) {
         console.log(JSON.stringify({ error: "not-initialized", root }, null, 2));
       } else {
@@ -11746,7 +11743,7 @@ function registerMemoryVerify(memory2) {
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir28(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const targets = opts.id ? all.filter((m) => m.memory.frontmatter.id === opts.id) : all;
     if (opts.id && targets.length === 0) {
       if (opts.json) {
@@ -11795,7 +11792,7 @@ function registerMemoryVerify(memory2) {
       }
       if (opts.update) {
         const next = applyVerification2(mem, result);
-        await writeFile26(filePath, serializeMemory23(next), "utf8");
+        await writeFile25(filePath, serializeMemory23(next), "utf8");
         updated++;
       }
     }
@@ -11858,7 +11855,7 @@ function applyVerification2(mem, result) {
 
 // src/commands/memory-import.ts
 import { readFile as readFile16 } from "fs/promises";
-import { existsSync as existsSync57 } from "fs";
+import { existsSync as existsSync56 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot33,
@@ -11870,12 +11867,12 @@ function registerMemoryImport(memory2) {
   ).requiredOption("--from <file>", "Markdown/text file to import from").option("--scope <scope>", "personal | team (default: team)", "team").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot33(opts.dir);
     const paths = resolveHaivePaths30(root);
-    if (!existsSync57(paths.haiveDir)) {
+    if (!existsSync56(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    if (!existsSync57(opts.from)) {
+    if (!existsSync56(opts.from)) {
       ui.error(`File not found: ${opts.from}`);
       process.exitCode = 1;
       return;
@@ -11908,8 +11905,8 @@ function registerMemoryImport(memory2) {
 }
 
 // src/commands/memory-import-changelog.ts
-import { existsSync as existsSync58 } from "fs";
-import { readFile as readFile17, mkdir as mkdir15, writeFile as writeFile27 } from "fs/promises";
+import { existsSync as existsSync57 } from "fs";
+import { readFile as readFile17, mkdir as mkdir15, writeFile as writeFile26 } from "fs/promises";
 import path36 from "path";
 import "commander";
 import {
@@ -11983,7 +11980,7 @@ function registerMemoryImportChangelog(memory2) {
     const root = findProjectRoot34(opts.dir);
     const paths = resolveHaivePaths31(root);
     const changelogPath = path36.resolve(root, opts.fromChangelog);
-    if (!existsSync58(changelogPath)) {
+    if (!existsSync57(changelogPath)) {
       ui.error(`CHANGELOG not found: ${changelogPath}`);
       process.exitCode = 1;
       return;
@@ -12046,7 +12043,7 @@ function registerMemoryImportChangelog(memory2) {
         paths: [path36.relative(root, changelogPath)],
         topic: `changelog-${pkgName}-${entry.version}`
       });
-      await writeFile27(
+      await writeFile26(
         path36.join(teamDir, `${fm.id}.md`),
         serializeMemory24({ frontmatter: fm, body: lines.join("\n") }),
         "utf8"
@@ -12070,15 +12067,15 @@ ${ui.bold(`Imported ${saved} changelog entr${saved === 1 ? "y" : "ies"} from ${p
 }
 
 // src/commands/memory-digest.ts
-import { existsSync as existsSync59 } from "fs";
-import { writeFile as writeFile28 } from "fs/promises";
+import { existsSync as existsSync58 } from "fs";
+import { writeFile as writeFile27 } from "fs/promises";
 import path37 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence12,
   findProjectRoot as findProjectRoot35,
   getUsage as getUsage20,
-  loadMemoriesFromDir as loadMemoriesFromDir29,
+  loadMemoriesFromDir as loadMemoriesFromDir28,
   loadUsageIndex as loadUsageIndex25,
   resolveHaivePaths as resolveHaivePaths32
 } from "@hiveai/core";
@@ -12095,7 +12092,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 = findProjectRoot35(opts.dir);
     const paths = resolveHaivePaths32(root);
-    if (!existsSync59(paths.memoriesDir)) {
+    if (!existsSync58(paths.memoriesDir)) {
       ui.error("No .ai/memories found. Run `haive init` first.");
       process.exitCode = 1;
       return;
@@ -12103,7 +12100,7 @@ function registerMemoryDigest(program2) {
     const days = Math.max(1, Number(opts.days ?? 7));
     const scopeFilter = opts.scope ?? "team";
     const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1e3);
-    const all = await loadMemoriesFromDir29(paths.memoriesDir);
+    const all = await loadMemoriesFromDir28(paths.memoriesDir);
     const usage = await loadUsageIndex25(paths);
     const recent = all.filter(({ memory: mem }) => {
       const fm = mem.frontmatter;
@@ -12168,7 +12165,7 @@ function registerMemoryDigest(program2) {
     const digest = lines.join("\n");
     if (opts.out) {
       const outPath = path37.resolve(process.cwd(), opts.out);
-      await writeFile28(outPath, digest, "utf8");
+      await writeFile27(outPath, digest, "utf8");
       ui.success(`Digest written to ${opts.out}  (${recent.length} memor${recent.length === 1 ? "y" : "ies"})`);
     } else {
       console.log(digest);
@@ -12177,15 +12174,15 @@ function registerMemoryDigest(program2) {
 }
 
 // src/commands/session-end.ts
-import { writeFile as writeFile29, mkdir as mkdir16, readFile as readFile18, rm as rm2 } from "fs/promises";
-import { existsSync as existsSync60 } from "fs";
+import { writeFile as writeFile28, mkdir as mkdir16, readFile as readFile18, rm as rm2 } from "fs/promises";
+import { existsSync as existsSync59 } from "fs";
 import { spawn as spawn4 } from "child_process";
 import path38 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter10,
   findProjectRoot as findProjectRoot36,
-  loadMemoriesFromDir as loadMemoriesFromDir30,
+  loadMemoriesFromDir as loadMemoriesFromDir29,
   loadPreventionEvents as loadPreventionEvents2,
   loadUsageIndex as loadUsageIndex26,
   memoryFilePath as memoryFilePath10,
@@ -12196,7 +12193,7 @@ import {
 } from "@hiveai/core";
 async function buildAutoRecap(paths) {
   const obsFile = path38.join(paths.haiveDir, ".cache", "observations.jsonl");
-  if (!existsSync60(obsFile)) return await buildGitAutoRecap(paths);
+  if (!existsSync59(obsFile)) return await buildGitAutoRecap(paths);
   const raw = await readFile18(obsFile, "utf8").catch(() => "");
   if (!raw.trim()) return await buildGitAutoRecap(paths);
   const lines = raw.split("\n").filter(Boolean);
@@ -12365,7 +12362,7 @@ function runGit(cwd, args) {
 }
 async function observationStart(paths) {
   const obsFile = path38.join(paths.haiveDir, ".cache", "observations.jsonl");
-  if (!existsSync60(obsFile)) return null;
+  if (!existsSync59(obsFile)) return null;
   const raw = await readFile18(obsFile, "utf8").catch(() => "");
   let first = null;
   for (const line of raw.split("\n")) {
@@ -12381,7 +12378,7 @@ async function observationStart(paths) {
 }
 async function printCaughtForYou(paths, since, quiet) {
   if (quiet) return;
-  const memories = existsSync60(paths.memoriesDir) ? await loadMemoriesFromDir30(paths.memoriesDir) : [];
+  const memories = existsSync59(paths.memoriesDir) ? await loadMemoriesFromDir29(paths.memoriesDir) : [];
   const usage = await loadUsageIndex26(paths);
   const events = await loadPreventionEvents2(paths);
   const summary = summarizeCaughtForYou(events, memories, usage, {
@@ -12419,7 +12416,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)").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 = findProjectRoot36(opts.dir);
     const paths = resolveHaivePaths33(root);
-    if (!existsSync60(paths.haiveDir)) {
+    if (!existsSync59(paths.haiveDir)) {
       if (opts.auto || opts.quiet) return;
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
@@ -12453,7 +12450,7 @@ function registerSessionEnd(session2) {
     });
     const topic = recapTopic2(scope, opts.module);
     const filesTouched = parseCsv5(resolvedFiles).map((p) => normalizeAnchorPath(root, p));
-    const missingPaths = filesTouched.filter((p) => !existsSync60(path38.resolve(root, p)));
+    const missingPaths = filesTouched.filter((p) => !existsSync59(path38.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}`);
@@ -12461,11 +12458,11 @@ function registerSessionEnd(session2) {
     const cleanupObservations = async () => {
       if (!opts.auto) return;
       const obsFile = path38.join(paths.haiveDir, ".cache", "observations.jsonl");
-      if (existsSync60(obsFile)) await rm2(obsFile).catch(() => {
+      if (existsSync59(obsFile)) await rm2(obsFile).catch(() => {
       });
     };
-    if (existsSync60(paths.memoriesDir)) {
-      const existing = await loadMemoriesFromDir30(paths.memoriesDir);
+    if (existsSync59(paths.memoriesDir)) {
+      const existing = await loadMemoriesFromDir29(paths.memoriesDir);
       const topicMatch = existing.find(
         ({ memory: memory2 }) => memory2.frontmatter.topic === topic && memory2.frontmatter.scope === scope && (!opts.module || memory2.frontmatter.module === opts.module)
       );
@@ -12481,7 +12478,7 @@ function registerSessionEnd(session2) {
             paths: filesTouched.length ? filesTouched : fm.anchor.paths
           }
         };
-        await writeFile29(topicMatch.filePath, serializeMemory25({ frontmatter: newFrontmatter, body }), "utf8");
+        await writeFile28(topicMatch.filePath, serializeMemory25({ frontmatter: newFrontmatter, body }), "utf8");
         await cleanupObservations();
         if (!opts.quiet) {
           ui.success(`Session recap updated (revision #${revisionCount})`);
@@ -12504,7 +12501,7 @@ function registerSessionEnd(session2) {
     });
     const file = memoryFilePath10(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
     await mkdir16(path38.dirname(file), { recursive: true });
-    await writeFile29(file, serializeMemory25({ frontmatter, body }), "utf8");
+    await writeFile28(file, serializeMemory25({ frontmatter, body }), "utf8");
     await cleanupObservations();
     if (!opts.quiet) {
       ui.success(`Session recap created`);
@@ -12528,7 +12525,7 @@ function normalizeAnchorPath(root, filePath) {
 }
 
 // src/commands/snapshot.ts
-import { existsSync as existsSync61 } from "fs";
+import { existsSync as existsSync60 } from "fs";
 import { readdir as readdir4 } from "fs/promises";
 import path39 from "path";
 import "commander";
@@ -12563,14 +12560,14 @@ function registerSnapshot(program2) {
   ).option("--diff", "compare the contract against its stored snapshot").option("--list", "list all stored contract snapshots").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot37(opts.dir);
     const paths = resolveHaivePaths34(root);
-    if (!existsSync61(paths.haiveDir)) {
+    if (!existsSync60(paths.haiveDir)) {
       ui.error("No .ai/ found. Run `haive init` first.");
       process.exitCode = 1;
       return;
     }
     if (opts.list) {
       const contractsDir = path39.join(paths.haiveDir, "contracts");
-      if (!existsSync61(contractsDir)) {
+      if (!existsSync60(contractsDir)) {
         console.log(ui.dim("No contract snapshots found."));
         return;
       }
@@ -12694,15 +12691,15 @@ function detectFormat(filePath) {
 }
 
 // src/commands/hub.ts
-import { existsSync as existsSync63 } from "fs";
-import { mkdir as mkdir17, readFile as readFile19, writeFile as writeFile30, copyFile } from "fs/promises";
+import { existsSync as existsSync61 } from "fs";
+import { mkdir as mkdir17, readFile as readFile19, writeFile as writeFile29, copyFile } from "fs/promises";
 import path40 from "path";
 import { spawnSync as spawnSync5 } from "child_process";
 import "commander";
 import {
   findProjectRoot as findProjectRoot38,
   loadConfig as loadConfig8,
-  loadMemoriesFromDir as loadMemoriesFromDir31,
+  loadMemoriesFromDir as loadMemoriesFromDir30,
   resolveHaivePaths as resolveHaivePaths35,
   saveConfig as saveConfig3,
   serializeMemory as serializeMemory26
@@ -12728,7 +12725,7 @@ function registerHub(program2) {
     }
     const sharedDir = path40.join(absPath, ".ai", "memories", "shared");
     await mkdir17(sharedDir, { recursive: true });
-    await writeFile30(
+    await writeFile29(
       path40.join(absPath, ".ai", "README.md"),
       `# hAIve Team Knowledge Hub
 
@@ -12750,7 +12747,7 @@ haive hub pull   # import into a project
 `,
       "utf8"
     );
-    await writeFile30(
+    await writeFile29(
       path40.join(absPath, ".gitignore"),
       ".ai/.cache/\n.ai/memories/personal/\n",
       "utf8"
@@ -12796,7 +12793,7 @@ Next steps:
       return;
     }
     const hubRoot = path40.resolve(root, config.hubPath);
-    if (!existsSync63(hubRoot)) {
+    if (!existsSync61(hubRoot)) {
       ui.error(`Hub not found at ${hubRoot}. Run \`haive hub init ${config.hubPath}\` first.`);
       process.exitCode = 1;
       return;
@@ -12804,7 +12801,7 @@ Next steps:
     const projectName = path40.basename(root);
     const destDir = path40.join(hubRoot, ".ai", "memories", "shared", projectName);
     await mkdir17(destDir, { recursive: true });
-    const all = await loadMemoriesFromDir31(paths.memoriesDir);
+    const all = await loadMemoriesFromDir30(paths.memoriesDir);
     const shared = all.filter(
       ({ memory: memory2 }) => memory2.frontmatter.scope === "shared" && memory2.frontmatter.status !== "rejected" && memory2.frontmatter.status !== "deprecated" && // Don't push imported memories (avoid echo loops)
       !memory2.frontmatter.tags.some((t) => t.startsWith("cross-repo:"))
@@ -12822,7 +12819,7 @@ Next steps:
       const fm = memory2.frontmatter;
       const fileName = `${fm.id}.md`;
       const destPath = path40.join(destDir, fileName);
-      await writeFile30(destPath, serializeMemory26(memory2), "utf8");
+      await writeFile29(destPath, serializeMemory26(memory2), "utf8");
       pushed++;
     }
     console.log(ui.green(`\u2713 Pushed ${pushed} shared memor${pushed === 1 ? "y" : "ies"} to hub`));
@@ -12866,7 +12863,7 @@ Next steps:
     }
     const hubRoot = path40.resolve(root, config.hubPath);
     const hubSharedDir = path40.join(hubRoot, ".ai", "memories", "shared");
-    if (!existsSync63(hubSharedDir)) {
+    if (!existsSync61(hubSharedDir)) {
       ui.warn("Hub has no shared memories yet. Run `haive hub push` from other projects first.");
       return;
     }
@@ -12921,7 +12918,7 @@ Next steps:
       `  hubPath: ${config.hubPath ? ui.green(config.hubPath) : ui.dim("not configured")}`
     );
     const sharedDir = path40.join(paths.memoriesDir, "shared");
-    if (existsSync63(sharedDir)) {
+    if (existsSync61(sharedDir)) {
       const { readdir: readdir7 } = await import("fs/promises");
       const sources = (await readdir7(sharedDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
       console.log(`
@@ -12933,7 +12930,7 @@ Next steps:
     } else {
       console.log(ui.dim("  No imported shared memories yet."));
     }
-    const all = await loadMemoriesFromDir31(paths.memoriesDir);
+    const all = await loadMemoriesFromDir30(paths.memoriesDir);
     const outgoing = all.filter(
       ({ memory: memory2 }) => memory2.frontmatter.scope === "shared" && !memory2.frontmatter.tags.some((t) => t.startsWith("cross-repo:"))
     );
@@ -12943,20 +12940,20 @@ Next steps:
       console.log(ui.dim("  Run `haive hub push` to publish them to the hub."));
     }
     void readFile19;
-    void writeFile30;
+    void writeFile29;
     void saveConfig3;
   });
 }
 
 // src/commands/stats.ts
 import "commander";
-import { existsSync as existsSync64 } from "fs";
-import { mkdir as mkdir18, writeFile as writeFile31 } from "fs/promises";
+import { existsSync as existsSync63 } from "fs";
+import { mkdir as mkdir18, writeFile as writeFile30 } from "fs/promises";
 import path41 from "path";
 import {
   aggregateUsage,
   findProjectRoot as findProjectRoot39,
-  loadMemoriesFromDir as loadMemoriesFromDir33,
+  loadMemoriesFromDir as loadMemoriesFromDir31,
   loadUsageIndex as loadUsageIndex27,
   parseSince,
   readUsageEvents as readUsageEvents2,
@@ -13028,8 +13025,8 @@ async function writeRoiReport(paths, root, sinceRaw, outRelative) {
   const size = await usageLogSize(paths);
   let events = await readUsageEvents2(paths);
   let memoryCount = { team: 0, personal: 0, total_skipped_session: 0 };
-  if (existsSync64(paths.memoriesDir)) {
-    const mems = await loadMemoriesFromDir33(paths.memoriesDir);
+  if (existsSync63(paths.memoriesDir)) {
+    const mems = await loadMemoriesFromDir31(paths.memoriesDir);
     for (const { memory: memory2 } of mems) {
       const fm = memory2.frontmatter;
       if (fm.type === "session_recap") memoryCount.total_skipped_session++;
@@ -13071,7 +13068,7 @@ async function writeRoiReport(paths, root, sinceRaw, outRelative) {
     top_memory_reads: memoryHitsLeader,
     roi_hints: roiHints
   };
-  await writeFile31(outAbs, JSON.stringify(payload, null, 2), "utf8");
+  await writeFile30(outAbs, JSON.stringify(payload, null, 2), "utf8");
   ui.success(`Wrote ROI / usage rollup \u2192 ${outAbs}`);
 }
 async function renderMemoryHits(paths, opts) {
@@ -13248,8 +13245,8 @@ function summarize(name, t0, payload, notes) {
 }
 
 // src/commands/benchmark.ts
-import { existsSync as existsSync65 } from "fs";
-import { readdir as readdir5, readFile as readFile20, writeFile as writeFile33 } from "fs/promises";
+import { existsSync as existsSync64 } from "fs";
+import { readdir as readdir5, readFile as readFile20, writeFile as writeFile31 } from "fs/promises";
 import path43 from "path";
 import "commander";
 import { estimateTokens as estimateTokens4, findProjectRoot as findProjectRoot41 } from "@hiveai/core";
@@ -13266,7 +13263,7 @@ function registerBenchmark(program2) {
     const markdown = renderMarkdown(root, summary, rows);
     if (opts.out) {
       const outFile = path43.isAbsolute(opts.out) ? opts.out : path43.join(root, opts.out);
-      await writeFile33(outFile, markdown, "utf8");
+      await writeFile31(outFile, markdown, "utf8");
       ui.success(`wrote ${path43.relative(process.cwd(), outFile)}`);
       return;
     }
@@ -13296,14 +13293,14 @@ function resolveBenchmarkRoot(dir) {
   return path43.join(projectRoot, candidate);
 }
 async function collectRows(root) {
-  if (!existsSync65(root)) throw new Error(`Benchmark directory not found: ${root}`);
+  if (!existsSync64(root)) throw new Error(`Benchmark directory not found: ${root}`);
   const entries = await readdir5(root, { withFileTypes: true });
   const rows = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     const fixtureDir = path43.join(root, entry.name);
     const reportFile = path43.join(fixtureDir, "BENCHMARK_AGENT_REPORT.md");
-    if (!existsSync65(reportFile)) continue;
+    if (!existsSync64(reportFile)) continue;
     const report = await readFile20(reportFile, "utf8");
     rows.push(parseAgentReport(entry.name, report));
   }
@@ -13393,8 +13390,8 @@ function escapeRegExp(value) {
 }
 
 // src/commands/eval.ts
-import { mkdir as mkdir19, readFile as readFile21, writeFile as writeFile34 } from "fs/promises";
-import { existsSync as existsSync66 } from "fs";
+import { mkdir as mkdir19, readFile as readFile21, writeFile as writeFile33 } from "fs/promises";
+import { existsSync as existsSync65 } from "fs";
 import path44 from "path";
 import "commander";
 import {
@@ -13422,7 +13419,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 = findProjectRoot42(opts.dir);
     const paths = resolveHaivePaths38(root);
-    if (!existsSync66(paths.memoriesDir)) {
+    if (!existsSync65(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -13501,13 +13498,13 @@ function registerEval(program2) {
         gate_precision: gatePrecision
       };
       await mkdir19(path44.dirname(baselineFile), { recursive: true });
-      await writeFile34(baselineFile, JSON.stringify(snapshot, null, 2), "utf8");
+      await writeFile33(baselineFile, JSON.stringify(snapshot, null, 2), "utf8");
       if (!opts.json) ui.success(`Saved baseline (score ${report.score}/100) \u2192 ${path44.relative(root, baselineFile)}`);
     }
     let delta = null;
     let gateDelta = null;
     if (opts.compare || opts.regressionGate) {
-      if (!existsSync66(baselineFile)) {
+      if (!existsSync65(baselineFile)) {
         if (opts.regressionGate) {
           if (!opts.json) ui.info(`No baseline at ${path44.relative(root, baselineFile)} \u2014 regression gate skipped. Run \`haive eval --baseline\` to enable it.`);
         } else {
@@ -13545,7 +13542,7 @@ function registerEval(program2) {
     const md = renderMarkdown2(root, k, resolvedSpec.source, report, gatePrecision);
     if (opts.out) {
       const outFile = path44.isAbsolute(opts.out) ? opts.out : path44.join(root, opts.out);
-      await writeFile34(outFile, md, "utf8");
+      await writeFile33(outFile, md, "utf8");
       ui.success(`wrote ${path44.relative(process.cwd(), outFile)}`);
     } else {
       console.log(md);
@@ -13632,10 +13629,10 @@ async function resolveSpec(opts, root, memoriesDir) {
     return { spec: JSON.parse(raw), source: file };
   }
   const defaultSpec = path44.join(root, ".ai", "eval", "spec.json");
-  if (existsSync66(defaultSpec)) {
+  if (existsSync65(defaultSpec)) {
     const raw = await readFile21(defaultSpec, "utf8");
     const explicit = JSON.parse(raw);
-    const memories2 = await loadMemoriesFromDir28(memoriesDir);
+    const memories2 = await loadMemoriesFromDir27(memoriesDir);
     const synthesized = synthesizeSelfEvalCases(memories2, { includeFiles: !opts.semanticOnly });
     return {
       spec: {
@@ -13645,7 +13642,7 @@ async function resolveSpec(opts, root, memoriesDir) {
       source: ".ai/eval/spec.json + synthesized anchored retrieval"
     };
   }
-  const memories = await loadMemoriesFromDir28(memoriesDir);
+  const memories = await loadMemoriesFromDir27(memoriesDir);
   return {
     spec: { retrieval: synthesizeSelfEvalCases(memories, { includeFiles: !opts.semanticOnly }) },
     source: "synthesized anchored retrieval"
@@ -13743,8 +13740,8 @@ function renderMarkdown2(root, k, source, report, gatePrecision) {
 }
 
 // src/commands/memory-suggest.ts
-import { mkdir as mkdir20, writeFile as writeFile35 } from "fs/promises";
-import { existsSync as existsSync67 } from "fs";
+import { mkdir as mkdir20, writeFile as writeFile34 } from "fs/promises";
+import { existsSync as existsSync66 } from "fs";
 import path45 from "path";
 import "commander";
 import {
@@ -13752,7 +13749,7 @@ import {
   buildFrontmatter as buildFrontmatter11,
   findProjectRoot as findProjectRoot43,
   loadConfig as loadConfig10,
-  loadMemoriesFromDir as loadMemoriesFromDir34,
+  loadMemoriesFromDir as loadMemoriesFromDir33,
   memoryFilePath as memoryFilePath11,
   parseSince as parseSince2,
   readUsageEvents as readUsageEvents3,
@@ -13823,7 +13820,7 @@ function registerMemorySuggest(memory2) {
       }
       const created = [];
       const skipped = [];
-      const existing = existsSync67(paths.memoriesDir) ? await loadMemoriesFromDir34(paths.memoriesDir) : [];
+      const existing = existsSync66(paths.memoriesDir) ? await loadMemoriesFromDir33(paths.memoriesDir) : [];
       for (const s of top) {
         const slug = slugify2(s.query);
         if (!slug) {
@@ -13847,11 +13844,11 @@ function registerMemorySuggest(memory2) {
         const body = renderTemplate(s, fm.id, status);
         const file = memoryFilePath11(paths, fm.scope, fm.id, fm.module);
         await mkdir20(path45.dirname(file), { recursive: true });
-        if (existsSync67(file)) {
+        if (existsSync66(file)) {
           skipped.push({ query: s.query, reason: `file already exists at ${path45.relative(root, file)}` });
           continue;
         }
-        await writeFile35(file, serializeMemory27({ frontmatter: fm, body }), "utf8");
+        await writeFile34(file, serializeMemory27({ frontmatter: fm, body }), "utf8");
         created.push({ id: fm.id, file: path45.relative(root, file), query: s.query });
       }
       if (opts.json) {
@@ -13950,8 +13947,8 @@ function truncate2(text, max) {
 }
 
 // src/commands/memory-archive.ts
-import { existsSync as existsSync68 } from "fs";
-import { writeFile as writeFile36 } from "fs/promises";
+import { existsSync as existsSync67 } from "fs";
+import { writeFile as writeFile35 } from "fs/promises";
 import path46 from "path";
 import "commander";
 import {
@@ -13959,7 +13956,7 @@ import {
   getUsage as getUsage21,
   retirementSignal as retirementSignal2,
   loadConfig as loadConfig11,
-  loadMemoriesFromDir as loadMemoriesFromDir35,
+  loadMemoriesFromDir as loadMemoriesFromDir34,
   loadUsageIndex as loadUsageIndex29,
   resolveHaivePaths as resolveHaivePaths40,
   serializeMemory as serializeMemory28
@@ -13971,7 +13968,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 = findProjectRoot44(opts.dir);
     const paths = resolveHaivePaths40(root);
-    if (!existsSync68(paths.memoriesDir)) {
+    if (!existsSync67(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -13985,7 +13982,7 @@ function registerMemoryArchive(memory2) {
       return;
     }
     const cutoff = Date.now() - minDays * MS_PER_DAY2;
-    const all = await loadMemoriesFromDir35(paths.memoriesDir);
+    const all = await loadMemoriesFromDir34(paths.memoriesDir);
     const usage = await loadUsageIndex29(paths);
     const typeFilter = opts.type === "all" ? null : opts.type ?? "attempt";
     const candidates = [];
@@ -13996,7 +13993,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) => !existsSync68(path46.join(paths.root, p)));
+      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync67(path46.join(paths.root, p)));
       const isAnchorless = !hasAnyAnchor;
       if (!retired.retired && !opts.unread && !isAnchorless && !allPathsGone) continue;
       const u = getUsage21(usage, fm.id);
@@ -14045,7 +14042,7 @@ function registerMemoryArchive(memory2) {
       if (!found) continue;
       const fm = { ...found.memory.frontmatter, status: "deprecated" };
       try {
-        await writeFile36(c.filePath, serializeMemory28({ frontmatter: fm, body: found.memory.body }), "utf8");
+        await writeFile35(c.filePath, serializeMemory28({ frontmatter: fm, body: found.memory.body }), "utf8");
         archived++;
       } catch (err) {
         if (!opts.json) {
@@ -14071,8 +14068,8 @@ function parseDays(input) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync69, statSync as statSync2 } from "fs";
-import { readFile as readFile23, stat, writeFile as writeFile37 } from "fs/promises";
+import { existsSync as existsSync68, statSync as statSync2 } from "fs";
+import { readFile as readFile23, stat, writeFile as writeFile36 } from "fs/promises";
 import path47 from "path";
 import { execFileSync, execSync as execSync3 } from "child_process";
 import "commander";
@@ -14083,7 +14080,7 @@ import {
   isStackPackSeed as isStackPackSeed2,
   loadCodeMap as loadCodeMap7,
   loadConfig as loadConfig12,
-  loadMemoriesFromDir as loadMemoriesFromDir36,
+  loadMemoriesFromDir as loadMemoriesFromDir35,
   loadUsageIndex as loadUsageIndex30,
   readUsageEvents as readUsageEvents4,
   resolveHaivePaths as resolveHaivePaths41
@@ -14098,7 +14095,7 @@ function registerDoctor(program2) {
     const findings = [];
     const repairs = [];
     const config = await loadConfig12(paths);
-    if (!existsSync69(paths.haiveDir)) {
+    if (!existsSync68(paths.haiveDir)) {
       findings.push({
         severity: "error",
         code: "not-initialized",
@@ -14119,7 +14116,7 @@ function registerDoctor(program2) {
         })
       );
     }
-    if (!existsSync69(paths.projectContext)) {
+    if (!existsSync68(paths.projectContext)) {
       findings.push({
         severity: "warn",
         code: "no-project-context",
@@ -14148,7 +14145,7 @@ function registerDoctor(program2) {
         });
       }
     }
-    const memories = existsSync69(paths.memoriesDir) ? await loadMemoriesFromDir36(paths.memoriesDir) : [];
+    const memories = existsSync68(paths.memoriesDir) ? await loadMemoriesFromDir35(paths.memoriesDir) : [];
     const now = Date.now();
     if (memories.length === 0) {
       findings.push({
@@ -14300,7 +14297,7 @@ function registerDoctor(program2) {
     if (config.enforcement?.requireBriefingFirst) {
       const claudeSettings = path47.join(root, ".claude", "settings.local.json");
       let hasClaudeEnforcement = false;
-      if (existsSync69(claudeSettings)) {
+      if (existsSync68(claudeSettings)) {
         try {
           const { readFile: readFile28 } = await import("fs/promises");
           const raw = await readFile28(claudeSettings, "utf8");
@@ -14326,7 +14323,7 @@ function registerDoctor(program2) {
         fix: "Edit .ai/haive.config.json: set autoSessionEnd: true (or re-run `haive init` without --manual)."
       });
     }
-    findings.push(...await collectInstallFindings(root, "0.18.0"));
+    findings.push(...await collectInstallFindings(root, "0.19.0"));
     findings.push(...await collectToolchainFindings(root));
     try {
       const legacyRaw = execSync3("haive-mcp --version", {
@@ -14334,7 +14331,7 @@ function registerDoctor(program2) {
         timeout: 3e3,
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      const cliVersion = "0.18.0";
+      const cliVersion = "0.19.0";
       if (legacyRaw && legacyRaw !== cliVersion) {
         findings.push({
           severity: "warn",
@@ -14356,14 +14353,14 @@ npm uninstall -g @hiveai/mcp`
       ];
       const staleConfigs = [];
       for (const cfgPath of configPaths) {
-        if (!existsSync69(cfgPath)) continue;
+        if (!existsSync68(cfgPath)) continue;
         try {
           const raw = await readFile23(cfgPath, "utf8");
           if (raw.includes('"haive-mcp"') || raw.includes("'haive-mcp'")) {
             staleConfigs.push(path47.relative(root, cfgPath));
             if (opts.fix && !opts.dryRun) {
               const updated = raw.replace(/"command"\s*:\s*"haive-mcp"/g, '"command": "haive"').replace(/"args"\s*:\s*\[\]/g, '"args": ["mcp", "--stdio"]');
-              await writeFile37(cfgPath, updated, "utf8");
+              await writeFile36(cfgPath, updated, "utf8");
             }
           }
         } catch {
@@ -14652,7 +14649,7 @@ which -a haive`
   ];
   for (const rel of integrationFiles) {
     const file = path47.join(root, rel);
-    if (!existsSync69(file)) continue;
+    if (!existsSync68(file)) continue;
     const text = await readFile23(file, "utf8").catch(() => "");
     for (const bin of extractAbsoluteHaiveBins(text)) {
       const version = versionForBinary(bin);
@@ -14700,7 +14697,7 @@ async function collectDistFreshnessFindings(root, expectedVersion) {
   const isHaiveWorkspace = (await readJson(path47.join(root, "package.json")))?.name === "haive-monorepo";
   if (!isHaiveWorkspace) return findings;
   const cliDist = path47.join(root, "packages/cli/dist/index.js");
-  if (!existsSync69(cliDist)) {
+  if (!existsSync68(cliDist)) {
     findings.push({
       severity: "warn",
       code: "workspace-dist-missing",
@@ -14724,7 +14721,7 @@ async function collectDistFreshnessFindings(root, expectedVersion) {
     "packages/core/src/index.ts",
     "packages/mcp/src/server.ts",
     "packages/cli/src/index.ts"
-  ].map((rel) => path47.join(root, rel)).filter(existsSync69);
+  ].map((rel) => path47.join(root, rel)).filter(existsSync68);
   if (sourceFiles.length > 0) {
     const distMtime = statSync2(cliDist).mtimeMs;
     const newestSource = Math.max(...sourceFiles.map((file) => statSync2(file).mtimeMs));
@@ -14813,7 +14810,7 @@ function collectGlobalHivemoduleFindings(expectedVersion) {
   }
 }
 async function readJson(file) {
-  if (!existsSync69(file)) return null;
+  if (!existsSync68(file)) return null;
   try {
     return JSON.parse(await readFile23(file, "utf8"));
   } catch {
@@ -14884,11 +14881,11 @@ function extractAbsoluteHaiveBins(text) {
 }
 
 // src/commands/playback.ts
-import { existsSync as existsSync70 } from "fs";
+import { existsSync as existsSync69 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot46,
-  loadMemoriesFromDir as loadMemoriesFromDir37,
+  loadMemoriesFromDir as loadMemoriesFromDir36,
   parseSince as parseSince3,
   readUsageEvents as readUsageEvents5,
   resolveHaivePaths as resolveHaivePaths42
@@ -14914,7 +14911,7 @@ function registerPlayback(program2) {
     const filtered = cutoff > 0 ? events.filter((e) => Date.parse(e.at) >= cutoff) : events;
     const gapMs = Math.max(1, parseInt(opts.sessionGap ?? "30", 10)) * MS_PER_MINUTE;
     const sessions = bucketSessions(filtered, gapMs);
-    const all = existsSync70(paths.memoriesDir) ? await loadMemoriesFromDir37(paths.memoriesDir) : [];
+    const all = existsSync69(paths.memoriesDir) ? await loadMemoriesFromDir36(paths.memoriesDir) : [];
     const memByCreatedAt = all.filter(({ memory: memory2 }) => memory2.frontmatter.type !== "session_recap").map(({ memory: memory2 }) => ({ id: memory2.frontmatter.id, at: Date.parse(memory2.frontmatter.created_at) })).sort((a, b) => a.at - b.at);
     const enriched = sessions.map((s, i) => {
       const startMs = Date.parse(s.start);
@@ -15156,11 +15153,11 @@ function runCommand3(cmd, args, cwd) {
 }
 
 // src/commands/welcome.ts
-import { existsSync as existsSync71 } from "fs";
+import { existsSync as existsSync70 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot48,
-  loadMemoriesFromDir as loadMemoriesFromDir38,
+  loadMemoriesFromDir as loadMemoriesFromDir37,
   resolveHaivePaths as resolveHaivePaths44
 } from "@hiveai/core";
 var TYPE_RANK = {
@@ -15178,12 +15175,12 @@ function registerWelcome(program2) {
   ).option("--limit <n>", "maximum memories listed", "20").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot48(opts.dir);
     const paths = resolveHaivePaths44(root);
-    if (!existsSync71(paths.memoriesDir)) {
+    if (!existsSync70(paths.memoriesDir)) {
       ui.error(`No memories at ${paths.memoriesDir}. Run 'haive init' first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir38(paths.memoriesDir);
+    const all = await loadMemoriesFromDir37(paths.memoriesDir);
     const team = all.filter(
       ({ memory: memory2 }) => memory2.frontmatter.scope === "team" && memory2.frontmatter.status !== "rejected" && memory2.frontmatter.status !== "deprecated" && memory2.frontmatter.status !== "stale" && memory2.frontmatter.type !== "session_recap"
     );
@@ -15269,7 +15266,7 @@ function registerResolveProject(program2) {
 }
 
 // src/commands/runtime-journal.ts
-import { existsSync as existsSync73 } from "fs";
+import { existsSync as existsSync71 } from "fs";
 import path49 from "path";
 import "commander";
 import {
@@ -15295,7 +15292,7 @@ function registerRuntime(program2) {
     const root = path49.resolve(opts.dir ?? process.cwd());
     const paths = resolveHaivePaths45(findProjectRoot49(root));
     const limit = Math.min(500, Math.max(1, parseInt(opts.limit, 10) || 30));
-    if (!existsSync73(paths.haiveDir)) {
+    if (!existsSync71(paths.haiveDir)) {
       ui.error("No .ai/ \u2014 run `haive init` first.");
       process.exitCode = 1;
       return;
@@ -15310,7 +15307,7 @@ function registerRuntime(program2) {
 }
 
 // src/commands/memory-timeline.ts
-import { existsSync as existsSync74 } from "fs";
+import { existsSync as existsSync73 } from "fs";
 import path50 from "path";
 import "commander";
 import {
@@ -15329,13 +15326,13 @@ function registerMemoryTimeline(memory2) {
     }
     const root = path50.resolve(opts.dir ?? process.cwd());
     const paths = resolveHaivePaths46(findProjectRoot50(root));
-    if (!existsSync74(paths.memoriesDir)) {
+    if (!existsSync73(paths.memoriesDir)) {
       ui.error("No memories \u2014 run `haive init`.");
       process.exitCode = 1;
       return;
     }
     const limit = Math.min(100, Math.max(1, parseInt(opts.limit, 10) || 30));
-    const all = await loadMemoriesFromDir28(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const { entries, notice } = collectTimelineEntries2(all, {
       memoryId: opts.id,
       topic: opts.topic,
@@ -15347,7 +15344,7 @@ function registerMemoryTimeline(memory2) {
 }
 
 // src/commands/memory-conflict-candidates.ts
-import { existsSync as existsSync75 } from "fs";
+import { existsSync as existsSync74 } from "fs";
 import path51 from "path";
 import "commander";
 import {
@@ -15372,7 +15369,7 @@ function registerMemoryConflictCandidates(memory2) {
   ).option("--min-jaccard <x>", "minimum Jaccard for lexical pairs", "0.45").option("--max-pairs <n>", "cap lexical pairs", "20").option("--max-scan <n>", "max memories scanned (lexical)", "500").option("--max-topic-pairs <n>", "cap topic/status pairs", "20").action(async (opts) => {
     const root = path51.resolve(opts.dir ?? process.cwd());
     const paths = resolveHaivePaths47(findProjectRoot51(root));
-    if (!existsSync75(paths.memoriesDir)) {
+    if (!existsSync74(paths.memoriesDir)) {
       ui.error("No memories \u2014 run `haive init`.");
       process.exitCode = 1;
       return;
@@ -15382,7 +15379,7 @@ function registerMemoryConflictCandidates(memory2) {
     const maxPairs = Math.min(100, Math.max(1, parseInt(opts.maxPairs, 10) || 20));
     const maxScan = Math.min(2e3, Math.max(1, parseInt(opts.maxScan, 10) || 500));
     const maxTopicPairs = Math.min(100, Math.max(1, parseInt(opts.maxTopicPairs, 10) || 20));
-    const all = await loadMemoriesFromDir28(paths.memoriesDir);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
     const lexical = findLexicalConflictPairs2(all, {
       sinceDays,
       types: parseTypes(opts.types),
@@ -15408,8 +15405,8 @@ function registerMemoryConflictCandidates(memory2) {
 
 // src/commands/enforce.ts
 import { execFileSync as execFileSync2, spawn as spawn6 } from "child_process";
-import { existsSync as existsSync76, statSync as statSync3 } from "fs";
-import { chmod as chmod2, mkdir as mkdir21, readFile as readFile24, readdir as readdir6, rm as rm3, writeFile as writeFile38 } from "fs/promises";
+import { existsSync as existsSync75, statSync as statSync3 } from "fs";
+import { chmod as chmod2, mkdir as mkdir21, readFile as readFile24, readdir as readdir6, rm as rm3, writeFile as writeFile37 } from "fs/promises";
 import path53 from "path";
 import "commander";
 import {
@@ -15419,7 +15416,7 @@ import {
   hasRecentBriefingMarker as hasRecentBriefingMarker2,
   isFreshIsoDate,
   loadConfig as loadConfig14,
-  loadMemoriesFromDir as loadMemoriesFromDir39,
+  loadMemoriesFromDir as loadMemoriesFromDir38,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths6,
   readRecentBriefingMarker,
   resolveBriefingBudget as resolveBriefingBudget3,
@@ -15484,14 +15481,14 @@ function registerEnforce(program2) {
     const root = findProjectRoot52(opts.dir);
     const paths = resolveHaivePaths48(root);
     const cacheDir = path53.join(paths.haiveDir, ".cache");
-    if (existsSync76(cacheDir)) {
+    if (existsSync75(cacheDir)) {
       if (opts.dryRun) ui.info(`would clean ${path53.relative(root, cacheDir)} (preserving .gitignore)`);
       else {
         const removed = await cleanupCacheDir(cacheDir);
         ui.success(`cleaned ${path53.relative(root, cacheDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
       }
     }
-    if (existsSync76(paths.runtimeDir)) {
+    if (existsSync75(paths.runtimeDir)) {
       if (opts.dryRun) ui.info(`would clean ${path53.relative(root, paths.runtimeDir)} (preserving briefing markers)`);
       else {
         const removed = await cleanupRuntimeDir(paths.runtimeDir);
@@ -15529,7 +15526,7 @@ function registerEnforce(program2) {
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
     const paths = resolveHaivePaths48(root);
-    if (!existsSync76(paths.haiveDir)) return;
+    if (!existsSync75(paths.haiveDir)) return;
     await mkdir21(paths.runtimeDir, { recursive: true });
     const sessionId = opts.sessionId ?? payload.session_id;
     const task = opts.task ?? payload.prompt ?? "Start an AI coding session in this hAIve-initialized project.";
@@ -15592,7 +15589,7 @@ ${briefing.project_context.content.slice(0, 1800)}`);
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
     const paths = resolveHaivePaths48(root);
-    if (!existsSync76(paths.haiveDir)) return;
+    if (!existsSync75(paths.haiveDir)) return;
     if (!isWriteLikeTool(payload)) return;
     const config = await loadConfig14(paths);
     if (config.enforcement?.requireBriefingFirst === false) return;
@@ -15657,7 +15654,7 @@ function emitPreToolUseContext(text) {
 async function buildFinishReport(dir) {
   const root = findProjectRoot52(dir);
   const paths = resolveHaivePaths48(root);
-  const initialized = existsSync76(paths.haiveDir);
+  const initialized = existsSync75(paths.haiveDir);
   const config = initialized ? await loadConfig14(paths) : {};
   const mode = config.enforcement?.mode ?? "strict";
   const findings = [];
@@ -15849,7 +15846,7 @@ async function checkFailureCapture(paths, config) {
   const gate = config.enforcement?.failureCaptureGate ?? "warn";
   if (gate === "off") return [];
   const obsFile = path53.join(paths.haiveDir, ".cache", "observations.jsonl");
-  if (!existsSync76(obsFile)) return [];
+  if (!existsSync75(obsFile)) return [];
   const failures = [];
   try {
     const raw = await readFile24(obsFile, "utf8");
@@ -15866,7 +15863,7 @@ async function checkFailureCapture(paths, config) {
     return [];
   }
   if (failures.length === 0) return [];
-  const memories = existsSync76(paths.memoriesDir) ? await loadMemoriesFromDir39(paths.memoriesDir) : [];
+  const memories = existsSync75(paths.memoriesDir) ? await loadMemoriesFromDir38(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) {
@@ -15901,7 +15898,7 @@ function finishReport(root, initialized, mode, findings, config) {
 async function runWithEnforcement(command, args, opts) {
   const root = findProjectRoot52(opts.dir);
   const paths = resolveHaivePaths48(root);
-  if (!existsSync76(paths.haiveDir)) {
+  if (!existsSync75(paths.haiveDir)) {
     ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
     process.exit(1);
   }
@@ -15990,13 +15987,13 @@ async function writeWrapperBriefing(paths, sessionId, task) {
   if (briefing.setup_warnings.length > 0) {
     parts.push("", "## Setup Warnings", ...briefing.setup_warnings.map((w) => `- ${w}`));
   }
-  await writeFile38(file, parts.join("\n") + "\n", "utf8");
+  await writeFile37(file, parts.join("\n") + "\n", "utf8");
   return file;
 }
 async function buildEnforcementReport(dir, stage, sessionId) {
   const root = findProjectRoot52(dir);
   const paths = resolveHaivePaths48(root);
-  const initialized = existsSync76(paths.haiveDir);
+  const initialized = existsSync75(paths.haiveDir);
   const config = initialized ? await loadConfig14(paths) : {};
   if (initialized) {
     await applyLightweightRepairs(root, paths);
@@ -16030,7 +16027,7 @@ async function buildEnforcementReport(dir, stage, sessionId) {
       findings: [{ severity: "info", code: "enforcement-off", message: "hAIve enforcement is disabled." }]
     });
   }
-  findings.push(...await inspectIntegrationVersions(root, "0.18.0"));
+  findings.push(...await inspectIntegrationVersions(root, "0.19.0"));
   if (config.enforcement?.requireBriefingFirst !== false && stage !== "ci") {
     const hasBriefing = await hasRecentBriefingMarker2(paths, sessionId);
     findings.push(hasBriefing ? { severity: "ok", code: "briefing-loaded", message: "A recent hAIve briefing marker exists." } : {
@@ -16100,8 +16097,8 @@ function withCategories(report) {
   };
 }
 async function hasRecentSessionRecap(paths) {
-  if (!existsSync76(paths.memoriesDir)) return false;
-  const all = await loadMemoriesFromDir39(paths.memoriesDir);
+  if (!existsSync75(paths.memoriesDir)) return false;
+  const all = await loadMemoriesFromDir38(paths.memoriesDir);
   return all.some(({ memory: memory2 }) => {
     const fm = memory2.frontmatter;
     const freshnessDate = fm.verified_at ?? fm.created_at;
@@ -16109,8 +16106,8 @@ async function hasRecentSessionRecap(paths) {
   });
 }
 async function verifyMemoryPolicy(paths, config) {
-  if (!existsSync76(paths.memoriesDir)) return [];
-  const all = await loadMemoriesFromDir39(paths.memoriesDir);
+  if (!existsSync75(paths.memoriesDir)) return [];
+  const all = await loadMemoriesFromDir38(paths.memoriesDir);
   const findings = [];
   const staleImportant = [];
   let verified = 0;
@@ -16147,12 +16144,12 @@ async function verifyMemoryPolicy(paths, config) {
   return findings;
 }
 async function verifyDecisionCoverage(paths, stage, sessionId) {
-  if (!existsSync76(paths.memoriesDir)) return [];
+  if (!existsSync75(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 loadMemoriesFromDir39(paths.memoriesDir);
+  const all = await loadMemoriesFromDir38(paths.memoriesDir);
   const policyTypes = /* @__PURE__ */ new Set(["decision", "gotcha", "architecture", "convention"]);
   const relevant = all.map(({ memory: memory2 }) => memory2).filter((memory2) => {
     const fm = memory2.frontmatter;
@@ -16267,9 +16264,9 @@ async function cleanupRuntimeDir(runtimeDir) {
     await rm3(path53.join(runtimeDir, entry.name), { recursive: true, force: true });
     removed++;
   }
-  await writeFile38(path53.join(runtimeDir, ".gitignore"), "*\n!.gitignore\n!README.md\n", "utf8");
-  if (!existsSync76(path53.join(runtimeDir, "README.md"))) {
-    await writeFile38(
+  await writeFile37(path53.join(runtimeDir, ".gitignore"), "*\n!.gitignore\n!README.md\n", "utf8");
+  if (!existsSync75(path53.join(runtimeDir, "README.md"))) {
+    await writeFile37(
       path53.join(runtimeDir, "README.md"),
       "# .ai/.runtime \u2014 disposable local layer\n\nRuntime data is local. hAIve cleanup preserves briefing markers so enforcement state remains valid.\n",
       "utf8"
@@ -16286,7 +16283,7 @@ async function cleanupCacheDir(cacheDir) {
     await rm3(path53.join(cacheDir, entry.name), { recursive: true, force: true });
     removed++;
   }
-  await writeFile38(path53.join(cacheDir, ".gitignore"), "*\n!.gitignore\n", "utf8");
+  await writeFile37(path53.join(cacheDir, ".gitignore"), "*\n!.gitignore\n", "utf8");
   return removed;
 }
 async function cleanupEnforcementDir(enforcementDir) {
@@ -16311,7 +16308,7 @@ async function inspectIntegrationVersions(root, expectedVersion) {
   const findings = [];
   for (const rel of files) {
     const file = path53.join(root, rel);
-    if (!existsSync76(file)) continue;
+    if (!existsSync75(file)) continue;
     const text = await readFile24(file, "utf8").catch(() => "");
     for (const bin of extractAbsoluteHaiveBins2(text)) {
       const version = versionForBinary2(bin);
@@ -16421,7 +16418,7 @@ async function resolveCiDiffRange(root) {
 }
 async function resolveGithubEventRange(root) {
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !existsSync76(eventPath)) return null;
+  if (!eventPath || !existsSync75(eventPath)) return null;
   try {
     const event = JSON.parse(await readFile24(eventPath, "utf8"));
     const prBase = cleanGitSha(event.pull_request?.base?.sha);
@@ -16744,7 +16741,7 @@ function buildScore(findings, threshold = 80) {
 }
 async function installGitEnforcement(root) {
   const hooksDir = path53.join(root, ".git", "hooks");
-  if (!existsSync76(path53.join(root, ".git"))) {
+  if (!existsSync75(path53.join(root, ".git"))) {
     ui.warn("No .git directory found; git enforcement hooks skipped.");
     return;
   }
@@ -16774,17 +16771,17 @@ haive enforce commit-msg "$1" --dir . || exit $?
   ];
   for (const hook of hooks) {
     const file = path53.join(hooksDir, hook.name);
-    if (existsSync76(file)) {
+    if (existsSync75(file)) {
       const current = await readFile24(file, "utf8").catch(() => "");
       if (current.includes(ENFORCE_HOOK_MARKER)) {
-        await writeFile38(file, hook.body, "utf8");
+        await writeFile37(file, hook.body, "utf8");
       } else {
-        await writeFile38(file, `${current.trimEnd()}
+        await writeFile37(file, `${current.trimEnd()}
 
 ${hook.body}`, "utf8");
       }
     } else {
-      await writeFile38(file, hook.body, "utf8");
+      await writeFile37(file, hook.body, "utf8");
     }
     await chmod2(file, 493);
   }
@@ -16793,11 +16790,11 @@ ${hook.body}`, "utf8");
 async function installCiEnforcement(root) {
   const workflowPath = path53.join(root, ".github", "workflows", "haive-enforcement.yml");
   await mkdir21(path53.dirname(workflowPath), { recursive: true });
-  if (existsSync76(workflowPath)) {
+  if (existsSync75(workflowPath)) {
     ui.info("GitHub Actions enforcement workflow already exists \u2014 skipped");
     return;
   }
-  await writeFile38(workflowPath, `name: haive-enforcement
+  await writeFile37(workflowPath, `name: haive-enforcement
 
 on:
   pull_request:
@@ -16932,11 +16929,11 @@ function normalizeToolPath(file, root) {
   return path53.relative(root, normalized).replace(/\\/g, "/");
 }
 async function missingRequiredMemoriesForFiles(paths, files, sessionId) {
-  if (!existsSync76(paths.memoriesDir)) return [];
+  if (!existsSync75(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 loadMemoriesFromDir39(paths.memoriesDir);
+  const all = await loadMemoriesFromDir38(paths.memoriesDir);
   return all.filter(({ memory: memory2 }) => {
     const fm = memory2.frontmatter;
     if (!policyTypes.has(fm.type)) return false;
@@ -17017,17 +17014,17 @@ function registerRun(program2) {
 
 // src/commands/sensors.ts
 import { execFile as execFile3 } from "child_process";
-import { existsSync as existsSync77 } from "fs";
-import { chmod as chmod3, mkdir as mkdir23, readFile as readFile25, writeFile as writeFile39 } from "fs/promises";
+import { existsSync as existsSync76 } from "fs";
+import { chmod as chmod3, mkdir as mkdir23, readFile as readFile25, writeFile as writeFile38 } from "fs/promises";
 import path54 from "path";
 import { promisify as promisify3 } from "util";
 import "commander";
 import {
   appendPreventionEvent as appendPreventionEvent2,
   findProjectRoot as findProjectRoot53,
-  isRetiredMemory as isRetiredMemory4,
+  isRetiredMemory as isRetiredMemory3,
   loadConfig as loadConfig15,
-  loadMemoriesFromDir as loadMemoriesFromDir40,
+  loadMemoriesFromDir as loadMemoriesFromDir39,
   loadUsageIndex as loadUsageIndex31,
   recordPrevention as recordPrevention2,
   resolveHaivePaths as resolveHaivePaths49,
@@ -17157,7 +17154,7 @@ function registerSensors(program2) {
     }
     const root = findProjectRoot53(opts.dir);
     const paths = resolveHaivePaths49(root);
-    const loaded = existsSync77(paths.memoriesDir) ? await loadMemoriesFromDir40(paths.memoriesDir) : [];
+    const loaded = existsSync76(paths.memoriesDir) ? await loadMemoriesFromDir39(paths.memoriesDir) : [];
     const found = loaded.find(({ memory: memory2 }) => memory2.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory found with id ${id}`);
@@ -17177,7 +17174,7 @@ function registerSensors(program2) {
       },
       body: found.memory.body
     };
-    await writeFile39(found.filePath, serializeMemory29(next), "utf8");
+    await writeFile38(found.filePath, serializeMemory29(next), "utf8");
     ui.success(`Updated ${id}: sensor severity=${severity}`);
     if (sensor.pattern) ui.info(`pattern=${JSON.stringify(sensor.pattern)}`);
     ui.info(`message=${sensor.message}`);
@@ -17196,7 +17193,7 @@ function registerSensors(program2) {
     await mkdir23(outDir, { recursive: true });
     const outPath = path54.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 writeFile39(outPath, content, "utf8");
+    await writeFile38(outPath, content, "utf8");
     if (format === "grep") await chmod3(outPath, 493);
     ui.success(`Exported ${rows.length} sensor(s): ${path54.relative(root, outPath)}`);
   });
@@ -17219,13 +17216,13 @@ async function sensorRows(paths) {
   });
 }
 async function runnableSensorMemories(paths, regexOnly = true) {
-  if (!existsSync77(paths.memoriesDir)) return [];
-  const loaded = await loadMemoriesFromDir40(paths.memoriesDir);
+  if (!existsSync76(paths.memoriesDir)) return [];
+  const loaded = await loadMemoriesFromDir39(paths.memoriesDir);
   return loaded.map(({ memory: memory2 }) => memory2).filter((memory2) => {
     const sensor = memory2.frontmatter.sensor;
     if (!sensor) return false;
     if (regexOnly && sensor.kind !== "regex") return false;
-    return !isRetiredMemory4(memory2.frontmatter, memory2.body);
+    return !isRetiredMemory3(memory2.frontmatter, memory2.body);
   });
 }
 async function runCommandSensor(spec, root) {
@@ -17269,15 +17266,15 @@ function shellQuote(value) {
 }
 
 // src/commands/ingest.ts
-import { existsSync as existsSync78 } from "fs";
-import { mkdir as mkdir24, readFile as readFile26, writeFile as writeFile40 } from "fs/promises";
+import { existsSync as existsSync77 } from "fs";
+import { mkdir as mkdir24, readFile as readFile26, writeFile as writeFile39 } from "fs/promises";
 import path55 from "path";
 import "commander";
 import {
   draftsFromFindings as draftsFromFindings2,
   filterNewDrafts as filterNewDrafts2,
   findProjectRoot as findProjectRoot54,
-  loadMemoriesFromDir as loadMemoriesFromDir41,
+  loadMemoriesFromDir as loadMemoriesFromDir40,
   memoryFilePath as memoryFilePath12,
   parseFindings as parseFindings2,
   resolveHaivePaths as resolveHaivePaths50,
@@ -17307,7 +17304,7 @@ function registerIngest(program2) {
     }
     const root = findProjectRoot54(opts.dir);
     const paths = resolveHaivePaths50(root);
-    if (!existsSync78(paths.haiveDir)) {
+    if (!existsSync77(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -17329,7 +17326,7 @@ function registerIngest(program2) {
         return;
       }
       const reportPath = path55.resolve(root, file);
-      if (!existsSync78(reportPath)) {
+      if (!existsSync77(reportPath)) {
         ui.error(`Report file not found: ${reportPath}`);
         process.exitCode = 1;
         return;
@@ -17358,7 +17355,7 @@ function registerIngest(program2) {
       process.exitCode = 1;
       return;
     }
-    const existing = existsSync78(paths.memoriesDir) ? await loadMemoriesFromDir41(paths.memoriesDir) : [];
+    const existing = existsSync77(paths.memoriesDir) ? await loadMemoriesFromDir40(paths.memoriesDir) : [];
     const existingTopics = new Set(
       existing.map(({ memory: memory2 }) => memory2.frontmatter.topic).filter((t) => Boolean(t))
     );
@@ -17424,7 +17421,7 @@ function registerIngest(program2) {
 async function writeDraft2(paths, draft) {
   const file = memoryFilePath12(paths, draft.frontmatter.scope, draft.frontmatter.id, draft.frontmatter.module);
   await mkdir24(path55.dirname(file), { recursive: true });
-  await writeFile40(file, serializeMemory30({ frontmatter: draft.frontmatter, body: draft.body }), "utf8");
+  await writeFile39(file, serializeMemory30({ frontmatter: draft.frontmatter, body: draft.body }), "utf8");
   return file;
 }
 async function fetchSonarIssues(opts) {
@@ -17465,13 +17462,13 @@ async function fetchSonarIssues(opts) {
 }
 
 // src/commands/dashboard.ts
-import { existsSync as existsSync79 } from "fs";
+import { existsSync as existsSync78 } from "fs";
 import "commander";
 import {
   buildDashboard,
   findProjectRoot as findProjectRoot55,
   loadConfig as loadConfig16,
-  loadMemoriesFromDir as loadMemoriesFromDir43,
+  loadMemoriesFromDir as loadMemoriesFromDir41,
   loadPreventionEvents as loadPreventionEvents4,
   loadUsageIndex as loadUsageIndex33,
   resolveHaivePaths as resolveHaivePaths51
@@ -17482,12 +17479,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 = findProjectRoot55(opts.dir);
     const paths = resolveHaivePaths51(root);
-    if (!existsSync79(paths.haiveDir)) {
+    if (!existsSync78(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const memories = existsSync79(paths.memoriesDir) ? await loadMemoriesFromDir43(paths.memoriesDir) : [];
+    const memories = existsSync78(paths.memoriesDir) ? await loadMemoriesFromDir41(paths.memoriesDir) : [];
     const usage = await loadUsageIndex33(paths);
     const preventionEvents = await loadPreventionEvents4(paths);
     const config = await loadConfig16(paths);
@@ -17601,7 +17598,7 @@ function warnNum(n) {
 // src/commands/dev-link.ts
 import { execFile as execFile4 } from "child_process";
 import { cp, readFile as readFile27 } from "fs/promises";
-import { existsSync as existsSync80 } from "fs";
+import { existsSync as existsSync79 } from "fs";
 import path56 from "path";
 import { promisify as promisify4 } from "util";
 import "commander";
@@ -17611,7 +17608,7 @@ function registerDevLink(program2) {
   const dev = program2.commands.find((c) => c.name() === "dev") ?? program2.command("dev").description("Developer utilities for working on hAIve itself.");
   dev.command("link").description("Hot-swap this repo's built dist into the global @hiveai install so `haive` 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 = findProjectRoot56(opts.dir);
-    if (!existsSync80(path56.join(root, "packages", "cli", "dist", "index.js"))) {
+    if (!existsSync79(path56.join(root, "packages", "cli", "dist", "index.js"))) {
       ui.error(`Not the hAIve monorepo (no packages/cli/dist) at ${root}. Run \`pnpm -r build\` first, or pass --dir.`);
       process.exitCode = 1;
       return;
@@ -17623,7 +17620,7 @@ function registerDevLink(program2) {
       globalModules = path56.join(path56.dirname(path56.dirname(process.execPath)), "lib", "node_modules");
     }
     const globalHive = path56.join(globalModules, "@hiveai");
-    if (!existsSync80(globalHive)) {
+    if (!existsSync79(globalHive)) {
       ui.error(`No global @hiveai install at ${globalHive}. Install once with \`npm i -g @hiveai/cli\`, then re-run.`);
       process.exitCode = 1;
       return;
@@ -17631,7 +17628,7 @@ function registerDevLink(program2) {
     const linked = [];
     const copyDist = async (fromPkg, toDistDir) => {
       const from = path56.join(root, "packages", fromPkg, "dist");
-      if (!existsSync80(from) || !existsSync80(path56.dirname(toDistDir))) return;
+      if (!existsSync79(from) || !existsSync79(path56.dirname(toDistDir))) return;
       await cp(from, toDistDir, { recursive: true });
       linked.push(path56.relative(globalModules, toDistDir));
     };
@@ -17690,7 +17687,7 @@ function registerCoverage(program2) {
       maxHotFiles: 500
     });
     const hotFiles = radar.hotFiles.filter((h) => !isNoisePath(h.path)).map((h) => ({ path: h.path, changes: h.changes }));
-    const memories = await loadMemoriesFromDir28(paths.memoriesDir);
+    const memories = await loadMemoriesFromDir27(paths.memoriesDir);
     const gaps = findCoverageGaps(hotFiles, memories, { minChanges, limit });
     if (opts.json) {
       console.log(JSON.stringify({ root, scanned_hot_files: hotFiles.length, gaps }, null, 2));
@@ -17718,7 +17715,7 @@ function registerCoverage(program2) {
 
 // src/commands/merge-driver.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { readFileSync, writeFileSync, existsSync as existsSync81 } from "fs";
+import { readFileSync, writeFileSync, existsSync as existsSync80 } from "fs";
 import path57 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot58, mergeMemoryVersions } from "@hiveai/core";
@@ -17752,7 +17749,7 @@ function registerMergeDriver(program2) {
       return;
     }
     const gaPath = path57.join(root, ".gitattributes");
-    let content = existsSync81(gaPath) ? readFileSync(gaPath, "utf8") : "";
+    let content = existsSync80(gaPath) ? readFileSync(gaPath, "utf8") : "";
     if (!content.includes(GITATTRIBUTES_MARK)) {
       if (content.length > 0 && !content.endsWith("\n")) content += "\n";
       content += GITATTRIBUTES_BLOCK + "\n";
@@ -17766,8 +17763,8 @@ function registerMergeDriver(program2) {
 }
 
 // src/commands/memory-resolve-conflict.ts
-import { writeFile as writeFile41 } from "fs/promises";
-import { existsSync as existsSync83 } from "fs";
+import { writeFile as writeFile40 } from "fs/promises";
+import { existsSync as existsSync81 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot59,
@@ -17779,12 +17776,12 @@ function registerMemoryResolveConflict(memory2) {
   memory2.command("resolve-conflict <id_a> <id_b>").description("Resolve a contradiction: keep the stronger memory, deprecate (supersede) the other").option("--yes", "apply the resolution (without this, only previews it)", false).option("--json", "emit JSON", false).option("-d, --dir <dir>", "project root").action(async (idA, idB, opts) => {
     const root = findProjectRoot59(opts.dir);
     const paths = resolveHaivePaths53(root);
-    if (!existsSync83(paths.memoriesDir)) {
+    if (!existsSync81(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const memories = await loadMemoriesFromDir28(paths.memoriesDir);
+    const memories = await loadMemoriesFromDir27(paths.memoriesDir);
     const a = memories.find((m) => m.memory.frontmatter.id === idA);
     const b = memories.find((m) => m.memory.frontmatter.id === idB);
     if (!a || !b) {
@@ -17806,7 +17803,7 @@ function registerMemoryResolveConflict(memory2) {
       if (!opts.json) ui.info("Preview only \u2014 re-run with --yes to apply.");
       return;
     }
-    await writeFile41(
+    await writeFile40(
       loser.filePath,
       serializeMemory31({
         frontmatter: {
@@ -17825,8 +17822,8 @@ function registerMemoryResolveConflict(memory2) {
 
 // src/commands/memory-seed-git.ts
 import { execFile as execFile5 } from "child_process";
-import { mkdir as mkdir25, writeFile as writeFile43 } from "fs/promises";
-import { existsSync as existsSync84 } from "fs";
+import { mkdir as mkdir25, writeFile as writeFile41 } from "fs/promises";
+import { existsSync as existsSync83 } from "fs";
 import path58 from "path";
 import { promisify as promisify5 } from "util";
 import "commander";
@@ -17843,7 +17840,7 @@ function registerMemorySeedGit(memory2) {
   memory2.command("seed-git").description("Propose draft `attempt` seeds from revert/hotfix commits in git history (cold-start)").option("--apply", "write the proposed seeds as draft memories (default: preview only)", false).option("--limit <n>", "max seeds to propose", "20").option("--days <n>", "git-history lookback window in days", "365").option("--scope <scope>", "personal | team", "team").option("--json", "emit JSON", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot60(opts.dir);
     const paths = resolveHaivePaths54(root);
-    if (!existsSync84(paths.haiveDir)) {
+    if (!existsSync83(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -17888,9 +17885,9 @@ function registerMemorySeedGit(memory2) {
 _Seeded from git ${p.kind} commit ${p.source_sha}. Review and validate (or delete) \u2014 not yet authoritative._
 `;
       const file = memoryFilePath13(paths, fm.scope, fm.id, fm.module);
-      if (existsSync84(file)) continue;
+      if (existsSync83(file)) continue;
       await mkdir25(path58.dirname(file), { recursive: true });
-      await writeFile43(file, serializeMemory33({ frontmatter: fm, body }), "utf8");
+      await writeFile41(file, serializeMemory33({ frontmatter: fm, body }), "utf8");
       written += 1;
     }
     if (!opts.json) {
@@ -17921,21 +17918,21 @@ async function readCommits(root, days) {
 }
 
 // src/commands/bridges.ts
-import { existsSync as existsSync85 } from "fs";
+import { existsSync as existsSync84 } from "fs";
 import path59 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot61,
   resolveHaivePaths as resolveHaivePaths55,
   BRIDGE_TARGET_PATH as BRIDGE_TARGET_PATH2,
-  BRIDGE_TARGETS as BRIDGE_TARGETS2
+  BRIDGE_TARGETS as BRIDGE_TARGETS3
 } from "@hiveai/core";
 function registerBridges(program2) {
   const bridges = program2.command("bridges").description(
     "Generate native agent bridge files from the hAIve 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    haive bridges sync --all\n    haive 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_TARGETS2.join(", ") + "\n"
+    "Regenerate bridge files idempotently (marker-based, preserves manual content outside markers).\n  Supported targets: " + BRIDGE_TARGETS3.join(", ") + "\n"
   ).option("--all", "generate all supported bridge targets").option(
     "--only <targets>",
     "comma-separated list of targets to generate (e.g. cline,windsurf,agents)"
@@ -17943,7 +17940,7 @@ function registerBridges(program2) {
     const root = findProjectRoot61(opts.dir);
     const paths = resolveHaivePaths55(root);
     const dryRun = opts.dryRun === true;
-    if (!existsSync85(paths.memoriesDir)) {
+    if (!existsSync84(paths.memoriesDir)) {
       ui.warn(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -17951,18 +17948,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_TARGETS2.includes(t));
+      const invalid = requested.filter((t) => !BRIDGE_TARGETS3.includes(t));
       if (invalid.length > 0) {
-        ui.error(`Unknown bridge target(s): ${invalid.join(", ")}. Valid: ${BRIDGE_TARGETS2.join(", ")}`);
+        ui.error(`Unknown bridge target(s): ${invalid.join(", ")}. Valid: ${BRIDGE_TARGETS3.join(", ")}`);
         process.exitCode = 1;
         return;
       }
       targets = requested;
     } else if (opts.all) {
-      targets = BRIDGE_TARGETS2;
+      targets = BRIDGE_TARGETS3;
     } else {
-      targets = BRIDGE_TARGETS2.filter(
-        (t) => existsSync85(path59.join(root, BRIDGE_TARGET_PATH2[t]))
+      targets = BRIDGE_TARGETS3.filter(
+        (t) => existsSync84(path59.join(root, BRIDGE_TARGET_PATH2[t]))
       );
       if (targets.length === 0) {
         ui.info(
@@ -17989,9 +17986,9 @@ function registerBridges(program2) {
   bridges.command("list").description("List bridge targets and their status in this project").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot61(opts.dir);
     console.log(ui.bold("hAIve bridge targets:"));
-    for (const target of BRIDGE_TARGETS2) {
+    for (const target of BRIDGE_TARGETS3) {
       const relPath = BRIDGE_TARGET_PATH2[target];
-      const exists = existsSync85(path59.join(root, relPath));
+      const exists = existsSync84(path59.join(root, relPath));
       const marker = exists ? ui.dim("\u2713") : ui.dim("\xB7");
       console.log(`  ${marker} ${target.padEnd(10)} ${relPath}${exists ? "" : "  (not present)"}`);
     }
@@ -18002,7 +17999,7 @@ function registerBridges(program2) {
 
 // src/index.ts
 var program = new Command64();
-program.name("haive").description("hAIve - repo-native memory and context policy for coding-agent harnesses").version("0.18.0").option("--advanced", "show maintenance and experimental commands in help");
+program.name("haive").description("hAIve - repo-native memory and context policy for coding-agent harnesses").version("0.19.0").option("--advanced", "show maintenance and experimental commands in help");
 registerInit(program);
 registerWelcome(program);
 registerResolveProject(program);