@hiveai/cli 0.9.28 → 0.9.30

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command51 } from "commander";
+import { Command as Command52 } from "commander";
 
 // src/commands/briefing.ts
 import { existsSync as existsSync3 } from "fs";
@@ -199,7 +199,7 @@ async function getHotFiles(root, daysBack, maxHotFiles, filePaths) {
       if (!f) continue;
       counts.set(f, (counts.get(f) ?? 0) + 1);
     }
-    let entries = [...counts.entries()].map(([path50, changes]) => ({ path: path50, changes }));
+    let entries = [...counts.entries()].map(([path51, changes]) => ({ path: path51, changes }));
     const lowerPaths = filePaths.map((p) => p.toLowerCase());
     if (lowerPaths.length > 0) {
       entries = entries.filter((e) => lowerPaths.some((p) => e.path.toLowerCase().includes(p)));
@@ -1213,12 +1213,14 @@ async function loadEmbeddings() {
 }
 
 // src/commands/index-code.ts
+import { existsSync as existsSync5, statSync } from "fs";
 import path5 from "path";
 import "commander";
 import {
   buildCodeMap as buildCodeMap2,
   codeMapPath,
   findProjectRoot as findProjectRoot5,
+  loadCodeMap as loadCodeMap4,
   resolveHaivePaths as resolveHaivePaths4,
   saveCodeMap as saveCodeMap2
 } from "@hiveai/core";
@@ -1228,14 +1230,18 @@ function registerIndexCode(program2) {
   );
   idx.action(() => idx.help());
   idx.command("code").description(
-    "Scan source files and write .ai/code-map.json (file \u2192 exports + 1-line description).\n\n  Supported languages: TypeScript, JavaScript, Java, Python, Go, Rust, C#, PHP.\n  The map is used by:\n    \u2022 get_briefing (symbol_locations) \u2014 look up where a class/function lives\n    \u2022 code_map MCP tool \u2014 browse exports without grepping\n    \u2022 haive briefing --symbols \u2014 look up symbols from the CLI\n\n  Run automatically by haive init (autopilot mode) and haive sync (if source changed).\n\n  Example:\n    haive index code\n    haive index code --exclude generated,proto\n"
+    "Scan source files and write .ai/code-map.json (file \u2192 exports + 1-line description).\n\n  Supported languages: TypeScript, JavaScript, Java, Python, Go, Rust, C#, PHP.\n  The map is used by:\n    \u2022 get_briefing (symbol_locations) \u2014 look up where a class/function lives\n    \u2022 code_map MCP tool \u2014 browse exports without grepping\n    \u2022 haive briefing --symbols \u2014 look up symbols from the CLI\n\n  Run automatically by haive init (autopilot mode) and haive sync (if source changed).\n\n  Example:\n    haive index code\n    haive index code --status        # report freshness without rebuilding\n    haive index code --exclude generated,proto\n"
   ).option("-d, --dir <dir>", "project root").option(
     "--exclude <csv>",
     "extra directory names to skip (comma-separated)",
     ""
-  ).action(async (opts) => {
+  ).option("--status", "report code-map / code-search index freshness without rebuilding").option("--json", "with --status, emit machine-readable JSON (for CI / agents)").action(async (opts) => {
     const root = findProjectRoot5(opts.dir);
     const paths = resolveHaivePaths4(root);
+    if (opts.status) {
+      await reportIndexStatus(root, paths, opts.json === true);
+      return;
+    }
     const extraExcludes = (opts.exclude ?? "").split(",").map((s) => s.trim()).filter(Boolean);
     ui.info(`Indexing source files in ${root}\u2026`);
     const map = await buildCodeMap2(root, {
@@ -1288,10 +1294,49 @@ function registerIndexCode(program2) {
     }
   });
 }
+async function reportIndexStatus(root, paths, asJson) {
+  const mapFile = codeMapPath(paths);
+  const map = existsSync5(mapFile) ? await loadCodeMap4(paths) : null;
+  const fileCount = map ? Object.keys(map.files).length : 0;
+  const exportCount = map ? Object.values(map.files).reduce((s, f) => s + f.exports.length, 0) : 0;
+  const mapMtime = existsSync5(mapFile) ? statSync(mapFile).mtime.toISOString() : null;
+  const searchIndexFile = path5.join(paths.haiveDir, ".cache", "embeddings", "code-embeddings-index.json");
+  const searchIndexPresent = existsSync5(searchIndexFile);
+  const status = {
+    code_map: {
+      present: map !== null,
+      path: path5.relative(root, mapFile),
+      files: fileCount,
+      exports: exportCount,
+      generated_at: map?.generated_at ?? null,
+      file_mtime: mapMtime
+    },
+    code_search_index: {
+      present: searchIndexPresent,
+      path: path5.relative(root, searchIndexFile)
+    }
+  };
+  if (asJson) {
+    console.log(JSON.stringify(status, null, 2));
+    if (!status.code_map.present) process.exitCode = 1;
+    return;
+  }
+  if (!status.code_map.present) {
+    ui.warn(`No code-map at ${status.code_map.path}. Run \`haive index code\`.`);
+    process.exitCode = 1;
+    return;
+  }
+  ui.info(
+    `code-map: ${fileCount} file(s), ${exportCount} export(s) \xB7 generated ${status.code_map.generated_at ?? "?"}`
+  );
+  ui.info(
+    status.code_search_index.present ? `code-search index: present (${status.code_search_index.path})` : `code-search index: missing \u2014 run \`haive index code-search\` for semantic code lookup.`
+  );
+}
 
 // src/commands/init.ts
 import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile6 } from "fs/promises";
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import path10 from "path";
 import { spawnSync as spawnSync3 } from "child_process";
 import "commander";
@@ -1305,7 +1350,7 @@ import {
 
 // src/commands/agent.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { mkdir as mkdir3, writeFile as writeFile4 } from "fs/promises";
 import os2 from "os";
 import path7 from "path";
@@ -1315,7 +1360,7 @@ import { findProjectRoot as findProjectRoot6, resolveHaivePaths as resolveHaiveP
 
 // src/commands/init-mcp-setup.ts
 import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import path6 from "path";
 import os from "os";
 var HOME = os.homedir();
@@ -1336,9 +1381,9 @@ function cursorMcpPath() {
 async function configureCursor() {
   const mcpPath = cursorMcpPath();
   const cursorDir = path6.join(HOME, ".cursor");
-  if (!existsSync5(cursorDir)) return { client: "Cursor", status: "not_installed" };
+  if (!existsSync6(cursorDir)) return { client: "Cursor", status: "not_installed" };
   let config = {};
-  if (existsSync5(mcpPath)) {
+  if (existsSync6(mcpPath)) {
     try {
       config = JSON.parse(await readFile3(mcpPath, "utf8"));
     } catch {
@@ -1362,7 +1407,7 @@ function vscodeMcpPath() {
     path6.join(HOME, ".config", "Code - Insiders", "User", "mcp.json")
   ];
   for (const c of candidates) {
-    if (existsSync5(path6.dirname(c))) return c;
+    if (existsSync6(path6.dirname(c))) return c;
   }
   return null;
 }
@@ -1370,7 +1415,7 @@ async function configureVSCode() {
   const mcpPath = vscodeMcpPath();
   if (!mcpPath) return { client: "VS Code", status: "not_installed" };
   let config = {};
-  if (existsSync5(mcpPath)) {
+  if (existsSync6(mcpPath)) {
     try {
       config = JSON.parse(await readFile3(mcpPath, "utf8"));
     } catch {
@@ -1385,18 +1430,18 @@ async function configureVSCode() {
 }
 function claudeConfigPath() {
   const p = path6.join(HOME, ".claude.json");
-  if (existsSync5(p)) return p;
+  if (existsSync6(p)) return p;
   const p2 = path6.join(HOME, ".config", "claude", "claude.json");
-  if (existsSync5(path6.dirname(p2))) return p2;
+  if (existsSync6(path6.dirname(p2))) return p2;
   return null;
 }
 async function configureClaude() {
   const cfgPath = claudeConfigPath() ?? path6.join(HOME, ".claude.json");
-  if (!existsSync5(cfgPath) && !existsSync5(path6.join(HOME, ".claude"))) {
+  if (!existsSync6(cfgPath) && !existsSync6(path6.join(HOME, ".claude"))) {
     return { client: "Claude Code", status: "not_installed" };
   }
   let config = {};
-  if (existsSync5(cfgPath)) {
+  if (existsSync6(cfgPath)) {
     try {
       config = JSON.parse(await readFile3(cfgPath, "utf8"));
     } catch {
@@ -1414,7 +1459,7 @@ function windsurfMcpPath() {
     path6.join(HOME, ".windsurf", "mcp.json")
   ];
   for (const c of candidates) {
-    if (existsSync5(path6.dirname(c))) return c;
+    if (existsSync6(path6.dirname(c))) return c;
   }
   return null;
 }
@@ -1422,7 +1467,7 @@ async function configureWindsurf() {
   const mcpPath = windsurfMcpPath();
   if (!mcpPath) return { client: "Windsurf", status: "not_installed" };
   let config = {};
-  if (existsSync5(mcpPath)) {
+  if (existsSync6(mcpPath)) {
     try {
       config = JSON.parse(await readFile3(mcpPath, "utf8"));
     } catch {
@@ -1454,7 +1499,7 @@ async function configureProjectMcpClients(root) {
   try {
     const cursorPath = path6.join(root, ".cursor", "mcp.json");
     let config = {};
-    if (existsSync5(cursorPath)) {
+    if (existsSync6(cursorPath)) {
       try {
         config = JSON.parse(await readFile3(cursorPath, "utf8"));
       } catch {
@@ -1471,7 +1516,7 @@ async function configureProjectMcpClients(root) {
   try {
     const vscodePath = path6.join(root, ".vscode", "mcp.json");
     let config = {};
-    if (existsSync5(vscodePath)) {
+    if (existsSync6(vscodePath)) {
       try {
         config = JSON.parse(await readFile3(vscodePath, "utf8"));
       } catch {
@@ -1488,7 +1533,7 @@ async function configureProjectMcpClients(root) {
   try {
     const mcpPath = path6.join(root, ".mcp.json");
     let config = {};
-    if (existsSync5(mcpPath)) {
+    if (existsSync6(mcpPath)) {
       try {
         config = JSON.parse(await readFile3(mcpPath, "utf8"));
       } catch {
@@ -1562,9 +1607,9 @@ async function detectAgentMode(dir) {
   const root = findProjectRoot6(dir);
   const paths = resolveHaivePaths5(root);
   const projectMcp = [
-    { client: "Claude Code", path: path7.join(root, ".mcp.json"), present: existsSync6(path7.join(root, ".mcp.json")) },
-    { client: "Cursor", path: path7.join(root, ".cursor", "mcp.json"), present: existsSync6(path7.join(root, ".cursor", "mcp.json")) },
-    { client: "VS Code", path: path7.join(root, ".vscode", "mcp.json"), present: existsSync6(path7.join(root, ".vscode", "mcp.json")) }
+    { client: "Claude Code", path: path7.join(root, ".mcp.json"), present: existsSync7(path7.join(root, ".mcp.json")) },
+    { client: "Cursor", path: path7.join(root, ".cursor", "mcp.json"), present: existsSync7(path7.join(root, ".cursor", "mcp.json")) },
+    { client: "VS Code", path: path7.join(root, ".vscode", "mcp.json"), present: existsSync7(path7.join(root, ".vscode", "mcp.json")) }
   ];
   const installedAgents = [
     { agent: "Codex", command: "codex", installed: commandExists("codex"), mcp_configured: codexMcpConfigured() },
@@ -1579,7 +1624,7 @@ async function detectAgentMode(dir) {
   const recommendedCommand = recommendedMode === "mcp" ? "Restart your AI client, then call get_briefing before editing." : recommendedMode === "wrapped" && wrapperAgent ? `haive run -- ${wrapperAgent.command}` : 'haive briefing --task "..." --files "..."';
   return {
     root,
-    initialized: existsSync6(paths.haiveDir),
+    initialized: existsSync7(paths.haiveDir),
     project_mcp: projectMcp,
     installed_agents: installedAgents,
     recommended_mode: recommendedMode,
@@ -1686,7 +1731,7 @@ function printSetupResult(result) {
 
 // src/commands/init-bootstrap.ts
 import { readdir, readFile as readFile4 } from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8, readdirSync } from "fs";
 import path8 from "path";
 var IGNORE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
@@ -1773,14 +1818,38 @@ function detectKeyDeps(allDeps) {
   return KEY_DEPS.filter((d) => allDeps[d] !== void 0);
 }
 function detectLanguage(root) {
-  if (existsSync7(path8.join(root, "tsconfig.json"))) return "TypeScript";
-  if (existsSync7(path8.join(root, "pyproject.toml")) || existsSync7(path8.join(root, "setup.py"))) return "Python";
-  if (existsSync7(path8.join(root, "go.mod"))) return "Go";
-  if (existsSync7(path8.join(root, "pom.xml")) || existsSync7(path8.join(root, "build.gradle"))) return "Java/Kotlin";
-  if (existsSync7(path8.join(root, "Cargo.toml"))) return "Rust";
-  if (existsSync7(path8.join(root, "package.json"))) return "JavaScript";
+  if (existsSync8(path8.join(root, "tsconfig.json"))) return "TypeScript";
+  if (existsSync8(path8.join(root, "pyproject.toml")) || existsSync8(path8.join(root, "setup.py"))) return "Python";
+  if (existsSync8(path8.join(root, "go.mod"))) return "Go";
+  if (existsSync8(path8.join(root, "pom.xml")) || existsSync8(path8.join(root, "build.gradle"))) return "Java/Kotlin";
+  if (existsSync8(path8.join(root, "Cargo.toml"))) return "Rust";
+  if (existsSync8(path8.join(root, "package.json"))) {
+    return hasSourceWithExt(root, [".ts", ".tsx", ".mts", ".cts"]) ? "TypeScript" : "JavaScript";
+  }
   return "Unknown";
 }
+function hasSourceWithExt(root, exts) {
+  const matches = (name) => !name.endsWith(".d.ts") && exts.some((ext) => name.endsWith(ext));
+  const scanDir = (dir, depth) => {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return false;
+    }
+    for (const entry of entries) {
+      if (entry.isFile() && matches(entry.name)) return true;
+    }
+    if (depth <= 0) return false;
+    for (const entry of entries) {
+      if (entry.isDirectory() && !IGNORE_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
+        if (scanDir(path8.join(dir, entry.name), depth - 1)) return true;
+      }
+    }
+    return false;
+  };
+  return scanDir(root, 2);
+}
 function detectProjectType(frameworks, scripts, isMonorepo) {
   if (isMonorepo) {
     if (frameworks.includes("NestJS")) return "Monorepo (NestJS backend)";
@@ -1795,7 +1864,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 (existsSync7("pom.xml")) return "Java backend";
+  if (existsSync8("pom.xml")) return "Java backend";
   return "Application";
 }
 async function scanDirs(root, maxDepth = 2) {
@@ -1931,7 +2000,7 @@ function readmeExcerpt(readme) {
 async function generateBootstrapContext(root) {
   let pkg = {};
   const pkgPath = path8.join(root, "package.json");
-  if (existsSync7(pkgPath)) {
+  if (existsSync8(pkgPath)) {
     try {
       pkg = JSON.parse(await readFile4(pkgPath, "utf8"));
     } catch {
@@ -1948,7 +2017,7 @@ async function generateBootstrapContext(root) {
   let readmeSummary = "";
   for (const name of ["README.md", "readme.md", "README"]) {
     const p = path8.join(root, name);
-    if (existsSync7(p)) {
+    if (existsSync8(p)) {
       try {
         const content = await readFile4(p, "utf8");
         readmeSummary = readmeExcerpt(content);
@@ -2015,7 +2084,7 @@ async function generateBootstrapContext(root) {
 
 // src/commands/init-stack-packs.ts
 import { mkdir as mkdir4, writeFile as writeFile5 } from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import path9 from "path";
 import {
   buildFrontmatter,
@@ -2643,7 +2712,7 @@ async function seedStackPack(haivePaths, stack) {
       tags: [...mem.tags, STACK_PACK_TAG]
     });
     const filePath = memoryFilePath(haivePaths, "team", fm.id);
-    if (existsSync8(filePath)) continue;
+    if (existsSync9(filePath)) continue;
     const content = serializeMemory2({ frontmatter: fm, body: `${mem.body}
 
 ${SEED_FOOTER(stack)}` });
@@ -2867,7 +2936,7 @@ function registerInit(program2) {
     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 (existsSync9(paths.haiveDir)) {
+    if (existsSync10(paths.haiveDir)) {
       ui.warn(`.ai/ already exists at ${paths.haiveDir} \u2014 leaving existing files in place.`);
     }
     await mkdir5(paths.personalDir, { recursive: true });
@@ -2876,7 +2945,7 @@ function registerInit(program2) {
     await mkdir5(paths.modulesContextDir, { recursive: true });
     await ensureAiRuntimeLayout(paths.runtimeDir);
     await ensureAiCacheLayout(path10.join(paths.haiveDir, ".cache"));
-    if (!existsSync9(paths.projectContext)) {
+    if (!existsSync10(paths.projectContext)) {
       if (wantBootstrap) {
         ui.info("Bootstrapping project context from local files\u2026");
         try {
@@ -2892,7 +2961,7 @@ function registerInit(program2) {
         ui.success(`Created ${path10.relative(root, paths.projectContext)}`);
       }
     }
-    const configExists = existsSync9(
+    const configExists = existsSync10(
       path10.join(paths.haiveDir, "haive.config.json")
     );
     if (!configExists) {
@@ -2931,7 +3000,7 @@ function registerInit(program2) {
     const wantCi = opts.withCi || autopilot;
     if (wantCi) {
       const ciPath = path10.join(root, ".github", "workflows", "haive-sync.yml");
-      if (existsSync9(ciPath)) {
+      if (existsSync10(ciPath)) {
         ui.info("CI workflow already exists \u2014 skipped");
       } else {
         await mkdir5(path10.dirname(ciPath), { recursive: true });
@@ -2980,8 +3049,8 @@ function registerInit(program2) {
         else if (r.status === "error") ui.warn(`${r.client}: ${r.error}`);
       }
       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 (r.status === "configured") ui.success(`haive MCP configured in ${r.client} user-level config${r.path ? ` (${r.path})` : ""}`);
+        else if (r.status === "already_configured") ui.info(`haive MCP already present in ${r.client} user-level config \u2014 left unchanged (this project's config was written above)`);
       }
       if (agentSetup.global_skipped_reason) ui.warn(agentSetup.global_skipped_reason);
       ui.info(`Recommended agent mode: ${agentSetup.detection.recommended_mode}`);
@@ -3048,7 +3117,7 @@ async function resolveStacksToSeed(root, stackOpt) {
   if (!stackOpt) return [];
   if (stackOpt === "auto") {
     const pkgPath = path10.join(root, "package.json");
-    if (!existsSync9(pkgPath)) return [];
+    if (!existsSync10(pkgPath)) return [];
     try {
       const pkg = JSON.parse(await readFile5(pkgPath, "utf8"));
       const allDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
@@ -3062,7 +3131,7 @@ async function resolveStacksToSeed(root, stackOpt) {
 async function writeCursorHaiveRule(root) {
   const relPath = ".cursor/rules/haive-mcp-required.mdc";
   const target = path10.join(root, relPath);
-  if (existsSync9(target)) {
+  if (existsSync10(target)) {
     ui.info(`Cursor rule ${relPath} already exists \u2014 skipped`);
     return;
   }
@@ -3072,7 +3141,7 @@ async function writeCursorHaiveRule(root) {
 }
 async function writeBridge(root, relPath) {
   const target = path10.join(root, relPath);
-  if (existsSync9(target)) {
+  if (existsSync10(target)) {
     ui.info(`Bridge ${relPath} already exists \u2014 skipped`);
     return;
   }
@@ -3095,18 +3164,18 @@ var RUNTIME_GITIGNORE_BODY = `*
 async function ensureAiRuntimeLayout(runtimeDir) {
   await mkdir5(runtimeDir, { recursive: true });
   const gi = path10.join(runtimeDir, ".gitignore");
-  if (!existsSync9(gi)) {
+  if (!existsSync10(gi)) {
     await writeFile6(gi, RUNTIME_GITIGNORE_BODY, "utf8");
   }
   const readme = path10.join(runtimeDir, "README.md");
-  if (!existsSync9(readme)) {
+  if (!existsSync10(readme)) {
     await writeFile6(readme, RUNTIME_README_BODY, "utf8");
   }
 }
 async function ensureAiCacheLayout(cacheDir) {
   await mkdir5(cacheDir, { recursive: true });
   const gi = path10.join(cacheDir, ".gitignore");
-  if (!existsSync9(gi)) {
+  if (!existsSync10(gi)) {
     await writeFile6(gi, "*\n!.gitignore\n", "utf8");
   }
 }
@@ -3114,7 +3183,7 @@ async function ensureGitignoreEntries(root, patterns) {
   try {
     const gitignorePath = path10.join(root, ".gitignore");
     let existing = "";
-    if (existsSync9(gitignorePath)) {
+    if (existsSync10(gitignorePath)) {
       existing = await readFile5(gitignorePath, "utf8");
     }
     const lines = existing.split("\n");
@@ -3128,13 +3197,13 @@ async function ensureGitignoreEntries(root, patterns) {
 
 // src/commands/install-hooks.ts
 import { mkdir as mkdir7, writeFile as writeFile8, chmod, readFile as readFile7 } from "fs/promises";
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 import path12 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot8 } from "@hiveai/core";
 
 // src/utils/claude-hooks.ts
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile7 } from "fs/promises";
 import path11 from "path";
 var HAIVE_HOOK_TAG = "haive-enforcement";
@@ -3222,7 +3291,7 @@ function unpatchClaudeSettings(input) {
 async function installClaudeHooksAtPath(settingsPath) {
   let raw = null;
   let created = false;
-  if (existsSync10(settingsPath)) {
+  if (existsSync11(settingsPath)) {
     try {
       raw = JSON.parse(await readFile6(settingsPath, "utf8"));
     } catch {
@@ -3237,7 +3306,7 @@ async function installClaudeHooksAtPath(settingsPath) {
   return { settingsPath, created };
 }
 async function uninstallClaudeHooksAtPath(settingsPath) {
-  if (!existsSync10(settingsPath)) {
+  if (!existsSync11(settingsPath)) {
     return { settingsPath, created: false };
   }
   const raw = JSON.parse(await readFile6(settingsPath, "utf8"));
@@ -3308,7 +3377,7 @@ fi
 async function installGitHooks(opts) {
   const root = findProjectRoot8(opts.dir);
   const gitDir = path12.join(root, ".git");
-  if (!existsSync11(gitDir)) {
+  if (!existsSync12(gitDir)) {
     ui.error(`No .git directory at ${root}.`);
     process.exitCode = 1;
     return;
@@ -3319,7 +3388,7 @@ async function installGitHooks(opts) {
   let skipped = 0;
   for (const { name, body } of HOOKS) {
     const file = path12.join(hooksDir, name);
-    if (existsSync11(file) && !opts.force) {
+    if (existsSync12(file) && !opts.force) {
       const existing = await readFile7(file, "utf8");
       if (!existing.includes(HOOK_MARKER)) {
         ui.warn(`${name} already exists and was not written by hAIve. Re-run with --force to overwrite.`);
@@ -3383,7 +3452,7 @@ function registerInstallHooks(program2) {
 
 // src/commands/observe.ts
 import { appendFile, mkdir as mkdir8 } from "fs/promises";
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import path13 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot9, resolveHaivePaths as resolveHaivePaths7 } from "@hiveai/core";
@@ -3484,7 +3553,7 @@ function registerObserve(program2) {
       })();
       if (!root) return;
       const paths = resolveHaivePaths7(root);
-      if (!existsSync12(paths.haiveDir)) return;
+      if (!existsSync13(paths.haiveDir)) return;
       const failureHint = detectFailure(payload);
       const observation = {
         ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3516,7 +3585,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { findProjectRoot as findProjectRoot10, resolveHaivePaths as resolveHaivePaths8 } from "@hiveai/core";
 import { mkdir as mkdir9, writeFile as writeFile9 } from "fs/promises";
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import path14 from "path";
 import { z } from "zod";
 import { readFile as readFile8, readdir as readdir2 } from "fs/promises";
@@ -3619,7 +3688,7 @@ import {
 } from "@hiveai/core";
 import { z as z13 } from "zod";
 import { mkdir as mkdir32, writeFile as writeFile72 } from "fs/promises";
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync142 } from "fs";
 import path52 from "path";
 import {
   buildFrontmatter as buildFrontmatter22,
@@ -3672,7 +3741,7 @@ import {
   isStackPackSeed as isStackPackSeed2,
   literalMatchesAllTokens as literalMatchesAllTokens22,
   literalMatchesAnyToken as literalMatchesAnyToken22,
-  loadCodeMap as loadCodeMap4,
+  loadCodeMap as loadCodeMap5,
   loadConfig as loadConfig3,
   loadMemoriesFromDir as loadMemoriesFromDir13,
   loadUsageIndex as loadUsageIndex7,
@@ -3795,7 +3864,7 @@ var BootstrapProjectSaveInputSchema = {
 };
 async function bootstrapProjectSave(input, ctx) {
   const target = input.module ? path14.join(ctx.paths.modulesContextDir, input.module, "context.md") : ctx.paths.projectContext;
-  const exists = existsSync13(target);
+  const exists = existsSync14(target);
   if (exists && !input.overwrite) {
     throw new Error(
       `${target} already exists. Pass overwrite=true to replace it.`
@@ -4675,7 +4744,7 @@ var MemTriedInputSchema = {
   author: z14.string().optional().describe("Author handle or email")
 };
 async function memTried(input, ctx) {
-  if (!existsSync14(ctx.paths.haiveDir)) {
+  if (!existsSync142(ctx.paths.haiveDir)) {
     throw new Error(`No .ai/ directory at ${ctx.paths.root}. Run 'haive init' first.`);
   }
   const slug = input.what.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim().split(/\s+/).slice(0, 5).join("-");
@@ -4697,7 +4766,7 @@ async function memTried(input, ctx) {
   const body = lines.join("\n") + "\n";
   const file = memoryFilePath22(ctx.paths, frontmatter.scope, frontmatter.id, frontmatter.module);
   await mkdir32(path52.dirname(file), { recursive: true });
-  if (existsSync14(file)) {
+  if (existsSync142(file)) {
     throw new Error(`Memory already exists at ${file}`);
   }
   await writeFile72(file, serializeMemory6({ frontmatter, body }), "utf8");
@@ -5189,7 +5258,7 @@ async function getBriefing(input, ctx) {
   if ((isTemplateContext || !existsSync18(ctx.paths.projectContext)) && input.include_project_context) {
     const haiveConfig = await loadConfig3(ctx.paths);
     if (haiveConfig.autoContext) {
-      const codeMap = await loadCodeMap4(ctx.paths);
+      const codeMap = await loadCodeMap5(ctx.paths);
       if (codeMap) {
         const totalFiles = Object.keys(codeMap.files).length;
         const extensions = /* @__PURE__ */ new Map();
@@ -5317,7 +5386,7 @@ ${m.content}`).join("\n\n---\n\n"),
     }
   }
   if (symbolsToLookup.size > 0) {
-    const codeMap = await loadCodeMap4(ctx.paths);
+    const codeMap = await loadCodeMap5(ctx.paths);
     if (codeMap) {
       symbolLocations = [];
       for (const sym of symbolsToLookup) {
@@ -5944,6 +6013,58 @@ var AntiPatternsCheckInputSchema = {
     "When true, also use semantic search (requires @hiveai/embeddings + memory index) to find related anti-patterns."
   )
 };
+var CODE_STOPWORDS = /* @__PURE__ */ new Set([
+  "import",
+  "export",
+  "function",
+  "return",
+  "const",
+  "let",
+  "var",
+  "class",
+  "public",
+  "private",
+  "protected",
+  "static",
+  "this",
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "void",
+  "async",
+  "await",
+  "from",
+  "type",
+  "interface",
+  "extends",
+  "implements",
+  "number",
+  "string",
+  "boolean",
+  "value",
+  "default",
+  "case",
+  "break",
+  "continue",
+  "throw",
+  "catch",
+  "finally",
+  "else",
+  "while",
+  "for",
+  "new",
+  "super",
+  "yield",
+  "module",
+  "require",
+  "console"
+]);
+function tokenizeDiffForLiteral(diff) {
+  const wsTokens = tokenizeQuery3(diff);
+  const wordTokens = diff.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length >= 4 && !CODE_STOPWORDS.has(t));
+  return [.../* @__PURE__ */ new Set([...wsTokens, ...wordTokens])];
+}
 async function antiPatternsCheck(input, ctx) {
   if (!input.diff && input.paths.length === 0) {
     return {
@@ -5997,7 +6118,7 @@ async function antiPatternsCheck(input, ctx) {
     }
   }
   if (input.diff) {
-    const tokens = tokenizeQuery3(input.diff);
+    const tokens = tokenizeDiffForLiteral(input.diff);
     if (tokens.length > 0) {
       for (const { memory: memory2 } of negative) {
         if (literalMatchesAnyToken3(memory2, tokens)) {
@@ -6450,7 +6571,10 @@ var PreCommitCheckInputSchema = {
   block_on: z28.enum(["any", "high-confidence", "never"]).default("high-confidence").describe(
     "When to set should_block=true: 'any' = any warning blocks; 'high-confidence' = only warnings from authoritative/trusted memories block; 'never' = report only, never block."
   ),
-  semantic: z28.boolean().default(true).describe("Enable semantic search in anti_patterns_check (requires embeddings index).")
+  semantic: z28.boolean().default(true).describe("Enable semantic search in anti_patterns_check (requires embeddings index)."),
+  anchored_blocks: z28.boolean().default(false).describe(
+    "When true, ALSO block a high-confidence anti-pattern (attempt/gotcha) that is anchored to a touched file AND corroborated by the diff (literal token overlap, or semantic >= 0.45) \u2014 not just very strong semantic matches. Powers the 'anchored' enforcement gate. Config/docs-only commits are still downgraded. Default false preserves the soft, semantic-only blocking behavior."
+  )
 };
 async function preCommitCheck(input, ctx) {
   if (!input.diff && input.paths.length === 0) {
@@ -6475,7 +6599,7 @@ 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 classifiedWarnings = apResult.warnings.map((warning) => classifyWarning(warning, input.paths));
+  const classifiedWarnings = apResult.warnings.map((warning) => classifyWarning(warning, input.paths, input.anchored_blocks));
   const blockingWarnings = classifiedWarnings.filter((w) => w.level === "blocking");
   const reviewWarnings = classifiedWarnings.filter((w) => w.level === "review");
   const infoWarnings = classifiedWarnings.filter((w) => w.level === "info");
@@ -6515,7 +6639,7 @@ async function preCommitCheck(input, ctx) {
     })
   };
 }
-function classifyWarning(warning, paths) {
+function classifyWarning(warning, paths, anchoredBlocks = false) {
   const affectedFiles = paths.filter((p) => !p.startsWith(".ai/.usage/"));
   const repairCommand = repairCommandForWarning(warning, affectedFiles);
   const fileDowngrade = fileTypeDowngradeReason(warning, affectedFiles);
@@ -6540,6 +6664,15 @@ function classifyWarning(warning, paths) {
   const hasSemantic = warning.reasons.includes("semantic");
   const semanticScore = warning.semantic_score ?? 0;
   const highConfidence = warning.confidence === "authoritative" || warning.confidence === "trusted";
+  if (anchoredBlocks && highConfidence && warning.reasons.includes("anchor") && (warning.reasons.includes("literal") || hasSemantic && semanticScore >= 0.45)) {
+    return {
+      ...warning,
+      level: "blocking",
+      rationale: "high-confidence anti-pattern anchored to a touched file and corroborated by the diff (anchored gate)",
+      affected_files: affectedFiles,
+      repair_command: repairCommand
+    };
+  }
   if (hasSemantic && semanticScore >= 0.45 || highConfidence && warning.reasons.includes("anchor") && warning.reasons.includes("literal")) {
     return {
       ...warning,
@@ -7190,7 +7323,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
   };
 }
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.9.28";
+var SERVER_VERSION = "0.9.30";
 function jsonResult(data) {
   return {
     content: [
@@ -8172,7 +8305,7 @@ import {
   isAutoPromoteEligible as isAutoPromoteEligible2,
   isDecaying as isDecaying2,
   isStackPackSeed as isStackPackSeed3,
-  loadCodeMap as loadCodeMap5,
+  loadCodeMap as loadCodeMap6,
   loadConfig as loadConfig4,
   loadMemoriesFromDir as loadMemoriesFromDir23,
   loadUsageIndex as loadUsageIndex12,
@@ -8543,7 +8676,7 @@ Attends une **confirmation explicite** avant d'agir.
         ui.warn(`contract watcher failed: ${String(err)}`);
       }
     }
-    const existingMap = await loadCodeMap5(paths);
+    const existingMap = await loadCodeMap6(paths);
     if (!dryRun && !existingMap && (config.autopilot || autoRepair.codeMap)) {
       try {
         const { buildCodeMap: buildCodeMap4, saveCodeMap: saveCodeMap4 } = await import("@hiveai/core");
@@ -8737,7 +8870,7 @@ function registerMemoryAdd(memory2) {
     haive memory add --type convention --slug flyway-no-modify --topic flyway \\\\
       --scope team --body "Never modify existing migrations. Create V{n+1}__desc.sql."
 `
-  ).requiredOption("--type <type>", "skill | convention | decision | gotcha | architecture | glossary | attempt").option("--slug <slug>", "short kebab-case identifier used in the file name (auto-derived from --title/--body when omitted)").option("--title <text>", "memory title \u2014 becomes the first heading of the body").option("--scope <scope>", "personal | team | module (default: config default; team in autopilot)").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags for easier retrieval").option("--domain <domain>", "domain (e.g. transactions)").option("--author <author>", "author email or handle").option("--paths <csv>", "anchor to source files \u2014 used for staleness detection by haive sync").option("--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) => {
+  ).requiredOption("--type <type>", "skill | convention | decision | gotcha | architecture | glossary | attempt").option("--slug <slug>", "short kebab-case identifier used in the file name (auto-derived from --title/--body when omitted)").option("--title <text>", "memory title \u2014 becomes the first heading of the body").option("--scope <scope>", "personal | team | module (default: config default; team in autopilot)").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags for easier retrieval").option("--domain <domain>", "domain (e.g. transactions)").option("--author <author>", "author email or handle").option("--paths <csv>", "anchor to source files \u2014 used for staleness detection by haive sync").option("--files <csv>", "alias for --paths (matches the MCP `files` parameter)").option("--symbols <csv>", "anchor to specific symbols (class/function names)").option("--commit <sha>", "anchor to a specific commit SHA").option("--body <text>", "memory body content (Markdown) \u2014 overrides --title default body").option("--body-file <path>", "read memory body from a Markdown file \u2014 for long content").option("--no-auto-tag", "disable automatic tag suggestions inferred from anchor paths").option("--topic <key>", "stable key for upsert: if a memory with this topic+scope already exists, update it in-place (revision_count++)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot13(opts.dir);
     const paths = resolveHaivePaths10(root);
     if (!existsSync30(paths.haiveDir)) {
@@ -8747,7 +8880,7 @@ function registerMemoryAdd(memory2) {
     }
     const config = await loadConfig5(paths);
     const userTags = parseCsv2(opts.tags);
-    const anchorPaths = parseCsv2(opts.paths);
+    const anchorPaths = parseCsv2(opts.paths ?? opts.files);
     const autoTagsEnabled = opts.autoTag !== false;
     const inferredTags = autoTagsEnabled ? inferModulesFromPaths3(anchorPaths) : [];
     const mergedTags = Array.from(/* @__PURE__ */ new Set([...userTags, ...inferredTags]));
@@ -9156,7 +9289,7 @@ import {
   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("--type <type>", "change the memory type (convention | decision | gotcha | architecture | glossary | skill | attempt)").option("--title <text>", "new title \u2014 replaces the first heading of the body").option("--body <text>", "new Markdown body \u2014 replaces the existing body").option("--body-file <path>", "read new body from a Markdown file \u2014 for long content").option("--tags <csv>", "new tags, comma-separated \u2014 fully replaces existing tags").option("--paths <csv>", "new anchor paths, comma-separated").option("--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) => {
+  memory2.command("update <id>").description("Update body, tags, or anchor of an existing memory (preserves id and usage history)").option("--type <type>", "change the memory type (convention | decision | gotcha | architecture | glossary | skill | attempt)").option("--title <text>", "new title \u2014 replaces the first heading of the body").option("--body <text>", "new Markdown body \u2014 replaces the existing body").option("--body-file <path>", "read new body from a Markdown file \u2014 for long content").option("--tags <csv>", "new tags, comma-separated \u2014 fully replaces existing tags").option("--paths <csv>", "new anchor paths, comma-separated").option("--files <csv>", "alias for --paths (matches the MCP `files` parameter)").option("--symbols <csv>", "new anchor symbols, comma-separated").option("--commit <sha>", "new anchor commit SHA").option("--domain <domain>", "new domain label").option("--author <author>", "new author handle or email").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
     const root = findProjectRoot17(opts.dir);
     const paths = resolveHaivePaths14(root);
     if (!existsSync35(paths.memoriesDir)) {
@@ -9174,8 +9307,9 @@ function registerMemoryUpdate(memory2) {
     const updated = [];
     const { frontmatter, body } = loaded.memory;
     const newAnchor = { ...frontmatter.anchor };
-    if (opts.paths !== void 0) {
-      newAnchor.paths = parseCsv3(opts.paths);
+    const pathsOpt = opts.paths ?? opts.files;
+    if (pathsOpt !== void 0) {
+      newAnchor.paths = parseCsv3(pathsOpt);
       updated.push("anchor.paths");
     }
     if (opts.symbols !== void 0) {
@@ -9570,7 +9704,7 @@ function registerMemoryTried(memory2) {
       --instead "use static import in the entry file" \\\\
       --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", "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) => {
+  ).requiredOption("--what <text>", "what approach was tried (short, descriptive title)").requiredOption("--why-failed <text>", "why it failed or should NOT be used (include the exact error if possible)").option("--instead <text>", "the correct approach to use instead").option("--scope <scope>", "personal | team | module", "personal").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags").option("--paths <csv>", "anchor paths, comma-separated").option("--files <csv>", "alias for --paths (matches the MCP `files` parameter)").option("--author <author>", "author email or handle").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot22(opts.dir);
     const paths = resolveHaivePaths19(root);
     if (!existsSync40(paths.haiveDir)) {
@@ -9585,7 +9719,7 @@ function registerMemoryTried(memory2) {
       scope: opts.scope,
       module: opts.module,
       tags: parseCsv4(opts.tags),
-      paths: parseCsv4(opts.paths),
+      paths: parseCsv4(opts.paths ?? opts.files),
       author: opts.author
     });
     const frontmatter = { ...baseFm, status: "validated" };
@@ -9612,21 +9746,118 @@ function parseCsv4(value) {
   return value.split(",").map((s) => s.trim()).filter(Boolean);
 }
 
-// src/commands/memory-pending.ts
+// src/commands/memory-seed.ts
+import { readFile as readFile13 } from "fs/promises";
 import { existsSync as existsSync41 } from "fs";
 import path27 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot23,
+  loadConfig as loadConfig6,
+  resolveHaivePaths as resolveHaivePaths20
+} from "@hiveai/core";
+async function readDependencyMap(root) {
+  try {
+    const raw = await readFile13(path27.join(root, "package.json"), "utf8");
+    const pkg = JSON.parse(raw);
+    return { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+  } catch {
+    return {};
+  }
+}
+function registerMemorySeed(memory2) {
+  memory2.command("seed [stack]").description(
+    "Seed a stack pack of starter memories on demand.\n\n  Stack packs are generic framework gotchas/conventions every team using that\n  stack rediscovers. They are tagged `stack-pack` and kept at BACKGROUND priority\n  in briefings until you anchor them to a real file or replace them with a\n  repo-specific note \u2014 so they never crowd out your own knowledge.\n\n  Examples:\n    haive memory seed              # auto-detect stacks from package.json and seed them\n    haive memory seed nestjs       # seed a specific stack\n    haive memory seed --list       # show supported + auto-detected stacks\n    haive memory seed --list --json\n"
+  ).option("--list", "list supported stacks (and which are auto-detected here) and exit").option("--json", "machine-readable output (use with --list)").option("-d, --dir <dir>", "project root").action(async (stack, opts) => {
+    const root = findProjectRoot23(opts.dir);
+    const paths = resolveHaivePaths20(root);
+    const deps = await readDependencyMap(root);
+    const detected = autoDetectStacks(deps);
+    if (opts.list) {
+      if (opts.json) {
+        console.log(JSON.stringify({ supported: SUPPORTED_STACKS, detected }, null, 2));
+        return;
+      }
+      ui.info("Supported stacks:");
+      for (const s of SUPPORTED_STACKS) {
+        const mark = detected.includes(s) ? ui.green(" \u2713 detected here") : "";
+        console.log(`  \u2022 ${s}${mark}`);
+      }
+      if (detected.length === 0) {
+        ui.info("No stack auto-detected from package.json \u2014 pass a stack name explicitly.");
+      }
+      return;
+    }
+    if (!existsSync41(paths.haiveDir)) {
+      ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
+      process.exitCode = 1;
+      return;
+    }
+    let stacksToSeed;
+    if (stack) {
+      if (!isValidStack(stack)) {
+        ui.error(`Unknown stack '${stack}'. Supported: ${SUPPORTED_STACKS.join(", ")}.`);
+        ui.info("Run `haive memory seed --list` to see all stacks.");
+        process.exitCode = 1;
+        return;
+      }
+      stacksToSeed = [stack];
+    } else if (detected.length > 0) {
+      stacksToSeed = detected;
+      ui.info(`Auto-detected from package.json: ${detected.join(", ")}`);
+    } else {
+      ui.error("No stack auto-detected from package.json.");
+      ui.info("Pass a stack name (e.g. `haive memory seed nestjs`) or run `haive memory seed --list`.");
+      process.exitCode = 1;
+      return;
+    }
+    let total = 0;
+    const seededStacks = [];
+    for (const s of stacksToSeed) {
+      const count = await seedStackPack(paths, s);
+      if (count > 0) {
+        total += count;
+        seededStacks.push(`${s} (${count})`);
+      } else {
+        ui.info(`Stack pack '${s}': all memories already exist \u2014 skipped.`);
+      }
+    }
+    if (total === 0) {
+      ui.info("Nothing new to seed \u2014 every memory in the selected pack(s) already exists.");
+      return;
+    }
+    ui.success(`Seeded ${total} starter memor${total === 1 ? "y" : "ies"}: ${seededStacks.join(", ")}`);
+    ui.info("Kept at background priority. Anchor them to a real file (or replace them) to make them high-signal:");
+    ui.info("  haive memory update <id> --paths <key-file>   # anchor a seed to a file");
+    const config = await loadConfig6(paths);
+    if (config.autopilot || config.autoRepair?.corpus === true) {
+      const repairs = await applyAutopilotRepairs(root, paths, {
+        applyConfig: false,
+        applyContext: false,
+        applyCorpus: true,
+        applyCodeMap: false,
+        applyCodeSearch: false
+      });
+      for (const repair of repairs) ui.info(repair.message);
+    }
+  });
+}
+
+// src/commands/memory-pending.ts
+import { existsSync as existsSync43 } from "fs";
+import path28 from "path";
+import "commander";
+import {
+  findProjectRoot as findProjectRoot24,
   getUsage as getUsage14,
   loadUsageIndex as loadUsageIndex16,
-  resolveHaivePaths as resolveHaivePaths20
+  resolveHaivePaths as resolveHaivePaths21
 } from "@hiveai/core";
 function registerMemoryPending(memory2) {
   memory2.command("pending").description("List draft and proposed memories awaiting review (sorted by reads desc).\n\n  draft = created but not yet activated \xB7 proposed = promoted, awaiting team validation").option("--scope <scope>", "filter by scope (personal | team | module)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot23(opts.dir);
-    const paths = resolveHaivePaths20(root);
-    if (!existsSync41(paths.memoriesDir)) {
+    const root = findProjectRoot24(opts.dir);
+    const paths = resolveHaivePaths21(root);
+    if (!existsSync43(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -9660,7 +9891,7 @@ function registerMemoryPending(memory2) {
         console.log(
           `  ${ui.bold(fm.id)}  ${ui.dim(`${fm.scope}/${fm.type}`)}  ${ui.dim(`age=${ageStr} reads=${u.read_count}`)}`
         );
-        console.log(`    ${ui.dim(path27.relative(root, filePath))}`);
+        console.log(`    ${ui.dim(path28.relative(root, filePath))}`);
       }
       if (proposed.length > 0) console.log(ui.dim(`  \u2192 haive memory approve <id>  or  haive memory auto-promote`));
       console.log();
@@ -9675,7 +9906,7 @@ function registerMemoryPending(memory2) {
         console.log(
           `  ${ui.bold(fm.id)}  ${ui.dim(`${fm.scope}/${fm.type}`)}  ${ui.dim(`age=${ageStr} reads=${u.read_count}`)}`
         );
-        console.log(`    ${ui.dim(path27.relative(root, filePath))}`);
+        console.log(`    ${ui.dim(path28.relative(root, filePath))}`);
       }
       console.log(ui.dim(`  \u2192 haive memory approve <id>   (activate)  |  haive memory promote <id>  (share with team)`));
     }
@@ -9684,24 +9915,24 @@ function registerMemoryPending(memory2) {
 }
 
 // src/commands/memory-query.ts
-import { existsSync as existsSync43 } from "fs";
-import path28 from "path";
+import { existsSync as existsSync44 } from "fs";
+import path29 from "path";
 import "commander";
 import {
   extractSnippet as extractSnippet2,
-  findProjectRoot as findProjectRoot24,
+  findProjectRoot as findProjectRoot25,
   literalMatchesAllTokens as literalMatchesAllTokens3,
   literalMatchesAnyToken as literalMatchesAnyToken4,
   pickSnippetNeedle as pickSnippetNeedle2,
-  resolveHaivePaths as resolveHaivePaths21,
+  resolveHaivePaths as resolveHaivePaths22,
   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 = findProjectRoot24(opts.dir);
-    const paths = resolveHaivePaths21(root);
-    if (!existsSync43(paths.memoriesDir)) {
+    const root = findProjectRoot25(opts.dir);
+    const paths = resolveHaivePaths22(root);
+    if (!existsSync44(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -9742,7 +9973,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(path28.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path29.relative(root, filePath))}`);
       const snippet = extractSnippet2(mem.body, snippetNeedle);
       if (snippet) console.log(`  ${snippet}`);
     }
@@ -9760,21 +9991,21 @@ ${top.length} of ${matches.length} match${matches.length === 1 ? "" : "es"}`)
 
 // src/commands/memory-reject.ts
 import { writeFile as writeFile20 } from "fs/promises";
-import { existsSync as existsSync44 } from "fs";
+import { existsSync as existsSync45 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot25,
+  findProjectRoot as findProjectRoot26,
   loadUsageIndex as loadUsageIndex17,
   recordRejection as recordRejection2,
-  resolveHaivePaths as resolveHaivePaths22,
+  resolveHaivePaths as resolveHaivePaths23,
   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 = findProjectRoot25(opts.dir);
-    const paths = resolveHaivePaths22(root);
-    if (!existsSync44(paths.memoriesDir)) {
+    const root = findProjectRoot26(opts.dir);
+    const paths = resolveHaivePaths23(root);
+    if (!existsSync45(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -9810,22 +10041,22 @@ function registerMemoryReject(memory2) {
 }
 
 // src/commands/memory-rm.ts
-import { existsSync as existsSync45 } from "fs";
+import { existsSync as existsSync46 } from "fs";
 import { unlink as unlink3 } from "fs/promises";
-import path29 from "path";
+import path30 from "path";
 import { createInterface as createInterface2 } from "readline/promises";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot26,
+  findProjectRoot as findProjectRoot27,
   loadUsageIndex as loadUsageIndex18,
-  resolveHaivePaths as resolveHaivePaths23,
+  resolveHaivePaths as resolveHaivePaths24,
   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 = findProjectRoot26(opts.dir);
-    const paths = resolveHaivePaths23(root);
-    if (!existsSync45(paths.memoriesDir)) {
+    const root = findProjectRoot27(opts.dir);
+    const paths = resolveHaivePaths24(root);
+    if (!existsSync46(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -9837,7 +10068,7 @@ function registerMemoryRm(memory2) {
       process.exitCode = 1;
       return;
     }
-    const rel = path29.relative(root, found.filePath);
+    const rel = path30.relative(root, found.filePath);
     if (!opts.yes) {
       const rl = createInterface2({ input: process.stdin, output: process.stdout });
       const answer = (await rl.question(`Delete ${rel}? [y/N] `)).trim().toLowerCase();
@@ -9861,22 +10092,22 @@ function registerMemoryRm(memory2) {
 }
 
 // src/commands/memory-show.ts
-import { existsSync as existsSync46 } from "fs";
-import { readFile as readFile13 } from "fs/promises";
-import path30 from "path";
+import { existsSync as existsSync47 } from "fs";
+import { readFile as readFile14 } from "fs/promises";
+import path31 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence10,
-  findProjectRoot as findProjectRoot27,
+  findProjectRoot as findProjectRoot28,
   getUsage as getUsage15,
   loadUsageIndex as loadUsageIndex19,
-  resolveHaivePaths as resolveHaivePaths24
+  resolveHaivePaths as resolveHaivePaths25
 } 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 = findProjectRoot27(opts.dir);
-    const paths = resolveHaivePaths24(root);
-    if (!existsSync46(paths.memoriesDir)) {
+    const root = findProjectRoot28(opts.dir);
+    const paths = resolveHaivePaths25(root);
+    if (!existsSync47(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -9889,7 +10120,7 @@ function registerMemoryShow(memory2) {
       return;
     }
     if (opts.raw) {
-      console.log(await readFile13(found.filePath, "utf8"));
+      console.log(await readFile14(found.filePath, "utf8"));
       return;
     }
     const fm = found.memory.frontmatter;
@@ -9905,7 +10136,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:")}       ${path30.relative(root, found.filePath)}`);
+    console.log(`${ui.dim("file:")}       ${path31.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}`);
@@ -9920,21 +10151,21 @@ function registerMemoryShow(memory2) {
 }
 
 // src/commands/memory-stats.ts
-import { existsSync as existsSync47 } from "fs";
-import path31 from "path";
+import { existsSync as existsSync48 } from "fs";
+import path33 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence11,
-  findProjectRoot as findProjectRoot28,
+  findProjectRoot as findProjectRoot29,
   getUsage as getUsage16,
   loadUsageIndex as loadUsageIndex20,
-  resolveHaivePaths as resolveHaivePaths25
+  resolveHaivePaths as resolveHaivePaths26
 } 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 = findProjectRoot28(opts.dir);
-    const paths = resolveHaivePaths25(root);
-    if (!existsSync47(paths.memoriesDir)) {
+    const root = findProjectRoot29(opts.dir);
+    const paths = resolveHaivePaths26(root);
+    if (!existsSync48(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -9959,63 +10190,83 @@ 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(path31.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path33.relative(root, filePath))}`);
     }
   });
 }
 
 // src/commands/memory-verify.ts
 import { writeFile as writeFile21 } from "fs/promises";
-import { existsSync as existsSync48 } from "fs";
-import path33 from "path";
+import { existsSync as existsSync49 } from "fs";
+import path34 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot29,
-  resolveHaivePaths as resolveHaivePaths26,
+  findProjectRoot as findProjectRoot30,
+  resolveHaivePaths as resolveHaivePaths27,
   serializeMemory as serializeMemory19,
   verifyAnchor as verifyAnchor3
 } from "@hiveai/core";
 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 = findProjectRoot29(opts.dir);
-    const paths = resolveHaivePaths26(root);
-    if (!existsSync48(paths.memoriesDir)) {
-      ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
+  ).option("--id <id>", "verify a single memory by id").option("--all", "verify every memory (default if --id is omitted)").option("--update", "write status=stale or status=validated back to disk").option("--json", "emit machine-readable JSON (for CI / agents)").option("-d, --dir <dir>", "project root").action(async (opts) => {
+    const root = findProjectRoot30(opts.dir);
+    const paths = resolveHaivePaths27(root);
+    if (!existsSync49(paths.memoriesDir)) {
+      if (opts.json) {
+        console.log(JSON.stringify({ error: "not-initialized", root }, null, 2));
+      } else {
+        ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
+      }
       process.exitCode = 1;
       return;
     }
     const all = await loadMemoriesFromDir25(paths.memoriesDir);
     const targets = opts.id ? all.filter((m) => m.memory.frontmatter.id === opts.id) : all;
     if (opts.id && targets.length === 0) {
-      ui.error(`No memory with id "${opts.id}".`);
+      if (opts.json) {
+        console.log(JSON.stringify({ error: "not-found", id: opts.id }, null, 2));
+      } else {
+        ui.error(`No memory with id "${opts.id}".`);
+      }
       process.exitCode = 1;
       return;
     }
     let staleCount = 0;
     let freshCount = 0;
     const anchorlessIds = [];
+    const entries = [];
     let updated = 0;
     for (const { memory: mem, filePath } of targets) {
       const result = await verifyAnchor3(mem, { projectRoot: root });
       const isAnchored = mem.frontmatter.anchor.paths.length > 0 || mem.frontmatter.anchor.symbols.length > 0;
+      const rel = path34.relative(root, filePath);
       if (!isAnchored) {
         anchorlessIds.push(mem.frontmatter.id);
+        entries.push({ id: mem.frontmatter.id, status: "anchorless", path: rel });
         continue;
       }
-      const rel = path33.relative(root, filePath);
       if (result.stale) {
         staleCount++;
-        console.log(`${ui.bold("STALE")}  ${mem.frontmatter.id}`);
-        console.log(`       ${ui.dim(rel)}`);
-        console.log(`       ${result.reason}`);
-        if (result.possibleRenames.length > 0) {
-          console.log(`       ${ui.yellow("Possible renames:")} ${result.possibleRenames.join(", ")}`);
+        entries.push({
+          id: mem.frontmatter.id,
+          status: "stale",
+          path: rel,
+          reason: result.reason ?? void 0,
+          possible_renames: result.possibleRenames
+        });
+        if (!opts.json) {
+          console.log(`${ui.bold("STALE")}  ${mem.frontmatter.id}`);
+          console.log(`       ${ui.dim(rel)}`);
+          console.log(`       ${result.reason}`);
+          if (result.possibleRenames.length > 0) {
+            console.log(`       ${ui.yellow("Possible renames:")} ${result.possibleRenames.join(", ")}`);
+          }
         }
       } else {
         freshCount++;
-        console.log(`${ui.dim("fresh")}  ${mem.frontmatter.id}`);
+        entries.push({ id: mem.frontmatter.id, status: "fresh", path: rel });
+        if (!opts.json) console.log(`${ui.dim("fresh")}  ${mem.frontmatter.id}`);
       }
       if (opts.update) {
         const next = applyVerification2(mem, result);
@@ -10023,6 +10274,20 @@ function registerMemoryVerify(memory2) {
         updated++;
       }
     }
+    if (opts.json) {
+      console.log(JSON.stringify({
+        summary: {
+          checked: freshCount + staleCount,
+          fresh: freshCount,
+          stale: staleCount,
+          anchorless: anchorlessIds.length,
+          updated
+        },
+        results: entries
+      }, null, 2));
+      if (staleCount > 0) process.exitCode = 1;
+      return;
+    }
     const summary = [
       `${freshCount} fresh`,
       `${staleCount} stale`,
@@ -10067,30 +10332,30 @@ function applyVerification2(mem, result) {
 }
 
 // src/commands/memory-import.ts
-import { readFile as readFile14 } from "fs/promises";
-import { existsSync as existsSync49 } from "fs";
+import { readFile as readFile15 } from "fs/promises";
+import { existsSync as existsSync50 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot30,
-  resolveHaivePaths as resolveHaivePaths27
+  findProjectRoot as findProjectRoot31,
+  resolveHaivePaths as resolveHaivePaths28
 } 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 = findProjectRoot30(opts.dir);
-    const paths = resolveHaivePaths27(root);
-    if (!existsSync49(paths.haiveDir)) {
+    const root = findProjectRoot31(opts.dir);
+    const paths = resolveHaivePaths28(root);
+    if (!existsSync50(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    if (!existsSync49(opts.from)) {
+    if (!existsSync50(opts.from)) {
       ui.error(`File not found: ${opts.from}`);
       process.exitCode = 1;
       return;
     }
-    const content = await readFile14(opts.from, "utf8");
+    const content = await readFile15(opts.from, "utf8");
     const scope = opts.scope ?? "team";
     ui.info(`Preparing import from: ${opts.from}  (scope=${scope})`);
     ui.info(`Content length: ${content.length} chars`);
@@ -10118,14 +10383,14 @@ function registerMemoryImport(memory2) {
 }
 
 // src/commands/memory-import-changelog.ts
-import { existsSync as existsSync50 } from "fs";
-import { readFile as readFile15, mkdir as mkdir14, writeFile as writeFile23 } from "fs/promises";
-import path34 from "path";
+import { existsSync as existsSync51 } from "fs";
+import { readFile as readFile16, mkdir as mkdir14, writeFile as writeFile23 } from "fs/promises";
+import path35 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter9,
-  findProjectRoot as findProjectRoot31,
-  resolveHaivePaths as resolveHaivePaths28,
+  findProjectRoot as findProjectRoot32,
+  resolveHaivePaths as resolveHaivePaths29,
   serializeMemory as serializeMemory20
 } from "@hiveai/core";
 function parseChangelog(content) {
@@ -10190,15 +10455,15 @@ 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 = findProjectRoot31(opts.dir);
-    const paths = resolveHaivePaths28(root);
-    const changelogPath = path34.resolve(root, opts.fromChangelog);
-    if (!existsSync50(changelogPath)) {
+    const root = findProjectRoot32(opts.dir);
+    const paths = resolveHaivePaths29(root);
+    const changelogPath = path35.resolve(root, opts.fromChangelog);
+    if (!existsSync51(changelogPath)) {
       ui.error(`CHANGELOG not found: ${changelogPath}`);
       process.exitCode = 1;
       return;
     }
-    const content = await readFile15(changelogPath, "utf8");
+    const content = await readFile16(changelogPath, "utf8");
     let entries = parseChangelog(content);
     if (entries.length === 0) {
       ui.warn("No breaking changes, deprecations, or removals found in the CHANGELOG.");
@@ -10213,9 +10478,9 @@ function registerMemoryImportChangelog(memory2) {
         entries = entries.filter((e) => requested.includes(e.version));
       }
     }
-    const pkgName = opts.package ?? path34.basename(path34.dirname(changelogPath));
+    const pkgName = opts.package ?? path35.basename(path35.dirname(changelogPath));
     const scope = opts.scope ?? "team";
-    const teamDir = path34.join(paths.memoriesDir, scope);
+    const teamDir = path35.join(paths.memoriesDir, scope);
     await mkdir14(teamDir, { recursive: true });
     let saved = 0;
     for (const entry of entries) {
@@ -10238,7 +10503,7 @@ function registerMemoryImportChangelog(memory2) {
         lines.push("");
       }
       lines.push(
-        `**Source:** \`${path34.relative(root, changelogPath)}\`  
+        `**Source:** \`${path35.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, "-")}`;
@@ -10253,11 +10518,11 @@ function registerMemoryImportChangelog(memory2) {
           pkgName.replace(/[^a-z0-9]/gi, "-").toLowerCase(),
           `v${entry.version}`
         ],
-        paths: [path34.relative(root, changelogPath)],
+        paths: [path35.relative(root, changelogPath)],
         topic: `changelog-${pkgName}-${entry.version}`
       });
       await writeFile23(
-        path34.join(teamDir, `${fm.id}.md`),
+        path35.join(teamDir, `${fm.id}.md`),
         serializeMemory20({ frontmatter: fm, body: lines.join("\n") }),
         "utf8"
       );
@@ -10280,17 +10545,17 @@ ${ui.bold(`Imported ${saved} changelog entr${saved === 1 ? "y" : "ies"} from ${p
 }
 
 // src/commands/memory-digest.ts
-import { existsSync as existsSync51 } from "fs";
+import { existsSync as existsSync53 } from "fs";
 import { writeFile as writeFile24 } from "fs/promises";
-import path35 from "path";
+import path36 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence12,
-  findProjectRoot as findProjectRoot32,
+  findProjectRoot as findProjectRoot33,
   getUsage as getUsage17,
   loadMemoriesFromDir as loadMemoriesFromDir26,
   loadUsageIndex as loadUsageIndex21,
-  resolveHaivePaths as resolveHaivePaths29
+  resolveHaivePaths as resolveHaivePaths30
 } from "@hiveai/core";
 var CONFIDENCE_EMOJI = {
   unverified: "\u2B1C",
@@ -10303,9 +10568,9 @@ 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 = findProjectRoot32(opts.dir);
-    const paths = resolveHaivePaths29(root);
-    if (!existsSync51(paths.memoriesDir)) {
+    const root = findProjectRoot33(opts.dir);
+    const paths = resolveHaivePaths30(root);
+    if (!existsSync53(paths.memoriesDir)) {
       ui.error("No .ai/memories found. Run `haive init` first.");
       process.exitCode = 1;
       return;
@@ -10377,7 +10642,7 @@ function registerMemoryDigest(program2) {
     );
     const digest = lines.join("\n");
     if (opts.out) {
-      const outPath = path35.resolve(process.cwd(), opts.out);
+      const outPath = path36.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 {
@@ -10387,23 +10652,23 @@ function registerMemoryDigest(program2) {
 }
 
 // src/commands/session-end.ts
-import { writeFile as writeFile25, mkdir as mkdir15, readFile as readFile16, rm as rm2 } from "fs/promises";
-import { existsSync as existsSync53 } from "fs";
+import { writeFile as writeFile25, mkdir as mkdir15, readFile as readFile17, rm as rm2 } from "fs/promises";
+import { existsSync as existsSync54 } from "fs";
 import { spawn as spawn4 } from "child_process";
-import path36 from "path";
+import path37 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter10,
-  findProjectRoot as findProjectRoot33,
+  findProjectRoot as findProjectRoot34,
   loadMemoriesFromDir as loadMemoriesFromDir27,
   memoryFilePath as memoryFilePath9,
-  resolveHaivePaths as resolveHaivePaths30,
+  resolveHaivePaths as resolveHaivePaths31,
   serializeMemory as serializeMemory21
 } from "@hiveai/core";
 async function buildAutoRecap(paths) {
-  const obsFile = path36.join(paths.haiveDir, ".cache", "observations.jsonl");
-  if (!existsSync53(obsFile)) return await buildGitAutoRecap(paths);
-  const raw = await readFile16(obsFile, "utf8").catch(() => "");
+  const obsFile = path37.join(paths.haiveDir, ".cache", "observations.jsonl");
+  if (!existsSync54(obsFile)) return await buildGitAutoRecap(paths);
+  const raw = await readFile17(obsFile, "utf8").catch(() => "");
   if (!raw.trim()) return await buildGitAutoRecap(paths);
   const lines = raw.split("\n").filter(Boolean);
   const obs = [];
@@ -10591,9 +10856,9 @@ 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 = findProjectRoot33(opts.dir);
-    const paths = resolveHaivePaths30(root);
-    if (!existsSync53(paths.haiveDir)) {
+    const root = findProjectRoot34(opts.dir);
+    const paths = resolveHaivePaths31(root);
+    if (!existsSync54(paths.haiveDir)) {
       if (opts.auto || opts.quiet) return;
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
@@ -10626,18 +10891,18 @@ function registerSessionEnd(session2) {
     });
     const topic = recapTopic2(scope, opts.module);
     const filesTouched = parseCsv5(resolvedFiles).map((p) => normalizeAnchorPath(root, p));
-    const missingPaths = filesTouched.filter((p) => !existsSync53(path36.resolve(root, p)));
+    const missingPaths = filesTouched.filter((p) => !existsSync54(path37.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 = path36.join(paths.haiveDir, ".cache", "observations.jsonl");
-      if (existsSync53(obsFile)) await rm2(obsFile).catch(() => {
+      const obsFile = path37.join(paths.haiveDir, ".cache", "observations.jsonl");
+      if (existsSync54(obsFile)) await rm2(obsFile).catch(() => {
       });
     };
-    if (existsSync53(paths.memoriesDir)) {
+    if (existsSync54(paths.memoriesDir)) {
       const existing = await loadMemoriesFromDir27(paths.memoriesDir);
       const topicMatch = existing.find(
         ({ memory: memory2 }) => memory2.frontmatter.topic === topic && memory2.frontmatter.scope === scope && (!opts.module || memory2.frontmatter.module === opts.module)
@@ -10658,7 +10923,7 @@ function registerSessionEnd(session2) {
         await cleanupObservations();
         if (!opts.quiet) {
           ui.success(`Session recap updated (revision #${revisionCount})`);
-          ui.info(`id=${fm.id}  file=${path36.relative(root, topicMatch.filePath)}`);
+          ui.info(`id=${fm.id}  file=${path37.relative(root, topicMatch.filePath)}`);
           ui.info("Tip: `haive stats --export-report` generates a usage JSON suitable for dashboards.");
         }
         return;
@@ -10675,12 +10940,12 @@ function registerSessionEnd(session2) {
       status: "validated"
     });
     const file = memoryFilePath9(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir15(path36.dirname(file), { recursive: true });
+    await mkdir15(path37.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=${path36.relative(root, file)}`);
+      ui.info(`id=${frontmatter.id}  scope=${scope}  file=${path37.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`.");
     }
@@ -10692,22 +10957,22 @@ function parseCsv5(value) {
 }
 function normalizeAnchorPath(root, filePath) {
   if (!filePath) return filePath;
-  if (!path36.isAbsolute(filePath)) return filePath;
-  const rel = path36.relative(root, filePath);
+  if (!path37.isAbsolute(filePath)) return filePath;
+  const rel = path37.relative(root, filePath);
   if (rel.startsWith("..")) return filePath;
   return rel;
 }
 
 // src/commands/snapshot.ts
-import { existsSync as existsSync54 } from "fs";
+import { existsSync as existsSync55 } from "fs";
 import { readdir as readdir4 } from "fs/promises";
-import path37 from "path";
+import path38 from "path";
 import "commander";
 import {
   diffContract,
-  findProjectRoot as findProjectRoot34,
-  loadConfig as loadConfig6,
-  resolveHaivePaths as resolveHaivePaths31,
+  findProjectRoot as findProjectRoot35,
+  loadConfig as loadConfig7,
+  resolveHaivePaths as resolveHaivePaths32,
   snapshotContract
 } from "@hiveai/core";
 function registerSnapshot(program2) {
@@ -10732,16 +10997,16 @@ 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 = findProjectRoot34(opts.dir);
-    const paths = resolveHaivePaths31(root);
-    if (!existsSync54(paths.haiveDir)) {
+    const root = findProjectRoot35(opts.dir);
+    const paths = resolveHaivePaths32(root);
+    if (!existsSync55(paths.haiveDir)) {
       ui.error("No .ai/ found. Run `haive init` first.");
       process.exitCode = 1;
       return;
     }
     if (opts.list) {
-      const contractsDir = path37.join(paths.haiveDir, "contracts");
-      if (!existsSync54(contractsDir)) {
+      const contractsDir = path38.join(paths.haiveDir, "contracts");
+      if (!existsSync55(contractsDir)) {
         console.log(ui.dim("No contract snapshots found."));
         return;
       }
@@ -10761,7 +11026,7 @@ function registerSnapshot(program2) {
     }
     if (opts.diff) {
       if (!opts.name) {
-        const config2 = await loadConfig6(paths);
+        const config2 = await loadConfig7(paths);
         const contracts = config2.contractFiles ?? [];
         if (contracts.length === 0) {
           ui.error("--diff requires --name, or configure contractFiles in haive.config.json");
@@ -10773,7 +11038,7 @@ function registerSnapshot(program2) {
         }
         return;
       }
-      const config = await loadConfig6(paths);
+      const config = await loadConfig7(paths);
       const configured = (config.contractFiles ?? []).find((c) => c.name === opts.name);
       if (!configured && !opts.contract) {
         ui.error(
@@ -10796,7 +11061,7 @@ function registerSnapshot(program2) {
       return;
     }
     const contractPath = opts.contract;
-    const name = opts.name ?? path37.basename(contractPath, path37.extname(contractPath));
+    const name = opts.name ?? path38.basename(contractPath, path38.extname(contractPath));
     const format = opts.format ?? detectFormat(contractPath) ?? "openapi";
     const contract = { name, path: contractPath, format };
     try {
@@ -10851,8 +11116,8 @@ async function runDiff(root, haiveDir, contract) {
   }
 }
 function detectFormat(filePath) {
-  const ext = path37.extname(filePath).toLowerCase();
-  const base = path37.basename(filePath).toLowerCase();
+  const ext = path38.extname(filePath).toLowerCase();
+  const base = path38.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";
@@ -10865,16 +11130,16 @@ function detectFormat(filePath) {
 }
 
 // src/commands/hub.ts
-import { existsSync as existsSync55 } from "fs";
-import { mkdir as mkdir16, readFile as readFile17, writeFile as writeFile26, copyFile } from "fs/promises";
-import path38 from "path";
+import { existsSync as existsSync56 } from "fs";
+import { mkdir as mkdir16, readFile as readFile18, writeFile as writeFile26, copyFile } from "fs/promises";
+import path39 from "path";
 import { spawnSync as spawnSync5 } from "child_process";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot35,
-  loadConfig as loadConfig7,
+  findProjectRoot as findProjectRoot36,
+  loadConfig as loadConfig8,
   loadMemoriesFromDir as loadMemoriesFromDir28,
-  resolveHaivePaths as resolveHaivePaths32,
+  resolveHaivePaths as resolveHaivePaths33,
   saveConfig as saveConfig3,
   serializeMemory as serializeMemory23
 } from "@hiveai/core";
@@ -10886,7 +11151,7 @@ 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 = path38.resolve(hubPath);
+    const absPath = path39.resolve(hubPath);
     await mkdir16(absPath, { recursive: true });
     const gitCheck = spawnSync5("git", ["rev-parse", "--git-dir"], { cwd: absPath });
     if (gitCheck.status !== 0) {
@@ -10897,10 +11162,10 @@ function registerHub(program2) {
         return;
       }
     }
-    const sharedDir = path38.join(absPath, ".ai", "memories", "shared");
+    const sharedDir = path39.join(absPath, ".ai", "memories", "shared");
     await mkdir16(sharedDir, { recursive: true });
     await writeFile26(
-      path38.join(absPath, ".ai", "README.md"),
+      path39.join(absPath, ".ai", "README.md"),
       `# hAIve Team Knowledge Hub
 
 This repo is a shared knowledge hub for hAIve.
@@ -10922,7 +11187,7 @@ haive hub pull   # import into a project
       "utf8"
     );
     await writeFile26(
-      path38.join(absPath, ".gitignore"),
+      path39.join(absPath, ".gitignore"),
       ".ai/.cache/\n.ai/memories/personal/\n",
       "utf8"
     );
@@ -10937,7 +11202,7 @@ haive hub pull   # import into a project
         `
 Next steps:
   1. Add hubPath to your project's .ai/haive.config.json:
-       { "hubPath": "${path38.relative(process.cwd(), absPath)}" }
+       { "hubPath": "${path39.relative(process.cwd(), absPath)}" }
   2. Run \`haive hub push\` to publish your shared memories
   3. Share ${absPath} with teammates (git remote, NFS, etc.)
 `
@@ -10956,9 +11221,9 @@ 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 = findProjectRoot35(opts.dir);
-    const paths = resolveHaivePaths32(root);
-    const config = await loadConfig7(paths);
+    const root = findProjectRoot36(opts.dir);
+    const paths = resolveHaivePaths33(root);
+    const config = await loadConfig8(paths);
     if (!config.hubPath) {
       ui.error(
         'hubPath not configured in .ai/haive.config.json.\n  Add: { "hubPath": "../team-hub" }\n  Or run: haive hub init <path> first.'
@@ -10966,14 +11231,14 @@ Next steps:
       process.exitCode = 1;
       return;
     }
-    const hubRoot = path38.resolve(root, config.hubPath);
-    if (!existsSync55(hubRoot)) {
+    const hubRoot = path39.resolve(root, config.hubPath);
+    if (!existsSync56(hubRoot)) {
       ui.error(`Hub not found at ${hubRoot}. Run \`haive hub init ${config.hubPath}\` first.`);
       process.exitCode = 1;
       return;
     }
-    const projectName = path38.basename(root);
-    const destDir = path38.join(hubRoot, ".ai", "memories", "shared", projectName);
+    const projectName = path39.basename(root);
+    const destDir = path39.join(hubRoot, ".ai", "memories", "shared", projectName);
     await mkdir16(destDir, { recursive: true });
     const all = await loadMemoriesFromDir28(paths.memoriesDir);
     const shared = all.filter(
@@ -10992,7 +11257,7 @@ Next steps:
     for (const { memory: memory2 } of shared) {
       const fm = memory2.frontmatter;
       const fileName = `${fm.id}.md`;
-      const destPath = path38.join(destDir, fileName);
+      const destPath = path39.join(destDir, fileName);
       await writeFile26(destPath, serializeMemory23(memory2), "utf8");
       pushed++;
     }
@@ -11000,7 +11265,7 @@ Next steps:
     console.log(ui.dim(`  Location: ${destDir}`));
     if (opts.commit) {
       const message = opts.message ?? `haive: sync shared memories from ${projectName} (${pushed} memories)`;
-      spawnSync5("git", ["add", path38.join(".ai", "memories", "shared", projectName)], {
+      spawnSync5("git", ["add", path39.join(".ai", "memories", "shared", projectName)], {
         cwd: hubRoot
       });
       const commit = spawnSync5("git", ["commit", "-m", message], {
@@ -11025,9 +11290,9 @@ 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 = findProjectRoot35(opts.dir);
-    const paths = resolveHaivePaths32(root);
-    const config = await loadConfig7(paths);
+    const root = findProjectRoot36(opts.dir);
+    const paths = resolveHaivePaths33(root);
+    const config = await loadConfig8(paths);
     if (!config.hubPath) {
       ui.error(
         'hubPath not configured in .ai/haive.config.json.\n  Add: { "hubPath": "../team-hub" }\n  Or run: haive hub init <path> first.'
@@ -11035,13 +11300,13 @@ Next steps:
       process.exitCode = 1;
       return;
     }
-    const hubRoot = path38.resolve(root, config.hubPath);
-    const hubSharedDir = path38.join(hubRoot, ".ai", "memories", "shared");
-    if (!existsSync55(hubSharedDir)) {
+    const hubRoot = path39.resolve(root, config.hubPath);
+    const hubSharedDir = path39.join(hubRoot, ".ai", "memories", "shared");
+    if (!existsSync56(hubSharedDir)) {
       ui.warn("Hub has no shared memories yet. Run `haive hub push` from other projects first.");
       return;
     }
-    const projectName = path38.basename(root);
+    const projectName = path39.basename(root);
     const { readdir: readdir7 } = await import("fs/promises");
     const projectDirs = (await readdir7(hubSharedDir, { withFileTypes: true })).filter((d) => d.isDirectory() && d.name !== projectName).map((d) => d.name);
     if (projectDirs.length === 0) {
@@ -11051,17 +11316,17 @@ Next steps:
     let totalImported = 0;
     let totalUpdated = 0;
     for (const sourceName of projectDirs) {
-      const sourceDir = path38.join(hubSharedDir, sourceName);
-      const destDir = path38.join(paths.memoriesDir, "shared", sourceName);
+      const sourceDir = path39.join(hubSharedDir, sourceName);
+      const destDir = path39.join(paths.memoriesDir, "shared", sourceName);
       await mkdir16(destDir, { recursive: true });
       const sourceFiles = (await readdir7(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 = path38.join(sourceDir, file);
-        const destPath = path38.join(destDir, file);
-        const fileContent = await readFile17(srcPath, "utf8");
+        const srcPath = path39.join(sourceDir, file);
+        const destPath = path39.join(destDir, file);
+        const fileContent = await readFile18(srcPath, "utf8");
         const alreadyTagged = fileContent.includes(`cross-repo:${sourceName}`);
         if (!alreadyTagged) {
           await copyFile(srcPath, destPath);
@@ -11084,21 +11349,21 @@ Next steps:
     );
   });
   hub.command("status").description("Show hub sync status.").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot35(opts.dir);
-    const paths = resolveHaivePaths32(root);
-    const config = await loadConfig7(paths);
+    const root = findProjectRoot36(opts.dir);
+    const paths = resolveHaivePaths33(root);
+    const config = await loadConfig8(paths);
     console.log(ui.bold("Hub status"));
     console.log(
       `  hubPath: ${config.hubPath ? ui.green(config.hubPath) : ui.dim("not configured")}`
     );
-    const sharedDir = path38.join(paths.memoriesDir, "shared");
-    if (existsSync55(sharedDir)) {
+    const sharedDir = path39.join(paths.memoriesDir, "shared");
+    if (existsSync56(sharedDir)) {
       const { readdir: readdir7 } = await import("fs/promises");
       const sources = (await readdir7(sharedDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
       console.log(`
   Imported from ${sources.length} source(s):`);
       for (const src of sources) {
-        const files = (await readdir7(path38.join(sharedDir, src))).filter((f) => f.endsWith(".md"));
+        const files = (await readdir7(path39.join(sharedDir, src))).filter((f) => f.endsWith(".md"));
         console.log(`    ${src}: ${files.length} memor${files.length === 1 ? "y" : "ies"}`);
       }
     } else {
@@ -11113,7 +11378,7 @@ Next steps:
     if (outgoing.length > 0) {
       console.log(ui.dim("  Run `haive hub push` to publish them to the hub."));
     }
-    void readFile17;
+    void readFile18;
     void writeFile26;
     void saveConfig3;
   });
@@ -11121,17 +11386,17 @@ Next steps:
 
 // src/commands/stats.ts
 import "commander";
-import { existsSync as existsSync56 } from "fs";
+import { existsSync as existsSync57 } from "fs";
 import { mkdir as mkdir17, writeFile as writeFile27 } from "fs/promises";
-import path39 from "path";
+import path40 from "path";
 import {
   aggregateUsage,
-  findProjectRoot as findProjectRoot36,
+  findProjectRoot as findProjectRoot37,
   loadMemoriesFromDir as loadMemoriesFromDir29,
   loadUsageIndex as loadUsageIndex23,
   parseSince,
   readUsageEvents as readUsageEvents2,
-  resolveHaivePaths as resolveHaivePaths33,
+  resolveHaivePaths as resolveHaivePaths34,
   usageLogSize
 } from "@hiveai/core";
 function registerStats(program2) {
@@ -11140,8 +11405,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 = findProjectRoot36(opts.dir);
-    const paths = resolveHaivePaths33(root);
+    const root = findProjectRoot37(opts.dir);
+    const paths = resolveHaivePaths34(root);
     if (opts.exportReport) {
       await writeRoiReport(paths, root, opts.since ?? "30d", opts.exportReport);
       return;
@@ -11195,11 +11460,11 @@ function registerStats(program2) {
   });
 }
 async function writeRoiReport(paths, root, sinceRaw, outRelative) {
-  const outAbs = path39.isAbsolute(outRelative) ? path39.resolve(outRelative) : path39.resolve(root, outRelative);
+  const outAbs = path40.isAbsolute(outRelative) ? path40.resolve(outRelative) : path40.resolve(root, outRelative);
   const size = await usageLogSize(paths);
   let events = await readUsageEvents2(paths);
   let memoryCount = { team: 0, personal: 0, total_skipped_session: 0 };
-  if (existsSync56(paths.memoriesDir)) {
+  if (existsSync57(paths.memoriesDir)) {
     const mems = await loadMemoriesFromDir29(paths.memoriesDir);
     for (const { memory: memory2 } of mems) {
       const fm = memory2.frontmatter;
@@ -11230,7 +11495,7 @@ async function writeRoiReport(paths, root, sinceRaw, outRelative) {
     ui.warn("Usage log missing or empty \u2014 report still written with partial data.");
     events = [];
   }
-  await mkdir17(path39.dirname(outAbs), { recursive: true });
+  await mkdir17(path40.dirname(outAbs), { recursive: true });
   const payload = {
     generated_at: (/* @__PURE__ */ new Date()).toISOString(),
     project_root: root,
@@ -11294,13 +11559,13 @@ import { performance } from "perf_hooks";
 import "commander";
 import {
   estimateTokens as estimateTokens3,
-  findProjectRoot as findProjectRoot37,
-  resolveHaivePaths as resolveHaivePaths34
+  findProjectRoot as findProjectRoot38,
+  resolveHaivePaths as resolveHaivePaths35
 } 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 = findProjectRoot37(opts.dir);
-    const paths = resolveHaivePaths34(root);
+    const root = findProjectRoot38(opts.dir);
+    const paths = resolveHaivePaths35(root);
     const ctx = { paths };
     const task = opts.task ?? "audit dependencies for security risks";
     const scenarios = [
@@ -11419,11 +11684,11 @@ function summarize(name, t0, payload, notes) {
 }
 
 // src/commands/benchmark.ts
-import { existsSync as existsSync57 } from "fs";
-import { readdir as readdir5, readFile as readFile18, writeFile as writeFile28 } from "fs/promises";
-import path40 from "path";
+import { existsSync as existsSync58 } from "fs";
+import { readdir as readdir5, readFile as readFile19, writeFile as writeFile28 } from "fs/promises";
+import path41 from "path";
 import "commander";
-import { estimateTokens as estimateTokens4, findProjectRoot as findProjectRoot38 } from "@hiveai/core";
+import { estimateTokens as estimateTokens4, findProjectRoot as findProjectRoot39 } 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) => {
@@ -11436,9 +11701,9 @@ function registerBenchmark(program2) {
     }
     const markdown = renderMarkdown(root, summary, rows);
     if (opts.out) {
-      const outFile = path40.isAbsolute(opts.out) ? opts.out : path40.join(root, opts.out);
+      const outFile = path41.isAbsolute(opts.out) ? opts.out : path41.join(root, opts.out);
       await writeFile28(outFile, markdown, "utf8");
-      ui.success(`wrote ${path40.relative(process.cwd(), outFile)}`);
+      ui.success(`wrote ${path41.relative(process.cwd(), outFile)}`);
       return;
     }
     console.log(markdown);
@@ -11462,20 +11727,20 @@ function registerBenchmark(program2) {
 }
 function resolveBenchmarkRoot(dir) {
   const candidate = dir ?? "benchmarks/agent-benchmark";
-  if (path40.isAbsolute(candidate)) return candidate;
-  const projectRoot = findProjectRoot38(process.cwd());
-  return path40.join(projectRoot, candidate);
+  if (path41.isAbsolute(candidate)) return candidate;
+  const projectRoot = findProjectRoot39(process.cwd());
+  return path41.join(projectRoot, candidate);
 }
 async function collectRows(root) {
-  if (!existsSync57(root)) throw new Error(`Benchmark directory not found: ${root}`);
+  if (!existsSync58(root)) throw new Error(`Benchmark directory not found: ${root}`);
   const entries = await readdir5(root, { withFileTypes: true });
   const rows = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const fixtureDir = path40.join(root, entry.name);
-    const reportFile = path40.join(fixtureDir, "BENCHMARK_AGENT_REPORT.md");
-    if (!existsSync57(reportFile)) continue;
-    const report = await readFile18(reportFile, "utf8");
+    const fixtureDir = path41.join(root, entry.name);
+    const reportFile = path41.join(fixtureDir, "BENCHMARK_AGENT_REPORT.md");
+    if (!existsSync58(reportFile)) continue;
+    const report = await readFile19(reportFile, "utf8");
     rows.push(parseAgentReport(entry.name, report));
   }
   return rows.sort((a, b) => a.fixture.localeCompare(b.fixture));
@@ -11565,19 +11830,19 @@ function escapeRegExp(value) {
 
 // src/commands/memory-suggest.ts
 import { mkdir as mkdir18, writeFile as writeFile29 } from "fs/promises";
-import { existsSync as existsSync58 } from "fs";
-import path41 from "path";
+import { existsSync as existsSync59 } from "fs";
+import path43 from "path";
 import "commander";
 import {
   aggregateUsage as aggregateUsage2,
   buildFrontmatter as buildFrontmatter11,
-  findProjectRoot as findProjectRoot39,
-  loadConfig as loadConfig8,
+  findProjectRoot as findProjectRoot40,
+  loadConfig as loadConfig9,
   loadMemoriesFromDir as loadMemoriesFromDir30,
   memoryFilePath as memoryFilePath10,
   parseSince as parseSince2,
   readUsageEvents as readUsageEvents3,
-  resolveHaivePaths as resolveHaivePaths35,
+  resolveHaivePaths as resolveHaivePaths36,
   serializeMemory as serializeMemory24
 } from "@hiveai/core";
 var SEARCH_TOOLS = /* @__PURE__ */ new Set([
@@ -11594,8 +11859,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 save the top-N suggestions using the project defaults.\n  In autopilot, suggestions land as validated team records; in manual mode they stay draft."
   ).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 saved memories (personal | team; default: config default)").option("--auto-save", "save top-N suggestions as 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 = findProjectRoot39(opts.dir);
-    const paths = resolveHaivePaths35(root);
+    const root = findProjectRoot40(opts.dir);
+    const paths = resolveHaivePaths36(root);
     const events = await readUsageEvents3(paths);
     if (events.length === 0) {
       if (opts.json) {
@@ -11633,7 +11898,7 @@ function registerMemorySuggest(memory2) {
       inferred_type: inferType(v.tools, query)
     })).sort((a, b) => b.count - a.count);
     if (opts.autoSave) {
-      const config = await loadConfig8(paths);
+      const config = await loadConfig9(paths);
       const topN = Math.max(1, parseInt(opts.topN ?? "3", 10));
       const scope = opts.scope === "personal" || opts.scope === "team" ? opts.scope : config.defaultScope ?? "personal";
       const status = config.defaultStatus === "validated" ? "validated" : "draft";
@@ -11644,7 +11909,7 @@ function registerMemorySuggest(memory2) {
       }
       const created = [];
       const skipped = [];
-      const existing = existsSync58(paths.memoriesDir) ? await loadMemoriesFromDir30(paths.memoriesDir) : [];
+      const existing = existsSync59(paths.memoriesDir) ? await loadMemoriesFromDir30(paths.memoriesDir) : [];
       for (const s of top) {
         const slug = slugify2(s.query);
         if (!slug) {
@@ -11667,13 +11932,13 @@ function registerMemorySuggest(memory2) {
         });
         const body = renderTemplate(s, fm.id, status);
         const file = memoryFilePath10(paths, fm.scope, fm.id, fm.module);
-        await mkdir18(path41.dirname(file), { recursive: true });
-        if (existsSync58(file)) {
-          skipped.push({ query: s.query, reason: `file already exists at ${path41.relative(root, file)}` });
+        await mkdir18(path43.dirname(file), { recursive: true });
+        if (existsSync59(file)) {
+          skipped.push({ query: s.query, reason: `file already exists at ${path43.relative(root, file)}` });
           continue;
         }
         await writeFile29(file, serializeMemory24({ frontmatter: fm, body }), "utf8");
-        created.push({ id: fm.id, file: path41.relative(root, file), query: s.query });
+        created.push({ id: fm.id, file: path43.relative(root, file), query: s.query });
       }
       if (opts.json) {
         console.log(JSON.stringify({ created, skipped }, null, 2));
@@ -11771,16 +12036,16 @@ function truncate2(text, max) {
 }
 
 // src/commands/memory-archive.ts
-import { existsSync as existsSync59 } from "fs";
+import { existsSync as existsSync60 } from "fs";
 import { writeFile as writeFile30 } from "fs/promises";
-import path43 from "path";
+import path44 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot40,
+  findProjectRoot as findProjectRoot41,
   getUsage as getUsage18,
   loadMemoriesFromDir as loadMemoriesFromDir31,
   loadUsageIndex as loadUsageIndex24,
-  resolveHaivePaths as resolveHaivePaths36,
+  resolveHaivePaths as resolveHaivePaths37,
   serializeMemory as serializeMemory25
 } from "@hiveai/core";
 var MS_PER_DAY2 = 24 * 60 * 60 * 1e3;
@@ -11788,9 +12053,9 @@ function registerMemoryArchive(memory2) {
   memory2.command("archive").description(
     "Archive obsolete memories: marks status='deprecated' for memories not read in N days\n  whose anchored paths have all disappeared (or have no anchor at all).\n\n  Defaults to a DRY RUN \u2014 pass --apply to actually rewrite files.\n  Targets `attempt` memories by default since they age the fastest.\n\n  Recover later with `haive memory edit <id>` to set status back to validated."
   ).option("--since <window>", "minimum age since last read (e.g. '180d', '6m')", "180d").option("--type <type>", "limit to a memory type (default 'attempt'). Pass 'all' to scan all types.", "attempt").option("--apply", "actually rewrite files (default: dry run)", false).option("--json", "emit JSON instead of human-readable output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot40(opts.dir);
-    const paths = resolveHaivePaths36(root);
-    if (!existsSync59(paths.memoriesDir)) {
+    const root = findProjectRoot41(opts.dir);
+    const paths = resolveHaivePaths37(root);
+    if (!existsSync60(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -11811,7 +12076,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(path43.join(paths.root, p)));
+      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync60(path44.join(paths.root, p)));
       const isAnchorless = !hasAnyAnchor;
       if (!isAnchorless && !allPathsGone) continue;
       const u = getUsage18(usage, fm.id);
@@ -11885,33 +12150,33 @@ function parseDays(input) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync60, statSync } from "fs";
-import { readFile as readFile19, stat, writeFile as writeFile31 } from "fs/promises";
-import path44 from "path";
+import { existsSync as existsSync61, statSync as statSync2 } from "fs";
+import { readFile as readFile20, stat, writeFile as writeFile31 } from "fs/promises";
+import path45 from "path";
 import { execFileSync, execSync as execSync3 } from "child_process";
 import "commander";
 import {
   codeMapPath as codeMapPath2,
-  findProjectRoot as findProjectRoot41,
+  findProjectRoot as findProjectRoot42,
   getUsage as getUsage19,
-  loadCodeMap as loadCodeMap6,
-  loadConfig as loadConfig9,
+  loadCodeMap as loadCodeMap7,
+  loadConfig as loadConfig10,
   loadMemoriesFromDir as loadMemoriesFromDir33,
   loadUsageIndex as loadUsageIndex25,
   readUsageEvents as readUsageEvents4,
-  resolveHaivePaths as resolveHaivePaths37
+  resolveHaivePaths as resolveHaivePaths38
 } 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 apply safe autopilot repairs."
   ).option("--json", "emit JSON instead of human-readable output", false).option("--fix", "include suggested fix commands in human output", false).option("--dry-run", "with --fix, show delegated repairs without applying them", false).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 findings = [];
     const repairs = [];
-    const config = await loadConfig9(paths);
-    if (!existsSync60(paths.haiveDir)) {
+    const config = await loadConfig10(paths);
+    if (!existsSync61(paths.haiveDir)) {
       findings.push({
         severity: "error",
         code: "not-initialized",
@@ -11932,7 +12197,7 @@ function registerDoctor(program2) {
         })
       );
     }
-    if (!existsSync60(paths.projectContext)) {
+    if (!existsSync61(paths.projectContext)) {
       findings.push({
         severity: "warn",
         code: "no-project-context",
@@ -11940,8 +12205,8 @@ function registerDoctor(program2) {
         fix: "haive init"
       });
     } else {
-      const { readFile: readFile21 } = await import("fs/promises");
-      const content = await readFile21(paths.projectContext, "utf8");
+      const { readFile: readFile23 } = await import("fs/promises");
+      const content = await readFile23(paths.projectContext, "utf8");
       const isTemplate = content.includes("TODO \u2014 high-level overview") || content.includes("Generated by `haive init`");
       if (isTemplate) {
         findings.push({
@@ -11961,7 +12226,7 @@ function registerDoctor(program2) {
         });
       }
     }
-    const memories = existsSync60(paths.memoriesDir) ? await loadMemoriesFromDir33(paths.memoriesDir) : [];
+    const memories = existsSync61(paths.memoriesDir) ? await loadMemoriesFromDir33(paths.memoriesDir) : [];
     const now = Date.now();
     if (memories.length === 0) {
       findings.push({
@@ -12043,7 +12308,7 @@ function registerDoctor(program2) {
         fix: "haive memory lint --fix --apply"
       });
     }
-    const codeMap = await loadCodeMap6(paths);
+    const codeMap = await loadCodeMap7(paths);
     if (!codeMap) {
       findings.push({
         severity: "warn",
@@ -12102,12 +12367,12 @@ function registerDoctor(program2) {
       }
     }
     if (config.enforcement?.requireBriefingFirst) {
-      const claudeSettings = path44.join(root, ".claude", "settings.local.json");
+      const claudeSettings = path45.join(root, ".claude", "settings.local.json");
       let hasClaudeEnforcement = false;
-      if (existsSync60(claudeSettings)) {
+      if (existsSync61(claudeSettings)) {
         try {
-          const { readFile: readFile21 } = await import("fs/promises");
-          const raw = await readFile21(claudeSettings, "utf8");
+          const { readFile: readFile23 } = await import("fs/promises");
+          const raw = await readFile23(claudeSettings, "utf8");
           hasClaudeEnforcement = raw.includes("haive enforce session-start") && raw.includes("haive enforce pre-tool-use");
         } catch {
           hasClaudeEnforcement = false;
@@ -12130,14 +12395,14 @@ function registerDoctor(program2) {
         fix: "Edit .ai/haive.config.json: set autoSessionEnd: true (or re-run `haive init` without --manual)."
       });
     }
-    findings.push(...await collectInstallFindings(root, "0.9.28"));
+    findings.push(...await collectInstallFindings(root, "0.9.30"));
     try {
       const legacyRaw = execSync3("haive-mcp --version", {
         encoding: "utf8",
         timeout: 3e3,
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      const cliVersion = "0.9.28";
+      const cliVersion = "0.9.30";
       if (legacyRaw && legacyRaw !== cliVersion) {
         findings.push({
           severity: "warn",
@@ -12153,17 +12418,17 @@ npm uninstall -g @hiveai/mcp`
     }
     {
       const configPaths = [
-        path44.join(root, ".mcp.json"),
-        path44.join(root, ".cursor", "mcp.json"),
-        path44.join(root, ".vscode", "mcp.json")
+        path45.join(root, ".mcp.json"),
+        path45.join(root, ".cursor", "mcp.json"),
+        path45.join(root, ".vscode", "mcp.json")
       ];
       const staleConfigs = [];
       for (const cfgPath of configPaths) {
-        if (!existsSync60(cfgPath)) continue;
+        if (!existsSync61(cfgPath)) continue;
         try {
-          const raw = await readFile19(cfgPath, "utf8");
+          const raw = await readFile20(cfgPath, "utf8");
           if (raw.includes('"haive-mcp"') || raw.includes("'haive-mcp'")) {
-            staleConfigs.push(path44.relative(root, cfgPath));
+            staleConfigs.push(path45.relative(root, cfgPath));
             if (opts.fix && !opts.dryRun) {
               const updated = raw.replace(/"command"\s*:\s*"haive-mcp"/g, '"command": "haive"').replace(/"args"\s*:\s*\[\]/g, '"args": ["mcp", "--stdio"]');
               await writeFile31(cfgPath, updated, "utf8");
@@ -12453,9 +12718,9 @@ which -a haive`
     ".vscode/mcp.json"
   ];
   for (const rel of integrationFiles) {
-    const file = path44.join(root, rel);
-    if (!existsSync60(file)) continue;
-    const text = await readFile19(file, "utf8").catch(() => "");
+    const file = path45.join(root, rel);
+    if (!existsSync61(file)) continue;
+    const text = await readFile20(file, "utf8").catch(() => "");
     for (const bin of extractAbsoluteHaiveBins(text)) {
       const version = versionForBinary(bin);
       if (!version) {
@@ -12479,7 +12744,7 @@ which -a haive`
 }
 async function collectWorkspaceVersionFindings(root, expectedVersion) {
   const findings = [];
-  const rootPkg = await readJson(path44.join(root, "package.json"));
+  const rootPkg = await readJson(path45.join(root, "package.json"));
   const workspacePackages = [
     "packages/core/package.json",
     "packages/embeddings/package.json",
@@ -12488,7 +12753,7 @@ async function collectWorkspaceVersionFindings(root, expectedVersion) {
   ];
   const existing = (await Promise.all(workspacePackages.map(async (rel) => ({
     rel,
-    pkg: await readJson(path44.join(root, rel))
+    pkg: await readJson(path45.join(root, rel))
   })))).filter((item) => item.pkg);
   const isHaiveWorkspace = rootPkg?.name === "haive-monorepo" || existing.some((item) => item.pkg?.name?.startsWith("@hiveai/"));
   if (!isHaiveWorkspace) return findings;
@@ -12550,9 +12815,9 @@ function collectGlobalHivemoduleFindings(expectedVersion) {
   }
 }
 async function readJson(file) {
-  if (!existsSync60(file)) return null;
+  if (!existsSync61(file)) return null;
   try {
-    return JSON.parse(await readFile19(file, "utf8"));
+    return JSON.parse(await readFile20(file, "utf8"));
   } catch {
     return null;
   }
@@ -12588,7 +12853,7 @@ function extractAbsoluteHaiveBins(text) {
     const p = match[2];
     if (!p) continue;
     try {
-      if (statSync(p).isDirectory()) continue;
+      if (statSync2(p).isDirectory()) continue;
     } catch {
     }
     out.add(p);
@@ -12597,22 +12862,22 @@ function extractAbsoluteHaiveBins(text) {
 }
 
 // src/commands/playback.ts
-import { existsSync as existsSync61 } from "fs";
+import { existsSync as existsSync63 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot42,
+  findProjectRoot as findProjectRoot43,
   loadMemoriesFromDir as loadMemoriesFromDir34,
   parseSince as parseSince3,
   readUsageEvents as readUsageEvents5,
-  resolveHaivePaths as resolveHaivePaths38
+  resolveHaivePaths as resolveHaivePaths39
 } 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 = findProjectRoot42(opts.dir);
-    const paths = resolveHaivePaths38(root);
+    const root = findProjectRoot43(opts.dir);
+    const paths = resolveHaivePaths39(root);
     const events = await readUsageEvents5(paths);
     if (events.length === 0) {
       if (opts.json) {
@@ -12627,7 +12892,7 @@ function registerPlayback(program2) {
     const filtered = cutoff > 0 ? events.filter((e) => Date.parse(e.at) >= cutoff) : events;
     const gapMs = Math.max(1, parseInt(opts.sessionGap ?? "30", 10)) * MS_PER_MINUTE;
     const sessions = bucketSessions(filtered, gapMs);
-    const all = existsSync61(paths.memoriesDir) ? await loadMemoriesFromDir34(paths.memoriesDir) : [];
+    const all = existsSync63(paths.memoriesDir) ? await loadMemoriesFromDir34(paths.memoriesDir) : [];
     const memByCreatedAt = all.filter(({ memory: memory2 }) => memory2.frontmatter.type !== "session_recap").map(({ memory: memory2 }) => ({ id: memory2.frontmatter.id, at: Date.parse(memory2.frontmatter.created_at) })).sort((a, b) => a.at - b.at);
     const enriched = sessions.map((s, i) => {
       const startMs = Date.parse(s.start);
@@ -12717,8 +12982,8 @@ function truncate3(text, max) {
 import { spawn as spawn5 } from "child_process";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot43,
-  resolveHaivePaths as resolveHaivePaths39
+  findProjectRoot as findProjectRoot44,
+  resolveHaivePaths as resolveHaivePaths40
 } from "@hiveai/core";
 function registerPrecommit(program2) {
   program2.command("precommit").description(
@@ -12727,9 +12992,12 @@ function registerPrecommit(program2) {
     "--block-on <mode>",
     "'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 = findProjectRoot43(opts.dir);
-    const paths = resolveHaivePaths39(root);
+  ).option("--no-semantic", "disable semantic search in anti-patterns matching").option(
+    "--no-anchored-blocks",
+    "do not block on anchored, diff-corroborated anti-patterns (only block on very strong semantic matches)"
+  ).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 = findProjectRoot44(opts.dir);
+    const paths = resolveHaivePaths40(root);
     const ctx = { paths };
     let diff = "";
     let touchedPaths = opts.paths ?? [];
@@ -12769,6 +13037,7 @@ function registerPrecommit(program2) {
       diff: diff || void 0,
       paths: touchedPaths,
       block_on: opts.blockOn ?? "high-confidence",
+      anchored_blocks: opts.anchoredBlocks !== false,
       semantic: opts.noSemantic ? false : true
     }, ctx);
     if (opts.json) {
@@ -12859,12 +13128,12 @@ function runCommand3(cmd, args, cwd) {
 }
 
 // src/commands/welcome.ts
-import { existsSync as existsSync63 } from "fs";
+import { existsSync as existsSync64 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot44,
+  findProjectRoot as findProjectRoot45,
   loadMemoriesFromDir as loadMemoriesFromDir35,
-  resolveHaivePaths as resolveHaivePaths40
+  resolveHaivePaths as resolveHaivePaths41
 } from "@hiveai/core";
 var TYPE_RANK = {
   skill: 0,
@@ -12879,9 +13148,9 @@ function registerWelcome(program2) {
   program2.command("welcome").description(
     "Onboarding checklist: ranks validated/proposed **team** memories by type.\nUse after `haive init` so new devs skim institutional knowledge quickly.\n\n  haive welcome\n  haive welcome --limit 15\n"
   ).option("--limit <n>", "maximum memories listed", "20").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot44(opts.dir);
-    const paths = resolveHaivePaths40(root);
-    if (!existsSync63(paths.memoriesDir)) {
+    const root = findProjectRoot45(opts.dir);
+    const paths = resolveHaivePaths41(root);
+    if (!existsSync64(paths.memoriesDir)) {
       ui.error(`No memories at ${paths.memoriesDir}. Run 'haive init' first.`);
       process.exitCode = 1;
       return;
@@ -12940,27 +13209,27 @@ function registerMemorySuggestTopic(memory2) {
 }
 
 // src/commands/resolve-project.ts
-import path45 from "path";
+import path46 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: path45.resolve(opts.dir) });
+    const info = resolveProjectInfo2({ cwd: path46.resolve(opts.dir) });
     console.log(JSON.stringify({ ok: true, info }, null, 2));
   });
 }
 
 // src/commands/runtime-journal.ts
-import { existsSync as existsSync64 } from "fs";
-import path46 from "path";
+import { existsSync as existsSync65 } from "fs";
+import path47 from "path";
 import "commander";
 import {
   appendRuntimeJournalEntry as appendRuntimeJournalEntry3,
-  findProjectRoot as findProjectRoot45,
+  findProjectRoot as findProjectRoot46,
   readRuntimeJournalTail as readRuntimeJournalTail2,
-  resolveHaivePaths as resolveHaivePaths41
+  resolveHaivePaths as resolveHaivePaths42
 } from "@hiveai/core";
 function registerRuntime(program2) {
   const runtime = program2.command("runtime").description(
@@ -12968,18 +13237,18 @@ function registerRuntime(program2) {
   );
   const journal = runtime.command("journal").description("Append or read the machine-local session journal (NDJSON)");
   journal.command("append").description("Append one JSON line to .ai/.runtime/session-journal.ndjson").argument("<message>", "short text to log").option("-k, --kind <kind>", "note | session_end | mcp", "note").option("-d, --dir <dir>", "project root", process.cwd()).action(async (message, opts) => {
-    const root = path46.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths41(findProjectRoot45(root));
+    const root = path47.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths42(findProjectRoot46(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 ${path46.relative(root, paths.runtimeDir)}/session-journal.ndjson`);
+    ui.success(`Appended to ${path47.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 = path46.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths41(findProjectRoot45(root));
+    const root = path47.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths42(findProjectRoot46(root));
     const limit = Math.min(500, Math.max(1, parseInt(opts.limit, 10) || 30));
-    if (!existsSync64(paths.haiveDir)) {
+    if (!existsSync65(paths.haiveDir)) {
       ui.error("No .ai/ \u2014 run `haive init` first.");
       process.exitCode = 1;
       return;
@@ -12994,13 +13263,13 @@ function registerRuntime(program2) {
 }
 
 // src/commands/memory-timeline.ts
-import { existsSync as existsSync65 } from "fs";
-import path47 from "path";
+import { existsSync as existsSync66 } from "fs";
+import path48 from "path";
 import "commander";
 import {
   collectTimelineEntries as collectTimelineEntries2,
-  findProjectRoot as findProjectRoot46,
-  resolveHaivePaths as resolveHaivePaths42
+  findProjectRoot as findProjectRoot47,
+  resolveHaivePaths as resolveHaivePaths43
 } from "@hiveai/core";
 function registerMemoryTimeline(memory2) {
   memory2.command("timeline").description(
@@ -13011,9 +13280,9 @@ function registerMemoryTimeline(memory2) {
       process.exitCode = 1;
       return;
     }
-    const root = path47.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths42(findProjectRoot46(root));
-    if (!existsSync65(paths.memoriesDir)) {
+    const root = path48.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths43(findProjectRoot47(root));
+    if (!existsSync66(paths.memoriesDir)) {
       ui.error("No memories \u2014 run `haive init`.");
       process.exitCode = 1;
       return;
@@ -13031,14 +13300,14 @@ function registerMemoryTimeline(memory2) {
 }
 
 // src/commands/memory-conflict-candidates.ts
-import { existsSync as existsSync66 } from "fs";
-import path48 from "path";
+import { existsSync as existsSync67 } from "fs";
+import path49 from "path";
 import "commander";
 import {
   findLexicalConflictPairs as findLexicalConflictPairs2,
   findTopicStatusConflictPairs as findTopicStatusConflictPairs2,
-  findProjectRoot as findProjectRoot47,
-  resolveHaivePaths as resolveHaivePaths43
+  findProjectRoot as findProjectRoot48,
+  resolveHaivePaths as resolveHaivePaths44
 } from "@hiveai/core";
 function parseTypes(csv) {
   const allowed = ["decision", "architecture", "convention", "gotcha"];
@@ -13054,9 +13323,9 @@ function registerMemoryConflictCandidates(memory2) {
     "decision,architecture,convention,gotcha (lexical scan)",
     "decision,architecture"
   ).option("--min-jaccard <x>", "minimum Jaccard for lexical pairs", "0.45").option("--max-pairs <n>", "cap lexical pairs", "20").option("--max-scan <n>", "max memories scanned (lexical)", "500").option("--max-topic-pairs <n>", "cap topic/status pairs", "20").action(async (opts) => {
-    const root = path48.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths43(findProjectRoot47(root));
-    if (!existsSync66(paths.memoriesDir)) {
+    const root = path49.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths44(findProjectRoot48(root));
+    if (!existsSync67(paths.memoriesDir)) {
       ui.error("No memories \u2014 run `haive init`.");
       process.exitCode = 1;
       return;
@@ -13092,20 +13361,20 @@ function registerMemoryConflictCandidates(memory2) {
 
 // src/commands/enforce.ts
 import { execFileSync as execFileSync2, spawn as spawn6 } from "child_process";
-import { existsSync as existsSync67, statSync as statSync2 } from "fs";
-import { chmod as chmod2, mkdir as mkdir19, readFile as readFile20, readdir as readdir6, rm as rm3, writeFile as writeFile33 } from "fs/promises";
-import path49 from "path";
+import { existsSync as existsSync68, statSync as statSync3 } from "fs";
+import { chmod as chmod2, mkdir as mkdir19, readFile as readFile21, readdir as readdir6, rm as rm3, writeFile as writeFile33 } from "fs/promises";
+import path50 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot48,
+  findProjectRoot as findProjectRoot49,
   hasRecentBriefingMarker,
   isFreshIsoDate,
-  loadConfig as loadConfig10,
+  loadConfig as loadConfig11,
   loadMemoriesFromDir as loadMemoriesFromDir36,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths6,
   readRecentBriefingMarker,
   resolveBriefingBudget as resolveBriefingBudget3,
-  resolveHaivePaths as resolveHaivePaths44,
+  resolveHaivePaths as resolveHaivePaths45,
   saveConfig as saveConfig4,
   SESSION_RECAP_TTL_MS,
   verifyAnchor as verifyAnchor4,
@@ -13118,10 +13387,10 @@ 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 = findProjectRoot48(opts.dir);
-    const paths = resolveHaivePaths44(root);
+    const root = findProjectRoot49(opts.dir);
+    const paths = resolveHaivePaths45(root);
     await mkdir19(paths.haiveDir, { recursive: true });
-    const current = await loadConfig10(paths);
+    const current = await loadConfig11(paths);
     await saveConfig4(paths, {
       ...current,
       enforcement: {
@@ -13144,7 +13413,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 (${path49.relative(root, result.settingsPath)})`);
+        ui.success(`${result.created ? "Created" : "Patched"} Claude Code hooks (${path50.relative(root, result.settingsPath)})`);
       } catch (err) {
         ui.warn(`Claude Code hooks not installed: ${err instanceof Error ? err.message : String(err)}`);
       }
@@ -13163,21 +13432,21 @@ 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 = findProjectRoot48(opts.dir);
-    const paths = resolveHaivePaths44(root);
-    const cacheDir = path49.join(paths.haiveDir, ".cache");
-    if (existsSync67(cacheDir)) {
-      if (opts.dryRun) ui.info(`would clean ${path49.relative(root, cacheDir)} (preserving .gitignore)`);
+    const root = findProjectRoot49(opts.dir);
+    const paths = resolveHaivePaths45(root);
+    const cacheDir = path50.join(paths.haiveDir, ".cache");
+    if (existsSync68(cacheDir)) {
+      if (opts.dryRun) ui.info(`would clean ${path50.relative(root, cacheDir)} (preserving .gitignore)`);
       else {
         const removed = await cleanupCacheDir(cacheDir);
-        ui.success(`cleaned ${path49.relative(root, cacheDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
+        ui.success(`cleaned ${path50.relative(root, cacheDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
       }
     }
-    if (existsSync67(paths.runtimeDir)) {
-      if (opts.dryRun) ui.info(`would clean ${path49.relative(root, paths.runtimeDir)} (preserving briefing markers)`);
+    if (existsSync68(paths.runtimeDir)) {
+      if (opts.dryRun) ui.info(`would clean ${path50.relative(root, paths.runtimeDir)} (preserving briefing markers)`);
       else {
         const removed = await cleanupRuntimeDir(paths.runtimeDir);
-        ui.success(`cleaned ${path49.relative(root, paths.runtimeDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
+        ui.success(`cleaned ${path50.relative(root, paths.runtimeDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
       }
     }
   });
@@ -13190,8 +13459,8 @@ function registerEnforce(program2) {
     const payload = await readHookPayload();
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
-    const paths = resolveHaivePaths44(root);
-    if (!existsSync67(paths.haiveDir)) return;
+    const paths = resolveHaivePaths45(root);
+    if (!existsSync68(paths.haiveDir)) return;
     await mkdir19(paths.runtimeDir, { recursive: true });
     const sessionId = opts.sessionId ?? payload.session_id;
     const task = opts.task ?? payload.prompt ?? "Start an AI coding session in this hAIve-initialized project.";
@@ -13253,8 +13522,8 @@ ${briefing.project_context.content.slice(0, 1800)}`);
     const payload = await readHookPayload();
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
-    const paths = resolveHaivePaths44(root);
-    if (!existsSync67(paths.haiveDir)) return;
+    const paths = resolveHaivePaths45(root);
+    if (!existsSync68(paths.haiveDir)) return;
     if (!isWriteLikeTool(payload)) return;
     const ok = await hasRecentBriefingMarker(paths, payload.session_id);
     if (ok) {
@@ -13296,9 +13565,9 @@ ${briefing.project_context.content.slice(0, 1800)}`);
   });
 }
 async function runWithEnforcement(command, args, opts) {
-  const root = findProjectRoot48(opts.dir);
-  const paths = resolveHaivePaths44(root);
-  if (!existsSync67(paths.haiveDir)) {
+  const root = findProjectRoot49(opts.dir);
+  const paths = resolveHaivePaths45(root);
+  if (!existsSync68(paths.haiveDir)) {
     ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
     process.exit(1);
   }
@@ -13317,7 +13586,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 ${path49.relative(root, briefingFile)} and exported as HAIVE_BRIEFING_FILE`);
+  ui.info(`Briefing written to ${path50.relative(root, briefingFile)} and exported as HAIVE_BRIEFING_FILE`);
   const child = spawn6(command, args, {
     cwd: root,
     stdio: "inherit",
@@ -13367,9 +13636,9 @@ async function writeWrapperBriefing(paths, sessionId, task) {
     source: "haive-run",
     memoryIds: briefing.memories.map((m) => m.id)
   });
-  const dir = path49.join(paths.runtimeDir, "enforcement", "briefings");
+  const dir = path50.join(paths.runtimeDir, "enforcement", "briefings");
   await mkdir19(dir, { recursive: true });
-  const file = path49.join(dir, `${sessionId}.md`);
+  const file = path50.join(dir, `${sessionId}.md`);
   const parts = [
     "# hAIve Briefing",
     "",
@@ -13391,10 +13660,10 @@ async function writeWrapperBriefing(paths, sessionId, task) {
   return file;
 }
 async function buildEnforcementReport(dir, stage, sessionId) {
-  const root = findProjectRoot48(dir);
-  const paths = resolveHaivePaths44(root);
-  const initialized = existsSync67(paths.haiveDir);
-  const config = initialized ? await loadConfig10(paths) : {};
+  const root = findProjectRoot49(dir);
+  const paths = resolveHaivePaths45(root);
+  const initialized = existsSync68(paths.haiveDir);
+  const config = initialized ? await loadConfig11(paths) : {};
   if (initialized) await applyLightweightRepairs(root, paths);
   const mode = config.enforcement?.mode ?? "strict";
   const findings = [];
@@ -13424,7 +13693,7 @@ async function buildEnforcementReport(dir, stage, sessionId) {
       findings: [{ severity: "info", code: "enforcement-off", message: "hAIve enforcement is disabled." }]
     });
   }
-  findings.push(...await inspectIntegrationVersions(root, "0.9.28"));
+  findings.push(...await inspectIntegrationVersions(root, "0.9.30"));
   if (config.enforcement?.requireBriefingFirst !== false && stage !== "ci") {
     const hasBriefing = await hasRecentBriefingMarker(paths, sessionId);
     findings.push(hasBriefing ? { severity: "ok", code: "briefing-loaded", message: "A recent hAIve briefing marker exists." } : {
@@ -13458,7 +13727,7 @@ async function buildEnforcementReport(dir, stage, sessionId) {
     findings.push(...await verifyDecisionCoverage(paths, stage, sessionId));
   }
   if (stage === "pre-commit" || stage === "ci") {
-    findings.push(...await runPrecommitPolicy(paths));
+    findings.push(...await runPrecommitPolicy(paths, config.enforcement?.antiPatternGate ?? "anchored"));
   }
   if (config.enforcement?.cleanupGeneratedArtifacts !== false) {
     findings.push(...await findGeneratedArtifacts(paths));
@@ -13494,7 +13763,7 @@ function withCategories(report) {
   };
 }
 async function hasRecentSessionRecap(paths) {
-  if (!existsSync67(paths.memoriesDir)) return false;
+  if (!existsSync68(paths.memoriesDir)) return false;
   const all = await loadMemoriesFromDir36(paths.memoriesDir);
   return all.some(({ memory: memory2 }) => {
     const fm = memory2.frontmatter;
@@ -13503,7 +13772,7 @@ async function hasRecentSessionRecap(paths) {
   });
 }
 async function verifyMemoryPolicy(paths, config) {
-  if (!existsSync67(paths.memoriesDir)) return [];
+  if (!existsSync68(paths.memoriesDir)) return [];
   const all = await loadMemoriesFromDir36(paths.memoriesDir);
   const findings = [];
   const staleImportant = [];
@@ -13541,7 +13810,7 @@ async function verifyMemoryPolicy(paths, config) {
   return findings;
 }
 async function verifyDecisionCoverage(paths, stage, sessionId) {
-  if (!existsSync67(paths.memoriesDir)) return [];
+  if (!existsSync68(paths.memoriesDir)) return [];
   const changedFiles = await getChangedFiles(paths.root, stage);
   if (changedFiles.length === 0) {
     return [{ severity: "info", code: "decision-coverage-no-changes", message: "No changed files to match against policy memories." }];
@@ -13582,7 +13851,10 @@ async function verifyDecisionCoverage(paths, stage, sessionId) {
     impact: Math.min(35, 10 + missing.length * 5)
   }];
 }
-async function runPrecommitPolicy(paths) {
+async function runPrecommitPolicy(paths, gate) {
+  if (gate === "off") {
+    return [{ severity: "info", code: "precommit-policy-off", message: "Anti-pattern gate is disabled (enforcement.antiPatternGate=off)." }];
+  }
   const staged = await runCommand4("git", ["diff", "--cached", "--name-only"], paths.root).catch(() => "");
   const touchedPaths = staged.split("\n").map((s) => s.trim()).filter(Boolean);
   if (touchedPaths.length === 0) {
@@ -13592,7 +13864,8 @@ async function runPrecommitPolicy(paths) {
   const result = await preCommitCheck({
     diff,
     paths: touchedPaths,
-    block_on: "high-confidence",
+    block_on: gate === "strict" ? "any" : "high-confidence",
+    anchored_blocks: gate === "anchored",
     semantic: true
   }, { paths });
   if (!result.should_block) {
@@ -13640,16 +13913,16 @@ async function cleanupRuntimeDir(runtimeDir) {
   for (const entry of entries) {
     if (entry.name === ".gitignore" || entry.name === "README.md") continue;
     if (entry.name === "enforcement") {
-      removed += await cleanupEnforcementDir(path49.join(runtimeDir, entry.name));
+      removed += await cleanupEnforcementDir(path50.join(runtimeDir, entry.name));
       continue;
     }
-    await rm3(path49.join(runtimeDir, entry.name), { recursive: true, force: true });
+    await rm3(path50.join(runtimeDir, entry.name), { recursive: true, force: true });
     removed++;
   }
-  await writeFile33(path49.join(runtimeDir, ".gitignore"), "*\n!.gitignore\n!README.md\n", "utf8");
-  if (!existsSync67(path49.join(runtimeDir, "README.md"))) {
+  await writeFile33(path50.join(runtimeDir, ".gitignore"), "*\n!.gitignore\n!README.md\n", "utf8");
+  if (!existsSync68(path50.join(runtimeDir, "README.md"))) {
     await writeFile33(
-      path49.join(runtimeDir, "README.md"),
+      path50.join(runtimeDir, "README.md"),
       "# .ai/.runtime \u2014 disposable local layer\n\nRuntime data is local. hAIve cleanup preserves briefing markers so enforcement state remains valid.\n",
       "utf8"
     );
@@ -13662,10 +13935,10 @@ async function cleanupCacheDir(cacheDir) {
   const entries = await readdir6(cacheDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.name === ".gitignore") continue;
-    await rm3(path49.join(cacheDir, entry.name), { recursive: true, force: true });
+    await rm3(path50.join(cacheDir, entry.name), { recursive: true, force: true });
     removed++;
   }
-  await writeFile33(path49.join(cacheDir, ".gitignore"), "*\n!.gitignore\n", "utf8");
+  await writeFile33(path50.join(cacheDir, ".gitignore"), "*\n!.gitignore\n", "utf8");
   return removed;
 }
 async function cleanupEnforcementDir(enforcementDir) {
@@ -13673,7 +13946,7 @@ async function cleanupEnforcementDir(enforcementDir) {
   const entries = await readdir6(enforcementDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.name === "briefings") continue;
-    await rm3(path49.join(enforcementDir, entry.name), { recursive: true, force: true });
+    await rm3(path50.join(enforcementDir, entry.name), { recursive: true, force: true });
     removed++;
   }
   return removed;
@@ -13689,9 +13962,9 @@ async function inspectIntegrationVersions(root, expectedVersion) {
   ];
   const findings = [];
   for (const rel of files) {
-    const file = path49.join(root, rel);
-    if (!existsSync67(file)) continue;
-    const text = await readFile20(file, "utf8").catch(() => "");
+    const file = path50.join(root, rel);
+    if (!existsSync68(file)) continue;
+    const text = await readFile21(file, "utf8").catch(() => "");
     for (const bin of extractAbsoluteHaiveBins2(text)) {
       const version = versionForBinary2(bin);
       if (!version) {
@@ -13730,7 +14003,7 @@ function extractAbsoluteHaiveBins2(text) {
     const p = match[2];
     if (!p) continue;
     try {
-      if (statSync2(p).isDirectory()) continue;
+      if (statSync3(p).isDirectory()) continue;
     } catch {
     }
     out.add(p);
@@ -13785,8 +14058,8 @@ function buildScore(findings, threshold = 80) {
   };
 }
 async function installGitEnforcement(root) {
-  const hooksDir = path49.join(root, ".git", "hooks");
-  if (!existsSync67(path49.join(root, ".git"))) {
+  const hooksDir = path50.join(root, ".git", "hooks");
+  if (!existsSync68(path50.join(root, ".git"))) {
     ui.warn("No .git directory found; git enforcement hooks skipped.");
     return;
   }
@@ -13808,9 +14081,9 @@ haive enforce check --stage pre-push --dir . || exit $?
     }
   ];
   for (const hook of hooks) {
-    const file = path49.join(hooksDir, hook.name);
-    if (existsSync67(file)) {
-      const current = await readFile20(file, "utf8").catch(() => "");
+    const file = path50.join(hooksDir, hook.name);
+    if (existsSync68(file)) {
+      const current = await readFile21(file, "utf8").catch(() => "");
       if (current.includes(ENFORCE_HOOK_MARKER)) {
         await writeFile33(file, hook.body, "utf8");
       } else {
@@ -13826,9 +14099,9 @@ ${hook.body}`, "utf8");
   ui.success("Installed blocking git enforcement hooks: pre-commit, pre-push");
 }
 async function installCiEnforcement(root) {
-  const workflowPath = path49.join(root, ".github", "workflows", "haive-enforcement.yml");
-  await mkdir19(path49.dirname(workflowPath), { recursive: true });
-  if (existsSync67(workflowPath)) {
+  const workflowPath = path50.join(root, ".github", "workflows", "haive-enforcement.yml");
+  await mkdir19(path50.dirname(workflowPath), { recursive: true });
+  if (existsSync68(workflowPath)) {
     ui.info("GitHub Actions enforcement workflow already exists \u2014 skipped");
     return;
   }
@@ -13856,7 +14129,7 @@ jobs:
       - name: Enforce hAIve policy
         run: haive enforce ci
 `, "utf8");
-  ui.success(`Created ${path49.relative(root, workflowPath)}`);
+  ui.success(`Created ${path50.relative(root, workflowPath)}`);
 }
 function printReport(report, json, explain = false) {
   if (json) {
@@ -13916,7 +14189,7 @@ async function readHookPayload() {
 }
 function resolveRoot(dir, payload) {
   try {
-    return findProjectRoot48(dir ?? payload.cwd);
+    return findProjectRoot49(dir ?? payload.cwd);
   } catch {
     return null;
   }
@@ -13953,11 +14226,11 @@ function extractToolPaths(payload, root) {
 }
 function normalizeToolPath(file, root) {
   const normalized = file.replace(/\\/g, "/");
-  if (!path49.isAbsolute(normalized)) return normalized.replace(/^\.\//, "");
-  return path49.relative(root, normalized).replace(/\\/g, "/");
+  if (!path50.isAbsolute(normalized)) return normalized.replace(/^\.\//, "");
+  return path50.relative(root, normalized).replace(/\\/g, "/");
 }
 async function missingRequiredMemoriesForFiles(paths, files, sessionId) {
-  if (!existsSync67(paths.memoriesDir)) return [];
+  if (!existsSync68(paths.memoriesDir)) return [];
   const marker = await readRecentBriefingMarker(paths, sessionId);
   const consulted = new Set(marker?.memory_ids ?? []);
   const policyTypes = /* @__PURE__ */ new Set(["decision", "gotcha", "architecture", "convention", "attempt"]);
@@ -14030,8 +14303,8 @@ function registerRun(program2) {
 }
 
 // src/index.ts
-var program = new Command51();
-program.name("haive").description("hAIve \u2014 the memory and enforcement layer of your agent harness").version("0.9.28").option("--advanced", "show maintenance and experimental commands in help");
+var program = new Command52();
+program.name("haive").description("hAIve \u2014 the memory and enforcement layer of your agent harness").version("0.9.30").option("--advanced", "show maintenance and experimental commands in help");
 registerInit(program);
 registerWelcome(program);
 registerResolveProject(program);
@@ -14065,6 +14338,7 @@ registerMemoryApprove(memory);
 registerMemoryUpdate(memory);
 registerMemoryHot(memory);
 registerMemoryTried(memory);
+registerMemorySeed(memory);
 registerMemoryImport(memory);
 registerMemoryImportChangelog(memory);
 registerMemoryDigest(memory);