@hiveai/cli 0.9.11 → 0.9.13

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command50 } 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(([path47, changes]) => ({ path: path47, 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)));
@@ -730,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",
@@ -832,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) {
@@ -854,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) {
@@ -870,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);
@@ -989,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 {
     }
   }
@@ -1002,14 +1383,14 @@ async function generateBootstrapContext(root) {
   const language = detectLanguage(root);
   const isMonorepo = pkg.workspaces !== void 0 && (Array.isArray(pkg.workspaces) ? pkg.workspaces.length > 0 : true);
   const projectType = detectProjectType(frameworks, pkg.scripts ?? {}, isMonorepo);
-  const projectName = pkg.name ?? 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 {
@@ -1071,201 +1452,10 @@ async function generateBootstrapContext(root) {
   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;
-}
-
 // 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,
@@ -1877,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({
@@ -1888,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;
@@ -2105,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 });
@@ -2147,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);
@@ -2170,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" }
@@ -2201,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();
@@ -2279,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 ?? {} };
@@ -2293,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
@@ -2325,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",
@@ -2447,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 {
@@ -2457,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
@@ -2531,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.`);
@@ -2552,7 +2738,7 @@ async function installGitHooks(opts) {
         continue;
       }
     }
-    await writeFile5(file, body, "utf8");
+    await writeFile6(file, body, "utf8");
     await chmod(file, 493);
     installed++;
   }
@@ -2562,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) {
@@ -2607,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) {
@@ -2681,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,
@@ -2697,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"
       );
@@ -2711,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";
@@ -2803,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";
@@ -2820,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 {
@@ -2981,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"),
@@ -2992,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"
@@ -3754,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);
@@ -3890,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 = {
@@ -4120,6 +4306,7 @@ async function memSessionEnd(input, ctx) {
     const revisionCount = (fm.revision_count ?? 0) + 1;
     const newFrontmatter = {
       ...fm,
+      verified_at: (/* @__PURE__ */ new Date()).toISOString(),
       revision_count: revisionCount,
       anchor: {
         ...fm.anchor,
@@ -5520,13 +5707,11 @@ async function preCommitCheck(input, ctx) {
   const filesTouching = new Set(relevantMatches.map((m) => m.id));
   const staleHits = verifyResult.results.filter((r) => r.stale && filesTouching.has(r.id));
   const blockOn = input.block_on;
+  const blockingWarnings = apResult.warnings.filter(isBlockingWarning);
   let should_block = false;
   if (blockOn !== "never") {
-    const high = apResult.warnings.filter(
-      (w) => w.confidence === "authoritative" || w.confidence === "trusted"
-    );
     if (blockOn === "any" && (apResult.warnings.length > 0 || staleHits.length > 0)) should_block = true;
-    if (blockOn === "high-confidence" && (high.length > 0 || staleHits.length > 0)) should_block = true;
+    if (blockOn === "high-confidence" && (blockingWarnings.length > 0 || staleHits.length > 0)) should_block = true;
   }
   const relevant_memories = relevantMatches.slice(0, 8).map((m) => ({
     id: m.id,
@@ -5538,6 +5723,7 @@ async function preCommitCheck(input, ctx) {
     should_block,
     summary: {
       anti_patterns: apResult.warnings.length,
+      blocking_warnings: blockingWarnings.length,
       relevant_memories: relevant_memories.length,
       stale_anchors: staleHits.length
     },
@@ -5551,6 +5737,11 @@ async function preCommitCheck(input, ctx) {
     }))
   };
 }
+function isBlockingWarning(warning) {
+  const highConfidence = warning.confidence === "authoritative" || warning.confidence === "trusted";
+  if (!highConfidence) return false;
+  return warning.reasons.includes("semantic") && (warning.semantic_score ?? 0) >= 0.65;
+}
 var CONFIG_PATTERNS = [
   ".eslintrc",
   "eslint.config",
@@ -6082,7 +6273,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
   };
 }
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.9.11";
+var SERVER_VERSION = "0.9.13";
 function jsonResult(data) {
   return {
     content: [
@@ -6991,7 +7182,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) {
@@ -7002,15 +7193,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,
@@ -7019,7 +7210,7 @@ import {
   loadMemoriesFromDir as loadMemoriesFromDir23,
   loadUsageIndex as loadUsageIndex12,
   pullCrossRepoSources,
-  resolveHaivePaths as resolveHaivePaths7,
+  resolveHaivePaths as resolveHaivePaths8,
   resolveManifestFiles,
   serializeMemory as serializeMemory11,
   trackDependencies,
@@ -7038,8 +7229,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;
@@ -7172,7 +7363,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);
     }
@@ -7278,10 +7469,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"
                 );
@@ -7345,10 +7536,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"
             );
@@ -7362,7 +7553,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",
@@ -7441,11 +7632,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;
@@ -7453,19 +7644,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" }
@@ -7485,17 +7676,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) {
@@ -7523,8 +7714,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;
@@ -7536,7 +7727,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}`);
@@ -7601,7 +7792,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;
       }
