@hiveai/cli 0.9.10 → 0.9.12

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command49 } from "commander";
+import { Command as Command51 } from "commander";
 
 // src/commands/briefing.ts
 import { existsSync } from "fs";
@@ -198,7 +198,7 @@ async function getHotFiles(root, daysBack, maxHotFiles, filePaths) {
       if (!f) continue;
       counts.set(f, (counts.get(f) ?? 0) + 1);
     }
-    let entries = [...counts.entries()].map(([path46, changes]) => ({ path: path46, changes }));
+    let entries = [...counts.entries()].map(([path48, changes]) => ({ path: path48, changes }));
     const lowerPaths = filePaths.map((p) => p.toLowerCase());
     if (lowerPaths.length > 0) {
       entries = entries.filter((e) => lowerPaths.some((p) => e.path.toLowerCase().includes(p)));
@@ -308,12 +308,14 @@ function registerBriefing(program2) {
   ).option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot(opts.dir);
     const paths = resolveHaivePaths(root);
+    const markerFiles = parseCsv(opts.files);
     if (existsSync(paths.haiveDir)) {
       await mkdir(paths.runtimeDir, { recursive: true });
       await writeBriefingMarker(paths, {
         task: opts.task ?? "CLI briefing",
         source: "haive-briefing-cli",
-        sessionId: process.env.HAIVE_SESSION_ID
+        sessionId: process.env.HAIVE_SESSION_ID,
+        files: markerFiles
       }).catch(() => {
       });
     }
@@ -386,7 +388,7 @@ function registerBriefing(program2) {
       }
     }
     const all = ownMemories;
