@hiveai/cli 0.6.0 → 0.7.1

package/dist/index.js

@@ -408,9 +408,9 @@ function registerIndexCode(program2) {
 }
 
 // src/commands/init.ts
-import { mkdir, writeFile } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
-import path4 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 {
@@ -420,9 +420,1101 @@ 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", "@trpc/client"],
+  "Prisma": ["@prisma/client"],
+  "Drizzle": ["drizzle-orm"],
+  "Redux Toolkit": ["@reduxjs/toolkit"],
+  "Zustand": ["zustand"],
+  "TanStack Query": ["@tanstack/react-query", "react-query"],
+  "Mongoose": ["mongoose"],
+  "Apollo": ["@apollo/client", "@apollo/server", "apollo-server"],
+  "GraphQL": ["graphql"],
+  "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, isMonorepo) {
+  if (isMonorepo) {
+    if (frameworks.includes("NestJS")) return "Monorepo (NestJS backend)";
+    if (frameworks.includes("Next.js")) return "Monorepo (Next.js)";
+    if (frameworks.includes("React")) return "Multi-package monorepo (React)";
+    if (frameworks.length > 0) return `Multi-package monorepo (${frameworks.slice(0, 2).join(", ")})`;
+    return "Multi-package monorepo";
+  }
+  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, frameworks = []) {
+  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",
+    "decorators": "custom decorators",
+    "interceptors": "NestJS interceptors",
+    "filters": "exception filters",
+    "pipes": "validation / transformation pipes",
+    "dto": "Data Transfer Objects",
+    "entities": "ORM entities / database models",
+    "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",
+    "auth": "authentication / authorization",
+    "users": "user management",
+    "products": "product catalog",
+    "orders": "order management",
+    "common": "shared / common utilities",
+    "shared": "shared code across modules"
+  };
+  const isNestJS = frameworks.includes("NestJS");
+  const srcSubdirs = dirs.filter((d) => d.startsWith("src/") && d.split("/").length === 2);
+  if (isNestJS && srcSubdirs.length >= 2) {
+    const result = [`- \`src/\` \u2014 main source (NestJS feature modules)`];
+    for (const d of srcSubdirs.slice(0, 12)) {
+      const name = d.split("/")[1];
+      const desc = known[name.toLowerCase()] ?? "feature module";
+      result.push(`  - \`${name}/\` \u2014 ${desc}`);
+    }
+    const otherTopLevel = dirs.filter((d) => !d.includes("/") && d !== "src").slice(0, 6);
+    for (const d of otherTopLevel) {
+      const desc = known[d.toLowerCase()] ?? "module";
+      result.push(`- \`${d}/\` \u2014 ${desc}`);
+    }
+    return result;
+  }
+  const isMonorepo = dirs.some((d) => d === "packages") && dirs.some((d) => d.startsWith("packages/") && d.split("/").length === 2);
+  if (isMonorepo) {
+    const packageSubdirs = dirs.filter((d) => d.startsWith("packages/") && d.split("/").length === 2);
+    const result = [`- \`packages/\` \u2014 monorepo sub-packages`];
+    for (const d of packageSubdirs.slice(0, 10)) {
+      const name = d.split("/")[1];
+      const desc = known[name.toLowerCase()] ?? "sub-package";
+      result.push(`  - \`${name}/\` \u2014 ${desc}`);
+    }
+    const otherTopLevel = dirs.filter((d) => !d.includes("/") && d !== "packages").slice(0, 5);
+    for (const d of otherTopLevel) {
+      const desc = known[d.toLowerCase()] ?? "module";
+      result.push(`- \`${d}/\` \u2014 ${desc}`);
+    }
+    return result;
+  }
+  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 isMonorepo = pkg.workspaces !== void 0 && (Array.isArray(pkg.workspaces) ? pkg.workspaces.length > 0 : true);
+  const projectType = detectProjectType(frameworks, pkg.scripts ?? {}, isMonorepo);
+  const projectName = pkg.name ?? path4.basename(root);
+  const 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, frameworks);
+  const scripts = pkg.scripts ?? {};
+  const scriptLines = Object.entries(scripts).filter(([k]) => ["build", "dev", "start", "test", "lint", "deploy"].includes(k)).map(([k, v]) => `- \`${k}\`: ${v}`).slice(0, 6);
+  const stackParts = [language];
+  if (frameworks.length) stackParts.push(...frameworks);
+  const techStack = stackParts.join(", ");
+  const notableDeps = Object.keys(allDeps).filter((d) => !d.startsWith("@types/") && !["typescript", "eslint", "prettier", "jest"].includes(d)).filter((d) => !["react", "react-dom", "next", "vue", "express"].includes(d)).slice(0, 10).map((d) => `\`${d}\``);
+  const lines = [
+    `# Project context \u2014 ${projectName}`,
+    "",
+    `> Auto-generated by \`haive init --bootstrap\`. Review and refine \u2014 especially the Architecture and Gotchas sections.`,
+    "",
+    `## Overview`,
+    `**Type:** ${projectType}`,
+    `**Tech stack:** ${techStack}`,
+    ...projectDesc ? [`**Description:** ${projectDesc}`] : [],
+    ...readmeSummary ? [`**From README:** ${readmeSummary}`] : [],
+    "",
+    `## Architecture`,
+    `TODO \u2014 fill in the high-level architecture (inferred structure below, verify manually):`,
+    "",
+    ...moduleLines.length ? moduleLines : ["TODO \u2014 no clear structure detected."],
+    "",
+    `## Key modules`,
+    `TODO \u2014 describe the purpose of the main modules. The directory scan found:`,
+    ...dirs.filter((d) => !d.includes("/")).slice(0, 8).map((d) => `- \`${d}/\``),
+    "",
+    `## Conventions`,
+    `TODO \u2014 fill in coding conventions (naming, patterns, file layout).`,
+    "",
+    ...scriptLines.length ? [
+      `**Available scripts:**`,
+      ...scriptLines,
+      ""
+    ] : [],
+    ...keyDeps.length ? [
+      `**Key dependencies in use:** ${keyDeps.map((d) => `\`${d}\``).join(", ")}`,
+      ""
+    ] : [],
+    ...notableDeps.length ? [
+      `**Other notable packages:** ${notableDeps.join(", ")}`,
+      ""
+    ] : [],
+    `## Glossary`,
+    `TODO \u2014 domain terms and what they mean here.`,
+    "",
+    `## Gotchas`,
+    `TODO \u2014 known traps, surprising behavior, things newcomers stub their toes on.`,
+    `(Run \`haive memory import-changelog\` or \`haive memory import README.md\` to seed these automatically.)`,
+    ""
+  ];
+  return lines.join("\n");
+}
+
+// src/commands/init-mcp-setup.ts
+import { readFile as readFile3, writeFile, mkdir } 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.`
+    }
+  ],
+  zustand: [
+    {
+      slug: "zustand-select-slices-not-whole-store",
+      type: "convention",
+      tags: ["zustand", "performance", "react"],
+      body: `Always select specific slices \u2014 never subscribe to the whole store.
+
+\`\`\`ts
+// \u274C Re-renders on any store change (even unrelated fields)
+const store = useStore();
+
+// \u2705 Re-renders only when count changes
+const count = useStore((s) => s.count);
+\`\`\`
+
+Subscribing to the whole store is the single most common Zustand performance mistake.`
+    },
+    {
+      slug: "zustand-devtools-wrap-dev-only",
+      type: "convention",
+      tags: ["zustand", "devtools", "performance"],
+      body: `Wrap Zustand devtools middleware in a dev-only condition.
+
+\`\`\`ts
+import { devtools } from 'zustand/middleware';
+
+const useStore = create(
+  process.env.NODE_ENV === 'development'
+    ? devtools(storeImpl, { name: 'AppStore' })
+    : storeImpl,
+);
+\`\`\`
+
+Shipping devtools to production adds overhead and exposes store internals in bundle.`
+    },
+    {
+      slug: "zustand-persist-hydration-ssr",
+      type: "gotcha",
+      tags: ["zustand", "ssr", "nextjs", "hydration"],
+      body: `Zustand persist middleware causes hydration mismatch in SSR (Next.js / Remix).
+
+The server renders with empty state; the client rehydrates from localStorage.
+Fix: use \`skipHydration: true\` and manually call \`rehydrate()\` after mount.
+
+\`\`\`ts
+// In a useEffect or useLayoutEffect on the client:
+useEffect(() => { useStore.persist.rehydrate(); }, []);
+\`\`\``
+    }
+  ],
+  redux: [
+    {
+      slug: "redux-toolkit-immer-mutate-or-return",
+      type: "gotcha",
+      tags: ["redux", "redux-toolkit", "immer"],
+      body: `In RTK createSlice reducers (Immer), you must EITHER mutate the draft OR return a new value \u2014 never both.
+
+\`\`\`ts
+// \u2705 Mutate draft (Immer converts to immutable update)
+state.count += 1;
+
+// \u2705 Return new value
+return { ...state, count: state.count + 1 };
+
+// \u274C Both \u2014 causes undefined state
+state.count += 1;
+return state; // DON'T \u2014 Immer sees both a mutation and a return
+\`\`\``
+    },
+    {
+      slug: "redux-toolkit-rtk-query-over-thunk",
+      type: "decision",
+      tags: ["redux", "redux-toolkit", "data-fetching"],
+      body: `Use RTK Query for server data, not createAsyncThunk.
+
+RTK Query automatically handles: caching, loading/error states, cache invalidation, polling, optimistic updates.
+createAsyncThunk is for one-off side effects that don't fit the query/mutation model (e.g. file upload with progress).`
+    },
+    {
+      slug: "redux-toolkit-normalize-nested-data",
+      type: "convention",
+      tags: ["redux", "redux-toolkit", "normalization"],
+      body: `Normalize nested API responses before storing in Redux \u2014 use createEntityAdapter.
+
+Storing deeply nested objects causes:
+- Redundant re-renders when any deeply nested field changes
+- Difficult update logic (deep merge)
+
+\`\`\`ts
+const usersAdapter = createEntityAdapter<User>();
+const usersSlice = createSlice({
+  name: 'users',
+  initialState: usersAdapter.getInitialState(),
+  reducers: { usersReceived: usersAdapter.setAll },
+});
+\`\`\``
+    }
+  ],
+  reactquery: [
+    {
+      slug: "tanstack-query-stale-time-default",
+      type: "gotcha",
+      tags: ["react-query", "tanstack-query", "caching"],
+      body: `By default, TanStack Query marks data as stale immediately (staleTime: 0) and refetches on every window focus.
+
+Set a reasonable staleTime to avoid unnecessary network requests:
+
+\`\`\`ts
+useQuery({
+  queryKey: ['user', id],
+  queryFn: () => getUser(id),
+  staleTime: 5 * 60 * 1000, // 5 minutes
+})
+\`\`\`
+
+Set globally via QueryClient defaultOptions for consistency.`
+    },
+    {
+      slug: "tanstack-query-invalidate-after-mutation",
+      type: "convention",
+      tags: ["react-query", "tanstack-query", "mutations"],
+      body: `Always invalidate related queries after a mutation to keep the cache fresh.
+
+\`\`\`ts
+useMutation({
+  mutationFn: createUser,
+  onSuccess: () => queryClient.invalidateQueries({ queryKey: ['users'] }),
+})
+\`\`\`
+
+Skipping invalidation causes the UI to show stale data after a write until the next background refetch.`
+    },
+    {
+      slug: "tanstack-query-querykey-as-dependency",
+      type: "convention",
+      tags: ["react-query", "tanstack-query"],
+      body: `Treat the queryKey array as a dependency array \u2014 include all variables the queryFn depends on.
+
+\`\`\`ts
+// \u274C Won't refetch when userId changes
+useQuery({ queryKey: ['user'], queryFn: () => getUser(userId) });
+
+// \u2705 Refetches automatically when userId changes
+useQuery({ queryKey: ['user', userId], queryFn: () => getUser(userId) });
+\`\`\``
+    }
+  ],
+  trpc: [
+    {
+      slug: "trpc-always-validate-input-with-zod",
+      type: "convention",
+      tags: ["trpc", "validation", "security"],
+      body: `Always validate procedure inputs with Zod \u2014 tRPC infers types but doesn't enforce them at runtime without a schema.
+
+\`\`\`ts
+// \u274C No runtime validation \u2014 input is 'unknown'
+t.procedure.query(({ input }) => getUser(input as string));
+
+// \u2705 Validated and typed end-to-end
+t.procedure
+  .input(z.object({ id: z.string().uuid() }))
+  .query(({ input }) => getUser(input.id));
+\`\`\``
+    },
+    {
+      slug: "trpc-server-side-caller-for-ssr",
+      type: "convention",
+      tags: ["trpc", "nextjs", "ssr"],
+      body: `Use the server-side caller in Server Components / SSR \u2014 don't call tRPC over HTTP from the server.
+
+\`\`\`ts
+// In Next.js App Router server component
+const caller = appRouter.createCaller(await createContext());
+const data = await caller.users.getAll(); // Direct function call, no HTTP
+\`\`\`
+
+HTTP round-trips from server \u2192 server add latency and bypass auth context.`
+    },
+    {
+      slug: "trpc-context-for-auth",
+      type: "architecture",
+      tags: ["trpc", "auth"],
+      body: `Put auth session on the tRPC context, not in individual procedures.
+
+\`\`\`ts
+// createContext(): resolve session once, share across all procedures
+export async function createContext({ req }: CreateNextContextOptions) {
+  const session = await getServerSession(req);
+  return { session, db };
+}
+
+// In procedure: ctx.session.user is always typed
+const protectedProcedure = t.procedure.use(({ ctx, next }) => {
+  if (!ctx.session?.user) throw new TRPCError({ code: 'UNAUTHORIZED' });
+  return next({ ctx: { ...ctx, user: ctx.session.user } });
+});
+\`\`\``
+    }
+  ],
+  mongoose: [
+    {
+      slug: "mongoose-connection-singleton",
+      type: "convention",
+      tags: ["mongoose", "mongodb", "connection", "serverless"],
+      body: `Create one Mongoose connection at startup \u2014 never connect inside route handlers.
+
+In serverless (Next.js, Vercel), cache the connection to reuse across warm invocations:
+
+\`\`\`ts
+let cached = (global as any).__mongoose ?? { conn: null, promise: null };
+
+export async function dbConnect() {
+  if (cached.conn) return cached.conn;
+  if (!cached.promise) {
+    cached.promise = mongoose.connect(process.env.MONGODB_URI!);
+  }
+  cached.conn = await cached.promise;
+  (global as any).__mongoose = cached;
+  return cached.conn;
+}
+\`\`\``
+    },
+    {
+      slug: "mongoose-lean-for-read-only",
+      type: "convention",
+      tags: ["mongoose", "performance"],
+      body: `Add .lean() to read-only queries to get plain JS objects instead of full Mongoose documents.
+
+\`\`\`ts
+// \u274C Full Mongoose document \u2014 slow, heavy, has virtuals/methods
+const users = await User.find({});
+
+// \u2705 Plain JS object \u2014 2-5x faster on large result sets
+const users = await User.find({}).lean();
+\`\`\`
+
+Never use .lean() when you need to call .save() or Mongoose instance methods.`
+    },
+    {
+      slug: "mongoose-index-frequently-queried-fields",
+      type: "gotcha",
+      tags: ["mongoose", "mongodb", "performance"],
+      body: `Mongoose does NOT create indexes automatically unless you call syncIndexes() or ensureIndexes().
+
+Declare indexes in the schema and sync them at startup:
+
+\`\`\`ts
+UserSchema.index({ email: 1 }, { unique: true });
+UserSchema.index({ createdAt: -1 });
+
+// At startup (not per-request):
+await User.syncIndexes();
+\`\`\`
+
+Missing indexes cause full collection scans and timeouts at scale.`
+    }
+  ],
+  graphql: [
+    {
+      slug: "graphql-n-plus-one-dataloader",
+      type: "gotcha",
+      tags: ["graphql", "performance", "n+1"],
+      body: `GraphQL resolvers cause N+1 database queries without DataLoader batching.
+
+Every field resolver runs independently \u2014 fetching related data naively causes N queries for N items.
+
+\`\`\`ts
+// In context, create one DataLoader per request (NOT per resolver call)
+const userLoader = new DataLoader(async (ids: readonly string[]) =>
+  User.findByIds(ids as string[])
+);
+
+// In resolver:
+author: (post) => userLoader.load(post.authorId),
+\`\`\`
+
+A list of 100 posts with authors = 101 queries without DataLoader, 2 queries with it.`
+    },
+    {
+      slug: "graphql-mask-internal-errors-in-production",
+      type: "gotcha",
+      tags: ["graphql", "security", "apollo"],
+      body: `Apollo Server exposes full error details (including stack traces) in development.
+
+In production, mask internal errors to prevent leaking implementation details:
+
+\`\`\`ts
+new ApolloServer({
+  formatError: (formattedError) => {
+    if (formattedError.extensions?.code === 'INTERNAL_SERVER_ERROR') {
+      return { message: 'Internal server error', extensions: { code: 'INTERNAL_SERVER_ERROR' } };
+    }
+    return formattedError;
+  },
+});
+\`\`\``
+    },
+    {
+      slug: "graphql-depth-limit-and-complexity",
+      type: "convention",
+      tags: ["graphql", "security", "dos"],
+      body: `Add query depth and complexity limits to prevent DoS via deeply nested queries.
+
+Without limits, a single query can request exponentially nested data and exhaust the server.
+
+\`\`\`ts
+import depthLimit from 'graphql-depth-limit';
+import { createComplexityLimitRule } from 'graphql-validation-complexity';
+
+new ApolloServer({
+  validationRules: [
+    depthLimit(7),
+    createComplexityLimitRule(1000),
+  ],
+});
+\`\`\``
+    }
+  ]
+};
+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"]],
+    ["zustand", ["zustand"]],
+    ["redux", ["@reduxjs/toolkit", "redux"]],
+    ["reactquery", ["@tanstack/react-query", "react-query"]],
+    ["trpc", ["@trpc/server", "@trpc/client"]],
+    ["mongoose", ["mongoose"]],
+    ["graphql", ["@apollo/client", "@apollo/server", "apollo-server", "graphql"]]
+  ];
+  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.
@@ -580,23 +1672,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 = path4.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 ${path4.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(
-      path4.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 });
@@ -607,17 +1722,35 @@ function registerInit(program2) {
     if (opts.bridges) {
       await writeBridge(root, "CLAUDE.md");
       await writeBridge(root, ".cursorrules");
-      await writeBridge(root, path4.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 = path4.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(path4.dirname(ciPath), { recursive: true });
-        await writeFile(ciPath, CI_WORKFLOW, "utf8");
-        ui.success(`Created ${path4.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) {
@@ -641,6 +1774,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) {
@@ -651,45 +1805,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();
-      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."));
+      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.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 = path4.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(path4.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 path5 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
@@ -700,46 +1883,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 = path5.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 = path5.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 = path5.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 path6 from "path";
+import path9 from "path";
 import { fileURLToPath } from "url";
 import "commander";
 import { findProjectRoot as findProjectRoot7 } from "@hiveai/core";
@@ -777,26 +1997,26 @@ function registerMcp(program2) {
 function locateMcpBin() {
   try {
     const pkgPath = require2.resolve("@hiveai/mcp/package.json");
-    const pkgDir = path6.dirname(pkgPath);
-    const candidate = path6.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 = path6.dirname(fileURLToPath(import.meta.url));
-  const sibling = path6.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 path7 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,
@@ -808,7 +2028,7 @@ import {
   pullCrossRepoSources,
   resolveHaivePaths as resolveHaivePaths5,
   resolveManifestFiles,
-  serializeMemory,
+  serializeMemory as serializeMemory2,
   trackDependencies,
   verifyAnchor,
   watchContracts
@@ -827,7 +2047,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;
@@ -847,9 +2067,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",
@@ -870,9 +2090,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",
@@ -886,9 +2106,9 @@ function registerSync(program2) {
             staleMarked++;
           }
         } else if (memory2.frontmatter.status === "stale") {
-          await writeFile3(
+          await writeFile5(
             filePath,
-            serializeMemory({
+            serializeMemory2({
               frontmatter: {
                 ...memory2.frontmatter,
                 status: "validated",
@@ -914,9 +2134,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++;
@@ -925,9 +2145,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",
@@ -959,7 +2179,7 @@ function registerSync(program2) {
       );
     }
     if (opts.injectBridge) {
-      const bridgeFile = opts.bridgeFile ? path7.resolve(opts.bridgeFile) : path7.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);
     }
@@ -1056,7 +2276,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",
@@ -1065,11 +2285,11 @@ Attends une **confirmation explicite** avant d'agir.
                   paths: [result.file],
                   topic: `dep-bump-${slugParts}`
                 });
-                const teamDir = path7.join(paths.memoriesDir, "team");
-                await mkdir3(teamDir, { recursive: true });
-                await writeFile3(
-                  path7.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}`));
@@ -1123,7 +2343,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",
@@ -1132,11 +2352,11 @@ Attends une **confirmation explicite** avant d'agir.
               paths: [diff.file],
               topic: `contract-breaking-${diff.contract}`
             });