@@ -7620,7 +7811,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;
@@ -7639,7 +7830,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)`);
@@ -7670,9 +7861,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 {
@@ -7684,8 +7875,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;
@@ -7718,7 +7909,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"}`));
@@ -7753,20 +7944,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;
@@ -7802,11 +7993,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)`));
   });
 }
@@ -7814,17 +8005,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;
@@ -7878,24 +8069,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;
@@ -7948,7 +8139,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(", ")}`);
   });
 }
@@ -7969,15 +8160,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) {
@@ -7986,8 +8177,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;
@@ -8014,7 +8205,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" },
@@ -8033,17 +8224,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;
@@ -8057,7 +8248,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}.`);
@@ -8085,21 +8276,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;
@@ -8207,24 +8398,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;
@@ -8253,7 +8444,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\`.`
@@ -8262,15 +8453,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) {
@@ -8290,8 +8481,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;
@@ -8315,14 +8506,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)`);
   });
 }
@@ -8333,18 +8524,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;
@@ -8373,7 +8564,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`);
   });
@@ -8381,22 +8572,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;
@@ -8438,7 +8629,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}`);
     }
@@ -8459,17 +8650,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;
@@ -8508,19 +8699,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;
@@ -8533,9 +8724,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") {
@@ -8559,19 +8750,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;
@@ -8601,7 +8792,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}`);
@@ -8617,19 +8808,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;
@@ -8655,7 +8846,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))}`);
     }
   });
 }
@@ -8663,11 +8854,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";
@@ -8675,8 +8866,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;
@@ -8700,7 +8891,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}`);
@@ -8767,15 +8958,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;
@@ -8815,13 +9006,13 @@ 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) {
@@ -8886,9 +9077,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;
@@ -8909,10 +9100,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 = [];
@@ -8934,7 +9125,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, "-")}`;
@@ -8949,11 +9140,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"
       );
@@ -8978,15 +9169,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",
@@ -8999,8 +9190,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;
@@ -9073,7 +9264,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 {
@@ -9083,20 +9274,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;
@@ -9176,8 +9367,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.`);
@@ -9210,14 +9401,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(() => {
       });
     };
@@ -9231,6 +9422,7 @@ function registerSessionEnd(session2) {
         const revisionCount = (fm.revision_count ?? 0) + 1;
         const newFrontmatter = {
           ...fm,
+          verified_at: (/* @__PURE__ */ new Date()).toISOString(),
           revision_count: revisionCount,
           anchor: {
             ...fm.anchor,
@@ -9241,7 +9433,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;
@@ -9258,12 +9450,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`.");
     }
@@ -9277,13 +9469,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) {
@@ -9308,15 +9500,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;
@@ -9372,7 +9564,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 {
@@ -9427,8 +9619,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";
@@ -9442,15 +9634,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";
@@ -9462,21 +9654,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.
@@ -9498,12 +9690,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"
     });
@@ -9513,7 +9705,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.)
 `
@@ -9532,8 +9724,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(
@@ -9542,15 +9734,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)
@@ -9568,7 +9760,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++;
     }
@@ -9576,10 +9768,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"
       });