-    const filePaths = parseCsv(opts.files);
+    const filePaths = markerFiles;
     const tokens = opts.task ? tokenizeQuery(opts.task) : null;
     const scopeFilter = opts.scope ?? "all";
     const recaps = all.filter(({ memory: mem }) => mem.frontmatter.type === "session_recap").sort(
@@ -498,6 +500,14 @@ function registerBriefing(program2) {
     if (ids.length > 0) {
       await trackReads(paths, ids).catch(() => {
       });
+      await writeBriefingMarker(paths, {
+        task: opts.task ?? "CLI briefing",
+        source: "haive-briefing-cli",
+        sessionId: process.env.HAIVE_SESSION_ID,
+        memoryIds: ids,
+        files: filePaths
+      }).catch(() => {
+      });
     }
     const radarForced = opts.radar === true;
     const radarAuto = opts.radar !== false && top.length < RADAR_AUTO_THRESHOLD;
@@ -720,23 +730,404 @@ function registerIndexCode(program2) {
 }
 
 // src/commands/init.ts
-import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import path7 from "path";
-import { spawnSync } from "child_process";
+import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
+import path8 from "path";
+import { spawnSync as spawnSync2 } from "child_process";
 import "commander";
 import {
   AUTOPILOT_DEFAULTS,
   buildCodeMap as buildCodeMap2,
-  resolveHaivePaths as resolveHaivePaths4,
+  resolveHaivePaths as resolveHaivePaths5,
   saveCodeMap as saveCodeMap2,
   saveConfig
 } from "@hiveai/core";
 
-// src/commands/init-bootstrap.ts
-import { readdir, readFile as readFile2 } from "fs/promises";
+// src/commands/agent.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync4 } from "fs";
+import { mkdir as mkdir3, writeFile as writeFile2 } from "fs/promises";
+import os2 from "os";
+import path5 from "path";
+import { createInterface } from "readline/promises";
+import "commander";
+import { findProjectRoot as findProjectRoot5, resolveHaivePaths as resolveHaivePaths4 } from "@hiveai/core";
+
+// src/commands/init-mcp-setup.ts
+import { readFile as readFile2, writeFile, mkdir as mkdir2 } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
 import path4 from "path";
+import os from "os";
+var HOME = os.homedir();
+var HAIVE_MCP_ENTRY = {
+  command: "haive",
+  args: ["mcp", "--stdio"]
+};
+function projectMcpEntry(root) {
+  return {
+    command: "haive",
+    args: ["mcp", "--stdio"],
+    env: { HAIVE_PROJECT_ROOT: root }
+  };
+}
+function cursorMcpPath() {
+  return path4.join(HOME, ".cursor", "mcp.json");
+}
+async function configureCursor() {
+  const mcpPath = cursorMcpPath();
+  const cursorDir = path4.join(HOME, ".cursor");
+  if (!existsSync3(cursorDir)) return { client: "Cursor", status: "not_installed" };
+  let config = {};
+  if (existsSync3(mcpPath)) {
+    try {
+      config = JSON.parse(await readFile2(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 writeFile(mcpPath, JSON.stringify(config, null, 2), "utf8");
+  return { client: "Cursor", status: "configured", path: mcpPath };
+}
+function vscodeMcpPath() {
+  const candidates = [
+    path4.join(HOME, ".config", "Code", "User", "mcp.json"),
+    // Linux
+    path4.join(HOME, "Library", "Application Support", "Code", "User", "mcp.json"),
+    // macOS
+    path4.join(HOME, "AppData", "Roaming", "Code", "User", "mcp.json"),
+    // Windows
+    path4.join(HOME, ".config", "Code - Insiders", "User", "mcp.json")
+  ];
+  for (const c of candidates) {
+    if (existsSync3(path4.dirname(c))) return c;
+  }
+  return null;
+}
+async function configureVSCode() {
+  const mcpPath = vscodeMcpPath();
+  if (!mcpPath) return { client: "VS Code", status: "not_installed" };
+  let config = {};
+  if (existsSync3(mcpPath)) {
+    try {
+      config = JSON.parse(await readFile2(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(path4.dirname(mcpPath), { recursive: true });
+  await writeFile(mcpPath, JSON.stringify(config, null, 2), "utf8");
+  return { client: "VS Code", status: "configured", path: mcpPath };
+}
+function claudeConfigPath() {
+  const p = path4.join(HOME, ".claude.json");
+  if (existsSync3(p)) return p;
+  const p2 = path4.join(HOME, ".config", "claude", "claude.json");
+  if (existsSync3(path4.dirname(p2))) return p2;
+  return null;
+}
+async function configureClaude() {
+  const cfgPath = claudeConfigPath() ?? path4.join(HOME, ".claude.json");
+  if (!existsSync3(cfgPath) && !existsSync3(path4.join(HOME, ".claude"))) {
+    return { client: "Claude Code", status: "not_installed" };
+  }
+  let config = {};
+  if (existsSync3(cfgPath)) {
+    try {
+      config = JSON.parse(await readFile2(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 writeFile(cfgPath, JSON.stringify(config, null, 2), "utf8");
+  return { client: "Claude Code", status: "configured", path: cfgPath };
+}
+function windsurfMcpPath() {
+  const candidates = [
+    path4.join(HOME, ".codeium", "windsurf", "mcp_config.json"),
+    path4.join(HOME, ".windsurf", "mcp.json")
+  ];
+  for (const c of candidates) {
+    if (existsSync3(path4.dirname(c))) return c;
+  }
+  return null;
+}
+async function configureWindsurf() {
+  const mcpPath = windsurfMcpPath();
+  if (!mcpPath) return { client: "Windsurf", status: "not_installed" };
+  let config = {};
+  if (existsSync3(mcpPath)) {
+    try {
+      config = JSON.parse(await readFile2(mcpPath, "utf8"));
+    } catch {
+    }
+  }
+  config.mcpServers ??= {};
+  if (config.mcpServers["haive"]) return { client: "Windsurf", status: "already_configured" };
+  config.mcpServers["haive"] = HAIVE_MCP_ENTRY;
+  await mkdir2(path4.dirname(mcpPath), { recursive: true });
+  await writeFile(mcpPath, JSON.stringify(config, null, 2), "utf8");
+  return { client: "Windsurf", status: "configured", path: mcpPath };
+}
+async function autoConfigureMcpClients() {
+  const results = [];
+  const configurators = [configureCursor, configureVSCode, configureClaude, configureWindsurf];
+  for (const fn of configurators) {
+    try {
+      results.push(await fn());
+    } catch (err) {
+      const name = fn.name.replace("configure", "");
+      results.push({ client: name, status: "error", error: String(err) });
+    }
+  }
+  return results;
+}
+async function configureProjectMcpClients(root) {
+  const entry = projectMcpEntry(root);
+  const results = [];
+  try {
+    const cursorPath = path4.join(root, ".cursor", "mcp.json");
+    let config = {};
+    if (existsSync3(cursorPath)) {
+      try {
+        config = JSON.parse(await readFile2(cursorPath, "utf8"));
+      } catch {
+      }
+    }
+    config.mcpServers ??= {};
+    config.mcpServers["haive"] = entry;
+    await mkdir2(path4.dirname(cursorPath), { recursive: true });
+    await writeFile(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 = path4.join(root, ".vscode", "mcp.json");
+    let config = {};
+    if (existsSync3(vscodePath)) {
+      try {
+        config = JSON.parse(await readFile2(vscodePath, "utf8"));
+      } catch {
+      }
+    }
+    config.servers ??= {};
+    config.servers["haive"] = { ...entry, type: "stdio" };
+    await mkdir2(path4.dirname(vscodePath), { recursive: true });
+    await writeFile(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 = path4.join(root, ".mcp.json");
+    let config = {};
+    if (existsSync3(mcpPath)) {
+      try {
+        config = JSON.parse(await readFile2(mcpPath, "utf8"));
+      } catch {
+      }
+    }
+    config.mcpServers ??= {};
+    config.mcpServers["haive"] = { ...entry, type: "stdio" };
+    await writeFile(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) });
+  }
+  return results;
+}
+
+// src/commands/agent.ts
+function registerAgent(program2) {
+  const agent = program2.command("agent").description("Detect, configure, and report the best hAIve mode for AI coding agents.");
+  agent.command("detect").description("Detect available AI agents and hAIve MCP/wrapper readiness.").option("-d, --dir <dir>", "project root").option("--json", "emit JSON", false).action(async (opts) => {
+    const detection = await detectAgentMode(opts.dir);
+    printDetection(detection, Boolean(opts.json));
+  });
+  agent.command("status").description("Alias for agent detect.").option("-d, --dir <dir>", "project root").option("--json", "emit JSON", false).action(async (opts) => {
+    const detection = await detectAgentMode(opts.dir);
+    printDetection(detection, Boolean(opts.json));
+  });
+  agent.command("setup").description("Configure hAIve project MCP, optional global MCP clients, and wrapper fallback metadata.").option("-d, --dir <dir>", "project root").option("-y, --yes", "approve user-level/global MCP configuration without prompting", false).option("--no-global", "skip user-level/global MCP configuration").option("--json", "emit JSON", false).action(async (opts) => {
+    const result = await setupAgentMode(opts.dir, {
+      yes: Boolean(opts.yes),
+      global: opts.global !== false && opts.noGlobal !== true,
+      interactive: process.stdin.isTTY
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    printSetupResult(result);
+  });
+}
+async function setupAgentMode(dir, opts = {}) {
+  const root = findProjectRoot5(dir);
+  const paths = resolveHaivePaths4(root);
+  const projectResults = await configureProjectMcpClients(root);
+  const detectionBeforeGlobal = await detectAgentMode(root);
+  let globalResults = [];
+  let globalSkippedReason;
+  const shouldConsiderGlobal = opts.global !== false;
+  if (shouldConsiderGlobal) {
+    const approved = opts.yes === true || (opts.interactive ? await confirmGlobalSetup() : false);
+    if (approved) {
+      globalResults = await autoConfigureMcpClients();
+      const codex = await configureCodexIfAvailable(root);
+      if (codex) globalResults.push(codex);
+    } else {
+      globalSkippedReason = opts.interactive ? "User declined user-level/global MCP configuration." : "Non-interactive shell; skipped user-level/global MCP configuration. Re-run `haive agent setup --yes` to apply it.";
+    }
+  } else {
+    globalSkippedReason = "User-level/global MCP configuration disabled.";
+  }
+  const detection = await detectAgentMode(root);
+  const modeFile = await writeAgentModeRecord(paths, detection, globalSkippedReason);
+  return {
+    detection,
+    project_results: projectResults,
+    global_results: globalResults,
+    mode_file: modeFile,
+    ...globalSkippedReason ? { global_skipped_reason: globalSkippedReason } : {}
+  };
+}
+async function detectAgentMode(dir) {
+  const root = findProjectRoot5(dir);
+  const paths = resolveHaivePaths4(root);
+  const projectMcp = [
+    { client: "Claude Code", path: path5.join(root, ".mcp.json"), present: existsSync4(path5.join(root, ".mcp.json")) },
+    { client: "Cursor", path: path5.join(root, ".cursor", "mcp.json"), present: existsSync4(path5.join(root, ".cursor", "mcp.json")) },
+    { client: "VS Code", path: path5.join(root, ".vscode", "mcp.json"), present: existsSync4(path5.join(root, ".vscode", "mcp.json")) }
+  ];
+  const installedAgents = [
+    { agent: "Codex", command: "codex", installed: commandExists("codex"), mcp_configured: codexMcpConfigured() },
+    { agent: "Claude", command: "claude", installed: commandExists("claude") },
+    { agent: "Aider", command: "aider", installed: commandExists("aider") },
+    { agent: "Cursor", command: "cursor", installed: commandExists("cursor") }
+  ];
+  const hasProjectMcp = projectMcp.some((item) => item.present);
+  const hasNativeMcp = hasProjectMcp || installedAgents.some((a) => a.mcp_configured);
+  const wrapperAgent = installedAgents.find((a) => a.installed && ["codex", "claude", "aider"].includes(a.command));
+  const recommendedMode = hasNativeMcp ? "mcp" : wrapperAgent ? "wrapped" : "fallback";
+  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: existsSync4(paths.haiveDir),
+    project_mcp: projectMcp,
+    installed_agents: installedAgents,
+    recommended_mode: recommendedMode,
+    recommended_command: recommendedCommand
+  };
+}
+async function writeAgentModeRecord(paths, detection, skippedReason) {
+  const dir = path5.join(paths.runtimeDir, "enforcement");
+  await mkdir3(dir, { recursive: true });
+  const file = path5.join(dir, "agent-mode.json");
+  const record = {
+    selected_mode: detection.recommended_mode,
+    recommended_command: detection.recommended_command,
+    configured_at: (/* @__PURE__ */ new Date()).toISOString(),
+    project_root: detection.root,
+    notes: [
+      "mcp = native hAIve MCP tools are available or project MCP config exists.",
+      "wrapped = use haive run when native MCP is unavailable.",
+      "fallback = use haive briefing/enforce manually.",
+      ...skippedReason ? [skippedReason] : []
+    ]
+  };
+  await writeFile2(file, JSON.stringify(record, null, 2) + "\n", "utf8");
+  return file;
+}
+async function confirmGlobalSetup() {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question(
+      "Configure hAIve in user-level AI client configs (Cursor/VS Code/Claude/Codex when detected)? [y/N] "
+    );
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+async function configureCodexIfAvailable(root) {
+  if (!commandExists("codex")) return { client: "Codex", status: "not_installed" };
+  if (codexMcpConfigured()) return { client: "Codex", status: "already_configured" };
+  const result = spawnSync("codex", [
+    "mcp",
+    "add",
+    "haive",
+    "--env",
+    `HAIVE_PROJECT_ROOT=${root}`,
+    "--",
+    "haive",
+    "mcp",
+    "--stdio"
+  ], { encoding: "utf8" });
+  if (result.status === 0) return { client: "Codex", status: "configured", path: path5.join(os2.homedir(), ".codex", "config.toml") };
+  return { client: "Codex", status: "error", error: result.stderr || result.stdout || "codex mcp add failed" };
+}
+function commandExists(command) {
+  const result = spawnSync(process.platform === "win32" ? "where" : "which", [command], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  return result.status === 0;
+}
+function codexMcpConfigured() {
+  if (!commandExists("codex")) return false;
+  const result = spawnSync("codex", ["mcp", "get", "haive"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  return result.status === 0;
+}
+function printDetection(detection, json) {
+  if (json) {
+    console.log(JSON.stringify(detection, null, 2));
+    return;
+  }
+  console.log(ui.bold("hAIve agent status"));
+  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(path5.relative(detection.root, cfg.path))}`);
+  }
+  for (const agent of detection.installed_agents) {
+    const marker = agent.installed ? ui.green("\u2713") : ui.dim("\u2022");
+    const mcp = agent.mcp_configured === true ? " + hAIve MCP" : "";
+    console.log(`${marker} ${agent.agent} (${agent.command})${mcp}`);
+  }
+  console.log(ui.bold(`Recommended mode: ${detection.recommended_mode}`));
+  console.log(`  ${detection.recommended_command}`);
+}
+function printSetupResult(result) {
+  for (const item of result.project_results) {
+    if (item.status === "configured") ui.success(`${item.client} project MCP config written (${item.path})`);
+    else if (item.status === "already_configured") ui.info(`${item.client} already configured`);
+    else if (item.status === "error") ui.warn(`${item.client}: ${item.error}`);
+  }
+  for (const item of result.global_results) {
+    if (item.status === "configured") ui.success(`${item.client} user-level MCP configured${item.path ? ` (${item.path})` : ""}`);
+    else if (item.status === "already_configured") ui.info(`${item.client} user-level MCP already configured`);
+    else if (item.status === "not_installed") ui.info(`${item.client} not detected`);
+    else if (item.status === "error") ui.warn(`${item.client}: ${item.error}`);
+  }
+  if (result.global_skipped_reason) ui.warn(result.global_skipped_reason);
+  ui.success(`Agent mode recorded at ${result.mode_file}`);
+  printDetection(result.detection, false);
+}
+
+// src/commands/init-bootstrap.ts
+import { readdir, readFile as readFile3 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import path6 from "path";
 var IGNORE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -822,12 +1213,12 @@ function detectKeyDeps(allDeps) {
   return KEY_DEPS.filter((d) => allDeps[d] !== void 0);
 }
 function detectLanguage(root) {
-  if (existsSync3(path4.join(root, "tsconfig.json"))) return "TypeScript";
-  if (existsSync3(path4.join(root, "pyproject.toml")) || existsSync3(path4.join(root, "setup.py"))) return "Python";
-  if (existsSync3(path4.join(root, "go.mod"))) return "Go";
-  if (existsSync3(path4.join(root, "pom.xml")) || existsSync3(path4.join(root, "build.gradle"))) return "Java/Kotlin";
-  if (existsSync3(path4.join(root, "Cargo.toml"))) return "Rust";
-  if (existsSync3(path4.join(root, "package.json"))) return "JavaScript";
+  if (existsSync5(path6.join(root, "tsconfig.json"))) return "TypeScript";
+  if (existsSync5(path6.join(root, "pyproject.toml")) || existsSync5(path6.join(root, "setup.py"))) return "Python";
+  if (existsSync5(path6.join(root, "go.mod"))) return "Go";
+  if (existsSync5(path6.join(root, "pom.xml")) || existsSync5(path6.join(root, "build.gradle"))) return "Java/Kotlin";
+  if (existsSync5(path6.join(root, "Cargo.toml"))) return "Rust";
+  if (existsSync5(path6.join(root, "package.json"))) return "JavaScript";
   return "Unknown";
 }
 function detectProjectType(frameworks, scripts, isMonorepo) {
@@ -844,7 +1235,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 (existsSync3("pom.xml")) return "Java backend";
+  if (existsSync5("pom.xml")) return "Java backend";
   return "Application";
 }
 async function scanDirs(root, maxDepth = 2) {
@@ -860,9 +1251,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 = path4.relative(root, path4.join(dir, entry.name));
+      const rel = path6.relative(root, path6.join(dir, entry.name));
       results.push(rel);
-      await walk(path4.join(dir, entry.name), depth + 1);
+      await walk(path6.join(dir, entry.name), depth + 1);
     }
   }
   await walk(root, 0);
@@ -979,10 +1370,10 @@ function readmeExcerpt(readme) {
 }
 async function generateBootstrapContext(root) {
   let pkg = {};
-  const pkgPath = path4.join(root, "package.json");
-  if (existsSync3(pkgPath)) {
+  const pkgPath = path6.join(root, "package.json");
+  if (existsSync5(pkgPath)) {
     try {
-      pkg = JSON.parse(await readFile2(pkgPath, "utf8"));
+      pkg = JSON.parse(await readFile3(pkgPath, "utf8"));
     } catch {
     }
   }
@@ -992,270 +1383,79 @@ 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 ?? path4.basename(root);
+  const projectName = pkg.name ?? path6.basename(root);
   const projectDesc = pkg.description ?? "";
   let readmeSummary = "";
   for (const name of ["README.md", "readme.md", "README"]) {
-    const p = path4.join(root, name);
-    if (existsSync3(p)) {
+    const p = path6.join(root, name);
+    if (existsSync5(p)) {
       try {
-        const content = await readFile2(p, "utf8");
+        const content = await readFile3(p, "utf8");
         readmeSummary = readmeExcerpt(content);
         break;
       } catch {
       }
-    }
-  }
-  const dirs = await scanDirs(root, 2);
-  const moduleLines = inferModuleDescriptions(dirs, frameworks);
-  const scripts = pkg.scripts ?? {};
-  const scriptLines = Object.entries(scripts).filter(([k]) => ["build", "dev", "start", "test", "lint", "deploy"].includes(k)).map(([k, v]) => `- \`${k}\`: ${v}`).slice(0, 6);
-  const stackParts = [language];
-  if (frameworks.length) stackParts.push(...frameworks);
-  const techStack = stackParts.join(", ");
-  const notableDeps = Object.keys(allDeps).filter((d) => !d.startsWith("@types/") && !["typescript", "eslint", "prettier", "jest"].includes(d)).filter((d) => !["react", "react-dom", "next", "vue", "express"].includes(d)).slice(0, 10).map((d) => `\`${d}\``);
-  const lines = [
-    `# Project context \u2014 ${projectName}`,
-    "",
-    `> Auto-generated by \`haive init --bootstrap\`. Review and refine \u2014 especially the Architecture and Gotchas sections.`,
-    "",
-    `## Overview`,
-    `**Type:** ${projectType}`,
-    `**Tech stack:** ${techStack}`,
-    ...projectDesc ? [`**Description:** ${projectDesc}`] : [],
-    ...readmeSummary ? [`**From README:** ${readmeSummary}`] : [],
-    "",
-    `## Architecture`,
-    `TODO \u2014 fill in the high-level architecture (inferred structure below, verify manually):`,
-    "",
-    ...moduleLines.length ? moduleLines : ["TODO \u2014 no clear structure detected."],
-    "",
-    `## Key modules`,
-    `TODO \u2014 describe the purpose of the main modules. The directory scan found:`,
-    ...dirs.filter((d) => !d.includes("/")).slice(0, 8).map((d) => `- \`${d}/\``),
-    "",
-    `## Conventions`,
-    `TODO \u2014 fill in coding conventions (naming, patterns, file layout).`,
-    "",
-    ...scriptLines.length ? [
-      `**Available scripts:**`,
-      ...scriptLines,
-      ""
-    ] : [],
-    ...keyDeps.length ? [
-      `**Key dependencies in use:** ${keyDeps.map((d) => `\`${d}\``).join(", ")}`,
-      ""
-    ] : [],
-    ...notableDeps.length ? [
-      `**Other notable packages:** ${notableDeps.join(", ")}`,
-      ""
-    ] : [],
-    `## Glossary`,
-    `TODO \u2014 domain terms and what they mean here.`,
-    "",
-    `## Gotchas`,
-    `TODO \u2014 known traps, surprising behavior, things newcomers stub their toes on.`,
-    `(Run \`haive memory import-changelog\` or \`haive memory import README.md\` to seed these automatically.)`,
-    ""
-  ];
-  return lines.join("\n");
-}
-
-// src/commands/init-mcp-setup.ts
-import { readFile as readFile3, writeFile, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import path5 from "path";
-import os from "os";
-var HOME = os.homedir();
-var HAIVE_MCP_ENTRY = {
-  command: "haive",
-  args: ["mcp", "--stdio"]
-};
-function projectMcpEntry(root) {
-  return {
-    command: "haive",
-    args: ["mcp", "--stdio"],
-    env: { HAIVE_PROJECT_ROOT: root }
-  };
-}
-function cursorMcpPath() {
-  return path5.join(HOME, ".cursor", "mcp.json");
-}
-async function configureCursor() {
-  const mcpPath = cursorMcpPath();
-  const cursorDir = path5.join(HOME, ".cursor");
-  if (!existsSync4(cursorDir)) return { client: "Cursor", status: "not_installed" };
-  let config = {};
-  if (existsSync4(mcpPath)) {
-    try {
-      config = JSON.parse(await readFile3(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 writeFile(mcpPath, JSON.stringify(config, null, 2), "utf8");
-  return { client: "Cursor", status: "configured", path: mcpPath };
-}
-function vscodeMcpPath() {
-  const candidates = [
-    path5.join(HOME, ".config", "Code", "User", "mcp.json"),
-    // Linux
-    path5.join(HOME, "Library", "Application Support", "Code", "User", "mcp.json"),
-    // macOS
-    path5.join(HOME, "AppData", "Roaming", "Code", "User", "mcp.json"),
-    // Windows
-    path5.join(HOME, ".config", "Code - Insiders", "User", "mcp.json")
-  ];
-  for (const c of candidates) {
-    if (existsSync4(path5.dirname(c))) return c;
-  }
-  return null;
-}
-async function configureVSCode() {
-  const mcpPath = vscodeMcpPath();
-  if (!mcpPath) return { client: "VS Code", status: "not_installed" };
-  let config = {};
-  if (existsSync4(mcpPath)) {
-    try {
-      config = JSON.parse(await readFile3(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(path5.dirname(mcpPath), { recursive: true });
-  await writeFile(mcpPath, JSON.stringify(config, null, 2), "utf8");
-  return { client: "VS Code", status: "configured", path: mcpPath };
-}
-function claudeConfigPath() {
-  const p = path5.join(HOME, ".claude.json");
-  if (existsSync4(p)) return p;
-  const p2 = path5.join(HOME, ".config", "claude", "claude.json");
-  if (existsSync4(path5.dirname(p2))) return p2;
-  return null;
-}
-async function configureClaude() {
-  const cfgPath = claudeConfigPath() ?? path5.join(HOME, ".claude.json");
-  if (!existsSync4(cfgPath) && !existsSync4(path5.join(HOME, ".claude"))) {
-    return { client: "Claude Code", status: "not_installed" };
-  }
-  let config = {};
-  if (existsSync4(cfgPath)) {
-    try {
-      config = JSON.parse(await readFile3(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 writeFile(cfgPath, JSON.stringify(config, null, 2), "utf8");
-  return { client: "Claude Code", status: "configured", path: cfgPath };
-}
-function windsurfMcpPath() {
-  const candidates = [
-    path5.join(HOME, ".codeium", "windsurf", "mcp_config.json"),
-    path5.join(HOME, ".windsurf", "mcp.json")
-  ];
-  for (const c of candidates) {
-    if (existsSync4(path5.dirname(c))) return c;
-  }
-  return null;
-}
-async function configureWindsurf() {
-  const mcpPath = windsurfMcpPath();
-  if (!mcpPath) return { client: "Windsurf", status: "not_installed" };
-  let config = {};
-  if (existsSync4(mcpPath)) {
-    try {
-      config = JSON.parse(await readFile3(mcpPath, "utf8"));
-    } catch {
-    }
-  }
-  config.mcpServers ??= {};
-  if (config.mcpServers["haive"]) return { client: "Windsurf", status: "already_configured" };
-  config.mcpServers["haive"] = HAIVE_MCP_ENTRY;
-  await mkdir2(path5.dirname(mcpPath), { recursive: true });
-  await writeFile(mcpPath, JSON.stringify(config, null, 2), "utf8");
-  return { client: "Windsurf", status: "configured", path: mcpPath };
-}
-async function autoConfigureMcpClients() {
-  const results = [];
-  const configurators = [configureCursor, configureVSCode, configureClaude, configureWindsurf];
-  for (const fn of configurators) {
-    try {
-      results.push(await fn());
-    } catch (err) {
-      const name = fn.name.replace("configure", "");
-      results.push({ client: name, status: "error", error: String(err) });
-    }
-  }
-  return results;
-}
-async function configureProjectMcpClients(root) {
-  const entry = projectMcpEntry(root);
-  const results = [];
-  try {
-    const cursorPath = path5.join(root, ".cursor", "mcp.json");
-    let config = {};
-    if (existsSync4(cursorPath)) {
-      try {
-        config = JSON.parse(await readFile3(cursorPath, "utf8"));
-      } catch {
-      }
-    }
-    config.mcpServers ??= {};
-    config.mcpServers["haive"] = entry;
-    await mkdir2(path5.dirname(cursorPath), { recursive: true });
-    await writeFile(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 = path5.join(root, ".vscode", "mcp.json");
-    let config = {};
-    if (existsSync4(vscodePath)) {
-      try {
-        config = JSON.parse(await readFile3(vscodePath, "utf8"));
-      } catch {
-      }
-    }
-    config.servers ??= {};
-    config.servers["haive"] = { ...entry, type: "stdio" };
-    await mkdir2(path5.dirname(vscodePath), { recursive: true });
-    await writeFile(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 = path5.join(root, ".mcp.json");
-    let config = {};
-    if (existsSync4(mcpPath)) {
-      try {
-        config = JSON.parse(await readFile3(mcpPath, "utf8"));
-      } catch {
-      }
-    }
-    config.mcpServers ??= {};
-    config.mcpServers["haive"] = { ...entry, type: "stdio" };
-    await writeFile(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) });
+    }
   }
-  return results;
+  const dirs = await scanDirs(root, 2);
+  const moduleLines = inferModuleDescriptions(dirs, frameworks);
+  const scripts = pkg.scripts ?? {};
+  const scriptLines = Object.entries(scripts).filter(([k]) => ["build", "dev", "start", "test", "lint", "deploy"].includes(k)).map(([k, v]) => `- \`${k}\`: ${v}`).slice(0, 6);
+  const stackParts = [language];
+  if (frameworks.length) stackParts.push(...frameworks);
+  const techStack = stackParts.join(", ");
+  const notableDeps = Object.keys(allDeps).filter((d) => !d.startsWith("@types/") && !["typescript", "eslint", "prettier", "jest"].includes(d)).filter((d) => !["react", "react-dom", "next", "vue", "express"].includes(d)).slice(0, 10).map((d) => `\`${d}\``);
+  const lines = [
+    `# Project context \u2014 ${projectName}`,
+    "",
+    `> Auto-generated by \`haive init --bootstrap\`. Review and refine \u2014 especially the Architecture and Gotchas sections.`,
+    "",
+    `## Overview`,
+    `**Type:** ${projectType}`,
+    `**Tech stack:** ${techStack}`,
+    ...projectDesc ? [`**Description:** ${projectDesc}`] : [],
+    ...readmeSummary ? [`**From README:** ${readmeSummary}`] : [],
+    "",
+    `## Architecture`,
+    `TODO \u2014 fill in the high-level architecture (inferred structure below, verify manually):`,
+    "",
+    ...moduleLines.length ? moduleLines : ["TODO \u2014 no clear structure detected."],
+    "",
+    `## Key modules`,
+    `TODO \u2014 describe the purpose of the main modules. The directory scan found:`,
+    ...dirs.filter((d) => !d.includes("/")).slice(0, 8).map((d) => `- \`${d}/\``),
+    "",
+    `## Conventions`,
+    `TODO \u2014 fill in coding conventions (naming, patterns, file layout).`,
+    "",
+    ...scriptLines.length ? [
+      `**Available scripts:**`,
+      ...scriptLines,
+      ""
+    ] : [],
+    ...keyDeps.length ? [
+      `**Key dependencies in use:** ${keyDeps.map((d) => `\`${d}\``).join(", ")}`,
+      ""
+    ] : [],
+    ...notableDeps.length ? [
+      `**Other notable packages:** ${notableDeps.join(", ")}`,
+      ""
+    ] : [],
+    `## Glossary`,
+    `TODO \u2014 domain terms and what they mean here.`,
+    "",
+    `## Gotchas`,
+    `TODO \u2014 known traps, surprising behavior, things newcomers stub their toes on.`,
+    `(Run \`haive memory import-changelog\` or \`haive memory import README.md\` to seed these automatically.)`,
+    ""
+  ];
+  return lines.join("\n");
 }
 
 // src/commands/init-stack-packs.ts
-import { mkdir as mkdir3, writeFile as writeFile2 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
-import path6 from "path";
+import { mkdir as mkdir4, writeFile as writeFile3 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import path7 from "path";
 import {
   buildFrontmatter,
   memoryFilePath,
@@ -1867,7 +2067,7 @@ function autoDetectStacks(deps) {
 async function seedStackPack(haivePaths, stack) {
   const memories = PACKS[stack];
   if (!memories) return 0;
-  await mkdir3(haivePaths.teamDir, { recursive: true });
+  await mkdir4(haivePaths.teamDir, { recursive: true });
   let count = 0;
   for (const mem of memories) {
     const fm = buildFrontmatter({
@@ -1878,10 +2078,10 @@ async function seedStackPack(haivePaths, stack) {
       tags: mem.tags
     });
     const filePath = memoryFilePath(haivePaths, "team", fm.id);
-    if (existsSync5(filePath)) continue;
+    if (existsSync6(filePath)) continue;
     const content = serializeMemory({ frontmatter: fm, body: mem.body });
-    await mkdir3(path6.dirname(filePath), { recursive: true });
-    await writeFile2(filePath, content, "utf8");
+    await mkdir4(path7.dirname(filePath), { recursive: true });
+    await writeFile3(filePath, content, "utf8");
     count++;
   }
   return count;
@@ -2095,38 +2295,42 @@ function registerInit(program2) {
   ).option(
     "--no-mcp-setup",
     "skip auto-configuring haive MCP (haive mcp --stdio) in Cursor / VS Code / Claude Code"
+  ).option(
+    "-y, --yes",
+    "approve user-level AI client configuration prompts during agent setup",
+    false
   ).action(async (opts) => {
-    const root = path7.resolve(opts.dir);
-    const paths = resolveHaivePaths4(root);
+    const root = path8.resolve(opts.dir);
+    const paths = resolveHaivePaths5(root);
     const autopilot = opts.manual !== true;
     const wantBootstrap = opts.bootstrap === void 0 ? autopilot : opts.bootstrap;
     const wantStack = opts.stack === void 0 ? autopilot ? "auto" : void 0 : opts.stack === "none" ? void 0 : opts.stack;
-    if (existsSync6(paths.haiveDir)) {
+    if (existsSync7(paths.haiveDir)) {
       ui.warn(`.ai/ already exists at ${paths.haiveDir} \u2014 leaving existing files in place.`);
     }
-    await mkdir4(paths.personalDir, { recursive: true });
-    await mkdir4(paths.teamDir, { recursive: true });
-    await mkdir4(paths.moduleDir, { recursive: true });
-    await mkdir4(paths.modulesContextDir, { recursive: true });
+    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 ensureAiRuntimeLayout(paths.runtimeDir);
-    if (!existsSync6(paths.projectContext)) {
+    if (!existsSync7(paths.projectContext)) {
       if (wantBootstrap) {
         ui.info("Bootstrapping project context from local files\u2026");
         try {
           const context = await generateBootstrapContext(root);
-          await writeFile3(paths.projectContext, context, "utf8");
+          await writeFile4(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 writeFile3(paths.projectContext, PROJECT_CONTEXT_TEMPLATE, "utf8");
+          await writeFile4(paths.projectContext, PROJECT_CONTEXT_TEMPLATE, "utf8");
         }
       } else {
-        await writeFile3(paths.projectContext, PROJECT_CONTEXT_TEMPLATE, "utf8");
-        ui.success(`Created ${path7.relative(root, paths.projectContext)}`);
+        await writeFile4(paths.projectContext, PROJECT_CONTEXT_TEMPLATE, "utf8");
+        ui.success(`Created ${path8.relative(root, paths.projectContext)}`);
       }
     }
-    const configExists = existsSync6(
-      path7.join(paths.haiveDir, "haive.config.json")
+    const configExists = existsSync7(
+      path8.join(paths.haiveDir, "haive.config.json")
     );
     if (!configExists) {
       await saveConfig(paths, autopilot ? AUTOPILOT_DEFAULTS : { autopilot: false });
@@ -2137,7 +2341,7 @@ function registerInit(program2) {
     if (opts.bridges) {
       await writeBridge(root, "CLAUDE.md");
       await writeBridge(root, ".cursorrules");
-      await writeBridge(root, path7.join(".github", "copilot-instructions.md"));
+      await writeBridge(root, path8.join(".github", "copilot-instructions.md"));
       await writeCursorHaiveRule(root);
     }
     const stacksToSeed = await resolveStacksToSeed(root, wantStack);
@@ -2160,18 +2364,18 @@ function registerInit(program2) {
     }
     const wantCi = opts.withCi || autopilot;
     if (wantCi) {
-      const ciPath = path7.join(root, ".github", "workflows", "haive-sync.yml");
-      if (existsSync6(ciPath)) {
+      const ciPath = path8.join(root, ".github", "workflows", "haive-sync.yml");
+      if (existsSync7(ciPath)) {
         ui.info("CI workflow already exists \u2014 skipped");
       } else {
-        await mkdir4(path7.dirname(ciPath), { recursive: true });
-        await writeFile3(ciPath, CI_WORKFLOW, "utf8");
-        ui.success(`Created ${path7.relative(root, ciPath)}`);
+        await mkdir5(path8.dirname(ciPath), { recursive: true });
+        await writeFile4(ciPath, CI_WORKFLOW, "utf8");
+        ui.success(`Created ${path8.relative(root, ciPath)}`);
       }
     }
     if (autopilot) {
       const haiveBin = process.argv[1];
-      const enforcementResult = spawnSync(
+      const enforcementResult = spawnSync2(
         process.execPath,
         [haiveBin, "enforce", "install", "--dir", root],
         { encoding: "utf8" }
@@ -2191,36 +2395,28 @@ function registerInit(program2) {
       }
     }
     if (opts.mcpSetup !== false) {
-      const mcpResults = await autoConfigureMcpClients();
-      const configured = mcpResults.filter((r) => r.status === "configured");
-      const alreadyOk = mcpResults.filter((r) => r.status === "already_configured");
-      for (const r of configured) {
-        ui.success(`haive MCP configured in ${r.client} (${r.path})`);
-      }
-      for (const r of alreadyOk) {
-        ui.info(`haive MCP already configured in ${r.client} \u2014 skipped`);
-      }
-      if (configured.length === 0 && alreadyOk.length === 0) {
-        ui.warn(
-          'No supported AI client detected (Cursor, VS Code, Claude Code, Windsurf).\n  Configure manually: command "haive", args ["mcp", "--stdio"].\n  See: https://github.com/Doucs91/hAIve#mcp-setup'
-        );
+      const agentSetup = await setupAgentMode(root, {
+        yes: opts.yes === true,
+        global: true,
+        interactive: process.stdin.isTTY
+      });
+      for (const r of agentSetup.project_results) {
+        if (r.status === "configured" && r.path) ui.success(`haive MCP project config written (${path8.relative(root, r.path)})`);
+        else if (r.status === "error") ui.warn(`${r.client}: ${r.error}`);
       }
-      const projectMcpResults = await configureProjectMcpClients(root);
-      for (const r of projectMcpResults) {
-        if (r.status === "configured") {
-          ui.success(`haive MCP project config written (${path7.relative(root, r.path)})`);
-        }
+      for (const r of agentSetup.global_results) {
+        if (r.status === "configured") ui.success(`haive MCP configured in ${r.client}${r.path ? ` (${r.path})` : ""}`);
+        else if (r.status === "already_configured") ui.info(`haive MCP already configured in ${r.client} \u2014 skipped`);
       }
+      if (agentSetup.global_skipped_reason) ui.warn(agentSetup.global_skipped_reason);
+      ui.info(`Recommended agent mode: ${agentSetup.detection.recommended_mode}`);
+      ui.info(agentSetup.detection.recommended_command);
       await ensureGitignoreEntries(root, [
         ".cursor/mcp.json",
         ".vscode/mcp.json",
         ".mcp.json"
       ]);
-      if (configured.length > 0 || projectMcpResults.some((r) => r.status === "configured")) {
-        ui.info(
-          ui.dim("  \u2192 Restart your AI client for MCP changes to take effect.")
-        );
-      }
+      ui.info(ui.dim("  \u2192 Restart your AI client for MCP changes to take effect."));
     }
     ui.success(`hAIve initialized at ${root}${autopilot ? " (autopilot mode)" : ""}`);
     console.log();
@@ -2269,8 +2465,8 @@ function registerInit(program2) {
 async function resolveStacksToSeed(root, stackOpt) {
   if (!stackOpt) return [];
   if (stackOpt === "auto") {
-    const pkgPath = path7.join(root, "package.json");
-    if (!existsSync6(pkgPath)) return [];
+    const pkgPath = path8.join(root, "package.json");
+    if (!existsSync7(pkgPath)) return [];
     try {
       const pkg = JSON.parse(await readFile4(pkgPath, "utf8"));
       const allDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
@@ -2283,23 +2479,23 @@ async function resolveStacksToSeed(root, stackOpt) {
 }
 async function writeCursorHaiveRule(root) {
   const relPath = ".cursor/rules/haive-mcp-required.mdc";
-  const target = path7.join(root, relPath);
-  if (existsSync6(target)) {
+  const target = path8.join(root, relPath);
+  if (existsSync7(target)) {
     ui.info(`Cursor rule ${relPath} already exists \u2014 skipped`);
     return;
   }
-  await mkdir4(path7.dirname(target), { recursive: true });
-  await writeFile3(target, CURSOR_HAIVE_RULE_MDC, "utf8");
+  await mkdir5(path8.dirname(target), { recursive: true });
+  await writeFile4(target, CURSOR_HAIVE_RULE_MDC, "utf8");
   ui.success(`Created Cursor rule ${relPath}`);
 }
 async function writeBridge(root, relPath) {
-  const target = path7.join(root, relPath);
-  if (existsSync6(target)) {
+  const target = path8.join(root, relPath);
+  if (existsSync7(target)) {
     ui.info(`Bridge ${relPath} already exists \u2014 skipped`);
     return;
   }
-  await mkdir4(path7.dirname(target), { recursive: true });
-  await writeFile3(target, BRIDGE_BODY, "utf8");
+  await mkdir5(path8.dirname(target), { recursive: true });
+  await writeFile4(target, BRIDGE_BODY, "utf8");
   ui.success(`Created bridge ${relPath}`);
 }
 var RUNTIME_README_BODY = `# .ai/.runtime \u2014 disposable local layer
@@ -2315,43 +2511,43 @@ var RUNTIME_GITIGNORE_BODY = `*
 !README.md
 `;
 async function ensureAiRuntimeLayout(runtimeDir) {
-  await mkdir4(runtimeDir, { recursive: true });
-  const gi = path7.join(runtimeDir, ".gitignore");
-  if (!existsSync6(gi)) {
-    await writeFile3(gi, RUNTIME_GITIGNORE_BODY, "utf8");
+  await mkdir5(runtimeDir, { recursive: true });
+  const gi = path8.join(runtimeDir, ".gitignore");
+  if (!existsSync7(gi)) {
+    await writeFile4(gi, RUNTIME_GITIGNORE_BODY, "utf8");
   }
-  const readme = path7.join(runtimeDir, "README.md");
-  if (!existsSync6(readme)) {
-    await writeFile3(readme, RUNTIME_README_BODY, "utf8");
+  const readme = path8.join(runtimeDir, "README.md");
+  if (!existsSync7(readme)) {
+    await writeFile4(readme, RUNTIME_README_BODY, "utf8");
   }
 }
 async function ensureGitignoreEntries(root, patterns) {
   try {
-    const gitignorePath = path7.join(root, ".gitignore");
+    const gitignorePath = path8.join(root, ".gitignore");
     let existing = "";
-    if (existsSync6(gitignorePath)) {
+    if (existsSync7(gitignorePath)) {
       existing = await readFile4(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 writeFile3(gitignorePath, existing + toAppend, "utf8");
+    await writeFile4(gitignorePath, existing + toAppend, "utf8");
   } catch {
   }
 }
 
 // src/commands/install-hooks.ts
-import { mkdir as mkdir6, writeFile as writeFile5, chmod, readFile as readFile6 } from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
-import path9 from "path";
+import { mkdir as mkdir7, writeFile as writeFile6, chmod, readFile as readFile6 } from "fs/promises";
+import { existsSync as existsSync9 } from "fs";
+import path10 from "path";
 import "commander";
-import { findProjectRoot as findProjectRoot6 } from "@hiveai/core";
+import { findProjectRoot as findProjectRoot7 } from "@hiveai/core";
 
 // src/utils/claude-hooks.ts
-import { existsSync as existsSync7 } from "fs";
-import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
-import path8 from "path";
+import { existsSync as existsSync8 } from "fs";
+import { mkdir as mkdir6, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import path9 from "path";
 var HAIVE_HOOK_TAG = "haive-enforcement";
 var POST_TOOL_USE_GROUP = {
   matcher: "Edit|Write|Bash",
@@ -2437,7 +2633,7 @@ function unpatchClaudeSettings(input) {
 async function installClaudeHooksAtPath(settingsPath) {
   let raw = null;
   let created = false;
-  if (existsSync7(settingsPath)) {
+  if (existsSync8(settingsPath)) {
     try {
       raw = JSON.parse(await readFile5(settingsPath, "utf8"));
     } catch {
@@ -2447,25 +2643,25 @@ async function installClaudeHooksAtPath(settingsPath) {
     created = true;
   }
   const patched = patchClaudeSettings(raw);
-  await mkdir5(path8.dirname(settingsPath), { recursive: true });
-  await writeFile4(settingsPath, JSON.stringify(patched, null, 2) + "\n", "utf8");
+  await mkdir6(path9.dirname(settingsPath), { recursive: true });
+  await writeFile5(settingsPath, JSON.stringify(patched, null, 2) + "\n", "utf8");
   return { settingsPath, created };
 }
 async function uninstallClaudeHooksAtPath(settingsPath) {
-  if (!existsSync7(settingsPath)) {
+  if (!existsSync8(settingsPath)) {
     return { settingsPath, created: false };
   }
   const raw = JSON.parse(await readFile5(settingsPath, "utf8"));
   const cleaned = unpatchClaudeSettings(raw);
-  await writeFile4(settingsPath, JSON.stringify(cleaned, null, 2) + "\n", "utf8");
+  await writeFile5(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 path8.join(home, ".claude", "settings.json");
+    return path9.join(home, ".claude", "settings.json");
   }
-  return path8.join(projectRoot, ".claude", "settings.local.json");
+  return path9.join(projectRoot, ".claude", "settings.local.json");
 }
 
 // src/commands/install-hooks.ts
@@ -2521,20 +2717,20 @@ fi
   }
 ];
 async function installGitHooks(opts) {
-  const root = findProjectRoot6(opts.dir);
-  const gitDir = path9.join(root, ".git");
-  if (!existsSync8(gitDir)) {
+  const root = findProjectRoot7(opts.dir);
+  const gitDir = path10.join(root, ".git");
+  if (!existsSync9(gitDir)) {
     ui.error(`No .git directory at ${root}.`);
     process.exitCode = 1;
     return;
   }
-  const hooksDir = path9.join(gitDir, "hooks");
-  await mkdir6(hooksDir, { recursive: true });
+  const hooksDir = path10.join(gitDir, "hooks");
+  await mkdir7(hooksDir, { recursive: true });
   let installed = 0;
   let skipped = 0;
   for (const { name, body } of HOOKS) {
-    const file = path9.join(hooksDir, name);
-    if (existsSync8(file) && !opts.force) {
+    const file = path10.join(hooksDir, name);
+    if (existsSync9(file) && !opts.force) {
       const existing = await readFile6(file, "utf8");
       if (!existing.includes(HOOK_MARKER)) {
         ui.warn(`${name} already exists and was not written by hAIve. Re-run with --force to overwrite.`);
@@ -2542,7 +2738,7 @@ async function installGitHooks(opts) {
         continue;
       }
     }
-    await writeFile5(file, body, "utf8");
+    await writeFile6(file, body, "utf8");
     await chmod(file, 493);
     installed++;
   }
@@ -2552,7 +2748,7 @@ async function installGitHooks(opts) {
   ui.info("pre-push:   haive enforce check blocks pushes that bypass briefing/session recap policy.");
 }
 async function installClaudeHooks(opts) {
-  const root = findProjectRoot6(opts.dir);
+  const root = findProjectRoot7(opts.dir);
   const scope = opts.scope ?? "user";
   const settingsPath = opts.settings ?? defaultClaudeSettingsPath(scope, root);
   if (opts.uninstall) {
@@ -2597,11 +2793,11 @@ function registerInstallHooks(program2) {
 }
 
 // src/commands/observe.ts
-import { appendFile, mkdir as mkdir7 } from "fs/promises";
-import { existsSync as existsSync9 } from "fs";
-import path10 from "path";
+import { appendFile, mkdir as mkdir8 } from "fs/promises";
+import { existsSync as existsSync10 } from "fs";
+import path11 from "path";
 import "commander";
-import { findProjectRoot as findProjectRoot7, resolveHaivePaths as resolveHaivePaths5 } from "@hiveai/core";
+import { findProjectRoot as findProjectRoot8, resolveHaivePaths as resolveHaivePaths6 } from "@hiveai/core";
 var MAX_STDIN_BYTES = 256 * 1024;
 var TRUNCATE_FIELD = 800;
 function truncate(s, max = TRUNCATE_FIELD) {
@@ -2671,14 +2867,14 @@ function registerObserve(program2) {
       }
       const root = (() => {
         try {
-          return findProjectRoot7(opts.dir ?? payload.cwd);
+          return findProjectRoot8(opts.dir ?? payload.cwd);
         } catch {
           return null;
         }
       })();
       if (!root) return;
-      const paths = resolveHaivePaths5(root);
-      if (!existsSync9(paths.haiveDir)) return;
+      const paths = resolveHaivePaths6(root);
+      if (!existsSync10(paths.haiveDir)) return;
       const observation = {
         ts: (/* @__PURE__ */ new Date()).toISOString(),
         session_id: payload.session_id,
@@ -2687,10 +2883,10 @@ function registerObserve(program2) {
         summary: buildSummary(payload),
         files: extractFiles(payload)
       };
-      const cacheDir = path10.join(paths.haiveDir, ".cache");
-      await mkdir7(cacheDir, { recursive: true });
+      const cacheDir = path11.join(paths.haiveDir, ".cache");
+      await mkdir8(cacheDir, { recursive: true });
       await appendFile(
-        path10.join(cacheDir, "observations.jsonl"),
+        path11.join(cacheDir, "observations.jsonl"),
         JSON.stringify(observation) + "\n",
         "utf8"
       );
@@ -2701,15 +2897,15 @@ function registerObserve(program2) {
 
 // src/commands/mcp.ts
 import "commander";
-import { findProjectRoot as findProjectRoot9 } from "@hiveai/core";
+import { findProjectRoot as findProjectRoot10 } from "@hiveai/core";
 
 // ../mcp/dist/server.js
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { findProjectRoot as findProjectRoot8, resolveHaivePaths as resolveHaivePaths6 } from "@hiveai/core";
-import { mkdir as mkdir8, writeFile as writeFile6 } from "fs/promises";
-import { existsSync as existsSync10 } from "fs";
-import path11 from "path";
+import { findProjectRoot as findProjectRoot9, resolveHaivePaths as resolveHaivePaths7 } from "@hiveai/core";
+import { mkdir as mkdir9, writeFile as writeFile7 } from "fs/promises";
+import { existsSync as existsSync11 } from "fs";
+import path12 from "path";
 import { z } from "zod";
 import { readFile as readFile7, readdir as readdir2 } from "fs/promises";
 import { existsSync as existsSync22 } from "fs";
@@ -2793,7 +2989,7 @@ import {
 } from "@hiveai/core";
 import { z as z10 } from "zod";
 import { writeFile as writeFile52 } from "fs/promises";
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync112 } from "fs";
 import { loadMemoriesFromDir as loadMemoriesFromDir9, serializeMemory as serializeMemory4 } from "@hiveai/core";
 import { z as z11 } from "zod";
 import { existsSync as existsSync12 } from "fs";
@@ -2810,7 +3006,7 @@ import {
   serializeMemory as serializeMemory5
 } from "@hiveai/core";
 import { z as z13 } from "zod";
-import { mkdir as mkdir32, writeFile as writeFile7 } from "fs/promises";
+import { mkdir as mkdir32, writeFile as writeFile72 } from "fs/promises";
 import { existsSync as existsSync14 } from "fs";
 import path52 from "path";
 import {
@@ -2971,8 +3167,8 @@ import { loadConfigSync } from "@hiveai/core";
 function createContext(options = {}) {
   const env = options.env ?? process.env;
   const cwd = options.cwd ?? process.cwd();
-  const root = options.root ?? env.HAIVE_PROJECT_ROOT ?? findProjectRoot8(cwd);
-  return { paths: resolveHaivePaths6(root) };
+  const root = options.root ?? env.HAIVE_PROJECT_ROOT ?? findProjectRoot9(cwd);
+  return { paths: resolveHaivePaths7(root) };
 }
 var BootstrapProjectSaveInputSchema = {
   content: z.string().min(1).describe("Full Markdown content for the project (or module) context file"),
@@ -2982,15 +3178,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 ? path11.join(ctx.paths.modulesContextDir, input.module, "context.md") : ctx.paths.projectContext;
-  const exists = existsSync10(target);
+  const target = input.module ? path12.join(ctx.paths.modulesContextDir, input.module, "context.md") : ctx.paths.projectContext;
+  const exists = existsSync11(target);
   if (exists && !input.overwrite) {
     throw new Error(
       `${target} already exists. Pass overwrite=true to replace it.`
     );
   }
-  await mkdir8(path11.dirname(target), { recursive: true });
-  await writeFile6(target, input.content, "utf8");
+  await mkdir9(path12.dirname(target), { recursive: true });
+  await writeFile7(target, input.content, "utf8");
   return {
     file_path: target,
     action: exists ? "overwritten" : "created"
@@ -3744,7 +3940,7 @@ var MemUpdateInputSchema = {
   author: z11.string().optional().describe("New author handle or email")
 };
 async function memUpdate(input, ctx) {
-  if (!existsSync11(ctx.paths.memoriesDir)) {
+  if (!existsSync112(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
   const memories = await loadMemoriesFromDir9(ctx.paths.memoriesDir);
@@ -3880,7 +4076,7 @@ async function memTried(input, ctx) {
   if (existsSync14(file)) {
     throw new Error(`Memory already exists at ${file}`);
   }
-  await writeFile7(file, serializeMemory6({ frontmatter, body }), "utf8");
+  await writeFile72(file, serializeMemory6({ frontmatter, body }), "utf8");
   return { id: frontmatter.id, scope: frontmatter.scope, file_path: file };
 }
 var MemObserveInputSchema = {
@@ -6072,7 +6268,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
   };
 }
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.9.10";
+var SERVER_VERSION = "0.9.12";
 function jsonResult(data) {
   return {
     content: [
@@ -6086,14 +6282,11 @@ function jsonResult(data) {
 var ENFORCEMENT_PROFILE_TOOLS = /* @__PURE__ */ new Set([
   "get_briefing",
   "mem_save",
-  "mem_tried",
   "mem_search",
-  "mem_get",
-  "mem_update",
   "mem_verify",
   "mem_relevant_to",
-  "code_map",
-  "pre_commit_check"
+  "pre_commit_check",
+  "mem_session_end"
 ]);
 var BRIEFING_TOOLS = /* @__PURE__ */ new Set(["get_briefing", "mem_relevant_to"]);
 var MUTATING_TOOLS = /* @__PURE__ */ new Set([
@@ -6984,7 +7177,7 @@ function registerMcp(program2) {
   ).option("-d, --dir <dir>", "project root (walks up from here for .ai/ / .git/)").option("-r, --root <dir>", "same as --dir (parity with legacy haive-mcp --root)").option("--stdio", "optional marker for client configs \u2014 transport is always stdio", false).action(async (opts) => {
     void opts.stdio;
     const raw = opts.root ?? opts.dir;
-    const root = raw ? findProjectRoot9(raw) : findProjectRoot9();
+    const root = raw ? findProjectRoot10(raw) : findProjectRoot10();
     try {
       await runHaiveMcpStdio({ root });
     } catch (err) {
@@ -6995,15 +7188,15 @@ function registerMcp(program2) {
 }
 
 // src/commands/sync.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import { readFile as readFile8, writeFile as writeFile13, mkdir as mkdir9 } from "fs/promises";
+import { spawnSync as spawnSync3 } from "child_process";
+import { readFile as readFile8, writeFile as writeFile13, mkdir as mkdir10 } from "fs/promises";
 import { existsSync as existsSync29 } from "fs";
-import path12 from "path";
+import path13 from "path";
 import "commander";
 import {
   DEFAULT_AUTO_PROMOTE_RULE as DEFAULT_AUTO_PROMOTE_RULE2,
   buildFrontmatter as buildFrontmatter6,
-  findProjectRoot as findProjectRoot10,
+  findProjectRoot as findProjectRoot11,
   getUsage as getUsage10,
   isAutoPromoteEligible as isAutoPromoteEligible2,
   isDecaying as isDecaying2,
@@ -7012,7 +7205,7 @@ import {
   loadMemoriesFromDir as loadMemoriesFromDir23,
   loadUsageIndex as loadUsageIndex12,
   pullCrossRepoSources,
-  resolveHaivePaths as resolveHaivePaths7,
+  resolveHaivePaths as resolveHaivePaths8,
   resolveManifestFiles,
   serializeMemory as serializeMemory11,
   trackDependencies,
@@ -7031,8 +7224,8 @@ function registerSync(program2) {
     "--inject-bridge",
     "inject top validated memories into CLAUDE.md (or --bridge-file) between <!-- haive:memories-start/end --> markers"
   ).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").action(async (opts) => {
-    const root = findProjectRoot10(opts.dir);
-    const paths = resolveHaivePaths7(root);
+    const root = findProjectRoot11(opts.dir);
+    const paths = resolveHaivePaths8(root);
     if (!existsSync29(paths.memoriesDir)) {
       if (!opts.quiet) ui.warn(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
@@ -7165,7 +7358,7 @@ function registerSync(program2) {
       );
     }
     if (opts.injectBridge) {
-      const bridgeFile = opts.bridgeFile ? path12.resolve(opts.bridgeFile) : path12.join(root, "CLAUDE.md");
+      const bridgeFile = opts.bridgeFile ? path13.resolve(opts.bridgeFile) : path13.join(root, "CLAUDE.md");
       const maxInject = Math.max(1, Number(opts.bridgeMaxMemories ?? 5));
       await injectBridge(bridgeFile, paths.memoriesDir, maxInject, root, opts.quiet);
     }
@@ -7271,10 +7464,10 @@ Attends une **confirmation explicite** avant d'agir.
                   paths: [result.file],
                   topic: `dep-bump-${slugParts}`
                 });
-                const teamDir = path12.join(paths.memoriesDir, "team");
-                await mkdir9(teamDir, { recursive: true });
+                const teamDir = path13.join(paths.memoriesDir, "team");
+                await mkdir10(teamDir, { recursive: true });
                 await writeFile13(
-                  path12.join(teamDir, `${fm.id}.md`),
+                  path13.join(teamDir, `${fm.id}.md`),
                   serializeMemory11({ frontmatter: { ...fm, requires_human_approval: true }, body }),
                   "utf8"
                 );
@@ -7338,10 +7531,10 @@ Attends une **confirmation explicite** avant d'agir.
               paths: [diff.file],
               topic: `contract-breaking-${diff.contract}`
             });
-            const teamDir = path12.join(paths.memoriesDir, "team");
-            await mkdir9(teamDir, { recursive: true });
+            const teamDir = path13.join(paths.memoriesDir, "team");
+            await mkdir10(teamDir, { recursive: true });
             await writeFile13(
-              path12.join(teamDir, `${fm.id}.md`),
+              path13.join(teamDir, `${fm.id}.md`),
               serializeMemory11({ frontmatter: { ...fm, requires_human_approval: true }, body }),
               "utf8"
             );
@@ -7355,7 +7548,7 @@ Attends une **confirmation explicite** avant d'agir.
     const existingMap = await loadCodeMap4(paths);
     if (existingMap) {
       const mapAge = new Date(existingMap.generated_at).getTime();
-      const gitResult = spawnSync2(
+      const gitResult = spawnSync3(
         "git",
         [
           "diff",
@@ -7434,11 +7627,11 @@ ${BRIDGE_END}`;
   const startIdx = existing.indexOf(BRIDGE_START);
   const endIdx = existing.indexOf(BRIDGE_END);
   if (startIdx !== -1 && endIdx === -1) {
-    ui.warn(`${path12.relative(root, bridgeFile)}: found ${BRIDGE_START} without ${BRIDGE_END}. Fix the file manually before running --inject-bridge.`);
+    ui.warn(`${path13.relative(root, bridgeFile)}: found ${BRIDGE_START} without ${BRIDGE_END}. Fix the file manually before running --inject-bridge.`);
     return;
   }
   if (startIdx === -1 && endIdx !== -1) {
-    ui.warn(`${path12.relative(root, bridgeFile)}: found ${BRIDGE_END} without ${BRIDGE_START}. Fix the file manually before running --inject-bridge.`);
+    ui.warn(`${path13.relative(root, bridgeFile)}: found ${BRIDGE_END} without ${BRIDGE_START}. Fix the file manually before running --inject-bridge.`);
     return;
   }
   let updated;
@@ -7446,19 +7639,19 @@ ${BRIDGE_END}`;
     updated = existing.slice(0, startIdx) + injected + existing.slice(endIdx + BRIDGE_END.length);
   } else {
     if (!fileExists && !quiet) {
-      ui.info(`Creating ${path12.relative(root, bridgeFile)} with haive memory block.`);
+      ui.info(`Creating ${path13.relative(root, bridgeFile)} with haive memory block.`);
     }
     updated = existing + (existing.endsWith("\n") ? "" : "\n") + "\n" + injected + "\n";
   }
   await writeFile13(bridgeFile, updated, "utf8");
   if (!quiet) {
     console.log(
-      ui.dim(`bridge: injected ${top.length} memor${top.length === 1 ? "y" : "ies"} into ${path12.relative(root, bridgeFile)}`)
+      ui.dim(`bridge: injected ${top.length} memor${top.length === 1 ? "y" : "ies"} into ${path13.relative(root, bridgeFile)}`)
     );
   }
 }
 function collectSinceChanges(root, ref) {
-  const result = spawnSync2(
+  const result = spawnSync3(
     "git",
     ["-C", root, "diff", "--name-status", "--diff-filter=AMD", `${ref}...HEAD`, "--", ".ai/memories"],
     { encoding: "utf8" }
@@ -7478,17 +7671,17 @@ function collectSinceChanges(root, ref) {
 
 // src/commands/memory-add.ts
 import { createHash as createHash2 } from "crypto";
-import { mkdir as mkdir10, readFile as readFile9, writeFile as writeFile14 } from "fs/promises";
+import { mkdir as mkdir11, readFile as readFile9, writeFile as writeFile14 } from "fs/promises";
 import { existsSync as existsSync30 } from "fs";
-import path13 from "path";
+import path14 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter7,
-  findProjectRoot as findProjectRoot11,
+  findProjectRoot as findProjectRoot12,
   inferModulesFromPaths as inferModulesFromPaths3,
   loadMemoriesFromDir as loadMemoriesFromDir24,
   memoryFilePath as memoryFilePath6,
-  resolveHaivePaths as resolveHaivePaths8,
+  resolveHaivePaths as resolveHaivePaths9,
   serializeMemory as serializeMemory12
 } from "@hiveai/core";
 function registerMemoryAdd(memory2) {
@@ -7516,8 +7709,8 @@ function registerMemoryAdd(memory2) {
       --scope team --body "Never modify existing migrations. Create V{n+1}__desc.sql."
 `
   ).requiredOption("--type <type>", "convention | decision | gotcha | architecture | glossary | attempt").requiredOption("--slug <slug>", "short kebab-case identifier used in the file name").option("--title <text>", "memory title \u2014 becomes the first heading of the body").option("--scope <scope>", "personal | team | module (default: personal, or team in autopilot)", "personal").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("--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("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot11(opts.dir);
-    const paths = resolveHaivePaths8(root);
+    const root = findProjectRoot12(opts.dir);
+    const paths = resolveHaivePaths9(root);
     if (!existsSync30(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
@@ -7529,7 +7722,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) => !existsSync30(path13.resolve(root, p)));
+      const missing = anchorPaths.filter((p) => !existsSync30(path14.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}`);
@@ -7594,7 +7787,7 @@ TODO \u2014 write the memory body.
           }
         };
         await writeFile14(topicMatch.filePath, serializeMemory12({ frontmatter: newFrontmatter, body }), "utf8");
-        ui.success(`Updated (topic upsert) ${path13.relative(root, topicMatch.filePath)}`);
+        ui.success(`Updated (topic upsert) ${path14.relative(root, topicMatch.filePath)}`);
         ui.info(`id=${fm.id}  revision=${revisionCount}`);
         return;
       }
@@ -7613,7 +7806,7 @@ TODO \u2014 write the memory body.
       topic: opts.topic
     });
     const file = memoryFilePath6(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir10(path13.dirname(file), { recursive: true });
+    await mkdir11(path14.dirname(file), { recursive: true });
     if (existsSync30(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
@@ -7632,7 +7825,7 @@ TODO \u2014 write the memory body.
       }
     }
     await writeFile14(file, serializeMemory12({ frontmatter, body }), "utf8");
-    ui.success(`Created ${path13.relative(root, file)}`);
+    ui.success(`Created ${path14.relative(root, file)}`);
     ui.info(`id=${frontmatter.id}  scope=${frontmatter.scope}  status=${frontmatter.status}`);
     if (inferredTags.length > 0) {
       ui.info(`auto-tagged: ${inferredTags.join(", ")}  (use --no-auto-tag to disable)`);
@@ -7663,9 +7856,9 @@ function parseCsv2(value) {
 
 // src/commands/memory-list.ts
 import { existsSync as existsSync31 } from "fs";
-import path14 from "path";
+import path15 from "path";
 import "commander";
-import { findProjectRoot as findProjectRoot12, resolveHaivePaths as resolveHaivePaths9 } from "@hiveai/core";
+import { findProjectRoot as findProjectRoot13, resolveHaivePaths as resolveHaivePaths10 } from "@hiveai/core";
 
 // src/utils/fs.ts
 import {
@@ -7677,8 +7870,8 @@ import {
 // src/commands/memory-list.ts
 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("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot12(opts.dir);
-    const paths = resolveHaivePaths9(root);
+    const root = findProjectRoot13(opts.dir);
+    const paths = resolveHaivePaths10(root);
     if (!existsSync31(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
@@ -7711,7 +7904,7 @@ function registerMemoryList(memory2) {
       console.log(
         `${ui.bold(fm.id)} ${ui.dim(fm.scope)}/${ui.dim(fm.type)} ${statusBadge}${moduleStr}${tagStr}`
       );
-      console.log(`  ${ui.dim(path14.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path15.relative(root, filePath))}`);
     }
     console.log(ui.dim(`
 ${filtered.length} memor${filtered.length === 1 ? "y" : "ies"}`));
@@ -7746,20 +7939,20 @@ function matchesFilters(loaded, opts) {
 }
 
 // src/commands/memory-promote.ts
-import { mkdir as mkdir11, unlink as unlink2, writeFile as writeFile15 } from "fs/promises";
+import { mkdir as mkdir12, unlink as unlink2, writeFile as writeFile15 } from "fs/promises";
 import { existsSync as existsSync33 } from "fs";
-import path15 from "path";
+import path16 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot13,
+  findProjectRoot as findProjectRoot14,
   memoryFilePath as memoryFilePath7,
-  resolveHaivePaths as resolveHaivePaths10,
+  resolveHaivePaths as resolveHaivePaths11,
   serializeMemory as serializeMemory13
 } from "@hiveai/core";
 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 = findProjectRoot13(opts.dir);
-    const paths = resolveHaivePaths10(root);
+    const root = findProjectRoot14(opts.dir);
+    const paths = resolveHaivePaths11(root);
     if (!existsSync33(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
@@ -7795,11 +7988,11 @@ function registerMemoryPromote(memory2) {
       body: found.memory.body
     };
     const newPath = memoryFilePath7(paths, "team", updated.frontmatter.id);
-    await mkdir11(path15.dirname(newPath), { recursive: true });
+    await mkdir12(path16.dirname(newPath), { recursive: true });
     await writeFile15(newPath, serializeMemory13(updated), "utf8");
     await unlink2(found.filePath);
     ui.success(`Promoted ${id} to team scope (status=proposed)`);
-    ui.info(`Now at ${path15.relative(root, newPath)}`);
+    ui.info(`Now at ${path16.relative(root, newPath)}`);
     console.log(ui.dim(`\u2192 next: haive memory approve ${id}  (validate for team use)`));
   });
 }
@@ -7807,17 +8000,17 @@ function registerMemoryPromote(memory2) {
 // src/commands/memory-approve.ts
 import { existsSync as existsSync34 } from "fs";
 import { writeFile as writeFile16 } from "fs/promises";
-import path16 from "path";
+import path17 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot14,
-  resolveHaivePaths as resolveHaivePaths11,
+  findProjectRoot as findProjectRoot15,
+  resolveHaivePaths as resolveHaivePaths12,
   serializeMemory as serializeMemory14
 } from "@hiveai/core";
 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 = findProjectRoot14(opts.dir);
-    const paths = resolveHaivePaths11(root);
+    const root = findProjectRoot15(opts.dir);
+    const paths = resolveHaivePaths12(root);
     if (!existsSync34(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
@@ -7871,24 +8064,24 @@ function registerMemoryApprove(memory2) {
     };
     await writeFile16(found.filePath, serializeMemory14(next), "utf8");
     ui.success(`Approved ${id} (status=validated)`);
-    ui.info(path16.relative(root, found.filePath));
+    ui.info(path17.relative(root, found.filePath));
   });
 }
 
 // src/commands/memory-update.ts
 import { writeFile as writeFile17 } from "fs/promises";
 import { existsSync as existsSync35 } from "fs";
-import path17 from "path";
+import path18 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot15,
-  resolveHaivePaths as resolveHaivePaths12,
+  findProjectRoot as findProjectRoot16,
+  resolveHaivePaths as resolveHaivePaths13,
   serializeMemory as serializeMemory15
 } from "@hiveai/core";
 function registerMemoryUpdate(memory2) {
   memory2.command("update <id>").description("Update body, tags, or anchor of an existing memory (preserves id and usage history)").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("--tags <csv>", "new tags, comma-separated \u2014 fully replaces existing tags").option("--paths <csv>", "new anchor paths, comma-separated").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 = findProjectRoot15(opts.dir);
-    const paths = resolveHaivePaths12(root);
+    const root = findProjectRoot16(opts.dir);
+    const paths = resolveHaivePaths13(root);
     if (!existsSync35(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
@@ -7941,7 +8134,7 @@ function registerMemoryUpdate(memory2) {
       serializeMemory15({ frontmatter: newFrontmatter, body: newBody }),
       "utf8"
     );
-    ui.success(`Updated ${path17.relative(root, loaded.filePath)}`);
+    ui.success(`Updated ${path18.relative(root, loaded.filePath)}`);
     ui.info(`fields: ${updated.join(", ")}`);
   });
 }
@@ -7962,15 +8155,15 @@ function parseCsv3(value) {
 // src/commands/memory-auto-promote.ts
 import { writeFile as writeFile18 } from "fs/promises";
 import { existsSync as existsSync36 } from "fs";
-import path18 from "path";
+import path19 from "path";
 import "commander";
 import {
   DEFAULT_AUTO_PROMOTE_RULE as DEFAULT_AUTO_PROMOTE_RULE3,
-  findProjectRoot as findProjectRoot16,
+  findProjectRoot as findProjectRoot17,
   getUsage as getUsage11,
   isAutoPromoteEligible as isAutoPromoteEligible3,
   loadUsageIndex as loadUsageIndex13,
-  resolveHaivePaths as resolveHaivePaths13,
+  resolveHaivePaths as resolveHaivePaths14,
   serializeMemory as serializeMemory16
 } from "@hiveai/core";
 function registerMemoryAutoPromote(memory2) {
@@ -7979,8 +8172,8 @@ function registerMemoryAutoPromote(memory2) {
     "memories with more rejections than this are skipped",
     String(DEFAULT_AUTO_PROMOTE_RULE3.maxRejections)
   ).option("--apply", "actually write status=validated to disk (default: dry-run)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot16(opts.dir);
-    const paths = resolveHaivePaths13(root);
+    const root = findProjectRoot17(opts.dir);
+    const paths = resolveHaivePaths14(root);
     if (!existsSync36(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
@@ -8007,7 +8200,7 @@ function registerMemoryAutoPromote(memory2) {
       console.log(
         `${ui.bold(opts.apply ? "PROMOTE" : "would promote")}  ${mem.frontmatter.id}  ${ui.dim(`reads=${u.read_count} rejections=${u.rejected_count}`)}`
       );
-      console.log(`             ${ui.dim(path18.relative(root, filePath))}`);
+      console.log(`             ${ui.dim(path19.relative(root, filePath))}`);
       if (opts.apply) {
         const next = {
           frontmatter: { ...mem.frontmatter, status: "validated" },
@@ -8026,17 +8219,17 @@ function registerMemoryAutoPromote(memory2) {
 import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync37 } from "fs";
 import { readFile as readFile10 } from "fs/promises";
-import path19 from "path";
+import path20 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot17,
+  findProjectRoot as findProjectRoot18,
   parseMemory,
-  resolveHaivePaths as resolveHaivePaths14
+  resolveHaivePaths as resolveHaivePaths15
 } from "@hiveai/core";
 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 = findProjectRoot17(opts.dir);
-    const paths = resolveHaivePaths14(root);
+    const root = findProjectRoot18(opts.dir);
+    const paths = resolveHaivePaths15(root);
     if (!existsSync37(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
@@ -8050,7 +8243,7 @@ function registerMemoryEdit(memory2) {
       return;
     }
     const editor = opts.editor ?? process.env.EDITOR ?? process.env.VISUAL ?? "vi";
-    ui.info(`Opening ${path19.relative(root, found.filePath)} with ${editor}\u2026`);
+    ui.info(`Opening ${path20.relative(root, found.filePath)} with ${editor}\u2026`);
     const code = await runEditor(editor, found.filePath);
     if (code !== 0) {
       ui.warn(`Editor exited with status ${code}.`);
@@ -8078,21 +8271,21 @@ function runEditor(editor, file) {
 
 // src/commands/memory-for-files.ts
 import { existsSync as existsSync38 } from "fs";
-import path20 from "path";
+import path21 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence9,
-  findProjectRoot as findProjectRoot18,
+  findProjectRoot as findProjectRoot19,
   getUsage as getUsage12,
   inferModulesFromPaths as inferModulesFromPaths4,
   loadUsageIndex as loadUsageIndex14,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths5,
-  resolveHaivePaths as resolveHaivePaths15
+  resolveHaivePaths as resolveHaivePaths16
 } from "@hiveai/core";
 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 = findProjectRoot18(opts.dir);
-    const paths = resolveHaivePaths15(root);
+    const root = findProjectRoot19(opts.dir);
+    const paths = resolveHaivePaths16(root);
     if (!existsSync38(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
@@ -8200,24 +8393,24 @@ function printGroup(root, label, loaded, usage) {
     const u = getUsage12(usage, fm.id);
     const conf = deriveConfidence9(fm, u);
     console.log(`${ui.bold(fm.id)}  ${ui.dim(`${fm.scope}/${fm.type}`)}  ${ui.bold(conf)}`);
-    console.log(`  ${ui.dim(path20.relative(root, filePath))}`);
+    console.log(`  ${ui.dim(path21.relative(root, filePath))}`);
   }
 }
 
 // src/commands/memory-hot.ts
 import { existsSync as existsSync39 } from "fs";
-import path21 from "path";
+import path23 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot19,
+  findProjectRoot as findProjectRoot20,
   getUsage as getUsage13,
   loadUsageIndex as loadUsageIndex15,
-  resolveHaivePaths as resolveHaivePaths16
+  resolveHaivePaths as resolveHaivePaths17
 } from "@hiveai/core";
 function registerMemoryHot(memory2) {
   memory2.command("hot").description("List memories actively used but not yet validated (good promotion candidates)").option("--threshold <n>", "minimum read_count to qualify", "3").option("--status <status>", "limit to one status (default: draft + proposed)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot19(opts.dir);
-    const paths = resolveHaivePaths16(root);
+    const root = findProjectRoot20(opts.dir);
+    const paths = resolveHaivePaths17(root);
     if (!existsSync39(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
@@ -8246,7 +8439,7 @@ function registerMemoryHot(memory2) {
       console.log(
         `${ui.bold(fm.id)}  ${ui.dim(`${fm.scope}/${fm.type}`)}  ${ui.bold(fm.status)}  ${ui.dim(`reads=${u.read_count} rejections=${u.rejected_count}`)}`
       );
-      console.log(`  ${ui.dim(path21.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path23.relative(root, filePath))}`);
     }
     ui.info(
       `${candidates.length} hot \u2014 promote drafts with \`haive memory promote <id>\`, then \`haive memory auto-promote --apply\`.`
@@ -8255,15 +8448,15 @@ function registerMemoryHot(memory2) {
 }
 
 // src/commands/memory-tried.ts
-import { mkdir as mkdir12, writeFile as writeFile19 } from "fs/promises";
+import { mkdir as mkdir13, writeFile as writeFile19 } from "fs/promises";
 import { existsSync as existsSync40 } from "fs";
-import path23 from "path";
+import path24 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter8,
-  findProjectRoot as findProjectRoot20,
+  findProjectRoot as findProjectRoot21,
   memoryFilePath as memoryFilePath8,
-  resolveHaivePaths as resolveHaivePaths17,
+  resolveHaivePaths as resolveHaivePaths18,
   serializeMemory as serializeMemory17
 } from "@hiveai/core";
 function registerMemoryTried(memory2) {
@@ -8283,8 +8476,8 @@ function registerMemoryTried(memory2) {
       --paths packages/cli/src/index.ts
 `
   ).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 (default: personal)", "personal").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags").option("--paths <csv>", "anchor paths, comma-separated").option("--author <author>", "author email or handle").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot20(opts.dir);
-    const paths = resolveHaivePaths17(root);
+    const root = findProjectRoot21(opts.dir);
+    const paths = resolveHaivePaths18(root);
     if (!existsSync40(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
@@ -8308,14 +8501,14 @@ function registerMemoryTried(memory2) {
     }
     const body = lines.join("\n") + "\n";
     const file = memoryFilePath8(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir12(path23.dirname(file), { recursive: true });
+    await mkdir13(path24.dirname(file), { recursive: true });
     if (existsSync40(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
       return;
     }
     await writeFile19(file, serializeMemory17({ frontmatter, body }), "utf8");
-    ui.success(`Recorded: ${path23.relative(root, file)}`);
+    ui.success(`Recorded: ${path24.relative(root, file)}`);
     ui.info(`id=${frontmatter.id}  type=attempt  status=validated (auto-approved)`);
   });
 }
@@ -8326,18 +8519,18 @@ function parseCsv4(value) {
 
 // src/commands/memory-pending.ts
 import { existsSync as existsSync41 } from "fs";
-import path24 from "path";
+import path25 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot21,
+  findProjectRoot as findProjectRoot22,
   getUsage as getUsage14,
   loadUsageIndex as loadUsageIndex16,
-  resolveHaivePaths as resolveHaivePaths18
+  resolveHaivePaths as resolveHaivePaths19
 } from "@hiveai/core";
 function registerMemoryPending(memory2) {
   memory2.command("pending").description("List 'proposed' memories awaiting review (sorted by reads desc)").option("--scope <scope>", "filter by scope (personal | team | module)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot21(opts.dir);
-    const paths = resolveHaivePaths18(root);
+    const root = findProjectRoot22(opts.dir);
+    const paths = resolveHaivePaths19(root);
     if (!existsSync41(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
@@ -8366,7 +8559,7 @@ function registerMemoryPending(memory2) {
       console.log(
         `${ui.bold(fm.id)}  ${ui.dim(`${fm.scope}/${fm.type}`)}  ${ui.dim(`age=${ageStr} reads=${u.read_count} rejections=${u.rejected_count}`)}`
       );
-      console.log(`  ${ui.dim(path24.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path25.relative(root, filePath))}`);
     }
     ui.info(`${proposed.length} pending`);
   });
@@ -8374,22 +8567,22 @@ function registerMemoryPending(memory2) {
 
 // src/commands/memory-query.ts
 import { existsSync as existsSync43 } from "fs";
-import path25 from "path";
+import path26 from "path";
 import "commander";
 import {
   extractSnippet as extractSnippet2,
-  findProjectRoot as findProjectRoot22,
+  findProjectRoot as findProjectRoot23,
   literalMatchesAllTokens as literalMatchesAllTokens3,
   literalMatchesAnyToken as literalMatchesAnyToken4,
   pickSnippetNeedle as pickSnippetNeedle2,
-  resolveHaivePaths as resolveHaivePaths19,
+  resolveHaivePaths as resolveHaivePaths20,
   tokenizeQuery as tokenizeQuery6,
   trackReads as trackReads4
 } from "@hiveai/core";
 function registerMemoryQuery(memory2) {
   memory2.command("query <text>").alias("search").description("Search memories by id, tag, or substring (AND, OR fallback). Alias: search").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 = findProjectRoot22(opts.dir);
-    const paths = resolveHaivePaths19(root);
+    const root = findProjectRoot23(opts.dir);
+    const paths = resolveHaivePaths20(root);
     if (!existsSync43(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
@@ -8431,7 +8624,7 @@ function registerMemoryQuery(memory2) {
       const fm = mem.frontmatter;
       const statusBadge = ui.statusBadge(fm.status);
       console.log(`${ui.bold(fm.id)} ${ui.dim(fm.scope)} ${statusBadge}`);
-      console.log(`  ${ui.dim(path25.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path26.relative(root, filePath))}`);
       const snippet = extractSnippet2(mem.body, snippetNeedle);
       if (snippet) console.log(`  ${snippet}`);
     }
@@ -8452,17 +8645,17 @@ import { writeFile as writeFile20 } from "fs/promises";
 import { existsSync as existsSync44 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot23,
+  findProjectRoot as findProjectRoot24,
   loadUsageIndex as loadUsageIndex17,
   recordRejection as recordRejection2,
-  resolveHaivePaths as resolveHaivePaths20,
+  resolveHaivePaths as resolveHaivePaths21,
   saveUsageIndex as saveUsageIndex3,
   serializeMemory as serializeMemory18
 } from "@hiveai/core";
 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 = findProjectRoot23(opts.dir);
-    const paths = resolveHaivePaths20(root);
+    const root = findProjectRoot24(opts.dir);
+    const paths = resolveHaivePaths21(root);
     if (!existsSync44(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
@@ -8501,19 +8694,19 @@ function registerMemoryReject(memory2) {
 // src/commands/memory-rm.ts
 import { existsSync as existsSync45 } from "fs";
 import { unlink as unlink3 } from "fs/promises";
-import path26 from "path";
-import { createInterface } from "readline/promises";
+import path27 from "path";
+import { createInterface as createInterface2 } from "readline/promises";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot24,
+  findProjectRoot as findProjectRoot25,
   loadUsageIndex as loadUsageIndex18,
-  resolveHaivePaths as resolveHaivePaths21,
+  resolveHaivePaths as resolveHaivePaths22,
   saveUsageIndex as saveUsageIndex4
 } from "@hiveai/core";
 function registerMemoryRm(memory2) {
   memory2.command("rm <id>").description("Delete a memory file (and its usage entry by default)").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 = findProjectRoot24(opts.dir);
-    const paths = resolveHaivePaths21(root);
+    const root = findProjectRoot25(opts.dir);
+    const paths = resolveHaivePaths22(root);
     if (!existsSync45(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
@@ -8526,9 +8719,9 @@ function registerMemoryRm(memory2) {
       process.exitCode = 1;
       return;
     }
-    const rel = path26.relative(root, found.filePath);
+    const rel = path27.relative(root, found.filePath);
     if (!opts.yes) {
-      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      const rl = createInterface2({ input: process.stdin, output: process.stdout });
       const answer = (await rl.question(`Delete ${rel}? [y/N] `)).trim().toLowerCase();
       rl.close();
       if (answer !== "y" && answer !== "yes") {
@@ -8552,19 +8745,19 @@ function registerMemoryRm(memory2) {
 // src/commands/memory-show.ts
 import { existsSync as existsSync46 } from "fs";
 import { readFile as readFile11 } from "fs/promises";
-import path27 from "path";
+import path28 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence10,
-  findProjectRoot as findProjectRoot25,
+  findProjectRoot as findProjectRoot26,
   getUsage as getUsage15,
   loadUsageIndex as loadUsageIndex19,
-  resolveHaivePaths as resolveHaivePaths22
+  resolveHaivePaths as resolveHaivePaths23
 } from "@hiveai/core";
 function registerMemoryShow(memory2) {
   memory2.command("show <id>").description("Print a memory's frontmatter, body, and confidence/usage").option("--raw", "print the raw file contents instead of a summary").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
-    const root = findProjectRoot25(opts.dir);
-    const paths = resolveHaivePaths22(root);
+    const root = findProjectRoot26(opts.dir);
+    const paths = resolveHaivePaths23(root);
     if (!existsSync46(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
@@ -8594,7 +8787,7 @@ function registerMemoryShow(memory2) {
     if (fm.verified_at) console.log(`${ui.dim("verified:")}   ${fm.verified_at}`);
     if (fm.stale_reason) console.log(`${ui.dim("stale:")}      ${fm.stale_reason}`);
     console.log(`${ui.dim("reads:")}      ${u.read_count}  ${ui.dim("rejections:")} ${u.rejected_count}`);
-    console.log(`${ui.dim("file:")}       ${path27.relative(root, found.filePath)}`);
+    console.log(`${ui.dim("file:")}       ${path28.relative(root, found.filePath)}`);
     if (fm.anchor.paths.length || fm.anchor.symbols.length) {
       console.log(ui.dim("anchor:"));
       if (fm.anchor.commit) console.log(`  ${ui.dim("commit:")}  ${fm.anchor.commit}`);
@@ -8610,19 +8803,19 @@ function registerMemoryShow(memory2) {
 
 // src/commands/memory-stats.ts
 import { existsSync as existsSync47 } from "fs";
-import path28 from "path";
+import path29 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence11,
-  findProjectRoot as findProjectRoot26,
+  findProjectRoot as findProjectRoot27,
   getUsage as getUsage16,
   loadUsageIndex as loadUsageIndex20,
-  resolveHaivePaths as resolveHaivePaths23
+  resolveHaivePaths as resolveHaivePaths24
 } from "@hiveai/core";
 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 = findProjectRoot26(opts.dir);
-    const paths = resolveHaivePaths23(root);
+    const root = findProjectRoot27(opts.dir);
+    const paths = resolveHaivePaths24(root);
     if (!existsSync47(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
@@ -8648,7 +8841,7 @@ function registerMemoryStats(memory2) {
       console.log(
         `  ${ui.dim("status:")} ${fm.status}  ${ui.dim("reads:")} ${u.read_count}  ${ui.dim("rejections:")} ${u.rejected_count}`
       );
-      console.log(`  ${ui.dim(path28.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path29.relative(root, filePath))}`);
     }
   });
 }
@@ -8656,11 +8849,11 @@ function registerMemoryStats(memory2) {
 // src/commands/memory-verify.ts
 import { writeFile as writeFile21 } from "fs/promises";
 import { existsSync as existsSync48 } from "fs";
-import path29 from "path";
+import path30 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot27,
-  resolveHaivePaths as resolveHaivePaths24,
+  findProjectRoot as findProjectRoot28,
+  resolveHaivePaths as resolveHaivePaths25,
   serializeMemory as serializeMemory19,
   verifyAnchor as verifyAnchor3
 } from "@hiveai/core";
@@ -8668,8 +8861,8 @@ function registerMemoryVerify(memory2) {
   memory2.command("verify").description(
     "Check that memory anchor paths still exist in the current codebase.\n\n  A memory is 'stale' when its anchored file or symbol was moved, deleted, or renamed.\n  Stale memories are shown with a warning in get_briefing and should be updated or deleted.\n\n  haive sync runs this automatically. Use this command for on-demand checks or in CI.\n\n  CI recommendation: add 'haive memory verify' to your haive-sync.yml PR check job\n  to catch stale memories before they reach main.\n\n  Examples:\n    haive memory verify                          # check all, report only\n    haive memory verify --update                 # mark stale/fresh on disk\n    haive memory verify --id 2026-04-28-gotcha-x # check one memory\n"
   ).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("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot27(opts.dir);
-    const paths = resolveHaivePaths24(root);
+    const root = findProjectRoot28(opts.dir);
+    const paths = resolveHaivePaths25(root);
     if (!existsSync48(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
@@ -8693,7 +8886,7 @@ function registerMemoryVerify(memory2) {
         anchorlessIds.push(mem.frontmatter.id);
         continue;
       }
-      const rel = path29.relative(root, filePath);
+      const rel = path30.relative(root, filePath);
       if (result.stale) {
         staleCount++;
         console.log(`${ui.bold("STALE")}  ${mem.frontmatter.id}`);
@@ -8760,15 +8953,15 @@ import { readFile as readFile12 } from "fs/promises";
 import { existsSync as existsSync49 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot28,
-  resolveHaivePaths as resolveHaivePaths25
+  findProjectRoot as findProjectRoot29,
+  resolveHaivePaths as resolveHaivePaths26
 } from "@hiveai/core";
 function registerMemoryImport(memory2) {
   memory2.command("import").description(
     "Parse a Markdown file and suggest memories via the import_docs MCP prompt (prints a ready-to-use prompt invocation)"
   ).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 = findProjectRoot28(opts.dir);
-    const paths = resolveHaivePaths25(root);
+    const root = findProjectRoot29(opts.dir);
+    const paths = resolveHaivePaths26(root);
     if (!existsSync49(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
@@ -8808,21 +9001,21 @@ function registerMemoryImport(memory2) {
 
 // src/commands/memory-import-changelog.ts
 import { existsSync as existsSync50 } from "fs";
-import { readFile as readFile13, mkdir as mkdir13, writeFile as writeFile23 } from "fs/promises";
-import path30 from "path";
+import { readFile as readFile13, mkdir as mkdir14, writeFile as writeFile23 } from "fs/promises";
+import path31 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter9,
-  findProjectRoot as findProjectRoot29,
-  resolveHaivePaths as resolveHaivePaths26,
+  findProjectRoot as findProjectRoot30,
+  resolveHaivePaths as resolveHaivePaths27,
   serializeMemory as serializeMemory20
 } from "@hiveai/core";
 function parseChangelog(content) {
   const entries = [];
   const versionRe = /^#{1,3}\s+(?:\[?)([0-9]+\.[0-9]+[.0-9]*)/m;
   const sections = content.split(/^#{1,3}\s+/m).slice(1);
-  for (const section of sections) {
-    const versionMatch = section.match(/^(?:\[?)([0-9]+\.[0-9]+[.0-9]*)/);
+  for (const section2 of sections) {
+    const versionMatch = section2.match(/^(?:\[?)([0-9]+\.[0-9]+[.0-9]*)/);
     const version = versionMatch?.[1];
     if (!version) continue;
     const entry = {
@@ -8833,7 +9026,7 @@ function parseChangelog(content) {
       fixed: [],
       added: []
     };
-    const subSections = section.split(/^#{2,4}\s+/m);
+    const subSections = section2.split(/^#{2,4}\s+/m);
     for (const sub of subSections) {
       const firstLine = (sub.split("\n")[0] ?? "").toLowerCase().trim();
       const items = sub.split("\n").slice(1).filter((l) => l.trim().startsWith("-") || l.trim().startsWith("*")).map((l) => l.replace(/^[\s\-*]+/, "").trim()).filter(Boolean);
@@ -8859,7 +9052,7 @@ function parseChangelog(content) {
       }
     }
     if (entry.breaking.length === 0) {
-      for (const line of section.split("\n")) {
+      for (const line of section2.split("\n")) {
         if (/breaking|⚠|deprecated|removed/.test(line.toLowerCase())) {
           const item = line.replace(/^[\s\-*#]+/, "").trim();
           if (item) entry.breaking.push(item);
@@ -8879,9 +9072,9 @@ function registerMemoryImportChangelog(memory2) {
     "--versions <csv>",
     "only import specific versions (comma-separated), or 'latest' for the most recent breaking version"
   ).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot29(opts.dir);
-    const paths = resolveHaivePaths26(root);
-    const changelogPath = path30.resolve(root, opts.fromChangelog);
+    const root = findProjectRoot30(opts.dir);
+    const paths = resolveHaivePaths27(root);
+    const changelogPath = path31.resolve(root, opts.fromChangelog);
     if (!existsSync50(changelogPath)) {
       ui.error(`CHANGELOG not found: ${changelogPath}`);
       process.exitCode = 1;
@@ -8902,10 +9095,10 @@ function registerMemoryImportChangelog(memory2) {
         entries = entries.filter((e) => requested.includes(e.version));
       }
     }
-    const pkgName = opts.package ?? path30.basename(path30.dirname(changelogPath));
+    const pkgName = opts.package ?? path31.basename(path31.dirname(changelogPath));
     const scope = opts.scope ?? "team";
-    const teamDir = path30.join(paths.memoriesDir, scope);
-    await mkdir13(teamDir, { recursive: true });
+    const teamDir = path31.join(paths.memoriesDir, scope);
+    await mkdir14(teamDir, { recursive: true });
     let saved = 0;
     for (const entry of entries) {
       const lines = [];
@@ -8927,7 +9120,7 @@ function registerMemoryImportChangelog(memory2) {
         lines.push("");
       }
       lines.push(
-        `**Source:** \`${path30.relative(root, changelogPath)}\`  
+        `**Source:** \`${path31.relative(root, changelogPath)}\`  
 **Action:** Update all usages of ${pkgName} if they rely on any of the above.`
       );
       const slug = `changelog-${pkgName.replace(/[^a-z0-9]/gi, "-").toLowerCase()}-v${entry.version.replace(/\./g, "-")}`;
@@ -8942,11 +9135,11 @@ function registerMemoryImportChangelog(memory2) {
           pkgName.replace(/[^a-z0-9]/gi, "-").toLowerCase(),
           `v${entry.version}`
         ],
-        paths: [path30.relative(root, changelogPath)],
+        paths: [path31.relative(root, changelogPath)],
         topic: `changelog-${pkgName}-${entry.version}`
       });
       await writeFile23(
-        path30.join(teamDir, `${fm.id}.md`),
+        path31.join(teamDir, `${fm.id}.md`),
         serializeMemory20({ frontmatter: fm, body: lines.join("\n") }),
         "utf8"
       );
@@ -8971,15 +9164,15 @@ ${ui.bold(`Imported ${saved} changelog entr${saved === 1 ? "y" : "ies"} from ${p
 // src/commands/memory-digest.ts
 import { existsSync as existsSync51 } from "fs";
 import { writeFile as writeFile24 } from "fs/promises";
-import path31 from "path";
+import path33 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence12,
-  findProjectRoot as findProjectRoot30,
+  findProjectRoot as findProjectRoot31,
   getUsage as getUsage17,
   loadMemoriesFromDir as loadMemoriesFromDir26,
   loadUsageIndex as loadUsageIndex21,
-  resolveHaivePaths as resolveHaivePaths27
+  resolveHaivePaths as resolveHaivePaths28
 } from "@hiveai/core";
 var CONFIDENCE_EMOJI = {
   unverified: "\u2B1C",
@@ -8992,8 +9185,8 @@ function registerMemoryDigest(program2) {
   program2.command("digest").description(
     "Generate a Markdown review digest of recently added or updated memories.\n\n  Groups memories by type, shows confidence, status, read count, and anchor info.\n  Each memory has action checkboxes (approve / reject / keep as-is) for peer review.\n\n  Use this to do a bulk weekly review of team memories, or share with teammates\n  as a pull-request attachment so humans can validate what the AI captured.\n\n  Examples:\n    haive memory digest                         # last 7 days, team scope\n    haive memory digest --days 30 --scope all   # last 30 days, all scopes\n    haive memory digest --out review.md         # write to file\n"
   ).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 = findProjectRoot30(opts.dir);
-    const paths = resolveHaivePaths27(root);
+    const root = findProjectRoot31(opts.dir);
+    const paths = resolveHaivePaths28(root);
     if (!existsSync51(paths.memoriesDir)) {
       ui.error("No .ai/memories found. Run `haive init` first.");
       process.exitCode = 1;
@@ -9066,7 +9259,7 @@ function registerMemoryDigest(program2) {
     );
     const digest = lines.join("\n");
     if (opts.out) {
-      const outPath = path31.resolve(process.cwd(), opts.out);
+      const outPath = path33.resolve(process.cwd(), opts.out);
       await writeFile24(outPath, digest, "utf8");
       ui.success(`Digest written to ${opts.out}  (${recent.length} memor${recent.length === 1 ? "y" : "ies"})`);
     } else {
@@ -9076,20 +9269,20 @@ function registerMemoryDigest(program2) {
 }
 
 // src/commands/session-end.ts
-import { writeFile as writeFile25, mkdir as mkdir14, readFile as readFile14, rm as rm2 } from "fs/promises";
+import { writeFile as writeFile25, mkdir as mkdir15, readFile as readFile14, rm as rm2 } from "fs/promises";
 import { existsSync as existsSync53 } from "fs";
-import path33 from "path";
+import path34 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter10,
-  findProjectRoot as findProjectRoot31,
+  findProjectRoot as findProjectRoot32,
   loadMemoriesFromDir as loadMemoriesFromDir27,
   memoryFilePath as memoryFilePath9,
-  resolveHaivePaths as resolveHaivePaths28,
+  resolveHaivePaths as resolveHaivePaths29,
   serializeMemory as serializeMemory21
 } from "@hiveai/core";
 async function buildAutoRecap(paths) {
-  const obsFile = path33.join(paths.haiveDir, ".cache", "observations.jsonl");
+  const obsFile = path34.join(paths.haiveDir, ".cache", "observations.jsonl");
   if (!existsSync53(obsFile)) return null;
   const raw = await readFile14(obsFile, "utf8").catch(() => "");
   if (!raw.trim()) return null;
@@ -9169,8 +9362,8 @@ function registerSessionEnd(session2) {
       --next "Add integration tests for webhook signature validation"
 `
   ).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 = findProjectRoot31(opts.dir);
-    const paths = resolveHaivePaths28(root);
+    const root = findProjectRoot32(opts.dir);
+    const paths = resolveHaivePaths29(root);
     if (!existsSync53(paths.haiveDir)) {
       if (opts.auto || opts.quiet) return;
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
@@ -9203,14 +9396,14 @@ function registerSessionEnd(session2) {
     });
     const topic = recapTopic2(scope, opts.module);
     const filesTouched = parseCsv5(resolvedFiles);
-    const missingPaths = filesTouched.filter((p) => !existsSync53(path33.resolve(root, p)));
+    const missingPaths = filesTouched.filter((p) => !existsSync53(path34.resolve(root, p)));
     if (missingPaths.length > 0 && !opts.quiet) {
       ui.warn(`Anchor path${missingPaths.length > 1 ? "s" : ""} not found in project (will be stale):`);
       for (const p of missingPaths) ui.warn(`  \u2717 ${p}`);
     }
     const cleanupObservations = async () => {
       if (!opts.auto) return;
-      const obsFile = path33.join(paths.haiveDir, ".cache", "observations.jsonl");
+      const obsFile = path34.join(paths.haiveDir, ".cache", "observations.jsonl");
       if (existsSync53(obsFile)) await rm2(obsFile).catch(() => {
       });
     };
@@ -9234,7 +9427,7 @@ function registerSessionEnd(session2) {
         await cleanupObservations();
         if (!opts.quiet) {
           ui.success(`Session recap updated (revision #${revisionCount})`);
-          ui.info(`id=${fm.id}  file=${path33.relative(root, topicMatch.filePath)}`);
+          ui.info(`id=${fm.id}  file=${path34.relative(root, topicMatch.filePath)}`);
           ui.info("Tip: `haive stats --export-report` generates a usage JSON suitable for dashboards.");
         }
         return;
@@ -9251,12 +9444,12 @@ function registerSessionEnd(session2) {
       status: "validated"
     });
     const file = memoryFilePath9(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir14(path33.dirname(file), { recursive: true });
+    await mkdir15(path34.dirname(file), { recursive: true });
     await writeFile25(file, serializeMemory21({ frontmatter, body }), "utf8");
     await cleanupObservations();
     if (!opts.quiet) {
       ui.success(`Session recap created`);
-      ui.info(`id=${frontmatter.id}  scope=${scope}  file=${path33.relative(root, file)}`);
+      ui.info(`id=${frontmatter.id}  scope=${scope}  file=${path34.relative(root, file)}`);
       ui.info("Next session: call `get_briefing` \u2014 the recap will be surfaced automatically.");
       ui.info("Tip: export a local MCP usage rollup with `haive stats --export-report .ai/tool-usage-roi-report.json`.");
     }
@@ -9270,13 +9463,13 @@ function parseCsv5(value) {
 // src/commands/snapshot.ts
 import { existsSync as existsSync54 } from "fs";
 import { readdir as readdir4 } from "fs/promises";
-import path34 from "path";
+import path35 from "path";
 import "commander";
 import {
   diffContract,
-  findProjectRoot as findProjectRoot32,
+  findProjectRoot as findProjectRoot33,
   loadConfig as loadConfig5,
-  resolveHaivePaths as resolveHaivePaths29,
+  resolveHaivePaths as resolveHaivePaths30,
   snapshotContract
 } from "@hiveai/core";
 function registerSnapshot(program2) {
@@ -9301,15 +9494,15 @@ function registerSnapshot(program2) {
     "--format <format>",
     "contract format: openapi | graphql | proto | typescript | json-schema (auto-detected if omitted)"
   ).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 = findProjectRoot32(opts.dir);
-    const paths = resolveHaivePaths29(root);
+    const root = findProjectRoot33(opts.dir);
+    const paths = resolveHaivePaths30(root);
     if (!existsSync54(paths.haiveDir)) {
       ui.error("No .ai/ found. Run `haive init` first.");
       process.exitCode = 1;
       return;
     }
     if (opts.list) {
-      const contractsDir = path34.join(paths.haiveDir, "contracts");
+      const contractsDir = path35.join(paths.haiveDir, "contracts");
       if (!existsSync54(contractsDir)) {
         console.log(ui.dim("No contract snapshots found."));
         return;
@@ -9365,7 +9558,7 @@ function registerSnapshot(program2) {
       return;
     }
     const contractPath = opts.contract;
-    const name = opts.name ?? path34.basename(contractPath, path34.extname(contractPath));
+    const name = opts.name ?? path35.basename(contractPath, path35.extname(contractPath));
     const format = opts.format ?? detectFormat(contractPath) ?? "openapi";
     const contract = { name, path: contractPath, format };
     try {
@@ -9420,8 +9613,8 @@ async function runDiff(root, haiveDir, contract) {
   }
 }
 function detectFormat(filePath) {
-  const ext = path34.extname(filePath).toLowerCase();
-  const base = path34.basename(filePath).toLowerCase();
+  const ext = path35.extname(filePath).toLowerCase();
+  const base = path35.basename(filePath).toLowerCase();
   if (ext === ".yaml" || ext === ".yml" || ext === ".json") {
     if (base.includes("openapi") || base.includes("swagger")) return "openapi";
     if (base.includes("schema") || base.includes("graphql")) return "graphql";
@@ -9435,15 +9628,15 @@ function detectFormat(filePath) {
 
 // src/commands/hub.ts
 import { existsSync as existsSync55 } from "fs";
-import { mkdir as mkdir15, readFile as readFile15, writeFile as writeFile26, copyFile } from "fs/promises";
-import path35 from "path";
-import { spawnSync as spawnSync3 } from "child_process";
+import { mkdir as mkdir16, readFile as readFile15, writeFile as writeFile26, copyFile } from "fs/promises";
+import path36 from "path";
+import { spawnSync as spawnSync4 } from "child_process";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot33,
+  findProjectRoot as findProjectRoot34,
   loadConfig as loadConfig6,
   loadMemoriesFromDir as loadMemoriesFromDir28,
-  resolveHaivePaths as resolveHaivePaths30,
+  resolveHaivePaths as resolveHaivePaths31,
   saveConfig as saveConfig2,
   serializeMemory as serializeMemory23
 } from "@hiveai/core";
@@ -9455,21 +9648,21 @@ function registerHub(program2) {
   hub.command("init <hubPath>").description(
     "Initialize a new team-knowledge hub repo at <hubPath>.\n\n  Creates a git repo with a .ai/ directory structure ready for shared memories.\n\n  Example:\n    haive hub init ../team-hub\n    haive hub init /srv/git/team-knowledge\n"
   ).action(async (hubPath) => {
-    const absPath = path35.resolve(hubPath);
-    await mkdir15(absPath, { recursive: true });
-    const gitCheck = spawnSync3("git", ["rev-parse", "--git-dir"], { cwd: absPath });
+    const absPath = path36.resolve(hubPath);
+    await mkdir16(absPath, { recursive: true });
+    const gitCheck = spawnSync4("git", ["rev-parse", "--git-dir"], { cwd: absPath });
     if (gitCheck.status !== 0) {
-      const init = spawnSync3("git", ["init"], { cwd: absPath, encoding: "utf8" });
+      const init = spawnSync4("git", ["init"], { cwd: absPath, encoding: "utf8" });
       if (init.status !== 0) {
         ui.error(`git init failed: ${init.stderr}`);
         process.exitCode = 1;
         return;
       }
     }
-    const sharedDir = path35.join(absPath, ".ai", "memories", "shared");
-    await mkdir15(sharedDir, { recursive: true });
+    const sharedDir = path36.join(absPath, ".ai", "memories", "shared");
+    await mkdir16(sharedDir, { recursive: true });
     await writeFile26(
-      path35.join(absPath, ".ai", "README.md"),
+      path36.join(absPath, ".ai", "README.md"),
       `# hAIve Team Knowledge Hub
 
 This repo is a shared knowledge hub for hAIve.
@@ -9491,12 +9684,12 @@ haive hub pull   # import into a project
       "utf8"
     );
     await writeFile26(
-      path35.join(absPath, ".gitignore"),
+      path36.join(absPath, ".gitignore"),
       ".ai/.cache/\n.ai/memories/personal/\n",
       "utf8"
     );
-    spawnSync3("git", ["add", "."], { cwd: absPath });
-    spawnSync3("git", ["commit", "-m", "chore: initialize hAIve team-knowledge hub"], {
+    spawnSync4("git", ["add", "."], { cwd: absPath });
+    spawnSync4("git", ["commit", "-m", "chore: initialize hAIve team-knowledge hub"], {
       cwd: absPath,
       encoding: "utf8"
     });
@@ -9506,7 +9699,7 @@ haive hub pull   # import into a project
         `
 Next steps:
   1. Add hubPath to your project's .ai/haive.config.json:
-       { "hubPath": "${path35.relative(process.cwd(), absPath)}" }
+       { "hubPath": "${path36.relative(process.cwd(), absPath)}" }
   2. Run \`haive hub push\` to publish your shared memories
   3. Share ${absPath} with teammates (git remote, NFS, etc.)
 `
@@ -9525,8 +9718,8 @@ Next steps:
     haive hub push --commit --message "feat: add payment API contract memories"
 `
   ).option("-d, --dir <dir>", "project root").option("--commit", "auto-commit to the hub repo after pushing").option("--message <msg>", "commit message for the hub (used with --commit)").action(async (opts) => {
-    const root = findProjectRoot33(opts.dir);
-    const paths = resolveHaivePaths30(root);
+    const root = findProjectRoot34(opts.dir);
+    const paths = resolveHaivePaths31(root);
     const config = await loadConfig6(paths);
     if (!config.hubPath) {
       ui.error(
@@ -9535,15 +9728,15 @@ Next steps:
       process.exitCode = 1;
       return;
     }
-    const hubRoot = path35.resolve(root, config.hubPath);
+    const hubRoot = path36.resolve(root, config.hubPath);
     if (!existsSync55(hubRoot)) {
       ui.error(`Hub not found at ${hubRoot}. Run \`haive hub init ${config.hubPath}\` first.`);
       process.exitCode = 1;
       return;
     }
-    const projectName = path35.basename(root);
-    const destDir = path35.join(hubRoot, ".ai", "memories", "shared", projectName);
-    await mkdir15(destDir, { recursive: true });
+    const projectName = path36.basename(root);
+    const destDir = path36.join(hubRoot, ".ai", "memories", "shared", projectName);
+    await mkdir16(destDir, { recursive: true });
     const all = await loadMemoriesFromDir28(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)
@@ -9561,7 +9754,7 @@ Next steps:
     for (const { memory: memory2 } of shared) {
       const fm = memory2.frontmatter;
       const fileName = `${fm.id}.md`;
-      const destPath = path35.join(destDir, fileName);
+      const destPath = path36.join(destDir, fileName);
       await writeFile26(destPath, serializeMemory23(memory2), "utf8");
       pushed++;
     }
@@ -9569,10 +9762,10 @@ Next steps:
     console.log(ui.dim(`  Location: ${destDir}`));
     if (opts.commit) {
       const message = opts.message ?? `haive: sync shared memories from ${projectName} (${pushed} memories)`;
-      spawnSync3("git", ["add", path35.join(".ai", "memories", "shared", projectName)], {
+      spawnSync4("git", ["add", path36.join(".ai", "memories", "shared", projectName)], {
         cwd: hubRoot
       });
-      const commit = spawnSync3("git", ["commit", "-m", message], {
+      const commit = spawnSync4("git", ["commit", "-m", message], {
         cwd: hubRoot,
         encoding: "utf8"
       });
@@ -9594,8 +9787,8 @@ Next steps:
   hub.command("pull").description(
     "Pull shared memories from the hub into this project.\n\n  Imports all memories from hub/.ai/memories/shared/ EXCEPT this project's own.\n  Imported memories land in .ai/memories/shared/<source-project-name>/.\n\n  Examples:\n    haive hub pull\n"
   ).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot33(opts.dir);
-    const paths = resolveHaivePaths30(root);
+    const root = findProjectRoot34(opts.dir);
+    const paths = resolveHaivePaths31(root);
     const config = await loadConfig6(paths);
     if (!config.hubPath) {
       ui.error(
@@ -9604,15 +9797,15 @@ Next steps:
       process.exitCode = 1;
       return;
     }
-    const hubRoot = path35.resolve(root, config.hubPath);
-    const hubSharedDir = path35.join(hubRoot, ".ai", "memories", "shared");
+    const hubRoot = path36.resolve(root, config.hubPath);
+    const hubSharedDir = path36.join(hubRoot, ".ai", "memories", "shared");
     if (!existsSync55(hubSharedDir)) {
       ui.warn("Hub has no shared memories yet. Run `haive hub push` from other projects first.");
       return;
     }
-    const projectName = path35.basename(root);
-    const { readdir: readdir5 } = await import("fs/promises");
-    const projectDirs = (await readdir5(hubSharedDir, { withFileTypes: true })).filter((d) => d.isDirectory() && d.name !== projectName).map((d) => d.name);
+    const projectName = path36.basename(root);
+    const { readdir: readdir6 } = await import("fs/promises");
+    const projectDirs = (await readdir6(hubSharedDir, { withFileTypes: true })).filter((d) => d.isDirectory() && d.name !== projectName).map((d) => d.name);
     if (projectDirs.length === 0) {
       console.log(ui.dim("No other projects have pushed to the hub yet."));
       return;
@@ -9620,16 +9813,16 @@ Next steps:
     let totalImported = 0;
     let totalUpdated = 0;
     for (const sourceName of projectDirs) {
-      const sourceDir = path35.join(hubSharedDir, sourceName);
-      const destDir = path35.join(paths.memoriesDir, "shared", sourceName);
-      await mkdir15(destDir, { recursive: true });
-      const sourceFiles = (await readdir5(sourceDir)).filter((f) => f.endsWith(".md"));
+      const sourceDir = path36.join(hubSharedDir, sourceName);
+      const destDir = path36.join(paths.memoriesDir, "shared", sourceName);
+      await mkdir16(destDir, { recursive: true });
+      const sourceFiles = (await readdir6(sourceDir)).filter((f) => f.endsWith(".md"));
       const { loadMemoriesFromDir: loadDir } = await import("@hiveai/core");
       const existingInDest = await loadDir(destDir);
       const existingIds = new Set(existingInDest.map(({ memory: memory2 }) => memory2.frontmatter.id));
       for (const file of sourceFiles) {
-        const srcPath = path35.join(sourceDir, file);
-        const destPath = path35.join(destDir, file);
+        const srcPath = path36.join(sourceDir, file);
+        const destPath = path36.join(destDir, file);
         const fileContent = await readFile15(srcPath, "utf8");
         const alreadyTagged = fileContent.includes(`cross-repo:${sourceName}`);
         if (!alreadyTagged) {
@@ -9653,21 +9846,21 @@ Next steps:
     );
   });
   hub.command("status").description("Show hub sync status.").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot33(opts.dir);
-    const paths = resolveHaivePaths30(root);
+    const root = findProjectRoot34(opts.dir);
+    const paths = resolveHaivePaths31(root);
     const config = await loadConfig6(paths);
     console.log(ui.bold("Hub status"));
     console.log(
       `  hubPath: ${config.hubPath ? ui.green(config.hubPath) : ui.dim("not configured")}`
     );
-    const sharedDir = path35.join(paths.memoriesDir, "shared");
+    const sharedDir = path36.join(paths.memoriesDir, "shared");
     if (existsSync55(sharedDir)) {
-      const { readdir: readdir5 } = await import("fs/promises");
-      const sources = (await readdir5(sharedDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
+      const { readdir: readdir6 } = await import("fs/promises");
+      const sources = (await readdir6(sharedDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
       console.log(`
   Imported from ${sources.length} source(s):`);
       for (const src of sources) {
-        const files = (await readdir5(path35.join(sharedDir, src))).filter((f) => f.endsWith(".md"));
+        const files = (await readdir6(path36.join(sharedDir, src))).filter((f) => f.endsWith(".md"));
         console.log(`    ${src}: ${files.length} memor${files.length === 1 ? "y" : "ies"}`);
       }
     } else {
@@ -9691,16 +9884,16 @@ Next steps:
 // src/commands/stats.ts
 import "commander";
 import { existsSync as existsSync56 } from "fs";
-import { mkdir as mkdir16, writeFile as writeFile27 } from "fs/promises";
-import path36 from "path";
+import { mkdir as mkdir17, writeFile as writeFile27 } from "fs/promises";
+import path37 from "path";
 import {
   aggregateUsage,
-  findProjectRoot as findProjectRoot34,
+  findProjectRoot as findProjectRoot35,
   loadMemoriesFromDir as loadMemoriesFromDir29,
   loadUsageIndex as loadUsageIndex23,
   parseSince,
   readUsageEvents as readUsageEvents2,
-  resolveHaivePaths as resolveHaivePaths31,
+  resolveHaivePaths as resolveHaivePaths32,
   usageLogSize
 } from "@hiveai/core";
 function registerStats(program2) {
@@ -9709,8 +9902,8 @@ function registerStats(program2) {
     "write a JSON rollup (tools + briefing counts + heuristic ROI hints). Parent dirs are created if needed.",
     void 0
   ).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot34(opts.dir);
-    const paths = resolveHaivePaths31(root);
+    const root = findProjectRoot35(opts.dir);
+    const paths = resolveHaivePaths32(root);
     if (opts.exportReport) {
       await writeRoiReport(paths, root, opts.since ?? "30d", opts.exportReport);
       return;
@@ -9764,7 +9957,7 @@ function registerStats(program2) {
   });
 }
 async function writeRoiReport(paths, root, sinceRaw, outRelative) {
-  const outAbs = path36.isAbsolute(outRelative) ? path36.resolve(outRelative) : path36.resolve(root, outRelative);
+  const outAbs = path37.isAbsolute(outRelative) ? path37.resolve(outRelative) : path37.resolve(root, outRelative);
   const size = await usageLogSize(paths);
   let events = await readUsageEvents2(paths);
   let memoryCount = { team: 0, personal: 0, total_skipped_session: 0 };
@@ -9799,7 +9992,7 @@ async function writeRoiReport(paths, root, sinceRaw, outRelative) {
     ui.warn("Usage log missing or empty \u2014 report still written with partial data.");
     events = [];
   }
-  await mkdir16(path36.dirname(outAbs), { recursive: true });
+  await mkdir17(path37.dirname(outAbs), { recursive: true });
   const payload = {
     generated_at: (/* @__PURE__ */ new Date()).toISOString(),
     project_root: root,
@@ -9863,13 +10056,13 @@ import { performance } from "perf_hooks";
 import "commander";
 import {
   estimateTokens as estimateTokens3,
-  findProjectRoot as findProjectRoot35,
-  resolveHaivePaths as resolveHaivePaths32
+  findProjectRoot as findProjectRoot36,
+  resolveHaivePaths as resolveHaivePaths33
 } from "@hiveai/core";
 function registerBench(program2) {
   program2.command("bench").description("Self-test the local hAIve setup: runs core MCP tools against this project and reports latency + payload size.").option("-t, --task <task>", "task description for ranking-aware tools", "audit dependencies for security risks").option("--json", "emit JSON instead of a table", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot35(opts.dir);
-    const paths = resolveHaivePaths32(root);
+    const root = findProjectRoot36(opts.dir);
+    const paths = resolveHaivePaths33(root);
     const ctx = { paths };
     const task = opts.task ?? "audit dependencies for security risks";
     const scenarios = [
@@ -9987,20 +10180,165 @@ function summarize(name, t0, payload, notes) {
   };
 }
 
-// src/commands/memory-suggest.ts
-import { mkdir as mkdir17, writeFile as writeFile28 } from "fs/promises";
+// src/commands/benchmark.ts
 import { existsSync as existsSync57 } from "fs";
-import path37 from "path";
+import { readdir as readdir5, readFile as readFile16, writeFile as writeFile28 } from "fs/promises";
+import path38 from "path";
+import "commander";
+import { estimateTokens as estimateTokens4, findProjectRoot as findProjectRoot37 } from "@hiveai/core";
+function registerBenchmark(program2) {
+  const benchmark = program2.command("benchmark").description("Official hAIve benchmark/demo utilities for measuring agent enforcement value.");
+  benchmark.command("report").description("Summarize BENCHMARK_AGENT_REPORT.md files from a paired hAIve/plain agent benchmark.").option("-d, --dir <dir>", "benchmark root", "benchmarks/agent-benchmark").option("--out <file>", "write a Markdown report").option("--json", "emit JSON", false).action(async (opts) => {
+    const root = resolveBenchmarkRoot(opts.dir);
+    const rows = await collectRows(root);
+    const summary = summarizeRows(rows);
+    if (opts.json) {
+      console.log(JSON.stringify({ root, summary, rows }, null, 2));
+      return;
+    }
+    const markdown = renderMarkdown(root, summary, rows);
+    if (opts.out) {
+      const outFile = path38.isAbsolute(opts.out) ? opts.out : path38.join(root, opts.out);
+      await writeFile28(outFile, markdown, "utf8");
+      ui.success(`wrote ${path38.relative(process.cwd(), outFile)}`);
+      return;
+    }
+    console.log(markdown);
+  });
+  benchmark.command("demo").description("Print the recommended protocol for running a hAIve vs plain agent benchmark.").action(() => {
+    console.log([
+      "# hAIve Agent Benchmark Demo",
+      "",
+      "1. Create paired fixtures: one `*-haive`, one `*-plain`.",
+      "2. Put the same failing tests in both fixtures.",
+      "3. Add precise `.ai/memories/team/*.md` policy memories only to the hAIve fixture.",
+      "4. Run equal agents in parallel:",
+      "   - hAIve agents must run `haive briefing --files ... --task ...` first.",
+      "   - Plain agents must not read `.ai` or call hAIve.",
+      "5. Require every agent to write `BENCHMARK_AGENT_REPORT.md`.",
+      "6. Run `haive benchmark report --dir <benchmark-root> --out RESULTS.md`.",
+      "",
+      "Recommended metrics: pass rate, test iterations, files read, files changed, visible artifacts, decision quality, and token proxy."
+    ].join("\n"));
+  });
+}
+function resolveBenchmarkRoot(dir) {
+  const candidate = dir ?? "benchmarks/agent-benchmark";
+  if (path38.isAbsolute(candidate)) return candidate;
+  const projectRoot = findProjectRoot37(process.cwd());
+  return path38.join(projectRoot, candidate);
+}
+async function collectRows(root) {
+  if (!existsSync57(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 = path38.join(root, entry.name);
+    const reportFile = path38.join(fixtureDir, "BENCHMARK_AGENT_REPORT.md");
+    if (!existsSync57(reportFile)) continue;
+    const report = await readFile16(reportFile, "utf8");
+    rows.push(parseAgentReport(entry.name, report));
+  }
+  return rows.sort((a, b) => a.fixture.localeCompare(b.fixture));
+}
+function parseAgentReport(fixture, report) {
+  const group = fixture.endsWith("-haive") ? "haive" : fixture.endsWith("-plain") ? "plain" : "unknown";
+  return {
+    fixture,
+    group,
+    commands: sectionBulletCount(report, "Commands"),
+    files_read: sectionBulletCount(report, "Files Read"),
+    files_modified: sectionBulletCount(report, "Files Modified"),
+    test_iterations: countMatches(section(report, "Test Iterations"), /Iteration\s+\d+|^- /gim),
+    terminal_failures: countMatches(section(report, "Terminal Errors"), /fail|error|not raised|exited with code 1/gi),
+    decision_mentions: sectionBulletCount(report, "Key Decisions"),
+    token_proxy: estimateTokens4(report),
+    haive_impact: /hAIve Memory Impact[\s\S]*?\b(yes|directly|changed|shaped|confirmed)\b/i.test(report)
+  };
+}
+function summarizeRows(rows) {
+  const byGroup = (group) => rows.filter((r) => r.group === group);
+  return {
+    fixtures: rows.length,
+    haive: summarizeGroup(byGroup("haive")),
+    plain: summarizeGroup(byGroup("plain"))
+  };
+}
+function summarizeGroup(rows) {
+  const sum = (key) => rows.reduce((total, row) => total + Number(row[key] ?? 0), 0);
+  return {
+    fixtures: rows.length,
+    commands: sum("commands"),
+    files_read: sum("files_read"),
+    files_modified: sum("files_modified"),
+    test_iterations: sum("test_iterations"),
+    terminal_failures: sum("terminal_failures"),
+    decision_mentions: sum("decision_mentions"),
+    token_proxy: sum("token_proxy"),
+    haive_impact_count: rows.filter((r) => r.haive_impact).length
+  };
+}
+function renderMarkdown(root, summary, rows) {
+  const lines = [
+    "# hAIve Agent Benchmark Report",
+    "",
+    `Benchmark root: \`${root}\``,
+    "",
+    "## Summary",
+    "",
+    "| Group | Fixtures | Commands | Files read | Files modified | Test iterations | Terminal failures | Decision mentions | Token proxy | hAIve impact |",
+    "| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |",
+    groupLine("hAIve", summary.haive),
+    groupLine("Plain", summary.plain),
+    "",
+    "## Fixtures",
+    "",
+    "| Fixture | Group | Commands | Files read | Files modified | Test iterations | Terminal failures | Decisions | Token proxy | hAIve impact |",
+    "| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- |",
+    ...rows.map(
+      (row) => `| \`${row.fixture}\` | ${row.group} | ${row.commands} | ${row.files_read} | ${row.files_modified} | ${row.test_iterations} | ${row.terminal_failures} | ${row.decision_mentions} | ${row.token_proxy} | ${row.haive_impact ? "yes" : "no"} |`
+    ),
+    "",
+    "## Reading",
+    "",
+    "The token proxy is estimated from the agent report size, not from private model billing data.",
+    "Use this report to compare relative effort and decision quality, then pair it with final test results and a human review of the diffs.",
+    ""
+  ];
+  return lines.join("\n");
+}
+function groupLine(label, group) {
+  return `| ${label} | ${group.fixtures} | ${group.commands} | ${group.files_read} | ${group.files_modified} | ${group.test_iterations} | ${group.terminal_failures} | ${group.decision_mentions} | ${group.token_proxy} | ${group.haive_impact_count} |`;
+}
+function sectionBulletCount(markdown, title) {
+  return countMatches(section(markdown, title), /^- |^\d+\.\s/gm);
+}
+function section(markdown, title) {
+  const re = new RegExp(`##\\s+[^\\n]*${escapeRegExp(title)}[^\\n]*\\n([\\s\\S]*?)(?=\\n##\\s+|$)`, "i");
+  return re.exec(markdown)?.[1] ?? "";
+}
+function countMatches(text, re) {
+  return [...text.matchAll(re)].length;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/commands/memory-suggest.ts
+import { mkdir as mkdir18, writeFile as writeFile29 } from "fs/promises";
+import { existsSync as existsSync58 } from "fs";
+import path39 from "path";
 import "commander";
 import {
   aggregateUsage as aggregateUsage2,
   buildFrontmatter as buildFrontmatter11,
-  findProjectRoot as findProjectRoot36,
+  findProjectRoot as findProjectRoot38,
   loadMemoriesFromDir as loadMemoriesFromDir30,
   memoryFilePath as memoryFilePath10,
   parseSince as parseSince2,
   readUsageEvents as readUsageEvents3,
-  resolveHaivePaths as resolveHaivePaths33,
+  resolveHaivePaths as resolveHaivePaths34,
   serializeMemory as serializeMemory24
 } from "@hiveai/core";
 var SEARCH_TOOLS = /* @__PURE__ */ new Set([
@@ -10013,8 +10351,8 @@ function registerMemorySuggest(memory2) {
   memory2.command("suggest").description(
     "Suggest memories to create based on recurring search queries in the usage log.\n\n  Use --auto-save to draft the top-N suggestions as draft memories. They land\n  in personal scope by default with status=draft, ready for you to edit and promote."
   ).option("--since <window>", "ISO date or relative (e.g. '7d', '24h')", "30d").option("--min <count>", "minimum repeat count to surface a query", "2").option("--top-n <n>", "with --auto-save, draft this many top suggestions", "3").option("--scope <scope>", "with --auto-save, scope of drafted memories (personal | team)", "personal").option("--auto-save", "draft top-N suggestions as draft memories on disk", false).option("--json", "emit JSON instead of human-readable output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot36(opts.dir);
-    const paths = resolveHaivePaths33(root);
+    const root = findProjectRoot38(opts.dir);
+    const paths = resolveHaivePaths34(root);
     const events = await readUsageEvents3(paths);
     if (events.length === 0) {
       if (opts.json) {
@@ -10060,7 +10398,7 @@ function registerMemorySuggest(memory2) {
       }
       const created = [];
       const skipped = [];
-      const existing = existsSync57(paths.memoriesDir) ? await loadMemoriesFromDir30(paths.memoriesDir) : [];
+      const existing = existsSync58(paths.memoriesDir) ? await loadMemoriesFromDir30(paths.memoriesDir) : [];
       for (const s of top) {
         const slug = slugify(s.query);
         if (!slug) {
@@ -10083,13 +10421,13 @@ function registerMemorySuggest(memory2) {
         fm.status = "draft";
         const body = renderTemplate(s);
         const file = memoryFilePath10(paths, fm.scope, fm.id, fm.module);
-        await mkdir17(path37.dirname(file), { recursive: true });
-        if (existsSync57(file)) {
-          skipped.push({ query: s.query, reason: `file already exists at ${path37.relative(root, file)}` });
+        await mkdir18(path39.dirname(file), { recursive: true });
+        if (existsSync58(file)) {
+          skipped.push({ query: s.query, reason: `file already exists at ${path39.relative(root, file)}` });
           continue;
         }
-        await writeFile28(file, serializeMemory24({ frontmatter: fm, body }), "utf8");
-        created.push({ id: fm.id, file: path37.relative(root, file), query: s.query });
+        await writeFile29(file, serializeMemory24({ frontmatter: fm, body }), "utf8");
+        created.push({ id: fm.id, file: path39.relative(root, file), query: s.query });
       }
       if (opts.json) {
         console.log(JSON.stringify({ created, skipped }, null, 2));
@@ -10182,16 +10520,16 @@ function truncate2(text, max) {
 }
 
 // src/commands/memory-archive.ts
-import { existsSync as existsSync58 } from "fs";
-import { writeFile as writeFile29 } from "fs/promises";
-import path38 from "path";
+import { existsSync as existsSync59 } from "fs";
+import { writeFile as writeFile30 } from "fs/promises";
+import path40 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot37,
+  findProjectRoot as findProjectRoot39,
   getUsage as getUsage18,
   loadMemoriesFromDir as loadMemoriesFromDir31,
   loadUsageIndex as loadUsageIndex24,
-  resolveHaivePaths as resolveHaivePaths34,
+  resolveHaivePaths as resolveHaivePaths35,
   serializeMemory as serializeMemory25
 } from "@hiveai/core";
 var MS_PER_DAY2 = 24 * 60 * 60 * 1e3;
@@ -10199,9 +10537,9 @@ function registerMemoryArchive(memory2) {
   memory2.command("archive").description(
     "Archive obsolete memories: marks status='deprecated' for memories not read in N days\n  whose anchored paths have all disappeared (or have no anchor at all).\n\n  Defaults to a DRY RUN \u2014 pass --apply to actually rewrite files.\n  Targets `attempt` memories by default since they age the fastest.\n\n  Recover later with `haive memory edit <id>` to set status back to validated."
   ).option("--since <window>", "minimum age since last read (e.g. '180d', '6m')", "180d").option("--type <type>", "limit to a memory type (default 'attempt'). Pass 'all' to scan all types.", "attempt").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 = findProjectRoot37(opts.dir);
-    const paths = resolveHaivePaths34(root);
-    if (!existsSync58(paths.memoriesDir)) {
+    const root = findProjectRoot39(opts.dir);
+    const paths = resolveHaivePaths35(root);
+    if (!existsSync59(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -10222,7 +10560,7 @@ function registerMemoryArchive(memory2) {
       if (typeFilter && fm.type !== typeFilter) continue;
       if (fm.status === "deprecated" || fm.status === "rejected") continue;
       const hasAnyAnchor = fm.anchor.paths.length + fm.anchor.symbols.length > 0;
-      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync58(path38.join(paths.root, p)));
+      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync59(path40.join(paths.root, p)));
       const isAnchorless = !hasAnyAnchor;
       if (!isAnchorless && !allPathsGone) continue;
       const u = getUsage18(usage, fm.id);
@@ -10270,7 +10608,7 @@ function registerMemoryArchive(memory2) {
       if (!found) continue;
       const fm = { ...found.memory.frontmatter, status: "deprecated" };
       try {
-        await writeFile29(c.filePath, serializeMemory25({ frontmatter: fm, body: found.memory.body }), "utf8");
+        await writeFile30(c.filePath, serializeMemory25({ frontmatter: fm, body: found.memory.body }), "utf8");
         archived++;
       } catch (err) {
         if (!opts.json) {
@@ -10296,31 +10634,31 @@ function parseDays(input) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync59 } from "fs";
+import { existsSync as existsSync60 } from "fs";
 import { stat } from "fs/promises";
-import path39 from "path";
+import path41 from "path";
 import { execSync as execSync3 } from "child_process";
 import "commander";
 import {
   codeMapPath as codeMapPath2,
-  findProjectRoot as findProjectRoot38,
+  findProjectRoot as findProjectRoot40,
   getUsage as getUsage19,
   loadCodeMap as loadCodeMap5,
   loadConfig as loadConfig7,
   loadMemoriesFromDir as loadMemoriesFromDir32,
   loadUsageIndex as loadUsageIndex25,
   readUsageEvents as readUsageEvents4,
-  resolveHaivePaths as resolveHaivePaths35
+  resolveHaivePaths as resolveHaivePaths36
 } from "@hiveai/core";
 var MS_PER_DAY3 = 24 * 60 * 60 * 1e3;
 function registerDoctor(program2) {
   program2.command("doctor").description(
     "Analyze the local hAIve setup and emit actionable recommendations.\n\n  Inspects: project-context status, memory health (stale/anchorless/decay/pending),\n  code-map freshness, usage log signals (low-hit briefings, repeated empty searches).\n\n  Read-only by default. Pass --fix to suggest commands you can copy-paste."
   ).option("--json", "emit JSON instead of human-readable output", false).option("--fix", "include suggested fix commands in human output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot38(opts.dir);
-    const paths = resolveHaivePaths35(root);
+    const root = findProjectRoot40(opts.dir);
+    const paths = resolveHaivePaths36(root);
     const findings = [];
-    if (!existsSync59(paths.haiveDir)) {
+    if (!existsSync60(paths.haiveDir)) {
       findings.push({
         severity: "error",
         code: "not-initialized",
@@ -10329,7 +10667,7 @@ function registerDoctor(program2) {
       });
       return emit(findings, opts);
     }
-    if (!existsSync59(paths.projectContext)) {
+    if (!existsSync60(paths.projectContext)) {
       findings.push({
         severity: "warn",
         code: "no-project-context",
@@ -10337,8 +10675,8 @@ function registerDoctor(program2) {
         fix: "haive init"
       });
     } else {
-      const { readFile: readFile17 } = await import("fs/promises");
-      const content = await readFile17(paths.projectContext, "utf8");
+      const { readFile: readFile18 } = await import("fs/promises");
+      const content = await readFile18(paths.projectContext, "utf8");
       const isTemplate = content.includes("TODO \u2014 high-level overview") || content.includes("Generated by `haive init`");
       if (isTemplate) {
         findings.push({
@@ -10349,7 +10687,7 @@ function registerDoctor(program2) {
         });
       }
     }
-    const memories = existsSync59(paths.memoriesDir) ? await loadMemoriesFromDir32(paths.memoriesDir) : [];
+    const memories = existsSync60(paths.memoriesDir) ? await loadMemoriesFromDir32(paths.memoriesDir) : [];
     const now = Date.now();
     if (memories.length === 0) {
       findings.push({
@@ -10460,12 +10798,12 @@ function registerDoctor(program2) {
     }
     const config = await loadConfig7(paths);
     if (config.enforcement?.requireBriefingFirst) {
-      const claudeSettings = path39.join(root, ".claude", "settings.local.json");
+      const claudeSettings = path41.join(root, ".claude", "settings.local.json");
       let hasClaudeEnforcement = false;
-      if (existsSync59(claudeSettings)) {
+      if (existsSync60(claudeSettings)) {
         try {
-          const { readFile: readFile17 } = await import("fs/promises");
-          const raw = await readFile17(claudeSettings, "utf8");
+          const { readFile: readFile18 } = await import("fs/promises");
+          const raw = await readFile18(claudeSettings, "utf8");
           hasClaudeEnforcement = raw.includes("haive enforce session-start") && raw.includes("haive enforce pre-tool-use");
         } catch {
           hasClaudeEnforcement = false;
@@ -10494,7 +10832,7 @@ function registerDoctor(program2) {
         timeout: 3e3,
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      const cliVersion = "0.9.10";
+      const cliVersion = "0.9.12";
       if (legacyRaw && legacyRaw !== cliVersion) {
         findings.push({
           severity: "warn",
@@ -10543,22 +10881,22 @@ function isSearchTool(name) {
 }
 
 // src/commands/playback.ts
-import { existsSync as existsSync60 } from "fs";
+import { existsSync as existsSync61 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot39,
+  findProjectRoot as findProjectRoot41,
   loadMemoriesFromDir as loadMemoriesFromDir33,
   parseSince as parseSince3,
   readUsageEvents as readUsageEvents5,
-  resolveHaivePaths as resolveHaivePaths36
+  resolveHaivePaths as resolveHaivePaths37
 } from "@hiveai/core";
 var MS_PER_MINUTE = 6e4;
 function registerPlayback(program2) {
   program2.command("playback").description(
     "Replay past sessions from the usage log. For each session, show:\n  - tool calls (what kind, how many)\n  - briefing tasks asked\n  - memories that have been created since then (that the session didn't have)\n\n  Useful to ask 'would today's haive have helped past me on this task?'"
   ).option("--since <window>", "limit to events in this window (e.g. '7d')", "30d").option("--session-gap <minutes>", "minutes of inactivity that splits a session", "30").option("--limit <n>", "show at most this many sessions (newest first)", "10").option("--json", "emit JSON instead of human-readable output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot39(opts.dir);
-    const paths = resolveHaivePaths36(root);
+    const root = findProjectRoot41(opts.dir);
+    const paths = resolveHaivePaths37(root);
     const events = await readUsageEvents5(paths);
     if (events.length === 0) {
       if (opts.json) {
@@ -10573,7 +10911,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 = existsSync60(paths.memoriesDir) ? await loadMemoriesFromDir33(paths.memoriesDir) : [];
+    const all = existsSync61(paths.memoriesDir) ? await loadMemoriesFromDir33(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);
@@ -10663,8 +11001,8 @@ function truncate3(text, max) {
 import { spawn as spawn4 } from "child_process";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot40,
-  resolveHaivePaths as resolveHaivePaths37
+  findProjectRoot as findProjectRoot42,
+  resolveHaivePaths as resolveHaivePaths38
 } from "@hiveai/core";
 function registerPrecommit(program2) {
   program2.command("precommit").description(
@@ -10674,8 +11012,8 @@ function registerPrecommit(program2) {
     "'any' | 'high-confidence' (default) | 'never' (report only)",
     "high-confidence"
   ).option("--no-semantic", "disable semantic search in anti-patterns matching").option("--json", "emit JSON instead of human-readable output", false).option("--paths <paths...>", "explicit paths to check (skips git diff)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot40(opts.dir);
-    const paths = resolveHaivePaths37(root);
+    const root = findProjectRoot42(opts.dir);
+    const paths = resolveHaivePaths38(root);
     const ctx = { paths };
     let diff = "";
     let touchedPaths = opts.paths ?? [];
@@ -10767,12 +11105,12 @@ function runCommand3(cmd, args, cwd) {
 }
 
 // src/commands/welcome.ts
-import { existsSync as existsSync61 } from "fs";
+import { existsSync as existsSync63 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot41,
+  findProjectRoot as findProjectRoot43,
   loadMemoriesFromDir as loadMemoriesFromDir34,
-  resolveHaivePaths as resolveHaivePaths38
+  resolveHaivePaths as resolveHaivePaths39
 } from "@hiveai/core";
 var TYPE_RANK = {
   decision: 0,
@@ -10786,9 +11124,9 @@ function registerWelcome(program2) {
   program2.command("welcome").description(
     "Onboarding checklist: ranks validated/proposed **team** memories by type.\nUse after `haive init` so new devs skim institutional knowledge quickly.\n\n  haive welcome\n  haive welcome --limit 15\n"
   ).option("--limit <n>", "maximum memories listed", "20").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot41(opts.dir);
-    const paths = resolveHaivePaths38(root);
-    if (!existsSync61(paths.memoriesDir)) {
+    const root = findProjectRoot43(opts.dir);
+    const paths = resolveHaivePaths39(root);
+    if (!existsSync63(paths.memoriesDir)) {
       ui.error(`No memories at ${paths.memoriesDir}. Run 'haive init' first.`);
       process.exitCode = 1;
       return;
@@ -10829,17 +11167,17 @@ function registerWelcome(program2) {
 }
 
 // src/commands/memory-lint.ts
-import { existsSync as existsSync63 } from "fs";
+import { existsSync as existsSync64 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot42,
+  findProjectRoot as findProjectRoot44,
   loadMemoriesFromDir as loadMemoriesFromDir35,
-  resolveHaivePaths as resolveHaivePaths39
+  resolveHaivePaths as resolveHaivePaths40
 } from "@hiveai/core";
 async function lintMemoriesAsync(root) {
-  const paths = resolveHaivePaths39(root);
+  const paths = resolveHaivePaths40(root);
   const out = [];
-  if (!existsSync63(paths.memoriesDir)) return out;
+  if (!existsSync64(paths.memoriesDir)) return out;
   const loaded = await loadMemoriesFromDir35(paths.memoriesDir);
   const ANCHOR_TYPES = /* @__PURE__ */ new Set(["decision", "architecture", "gotcha"]);
   for (const { filePath, memory: memory2 } of loaded) {
@@ -10900,7 +11238,7 @@ function registerMemoryLint(parent) {
   parent.command("lint").description(
     "Heuristic corpus checks (anchors on key types, headings, verbosity). Static analysis only."
   ).option("--json", "emit findings as JSON", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot42(opts.dir);
+    const root = findProjectRoot44(opts.dir);
     const findings = await lintMemoriesAsync(root);
     if (opts.json) {
       console.log(JSON.stringify({ findings_count: findings.length, findings }, null, 2));
@@ -10946,27 +11284,27 @@ function registerMemorySuggestTopic(memory2) {
 }
 
 // src/commands/resolve-project.ts
-import path40 from "path";
+import path43 from "path";
 import "commander";
 import { resolveProjectInfo as resolveProjectInfo2 } from "@hiveai/core";
 function registerResolveProject(program2) {
   program2.command("resolve-project").description(
     "Print JSON for hAIve project root resolution (HAIVE_PROJECT_ROOT, markers, .ai layout)."
   ).option("-d, --dir <dir>", "working directory", process.cwd()).action((opts) => {
-    const info = resolveProjectInfo2({ cwd: path40.resolve(opts.dir) });
+    const info = resolveProjectInfo2({ cwd: path43.resolve(opts.dir) });
     console.log(JSON.stringify({ ok: true, info }, null, 2));
   });
 }
 
 // src/commands/runtime-journal.ts
-import { existsSync as existsSync64 } from "fs";
-import path41 from "path";
+import { existsSync as existsSync65 } from "fs";
+import path44 from "path";
 import "commander";
 import {
   appendRuntimeJournalEntry as appendRuntimeJournalEntry3,
-  findProjectRoot as findProjectRoot43,
+  findProjectRoot as findProjectRoot45,
   readRuntimeJournalTail as readRuntimeJournalTail2,
-  resolveHaivePaths as resolveHaivePaths40
+  resolveHaivePaths as resolveHaivePaths41
 } from "@hiveai/core";
 function registerRuntime(program2) {
   const runtime = program2.command("runtime").description(
@@ -10974,18 +11312,18 @@ function registerRuntime(program2) {
   );
   const journal = runtime.command("journal").description("Append or read the machine-local session journal (NDJSON)");
   journal.command("append").description("Append one JSON line to .ai/.runtime/session-journal.ndjson").argument("<message>", "short text to log").option("-k, --kind <kind>", "note | session_end | mcp", "note").option("-d, --dir <dir>", "project root", process.cwd()).action(async (message, opts) => {
-    const root = path41.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths40(findProjectRoot43(root));
+    const root = path44.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths41(findProjectRoot45(root));
     const raw = opts.kind ?? "note";
     const kind = ["note", "session_end", "mcp"].includes(raw) ? raw : "note";
     await appendRuntimeJournalEntry3(paths, { kind, message });
-    ui.success(`Appended to ${path41.relative(root, paths.runtimeDir)}/session-journal.ndjson`);
+    ui.success(`Appended to ${path44.relative(root, paths.runtimeDir)}/session-journal.ndjson`);
   });
   journal.command("tail").description("Print the last N entries from the runtime session journal as JSON").option("-n, --limit <n>", "number of lines", "30").option("-d, --dir <dir>", "project root", process.cwd()).action(async (opts) => {
-    const root = path41.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths40(findProjectRoot43(root));
+    const root = path44.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths41(findProjectRoot45(root));
     const limit = Math.min(500, Math.max(1, parseInt(opts.limit, 10) || 30));
-    if (!existsSync64(paths.haiveDir)) {
+    if (!existsSync65(paths.haiveDir)) {
       ui.error("No .ai/ \u2014 run `haive init` first.");
       process.exitCode = 1;
       return;
@@ -11000,13 +11338,13 @@ function registerRuntime(program2) {
 }
 
 // src/commands/memory-timeline.ts
-import { existsSync as existsSync65 } from "fs";
-import path43 from "path";
+import { existsSync as existsSync66 } from "fs";
+import path45 from "path";
 import "commander";
 import {
   collectTimelineEntries as collectTimelineEntries2,
-  findProjectRoot as findProjectRoot44,
-  resolveHaivePaths as resolveHaivePaths41
+  findProjectRoot as findProjectRoot46,
+  resolveHaivePaths as resolveHaivePaths42
 } from "@hiveai/core";
 function registerMemoryTimeline(memory2) {
   memory2.command("timeline").description(
@@ -11017,9 +11355,9 @@ function registerMemoryTimeline(memory2) {
       process.exitCode = 1;
       return;
     }
-    const root = path43.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths41(findProjectRoot44(root));
-    if (!existsSync65(paths.memoriesDir)) {
+    const root = path45.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths42(findProjectRoot46(root));
+    if (!existsSync66(paths.memoriesDir)) {
       ui.error("No memories \u2014 run `haive init`.");
       process.exitCode = 1;
       return;
@@ -11037,14 +11375,14 @@ function registerMemoryTimeline(memory2) {
 }
 
 // src/commands/memory-conflict-candidates.ts
-import { existsSync as existsSync66 } from "fs";
-import path44 from "path";
+import { existsSync as existsSync67 } from "fs";
+import path46 from "path";
 import "commander";
 import {
   findLexicalConflictPairs as findLexicalConflictPairs2,
   findTopicStatusConflictPairs as findTopicStatusConflictPairs2,
-  findProjectRoot as findProjectRoot45,
-  resolveHaivePaths as resolveHaivePaths42
+  findProjectRoot as findProjectRoot47,
+  resolveHaivePaths as resolveHaivePaths43
 } from "@hiveai/core";
 function parseTypes(csv) {
   const allowed = ["decision", "architecture", "convention", "gotcha"];
@@ -11060,9 +11398,9 @@ function registerMemoryConflictCandidates(memory2) {
     "decision,architecture,convention,gotcha (lexical scan)",
     "decision,architecture"
   ).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 = path44.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths42(findProjectRoot45(root));
-    if (!existsSync66(paths.memoriesDir)) {
+    const root = path46.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths43(findProjectRoot47(root));
+    if (!existsSync67(paths.memoriesDir)) {
       ui.error("No memories \u2014 run `haive init`.");
       process.exitCode = 1;
       return;
@@ -11098,18 +11436,20 @@ function registerMemoryConflictCandidates(memory2) {
 
 // src/commands/enforce.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync67 } from "fs";
-import { chmod as chmod2, mkdir as mkdir18, readFile as readFile16, writeFile as writeFile30 } from "fs/promises";
-import path45 from "path";
+import { existsSync as existsSync68 } from "fs";
+import { chmod as chmod2, mkdir as mkdir19, readFile as readFile17, rm as rm3, writeFile as writeFile31 } from "fs/promises";
+import path47 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot46,
+  findProjectRoot as findProjectRoot48,
   hasRecentBriefingMarker,
   isFreshIsoDate,
   loadConfig as loadConfig8,
   loadMemoriesFromDir as loadMemoriesFromDir36,
+  memoryMatchesAnchorPaths as memoryMatchesAnchorPaths6,
+  readRecentBriefingMarker,
   resolveBriefingBudget as resolveBriefingBudget3,
-  resolveHaivePaths as resolveHaivePaths43,
+  resolveHaivePaths as resolveHaivePaths44,
   saveConfig as saveConfig3,
   SESSION_RECAP_TTL_MS,
   verifyAnchor as verifyAnchor4,
@@ -11122,9 +11462,9 @@ function registerEnforce(program2) {
     "Agent-agnostic enforcement helpers: install policy gates, report status, and block unsafe workflows."
   );
   enforce.command("install").description("Install hAIve enforcement across MCP config, git hooks, CI template, and supported client hooks.").option("-d, --dir <dir>", "project root").option("--no-git", "skip git pre-commit/pre-push enforcement hooks").option("--no-claude", "skip Claude Code hooks").option("--no-ci", "skip GitHub Actions enforcement workflow").action(async (opts) => {
-    const root = findProjectRoot46(opts.dir);
-    const paths = resolveHaivePaths43(root);
-    await mkdir18(paths.haiveDir, { recursive: true });
+    const root = findProjectRoot48(opts.dir);
+    const paths = resolveHaivePaths44(root);
+    await mkdir19(paths.haiveDir, { recursive: true });
     const current = await loadConfig8(paths);
     await saveConfig3(paths, {
       ...current,
@@ -11135,7 +11475,11 @@ function registerEnforce(program2) {
         requireSessionRecap: true,
         requireMemoryVerify: true,
         blockStaleDecisionChanges: true,
-        toolProfile: "enforcement"
+        requireDecisionCoverage: true,
+        scoreThreshold: 85,
+        cleanupGeneratedArtifacts: true,
+        toolProfile: "enforcement",
+        policyPacks: ["architecture", "gotchas", "security", "domain", "release"]
       }
     });
     ui.success("hAIve strict enforcement enabled in .ai/haive.config.json");
@@ -11144,7 +11488,7 @@ function registerEnforce(program2) {
     if (opts.claude !== false) {
       try {
         const result = await installClaudeHooksAtPath(defaultClaudeSettingsPath("project", root));
-        ui.success(`${result.created ? "Created" : "Patched"} Claude Code hooks (${path45.relative(root, result.settingsPath)})`);
+        ui.success(`${result.created ? "Created" : "Patched"} Claude Code hooks (${path47.relative(root, result.settingsPath)})`);
       } catch (err) {
         ui.warn(`Claude Code hooks not installed: ${err instanceof Error ? err.message : String(err)}`);
       }
@@ -11162,6 +11506,23 @@ function registerEnforce(program2) {
     printReport(report, Boolean(opts.json));
     if (report.should_block) process.exit(2);
   });
+  enforce.command("cleanup").description("Remove generated hAIve runtime/cache artifacts that should not appear in commits.").option("-d, --dir <dir>", "project root").option("--dry-run", "print what would be removed without deleting", false).action(async (opts) => {
+    const root = findProjectRoot48(opts.dir);
+    const paths = resolveHaivePaths44(root);
+    const targets = [
+      path47.join(paths.haiveDir, ".cache"),
+      path47.join(paths.haiveDir, ".runtime")
+    ];
+    for (const target of targets) {
+      if (!existsSync68(target)) continue;
+      const rel = path47.relative(root, target);
+      if (opts.dryRun) ui.info(`would remove ${rel}`);
+      else {
+        await rm3(target, { recursive: true, force: true });
+        ui.success(`removed ${rel}`);
+      }
+    }
+  });
   enforce.command("ci").description("CI entrypoint: fail if the repository violates hAIve enforcement policy.").option("-d, --dir <dir>", "project root").option("--json", "emit JSON", false).action(async (opts) => {
     const report = await buildEnforcementReport(opts.dir, "ci");
     printReport(report, Boolean(opts.json));
@@ -11171,16 +11532,11 @@ function registerEnforce(program2) {
     const payload = await readHookPayload();
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
-    const paths = resolveHaivePaths43(root);
-    if (!existsSync67(paths.haiveDir)) return;
-    await mkdir18(paths.runtimeDir, { recursive: true });
+    const paths = resolveHaivePaths44(root);
+    if (!existsSync68(paths.haiveDir)) return;
+    await mkdir19(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.";
-    await writeBriefingMarker2(paths, {
-      sessionId,
-      task,
-      source: opts.source ?? "claude-session-start"
-    });
     const budget = resolveBriefingBudget3("quick", {
       max_tokens: 2500,
       max_memories: 5,
@@ -11204,6 +11560,12 @@ function registerEnforce(program2) {
       },
       { paths }
     );
+    await writeBriefingMarker2(paths, {
+      sessionId,
+      task,
+      source: opts.source ?? "claude-session-start",
+      memoryIds: briefing.memories.map((m) => m.id)
+    });
     console.log("hAIve briefing loaded. Agents must consult this before editing.");
     if (briefing.last_session) {
       console.log(`
@@ -11232,8 +11594,8 @@ ${briefing.project_context.content.slice(0, 1800)}`);
     const payload = await readHookPayload();
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
-    const paths = resolveHaivePaths43(root);
-    if (!existsSync67(paths.haiveDir)) return;
+    const paths = resolveHaivePaths44(root);
+    if (!existsSync68(paths.haiveDir)) return;
     if (!isWriteLikeTool(payload)) return;
     const ok = await hasRecentBriefingMarker(paths, payload.session_id);
     if (ok) return;
@@ -11255,9 +11617,9 @@ ${briefing.project_context.content.slice(0, 1800)}`);
   });
 }
 async function runWithEnforcement(command, args, opts) {
-  const root = findProjectRoot46(opts.dir);
-  const paths = resolveHaivePaths43(root);
-  if (!existsSync67(paths.haiveDir)) {
+  const root = findProjectRoot48(opts.dir);
+  const paths = resolveHaivePaths44(root);
+  if (!existsSync68(paths.haiveDir)) {
     ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
     process.exit(1);
   }
@@ -11276,7 +11638,7 @@ async function runWithEnforcement(command, args, opts) {
     process.exit(2);
   }
   ui.info(`hAIve briefing marker created for wrapped agent session: ${sessionId}`);
-  ui.info(`Briefing written to ${path45.relative(root, briefingFile)} and exported as HAIVE_BRIEFING_FILE`);
+  ui.info(`Briefing written to ${path47.relative(root, briefingFile)} and exported as HAIVE_BRIEFING_FILE`);
   const child = spawn5(command, args, {
     cwd: root,
     stdio: "inherit",
@@ -11319,9 +11681,15 @@ async function writeWrapperBriefing(paths, sessionId, task) {
     min_semantic_score: 0.25,
     budget_preset: "quick"
   }, { paths });
-  const dir = path45.join(paths.runtimeDir, "enforcement", "briefings");
-  await mkdir18(dir, { recursive: true });
-  const file = path45.join(dir, `${sessionId}.md`);
+  await writeBriefingMarker2(paths, {
+    sessionId,
+    task,
+    source: "haive-run",
+    memoryIds: briefing.memories.map((m) => m.id)
+  });
+  const dir = path47.join(paths.runtimeDir, "enforcement", "briefings");
+  await mkdir19(dir, { recursive: true });
+  const file = path47.join(dir, `${sessionId}.md`);
   const parts = [
     "# hAIve Briefing",
     "",
@@ -11339,13 +11707,13 @@ async function writeWrapperBriefing(paths, sessionId, task) {
   if (briefing.setup_warnings.length > 0) {
     parts.push("", "## Setup Warnings", ...briefing.setup_warnings.map((w) => `- ${w}`));
   }
-  await writeFile30(file, parts.join("\n") + "\n", "utf8");
+  await writeFile31(file, parts.join("\n") + "\n", "utf8");
   return file;
 }
 async function buildEnforcementReport(dir, stage, sessionId) {
-  const root = findProjectRoot46(dir);
-  const paths = resolveHaivePaths43(root);
-  const initialized = existsSync67(paths.haiveDir);
+  const root = findProjectRoot48(dir);
+  const paths = resolveHaivePaths44(root);
+  const initialized = existsSync68(paths.haiveDir);
   const config = initialized ? await loadConfig8(paths) : {};
   const mode = config.enforcement?.mode ?? "strict";
   const findings = [];
@@ -11354,12 +11722,14 @@ async function buildEnforcementReport(dir, stage, sessionId) {
       root,
       initialized,
       mode,
+      score: buildScore([], config.enforcement?.scoreThreshold),
       should_block: true,
       findings: [{
         severity: "error",
         code: "not-initialized",
         message: "This repository is not initialized with hAIve.",
-        fix: "Run `haive init` or `haive enforce install`."
+        fix: "Run `haive init` or `haive enforce install`.",
+        impact: 100
       }]
     };
   }
@@ -11368,6 +11738,7 @@ async function buildEnforcementReport(dir, stage, sessionId) {
       root,
       initialized,
       mode,
+      score: buildScore([], config.enforcement?.scoreThreshold),
       should_block: false,
       findings: [{ severity: "info", code: "enforcement-off", message: "hAIve enforcement is disabled." }]
     };
@@ -11378,42 +11749,67 @@ async function buildEnforcementReport(dir, stage, sessionId) {
       severity: "error",
       code: "briefing-missing",
       message: "No recent hAIve briefing marker was found for this workflow.",
-      fix: 'Run `haive briefing --task "..."`, `haive enforce session-start`, or wrap the agent with `haive run -- <agent>`.'
+      fix: 'Run `haive briefing --task "..."`, `haive enforce session-start`, or wrap the agent with `haive run -- <agent>`.',
+      impact: 35
     });
   }
   if (config.enforcement?.requireSessionRecap !== false && (stage === "pre-push" || stage === "ci")) {
     const hasRecap = await hasRecentSessionRecap(paths);
-    findings.push(hasRecap ? { severity: "ok", code: "session-recap-present", message: "A recent session_recap memory exists." } : {
+    findings.push(hasRecap ? { severity: "ok", code: "session-recap-present", message: "A recent session_recap memory exists." } : stage === "ci" ? {
+      severity: "warn",
+      code: "session-recap-missing",
+      message: "No recent session_recap memory was found. CI reports this as a warning because personal recaps are usually not committed.",
+      fix: "Run `haive session end --scope team --goal ... --accomplished ...` if you want a team recap visible in CI.",
+      impact: 5
+    } : {
       severity: "error",
       code: "session-recap-missing",
       message: "No recent session_recap memory was found.",
-      fix: "Run `haive session end --goal ... --accomplished ...` before pushing."
+      fix: "Run `haive session end --goal ... --accomplished ...` before pushing.",
+      impact: 20
     });
   }
   if (config.enforcement?.requireMemoryVerify !== false) {
     findings.push(...await verifyMemoryPolicy(paths, config));
   }
+  if (config.enforcement?.requireDecisionCoverage !== false) {
+    findings.push(...await verifyDecisionCoverage(paths, stage, sessionId));
+  }
   if (stage === "pre-commit" || stage === "ci") {
     findings.push(...await runPrecommitPolicy(paths));
   }
+  if (config.enforcement?.cleanupGeneratedArtifacts !== false) {
+    findings.push(...await findGeneratedArtifacts(paths));
+  }
+  const score = buildScore(findings, config.enforcement?.scoreThreshold);
+  if (score.score < score.threshold) {
+    findings.push({
+      severity: "error",
+      code: "enforcement-score-below-threshold",
+      message: `Enforcement score ${score.score}% is below required threshold ${score.threshold}%.`,
+      fix: "Load the relevant briefing, address policy findings, then rerun `haive enforce check`.",
+      impact: 0
+    });
+  }
   const hasErrors = findings.some((f) => f.severity === "error");
   return {
     root,
     initialized,
     mode,
+    score: buildScore(findings, config.enforcement?.scoreThreshold),
     should_block: mode === "strict" && hasErrors,
     findings
   };
 }
 async function hasRecentSessionRecap(paths) {
-  if (!existsSync67(paths.memoriesDir)) return false;
+  if (!existsSync68(paths.memoriesDir)) return false;
   const all = await loadMemoriesFromDir36(paths.memoriesDir);
   return all.some(
     ({ memory: memory2 }) => memory2.frontmatter.type === "session_recap" && memory2.frontmatter.status !== "rejected" && isFreshIsoDate(memory2.frontmatter.created_at, SESSION_RECAP_TTL_MS)
   );
 }
 async function verifyMemoryPolicy(paths, config) {
-  if (!existsSync67(paths.memoriesDir)) return [];
+  if (!existsSync68(paths.memoriesDir)) return [];
   const all = await loadMemoriesFromDir36(paths.memoriesDir);
   const findings = [];
   const staleImportant = [];
@@ -11444,11 +11840,51 @@ async function verifyMemoryPolicy(paths, config) {
       severity: "error",
       code: "stale-important-memories",
       message: `${staleImportant.length} important anchored memories are stale: ${staleImportant.slice(0, 8).join(", ")}`,
-      fix: "Run `haive memory verify --update`, then update or delete stale decisions/gotchas before merging."
+      fix: "Run `haive memory verify --update`, then update or delete stale decisions/gotchas before merging.",
+      impact: 40
     });
   }
   return findings;
 }
+async function verifyDecisionCoverage(paths, stage, sessionId) {
+  if (!existsSync68(paths.memoriesDir)) return [];
+  const changedFiles = await getChangedFiles(paths.root, stage);
+  if (changedFiles.length === 0) {
+    return [{ severity: "info", code: "decision-coverage-no-changes", message: "No changed files to match against policy memories." }];
+  }
+  const all = await loadMemoriesFromDir36(paths.memoriesDir);
+  const policyTypes = /* @__PURE__ */ new Set(["decision", "gotcha", "architecture", "convention"]);
+  const relevant = all.map(({ memory: memory2 }) => memory2).filter((memory2) => {
+    const fm = memory2.frontmatter;
+    if (!policyTypes.has(fm.type)) return false;
+    if (fm.status === "rejected" || fm.status === "deprecated" || fm.status === "stale") return false;
+    return memoryMatchesAnchorPaths6(memory2, changedFiles);
+  });
+  if (relevant.length === 0) {
+    return [{
+      severity: "ok",
+      code: "decision-coverage-none-required",
+      message: `No anchored decisions or policies matched ${changedFiles.length} changed file(s).`
+    }];
+  }
+  const marker = await readRecentBriefingMarker(paths, sessionId);
+  const consulted = new Set(marker?.memory_ids ?? []);
+  const missing = relevant.filter((memory2) => !consulted.has(memory2.frontmatter.id));
+  if (missing.length === 0) {
+    return [{
+      severity: "ok",
+      code: "decision-coverage-pass",
+      message: `Relevant decisions/policies were surfaced for ${changedFiles.length} changed file(s): ${relevant.length}/${relevant.length}.`
+    }];
+  }
+  return [{
+    severity: stage === "local" ? "warn" : "error",
+    code: "decision-coverage-missing",
+    message: `${missing.length}/${relevant.length} relevant anchored decisions/policies were not present in the latest briefing: ${missing.slice(0, 6).map((m) => m.frontmatter.id).join(", ")}`,
+    fix: `Run \`haive briefing --files "${changedFiles.slice(0, 10).join(",")}" --task "..."\` before committing.`,
+    impact: Math.min(35, 10 + missing.length * 5)
+  }];
+}
 async function runPrecommitPolicy(paths) {
   const staged = await runCommand4("git", ["diff", "--cached", "--name-only"], paths.root).catch(() => "");
   const touchedPaths = staged.split("\n").map((s) => s.trim()).filter(Boolean);
@@ -11473,16 +11909,66 @@ async function runPrecommitPolicy(paths) {
     severity: "error",
     code: "precommit-policy-block",
     message: `Pre-commit policy matched ${result.summary.anti_patterns} anti-pattern(s), ${result.summary.stale_anchors} stale anchor(s).`,
-    fix: "Review the hAIve warnings, then update the code or the relevant memories."
+    fix: "Review the hAIve warnings, then update the code or the relevant memories.",
+    impact: 45
+  }];
+}
+async function findGeneratedArtifacts(paths) {
+  const dirty = await runCommand4("git", ["status", "--short", "--untracked-files=all"], paths.root).catch(() => "");
+  const generated = dirty.split("\n").map((line) => line.trim()).filter(Boolean).filter(
+    (line) => line.includes(".ai/.cache/") || line.includes(".ai/.runtime/") || line.includes("__pycache__/") || line.endsWith(".pyc")
+  );
+  if (generated.length === 0) {
+    return [{ severity: "ok", code: "generated-artifacts-clean", message: "No generated runtime/cache artifacts are visible to git." }];
+  }
+  return [{
+    severity: "warn",
+    code: "generated-artifacts-visible",
+    message: `${generated.length} generated artifact(s) are visible in git status.`,
+    fix: "Run `haive enforce cleanup`, update .gitignore, or remove test/runtime outputs before committing.",
+    impact: 10
   }];
 }
+async function getChangedFiles(root, stage) {
+  const commands = stage === "pre-commit" ? [["diff", "--cached", "--name-only"]] : [
+    ["diff", "--cached", "--name-only"],
+    ["diff", "--name-only"]
+  ];
+  const files = /* @__PURE__ */ new Set();
+  for (const args of commands) {
+    const out = await runCommand4("git", args, root).catch(() => "");
+    for (const line of out.split("\n")) {
+      const file = line.trim();
+      if (file) files.add(file);
+    }
+  }
+  return [...files].filter((file) => !file.startsWith(".ai/.runtime/") && !file.startsWith(".ai/.cache/"));
+}
+function buildScore(findings, threshold = 80) {
+  const checks = {
+    total: findings.length,
+    ok: findings.filter((f) => f.severity === "ok").length,
+    warn: findings.filter((f) => f.severity === "warn").length,
+    error: findings.filter((f) => f.severity === "error").length
+  };
+  const penalty = findings.reduce((sum, f) => {
+    if (f.severity === "error") return sum + (f.impact ?? 25);
+    if (f.severity === "warn") return sum + (f.impact ?? 8);
+    return sum;
+  }, 0);
+  return {
+    score: Math.max(0, Math.min(100, 100 - penalty)),
+    threshold,
+    checks
+  };
+}
 async function installGitEnforcement(root) {
-  const hooksDir = path45.join(root, ".git", "hooks");
-  if (!existsSync67(path45.join(root, ".git"))) {
+  const hooksDir = path47.join(root, ".git", "hooks");
+  if (!existsSync68(path47.join(root, ".git"))) {
     ui.warn("No .git directory found; git enforcement hooks skipped.");
     return;
   }
-  await mkdir18(hooksDir, { recursive: true });
+  await mkdir19(hooksDir, { recursive: true });
   const hooks = [
     {
       name: "pre-commit",
@@ -11500,31 +11986,31 @@ haive enforce check --stage pre-push --dir . || exit $?
     }
   ];
   for (const hook of hooks) {
-    const file = path45.join(hooksDir, hook.name);
-    if (existsSync67(file)) {
-      const current = await readFile16(file, "utf8").catch(() => "");
+    const file = path47.join(hooksDir, hook.name);
+    if (existsSync68(file)) {
+      const current = await readFile17(file, "utf8").catch(() => "");
       if (current.includes(ENFORCE_HOOK_MARKER)) {
-        await writeFile30(file, hook.body, "utf8");
+        await writeFile31(file, hook.body, "utf8");
       } else {
-        await writeFile30(file, `${current.trimEnd()}
+        await writeFile31(file, `${current.trimEnd()}
 
 ${hook.body}`, "utf8");
       }
     } else {
-      await writeFile30(file, hook.body, "utf8");
+      await writeFile31(file, hook.body, "utf8");
     }
     await chmod2(file, 493);
   }
   ui.success("Installed blocking git enforcement hooks: pre-commit, pre-push");
 }
 async function installCiEnforcement(root) {
-  const workflowPath = path45.join(root, ".github", "workflows", "haive-enforcement.yml");
-  await mkdir18(path45.dirname(workflowPath), { recursive: true });
-  if (existsSync67(workflowPath)) {
+  const workflowPath = path47.join(root, ".github", "workflows", "haive-enforcement.yml");
+  await mkdir19(path47.dirname(workflowPath), { recursive: true });
+  if (existsSync68(workflowPath)) {
     ui.info("GitHub Actions enforcement workflow already exists \u2014 skipped");
     return;
   }
-  await writeFile30(workflowPath, `name: haive-enforcement
+  await writeFile31(workflowPath, `name: haive-enforcement
 
 on:
   pull_request:
@@ -11548,7 +12034,7 @@ jobs:
       - name: Enforce hAIve policy
         run: haive enforce ci
 `, "utf8");
-  ui.success(`Created ${path45.relative(root, workflowPath)}`);
+  ui.success(`Created ${path47.relative(root, workflowPath)}`);
 }
 function printReport(report, json) {
   if (json) {
@@ -11557,6 +12043,7 @@ function printReport(report, json) {
   }
   console.log(ui.bold(`hAIve enforcement \u2014 ${report.mode}`));
   console.log(ui.dim(`  root: ${report.root}`));
+  console.log(ui.dim(`  score: ${report.score.score}% / threshold ${report.score.threshold}%`));
   for (const finding of report.findings) {
     const marker = finding.severity === "error" ? ui.red("\u2717") : finding.severity === "warn" ? ui.yellow("\u26A0") : finding.severity === "ok" ? ui.green("\u2713") : ui.dim("\u2022");
     console.log(`${marker} ${finding.code}: ${finding.message}`);
@@ -11576,7 +12063,7 @@ async function readHookPayload() {
 }
 function resolveRoot(dir, payload) {
   try {
-    return findProjectRoot46(dir ?? payload.cwd);
+    return findProjectRoot48(dir ?? payload.cwd);
   } catch {
     return null;
   }
@@ -11645,14 +12132,15 @@ function registerRun(program2) {
 }
 
 // src/index.ts
-var program = new Command49();
-program.name("haive").description("hAIve \u2014 team-first persistent memory layer for AI coding agents").version("0.9.10");
+var program = new Command51();
+program.name("haive").description("hAIve \u2014 policy enforcement layer for AI coding agents").version("0.9.12");
 registerInit(program);
 registerWelcome(program);
 registerResolveProject(program);
 registerRuntime(program);
 registerEnforce(program);
 registerRun(program);
+registerAgent(program);
 registerMcp(program);
 registerBriefing(program);
 registerTui(program);
@@ -11694,6 +12182,7 @@ registerSnapshot(program);
 registerHub(program);
 registerStats(program);
 registerBench(program);
+registerBenchmark(program);
 registerDoctor(program);
 registerPlayback(program);
 registerPrecommit(program);