-            const teamDir = path7.join(paths.memoriesDir, "team");
-            await mkdir3(teamDir, { recursive: true });
-            await writeFile3(
-              path7.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}`));
@@ -1196,7 +2416,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;
@@ -1221,17 +2441,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(`${path7.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(`${path7.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;
@@ -1239,14 +2459,14 @@ ${BRIDGE_END}`;
     updated = existing.slice(0, startIdx) + injected + existing.slice(endIdx + BRIDGE_END.length);
   } else {
     if (!fileExists && !quiet) {
-      ui.info(`Creating ${path7.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 ${path7.relative(root, bridgeFile)}`)
+      ui.dim(`bridge: injected ${top.length} memor${top.length === 1 ? "y" : "ies"} into ${path10.relative(root, bridgeFile)}`)
     );
   }
 }
@@ -1271,18 +2491,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 path8 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(
@@ -1311,7 +2531,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;
@@ -1322,7 +2542,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(path8.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}`);
@@ -1334,12 +2554,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()}
@@ -1355,7 +2575,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(
@@ -1368,7 +2588,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)
@@ -1386,13 +2606,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) ${path8.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,
@@ -1405,14 +2625,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(path8.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 }) => {
@@ -1424,8 +2644,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 ${path8.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)`);
@@ -1455,8 +2675,8 @@ function parseCsv2(value) {
 }
 
 // src/commands/memory-list.ts