@@ -9601,8 +9793,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(
@@ -9611,13 +9803,13 @@ 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 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) {
@@ -9627,16 +9819,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 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) {
@@ -9660,21 +9852,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: 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 readdir6(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 {
@@ -9698,16 +9890,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) {
@@ -9716,8 +9908,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;
@@ -9771,7 +9963,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 };
@@ -9806,7 +9998,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,
@@ -9870,13 +10062,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 = [
@@ -9997,9 +10189,9 @@ function summarize(name, t0, payload, notes) {
 // src/commands/benchmark.ts
 import { existsSync as existsSync57 } from "fs";
 import { readdir as readdir5, readFile as readFile16, writeFile as writeFile28 } from "fs/promises";
-import path37 from "path";
+import path38 from "path";
 import "commander";
-import { estimateTokens as estimateTokens4, findProjectRoot as findProjectRoot36 } from "@hiveai/core";
+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) => {
@@ -10012,9 +10204,9 @@ function registerBenchmark(program2) {
     }
     const markdown = renderMarkdown(root, summary, rows);
     if (opts.out) {
-      const outFile = path37.isAbsolute(opts.out) ? opts.out : path37.join(root, opts.out);
+      const outFile = path38.isAbsolute(opts.out) ? opts.out : path38.join(root, opts.out);
       await writeFile28(outFile, markdown, "utf8");
-      ui.success(`wrote ${path37.relative(process.cwd(), outFile)}`);
+      ui.success(`wrote ${path38.relative(process.cwd(), outFile)}`);
       return;
     }
     console.log(markdown);
@@ -10038,9 +10230,9 @@ function registerBenchmark(program2) {
 }
 function resolveBenchmarkRoot(dir) {
   const candidate = dir ?? "benchmarks/agent-benchmark";
-  if (path37.isAbsolute(candidate)) return candidate;
-  const projectRoot = findProjectRoot36(process.cwd());
-  return path37.join(projectRoot, candidate);
+  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}`);
@@ -10048,8 +10240,8 @@ async function collectRows(root) {
   const rows = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const fixtureDir = path37.join(root, entry.name);
-    const reportFile = path37.join(fixtureDir, "BENCHMARK_AGENT_REPORT.md");
+    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));
@@ -10140,19 +10332,19 @@ function escapeRegExp(value) {
 }
 
 // src/commands/memory-suggest.ts
-import { mkdir as mkdir17, writeFile as writeFile29 } from "fs/promises";
+import { mkdir as mkdir18, writeFile as writeFile29 } from "fs/promises";
 import { existsSync as existsSync58 } from "fs";
-import path38 from "path";
+import path39 from "path";
 import "commander";
 import {
   aggregateUsage as aggregateUsage2,
   buildFrontmatter as buildFrontmatter11,
-  findProjectRoot as findProjectRoot37,
+  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([
@@ -10165,8 +10357,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 = findProjectRoot37(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) {
@@ -10235,13 +10427,13 @@ function registerMemorySuggest(memory2) {
         fm.status = "draft";
         const body = renderTemplate(s);
         const file = memoryFilePath10(paths, fm.scope, fm.id, fm.module);
-        await mkdir17(path38.dirname(file), { recursive: true });
+        await mkdir18(path39.dirname(file), { recursive: true });
         if (existsSync58(file)) {
-          skipped.push({ query: s.query, reason: `file already exists at ${path38.relative(root, file)}` });
+          skipped.push({ query: s.query, reason: `file already exists at ${path39.relative(root, file)}` });
           continue;
         }
         await writeFile29(file, serializeMemory24({ frontmatter: fm, body }), "utf8");
-        created.push({ id: fm.id, file: path38.relative(root, file), query: s.query });
+        created.push({ id: fm.id, file: path39.relative(root, file), query: s.query });
       }
       if (opts.json) {
         console.log(JSON.stringify({ created, skipped }, null, 2));
@@ -10336,14 +10528,14 @@ function truncate2(text, max) {
 // src/commands/memory-archive.ts
 import { existsSync as existsSync59 } from "fs";
 import { writeFile as writeFile30 } from "fs/promises";
-import path39 from "path";
+import path40 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot38,
+  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;
@@ -10351,8 +10543,8 @@ 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 = findProjectRoot38(opts.dir);
-    const paths = resolveHaivePaths34(root);
+    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;
@@ -10374,7 +10566,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) => !existsSync59(path39.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);
@@ -10450,27 +10642,27 @@ function parseDays(input) {
 // src/commands/doctor.ts
 import { existsSync as existsSync60 } from "fs";
 import { stat } from "fs/promises";
-import path40 from "path";
+import path41 from "path";
 import { execSync as execSync3 } from "child_process";
 import "commander";
 import {
   codeMapPath as codeMapPath2,
-  findProjectRoot as findProjectRoot39,
+  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 = findProjectRoot39(opts.dir);
-    const paths = resolveHaivePaths35(root);
+    const root = findProjectRoot40(opts.dir);
+    const paths = resolveHaivePaths36(root);
     const findings = [];
     if (!existsSync60(paths.haiveDir)) {
       findings.push({
@@ -10612,7 +10804,7 @@ function registerDoctor(program2) {
     }
     const config = await loadConfig7(paths);
     if (config.enforcement?.requireBriefingFirst) {
-      const claudeSettings = path40.join(root, ".claude", "settings.local.json");
+      const claudeSettings = path41.join(root, ".claude", "settings.local.json");
       let hasClaudeEnforcement = false;
       if (existsSync60(claudeSettings)) {
         try {
@@ -10646,7 +10838,7 @@ function registerDoctor(program2) {
         timeout: 3e3,
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      const cliVersion = "0.9.11";
+      const cliVersion = "0.9.13";
       if (legacyRaw && legacyRaw !== cliVersion) {
         findings.push({
           severity: "warn",
@@ -10698,19 +10890,19 @@ function isSearchTool(name) {
 import { existsSync as existsSync61 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot40,
+  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 = findProjectRoot40(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) {
@@ -10815,8 +11007,8 @@ function truncate3(text, max) {
 import { spawn as spawn4 } from "child_process";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot41,
-  resolveHaivePaths as resolveHaivePaths37
+  findProjectRoot as findProjectRoot42,
+  resolveHaivePaths as resolveHaivePaths38
 } from "@hiveai/core";
 function registerPrecommit(program2) {
   program2.command("precommit").description(
@@ -10826,8 +11018,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 = findProjectRoot41(opts.dir);
-    const paths = resolveHaivePaths37(root);
+    const root = findProjectRoot42(opts.dir);
+    const paths = resolveHaivePaths38(root);
     const ctx = { paths };
     let diff = "";
     let touchedPaths = opts.paths ?? [];
@@ -10858,7 +11050,7 @@ function registerPrecommit(program2) {
     console.log(ui.bold(`hAIve precommit \u2014 ${touchedPaths.length} file(s)`));
     console.log(
       ui.dim(
-        `  anti-patterns: ${result.summary.anti_patterns}  relevant memories: ${result.summary.relevant_memories}  stale anchors: ${result.summary.stale_anchors}`
+        `  anti-patterns: ${result.summary.anti_patterns}  blocking: ${result.summary.blocking_warnings ?? result.summary.anti_patterns}  relevant memories: ${result.summary.relevant_memories}  stale anchors: ${result.summary.stale_anchors}`
       )
     );
     console.log();
@@ -10922,9 +11114,9 @@ function runCommand3(cmd, args, cwd) {
 import { existsSync as existsSync63 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot42,
+  findProjectRoot as findProjectRoot43,
   loadMemoriesFromDir as loadMemoriesFromDir34,
-  resolveHaivePaths as resolveHaivePaths38
+  resolveHaivePaths as resolveHaivePaths39
 } from "@hiveai/core";
 var TYPE_RANK = {
   decision: 0,
@@ -10938,8 +11130,8 @@ 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 = findProjectRoot42(opts.dir);
-    const paths = resolveHaivePaths38(root);
+    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;
@@ -10984,12 +11176,12 @@ function registerWelcome(program2) {
 import { existsSync as existsSync64 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot43,
+  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 (!existsSync64(paths.memoriesDir)) return out;
   const loaded = await loadMemoriesFromDir35(paths.memoriesDir);
@@ -11052,7 +11244,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 = findProjectRoot43(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));
@@ -11098,27 +11290,27 @@ function registerMemorySuggestTopic(memory2) {
 }
 
 // src/commands/resolve-project.ts
-import path41 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: path41.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 existsSync65 } from "fs";
-import path43 from "path";
+import path44 from "path";
 import "commander";
 import {
   appendRuntimeJournalEntry as appendRuntimeJournalEntry3,
-  findProjectRoot as findProjectRoot44,
+  findProjectRoot as findProjectRoot45,
   readRuntimeJournalTail as readRuntimeJournalTail2,
-  resolveHaivePaths as resolveHaivePaths40
+  resolveHaivePaths as resolveHaivePaths41
 } from "@hiveai/core";
 function registerRuntime(program2) {
   const runtime = program2.command("runtime").description(
@@ -11126,16 +11318,16 @@ 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 = path43.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths40(findProjectRoot44(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 ${path43.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 = path43.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths40(findProjectRoot44(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 (!existsSync65(paths.haiveDir)) {
       ui.error("No .ai/ \u2014 run `haive init` first.");
@@ -11153,12 +11345,12 @@ function registerRuntime(program2) {
 
 // src/commands/memory-timeline.ts
 import { existsSync as existsSync66 } from "fs";
-import path44 from "path";
+import path45 from "path";
 import "commander";
 import {
   collectTimelineEntries as collectTimelineEntries2,
-  findProjectRoot as findProjectRoot45,
-  resolveHaivePaths as resolveHaivePaths41
+  findProjectRoot as findProjectRoot46,
+  resolveHaivePaths as resolveHaivePaths42
 } from "@hiveai/core";
 function registerMemoryTimeline(memory2) {
   memory2.command("timeline").description(
@@ -11169,8 +11361,8 @@ function registerMemoryTimeline(memory2) {
       process.exitCode = 1;
       return;
     }
-    const root = path44.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths41(findProjectRoot45(root));
+    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;
@@ -11190,13 +11382,13 @@ function registerMemoryTimeline(memory2) {
 
 // src/commands/memory-conflict-candidates.ts
 import { existsSync as existsSync67 } from "fs";
-import path45 from "path";
+import path46 from "path";
 import "commander";
 import {
   findLexicalConflictPairs as findLexicalConflictPairs2,
   findTopicStatusConflictPairs as findTopicStatusConflictPairs2,
-  findProjectRoot as findProjectRoot46,
-  resolveHaivePaths as resolveHaivePaths42
+  findProjectRoot as findProjectRoot47,
+  resolveHaivePaths as resolveHaivePaths43
 } from "@hiveai/core";
 function parseTypes(csv) {
   const allowed = ["decision", "architecture", "convention", "gotcha"];
@@ -11212,8 +11404,8 @@ 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 = path45.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths42(findProjectRoot46(root));
+    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;
@@ -11251,11 +11443,11 @@ function registerMemoryConflictCandidates(memory2) {
 // src/commands/enforce.ts
 import { spawn as spawn5 } from "child_process";
 import { existsSync as existsSync68 } from "fs";
-import { chmod as chmod2, mkdir as mkdir18, readFile as readFile17, rm as rm3, writeFile as writeFile31 } from "fs/promises";
-import path46 from "path";
+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 findProjectRoot47,
+  findProjectRoot as findProjectRoot48,
   hasRecentBriefingMarker,
   isFreshIsoDate,
   loadConfig as loadConfig8,
@@ -11263,7 +11455,7 @@ import {
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths6,
   readRecentBriefingMarker,
   resolveBriefingBudget as resolveBriefingBudget3,
-  resolveHaivePaths as resolveHaivePaths43,
+  resolveHaivePaths as resolveHaivePaths44,
   saveConfig as saveConfig3,
   SESSION_RECAP_TTL_MS,
   verifyAnchor as verifyAnchor4,
@@ -11276,9 +11468,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 = findProjectRoot47(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,
@@ -11302,7 +11494,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 (${path46.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)}`);
       }
@@ -11321,15 +11513,15 @@ function registerEnforce(program2) {
     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 = findProjectRoot47(opts.dir);
-    const paths = resolveHaivePaths43(root);
+    const root = findProjectRoot48(opts.dir);
+    const paths = resolveHaivePaths44(root);
     const targets = [
-      path46.join(paths.haiveDir, ".cache"),
-      path46.join(paths.haiveDir, ".runtime")
+      path47.join(paths.haiveDir, ".cache"),
+      path47.join(paths.haiveDir, ".runtime")
     ];
     for (const target of targets) {
       if (!existsSync68(target)) continue;
-      const rel = path46.relative(root, target);
+      const rel = path47.relative(root, target);
       if (opts.dryRun) ui.info(`would remove ${rel}`);
       else {
         await rm3(target, { recursive: true, force: true });
@@ -11346,9 +11538,9 @@ function registerEnforce(program2) {
     const payload = await readHookPayload();
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
-    const paths = resolveHaivePaths43(root);
+    const paths = resolveHaivePaths44(root);
     if (!existsSync68(paths.haiveDir)) return;
-    await mkdir18(paths.runtimeDir, { recursive: true });
+    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.";
     const budget = resolveBriefingBudget3("quick", {
@@ -11408,7 +11600,7 @@ ${briefing.project_context.content.slice(0, 1800)}`);
     const payload = await readHookPayload();
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
-    const paths = resolveHaivePaths43(root);
+    const paths = resolveHaivePaths44(root);
     if (!existsSync68(paths.haiveDir)) return;
     if (!isWriteLikeTool(payload)) return;
     const ok = await hasRecentBriefingMarker(paths, payload.session_id);
@@ -11431,8 +11623,8 @@ ${briefing.project_context.content.slice(0, 1800)}`);
   });
 }
 async function runWithEnforcement(command, args, opts) {
-  const root = findProjectRoot47(opts.dir);
-  const paths = resolveHaivePaths43(root);
+  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);
@@ -11452,7 +11644,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 ${path46.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",
@@ -11501,9 +11693,9 @@ async function writeWrapperBriefing(paths, sessionId, task) {
     source: "haive-run",
     memoryIds: briefing.memories.map((m) => m.id)
   });
-  const dir = path46.join(paths.runtimeDir, "enforcement", "briefings");
-  await mkdir18(dir, { recursive: true });
-  const file = path46.join(dir, `${sessionId}.md`);
+  const dir = path47.join(paths.runtimeDir, "enforcement", "briefings");
+  await mkdir19(dir, { recursive: true });
+  const file = path47.join(dir, `${sessionId}.md`);
   const parts = [
     "# hAIve Briefing",
     "",
@@ -11525,8 +11717,8 @@ async function writeWrapperBriefing(paths, sessionId, task) {
   return file;
 }
 async function buildEnforcementReport(dir, stage, sessionId) {
-  const root = findProjectRoot47(dir);
-  const paths = resolveHaivePaths43(root);
+  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";
@@ -11618,9 +11810,11 @@ async function buildEnforcementReport(dir, stage, sessionId) {
 async function hasRecentSessionRecap(paths) {
   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)
-  );
+  return all.some(({ memory: memory2 }) => {
+    const fm = memory2.frontmatter;
+    const freshnessDate = fm.verified_at ?? fm.created_at;
+    return fm.type === "session_recap" && fm.status !== "rejected" && isFreshIsoDate(freshnessDate, SESSION_RECAP_TTL_MS);
+  });
 }
 async function verifyMemoryPolicy(paths, config) {
   if (!existsSync68(paths.memoriesDir)) return [];
@@ -11722,7 +11916,7 @@ async function runPrecommitPolicy(paths) {
   return [{
     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).`,
+    message: `Pre-commit policy matched ${result.summary.blocking_warnings ?? result.summary.anti_patterns} blocking anti-pattern(s), ${result.summary.stale_anchors} stale anchor(s).`,
     fix: "Review the hAIve warnings, then update the code or the relevant memories.",
     impact: 45
   }];
@@ -11777,12 +11971,12 @@ function buildScore(findings, threshold = 80) {
   };
 }
 async function installGitEnforcement(root) {
-  const hooksDir = path46.join(root, ".git", "hooks");
-  if (!existsSync68(path46.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",
@@ -11800,7 +11994,7 @@ haive enforce check --stage pre-push --dir . || exit $?
     }
   ];
   for (const hook of hooks) {
-    const file = path46.join(hooksDir, hook.name);
+    const file = path47.join(hooksDir, hook.name);
     if (existsSync68(file)) {
       const current = await readFile17(file, "utf8").catch(() => "");
       if (current.includes(ENFORCE_HOOK_MARKER)) {
@@ -11818,8 +12012,8 @@ ${hook.body}`, "utf8");
   ui.success("Installed blocking git enforcement hooks: pre-commit, pre-push");
 }
 async function installCiEnforcement(root) {
-  const workflowPath = path46.join(root, ".github", "workflows", "haive-enforcement.yml");
-  await mkdir18(path46.dirname(workflowPath), { recursive: true });
+  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;
@@ -11848,7 +12042,7 @@ jobs:
       - name: Enforce hAIve policy
         run: haive enforce ci
 `, "utf8");
-  ui.success(`Created ${path46.relative(root, workflowPath)}`);
+  ui.success(`Created ${path47.relative(root, workflowPath)}`);
 }
 function printReport(report, json) {
   if (json) {
@@ -11877,7 +12071,7 @@ async function readHookPayload() {
 }
 function resolveRoot(dir, payload) {
   try {
-    return findProjectRoot47(dir ?? payload.cwd);
+    return findProjectRoot48(dir ?? payload.cwd);
   } catch {
     return null;
   }
@@ -11946,14 +12140,15 @@ function registerRun(program2) {
 }
 
 // src/index.ts
-var program = new Command50();
-program.name("haive").description("hAIve \u2014 policy enforcement layer for AI coding agents").version("0.9.11");
+var program = new Command51();
+program.name("haive").description("hAIve \u2014 policy enforcement layer for AI coding agents").version("0.9.13");
 registerInit(program);
 registerWelcome(program);
 registerResolveProject(program);
 registerRuntime(program);
 registerEnforce(program);
 registerRun(program);
+registerAgent(program);
 registerMcp(program);
 registerBriefing(program);
 registerTui(program);