@hiveai/cli 0.5.0 → 0.7.0

package/dist/index.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command35 } from "commander";
+import { Command as Command39 } from "commander";
 
 // src/commands/briefing.ts
 import { existsSync } from "fs";
 import { readFile } from "fs/promises";
+import path from "path";
 import "commander";
 import {
   findProjectRoot,
@@ -58,7 +59,12 @@ function registerBriefing(program2) {
     "--scope <scope>",
     "personal | team | shared | all (default: all \u2014 includes team + shared cross-repo memories)",
     "all"
-  ).option("--include-draft", "include draft memories (excluded by default)").option("--include-stale", "include stale memories (excluded by default \u2014 may be outdated)").option("-d, --dir <dir>", "project root").action(async (opts) => {
+  ).option("--include-draft", "include draft memories (excluded by default)").option("--include-stale", "include stale memories (excluded by default \u2014 may be outdated)").option(
+    "--include <path>",
+    "merge memories from another haive-initialized project (repeatable). Useful for teams with multiple coordinated repos (e.g. backend + frontend).",
+    collectInclude,
+    []
+  ).option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot(opts.dir);
     const paths = resolveHaivePaths(root);
     if (!existsSync(paths.memoriesDir)) {
@@ -71,7 +77,34 @@ function registerBriefing(program2) {
       }
       return;
     }
-    const all = await loadMemoriesFromDir(paths.memoriesDir);
+    const ownMemories = await loadMemoriesFromDir(paths.memoriesDir);
+    const externalRoots = [];
+    if (opts.include && opts.include.length > 0) {
+      for (const includePath of opts.include) {
+        try {
+          const otherRoot = findProjectRoot(includePath);
+          if (otherRoot === root) continue;
+          const otherPaths = resolveHaivePaths(otherRoot);
+          if (!existsSync(otherPaths.memoriesDir)) {
+            ui.warn(`--include ${includePath}: no .ai/memories at ${otherRoot} \u2014 skipping`);
+            continue;
+          }
+          const otherMemories = await loadMemoriesFromDir(otherPaths.memoriesDir);
+          const tag = path.basename(otherRoot);
+          for (const m of otherMemories) {
+            ownMemories.push({ ...m, origin: tag });
+          }
+          externalRoots.push(`${tag} (${otherMemories.length})`);
+        } catch (err) {
+          ui.warn(`--include ${includePath}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+      if (externalRoots.length > 0) {
+        ui.info(`merged from: ${externalRoots.join(", ")}`);
+        console.log();
+      }
+    }
+    const all = ownMemories;
     const filePaths = parseCsv(opts.files);
     const tokens = opts.task ? tokenizeQuery(opts.task) : null;
     const maxMemories = Math.max(1, Number(opts.maxMemories ?? 10));
@@ -148,15 +181,16 @@ function registerBriefing(program2) {
     }
     console.log(`${ui.bold("=== Relevant Memories ===")}
 `);
-    for (const { memory: mem } of top) {
-      const fm = mem.frontmatter;
+    for (const item of top) {
+      const fm = item.memory.frontmatter;
       const badge = ui.statusBadge(fm.status);
       const draftMarker = fm.status === "draft" ? ui.yellow(" [DRAFT]") : "";
       const unverifiedMarker = fm.status === "proposed" ? ui.yellow(" [UNVERIFIED]") : "";
+      const originMarker = item.origin ? ` ${ui.yellow("[from " + item.origin + "]")}` : "";
       console.log(
-        `${ui.bold(fm.id)}  ${ui.dim(fm.scope + "/" + fm.type)}  ${badge}${draftMarker}${unverifiedMarker}`
+        `${ui.bold(fm.id)}  ${ui.dim(fm.scope + "/" + fm.type)}  ${badge}${draftMarker}${unverifiedMarker}${originMarker}`
       );
-      console.log(mem.body.trim());
+      console.log(item.memory.body.trim());
       console.log();
     }
     console.log(ui.dim(`${top.length} memor${top.length === 1 ? "y" : "ies"} surfaced`));
@@ -199,6 +233,9 @@ function parseCsv(value) {
   if (!value) return [];
   return value.split(",").map((s) => s.trim()).filter(Boolean);
 }
+function collectInclude(value, previous) {
+  return [...previous, value];
+}
 
 // src/commands/tui.ts
 import "commander";
@@ -223,7 +260,7 @@ function registerTui(program2) {
 
 // src/commands/embeddings.ts
 import { existsSync as existsSync2 } from "fs";
-import path from "path";
+import path2 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot3, resolveHaivePaths as resolveHaivePaths2 } from "@hiveai/core";
 function registerEmbeddings(program2) {
@@ -265,22 +302,22 @@ function registerEmbeddings(program2) {
     for (const hit of result.hits) {
       const score = hit.score.toFixed(3);
       console.log(`${ui.bold(score)}  ${hit.id}`);
-      console.log(`       ${ui.dim(path.relative(root, hit.file_path))}`);
+      console.log(`       ${ui.dim(path2.relative(root, hit.file_path))}`);
     }
   });
   embeddings.command("status").description("Show the embeddings index status").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot3(opts.dir);
     const paths = resolveHaivePaths2(root);
     const { indexStat } = await loadEmbeddings();
-    const stat = await indexStat(paths);
-    if (!stat.exists) {
+    const stat2 = await indexStat(paths);
+    if (!stat2.exists) {
       ui.warn("No embeddings index. Run `haive embeddings index` to create one.");
       return;
     }
-    console.log(`${ui.bold("entries:")}    ${stat.count}`);
-    console.log(`${ui.bold("model:")}      ${stat.model}`);
-    console.log(`${ui.bold("updated_at:")} ${stat.updatedAt}`);
-    console.log(`${ui.bold("size:")}       ${(stat.sizeBytes / 1024).toFixed(1)} KB`);
+    console.log(`${ui.bold("entries:")}    ${stat2.count}`);
+    console.log(`${ui.bold("model:")}      ${stat2.model}`);
+    console.log(`${ui.bold("updated_at:")} ${stat2.updatedAt}`);
+    console.log(`${ui.bold("size:")}       ${(stat2.sizeBytes / 1024).toFixed(1)} KB`);
   });
 }
 async function loadEmbeddings() {
@@ -295,7 +332,7 @@ async function loadEmbeddings() {
 }
 
 // src/commands/index-code.ts
-import path2 from "path";
+import path3 from "path";
 import "commander";
 import {
   buildCodeMap,
@@ -338,7 +375,7 @@ function registerIndexCode(program2) {
     const fileCount = Object.keys(map.files).length;
     const exportCount = Object.values(map.files).reduce((s, f) => s + f.exports.length, 0);
     ui.success(
-      `Indexed ${fileCount} file(s) with ${exportCount} export(s) \u2192 ${path2.relative(root, codeMapPath(paths))}`
+      `Indexed ${fileCount} file(s) with ${exportCount} export(s) \u2192 ${path3.relative(root, codeMapPath(paths))}`
     );
   });
   idx.command("code-search").description(
@@ -371,9 +408,9 @@ function registerIndexCode(program2) {
 }
 
 // src/commands/init.ts
-import { mkdir, writeFile } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
-import path3 from "path";
+import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import path7 from "path";
 import { spawnSync } from "child_process";
 import "commander";
 import {
@@ -383,9 +420,719 @@ import {
   saveCodeMap as saveCodeMap2,
   saveConfig
 } from "@hiveai/core";
+
+// src/commands/init-bootstrap.ts
+import { readdir, readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import path4 from "path";
+var IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  ".git",
+  "coverage",
+  ".turbo",
+  "out",
+  ".cache",
+  "tmp",
+  "temp",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "target",
+  ".gradle"
+]);
+var FRAMEWORK_SIGNALS = {
+  "NestJS": ["@nestjs/core", "@nestjs/common"],
+  "Next.js": ["next"],
+  "Remix": ["@remix-run/react", "@remix-run/node"],
+  "React": ["react", "react-dom"],
+  "Vue": ["vue"],
+  "Svelte": ["svelte"],
+  "SvelteKit": ["@sveltejs/kit"],
+  "Astro": ["astro"],
+  "Express": ["express"],
+  "Fastify": ["fastify"],
+  "Hono": ["hono"],
+  "tRPC": ["@trpc/server"],
+  "Prisma": ["@prisma/client"],
+  "Drizzle": ["drizzle-orm"],
+  "Vite": ["vite"],
+  "Vitest": ["vitest"],
+  "Jest": ["jest"]
+};
+var KEY_DEPS = [
+  "@nestjs/jwt",
+  "@nestjs/passport",
+  "passport-jwt",
+  "jsonwebtoken",
+  "bcrypt",
+  "bcryptjs",
+  "stripe",
+  "axios",
+  "socket.io",
+  "ws",
+  "redis",
+  "ioredis",
+  "pg",
+  "mysql2",
+  "mongodb",
+  "mongoose",
+  "zod",
+  "yup",
+  "class-validator",
+  "tailwindcss",
+  "shadcn",
+  "@radix-ui",
+  "@vercel/ai",
+  "ai",
+  "openai",
+  "@anthropic-ai/sdk",
+  "typescript"
+];
+function detectFrameworks(allDeps) {
+  const found = [];
+  for (const [fw, signals] of Object.entries(FRAMEWORK_SIGNALS)) {
+    if (signals.some((s) => allDeps[s] !== void 0)) found.push(fw);
+  }
+  return found;
+}
+function detectKeyDeps(allDeps) {
+  return KEY_DEPS.filter((d) => allDeps[d] !== void 0);
+}
+function detectLanguage(root) {
+  if (existsSync3(path4.join(root, "tsconfig.json"))) return "TypeScript";
+  if (existsSync3(path4.join(root, "pyproject.toml")) || existsSync3(path4.join(root, "setup.py"))) return "Python";
+  if (existsSync3(path4.join(root, "go.mod"))) return "Go";
+  if (existsSync3(path4.join(root, "pom.xml")) || existsSync3(path4.join(root, "build.gradle"))) return "Java/Kotlin";
+  if (existsSync3(path4.join(root, "Cargo.toml"))) return "Rust";
+  if (existsSync3(path4.join(root, "package.json"))) return "JavaScript";
+  return "Unknown";
+}
+function detectProjectType(frameworks, scripts) {
+  if (frameworks.includes("NestJS")) return "Backend API (NestJS)";
+  if (frameworks.includes("Next.js")) return "Full-stack web app (Next.js)";
+  if (frameworks.includes("Remix")) return "Full-stack web app (Remix)";
+  if (frameworks.includes("Express") || frameworks.includes("Fastify") || frameworks.includes("Hono")) return "Backend API";
+  if (frameworks.includes("React") || frameworks.includes("Vue") || frameworks.includes("Svelte")) return "Frontend SPA";
+  if (scripts["build"] && !scripts["dev"]) return "CLI tool / library";
+  if (existsSync3("pom.xml")) return "Java backend";
+  return "Application";
+}
+async function scanDirs(root, maxDepth = 2) {
+  const results = [];
+  async function walk(dir, depth) {
+    if (depth > maxDepth) return;
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (IGNORE_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
+      const rel = path4.relative(root, path4.join(dir, entry.name));
+      results.push(rel);
+      await walk(path4.join(dir, entry.name), depth + 1);
+    }
+  }
+  await walk(root, 0);
+  return results;
+}
+function inferModuleDescriptions(dirs) {
+  const known = {
+    "src": "main source directory",
+    "app": "application entrypoint / routes (Next.js App Router or similar)",
+    "pages": "file-based routing pages",
+    "components": "reusable UI components",
+    "lib": "shared utilities and helpers",
+    "utils": "utility functions",
+    "hooks": "React hooks",
+    "services": "business logic services",
+    "controllers": "HTTP controllers / route handlers",
+    "modules": "feature modules",
+    "middleware": "HTTP or business middleware",
+    "guards": "auth / access guards",
+    "prisma": "Prisma schema and migrations",
+    "migrations": "database migrations",
+    "config": "configuration files",
+    "types": "TypeScript type definitions",
+    "schemas": "validation schemas (Zod / class-validator)",
+    "test": "tests",
+    "tests": "tests",
+    "__tests__": "tests",
+    "e2e": "end-to-end tests",
+    "public": "static public assets",
+    "assets": "static assets",
+    "styles": "global CSS / style files",
+    "scripts": "build or utility scripts",
+    "docs": "documentation",
+    "docker": "Docker configuration",
+    "infra": "infrastructure / IaC",
+    "packages": "monorepo sub-packages",
+    "functions": "serverless / edge functions",
+    "api": "API routes or client",
+    "store": "state management (Redux / Zustand / Pinia)",
+    "context": "React contexts",
+    "server": "server-side code",
+    "client": "client-side code",
+    "features": "feature-based modules",
+    "routes": "route definitions",
+    "workers": "background workers / queues"
+  };
+  const top = dirs.filter((d) => !d.includes("/")).slice(0, 12);
+  return top.map((d) => {
+    const desc = known[d.toLowerCase()] ?? "module";
+    return `- \`${d}/\` \u2014 ${desc}`;
+  });
+}
+function readmeExcerpt(readme) {
+  const lines = readme.split("\n");
+  let inContent = false;
+  const kept = [];
+  for (const line of lines) {
+    if (!inContent && line.trim().startsWith("#")) {
+      inContent = true;
+      continue;
+    }
+    if (!inContent) continue;
+    if (kept.length >= 6) break;
+    if (line.trim()) kept.push(line.trim());
+  }
+  return kept.join(" ").slice(0, 400);
+}
+async function generateBootstrapContext(root) {
+  let pkg = {};
+  const pkgPath = path4.join(root, "package.json");
+  if (existsSync3(pkgPath)) {
+    try {
+      pkg = JSON.parse(await readFile2(pkgPath, "utf8"));
+    } catch {
+    }
+  }
+  const allDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+  const frameworks = detectFrameworks(allDeps);
+  const keyDeps = detectKeyDeps(allDeps);
+  const language = detectLanguage(root);
+  const projectType = detectProjectType(frameworks, pkg.scripts ?? {});
+  const projectName = pkg.name ?? path4.basename(root);
+  const projectDesc = pkg.description ?? "";
+  let readmeSummary = "";
+  for (const name of ["README.md", "readme.md", "README"]) {
+    const p = path4.join(root, name);
+    if (existsSync3(p)) {
+      try {
+        const content = await readFile2(p, "utf8");
+        readmeSummary = readmeExcerpt(content);
+        break;
+      } catch {
+      }
+    }
+  }
+  const dirs = await scanDirs(root, 2);
+  const moduleLines = inferModuleDescriptions(dirs);
+  const scripts = pkg.scripts ?? {};
+  const scriptLines = Object.entries(scripts).filter(([k]) => ["build", "dev", "start", "test", "lint", "deploy"].includes(k)).map(([k, v]) => `- \`${k}\`: ${v}`).slice(0, 6);
+  const stackParts = [language];
+  if (frameworks.length) stackParts.push(...frameworks);
+  const techStack = stackParts.join(", ");
+  const notableDeps = Object.keys(allDeps).filter((d) => !d.startsWith("@types/") && !["typescript", "eslint", "prettier", "jest"].includes(d)).filter((d) => !["react", "react-dom", "next", "vue", "express"].includes(d)).slice(0, 10).map((d) => `\`${d}\``);
+  const lines = [
+    `# Project context \u2014 ${projectName}`,
+    "",
+    `> Auto-generated by \`haive init --bootstrap\`. Review and refine \u2014 especially the Architecture and Gotchas sections.`,
+    "",
+    `## Overview`,
+    `**Type:** ${projectType}`,
+    `**Tech stack:** ${techStack}`,
+    ...projectDesc ? [`**Description:** ${projectDesc}`] : [],
+    ...readmeSummary ? [`**From README:** ${readmeSummary}`] : [],
+    "",
+    `## Architecture`,
+    `TODO \u2014 fill in the high-level architecture (inferred structure below, verify manually):`,
+    "",
+    ...moduleLines.length ? moduleLines : ["TODO \u2014 no clear structure detected."],
+    "",
+    `## Key modules`,
+    `TODO \u2014 describe the purpose of the main modules. The directory scan found:`,
+    ...dirs.filter((d) => !d.includes("/")).slice(0, 8).map((d) => `- \`${d}/\``),
+    "",
+    `## Conventions`,
+    `TODO \u2014 fill in coding conventions (naming, patterns, file layout).`,
+    "",
+    ...scriptLines.length ? [
+      `**Available scripts:**`,
+      ...scriptLines,
+      ""
+    ] : [],
+    ...keyDeps.length ? [
+      `**Key dependencies in use:** ${keyDeps.map((d) => `\`${d}\``).join(", ")}`,
+      ""
+    ] : [],
+    ...notableDeps.length ? [
+      `**Other notable packages:** ${notableDeps.join(", ")}`,
+      ""
+    ] : [],
+    `## Glossary`,
+    `TODO \u2014 domain terms and what they mean here.`,
+    "",
+    `## Gotchas`,
+    `TODO \u2014 known traps, surprising behavior, things newcomers stub their toes on.`,
+    `(Run \`haive memory import-changelog\` or \`haive memory import README.md\` to seed these automatically.)`,
+    ""
+  ];
+  return lines.join("\n");
+}
+
+// src/commands/init-mcp-setup.ts
+import { readFile as readFile3, writeFile, mkdir } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import path5 from "path";
+import os from "os";
+var HOME = os.homedir();
+var HAIVE_MCP_ENTRY = {
+  command: "haive-mcp",
+  args: []
+};
+function cursorMcpPath() {
+  return path5.join(HOME, ".cursor", "mcp.json");
+}
+async function configureCursor() {
+  const mcpPath = cursorMcpPath();
+  const cursorDir = path5.join(HOME, ".cursor");
+  if (!existsSync4(cursorDir)) return { client: "Cursor", status: "not_installed" };
+  let config = {};
+  if (existsSync4(mcpPath)) {
+    try {
+      config = JSON.parse(await readFile3(mcpPath, "utf8"));
+    } catch {
+    }
+  }
+  config.mcpServers ??= {};
+  if (config.mcpServers["haive"]) return { client: "Cursor", status: "already_configured" };
+  config.mcpServers["haive"] = HAIVE_MCP_ENTRY;
+  await mkdir(cursorDir, { recursive: true });
+  await writeFile(mcpPath, JSON.stringify(config, null, 2), "utf8");
+  return { client: "Cursor", status: "configured", path: mcpPath };
+}
+function vscodeMcpPath() {
+  const candidates = [
+    path5.join(HOME, ".config", "Code", "User", "mcp.json"),
+    // Linux
+    path5.join(HOME, "Library", "Application Support", "Code", "User", "mcp.json"),
+    // macOS
+    path5.join(HOME, "AppData", "Roaming", "Code", "User", "mcp.json"),
+    // Windows
+    path5.join(HOME, ".config", "Code - Insiders", "User", "mcp.json")
+  ];
+  for (const c of candidates) {
+    if (existsSync4(path5.dirname(c))) return c;
+  }
+  return null;
+}
+async function configureVSCode() {
+  const mcpPath = vscodeMcpPath();
+  if (!mcpPath) return { client: "VS Code", status: "not_installed" };
+  let config = {};
+  if (existsSync4(mcpPath)) {
+    try {
+      config = JSON.parse(await readFile3(mcpPath, "utf8"));
+    } catch {
+    }
+  }
+  config.servers ??= {};
+  if (config.servers["haive"]) return { client: "VS Code", status: "already_configured" };
+  config.servers["haive"] = { ...HAIVE_MCP_ENTRY, type: "stdio" };
+  await mkdir(path5.dirname(mcpPath), { recursive: true });
+  await writeFile(mcpPath, JSON.stringify(config, null, 2), "utf8");
+  return { client: "VS Code", status: "configured", path: mcpPath };
+}
+function claudeConfigPath() {
+  const p = path5.join(HOME, ".claude.json");
+  if (existsSync4(p)) return p;
+  const p2 = path5.join(HOME, ".config", "claude", "claude.json");
+  if (existsSync4(path5.dirname(p2))) return p2;
+  return null;
+}
+async function configureClaude() {
+  const cfgPath = claudeConfigPath() ?? path5.join(HOME, ".claude.json");
+  if (!existsSync4(cfgPath) && !existsSync4(path5.join(HOME, ".claude"))) {
+    return { client: "Claude Code", status: "not_installed" };
+  }
+  let config = {};
+  if (existsSync4(cfgPath)) {
+    try {
+      config = JSON.parse(await readFile3(cfgPath, "utf8"));
+    } catch {
+    }
+  }
+  config.mcpServers ??= {};
+  if (config.mcpServers["haive"]) return { client: "Claude Code", status: "already_configured" };
+  config.mcpServers["haive"] = { ...HAIVE_MCP_ENTRY, type: "stdio" };
+  await writeFile(cfgPath, JSON.stringify(config, null, 2), "utf8");
+  return { client: "Claude Code", status: "configured", path: cfgPath };
+}
+function windsurfMcpPath() {
+  const candidates = [
+    path5.join(HOME, ".codeium", "windsurf", "mcp_config.json"),
+    path5.join(HOME, ".windsurf", "mcp.json")
+  ];
+  for (const c of candidates) {
+    if (existsSync4(path5.dirname(c))) return c;
+  }
+  return null;
+}
+async function configureWindsurf() {
+  const mcpPath = windsurfMcpPath();
+  if (!mcpPath) return { client: "Windsurf", status: "not_installed" };
+  let config = {};
+  if (existsSync4(mcpPath)) {
+    try {
+      config = JSON.parse(await readFile3(mcpPath, "utf8"));
+    } catch {
+    }
+  }
+  config.mcpServers ??= {};
+  if (config.mcpServers["haive"]) return { client: "Windsurf", status: "already_configured" };
+  config.mcpServers["haive"] = HAIVE_MCP_ENTRY;
+  await mkdir(path5.dirname(mcpPath), { recursive: true });
+  await writeFile(mcpPath, JSON.stringify(config, null, 2), "utf8");
+  return { client: "Windsurf", status: "configured", path: mcpPath };
+}
+async function autoConfigureMcpClients() {
+  const results = [];
+  const configurators = [configureCursor, configureVSCode, configureClaude, configureWindsurf];
+  for (const fn of configurators) {
+    try {
+      results.push(await fn());
+    } catch (err) {
+      const name = fn.name.replace("configure", "");
+      results.push({ client: name, status: "error", error: String(err) });
+    }
+  }
+  return results;
+}
+
+// src/commands/init-stack-packs.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import path6 from "path";
+import {
+  buildFrontmatter,
+  memoryFilePath,
+  serializeMemory
+} from "@hiveai/core";
+var PACKS = {
+  nestjs: [
+    {
+      slug: "jwtmodule-requires-secret",
+      type: "gotcha",
+      tags: ["auth", "jwt", "nestjs"],
+      body: `JwtModule must be registered with an explicit secret \u2014 there is no default.
+
+\`\`\`ts
+JwtModule.register({ secret: process.env.JWT_SECRET, signOptions: { expiresIn: '7d' } })
+\`\`\`
+
+Without a secret, tokens are signed with an empty string and any client can forge them.
+Always load the secret from env and validate it is defined at startup.`
+    },
+    {
+      slug: "global-validation-pipe",
+      type: "convention",
+      tags: ["validation", "nestjs", "security"],
+      body: `Register ValidationPipe globally in main.ts, not per-controller.
+
+\`\`\`ts
+app.useGlobalPipes(new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true }));
+\`\`\`
+
+- \`whitelist: true\` strips unknown properties silently
+- \`forbidNonWhitelisted: true\` throws 400 on unknown fields (safer)
+- Without this, NestJS passes unvalidated payloads to handlers.`
+    },
+    {
+      slug: "nestjs-no-direct-orm-in-controller",
+      type: "convention",
+      tags: ["architecture", "nestjs"],
+      body: `Controllers must never import Prisma/TypeORM directly \u2014 that belongs in Services.
+
+Controller \u2192 Service \u2192 Repository (or direct ORM) is the required layering.
+Direct ORM usage in controllers makes testing impossible and couples transport to persistence.`
+    },
+    {
+      slug: "nestjs-exception-filter-for-prisma",
+      type: "gotcha",
+      tags: ["error-handling", "nestjs", "prisma"],
+      body: `Prisma errors bubble up as unhandled 500s without a custom exception filter.
+
+Create an \`AllExceptionsFilter\` or a specific \`PrismaClientExceptionFilter\` that maps:
+- P2002 (unique constraint) \u2192 409 Conflict
+- P2025 (record not found) \u2192 404 Not Found
+- P2003 (foreign key) \u2192 422 Unprocessable
+
+Without this, clients receive raw Prisma error messages which may leak schema info.`
+    }
+  ],
+  nextjs: [
+    {
+      slug: "server-components-no-client-hooks",
+      type: "gotcha",
+      tags: ["nextjs", "react", "server-components"],
+      body: `Server Components cannot use useState, useEffect, or any browser APIs.
+
+Add \`"use client"\` at the top of any component that needs hooks or event handlers.
+The boundary propagates down \u2014 children of a client component don't need the directive.
+
+Common mistake: importing a client-only library (e.g. framer-motion) in a server component
+causes a cryptic runtime error. Check for browser globals (window, document, localStorage).`
+    },
+    {
+      slug: "nextjs-env-client-exposure",
+      type: "gotcha",
+      tags: ["security", "nextjs", "env"],
+      body: `Only environment variables prefixed with NEXT_PUBLIC_ are exposed to the browser.
+
+Never put secrets in NEXT_PUBLIC_* variables \u2014 they are bundled into the client JS.
+Variables without the prefix are server-only and safe for API keys, database URLs, etc.`
+    },
+    {
+      slug: "nextjs-fetch-cache-defaults",
+      type: "gotcha",
+      tags: ["nextjs", "caching", "fetch"],
+      body: `In Next.js App Router, \`fetch()\` is cached indefinitely by default in Server Components.
+
+Add \`{ cache: 'no-store' }\` for dynamic data, or \`{ next: { revalidate: 60 } }\` for ISR.
+Forgetting this means stale data is returned after a deploy until the cache expires.`
+    },
+    {
+      slug: "nextjs-metadata-api",
+      type: "convention",
+      tags: ["nextjs", "seo"],
+      body: `Use the Metadata API (export const metadata / generateMetadata) instead of <Head>.
+
+\`<Head>\` from next/head still works in pages/ but is not supported in the App Router.
+Use \`generateMetadata\` for dynamic titles/descriptions based on route params.`
+    }
+  ],
+  remix: [
+    {
+      slug: "remix-loader-vs-action",
+      type: "convention",
+      tags: ["remix", "architecture"],
+      body: `loader = GET data for rendering. action = handle form submissions / mutations.
+
+- \`loader\` runs on every GET request (server-side, returns data for the component)
+- \`action\` runs on POST/PUT/DELETE (mutations \u2014 redirect after success)
+- Never fetch inside the component itself for route data \u2014 use the loader instead.`
+    },
+    {
+      slug: "remix-error-boundaries",
+      type: "gotcha",
+      tags: ["remix", "error-handling"],
+      body: `Each route should export an ErrorBoundary to catch loader/action errors gracefully.
+
+Without it, errors bubble to the root boundary and replace the entire page.
+Export \`export function ErrorBoundary() { ... }\` to scope errors to the route.`
+    }
+  ],
+  react: [
+    {
+      slug: "useeffect-cleanup",
+      type: "gotcha",
+      tags: ["react", "memory-leak"],
+      body: `useEffect subscriptions, timers, and async operations need cleanup to avoid memory leaks.
+
+\`\`\`ts
+useEffect(() => {
+  const controller = new AbortController();
+  fetchData({ signal: controller.signal });
+  return () => controller.abort(); // cleanup
+}, [dep]);
+\`\`\`
+
+Missing cleanup causes: state updates on unmounted components, duplicate subscriptions,
+and event listeners that accumulate across re-renders.`
+    },
+    {
+      slug: "react-key-prop-in-lists",
+      type: "gotcha",
+      tags: ["react", "performance"],
+      body: `Keys must be stable, unique IDs \u2014 never use array index as key.
+
+Using index as key causes React to re-render wrong items on reorder/filter,
+corrupts form state, and triggers avoidable DOM mutations.
+Use item.id or a stable hash \u2014 never Math.random().`
+    },
+    {
+      slug: "react-avoid-use-effect-for-derived-state",
+      type: "convention",
+      tags: ["react", "state"],
+      body: `Don't use useEffect to sync state from props \u2014 compute it during render instead.
+
+\`\`\`ts
+// \u274C Bad
+const [fullName, setFullName] = useState('');
+useEffect(() => { setFullName(first + ' ' + last); }, [first, last]);
+
+// \u2705 Good
+const fullName = first + ' ' + last; // derived during render
+\`\`\``
+    }
+  ],
+  express: [
+    {
+      slug: "express-missing-validation",
+      type: "gotcha",
+      tags: ["security", "express", "validation"],
+      body: `Express does not validate request bodies by default \u2014 always validate with zod, joi, or express-validator.
+
+Without validation:
+- req.body fields are \`any\` and may be missing, wrong type, or injected
+- Downstream code crashes or processes malicious data
+Add a validation middleware for every route that accepts user input.`
+    },
+    {
+      slug: "express-async-error-propagation",
+      type: "gotcha",
+      tags: ["express", "error-handling"],
+      body: `Async route handlers don't propagate errors to error middleware without explicit next(err).
+
+\`\`\`ts
+// \u274C Unhandled \u2014 Express never sees the rejection
+app.get('/', async (req, res) => { throw new Error('oops'); });
+
+// \u2705 Correct
+app.get('/', async (req, res, next) => {
+  try { await doWork(); }
+  catch (err) { next(err); }
+});
+\`\`\`
+Or use express-async-errors / wrap helper.`
+    }
+  ],
+  fastify: [
+    {
+      slug: "fastify-schema-validation-required",
+      type: "convention",
+      tags: ["fastify", "validation", "security"],
+      body: `Always define a JSON schema on routes \u2014 Fastify validates and coerces automatically.
+
+\`\`\`ts
+fastify.post('/users', {
+  schema: { body: { type: 'object', required: ['email'], properties: { email: { type: 'string', format: 'email' } } } }
+}, handler)
+\`\`\`
+Routes without schema accept any body and bypass Fastify's fast-json-stringify serialization.`
+    }
+  ],
+  prisma: [
+    {
+      slug: "prisma-no-disconnect-in-lambda",
+      type: "gotcha",
+      tags: ["prisma", "serverless"],
+      body: `Do NOT call prisma.$disconnect() inside Lambda/Edge function handlers.
+
+Calling $disconnect() after each request wastes the warm connection pool.
+Create one PrismaClient per process (module-level singleton), not per request.
+Disconnecting is only needed when the process is shutting down.`
+    },
+    {
+      slug: "prisma-migrations-never-modify",
+      type: "convention",
+      tags: ["prisma", "database", "migrations"],
+      body: `Never modify an existing migration file \u2014 create a new one instead.
+
+Prisma tracks migration history by file hash. Editing a deployed migration
+causes \`migrate deploy\` to fail with a checksum mismatch in production.
+Always use \`npx prisma migrate dev --name <description>\` to create incremental migrations.`
+    }
+  ],
+  drizzle: [
+    {
+      slug: "drizzle-always-await-queries",
+      type: "gotcha",
+      tags: ["drizzle", "async"],
+      body: `Drizzle queries are thenable but not auto-executed \u2014 always await them.
+
+\`\`\`ts
+// \u274C Silently returns a query builder, never executes
+const rows = db.select().from(users).where(eq(users.id, id));
+
+// \u2705 Correct
+const rows = await db.select().from(users).where(eq(users.id, id));
+\`\`\``
+    },
+    {
+      slug: "drizzle-schema-must-match-db",
+      type: "gotcha",
+      tags: ["drizzle", "migrations"],
+      body: `Drizzle does NOT auto-sync the schema to the database \u2014 you must run migrations explicitly.
+
+After changing schema.ts:
+1. \`npx drizzle-kit generate\` \u2014 creates migration SQL
+2. \`npx drizzle-kit migrate\` (or push in dev) \u2014 applies it
+
+Without this, queries silently operate on stale column definitions and may return wrong data.`
+    }
+  ]
+};
+var SUPPORTED_STACKS = Object.keys(PACKS);
+function isValidStack(name) {
+  return name in PACKS;
+}
+function autoDetectStacks(deps) {
+  const detected = [];
+  const stackDetectors = [
+    ["nestjs", ["@nestjs/core"]],
+    ["nextjs", ["next"]],
+    ["remix", ["@remix-run/react", "@remix-run/node"]],
+    ["react", ["react"]],
+    ["express", ["express"]],
+    ["fastify", ["fastify"]],
+    ["prisma", ["@prisma/client", "prisma"]],
+    ["drizzle", ["drizzle-orm"]]
+  ];
+  for (const [stack, signals] of stackDetectors) {
+    if (signals.some((s) => s in deps)) detected.push(stack);
+  }
+  if (detected.includes("nextjs") || detected.includes("remix")) {
+    return detected.filter((s) => s !== "react");
+  }
+  return detected;
+}
+async function seedStackPack(haivePaths, stack) {
+  const memories = PACKS[stack];
+  if (!memories) return 0;
+  await mkdir2(haivePaths.teamDir, { recursive: true });
+  let count = 0;
+  for (const mem of memories) {
+    const fm = buildFrontmatter({
+      type: mem.type,
+      slug: `${stack}-${mem.slug}`,
+      scope: "team",
+      status: "validated",
+      tags: mem.tags
+    });
+    const filePath = memoryFilePath(haivePaths, "team", fm.id);
+    if (existsSync5(filePath)) continue;
+    const content = serializeMemory({ frontmatter: fm, body: mem.body });
+    await mkdir2(path6.dirname(filePath), { recursive: true });
+    await writeFile2(filePath, content, "utf8");
+    count++;
+  }
+  return count;
+}
+
+// src/commands/init.ts
 var PROJECT_CONTEXT_TEMPLATE = `# Project context
 
-> Generated by \`haive init\`. Edit this file (or let your AI agent fill it via the upcoming MCP \`bootstrap_project\` tool).
+> Generated by \`haive init\`. Run \`haive init --bootstrap\` to auto-fill from your codebase,
+> or invoke the MCP prompt \`bootstrap_project\` in your AI client for a richer AI-generated version.
 
 ## Architecture
 TODO \u2014 high-level overview of the codebase.
@@ -543,23 +1290,46 @@ function registerInit(program2) {
   ).option("-d, --dir <dir>", "project root", process.cwd()).option("--no-bridges", "do not generate CLAUDE.md / .cursorrules / copilot-instructions.md").option("--with-ci", "write a GitHub Actions workflow (.github/workflows/haive-sync.yml) \u2014 included automatically in autopilot mode").option(
     "--manual",
     "opt out of autopilot: memories require manual approval, no auto-session recap, no auto-context"
+  ).option(
+    "--bootstrap",
+    "auto-generate .ai/project-context.md from package.json, README, and directory structure (no AI needed)"
+  ).option(
+    "--stack <stacks>",
+    `pre-seed validated memory packs for the given stacks (comma-separated).
+  Supported: ${SUPPORTED_STACKS.join(", ")}.
+  Use 'auto' to detect from package.json automatically.`
+  ).option(
+    "--no-mcp-setup",
+    "skip auto-configuring haive-mcp in Cursor / VS Code / Claude Code"
   ).action(async (opts) => {
-    const root = path3.resolve(opts.dir);
+    const root = path7.resolve(opts.dir);
     const paths = resolveHaivePaths4(root);
     const autopilot = opts.manual !== true;
-    if (existsSync3(paths.haiveDir)) {
+    if (existsSync6(paths.haiveDir)) {
       ui.warn(`.ai/ already exists at ${paths.haiveDir} \u2014 leaving existing files in place.`);
     }
-    await mkdir(paths.personalDir, { recursive: true });
-    await mkdir(paths.teamDir, { recursive: true });
-    await mkdir(paths.moduleDir, { recursive: true });
-    await mkdir(paths.modulesContextDir, { recursive: true });
-    if (!existsSync3(paths.projectContext)) {
-      await writeFile(paths.projectContext, PROJECT_CONTEXT_TEMPLATE, "utf8");
-      ui.success(`Created ${path3.relative(root, paths.projectContext)}`);
+    await mkdir3(paths.personalDir, { recursive: true });
+    await mkdir3(paths.teamDir, { recursive: true });
+    await mkdir3(paths.moduleDir, { recursive: true });
+    await mkdir3(paths.modulesContextDir, { recursive: true });
+    if (!existsSync6(paths.projectContext)) {
+      if (opts.bootstrap) {
+        ui.info("Bootstrapping project context from local files\u2026");
+        try {
+          const context = await generateBootstrapContext(root);
+          await writeFile3(paths.projectContext, context, "utf8");
+          ui.success("Created .ai/project-context.md (auto-bootstrapped from local files)");
+        } catch (err) {
+          ui.warn(`Bootstrap failed (${String(err)}) \u2014 writing default template instead`);
+          await writeFile3(paths.projectContext, PROJECT_CONTEXT_TEMPLATE, "utf8");
+        }
+      } else {
+        await writeFile3(paths.projectContext, PROJECT_CONTEXT_TEMPLATE, "utf8");
+        ui.success(`Created ${path7.relative(root, paths.projectContext)}`);
+      }
     }
-    const configExists = existsSync3(
-      path3.join(paths.haiveDir, "haive.config.json")
+    const configExists = existsSync6(
+      path7.join(paths.haiveDir, "haive.config.json")
     );
     if (!configExists) {
       await saveConfig(paths, autopilot ? AUTOPILOT_DEFAULTS : { autopilot: false });
@@ -570,17 +1340,35 @@ function registerInit(program2) {
     if (opts.bridges) {
       await writeBridge(root, "CLAUDE.md");
       await writeBridge(root, ".cursorrules");
-      await writeBridge(root, path3.join(".github", "copilot-instructions.md"));
+      await writeBridge(root, path7.join(".github", "copilot-instructions.md"));
+    }
+    const stacksToSeed = await resolveStacksToSeed(root, opts.stack);
+    if (stacksToSeed.length > 0) {
+      let totalSeeded = 0;
+      for (const stack of stacksToSeed) {
+        const count = await seedStackPack(paths, stack);
+        if (count > 0) {
+          ui.success(`Seeded ${count} memories for stack: ${stack}`);
+          totalSeeded += count;
+        } else {
+          ui.info(`Stack pack '${stack}': all memories already exist \u2014 skipped`);
+        }
+      }
+      if (totalSeeded > 0) {
+        ui.success(
+          `${totalSeeded} validated team memories pre-seeded \u2014 haive is useful from J+0`
+        );
+      }
     }
     const wantCi = opts.withCi || autopilot;
     if (wantCi) {
-      const ciPath = path3.join(root, ".github", "workflows", "haive-sync.yml");
-      if (existsSync3(ciPath)) {
+      const ciPath = path7.join(root, ".github", "workflows", "haive-sync.yml");
+      if (existsSync6(ciPath)) {
         ui.info("CI workflow already exists \u2014 skipped");
       } else {
-        await mkdir(path3.dirname(ciPath), { recursive: true });
-        await writeFile(ciPath, CI_WORKFLOW, "utf8");
-        ui.success(`Created ${path3.relative(root, ciPath)}`);
+        await mkdir3(path7.dirname(ciPath), { recursive: true });
+        await writeFile3(ciPath, CI_WORKFLOW, "utf8");
+        ui.success(`Created ${path7.relative(root, ciPath)}`);
       }
     }
     if (autopilot) {
@@ -604,6 +1392,27 @@ function registerInit(program2) {
         ui.warn("Code-map build failed \u2014 run `haive index code` manually");
       }
     }
+    if (opts.mcpSetup !== false) {
+      const mcpResults = await autoConfigureMcpClients();
+      const configured = mcpResults.filter((r) => r.status === "configured");
+      const alreadyOk = mcpResults.filter((r) => r.status === "already_configured");
+      for (const r of configured) {
+        ui.success(`haive-mcp configured in ${r.client} (${r.path})`);
+      }
+      for (const r of alreadyOk) {
+        ui.info(`haive-mcp already configured in ${r.client} \u2014 skipped`);
+      }
+      if (configured.length === 0 && alreadyOk.length === 0) {
+        ui.warn(
+          "No supported AI client detected (Cursor, VS Code, Claude Code, Windsurf).\n  Configure manually: add haive-mcp to your client's MCP config.\n  See: https://github.com/Doucs91/hAIve#mcp-setup"
+        );
+      }
+      if (configured.length > 0) {
+        ui.info(
+          ui.dim("  \u2192 Restart your AI client for MCP changes to take effect.")
+        );
+      }
+    }
     ui.success(`hAIve initialized at ${root}${autopilot ? " (autopilot mode)" : ""}`);
     console.log();
     if (autopilot) {
@@ -614,45 +1423,74 @@ function registerInit(program2) {
       console.log(ui.dim("  \u2713 Code-map refreshes automatically after every pull"));
       console.log(ui.dim("  \u2713 Git hooks installed (auto-sync after pull/merge)"));
       console.log(ui.dim("  \u2713 CI workflow created (pr-stale-check + sync-on-merge)"));
+      if (stacksToSeed.length > 0) {
+        console.log(ui.dim(`  \u2713 Stack memory packs pre-seeded (${stacksToSeed.join(", ")})`));
+      }
+      console.log();
+      if (!opts.bootstrap) {
+        console.log(ui.bold("One remaining step (optional but recommended):"));
+        console.log("  " + ui.bold("haive init --bootstrap") + ui.dim("  \u2190 fill project-context.md without AI"));
+        console.log("  " + ui.dim("Or in your AI client: invoke the MCP prompt ") + ui.bold("bootstrap_project"));
+      } else {
+        console.log(ui.bold("Project context bootstrapped from local files."));
+        console.log(ui.dim("  Review .ai/project-context.md and fill in the TODO sections."));
+        console.log(ui.dim("  Or invoke the MCP prompt `bootstrap_project` for a richer AI-generated version."));
+      }
       console.log();
-      console.log(ui.bold("One remaining step:"));
-      console.log("  In your AI client, invoke the MCP prompt: " + ui.bold("bootstrap_project"));
-      console.log(ui.dim("  This fills .ai/project-context.md \u2014 only needed once."));
+      console.log(ui.dim("  Seed more memories instantly:"));
+      console.log(ui.dim("    haive memory import-changelog   \u2014 from CHANGELOG.md"));
+      console.log(ui.dim("    haive memory import README.md   \u2014 from README / docs"));
     } else {
       console.log(ui.bold("Next steps:"));
-      console.log(ui.dim("  1. Fill project context \u2014 let your AI agent do it:"));
-      console.log("     " + ui.bold("In your AI client (Claude, Cursor\u2026), invoke the MCP prompt: bootstrap_project"));
-      console.log(ui.dim("     This analyzes your codebase and writes .ai/project-context.md automatically."));
-      console.log();
-      console.log(ui.dim("  2. Point your AI client at the MCP server:"));
-      console.log(`     haive-mcp --root ${root}`);
+      if (!opts.bootstrap) {
+        console.log(ui.dim("  1. Fill project context (pick one):"));
+        console.log("     " + ui.bold("haive init --bootstrap") + ui.dim("  \u2190 instant, no AI needed"));
+        console.log("     or invoke the MCP prompt " + ui.bold("bootstrap_project") + ui.dim(" in your AI client"));
+      } else {
+        console.log(ui.dim("  1. Review .ai/project-context.md and fill in the TODO sections."));
+      }
       console.log();
-      console.log(ui.dim("  3. Start every AI session with:"));
+      console.log(ui.dim("  2. Start every AI session with:"));
       console.log("     " + ui.bold("get_briefing({ task: '\u2026what you are about to do\u2026' })"));
       console.log();
       console.log(ui.dim("  Tip: run `haive init` (without --manual) for zero-friction autopilot mode."));
     }
   });
 }
+async function resolveStacksToSeed(root, stackOpt) {
+  if (!stackOpt) return [];
+  if (stackOpt === "auto") {
+    const pkgPath = path7.join(root, "package.json");
+    if (!existsSync6(pkgPath)) return [];
+    try {
+      const pkg = JSON.parse(await readFile4(pkgPath, "utf8"));
+      const allDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+      return autoDetectStacks(allDeps);
+    } catch {
+      return [];
+    }
+  }
+  return stackOpt.split(",").map((s) => s.trim().toLowerCase()).filter(isValidStack);
+}
 async function writeBridge(root, relPath) {
-  const target = path3.join(root, relPath);
-  if (existsSync3(target)) {
+  const target = path7.join(root, relPath);
+  if (existsSync6(target)) {
     ui.info(`Bridge ${relPath} already exists \u2014 skipped`);
     return;
   }
-  await mkdir(path3.dirname(target), { recursive: true });
-  await writeFile(target, BRIDGE_BODY, "utf8");
+  await mkdir3(path7.dirname(target), { recursive: true });
+  await writeFile3(target, BRIDGE_BODY, "utf8");
   ui.success(`Created bridge ${relPath}`);
 }
 
 // src/commands/install-hooks.ts
-import { mkdir as mkdir2, writeFile as writeFile2, chmod, readFile as readFile2 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import path4 from "path";
+import { mkdir as mkdir4, writeFile as writeFile4, chmod, readFile as readFile5 } from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
+import path8 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot6 } from "@hiveai/core";
 var HOOK_MARKER = "# hAIve auto-generated";
-var HOOK_BODY = `#!/bin/sh
+var POST_MERGE_BODY = `#!/bin/sh
 ${HOOK_MARKER} \u2014 keep this block to allow upgrades. Hand-edit anything outside it.
 
 # After a merge or pull, refresh memory anchors and auto-promote eligible
@@ -663,46 +1501,83 @@ elif [ -x ./node_modules/.bin/haive ]; then
   ./node_modules/.bin/haive sync --quiet --since ORIG_HEAD || true
 fi
 `;
-var HOOKS = ["post-merge", "post-rewrite"];
+var PRE_PUSH_BODY = `#!/bin/sh
+${HOOK_MARKER} \u2014 keep this block to allow upgrades. Hand-edit anything outside it.
+
+# Before pushing, run haive precommit to surface known anti-patterns and stale memories.
+# Exit 0 always \u2014 this is advisory only (set HAIVE_BLOCK=1 to make it blocking).
+HAIVE_BLOCK=\${HAIVE_BLOCK:-0}
+
+_haive() {
+  if command -v haive >/dev/null 2>&1; then haive "$@"
+  elif [ -x ./node_modules/.bin/haive ]; then ./node_modules/.bin/haive "$@"
+  else return 0
+  fi
+}
+
+# Run pre-commit check on diff between local and remote
+LOCAL_BRANCH=$(git rev-parse --abbrev-ref HEAD)
+REMOTE_SHA=$(git rev-parse --verify "@{u}" 2>/dev/null || echo "")
+if [ -n "$REMOTE_SHA" ]; then
+  DIFF=$(git diff "$REMOTE_SHA"..HEAD 2>/dev/null || "")
+  if [ -n "$DIFF" ]; then
+    _haive precommit --quiet 2>/dev/null || true
+  fi
+fi
+
+# Remind agent to save session recap if env var is set
+if [ "$HAIVE_SESSION_REMINDER" = "1" ]; then
+  echo "haive: session active \u2014 remember to call mem_session_end before closing." >&2
+fi
+
+exit 0
+`;
+var HOOKS = [
+  { name: "post-merge", body: POST_MERGE_BODY },
+  { name: "post-rewrite", body: POST_MERGE_BODY },
+  { name: "pre-push", body: PRE_PUSH_BODY }
+];
 function registerInstallHooks(program2) {
   program2.command("install-hooks").description(
-    "Install git hooks so haive sync runs automatically after every pull or merge.\n\n  Installs a post-merge hook at .git/hooks/post-merge that runs:\n    haive sync --quiet --since ORIG_HEAD --embed\n\n  This ensures memory anchors are always verified and the embeddings index\n  is kept fresh without requiring any manual steps.\n\n  Installed automatically by haive init (autopilot mode).\n  Use --force to overwrite an existing post-merge hook.\n"
+    "Install git hooks so haive sync runs automatically after every pull or merge.\n\n  Installs:\n    post-merge / post-rewrite \u2014 runs haive sync after every pull/merge\n    pre-push                  \u2014 runs haive precommit before every push (advisory)\n\n  Installed automatically by haive init (autopilot mode).\n  Use --force to overwrite existing hooks.\n"
   ).option("-d, --dir <dir>", "project root").option("--force", "overwrite existing hooks").action(async (opts) => {
     const root = findProjectRoot6(opts.dir);
-    const gitDir = path4.join(root, ".git");
-    if (!existsSync4(gitDir)) {
+    const gitDir = path8.join(root, ".git");
+    if (!existsSync7(gitDir)) {
       ui.error(`No .git directory at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const hooksDir = path4.join(gitDir, "hooks");
-    await mkdir2(hooksDir, { recursive: true });
+    const hooksDir = path8.join(gitDir, "hooks");
+    await mkdir4(hooksDir, { recursive: true });
     let installed = 0;
     let skipped = 0;
-    for (const name of HOOKS) {
-      const file = path4.join(hooksDir, name);
-      if (existsSync4(file) && !opts.force) {
-        const existing = await readFile2(file, "utf8");
+    for (const { name, body } of HOOKS) {
+      const file = path8.join(hooksDir, name);
+      if (existsSync7(file) && !opts.force) {
+        const existing = await readFile5(file, "utf8");
         if (!existing.includes(HOOK_MARKER)) {
           ui.warn(`${name} already exists and was not written by hAIve. Re-run with --force to overwrite.`);
           skipped++;
           continue;
         }
       }
-      await writeFile2(file, HOOK_BODY, "utf8");
+      await writeFile4(file, body, "utf8");
       await chmod(file, 493);
       installed++;
     }
     ui.success(`Installed ${installed} hook(s) in .git/hooks/${skipped ? `, skipped ${skipped}` : ""}`);
-    ui.info("Test with: git pull (or any merge), then check .ai/memories for status updates.");
+    ui.info("post-merge: haive sync runs after every pull/merge.");
+    ui.info("pre-push:   haive precommit runs before every push (advisory, never blocks).");
+    ui.info("           Set HAIVE_BLOCK=1 in your shell to make pre-push blocking.");
   });
 }
 
 // src/commands/mcp.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import { createRequire } from "module";
-import path5 from "path";
+import path9 from "path";
 import { fileURLToPath } from "url";
 import "commander";
 import { findProjectRoot as findProjectRoot7 } from "@hiveai/core";
@@ -740,26 +1615,26 @@ function registerMcp(program2) {
 function locateMcpBin() {
   try {
     const pkgPath = require2.resolve("@hiveai/mcp/package.json");
-    const pkgDir = path5.dirname(pkgPath);
-    const candidate = path5.join(pkgDir, "dist", "index.js");
-    if (existsSync5(candidate)) return candidate;
+    const pkgDir = path9.dirname(pkgPath);
+    const candidate = path9.join(pkgDir, "dist", "index.js");
+    if (existsSync8(candidate)) return candidate;
   } catch {
   }
-  const here = path5.dirname(fileURLToPath(import.meta.url));
-  const sibling = path5.resolve(here, "..", "..", "..", "mcp", "dist", "index.js");
-  if (existsSync5(sibling)) return sibling;
+  const here = path9.dirname(fileURLToPath(import.meta.url));
+  const sibling = path9.resolve(here, "..", "..", "..", "mcp", "dist", "index.js");
+  if (existsSync8(sibling)) return sibling;
   return null;
 }
 
 // src/commands/sync.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import path6 from "path";
+import { readFile as readFile6, writeFile as writeFile5, mkdir as mkdir5 } from "fs/promises";
+import { existsSync as existsSync9 } from "fs";
+import path10 from "path";
 import "commander";
 import {
   DEFAULT_AUTO_PROMOTE_RULE,
-  buildFrontmatter,
+  buildFrontmatter as buildFrontmatter2,
   findProjectRoot as findProjectRoot8,
   getUsage,
   isAutoPromoteEligible,
@@ -771,7 +1646,7 @@ import {
   pullCrossRepoSources,
   resolveHaivePaths as resolveHaivePaths5,
   resolveManifestFiles,
-  serializeMemory,
+  serializeMemory as serializeMemory2,
   trackDependencies,
   verifyAnchor,
   watchContracts
@@ -790,7 +1665,7 @@ function registerSync(program2) {
   ).option("--bridge-file <path>", "bridge file to inject into (default: CLAUDE.md)").option("--bridge-max-memories <n>", "max memories to inject into bridge file", "5").option("--embed", "rebuild embeddings index after sync (requires @haive/embeddings)").option("--no-cross-repo", "skip cross-repo memory pull even if crossRepoSources is configured").option("--no-deps", "skip dependency version tracking").option("--no-contracts", "skip contract file diff checking").action(async (opts) => {
     const root = findProjectRoot8(opts.dir);
     const paths = resolveHaivePaths5(root);
-    if (!existsSync6(paths.memoriesDir)) {
+    if (!existsSync9(paths.memoriesDir)) {
       if (!opts.quiet) ui.warn(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -810,9 +1685,9 @@ function registerSync(program2) {
       for (const { memory: memory2, filePath } of memories) {
         if (memory2.frontmatter.type === "session_recap") {
           if (memory2.frontmatter.status === "stale") {
-            await writeFile3(
+            await writeFile5(
               filePath,
-              serializeMemory({
+              serializeMemory2({
                 frontmatter: {
                   ...memory2.frontmatter,
                   status: "validated",
@@ -833,9 +1708,9 @@ function registerSync(program2) {
         const verifiedAt = (/* @__PURE__ */ new Date()).toISOString();
         if (result.stale) {
           if (memory2.frontmatter.status !== "stale") {
-            await writeFile3(
+            await writeFile5(
               filePath,
-              serializeMemory({
+              serializeMemory2({
                 frontmatter: {
                   ...memory2.frontmatter,
                   status: "stale",
@@ -849,9 +1724,9 @@ function registerSync(program2) {
             staleMarked++;
           }
         } else if (memory2.frontmatter.status === "stale") {
-          await writeFile3(
+          await writeFile5(
             filePath,
-            serializeMemory({
+            serializeMemory2({
               frontmatter: {
                 ...memory2.frontmatter,
                 status: "validated",
@@ -877,9 +1752,9 @@ function registerSync(program2) {
           minReads: autoPromoteMinReads,
           maxRejections: DEFAULT_AUTO_PROMOTE_RULE.maxRejections
         })) {
-          await writeFile3(
+          await writeFile5(
             filePath,
-            serializeMemory({ frontmatter: { ...fm, status: "validated" }, body: memory2.body }),
+            serializeMemory2({ frontmatter: { ...fm, status: "validated" }, body: memory2.body }),
             "utf8"
           );
           promoted++;
@@ -888,9 +1763,9 @@ function registerSync(program2) {
         if (autoApproveDelayHours !== null && fm.status === "proposed" && fm.scope === "team") {
           const ageHours = (nowMs - new Date(fm.created_at).getTime()) / (1e3 * 60 * 60);
           if (ageHours >= autoApproveDelayHours) {
-            await writeFile3(
+            await writeFile5(
               filePath,
-              serializeMemory({
+              serializeMemory2({
                 frontmatter: {
                   ...fm,
                   status: "validated",
@@ -922,7 +1797,7 @@ function registerSync(program2) {
       );
     }
     if (opts.injectBridge) {
-      const bridgeFile = opts.bridgeFile ? path6.resolve(opts.bridgeFile) : path6.join(root, "CLAUDE.md");
+      const bridgeFile = opts.bridgeFile ? path10.resolve(opts.bridgeFile) : path10.join(root, "CLAUDE.md");
       const maxInject = Math.max(1, Number(opts.bridgeMaxMemories ?? 5));
       await injectBridge(bridgeFile, paths.memoriesDir, maxInject, root, opts.quiet);
     }
@@ -1019,7 +1894,7 @@ Attends une **confirmation explicite** avant d'agir.
 **Prochaines \xE9tapes (si confirm\xE9) :**
 - Consulter le CHANGELOG : \`haive memory import-changelog --from node_modules/<pkg>/CHANGELOG.md\`
 - V\xE9rifier les m\xE9moires ancr\xE9es : \`haive memory verify\``;
-                const fm = buildFrontmatter({
+                const fm = buildFrontmatter2({
                   type: "gotcha",
                   slug,
                   scope: "team",
@@ -1028,11 +1903,11 @@ Attends une **confirmation explicite** avant d'agir.
                   paths: [result.file],
                   topic: `dep-bump-${slugParts}`
                 });
-                const teamDir = path6.join(paths.memoriesDir, "team");
-                await mkdir3(teamDir, { recursive: true });
-                await writeFile3(
-                  path6.join(teamDir, `${fm.id}.md`),
-                  serializeMemory({ frontmatter: { ...fm, requires_human_approval: true }, body }),
+                const teamDir = path10.join(paths.memoriesDir, "team");
+                await mkdir5(teamDir, { recursive: true });
+                await writeFile5(
+                  path10.join(teamDir, `${fm.id}.md`),
+                  serializeMemory2({ frontmatter: { ...fm, requires_human_approval: true }, body }),
                   "utf8"
                 );
                 log(ui.yellow(`   \u2192 memory created: ${fm.id}`));
@@ -1086,7 +1961,7 @@ Attends une **confirmation explicite** avant d'agir.
 **Prochaines \xE9tapes (si confirm\xE9) :**
 - Rechercher les usages : \`haive memory for-files <fichiers concern\xE9s>\`
 - V\xE9rifier les m\xE9moires li\xE9es : \`haive memory query ${diff.contract}\``;
-            const fm = buildFrontmatter({
+            const fm = buildFrontmatter2({
               type: "gotcha",
               slug,
               scope: "team",
@@ -1095,11 +1970,11 @@ Attends une **confirmation explicite** avant d'agir.
               paths: [diff.file],
               topic: `contract-breaking-${diff.contract}`
             });
-            const teamDir = path6.join(paths.memoriesDir, "team");
-            await mkdir3(teamDir, { recursive: true });
-            await writeFile3(
-              path6.join(teamDir, `${fm.id}.md`),
-              serializeMemory({ frontmatter: { ...fm, requires_human_approval: true }, body }),
+            const teamDir = path10.join(paths.memoriesDir, "team");
+            await mkdir5(teamDir, { recursive: true });
+            await writeFile5(
+              path10.join(teamDir, `${fm.id}.md`),
+              serializeMemory2({ frontmatter: { ...fm, requires_human_approval: true }, body }),
               "utf8"
             );
             log(ui.yellow(`   \u2192 memory created: ${fm.id}`));
@@ -1159,7 +2034,7 @@ Attends une **confirmation explicite** avant d'agir.
   });
 }
 async function injectBridge(bridgeFile, memoriesDir, maxMemories, root, quiet) {
-  if (!existsSync6(memoriesDir)) return;
+  if (!existsSync9(memoriesDir)) return;
   const all = await loadMemoriesFromDir2(memoriesDir);
   const top = all.filter(({ memory: memory2 }) => {
     const s = memory2.frontmatter.status;
@@ -1184,17 +2059,17 @@ ${m.memory.body.trim()}`;
 ` + block + `
 
 ${BRIDGE_END}`;
-  const fileExists = existsSync6(bridgeFile);
-  let existing = fileExists ? await readFile3(bridgeFile, "utf8") : "";
+  const fileExists = existsSync9(bridgeFile);
+  let existing = fileExists ? await readFile6(bridgeFile, "utf8") : "";
   existing = existing.replace(/\r\n/g, "\n");
   const startIdx = existing.indexOf(BRIDGE_START);
   const endIdx = existing.indexOf(BRIDGE_END);
   if (startIdx !== -1 && endIdx === -1) {
-    ui.warn(`${path6.relative(root, bridgeFile)}: found ${BRIDGE_START} without ${BRIDGE_END}. Fix the file manually before running --inject-bridge.`);
+    ui.warn(`${path10.relative(root, bridgeFile)}: found ${BRIDGE_START} without ${BRIDGE_END}. Fix the file manually before running --inject-bridge.`);
     return;
   }
   if (startIdx === -1 && endIdx !== -1) {
-    ui.warn(`${path6.relative(root, bridgeFile)}: found ${BRIDGE_END} without ${BRIDGE_START}. Fix the file manually before running --inject-bridge.`);
+    ui.warn(`${path10.relative(root, bridgeFile)}: found ${BRIDGE_END} without ${BRIDGE_START}. Fix the file manually before running --inject-bridge.`);
     return;
   }
   let updated;
@@ -1202,14 +2077,14 @@ ${BRIDGE_END}`;
     updated = existing.slice(0, startIdx) + injected + existing.slice(endIdx + BRIDGE_END.length);
   } else {
     if (!fileExists && !quiet) {
-      ui.info(`Creating ${path6.relative(root, bridgeFile)} with haive memory block.`);
+      ui.info(`Creating ${path10.relative(root, bridgeFile)} with haive memory block.`);
     }
     updated = existing + (existing.endsWith("\n") ? "" : "\n") + "\n" + injected + "\n";
   }
-  await writeFile3(bridgeFile, updated, "utf8");
+  await writeFile5(bridgeFile, updated, "utf8");
   if (!quiet) {
     console.log(
-      ui.dim(`bridge: injected ${top.length} memor${top.length === 1 ? "y" : "ies"} into ${path6.relative(root, bridgeFile)}`)
+      ui.dim(`bridge: injected ${top.length} memor${top.length === 1 ? "y" : "ies"} into ${path10.relative(root, bridgeFile)}`)
     );
   }
 }
@@ -1234,18 +2109,18 @@ function collectSinceChanges(root, ref) {
 
 // src/commands/memory-add.ts
 import { createHash } from "crypto";
-import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
-import path7 from "path";
+import { mkdir as mkdir6, readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
+import { existsSync as existsSync10 } from "fs";
+import path11 from "path";
 import "commander";
 import {
-  buildFrontmatter as buildFrontmatter2,
+  buildFrontmatter as buildFrontmatter3,
   findProjectRoot as findProjectRoot9,
   inferModulesFromPaths,
   loadMemoriesFromDir as loadMemoriesFromDir3,
-  memoryFilePath,
+  memoryFilePath as memoryFilePath2,
   resolveHaivePaths as resolveHaivePaths6,
-  serializeMemory as serializeMemory2
+  serializeMemory as serializeMemory3
 } from "@hiveai/core";
 function registerMemoryAdd(memory2) {
   memory2.command("add").description(
@@ -1274,7 +2149,7 @@ function registerMemoryAdd(memory2) {
   ).requiredOption("--type <type>", "convention | decision | gotcha | architecture | glossary | attempt").requiredOption("--slug <slug>", "short kebab-case identifier used in the file name").option("--title <text>", "memory title \u2014 becomes the first heading of the body").option("--scope <scope>", "personal | team | module (default: personal, or team in autopilot)", "personal").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags for easier retrieval").option("--domain <domain>", "domain (e.g. transactions)").option("--author <author>", "author email or handle").option("--paths <csv>", "anchor to source files \u2014 used for staleness detection by haive sync").option("--symbols <csv>", "anchor to specific symbols (class/function names)").option("--commit <sha>", "anchor to a specific commit SHA").option("--body <text>", "memory body content (Markdown) \u2014 overrides --title default body").option("--body-file <path>", "read memory body from a Markdown file \u2014 for long content").option("--no-auto-tag", "disable automatic tag suggestions inferred from anchor paths").option("--topic <key>", "stable key for upsert: if a memory with this topic+scope already exists, update it in-place (revision_count++)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot9(opts.dir);
     const paths = resolveHaivePaths6(root);
-    if (!existsSync7(paths.haiveDir)) {
+    if (!existsSync10(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -1285,7 +2160,7 @@ function registerMemoryAdd(memory2) {
     const inferredTags = autoTagsEnabled ? inferModulesFromPaths(anchorPaths) : [];
     const mergedTags = Array.from(/* @__PURE__ */ new Set([...userTags, ...inferredTags]));
     if (anchorPaths.length > 0) {
-      const missing = anchorPaths.filter((p) => !existsSync7(path7.resolve(root, p)));
+      const missing = anchorPaths.filter((p) => !existsSync10(path11.resolve(root, p)));
       if (missing.length > 0) {
         ui.warn(`Anchor path${missing.length > 1 ? "s" : ""} not found in project:`);
         for (const p of missing) ui.warn(`  \u2717 ${p}`);
@@ -1297,12 +2172,12 @@ function registerMemoryAdd(memory2) {
     const title = opts.title ?? opts.slug;
     let body;
     if (opts.bodyFile !== void 0) {
-      if (!existsSync7(opts.bodyFile)) {
+      if (!existsSync10(opts.bodyFile)) {
         ui.error(`--body-file not found: ${opts.bodyFile}`);
         process.exitCode = 1;
         return;
       }
-      const fileContent = await readFile4(opts.bodyFile, "utf8");
+      const fileContent = await readFile7(opts.bodyFile, "utf8");
       body = opts.title ? `# ${opts.title}
 
 ${fileContent.trim()}
@@ -1318,7 +2193,7 @@ TODO \u2014 write the memory body.
 `;
     }
     const scope = opts.scope ?? "personal";
-    if (existsSync7(paths.memoriesDir)) {
+    if (existsSync10(paths.memoriesDir)) {
       const incomingHash = createHash("sha256").update(body.trim()).digest("hex").slice(0, 12);
       const allForHash = await loadMemoriesFromDir3(paths.memoriesDir);
       const hashDup = allForHash.find(
@@ -1331,7 +2206,7 @@ TODO \u2014 write the memory body.
         return;
       }
     }
-    if (opts.topic && existsSync7(paths.memoriesDir)) {
+    if (opts.topic && existsSync10(paths.memoriesDir)) {
       const existing = await loadMemoriesFromDir3(paths.memoriesDir);
       const topicMatch = existing.find(
         ({ memory: memory3 }) => memory3.frontmatter.topic === opts.topic && memory3.frontmatter.scope === scope && (!opts.module || memory3.frontmatter.module === opts.module)
@@ -1349,13 +2224,13 @@ TODO \u2014 write the memory body.
             symbols: parseCsv2(opts.symbols).length ? parseCsv2(opts.symbols) : fm.anchor.symbols
           }
         };
-        await writeFile4(topicMatch.filePath, serializeMemory2({ frontmatter: newFrontmatter, body }), "utf8");
-        ui.success(`Updated (topic upsert) ${path7.relative(root, topicMatch.filePath)}`);
+        await writeFile6(topicMatch.filePath, serializeMemory3({ frontmatter: newFrontmatter, body }), "utf8");
+        ui.success(`Updated (topic upsert) ${path11.relative(root, topicMatch.filePath)}`);
         ui.info(`id=${fm.id}  revision=${revisionCount}`);
         return;
       }
     }
-    const frontmatter = buildFrontmatter2({
+    const frontmatter = buildFrontmatter3({
       type: opts.type,
       slug: opts.slug,
       scope,
@@ -1368,14 +2243,14 @@ TODO \u2014 write the memory body.
       commit: opts.commit,
       topic: opts.topic
     });
-    const file = memoryFilePath(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir4(path7.dirname(file), { recursive: true });
-    if (existsSync7(file)) {
+    const file = memoryFilePath2(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
+    await mkdir6(path11.dirname(file), { recursive: true });
+    if (existsSync10(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
       return;
     }
-    if (existsSync7(paths.memoriesDir)) {
+    if (existsSync10(paths.memoriesDir)) {
       const existing = await loadMemoriesFromDir3(paths.memoriesDir);
       const slugTokens = opts.slug.toLowerCase().split(/[-_\s]+/).filter(Boolean);
       const similar = existing.filter(({ memory: memory3 }) => {
@@ -1387,8 +2262,8 @@ TODO \u2014 write the memory body.
         ui.warn("Consider updating one of these with `haive memory update` instead.");
       }
     }
-    await writeFile4(file, serializeMemory2({ frontmatter, body }), "utf8");
-    ui.success(`Created ${path7.relative(root, file)}`);
+    await writeFile6(file, serializeMemory3({ frontmatter, body }), "utf8");
+    ui.success(`Created ${path11.relative(root, file)}`);
     ui.info(`id=${frontmatter.id}  scope=${frontmatter.scope}  status=${frontmatter.status}`);
     if (inferredTags.length > 0) {
       ui.info(`auto-tagged: ${inferredTags.join(", ")}  (use --no-auto-tag to disable)`);
@@ -1418,8 +2293,8 @@ function parseCsv2(value) {
 }
 
 // src/commands/memory-list.ts
-import { existsSync as existsSync8 } from "fs";
-import path8 from "path";
+import { existsSync as existsSync11 } from "fs";
+import path12 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot10, resolveHaivePaths as resolveHaivePaths7 } from "@hiveai/core";
 
@@ -1435,7 +2310,7 @@ function registerMemoryList(memory2) {
   memory2.command("list").description("List memories with optional filters").option("--scope <scope>", "personal | team | module").option("--type <type>", "filter by type").option("--tag <tag>", "filter by tag").option("--module <name>", "filter by module name").option("--status <csv>", "filter by status (draft,proposed,validated,stale,rejected,deprecated)").option("--show-rejected", "include rejected memories (hidden by default)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot10(opts.dir);
     const paths = resolveHaivePaths7(root);
-    if (!existsSync8(paths.memoriesDir)) {
+    if (!existsSync11(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -1467,7 +2342,7 @@ function registerMemoryList(memory2) {
       console.log(
         `${ui.bold(fm.id)} ${ui.dim(fm.scope)}/${ui.dim(fm.type)} ${statusBadge}${moduleStr}${tagStr}`
       );
-      console.log(`  ${ui.dim(path8.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path12.relative(root, filePath))}`);
     }
     console.log(ui.dim(`
 ${filtered.length} memor${filtered.length === 1 ? "y" : "ies"}`));
@@ -1502,21 +2377,21 @@ function matchesFilters(loaded, opts) {
 }
 
 // src/commands/memory-promote.ts
-import { mkdir as mkdir5, unlink, writeFile as writeFile5 } from "fs/promises";
-import { existsSync as existsSync9 } from "fs";
-import path9 from "path";
+import { mkdir as mkdir7, unlink, writeFile as writeFile7 } from "fs/promises";
+import { existsSync as existsSync12 } from "fs";
+import path13 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot11,
-  memoryFilePath as memoryFilePath2,
+  memoryFilePath as memoryFilePath3,
   resolveHaivePaths as resolveHaivePaths8,
-  serializeMemory as serializeMemory3
+  serializeMemory as serializeMemory4
 } from "@hiveai/core";
 function registerMemoryPromote(memory2) {
   memory2.command("promote <id>").description("Promote a personal memory to team scope (status -> proposed)").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
     const root = findProjectRoot11(opts.dir);
     const paths = resolveHaivePaths8(root);
-    if (!existsSync9(paths.memoriesDir)) {
+    if (!existsSync12(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -1550,31 +2425,31 @@ function registerMemoryPromote(memory2) {
       },
       body: found.memory.body
     };
-    const newPath = memoryFilePath2(paths, "team", updated.frontmatter.id);
-    await mkdir5(path9.dirname(newPath), { recursive: true });
-    await writeFile5(newPath, serializeMemory3(updated), "utf8");
+    const newPath = memoryFilePath3(paths, "team", updated.frontmatter.id);
+    await mkdir7(path13.dirname(newPath), { recursive: true });
+    await writeFile7(newPath, serializeMemory4(updated), "utf8");
     await unlink(found.filePath);
     ui.success(`Promoted ${id} to team scope (status=proposed)`);
-    ui.info(`Now at ${path9.relative(root, newPath)}`);
+    ui.info(`Now at ${path13.relative(root, newPath)}`);
     console.log(ui.dim(`\u2192 next: haive memory approve ${id}  (validate for team use)`));
   });
 }
 
 // src/commands/memory-approve.ts
-import { existsSync as existsSync10 } from "fs";
-import { writeFile as writeFile6 } from "fs/promises";
-import path10 from "path";
+import { existsSync as existsSync13 } from "fs";
+import { writeFile as writeFile8 } from "fs/promises";
+import path14 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot12,
   resolveHaivePaths as resolveHaivePaths9,
-  serializeMemory as serializeMemory4
+  serializeMemory as serializeMemory5
 } from "@hiveai/core";
 function registerMemoryApprove(memory2) {
   memory2.command("approve [id]").description("Mark a memory as 'validated'. Use --all to bulk-approve all proposed/draft memories.").option("--all", "approve all proposed and draft memories at once").option("--pending", "approve all memories with status 'proposed'").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
     const root = findProjectRoot12(opts.dir);
     const paths = resolveHaivePaths9(root);
-    if (!existsSync10(paths.memoriesDir)) {
+    if (!existsSync13(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -1596,7 +2471,7 @@ function registerMemoryApprove(memory2) {
           frontmatter: { ...found2.memory.frontmatter, status: "validated" },
           body: found2.memory.body
         };
-        await writeFile6(found2.filePath, serializeMemory4(next2), "utf8");
+        await writeFile8(found2.filePath, serializeMemory5(next2), "utf8");
         count++;
       }
       ui.success(`Approved ${count} memor${count === 1 ? "y" : "ies"} (status=validated)`);
@@ -1625,27 +2500,27 @@ function registerMemoryApprove(memory2) {
       frontmatter: { ...found.memory.frontmatter, status: "validated" },
       body: found.memory.body
     };
-    await writeFile6(found.filePath, serializeMemory4(next), "utf8");
+    await writeFile8(found.filePath, serializeMemory5(next), "utf8");
     ui.success(`Approved ${id} (status=validated)`);
-    ui.info(path10.relative(root, found.filePath));
+    ui.info(path14.relative(root, found.filePath));
   });
 }
 
 // src/commands/memory-update.ts
-import { writeFile as writeFile7 } from "fs/promises";
-import { existsSync as existsSync11 } from "fs";
-import path11 from "path";
+import { writeFile as writeFile9 } from "fs/promises";
+import { existsSync as existsSync14 } from "fs";
+import path15 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot13,
   resolveHaivePaths as resolveHaivePaths10,
-  serializeMemory as serializeMemory5
+  serializeMemory as serializeMemory6
 } from "@hiveai/core";
 function registerMemoryUpdate(memory2) {
   memory2.command("update <id>").description("Update body, tags, or anchor of an existing memory (preserves id and usage history)").option("--title <text>", "new title \u2014 replaces the first heading of the body").option("--body <text>", "new Markdown body \u2014 replaces the existing body").option("--tags <csv>", "new tags, comma-separated \u2014 fully replaces existing tags").option("--paths <csv>", "new anchor paths, comma-separated").option("--symbols <csv>", "new anchor symbols, comma-separated").option("--commit <sha>", "new anchor commit SHA").option("--domain <domain>", "new domain label").option("--author <author>", "new author handle or email").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
     const root = findProjectRoot13(opts.dir);
     const paths = resolveHaivePaths10(root);
-    if (!existsSync11(paths.memoriesDir)) {
+    if (!existsSync14(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -1692,12 +2567,12 @@ function registerMemoryUpdate(memory2) {
       ui.warn("Nothing to update \u2014 provide at least one option.");
       return;
     }
-    await writeFile7(
+    await writeFile9(
       loaded.filePath,
-      serializeMemory5({ frontmatter: newFrontmatter, body: newBody }),
+      serializeMemory6({ frontmatter: newFrontmatter, body: newBody }),
       "utf8"
     );
-    ui.success(`Updated ${path11.relative(root, loaded.filePath)}`);
+    ui.success(`Updated ${path15.relative(root, loaded.filePath)}`);
     ui.info(`fields: ${updated.join(", ")}`);
   });
 }
@@ -1716,9 +2591,9 @@ function parseCsv3(value) {
 }
 
 // src/commands/memory-auto-promote.ts
-import { writeFile as writeFile8 } from "fs/promises";
-import { existsSync as existsSync12 } from "fs";
-import path12 from "path";
+import { writeFile as writeFile10 } from "fs/promises";
+import { existsSync as existsSync15 } from "fs";
+import path16 from "path";
 import "commander";
 import {
   DEFAULT_AUTO_PROMOTE_RULE as DEFAULT_AUTO_PROMOTE_RULE2,
@@ -1727,7 +2602,7 @@ import {
   isAutoPromoteEligible as isAutoPromoteEligible2,
   loadUsageIndex as loadUsageIndex2,
   resolveHaivePaths as resolveHaivePaths11,
-  serializeMemory as serializeMemory6
+  serializeMemory as serializeMemory7
 } from "@hiveai/core";
 function registerMemoryAutoPromote(memory2) {
   memory2.command("auto-promote").description("Promote eligible 'proposed' memories to 'validated' based on usage").option("--min-reads <n>", "minimum read_count to qualify", String(DEFAULT_AUTO_PROMOTE_RULE2.minReads)).option(
@@ -1737,7 +2612,7 @@ function registerMemoryAutoPromote(memory2) {
   ).option("--apply", "actually write status=validated to disk (default: dry-run)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot14(opts.dir);
     const paths = resolveHaivePaths11(root);
-    if (!existsSync12(paths.memoriesDir)) {
+    if (!existsSync15(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -1763,13 +2638,13 @@ function registerMemoryAutoPromote(memory2) {
       console.log(
         `${ui.bold(opts.apply ? "PROMOTE" : "would promote")}  ${mem.frontmatter.id}  ${ui.dim(`reads=${u.read_count} rejections=${u.rejected_count}`)}`
       );
-      console.log(`             ${ui.dim(path12.relative(root, filePath))}`);
+      console.log(`             ${ui.dim(path16.relative(root, filePath))}`);
       if (opts.apply) {
         const next = {
           frontmatter: { ...mem.frontmatter, status: "validated" },
           body: mem.body
         };
-        await writeFile8(filePath, serializeMemory6(next), "utf8");
+        await writeFile10(filePath, serializeMemory7(next), "utf8");
         written++;
       }
     }
@@ -1780,9 +2655,9 @@ function registerMemoryAutoPromote(memory2) {
 
 // src/commands/memory-edit.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync13 } from "fs";
-import { readFile as readFile5 } from "fs/promises";
-import path13 from "path";
+import { existsSync as existsSync16 } from "fs";
+import { readFile as readFile8 } from "fs/promises";
+import path17 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot15,
@@ -1793,7 +2668,7 @@ function registerMemoryEdit(memory2) {
   memory2.command("edit <id>").description("Open a memory in $EDITOR and re-validate when you save").option("-e, --editor <cmd>", "editor command (defaults to $EDITOR or 'vi')").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
     const root = findProjectRoot15(opts.dir);
     const paths = resolveHaivePaths12(root);
-    if (!existsSync13(paths.memoriesDir)) {
+    if (!existsSync16(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -1806,13 +2681,13 @@ function registerMemoryEdit(memory2) {
       return;
     }
     const editor = opts.editor ?? process.env.EDITOR ?? process.env.VISUAL ?? "vi";
-    ui.info(`Opening ${path13.relative(root, found.filePath)} with ${editor}\u2026`);
+    ui.info(`Opening ${path17.relative(root, found.filePath)} with ${editor}\u2026`);
     const code = await runEditor(editor, found.filePath);
     if (code !== 0) {
       ui.warn(`Editor exited with status ${code}.`);
     }
     try {
-      const fresh = await readFile5(found.filePath, "utf8");
+      const fresh = await readFile8(found.filePath, "utf8");
       parseMemory(fresh);
       ui.success("Memory still parses cleanly.");
     } catch (err) {
@@ -1833,8 +2708,8 @@ function runEditor(editor, file) {
 }
 
 // src/commands/memory-for-files.ts
-import { existsSync as existsSync14 } from "fs";
-import path14 from "path";
+import { existsSync as existsSync17 } from "fs";
+import path18 from "path";
 import "commander";
 import {
   deriveConfidence,
@@ -1849,7 +2724,7 @@ function registerMemoryForFiles(memory2) {
   memory2.command("for-files <files...>").description("Show memories relevant to the given files (anchor overlap, module, domain)").option("-d, --dir <dir>", "project root").action(async (files, opts) => {
     const root = findProjectRoot16(opts.dir);
     const paths = resolveHaivePaths13(root);
-    if (!existsSync14(paths.memoriesDir)) {
+    if (!existsSync17(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -1956,13 +2831,13 @@ function printGroup(root, label, loaded, usage) {
     const u = getUsage3(usage, fm.id);
     const conf = deriveConfidence(fm, u);
     console.log(`${ui.bold(fm.id)}  ${ui.dim(`${fm.scope}/${fm.type}`)}  ${ui.bold(conf)}`);
-    console.log(`  ${ui.dim(path14.relative(root, filePath))}`);
+    console.log(`  ${ui.dim(path18.relative(root, filePath))}`);
   }
 }
 
 // src/commands/memory-hot.ts
-import { existsSync as existsSync15 } from "fs";
-import path15 from "path";
+import { existsSync as existsSync18 } from "fs";
+import path19 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot17,
@@ -1974,7 +2849,7 @@ function registerMemoryHot(memory2) {
   memory2.command("hot").description("List memories actively used but not yet validated (good promotion candidates)").option("--threshold <n>", "minimum read_count to qualify", "3").option("--status <status>", "limit to one status (default: draft + proposed)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot17(opts.dir);
     const paths = resolveHaivePaths14(root);
-    if (!existsSync15(paths.memoriesDir)) {
+    if (!existsSync18(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -2002,7 +2877,7 @@ function registerMemoryHot(memory2) {
       console.log(
         `${ui.bold(fm.id)}  ${ui.dim(`${fm.scope}/${fm.type}`)}  ${ui.bold(fm.status)}  ${ui.dim(`reads=${u.read_count} rejections=${u.rejected_count}`)}`
       );
-      console.log(`  ${ui.dim(path15.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path19.relative(root, filePath))}`);
     }
     ui.info(
       `${candidates.length} hot \u2014 promote drafts with \`haive memory promote <id>\`, then \`haive memory auto-promote --apply\`.`
@@ -2011,16 +2886,16 @@ function registerMemoryHot(memory2) {
 }
 
 // src/commands/memory-tried.ts
-import { mkdir as mkdir6, writeFile as writeFile9 } from "fs/promises";
-import { existsSync as existsSync16 } from "fs";
-import path16 from "path";
+import { mkdir as mkdir8, writeFile as writeFile11 } from "fs/promises";
+import { existsSync as existsSync19 } from "fs";
+import path20 from "path";
 import "commander";
 import {
-  buildFrontmatter as buildFrontmatter3,
+  buildFrontmatter as buildFrontmatter4,
   findProjectRoot as findProjectRoot18,
-  memoryFilePath as memoryFilePath3,
+  memoryFilePath as memoryFilePath4,
   resolveHaivePaths as resolveHaivePaths15,
-  serializeMemory as serializeMemory7
+  serializeMemory as serializeMemory8
 } from "@hiveai/core";
 function registerMemoryTried(memory2) {
   memory2.command("tried").description(
@@ -2041,13 +2916,13 @@ function registerMemoryTried(memory2) {
   ).requiredOption("--what <text>", "what approach was tried (short, descriptive title)").requiredOption("--why-failed <text>", "why it failed or should NOT be used (include the exact error if possible)").option("--instead <text>", "the correct approach to use instead").option("--scope <scope>", "personal | team | module (default: personal)", "personal").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags").option("--paths <csv>", "anchor paths, comma-separated").option("--author <author>", "author email or handle").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot18(opts.dir);
     const paths = resolveHaivePaths15(root);
-    if (!existsSync16(paths.haiveDir)) {
+    if (!existsSync19(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
     const slug = opts.what.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim().split(/\s+/).slice(0, 5).join("-");
-    const baseFm = buildFrontmatter3({
+    const baseFm = buildFrontmatter4({
       type: "attempt",
       slug,
       scope: opts.scope,
@@ -2063,15 +2938,15 @@ function registerMemoryTried(memory2) {
       lines.push("", `**Instead, use:** ${opts.instead}`);
     }
     const body = lines.join("\n") + "\n";
-    const file = memoryFilePath3(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir6(path16.dirname(file), { recursive: true });
-    if (existsSync16(file)) {
+    const file = memoryFilePath4(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
+    await mkdir8(path20.dirname(file), { recursive: true });
+    if (existsSync19(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
       return;
     }
-    await writeFile9(file, serializeMemory7({ frontmatter, body }), "utf8");
-    ui.success(`Recorded: ${path16.relative(root, file)}`);
+    await writeFile11(file, serializeMemory8({ frontmatter, body }), "utf8");
+    ui.success(`Recorded: ${path20.relative(root, file)}`);
     ui.info(`id=${frontmatter.id}  type=attempt  status=validated (auto-approved)`);
   });
 }
@@ -2081,8 +2956,8 @@ function parseCsv4(value) {
 }
 
 // src/commands/memory-pending.ts
-import { existsSync as existsSync17 } from "fs";
-import path17 from "path";
+import { existsSync as existsSync20 } from "fs";
+import path21 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot19,
@@ -2094,7 +2969,7 @@ function registerMemoryPending(memory2) {
   memory2.command("pending").description("List 'proposed' memories awaiting review (sorted by reads desc)").option("--scope <scope>", "filter by scope (personal | team | module)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot19(opts.dir);
     const paths = resolveHaivePaths16(root);
-    if (!existsSync17(paths.memoriesDir)) {
+    if (!existsSync20(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -2122,15 +2997,15 @@ function registerMemoryPending(memory2) {
       console.log(
         `${ui.bold(fm.id)}  ${ui.dim(`${fm.scope}/${fm.type}`)}  ${ui.dim(`age=${ageStr} reads=${u.read_count} rejections=${u.rejected_count}`)}`
       );
-      console.log(`  ${ui.dim(path17.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path21.relative(root, filePath))}`);
     }
     ui.info(`${proposed.length} pending`);
   });
 }
 
 // src/commands/memory-query.ts
-import { existsSync as existsSync18 } from "fs";
-import path18 from "path";
+import { existsSync as existsSync21 } from "fs";
+import path22 from "path";
 import "commander";
 import {
   extractSnippet,
@@ -2146,7 +3021,7 @@ function registerMemoryQuery(memory2) {
   memory2.command("query <text>").description("Search memories by id, tag, or substring (AND, OR fallback)").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 = findProjectRoot20(opts.dir);
     const paths = resolveHaivePaths17(root);
-    if (!existsSync18(paths.memoriesDir)) {
+    if (!existsSync21(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -2187,7 +3062,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(path18.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path22.relative(root, filePath))}`);
       const snippet = extractSnippet(mem.body, snippetNeedle);
       if (snippet) console.log(`  ${snippet}`);
     }
@@ -2204,8 +3079,8 @@ ${top.length} of ${matches.length} match${matches.length === 1 ? "" : "es"}`)
 }
 
 // src/commands/memory-reject.ts
-import { writeFile as writeFile10 } from "fs/promises";
-import { existsSync as existsSync19 } from "fs";
+import { writeFile as writeFile12 } from "fs/promises";
+import { existsSync as existsSync22 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot21,
@@ -2213,13 +3088,13 @@ import {
   recordRejection,
   resolveHaivePaths as resolveHaivePaths18,
   saveUsageIndex,
-  serializeMemory as serializeMemory8
+  serializeMemory as serializeMemory9
 } 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 = findProjectRoot21(opts.dir);
     const paths = resolveHaivePaths18(root);
-    if (!existsSync19(paths.memoriesDir)) {
+    if (!existsSync22(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -2231,9 +3106,9 @@ function registerMemoryReject(memory2) {
       process.exitCode = 1;
       return;
     }
-    await writeFile10(
+    await writeFile12(
       loaded.filePath,
-      serializeMemory8({
+      serializeMemory9({
         frontmatter: {
           ...loaded.memory.frontmatter,
           status: "rejected",
@@ -2255,9 +3130,9 @@ function registerMemoryReject(memory2) {
 }
 
 // src/commands/memory-rm.ts
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync23 } from "fs";
 import { unlink as unlink2 } from "fs/promises";
-import path19 from "path";
+import path23 from "path";
 import { createInterface } from "readline/promises";
 import "commander";
 import {
@@ -2270,7 +3145,7 @@ 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 = findProjectRoot22(opts.dir);
     const paths = resolveHaivePaths19(root);
-    if (!existsSync20(paths.memoriesDir)) {
+    if (!existsSync23(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -2282,7 +3157,7 @@ function registerMemoryRm(memory2) {
       process.exitCode = 1;
       return;
     }
-    const rel = path19.relative(root, found.filePath);
+    const rel = path23.relative(root, found.filePath);
     if (!opts.yes) {
       const rl = createInterface({ input: process.stdin, output: process.stdout });
       const answer = (await rl.question(`Delete ${rel}? [y/N] `)).trim().toLowerCase();
@@ -2306,9 +3181,9 @@ function registerMemoryRm(memory2) {
 }
 
 // src/commands/memory-show.ts
-import { existsSync as existsSync21 } from "fs";
-import { readFile as readFile6 } from "fs/promises";
-import path20 from "path";
+import { existsSync as existsSync24 } from "fs";
+import { readFile as readFile9 } from "fs/promises";
+import path24 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence2,
@@ -2321,7 +3196,7 @@ 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 = findProjectRoot23(opts.dir);
     const paths = resolveHaivePaths20(root);
-    if (!existsSync21(paths.memoriesDir)) {
+    if (!existsSync24(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -2334,7 +3209,7 @@ function registerMemoryShow(memory2) {
       return;
     }
     if (opts.raw) {
-      console.log(await readFile6(found.filePath, "utf8"));
+      console.log(await readFile9(found.filePath, "utf8"));
       return;
     }
     const fm = found.memory.frontmatter;
@@ -2350,7 +3225,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:")}       ${path20.relative(root, found.filePath)}`);
+    console.log(`${ui.dim("file:")}       ${path24.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}`);
@@ -2365,8 +3240,8 @@ function registerMemoryShow(memory2) {
 }
 
 // src/commands/memory-stats.ts
-import { existsSync as existsSync22 } from "fs";
-import path21 from "path";
+import { existsSync as existsSync25 } from "fs";
+import path25 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence3,
@@ -2379,7 +3254,7 @@ function registerMemoryStats(memory2) {
   memory2.command("stats").description("Show usage stats and confidence levels per memory").option("--id <id>", "show stats for a single memory id").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot24(opts.dir);
     const paths = resolveHaivePaths21(root);
-    if (!existsSync22(paths.memoriesDir)) {
+    if (!existsSync25(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -2404,20 +3279,20 @@ 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(path21.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path25.relative(root, filePath))}`);
     }
   });
 }
 
 // src/commands/memory-verify.ts
-import { writeFile as writeFile11 } from "fs/promises";
-import { existsSync as existsSync23 } from "fs";
-import path22 from "path";
+import { writeFile as writeFile13 } from "fs/promises";
+import { existsSync as existsSync26 } from "fs";
+import path26 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot25,
   resolveHaivePaths as resolveHaivePaths22,
-  serializeMemory as serializeMemory9,
+  serializeMemory as serializeMemory10,
   verifyAnchor as verifyAnchor2
 } from "@hiveai/core";
 function registerMemoryVerify(memory2) {
@@ -2426,7 +3301,7 @@ function registerMemoryVerify(memory2) {
   ).option("--id <id>", "verify a single memory by id").option("--all", "verify every memory (default if --id is omitted)").option("--update", "write status=stale or status=validated back to disk").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot25(opts.dir);
     const paths = resolveHaivePaths22(root);
-    if (!existsSync23(paths.memoriesDir)) {
+    if (!existsSync26(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -2449,7 +3324,7 @@ function registerMemoryVerify(memory2) {
         anchorlessIds.push(mem.frontmatter.id);
         continue;
       }
-      const rel = path22.relative(root, filePath);
+      const rel = path26.relative(root, filePath);
       if (result.stale) {
         staleCount++;
         console.log(`${ui.bold("STALE")}  ${mem.frontmatter.id}`);
@@ -2464,7 +3339,7 @@ function registerMemoryVerify(memory2) {
       }
       if (opts.update) {
         const next = applyVerification(mem, result);
-        await writeFile11(filePath, serializeMemory9(next), "utf8");
+        await writeFile13(filePath, serializeMemory10(next), "utf8");
         updated++;
       }
     }
@@ -2512,8 +3387,8 @@ function applyVerification(mem, result) {
 }
 
 // src/commands/memory-import.ts
-import { readFile as readFile7 } from "fs/promises";
-import { existsSync as existsSync24 } from "fs";
+import { readFile as readFile10 } from "fs/promises";
+import { existsSync as existsSync27 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot26,
@@ -2525,17 +3400,17 @@ function registerMemoryImport(memory2) {
   ).requiredOption("--from <file>", "Markdown/text file to import from").option("--scope <scope>", "personal | team (default: team)", "team").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot26(opts.dir);
     const paths = resolveHaivePaths23(root);
-    if (!existsSync24(paths.haiveDir)) {
+    if (!existsSync27(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    if (!existsSync24(opts.from)) {
+    if (!existsSync27(opts.from)) {
       ui.error(`File not found: ${opts.from}`);
       process.exitCode = 1;
       return;
     }
-    const content = await readFile7(opts.from, "utf8");
+    const content = await readFile10(opts.from, "utf8");
     const scope = opts.scope ?? "team";
     ui.info(`Preparing import from: ${opts.from}  (scope=${scope})`);
     ui.info(`Content length: ${content.length} chars`);
@@ -2563,15 +3438,15 @@ function registerMemoryImport(memory2) {
 }
 
 // src/commands/memory-import-changelog.ts
-import { existsSync as existsSync25 } from "fs";
-import { readFile as readFile8, mkdir as mkdir7, writeFile as writeFile12 } from "fs/promises";
-import path23 from "path";
+import { existsSync as existsSync28 } from "fs";
+import { readFile as readFile11, mkdir as mkdir9, writeFile as writeFile14 } from "fs/promises";
+import path27 from "path";
 import "commander";
 import {
-  buildFrontmatter as buildFrontmatter4,
+  buildFrontmatter as buildFrontmatter5,
   findProjectRoot as findProjectRoot27,
   resolveHaivePaths as resolveHaivePaths24,
-  serializeMemory as serializeMemory10
+  serializeMemory as serializeMemory11
 } from "@hiveai/core";
 function parseChangelog(content) {
   const entries = [];
@@ -2636,13 +3511,13 @@ function registerMemoryImportChangelog(memory2) {
   ).option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot27(opts.dir);
     const paths = resolveHaivePaths24(root);
-    const changelogPath = path23.resolve(root, opts.fromChangelog);
-    if (!existsSync25(changelogPath)) {
+    const changelogPath = path27.resolve(root, opts.fromChangelog);
+    if (!existsSync28(changelogPath)) {
       ui.error(`CHANGELOG not found: ${changelogPath}`);
       process.exitCode = 1;
       return;
     }
-    const content = await readFile8(changelogPath, "utf8");
+    const content = await readFile11(changelogPath, "utf8");
     let entries = parseChangelog(content);
     if (entries.length === 0) {
       ui.warn("No breaking changes, deprecations, or removals found in the CHANGELOG.");
@@ -2656,10 +3531,10 @@ function registerMemoryImportChangelog(memory2) {
         entries = entries.filter((e) => requested.includes(e.version));
       }
     }
-    const pkgName = opts.package ?? path23.basename(path23.dirname(changelogPath));
+    const pkgName = opts.package ?? path27.basename(path27.dirname(changelogPath));
     const scope = opts.scope ?? "team";
-    const teamDir = path23.join(paths.memoriesDir, scope);
-    await mkdir7(teamDir, { recursive: true });
+    const teamDir = path27.join(paths.memoriesDir, scope);
+    await mkdir9(teamDir, { recursive: true });
     let saved = 0;
     for (const entry of entries) {
       const lines = [];
@@ -2681,11 +3556,11 @@ function registerMemoryImportChangelog(memory2) {
         lines.push("");
       }
       lines.push(
-        `**Source:** \`${path23.relative(root, changelogPath)}\`  
+        `**Source:** \`${path27.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, "-")}`;
-      const fm = buildFrontmatter4({
+      const fm = buildFrontmatter5({
         type: "gotcha",
         slug,
         scope,
@@ -2696,12 +3571,12 @@ function registerMemoryImportChangelog(memory2) {
           pkgName.replace(/[^a-z0-9]/gi, "-").toLowerCase(),
           `v${entry.version}`
         ],
-        paths: [path23.relative(root, changelogPath)],
+        paths: [path27.relative(root, changelogPath)],
         topic: `changelog-${pkgName}-${entry.version}`
       });
-      await writeFile12(
-        path23.join(teamDir, `${fm.id}.md`),
-        serializeMemory10({ frontmatter: fm, body: lines.join("\n") }),
+      await writeFile14(
+        path27.join(teamDir, `${fm.id}.md`),
+        serializeMemory11({ frontmatter: fm, body: lines.join("\n") }),
         "utf8"
       );
       console.log(ui.green(`  \u2713 ${fm.id}`));
@@ -2723,9 +3598,9 @@ ${ui.bold(`Imported ${saved} changelog entr${saved === 1 ? "y" : "ies"} from ${p
 }
 
 // src/commands/memory-digest.ts
-import { existsSync as existsSync26 } from "fs";
-import { writeFile as writeFile13 } from "fs/promises";
-import path24 from "path";
+import { existsSync as existsSync29 } from "fs";
+import { writeFile as writeFile15 } from "fs/promises";
+import path28 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence4,
@@ -2748,7 +3623,7 @@ function registerMemoryDigest(program2) {
   ).option("--days <n>", "look-back window in days (default: 7)", "7").option("--scope <scope>", "personal | team | module | all (default: team)", "team").option("--out <file>", "write digest to a file instead of stdout").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot28(opts.dir);
     const paths = resolveHaivePaths25(root);
-    if (!existsSync26(paths.memoriesDir)) {
+    if (!existsSync29(paths.memoriesDir)) {
       ui.error("No .ai/memories found. Run `haive init` first.");
       process.exitCode = 1;
       return;
@@ -2820,8 +3695,8 @@ function registerMemoryDigest(program2) {
     );
     const digest = lines.join("\n");
     if (opts.out) {
-      const outPath = path24.resolve(process.cwd(), opts.out);
-      await writeFile13(outPath, digest, "utf8");
+      const outPath = path28.resolve(process.cwd(), opts.out);
+      await writeFile15(outPath, digest, "utf8");
       ui.success(`Digest written to ${opts.out}  (${recent.length} memor${recent.length === 1 ? "y" : "ies"})`);
     } else {
       console.log(digest);
@@ -2830,17 +3705,17 @@ function registerMemoryDigest(program2) {
 }
 
 // src/commands/session-end.ts
-import { writeFile as writeFile14, mkdir as mkdir8 } from "fs/promises";
-import { existsSync as existsSync27 } from "fs";
-import path25 from "path";
+import { writeFile as writeFile16, mkdir as mkdir10 } from "fs/promises";
+import { existsSync as existsSync30 } from "fs";
+import path29 from "path";
 import "commander";
 import {
-  buildFrontmatter as buildFrontmatter5,
+  buildFrontmatter as buildFrontmatter6,
   findProjectRoot as findProjectRoot29,
   loadMemoriesFromDir as loadMemoriesFromDir6,
-  memoryFilePath as memoryFilePath4,
+  memoryFilePath as memoryFilePath5,
   resolveHaivePaths as resolveHaivePaths26,
-  serializeMemory as serializeMemory11
+  serializeMemory as serializeMemory12
 } from "@hiveai/core";
 function buildRecapBody(opts) {
   const lines = [];
@@ -2891,7 +3766,7 @@ function registerSessionEnd(session2) {
   ).requiredOption("--goal <text>", "what you were trying to accomplish (1\u20132 sentences)").requiredOption("--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("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot29(opts.dir);
     const paths = resolveHaivePaths26(root);
-    if (!existsSync27(paths.haiveDir)) {
+    if (!existsSync30(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -2900,12 +3775,12 @@ function registerSessionEnd(session2) {
     const body = buildRecapBody(opts);
     const topic = recapTopic(scope, opts.module);
     const filesTouched = parseCsv5(opts.files);
-    const missingPaths = filesTouched.filter((p) => !existsSync27(path25.resolve(root, p)));
+    const missingPaths = filesTouched.filter((p) => !existsSync30(path29.resolve(root, p)));
     if (missingPaths.length > 0) {
       ui.warn(`Anchor path${missingPaths.length > 1 ? "s" : ""} not found in project (will be stale):`);
       for (const p of missingPaths) ui.warn(`  \u2717 ${p}`);
     }
-    if (existsSync27(paths.memoriesDir)) {
+    if (existsSync30(paths.memoriesDir)) {
       const existing = await loadMemoriesFromDir6(paths.memoriesDir);
       const topicMatch = existing.find(
         ({ memory: memory2 }) => memory2.frontmatter.topic === topic && memory2.frontmatter.scope === scope && (!opts.module || memory2.frontmatter.module === opts.module)
@@ -2921,13 +3796,13 @@ function registerSessionEnd(session2) {
             paths: filesTouched.length ? filesTouched : fm.anchor.paths
           }
         };
-        await writeFile14(topicMatch.filePath, serializeMemory11({ frontmatter: newFrontmatter, body }), "utf8");
+        await writeFile16(topicMatch.filePath, serializeMemory12({ frontmatter: newFrontmatter, body }), "utf8");
         ui.success(`Session recap updated (revision #${revisionCount})`);
-        ui.info(`id=${fm.id}  file=${path25.relative(root, topicMatch.filePath)}`);
+        ui.info(`id=${fm.id}  file=${path29.relative(root, topicMatch.filePath)}`);
         return;
       }
     }
-    const frontmatter = buildFrontmatter5({
+    const frontmatter = buildFrontmatter6({
       type: "session_recap",
       slug: "recap",
       scope,
@@ -2937,11 +3812,11 @@ function registerSessionEnd(session2) {
       topic,
       status: "validated"
     });
-    const file = memoryFilePath4(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir8(path25.dirname(file), { recursive: true });
-    await writeFile14(file, serializeMemory11({ frontmatter, body }), "utf8");
+    const file = memoryFilePath5(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
+    await mkdir10(path29.dirname(file), { recursive: true });
+    await writeFile16(file, serializeMemory12({ frontmatter, body }), "utf8");
     ui.success(`Session recap created`);
-    ui.info(`id=${frontmatter.id}  scope=${scope}  file=${path25.relative(root, file)}`);
+    ui.info(`id=${frontmatter.id}  scope=${scope}  file=${path29.relative(root, file)}`);
     ui.info("Next session: call `get_briefing` \u2014 the recap will be surfaced automatically.");
   });
 }
@@ -2951,9 +3826,9 @@ function parseCsv5(value) {
 }
 
 // src/commands/snapshot.ts
-import { existsSync as existsSync28 } from "fs";
-import { readdir } from "fs/promises";
-import path26 from "path";
+import { existsSync as existsSync31 } from "fs";
+import { readdir as readdir2 } from "fs/promises";
+import path30 from "path";
 import "commander";
 import {
   diffContract,
@@ -2986,18 +3861,18 @@ function registerSnapshot(program2) {
   ).option("--diff", "compare the contract against its stored snapshot").option("--list", "list all stored contract snapshots").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot30(opts.dir);
     const paths = resolveHaivePaths27(root);
-    if (!existsSync28(paths.haiveDir)) {
+    if (!existsSync31(paths.haiveDir)) {
       ui.error("No .ai/ found. Run `haive init` first.");
       process.exitCode = 1;
       return;
     }
     if (opts.list) {
-      const contractsDir = path26.join(paths.haiveDir, "contracts");
-      if (!existsSync28(contractsDir)) {
+      const contractsDir = path30.join(paths.haiveDir, "contracts");
+      if (!existsSync31(contractsDir)) {
         console.log(ui.dim("No contract snapshots found."));
         return;
       }
-      const files = (await readdir(contractsDir)).filter(
+      const files = (await readdir2(contractsDir)).filter(
         (f) => f.endsWith(".lock") && !f.startsWith("deps-")
       );
       if (files.length === 0) {
@@ -3048,7 +3923,7 @@ function registerSnapshot(program2) {
       return;
     }
     const contractPath = opts.contract;
-    const name = opts.name ?? path26.basename(contractPath, path26.extname(contractPath));
+    const name = opts.name ?? path30.basename(contractPath, path30.extname(contractPath));
     const format = opts.format ?? detectFormat(contractPath) ?? "openapi";
     const contract = { name, path: contractPath, format };
     try {
@@ -3103,8 +3978,8 @@ async function runDiff(root, haiveDir, contract) {
   }
 }
 function detectFormat(filePath) {
-  const ext = path26.extname(filePath).toLowerCase();
-  const base = path26.basename(filePath).toLowerCase();
+  const ext = path30.extname(filePath).toLowerCase();
+  const base = path30.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";
@@ -3117,9 +3992,9 @@ function detectFormat(filePath) {
 }
 
 // src/commands/hub.ts
-import { existsSync as existsSync29 } from "fs";
-import { mkdir as mkdir9, readFile as readFile9, writeFile as writeFile15, copyFile } from "fs/promises";
-import path27 from "path";
+import { existsSync as existsSync32 } from "fs";
+import { mkdir as mkdir11, readFile as readFile12, writeFile as writeFile17, copyFile } from "fs/promises";
+import path31 from "path";
 import { spawnSync as spawnSync3 } from "child_process";
 import "commander";
 import {
@@ -3128,7 +4003,7 @@ import {
   loadMemoriesFromDir as loadMemoriesFromDir7,
   resolveHaivePaths as resolveHaivePaths28,
   saveConfig as saveConfig2,
-  serializeMemory as serializeMemory12
+  serializeMemory as serializeMemory13
 } from "@hiveai/core";
 function registerHub(program2) {
   const hub = program2.command("hub").description(
@@ -3138,8 +4013,8 @@ 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 = path27.resolve(hubPath);
-    await mkdir9(absPath, { recursive: true });
+    const absPath = path31.resolve(hubPath);
+    await mkdir11(absPath, { recursive: true });
     const gitCheck = spawnSync3("git", ["rev-parse", "--git-dir"], { cwd: absPath });
     if (gitCheck.status !== 0) {
       const init = spawnSync3("git", ["init"], { cwd: absPath, encoding: "utf8" });
@@ -3149,10 +4024,10 @@ function registerHub(program2) {
         return;
       }
     }
-    const sharedDir = path27.join(absPath, ".ai", "memories", "shared");
-    await mkdir9(sharedDir, { recursive: true });
-    await writeFile15(
-      path27.join(absPath, ".ai", "README.md"),
+    const sharedDir = path31.join(absPath, ".ai", "memories", "shared");
+    await mkdir11(sharedDir, { recursive: true });
+    await writeFile17(
+      path31.join(absPath, ".ai", "README.md"),
       `# hAIve Team Knowledge Hub
 
 This repo is a shared knowledge hub for hAIve.
@@ -3173,8 +4048,8 @@ haive hub pull   # import into a project
 `,
       "utf8"
     );
-    await writeFile15(
-      path27.join(absPath, ".gitignore"),
+    await writeFile17(
+      path31.join(absPath, ".gitignore"),
       ".ai/.cache/\n.ai/memories/personal/\n",
       "utf8"
     );
@@ -3189,7 +4064,7 @@ haive hub pull   # import into a project
         `
 Next steps:
   1. Add hubPath to your project's .ai/haive.config.json:
-       { "hubPath": "${path27.relative(process.cwd(), absPath)}" }
+       { "hubPath": "${path31.relative(process.cwd(), absPath)}" }
   2. Run \`haive hub push\` to publish your shared memories
   3. Share ${absPath} with teammates (git remote, NFS, etc.)
 `
@@ -3218,15 +4093,15 @@ Next steps:
       process.exitCode = 1;
       return;
     }
-    const hubRoot = path27.resolve(root, config.hubPath);
-    if (!existsSync29(hubRoot)) {
+    const hubRoot = path31.resolve(root, config.hubPath);
+    if (!existsSync32(hubRoot)) {
       ui.error(`Hub not found at ${hubRoot}. Run \`haive hub init ${config.hubPath}\` first.`);
       process.exitCode = 1;
       return;
     }
-    const projectName = path27.basename(root);
-    const destDir = path27.join(hubRoot, ".ai", "memories", "shared", projectName);
-    await mkdir9(destDir, { recursive: true });
+    const projectName = path31.basename(root);
+    const destDir = path31.join(hubRoot, ".ai", "memories", "shared", projectName);
+    await mkdir11(destDir, { recursive: true });
     const all = await loadMemoriesFromDir7(paths.memoriesDir);
     const shared = all.filter(
       ({ memory: memory2 }) => memory2.frontmatter.scope === "shared" && memory2.frontmatter.status !== "rejected" && memory2.frontmatter.status !== "deprecated" && // Don't push imported memories (avoid echo loops)
@@ -3244,15 +4119,15 @@ Next steps:
     for (const { memory: memory2 } of shared) {
       const fm = memory2.frontmatter;
       const fileName = `${fm.id}.md`;
-      const destPath = path27.join(destDir, fileName);
-      await writeFile15(destPath, serializeMemory12(memory2), "utf8");
+      const destPath = path31.join(destDir, fileName);
+      await writeFile17(destPath, serializeMemory13(memory2), "utf8");
       pushed++;
     }
     console.log(ui.green(`\u2713 Pushed ${pushed} shared memor${pushed === 1 ? "y" : "ies"} to hub`));
     console.log(ui.dim(`  Location: ${destDir}`));
     if (opts.commit) {
       const message = opts.message ?? `haive: sync shared memories from ${projectName} (${pushed} memories)`;
-      spawnSync3("git", ["add", path27.join(".ai", "memories", "shared", projectName)], {
+      spawnSync3("git", ["add", path31.join(".ai", "memories", "shared", projectName)], {
         cwd: hubRoot
       });
       const commit = spawnSync3("git", ["commit", "-m", message], {
@@ -3287,15 +4162,15 @@ Next steps:
       process.exitCode = 1;
       return;
     }
-    const hubRoot = path27.resolve(root, config.hubPath);
-    const hubSharedDir = path27.join(hubRoot, ".ai", "memories", "shared");
-    if (!existsSync29(hubSharedDir)) {
+    const hubRoot = path31.resolve(root, config.hubPath);
+    const hubSharedDir = path31.join(hubRoot, ".ai", "memories", "shared");
+    if (!existsSync32(hubSharedDir)) {
       ui.warn("Hub has no shared memories yet. Run `haive hub push` from other projects first.");
       return;
     }
-    const projectName = path27.basename(root);
-    const { readdir: readdir2 } = await import("fs/promises");
-    const projectDirs = (await readdir2(hubSharedDir, { withFileTypes: true })).filter((d) => d.isDirectory() && d.name !== projectName).map((d) => d.name);
+    const projectName = path31.basename(root);
+    const { readdir: readdir3 } = await import("fs/promises");
+    const projectDirs = (await readdir3(hubSharedDir, { withFileTypes: true })).filter((d) => d.isDirectory() && d.name !== projectName).map((d) => d.name);
     if (projectDirs.length === 0) {
       console.log(ui.dim("No other projects have pushed to the hub yet."));
       return;
@@ -3303,17 +4178,17 @@ Next steps:
     let totalImported = 0;
     let totalUpdated = 0;
     for (const sourceName of projectDirs) {
-      const sourceDir = path27.join(hubSharedDir, sourceName);
-      const destDir = path27.join(paths.memoriesDir, "shared", sourceName);
-      await mkdir9(destDir, { recursive: true });
-      const sourceFiles = (await readdir2(sourceDir)).filter((f) => f.endsWith(".md"));
+      const sourceDir = path31.join(hubSharedDir, sourceName);
+      const destDir = path31.join(paths.memoriesDir, "shared", sourceName);
+      await mkdir11(destDir, { recursive: true });
+      const sourceFiles = (await readdir3(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 = path27.join(sourceDir, file);
-        const destPath = path27.join(destDir, file);
-        const fileContent = await readFile9(srcPath, "utf8");
+        const srcPath = path31.join(sourceDir, file);
+        const destPath = path31.join(destDir, file);
+        const fileContent = await readFile12(srcPath, "utf8");
         const alreadyTagged = fileContent.includes(`cross-repo:${sourceName}`);
         if (!alreadyTagged) {
           await copyFile(srcPath, destPath);
@@ -3343,14 +4218,14 @@ Next steps:
     console.log(
       `  hubPath: ${config.hubPath ? ui.green(config.hubPath) : ui.dim("not configured")}`
     );
-    const sharedDir = path27.join(paths.memoriesDir, "shared");
-    if (existsSync29(sharedDir)) {
-      const { readdir: readdir2 } = await import("fs/promises");
-      const sources = (await readdir2(sharedDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
+    const sharedDir = path31.join(paths.memoriesDir, "shared");
+    if (existsSync32(sharedDir)) {
+      const { readdir: readdir3 } = await import("fs/promises");
+      const sources = (await readdir3(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 readdir2(path27.join(sharedDir, src))).filter((f) => f.endsWith(".md"));
+        const files = (await readdir3(path31.join(sharedDir, src))).filter((f) => f.endsWith(".md"));
         console.log(`    ${src}: ${files.length} memor${files.length === 1 ? "y" : "ies"}`);
       }
     } else {
@@ -3365,8 +4240,8 @@ Next steps:
     if (outgoing.length > 0) {
       console.log(ui.dim("  Run `haive hub push` to publish them to the hub."));
     }
-    void readFile9;
-    void writeFile15;
+    void readFile12;
+    void writeFile17;
     void saveConfig2;
   });
 }
@@ -3568,13 +4443,20 @@ function summarize(name, t0, payload, notes) {
 }
 
 // src/commands/memory-suggest.ts
+import { mkdir as mkdir12, writeFile as writeFile18 } from "fs/promises";
+import { existsSync as existsSync33 } from "fs";
+import path32 from "path";
 import "commander";
 import {
   aggregateUsage as aggregateUsage2,
+  buildFrontmatter as buildFrontmatter7,
   findProjectRoot as findProjectRoot34,
+  loadMemoriesFromDir as loadMemoriesFromDir8,
+  memoryFilePath as memoryFilePath6,
   parseSince as parseSince2,
   readUsageEvents as readUsageEvents2,
-  resolveHaivePaths as resolveHaivePaths31
+  resolveHaivePaths as resolveHaivePaths31,
+  serializeMemory as serializeMemory14
 } from "@hiveai/core";
 var SEARCH_TOOLS = /* @__PURE__ */ new Set([
   "mem_search",
@@ -3583,7 +4465,9 @@ var SEARCH_TOOLS = /* @__PURE__ */ new Set([
   "get_briefing"
 ]);
 function registerMemorySuggest(memory2) {
-  memory2.command("suggest").description("Suggest memories to create based on recurring search queries in the usage log.").option("--since <window>", "ISO date or relative (e.g. '7d', '24h')", "30d").option("--min <count>", "minimum repeat count to surface a query", "2").option("--json", "emit JSON instead of human-readable output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
+  memory2.command("suggest").description(
+    "Suggest memories to create based on recurring search queries in the usage log.\n\n  Use --auto-save to draft the top-N suggestions as draft memories. They land\n  in personal scope by default with status=draft, ready for you to edit and promote."
+  ).option("--since <window>", "ISO date or relative (e.g. '7d', '24h')", "30d").option("--min <count>", "minimum repeat count to surface a query", "2").option("--top-n <n>", "with --auto-save, draft this many top suggestions", "3").option("--scope <scope>", "with --auto-save, scope of drafted memories (personal | team)", "personal").option("--auto-save", "draft top-N suggestions as draft memories on disk", false).option("--json", "emit JSON instead of human-readable output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot34(opts.dir);
     const paths = resolveHaivePaths31(root);
     const events = await readUsageEvents2(paths);
@@ -3618,8 +4502,67 @@ function registerMemorySuggest(memory2) {
       count: v.count,
       tools: [...v.tools].sort(),
       last_used: v.last,
-      reason: chooseReason(v.tools, v.count)
+      reason: chooseReason(v.tools, v.count),
+      inferred_type: inferType(v.tools, query)
     })).sort((a, b) => b.count - a.count);
+    if (opts.autoSave) {
+      const topN = Math.max(1, parseInt(opts.topN ?? "3", 10));
+      const scope = opts.scope === "team" ? "team" : "personal";
+      const top = suggestions.slice(0, topN);
+      if (top.length === 0) {
+        ui.warn(`No suggestions met --min=${minCount} \u2014 nothing to draft.`);
+        return;
+      }
+      const created = [];
+      const skipped = [];
+      const existing = existsSync33(paths.memoriesDir) ? await loadMemoriesFromDir8(paths.memoriesDir) : [];
+      for (const s of top) {
+        const slug = slugify(s.query);
+        if (!slug) {
+          skipped.push({ query: s.query, reason: "could not derive a slug" });
+          continue;
+        }
+        const dup = existing.find(({ memory: memory3 }) => memory3.frontmatter.id.endsWith(`-${slug}`));
+        if (dup) {
+          skipped.push({ query: s.query, reason: `similar memory already exists (${dup.memory.frontmatter.id})` });
+          continue;
+        }
+        const fm = buildFrontmatter7({
+          type: s.inferred_type,
+          slug,
+          scope,
+          tags: ["auto-suggested", ...s.tools],
+          paths: [],
+          symbols: []
+        });
+        fm.status = "draft";
+        const body = renderTemplate(s);
+        const file = memoryFilePath6(paths, fm.scope, fm.id, fm.module);
+        await mkdir12(path32.dirname(file), { recursive: true });
+        if (existsSync33(file)) {
+          skipped.push({ query: s.query, reason: `file already exists at ${path32.relative(root, file)}` });
+          continue;
+        }
+        await writeFile18(file, serializeMemory14({ frontmatter: fm, body }), "utf8");
+        created.push({ id: fm.id, file: path32.relative(root, file), query: s.query });
+      }
+      if (opts.json) {
+        console.log(JSON.stringify({ created, skipped }, null, 2));
+        return;
+      }
+      for (const c of created) {
+        ui.success(`Drafted ${c.id} \u2192 ${c.file}`);
+        console.log(`     ${ui.dim("from query:")} ${truncate(c.query, 60)}`);
+      }
+      for (const s of skipped) {
+        ui.warn(`Skipped: ${truncate(s.query, 50)} \u2014 ${s.reason}`);
+      }
+      if (created.length > 0) {
+        console.log();
+        ui.info("Drafts are status=draft \u2014 edit them, then `haive memory promote` to validate.");
+      }
+      return;
+    }
     if (opts.json) {
       console.log(JSON.stringify({ window: opts.since, suggestions }, null, 2));
       return;
@@ -3640,6 +4583,8 @@ function registerMemorySuggest(memory2) {
       );
       console.log(`     ${ui.dim("\u2192")} ${s.reason}`);
     }
+    console.log();
+    ui.info("Run with --auto-save to draft the top-3 as draft memories.");
   });
 }
 function chooseReason(tools, count) {
@@ -3651,14 +4596,594 @@ function chooseReason(tools, count) {
   }
   return `${count} agents asked the briefing for this \u2014 consider promoting the answer to a team memory.`;
 }
+function inferType(tools, query) {
+  const q = query.toLowerCase();
+  if (q.includes("bug") || q.includes("error") || q.includes("crash") || q.includes("trap")) return "gotcha";
+  if (q.includes("decid") || q.includes("why") || q.includes("choose") || q.includes("vs ")) return "decision";
+  if (tools.has("code_search") && (q.includes("where") || q.includes("location") || q.includes("structure"))) {
+    return "architecture";
+  }
+  return "convention";
+}
+function renderTemplate(s) {
+  return [
+    `# Auto-drafted from recurring searches`,
+    ``,
+    `> This memory was drafted by \`haive memory suggest --auto-save\` because`,
+    `> agents searched for this **${s.count} times** in the recent window`,
+    `> via ${s.tools.join(", ")}.`,
+    ``,
+    `## Query`,
+    ``,
+    `> ${s.query}`,
+    ``,
+    `## What to fill in`,
+    ``,
+    `Replace this section with the actual answer the team keeps re-discovering:`,
+    ``,
+    `- **What** \u2014 the convention / decision / gotcha (1-3 sentences)`,
+    `- **Why** \u2014 the rationale or root cause`,
+    `- **How to apply** \u2014 what an agent should do when this comes up again`,
+    ``,
+    `Then run \`haive memory promote ${truncate(s.query, 30)}\` to mark it validated.`
+  ].join("\n");
+}
+function slugify(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+}
 function truncate(text, max) {
   if (text.length <= max) return text;
   return text.slice(0, max - 1) + "\u2026";
 }
 
+// src/commands/memory-archive.ts
+import { existsSync as existsSync34 } from "fs";
+import { writeFile as writeFile19 } from "fs/promises";
+import path33 from "path";
+import "commander";
+import {
+  findProjectRoot as findProjectRoot35,
+  getUsage as getUsage9,
+  loadMemoriesFromDir as loadMemoriesFromDir9,
+  loadUsageIndex as loadUsageIndex11,
+  resolveHaivePaths as resolveHaivePaths32,
+  serializeMemory as serializeMemory15
+} from "@hiveai/core";
+var MS_PER_DAY = 24 * 60 * 60 * 1e3;
+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 = findProjectRoot35(opts.dir);
+    const paths = resolveHaivePaths32(root);
+    if (!existsSync34(paths.memoriesDir)) {
+      ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
+      process.exitCode = 1;
+      return;
+    }
+    const minDays = parseDays(opts.since ?? "180d");
+    if (minDays === null) {
+      ui.error(`Invalid --since value: ${opts.since}. Use formats like '180d', '6m', '1y'.`);
+      process.exitCode = 1;
+      return;
+    }
+    const cutoff = Date.now() - minDays * MS_PER_DAY;
+    const all = await loadMemoriesFromDir9(paths.memoriesDir);
+    const usage = await loadUsageIndex11(paths);
+    const typeFilter = opts.type === "all" ? null : opts.type ?? "attempt";
+    const candidates = [];
+    for (const { memory: mem, filePath } of all) {
+      const fm = mem.frontmatter;
+      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) => !existsSync34(path33.join(paths.root, p)));
+      const isAnchorless = !hasAnyAnchor;
+      if (!isAnchorless && !allPathsGone) continue;
+      const u = getUsage9(usage, fm.id);
+      const lastSeen = u.last_read_at ?? fm.created_at;
+      if (Date.parse(lastSeen) >= cutoff) continue;
+      candidates.push({
+        id: fm.id,
+        type: fm.type,
+        status: fm.status,
+        last_seen: lastSeen,
+        reason: isAnchorless ? `anchorless and not read since ${lastSeen.slice(0, 10)}` : `all ${fm.anchor.paths.length} anchored path(s) missing and not read since ${lastSeen.slice(0, 10)}`,
+        filePath
+      });
+    }
+    if (opts.json) {
+      console.log(JSON.stringify({
+        dry_run: !opts.apply,
+        window_days: minDays,
+        candidates: candidates.length,
+        archived: opts.apply ? candidates.length : 0,
+        items: candidates
+      }, null, 2));
+    } else {
+      const header = opts.apply ? "Archiving" : "Would archive";
+      console.log(ui.bold(`${header} ${candidates.length} memor${candidates.length === 1 ? "y" : "ies"} (older than ${minDays}d, type=${typeFilter ?? "all"})`));
+      if (candidates.length === 0) {
+        ui.info("Nothing to archive \u2014 all memories are anchored or read recently.");
+        return;
+      }
+      for (const c of candidates) {
+        console.log(`  ${ui.dim(c.last_seen.slice(0, 10))} ${c.id} ${ui.dim(`(${c.type})`)} \u2014 ${c.reason}`);
+      }
+    }
+    if (!opts.apply) {
+      if (!opts.json) {
+        console.log();
+        ui.info("Dry run \u2014 pass --apply to mark these as deprecated on disk.");
+      }
+      return;
+    }
+    let archived = 0;
+    let failed = 0;
+    for (const c of candidates) {
+      const found = all.find(({ filePath }) => filePath === c.filePath);
+      if (!found) continue;
+      const fm = { ...found.memory.frontmatter, status: "deprecated" };
+      try {
+        await writeFile19(c.filePath, serializeMemory15({ frontmatter: fm, body: found.memory.body }), "utf8");
+        archived++;
+      } catch (err) {
+        if (!opts.json) {
+          ui.error(`Failed to archive ${c.id}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        failed++;
+      }
+    }
+    if (!opts.json) {
+      ui.success(`Archived ${archived} memor${archived === 1 ? "y" : "ies"}${failed > 0 ? ` (${failed} failed)` : ""}`);
+    }
+  });
+}
+function parseDays(input) {
+  const m = input.match(/^(\d+)([dmy])$/);
+  if (!m) return null;
+  const n = parseInt(m[1] ?? "0", 10);
+  const unit = m[2] ?? "d";
+  if (unit === "d") return n;
+  if (unit === "m") return n * 30;
+  if (unit === "y") return n * 365;
+  return null;
+}
+
+// src/commands/doctor.ts
+import { existsSync as existsSync35 } from "fs";
+import { stat } from "fs/promises";
+import "path";
+import "commander";
+import {
+  codeMapPath as codeMapPath2,
+  findProjectRoot as findProjectRoot36,
+  getUsage as getUsage10,
+  loadCodeMap as loadCodeMap3,
+  loadConfig as loadConfig4,
+  loadMemoriesFromDir as loadMemoriesFromDir10,
+  loadUsageIndex as loadUsageIndex12,
+  readUsageEvents as readUsageEvents3,
+  resolveHaivePaths as resolveHaivePaths33
+} from "@hiveai/core";
+var MS_PER_DAY2 = 24 * 60 * 60 * 1e3;
+function registerDoctor(program2) {
+  program2.command("doctor").description(
+    "Analyze the local hAIve setup and emit actionable recommendations.\n\n  Inspects: project-context status, memory health (stale/anchorless/decay/pending),\n  code-map freshness, usage log signals (low-hit briefings, repeated empty searches).\n\n  Read-only by default. Pass --fix to suggest commands you can copy-paste."
+  ).option("--json", "emit JSON instead of human-readable output", false).option("--fix", "include suggested fix commands in human output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
+    const root = findProjectRoot36(opts.dir);
+    const paths = resolveHaivePaths33(root);
+    const findings = [];
+    if (!existsSync35(paths.haiveDir)) {
+      findings.push({
+        severity: "error",
+        code: "not-initialized",
+        message: ".ai/ directory missing \u2014 haive is not initialized in this project.",
+        fix: "haive init"
+      });
+      return emit(findings, opts);
+    }
+    if (!existsSync35(paths.projectContext)) {
+      findings.push({
+        severity: "warn",
+        code: "no-project-context",
+        message: ".ai/project-context.md is missing.",
+        fix: "haive init"
+      });
+    } else {
+      const { readFile: readFile13 } = await import("fs/promises");
+      const content = await readFile13(paths.projectContext, "utf8");
+      const isTemplate = content.includes("TODO \u2014 high-level overview") || content.includes("Generated by `haive init`");
+      if (isTemplate) {
+        findings.push({
+          severity: "warn",
+          code: "template-context",
+          message: "project-context.md still contains the default template \u2014 get_briefing returns little value until filled.",
+          fix: "Invoke the bootstrap_project MCP prompt from your AI client."
+        });
+      }
+    }
+    const memories = existsSync35(paths.memoriesDir) ? await loadMemoriesFromDir10(paths.memoriesDir) : [];
+    const now = Date.now();
+    if (memories.length === 0) {
+      findings.push({
+        severity: "info",
+        code: "no-memories",
+        message: "No memories yet. Capture knowledge as agents work via mem_save / mem_observe / mem_tried."
+      });
+    } else {
+      const usage = await loadUsageIndex12(paths);
+      const stale = memories.filter((m) => m.memory.frontmatter.status === "stale");
+      if (stale.length > 0) {
+        findings.push({
+          severity: "warn",
+          code: "stale-memories",
+          message: `${stale.length} memor${stale.length === 1 ? "y" : "ies"} marked stale (anchored code drifted).`,
+          fix: "haive memory verify --update    # re-check anchors\nhaive memory edit <id>           # manually refresh body"
+        });
+      }
+      const proposed = memories.filter((m) => m.memory.frontmatter.status === "proposed");
+      if (proposed.length > 0) {
+        findings.push({
+          severity: "info",
+          code: "pending-review",
+          message: `${proposed.length} memor${proposed.length === 1 ? "y is" : "ies are"} proposed and awaiting validation.`,
+          fix: "haive memory pending      # list them\nhaive memory auto-promote   # promote those with high read_count"
+        });
+      }
+      const anchorless = memories.filter(
+        (m) => m.memory.frontmatter.anchor.paths.length === 0 && m.memory.frontmatter.anchor.symbols.length === 0 && m.memory.frontmatter.type !== "session_recap" && m.memory.frontmatter.type !== "glossary"
+      );
+      if (anchorless.length / Math.max(memories.length, 1) > 0.3) {
+        findings.push({
+          severity: "warn",
+          code: "anchorless-majority",
+          message: `${anchorless.length}/${memories.length} memories have no anchor path/symbol \u2014 staleness undetectable.`,
+          fix: "Add `paths:` + `symbols:` to mem_save calls to enable haive memory verify."
+        });
+      }
+      const decayCandidates = memories.filter((m) => {
+        if (m.memory.frontmatter.status !== "validated") return false;
+        const u = getUsage10(usage, m.memory.frontmatter.id);
+        const last = u.last_read_at ?? m.memory.frontmatter.created_at;
+        return (now - Date.parse(last)) / MS_PER_DAY2 > 180;
+      });
+      if (decayCandidates.length > 0) {
+        findings.push({
+          severity: "info",
+          code: "decay-candidates",
+          message: `${decayCandidates.length} validated memor${decayCandidates.length === 1 ? "y has" : "ies have"} not been read in 180+ days \u2014 confidence is decaying.`,
+          fix: "haive memory archive --type all --since 365d   # dry run"
+        });
+      }
+    }
+    const codeMap = await loadCodeMap3(paths);
+    if (!codeMap) {
+      findings.push({
+        severity: "warn",
+        code: "no-code-map",
+        message: "No code-map found \u2014 code_map MCP tool and symbol_locations are unavailable.",
+        fix: "haive index code"
+      });
+    } else {
+      const cmFile = codeMapPath2(paths);
+      const cmStat = await stat(cmFile);
+      const ageDays = (now - cmStat.mtimeMs) / MS_PER_DAY2;
+      if (ageDays > 14) {
+        findings.push({
+          severity: "warn",
+          code: "stale-code-map",
+          message: `code-map is ${Math.round(ageDays)} days old (${Object.keys(codeMap.files).length} files indexed).`,
+          fix: "haive index code   # or rely on the post-merge git hook"
+        });
+      }
+    }
+    const events = await readUsageEvents3(paths);
+    if (events.length === 0) {
+      findings.push({
+        severity: "info",
+        code: "no-usage-log",
+        message: "No usage log entries \u2014 MCP server hasn't recorded any calls yet, or this project hasn't been used by an agent."
+      });
+    } else {
+      const queryRepeats = /* @__PURE__ */ new Map();
+      for (const e of events) {
+        if (!isSearchTool(e.tool)) continue;
+        const key = (e.summary ?? "").toLowerCase().trim();
+        if (!key) continue;
+        queryRepeats.set(key, (queryRepeats.get(key) ?? 0) + 1);
+      }
+      const repeated = [...queryRepeats.entries()].filter(([, n]) => n >= 3);
+      if (repeated.length > 0) {
+        findings.push({
+          severity: "info",
+          code: "recurring-searches",
+          message: `${repeated.length} query${repeated.length === 1 ? "" : "ies"} repeated 3+ times \u2014 agents keep asking the same things.`,
+          fix: `haive memory suggest --auto-save --top-n ${Math.min(5, repeated.length)}`
+        });
+      }
+      const codeMapCalls = events.filter((e) => e.tool === "code_map").length;
+      const briefingCalls = events.filter((e) => e.tool === "get_briefing").length;
+      if (codeMapCalls > 0 && memories.length > 0) {
+        findings.push({
+          severity: "info",
+          code: "tool-mix",
+          message: `${briefingCalls} get_briefing call${briefingCalls === 1 ? "" : "s"}, ${codeMapCalls} code_map call${codeMapCalls === 1 ? "" : "s"} recorded.`
+        });
+      }
+    }
+    const config = await loadConfig4(paths);
+    if (!config.autoSessionEnd) {
+      findings.push({
+        severity: "info",
+        code: "no-autopilot",
+        message: "Autopilot is OFF \u2014 session recaps are not auto-saved on shutdown.",
+        fix: "Edit .ai/haive.config.json: set autoSessionEnd: true (or re-run `haive init` without --manual)."
+      });
+    }
+    emit(findings, opts);
+  });
+}
+function emit(findings, opts) {
+  if (opts.json) {
+    console.log(JSON.stringify({ findings }, null, 2));
+    return;
+  }
+  if (findings.length === 0) {
+    ui.success("hAIve doctor \u2014 no issues found.");
+    return;
+  }
+  console.log(ui.bold(`hAIve doctor \u2014 ${findings.length} finding${findings.length === 1 ? "" : "s"}`));
+  console.log();
+  const order = ["error", "warn", "info"];
+  for (const sev of order) {
+    for (const f of findings.filter((x) => x.severity === sev)) {
+      const icon = sev === "error" ? ui.red("\u2717") : sev === "warn" ? ui.yellow("\u26A0") : ui.dim("\u2139");
+      console.log(`${icon} ${ui.bold(f.code)}  ${f.message}`);
+      if (opts.fix && f.fix) {
+        for (const line of f.fix.split("\n")) {
+          console.log(`     ${ui.dim("$")} ${line}`);
+        }
+      }
+    }
+  }
+  if (!opts.fix && findings.some((f) => f.fix)) {
+    console.log();
+    ui.info("Re-run with --fix to see suggested commands.");
+  }
+}
+function isSearchTool(name) {
+  return ["mem_search", "code_search", "mem_relevant_to", "get_briefing"].includes(name);
+}
+
+// src/commands/playback.ts
+import { existsSync as existsSync36 } from "fs";
+import "commander";
+import {
+  findProjectRoot as findProjectRoot37,
+  loadMemoriesFromDir as loadMemoriesFromDir11,
+  parseSince as parseSince3,
+  readUsageEvents as readUsageEvents4,
+  resolveHaivePaths as resolveHaivePaths34
+} 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 = findProjectRoot37(opts.dir);
+    const paths = resolveHaivePaths34(root);
+    const events = await readUsageEvents4(paths);
+    if (events.length === 0) {
+      if (opts.json) {
+        console.log(JSON.stringify({ sessions: [] }));
+        return;
+      }
+      ui.warn("No usage log entries yet.");
+      return;
+    }
+    const since = parseSince3(opts.since);
+    const cutoff = since ? since.getTime() : 0;
+    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 = existsSync36(paths.memoriesDir) ? await loadMemoriesFromDir11(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);
+      const newer = memByCreatedAt.filter((m) => m.at > startMs);
+      return {
+        index: i,
+        start: s.start,
+        end: s.end,
+        duration_minutes: (Date.parse(s.end) - startMs) / MS_PER_MINUTE,
+        events: s.events.length,
+        tools_count: countTools(s.events),
+        briefing_tasks: s.events.filter((e) => e.tool === "get_briefing" && e.summary).map((e) => e.summary).slice(0, 5),
+        memories_created_since: newer.length,
+        new_memories: newer.slice(0, 5).map((m) => m.id)
+      };
+    });
+    enriched.sort((a, b) => Date.parse(b.start) - Date.parse(a.start));
+    const limit = Math.max(1, parseInt(opts.limit ?? "10", 10));
+    const shown = enriched.slice(0, limit);
+    if (opts.json) {
+      console.log(JSON.stringify({
+        window: opts.since,
+        session_gap_minutes: gapMs / MS_PER_MINUTE,
+        total_sessions: enriched.length,
+        sessions: shown
+      }, null, 2));
+      return;
+    }
+    console.log(ui.bold(`hAIve playback \u2014 ${enriched.length} session(s) over ${opts.since ?? "all time"}`));
+    console.log();
+    for (const s of shown) {
+      console.log(
+        `${ui.bold(`Session ${s.index + 1}`)}  ${ui.dim(s.start.slice(0, 19) + " \u2192 " + s.end.slice(11, 19))}  ${ui.dim(`(${Math.round(s.duration_minutes)}m, ${s.events} call${s.events === 1 ? "" : "s"})`)}`
+      );
+      const toolList = Object.entries(s.tools_count).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([t, n]) => `${t}\xD7${n}`).join(", ");
+      if (toolList) console.log(`  ${ui.dim("tools:")} ${toolList}`);
+      if (s.briefing_tasks.length > 0) {
+        console.log(`  ${ui.dim("briefings asked:")}`);
+        for (const t of s.briefing_tasks) {
+          console.log(`    \u2022 ${truncate2(t, 80)}`);
+        }
+      }
+      if (s.memories_created_since > 0) {
+        console.log(
+          `  ${ui.green("\u2934")} ${s.memories_created_since} memor${s.memories_created_since === 1 ? "y has" : "ies have"} been created since this session ` + ui.dim(`\u2014 newer haive could have answered better`)
+        );
+        for (const id of s.new_memories) {
+          console.log(`    + ${ui.dim(id)}`);
+        }
+      }
+      console.log();
+    }
+  });
+}
+function bucketSessions(events, gapMs) {
+  if (events.length === 0) return [];
+  const sorted = [...events].sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+  const buckets = [];
+  let current = null;
+  for (const e of sorted) {
+    if (!current) {
+      current = { start: e.at, end: e.at, events: [e] };
+      continue;
+    }
+    if (Date.parse(e.at) - Date.parse(current.end) > gapMs) {
+      buckets.push(current);
+      current = { start: e.at, end: e.at, events: [e] };
+    } else {
+      current.events.push(e);
+      current.end = e.at;
+    }
+  }
+  if (current) buckets.push(current);
+  return buckets;
+}
+function countTools(events) {
+  const out = {};
+  for (const e of events) out[e.tool] = (out[e.tool] ?? 0) + 1;
+  return out;
+}
+function truncate2(text, max) {
+  if (text.length <= max) return text;
+  return text.slice(0, max - 1) + "\u2026";
+}
+
+// src/commands/precommit.ts
+import { spawn as spawn3 } from "child_process";
+import "commander";
+import {
+  findProjectRoot as findProjectRoot38,
+  resolveHaivePaths as resolveHaivePaths35
+} from "@hiveai/core";
+import { preCommitCheck } from "@hiveai/mcp";
+function registerPrecommit(program2) {
+  program2.command("precommit").description(
+    "Run a pre-commit safety check: scans `git diff --cached` against known anti-patterns,\n  surfaces conventions/decisions anchored to touched files, and warns about stale anchored memories.\n\n  Wire it into git as: `.git/hooks/pre-commit` running `haive precommit` (exit 1 = block).\n\n  Examples:\n    haive precommit                                # auto-detects staged diff\n    haive precommit --block-on any                 # block on any warning, not just high-confidence\n    haive precommit --paths src/auth.ts src/db.ts  # explicit paths instead of git diff"
+  ).option(
+    "--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 = findProjectRoot38(opts.dir);
+    const paths = resolveHaivePaths35(root);
+    const ctx = { paths };
+    let diff = "";
+    let touchedPaths = opts.paths ?? [];
+    if (touchedPaths.length === 0) {
+      try {
+        diff = await runCommand("git", ["diff", "--cached"], root);
+        if (!diff.trim()) {
+          ui.warn("No staged changes \u2014 nothing to check. Stage with `git add` first.");
+          return;
+        }
+        const nameOnly = await runCommand("git", ["diff", "--cached", "--name-only"], root);
+        touchedPaths = nameOnly.split("\n").map((s) => s.trim()).filter(Boolean);
+      } catch (err) {
+        ui.error(`git diff failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+      }
+    }
+    const result = await preCommitCheck({
+      diff: diff || void 0,
+      paths: touchedPaths,
+      block_on: opts.blockOn ?? "high-confidence",
+      semantic: opts.noSemantic ? false : true
+    }, ctx);
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      process.exit(result.should_block ? 1 : 0);
+    }
+    console.log(ui.bold(`hAIve precommit \u2014 ${touchedPaths.length} file(s)`));
+    console.log(
+      ui.dim(
+        `  anti-patterns: ${result.summary.anti_patterns}  relevant memories: ${result.summary.relevant_memories}  stale anchors: ${result.summary.stale_anchors}`
+      )
+    );
+    console.log();
+    if (result.warnings.length > 0) {
+      console.log(ui.bold("\u26A0 Anti-patterns matched:"));
+      for (const w of result.warnings.slice(0, 10)) {
+        console.log(`  ${ui.yellow("\u26A0")} ${w.id} ${ui.dim(`(${w.type}, ${w.confidence})`)}`);
+        for (const line of w.body_preview.split("\n").slice(0, 3)) {
+          console.log(`     ${ui.dim(line)}`);
+        }
+        console.log(`     ${ui.dim("reasons:")} ${w.reasons.join(", ")}`);
+      }
+      console.log();
+    }
+    if (result.relevant_memories.length > 0) {
+      console.log(ui.bold("\u{1F4CC} Relevant conventions/decisions:"));
+      for (const m of result.relevant_memories) {
+        console.log(`  \u2022 ${m.id} ${ui.dim(`(${m.type}, ${m.confidence})`)}`);
+      }
+      console.log();
+    }
+    if (result.stale_anchors.length > 0) {
+      console.log(ui.bold("\u{1F552} Stale anchored memories:"));
+      for (const s of result.stale_anchors) {
+        console.log(`  \u2022 ${s.id}`);
+        if (s.body_preview) console.log(`     ${ui.dim(s.body_preview)}`);
+      }
+      console.log();
+    }
+    if (result.should_block) {
+      ui.error(`Blocking commit (block_on=${opts.blockOn ?? "high-confidence"}). Address the warnings above or pass --block-on never to bypass.`);
+      process.exit(1);
+    }
+    if (result.warnings.length === 0 && result.stale_anchors.length === 0) {
+      ui.success("No anti-patterns or stale anchors found.");
+    } else {
+      ui.success("Check passed (block_on threshold not met).");
+    }
+  });
+}
+function runCommand(cmd, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn3(cmd, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    proc.on("error", reject);
+    proc.on("close", (code) => {
+      if (code === 0) resolve(stdout);
+      else reject(new Error(stderr || `${cmd} exited with code ${code}`));
+    });
+  });
+}
+
 // src/index.ts
-var program = new Command35();
-program.name("haive").description("hAIve \u2014 team-first persistent memory layer for AI coding agents").version("0.5.0");
+var program = new Command39();
+program.name("haive").description("hAIve \u2014 team-first persistent memory layer for AI coding agents").version("0.7.0");
 registerInit(program);
 registerMcp(program);
 registerBriefing(program);
@@ -3689,12 +5214,16 @@ registerMemoryImport(memory);
 registerMemoryImportChangelog(memory);
 registerMemoryDigest(memory);
 registerMemorySuggest(memory);
+registerMemoryArchive(memory);
 var session = program.command("session").description("Manage session lifecycle");
 registerSessionEnd(session);
 registerSnapshot(program);
 registerHub(program);
 registerStats(program);
 registerBench(program);
+registerDoctor(program);
+registerPlayback(program);
+registerPrecommit(program);
 program.parseAsync(process.argv).catch((err) => {
   if (isZodError(err)) {
     for (const issue of err.issues) {