-import { existsSync as existsSync8 } from "fs";
-import path9 from "path";
+import { existsSync as existsSync11 } from "fs";
+import path12 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot10, resolveHaivePaths as resolveHaivePaths7 } from "@hiveai/core";
 
@@ -1472,7 +2692,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;
@@ -1504,7 +2724,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(path9.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path12.relative(root, filePath))}`);
     }
     console.log(ui.dim(`
 ${filtered.length} memor${filtered.length === 1 ? "y" : "ies"}`));
@@ -1539,21 +2759,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 path10 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;
@@ -1587,31 +2807,31 @@ function registerMemoryPromote(memory2) {
       },
       body: found.memory.body
     };
-    const newPath = memoryFilePath2(paths, "team", updated.frontmatter.id);
-    await mkdir5(path10.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 ${path10.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 path11 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;
@@ -1633,7 +2853,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)`);
@@ -1662,27 +2882,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(path11.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 path12 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;
@@ -1729,12 +2949,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 ${path12.relative(root, loaded.filePath)}`);
+    ui.success(`Updated ${path15.relative(root, loaded.filePath)}`);
     ui.info(`fields: ${updated.join(", ")}`);
   });
 }
@@ -1753,9 +2973,9 @@ function parseCsv3(value) {
 }
 
 // src/commands/memory-auto-promote.ts
-import { writeFile as writeFile8 } from "fs/promises";
-import { existsSync as existsSync12 } from "fs";
-import path13 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,
@@ -1764,7 +2984,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(
@@ -1774,7 +2994,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;
@@ -1800,13 +3020,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(path13.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++;
       }
     }
@@ -1817,9 +3037,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 path14 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,
@@ -1830,7 +3050,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;
@@ -1843,13 +3063,13 @@ function registerMemoryEdit(memory2) {
       return;
     }
     const editor = opts.editor ?? process.env.EDITOR ?? process.env.VISUAL ?? "vi";
-    ui.info(`Opening ${path14.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) {
@@ -1870,8 +3090,8 @@ function runEditor(editor, file) {
 }
 
 // src/commands/memory-for-files.ts
-import { existsSync as existsSync14 } from "fs";
-import path15 from "path";
+import { existsSync as existsSync17 } from "fs";
+import path18 from "path";
 import "commander";
 import {
   deriveConfidence,
@@ -1886,7 +3106,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;
@@ -1993,13 +3213,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(path15.relative(root, filePath))}`);
+    console.log(`  ${ui.dim(path18.relative(root, filePath))}`);
   }
 }
 
 // src/commands/memory-hot.ts
-import { existsSync as existsSync15 } from "fs";
-import path16 from "path";
+import { existsSync as existsSync18 } from "fs";
+import path19 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot17,
@@ -2011,7 +3231,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;
@@ -2039,7 +3259,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(path16.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\`.`
@@ -2048,16 +3268,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 path17 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(
@@ -2078,13 +3298,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,
@@ -2100,15 +3320,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(path17.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: ${path17.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)`);
   });
 }
@@ -2118,8 +3338,8 @@ function parseCsv4(value) {
 }
 
 // src/commands/memory-pending.ts
-import { existsSync as existsSync17 } from "fs";
-import path18 from "path";
+import { existsSync as existsSync20 } from "fs";
+import path21 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot19,
@@ -2131,7 +3351,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;
@@ -2159,15 +3379,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(path18.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 path19 from "path";
+import { existsSync as existsSync21 } from "fs";
+import path22 from "path";
 import "commander";
 import {
   extractSnippet,
@@ -2183,7 +3403,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;
@@ -2224,7 +3444,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(path19.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path22.relative(root, filePath))}`);
       const snippet = extractSnippet(mem.body, snippetNeedle);
       if (snippet) console.log(`  ${snippet}`);
     }
@@ -2241,8 +3461,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,
@@ -2250,13 +3470,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;
@@ -2268,9 +3488,9 @@ function registerMemoryReject(memory2) {
       process.exitCode = 1;
       return;
     }
-    await writeFile10(
+    await writeFile12(
       loaded.filePath,
-      serializeMemory8({
+      serializeMemory9({
         frontmatter: {
           ...loaded.memory.frontmatter,
           status: "rejected",
@@ -2292,9 +3512,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 path20 from "path";
+import path23 from "path";
 import { createInterface } from "readline/promises";
 import "commander";
 import {
@@ -2307,7 +3527,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;
@@ -2319,7 +3539,7 @@ function registerMemoryRm(memory2) {
       process.exitCode = 1;
       return;
     }
-    const rel = path20.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();
@@ -2343,9 +3563,9 @@ function registerMemoryRm(memory2) {
 }
 
 // src/commands/memory-show.ts
-import { existsSync as existsSync21 } from "fs";
-import { readFile as readFile6 } from "fs/promises";
-import path21 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,
@@ -2358,7 +3578,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;
@@ -2371,7 +3591,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;
@@ -2387,7 +3607,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:")}       ${path21.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}`);
@@ -2402,8 +3622,8 @@ function registerMemoryShow(memory2) {
 }
 
 // src/commands/memory-stats.ts
-import { existsSync as existsSync22 } from "fs";
-import path22 from "path";
+import { existsSync as existsSync25 } from "fs";
+import path25 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence3,
@@ -2416,7 +3636,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;
@@ -2441,20 +3661,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(path22.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 path23 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) {
@@ -2463,7 +3683,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;
@@ -2486,7 +3706,7 @@ function registerMemoryVerify(memory2) {
         anchorlessIds.push(mem.frontmatter.id);
         continue;
       }
-      const rel = path23.relative(root, filePath);
+      const rel = path26.relative(root, filePath);
       if (result.stale) {
         staleCount++;
         console.log(`${ui.bold("STALE")}  ${mem.frontmatter.id}`);
@@ -2501,7 +3721,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++;
       }
     }
@@ -2549,8 +3769,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,
@@ -2562,17 +3782,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`);
@@ -2600,15 +3820,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 path24 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 = [];
@@ -2673,13 +3893,13 @@ function registerMemoryImportChangelog(memory2) {
   ).option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot27(opts.dir);
     const paths = resolveHaivePaths24(root);
-    const changelogPath = path24.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.");
@@ -2693,10 +3913,10 @@ function registerMemoryImportChangelog(memory2) {
         entries = entries.filter((e) => requested.includes(e.version));
       }
     }
-    const pkgName = opts.package ?? path24.basename(path24.dirname(changelogPath));
+    const pkgName = opts.package ?? path27.basename(path27.dirname(changelogPath));
     const scope = opts.scope ?? "team";
-    const teamDir = path24.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 = [];
@@ -2718,11 +3938,11 @@ function registerMemoryImportChangelog(memory2) {
         lines.push("");
       }
       lines.push(
-        `**Source:** \`${path24.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,
@@ -2733,12 +3953,12 @@ function registerMemoryImportChangelog(memory2) {
           pkgName.replace(/[^a-z0-9]/gi, "-").toLowerCase(),
           `v${entry.version}`
         ],
-        paths: [path24.relative(root, changelogPath)],
+        paths: [path27.relative(root, changelogPath)],
         topic: `changelog-${pkgName}-${entry.version}`
       });
-      await writeFile12(
-        path24.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}`));
@@ -2760,9 +3980,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 path25 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,
@@ -2785,7 +4005,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;
@@ -2857,8 +4077,8 @@ function registerMemoryDigest(program2) {
     );
     const digest = lines.join("\n");
     if (opts.out) {
-      const outPath = path25.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);
@@ -2867,17 +4087,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 path26 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 = [];
@@ -2928,7 +4148,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;
@@ -2937,12 +4157,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(path26.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)
@@ -2958,13 +4178,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=${path26.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,
@@ -2974,11 +4194,11 @@ function registerSessionEnd(session2) {
       topic,
       status: "validated"
     });
-    const file = memoryFilePath4(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir8(path26.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=${path26.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.");
   });
 }
@@ -2988,9 +4208,9 @@ function parseCsv5(value) {
 }
 
 // src/commands/snapshot.ts
-import { existsSync as existsSync28 } from "fs";
-import { readdir } from "fs/promises";
-import path27 from "path";
+import { existsSync as existsSync31 } from "fs";
+import { readdir as readdir2 } from "fs/promises";
+import path30 from "path";
 import "commander";
 import {
   diffContract,
@@ -3023,18 +4243,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 = path27.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) {
@@ -3085,7 +4305,7 @@ function registerSnapshot(program2) {
       return;
     }
     const contractPath = opts.contract;
-    const name = opts.name ?? path27.basename(contractPath, path27.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 {
@@ -3140,8 +4360,8 @@ async function runDiff(root, haiveDir, contract) {
   }
 }
 function detectFormat(filePath) {
-  const ext = path27.extname(filePath).toLowerCase();
-  const base = path27.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";
@@ -3154,9 +4374,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 path28 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 {
@@ -3165,7 +4385,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(
@@ -3175,8 +4395,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 = path28.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" });
@@ -3186,10 +4406,10 @@ function registerHub(program2) {
         return;
       }
     }
-    const sharedDir = path28.join(absPath, ".ai", "memories", "shared");
-    await mkdir9(sharedDir, { recursive: true });
-    await writeFile15(
-      path28.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.
@@ -3210,8 +4430,8 @@ haive hub pull   # import into a project
 `,
       "utf8"
     );
-    await writeFile15(
-      path28.join(absPath, ".gitignore"),
+    await writeFile17(
+      path31.join(absPath, ".gitignore"),
       ".ai/.cache/\n.ai/memories/personal/\n",
       "utf8"
     );
@@ -3226,7 +4446,7 @@ haive hub pull   # import into a project
         `
 Next steps:
   1. Add hubPath to your project's .ai/haive.config.json:
-       { "hubPath": "${path28.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.)
 `
@@ -3255,15 +4475,15 @@ Next steps:
       process.exitCode = 1;
       return;
     }
-    const hubRoot = path28.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 = path28.basename(root);
-    const destDir = path28.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)
@@ -3281,15 +4501,15 @@ Next steps:
     for (const { memory: memory2 } of shared) {
       const fm = memory2.frontmatter;
       const fileName = `${fm.id}.md`;
-      const destPath = path28.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", path28.join(".ai", "memories", "shared", projectName)], {
+      spawnSync3("git", ["add", path31.join(".ai", "memories", "shared", projectName)], {
         cwd: hubRoot
       });
       const commit = spawnSync3("git", ["commit", "-m", message], {
@@ -3324,15 +4544,15 @@ Next steps:
       process.exitCode = 1;
       return;
     }
-    const hubRoot = path28.resolve(root, config.hubPath);
-    const hubSharedDir = path28.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 = path28.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;
@@ -3340,17 +4560,17 @@ Next steps:
     let totalImported = 0;
     let totalUpdated = 0;
     for (const sourceName of projectDirs) {
-      const sourceDir = path28.join(hubSharedDir, sourceName);
-      const destDir = path28.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 = path28.join(sourceDir, file);
-        const destPath = path28.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);
@@ -3380,14 +4600,14 @@ Next steps:
     console.log(
       `  hubPath: ${config.hubPath ? ui.green(config.hubPath) : ui.dim("not configured")}`
     );
-    const sharedDir = path28.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(path28.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 {
@@ -3402,8 +4622,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;
   });
 }
@@ -3605,20 +4825,20 @@ function summarize(name, t0, payload, notes) {
 }
 
 // src/commands/memory-suggest.ts
-import { mkdir as mkdir10, writeFile as writeFile16 } from "fs/promises";
-import { existsSync as existsSync30 } from "fs";
-import path29 from "path";
+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 buildFrontmatter6,
+  buildFrontmatter as buildFrontmatter7,
   findProjectRoot as findProjectRoot34,
   loadMemoriesFromDir as loadMemoriesFromDir8,
-  memoryFilePath as memoryFilePath5,
+  memoryFilePath as memoryFilePath6,
   parseSince as parseSince2,
   readUsageEvents as readUsageEvents2,
   resolveHaivePaths as resolveHaivePaths31,
-  serializeMemory as serializeMemory13
+  serializeMemory as serializeMemory14
 } from "@hiveai/core";
 var SEARCH_TOOLS = /* @__PURE__ */ new Set([
   "mem_search",
@@ -3677,7 +4897,7 @@ function registerMemorySuggest(memory2) {
       }
       const created = [];
       const skipped = [];
-      const existing = existsSync30(paths.memoriesDir) ? await loadMemoriesFromDir8(paths.memoriesDir) : [];
+      const existing = existsSync33(paths.memoriesDir) ? await loadMemoriesFromDir8(paths.memoriesDir) : [];
       for (const s of top) {
         const slug = slugify(s.query);
         if (!slug) {
@@ -3689,7 +4909,7 @@ function registerMemorySuggest(memory2) {
           skipped.push({ query: s.query, reason: `similar memory already exists (${dup.memory.frontmatter.id})` });
           continue;
         }
-        const fm = buildFrontmatter6({
+        const fm = buildFrontmatter7({
           type: s.inferred_type,
           slug,
           scope,
@@ -3699,14 +4919,14 @@ function registerMemorySuggest(memory2) {
         });
         fm.status = "draft";
         const body = renderTemplate(s);
-        const file = memoryFilePath5(paths, fm.scope, fm.id, fm.module);
-        await mkdir10(path29.dirname(file), { recursive: true });
-        if (existsSync30(file)) {
-          skipped.push({ query: s.query, reason: `file already exists at ${path29.relative(root, file)}` });
+        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 writeFile16(file, serializeMemory13({ frontmatter: fm, body }), "utf8");
-        created.push({ id: fm.id, file: path29.relative(root, file), query: s.query });
+        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));
@@ -3799,9 +5019,9 @@ function truncate(text, max) {
 }
 
 // src/commands/memory-archive.ts
-import { existsSync as existsSync31 } from "fs";
-import { writeFile as writeFile17 } from "fs/promises";
-import path30 from "path";
+import { existsSync as existsSync34 } from "fs";
+import { writeFile as writeFile19 } from "fs/promises";
+import path33 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot35,
@@ -3809,7 +5029,7 @@ import {
   loadMemoriesFromDir as loadMemoriesFromDir9,
   loadUsageIndex as loadUsageIndex11,
   resolveHaivePaths as resolveHaivePaths32,
-  serializeMemory as serializeMemory14
+  serializeMemory as serializeMemory15
 } from "@hiveai/core";
 var MS_PER_DAY = 24 * 60 * 60 * 1e3;
 function registerMemoryArchive(memory2) {
@@ -3818,7 +5038,7 @@ function registerMemoryArchive(memory2) {
   ).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 (!existsSync31(paths.memoriesDir)) {
+    if (!existsSync34(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -3839,7 +5059,7 @@ function registerMemoryArchive(memory2) {
       if (typeFilter && fm.type !== typeFilter) continue;
       if (fm.status === "deprecated" || fm.status === "rejected") continue;
       const hasAnyAnchor = fm.anchor.paths.length + fm.anchor.symbols.length > 0;
-      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync31(path30.join(paths.root, p)));
+      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);
@@ -3887,7 +5107,7 @@ function registerMemoryArchive(memory2) {
       if (!found) continue;
       const fm = { ...found.memory.frontmatter, status: "deprecated" };
       try {
-        await writeFile17(c.filePath, serializeMemory14({ frontmatter: fm, body: found.memory.body }), "utf8");
+        await writeFile19(c.filePath, serializeMemory15({ frontmatter: fm, body: found.memory.body }), "utf8");
         archived++;
       } catch (err) {
         if (!opts.json) {
@@ -3913,7 +5133,7 @@ function parseDays(input) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync32 } from "fs";
+import { existsSync as existsSync35 } from "fs";
 import { stat } from "fs/promises";
 import "path";
 import "commander";
@@ -3936,7 +5156,7 @@ function registerDoctor(program2) {
     const root = findProjectRoot36(opts.dir);
     const paths = resolveHaivePaths33(root);
     const findings = [];
-    if (!existsSync32(paths.haiveDir)) {
+    if (!existsSync35(paths.haiveDir)) {
       findings.push({
         severity: "error",
         code: "not-initialized",
@@ -3945,7 +5165,7 @@ function registerDoctor(program2) {
       });
       return emit(findings, opts);
     }
-    if (!existsSync32(paths.projectContext)) {
+    if (!existsSync35(paths.projectContext)) {
       findings.push({
         severity: "warn",
         code: "no-project-context",
@@ -3953,8 +5173,8 @@ function registerDoctor(program2) {
         fix: "haive init"
       });
     } else {
-      const { readFile: readFile10 } = await import("fs/promises");
-      const content = await readFile10(paths.projectContext, "utf8");
+      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({
@@ -3965,7 +5185,7 @@ function registerDoctor(program2) {
         });
       }
     }
-    const memories = existsSync32(paths.memoriesDir) ? await loadMemoriesFromDir10(paths.memoriesDir) : [];
+    const memories = existsSync35(paths.memoriesDir) ? await loadMemoriesFromDir10(paths.memoriesDir) : [];
     const now = Date.now();
     if (memories.length === 0) {
       findings.push({
@@ -4119,7 +5339,7 @@ function isSearchTool(name) {
 }
 
 // src/commands/playback.ts
-import { existsSync as existsSync33 } from "fs";
+import { existsSync as existsSync36 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot37,
@@ -4149,7 +5369,7 @@ function registerPlayback(program2) {
     const filtered = cutoff > 0 ? events.filter((e) => Date.parse(e.at) >= cutoff) : events;
     const gapMs = Math.max(1, parseInt(opts.sessionGap ?? "30", 10)) * MS_PER_MINUTE;
     const sessions = bucketSessions(filtered, gapMs);
-    const all = existsSync33(paths.memoriesDir) ? await loadMemoriesFromDir11(paths.memoriesDir) : [];
+    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);
@@ -4345,7 +5565,7 @@ function runCommand(cmd, args, cwd) {
 
 // src/index.ts
 var program = new Command39();
-program.name("haive").description("hAIve \u2014 team-first persistent memory layer for AI coding agents").version("0.6.0");
+program.name("haive").description("hAIve \u2014 team-first persistent memory layer for AI coding agents").version("0.7.1");
 registerInit(program);
 registerMcp(program);
 registerBriefing(program);