@hiveai/cli 0.7.2 → 0.9.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command39 } from "commander";
+import { Command as Command40 } from "commander";
 
 // src/commands/briefing.ts
 import { existsSync } from "fs";
@@ -14,6 +14,7 @@ import {
   literalMatchesAnyToken,
   loadCodeMap,
   loadMemoriesFromDir,
+  loadUsageIndex,
   memoryMatchesAnchorPaths,
   queryCodeMap,
   resolveHaivePaths,
@@ -51,11 +52,240 @@ var ui = {
   }
 };
 
+// src/utils/briefing-radar.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var exec = promisify(execFile);
+var DEFAULT_DAYS_BACK = 14;
+var DEFAULT_MAX_COMMITS = 5;
+var DEFAULT_MAX_TODOS = 8;
+var DEFAULT_MAX_HOT_FILES = 5;
+var TODO_RE = /\b(?:TODO|FIXME|HACK|XXX)\b[: ]?(.{0,120})/i;
+var SOURCE_GLOBS = [
+  "*.ts",
+  "*.tsx",
+  "*.js",
+  "*.jsx",
+  "*.py",
+  "*.go",
+  "*.rs",
+  "*.java",
+  "*.kt",
+  "*.swift",
+  "*.rb",
+  "*.php",
+  "*.cs",
+  "*.cpp",
+  "*.c",
+  "*.h"
+];
+async function isGitRepo(root) {
+  try {
+    await exec("git", ["rev-parse", "--is-inside-work-tree"], { cwd: root });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getRecentCommits(root, daysBack, maxCommits, taskTokens, filePaths) {
+  try {
+    const { stdout } = await exec(
+      "git",
+      [
+        "log",
+        `--since=${daysBack}.days.ago`,
+        "--name-only",
+        "--pretty=format:%x1f%h%x1f%ad%x1f%s",
+        "--date=short",
+        "-n",
+        "60"
+      ],
+      { cwd: root, maxBuffer: 4 * 1024 * 1024 }
+    );
+    const blocks = stdout.split("").filter((b) => b.trim().length > 0);
+    const commits = [];
+    for (let i = 0; i + 2 < blocks.length; i += 3) {
+      const sha = blocks[i].trim();
+      const date = blocks[i + 1].trim();
+      const tail = blocks[i + 2];
+      const lines = tail.split("\n").map((l) => l.trim()).filter(Boolean);
+      const subject = lines.shift() ?? "";
+      const files = lines;
+      commits.push({ sha, date, subject, files });
+    }
+    const lowerTokens = taskTokens?.map((t) => t.toLowerCase()) ?? [];
+    const lowerPaths = filePaths.map((p) => p.toLowerCase());
+    const scored = commits.map((c) => {
+      let score = 0;
+      const haystack = (c.subject + " " + c.files.join(" ")).toLowerCase();
+      for (const t of lowerTokens) if (haystack.includes(t)) score += 2;
+      for (const p of lowerPaths) if (c.files.some((f) => f.toLowerCase().includes(p))) score += 3;
+      return { c, score };
+    });
+    if (lowerTokens.length === 0 && lowerPaths.length === 0) {
+      return commits.slice(0, maxCommits);
+    }
+    return scored.filter((s) => s.score > 0).sort((a, b) => b.score - a.score).slice(0, maxCommits).map((s) => s.c);
+  } catch {
+    return [];
+  }
+}
+async function getOpenTodos(root, maxTodos, taskTokens, filePaths) {
+  try {
+    const includeArgs = SOURCE_GLOBS.flatMap((g) => ["--include", g]);
+    const { stdout } = await exec(
+      "grep",
+      [
+        "-rnE",
+        "--exclude-dir=node_modules",
+        "--exclude-dir=.git",
+        "--exclude-dir=dist",
+        "--exclude-dir=build",
+        "--exclude-dir=.next",
+        "--exclude-dir=coverage",
+        ...includeArgs,
+        "\\b(TODO|FIXME|HACK|XXX)\\b",
+        "."
+      ],
+      { cwd: root, maxBuffer: 4 * 1024 * 1024 }
+    ).catch((err) => ({ stdout: err.stdout ?? "" }));
+    const lines = stdout.split("\n").filter(Boolean);
+    const parsed = [];
+    for (const line of lines) {
+      const m = line.match(/^([^:]+):(\d+):(.*)$/);
+      if (!m) continue;
+      const [, file, lineNoStr, rest] = m;
+      const todoMatch = rest.match(TODO_RE);
+      if (!todoMatch) continue;
+      const text = (todoMatch[1] ?? "").trim() || rest.trim().slice(0, 120);
+      parsed.push({ file: file.replace(/^\.\//, ""), line: Number(lineNoStr), text });
+    }
+    const lowerTokens = taskTokens?.map((t) => t.toLowerCase()) ?? [];
+    const lowerPaths = filePaths.map((p) => p.toLowerCase());
+    if (lowerTokens.length === 0 && lowerPaths.length === 0) {
+      return parsed.slice(0, maxTodos);
+    }
+    const scored = parsed.map((t) => {
+      let score = 0;
+      const hay = (t.file + " " + t.text).toLowerCase();
+      for (const tok of lowerTokens) if (hay.includes(tok)) score += 1;
+      for (const p of lowerPaths) if (t.file.toLowerCase().includes(p)) score += 2;
+      return { t, score };
+    });
+    return scored.filter((s) => s.score > 0).sort((a, b) => b.score - a.score).slice(0, maxTodos).map((s) => s.t);
+  } catch {
+    return [];
+  }
+}
+async function getHotFiles(root, daysBack, maxHotFiles, filePaths) {
+  try {
+    const { stdout } = await exec(
+      "git",
+      [
+        "log",
+        `--since=${daysBack * 6}.days.ago`,
+        "--name-only",
+        "--pretty=format:"
+      ],
+      { cwd: root, maxBuffer: 4 * 1024 * 1024 }
+    );
+    const counts = /* @__PURE__ */ new Map();
+    for (const raw of stdout.split("\n")) {
+      const f = raw.trim();
+      if (!f) continue;
+      counts.set(f, (counts.get(f) ?? 0) + 1);
+    }
+    let entries = [...counts.entries()].map(([path37, changes]) => ({ path: path37, changes }));
+    const lowerPaths = filePaths.map((p) => p.toLowerCase());
+    if (lowerPaths.length > 0) {
+      entries = entries.filter((e) => lowerPaths.some((p) => e.path.toLowerCase().includes(p)));
+    }
+    return entries.sort((a, b) => b.changes - a.changes).slice(0, maxHotFiles);
+  } catch {
+    return [];
+  }
+}
+async function buildRadar(opts) {
+  const inside = await isGitRepo(opts.root);
+  if (!inside) {
+    return { recentCommits: [], openTodos: [], hotFiles: [], insideGitRepo: false };
+  }
+  const daysBack = opts.daysBack ?? DEFAULT_DAYS_BACK;
+  const [recentCommits, openTodos, hotFiles] = await Promise.all([
+    getRecentCommits(opts.root, daysBack, opts.maxCommits ?? DEFAULT_MAX_COMMITS, opts.taskTokens, opts.filePaths),
+    getOpenTodos(opts.root, opts.maxTodos ?? DEFAULT_MAX_TODOS, opts.taskTokens, opts.filePaths),
+    getHotFiles(opts.root, daysBack, opts.maxHotFiles ?? DEFAULT_MAX_HOT_FILES, opts.filePaths)
+  ]);
+  return { recentCommits, openTodos, hotFiles, insideGitRepo: true };
+}
+function radarHasContent(r) {
+  return r.recentCommits.length > 0 || r.openTodos.length > 0 || r.hotFiles.length > 0;
+}
+
 // src/commands/briefing.ts
+var RADAR_AUTO_THRESHOLD = 3;
+var CHARS_PER_TOKEN = 4;
+function printRadar(radar, out, reason) {
+  if (!radar.insideGitRepo) return;
+  if (!radarHasContent(radar)) return;
+  const header = reason === "low-memory-signal" ? "=== Project Radar (few relevant memories \u2014 surfacing live signals) ===" : "=== Project Radar ===";
+  out(`${ui.bold(header)}
+`);
+  if (radar.recentCommits.length > 0) {
+    out(ui.bold("Recent commits:"));
+    for (const c of radar.recentCommits) {
+      const filesBlurb = c.files.slice(0, 3).join(", ");
+      const more = c.files.length > 3 ? ` (+${c.files.length - 3})` : "";
+      out(`  ${ui.dim(c.date)} ${c.sha}  ${c.subject}`);
+      if (filesBlurb) out(ui.dim(`    ${filesBlurb}${more}`));
+    }
+    out("");
+  }
+  if (radar.openTodos.length > 0) {
+    out(ui.bold("Open TODOs/FIXMEs:"));
+    for (const t of radar.openTodos) {
+      out(`  ${ui.dim(t.file + ":" + t.line)}  ${t.text}`);
+    }
+    out("");
+  }
+  if (radar.hotFiles.length > 0) {
+    out(ui.bold("Hot files (most modified recently):"));
+    for (const f of radar.hotFiles) {
+      out(`  ${f.changes}\xD7 ${ui.dim(f.path)}`);
+    }
+    out("");
+  }
+}
+var TokenBudgetWriter = class {
+  constructor(budgetChars) {
+    this.budgetChars = budgetChars;
+  }
+  budgetChars;
+  used = 0;
+  truncated = false;
+  write(text) {
+    if (this.truncated) return false;
+    const next = this.used + text.length + 1;
+    if (next > this.budgetChars) {
+      console.log(ui.dim(`... [briefing truncated to fit --max-tokens budget \xB7 ${Math.round(this.used / CHARS_PER_TOKEN)} tokens used]`));
+      this.truncated = true;
+      return false;
+    }
+    console.log(text);
+    this.used = next;
+    return true;
+  }
+  isTruncated() {
+    return this.truncated;
+  }
+  remainingChars() {
+    return Math.max(0, this.budgetChars - this.used);
+  }
+};
 function registerBriefing(program2) {
   program2.command("briefing").description(
     'Print the full project briefing: last session recap + project context + relevant memories.\n  Equivalent to calling get_briefing via MCP. Run before starting any task.\n\n  Examples:\n    haive briefing\n    haive briefing --task "add Stripe payment" --files src/payments/PaymentService.ts\n    haive briefing --symbols PaymentService,TenantFilter   # look up where symbols live\n'
-  ).option("--task <text>", "what you are about to do \u2014 filters memories by relevance").option("--files <csv>", "comma-separated file paths being worked on (surfaces anchored memories)").option("--symbols <csv>", "symbol names to look up in the code-map (e.g. PaymentService,TenantFilter) \u2014 requires haive index code").option("--max-memories <n>", "cap on memories surfaced", "10").option(
+  ).option("--task <text>", "what you are about to do \u2014 filters memories by relevance").option("--files <csv>", "comma-separated file paths being worked on (surfaces anchored memories)").option("--symbols <csv>", "symbol names to look up in the code-map (e.g. PaymentService,TenantFilter) \u2014 requires haive index code").option("--max-memories <n>", "cap on memories surfaced", "10").option("--max-tokens <n>", "approximate token budget for the entire briefing (truncates if exceeded)").option("--explain-source", "annotate each memory with [source: <relative-path> \xB7 anchors: <files>] for traceable citations").option("--radar", "force project radar (recent commits, open TODOs, hot files) even when memories are plentiful").option("--no-radar", "disable the project radar even when memories are scarce").option(
     "--scope <scope>",
     "personal | team | shared | all (default: all \u2014 includes team + shared cross-repo memories)",
     "all"
@@ -67,14 +297,29 @@ function registerBriefing(program2) {
   ).option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot(opts.dir);
     const paths = resolveHaivePaths(root);
+    const budgetTokens = opts.maxTokens ? Math.max(100, Number(opts.maxTokens)) : null;
+    const writer = budgetTokens ? new TokenBudgetWriter(budgetTokens * CHARS_PER_TOKEN) : null;
+    const out = (text) => {
+      if (writer) return writer.write(text);
+      console.log(text);
+      return true;
+    };
+    const stopped = () => writer?.isTruncated() ?? false;
     if (!existsSync(paths.memoriesDir)) {
       if (existsSync(paths.projectContext)) {
-        console.log(`${ui.bold("=== Project Context ===")}
+        out(`${ui.bold("=== Project Context ===")}
 `);
-        console.log((await readFile(paths.projectContext, "utf8")).trim());
+        out((await readFile(paths.projectContext, "utf8")).trim());
+        out("");
       } else {
         ui.warn("No project-context.md found. Run `haive init` and the `bootstrap_project` MCP prompt to set it up.");
       }
+      if (opts.radar !== false && !stopped()) {
+        const filePathsEarly = parseCsv(opts.files);
+        const tokensEarly = opts.task ? tokenizeQuery(opts.task) : null;
+        const radar = await buildRadar({ root, taskTokens: tokensEarly, filePaths: filePathsEarly });
+        printRadar(radar, out, "low-memory-signal");
+      }
       return;
     }
     const ownMemories = await loadMemoriesFromDir(paths.memoriesDir);
@@ -112,17 +357,17 @@ function registerBriefing(program2) {
     const recaps = all.filter(({ memory: mem }) => mem.frontmatter.type === "session_recap").sort(
       (a, b) => new Date(b.memory.frontmatter.created_at).getTime() - new Date(a.memory.frontmatter.created_at).getTime()
     );
-    if (recaps.length > 0) {
+    if (recaps.length > 0 && !stopped()) {
       const recap = recaps[0];
       const fm = recap.memory.frontmatter;
       const rev = fm.revision_count ? ` \xB7 revision #${fm.revision_count}` : "";
-      console.log(`${ui.bold("=== Last Session Recap ===")}
+      out(`${ui.bold("=== Last Session Recap ===")}
 `);
-      console.log(ui.dim(`${fm.id} (${fm.scope}${rev})`));
-      console.log(recap.memory.body.trim());
-      console.log();
+      out(ui.dim(`${fm.id} (${fm.scope}${rev})`));
+      out(recap.memory.body.trim());
+      out("");
     }
-    if (existsSync(paths.projectContext)) {
+    if (existsSync(paths.projectContext) && !stopped()) {
       const ctx = await readFile(paths.projectContext, "utf8");
       const isTemplate = ctx.includes("TODO \u2014 high-level overview") || ctx.includes("Generated by `haive init`");
       if (isTemplate) {
@@ -132,14 +377,14 @@ function registerBriefing(program2) {
         ui.warn(
           "Fix: in your AI client, invoke the MCP prompt bootstrap_project to auto-fill it from your codebase."
         );
-        console.log();
+        out("");
       } else {
-        console.log(`${ui.bold("=== Project Context ===")}
+        out(`${ui.bold("=== Project Context ===")}
 `);
-        console.log(ctx.trim());
-        console.log();
+        out(ctx.trim());
+        out("");
       }
-    } else {
+    } else if (!existsSync(paths.projectContext)) {
       ui.warn(
         "No project-context.md found. Run `haive init` then invoke the bootstrap_project MCP prompt."
       );
@@ -177,54 +422,85 @@ function registerBriefing(program2) {
       if (draftCount > 0) {
         ui.info(`(${draftCount} draft memories excluded \u2014 use --include-draft to show)`);
       }
+      if (opts.radar !== false && !stopped()) {
+        const radar = await buildRadar({ root, taskTokens: tokens, filePaths });
+        out("");
+        printRadar(radar, out, "low-memory-signal");
+      }
       return;
     }
-    console.log(`${ui.bold("=== Relevant Memories ===")}
+    if (stopped()) return;
+    const usageIndex = await loadUsageIndex(paths).catch(() => null);
+    out(`${ui.bold("=== Relevant Memories ===")}
 `);
     for (const item of top) {
+      if (stopped()) break;
       const fm = item.memory.frontmatter;
       const badge = ui.statusBadge(fm.status);
       const draftMarker = fm.status === "draft" ? ui.yellow(" [DRAFT]") : "";
       const unverifiedMarker = fm.status === "proposed" ? ui.yellow(" [UNVERIFIED]") : "";
       const originMarker = item.origin ? ` ${ui.yellow("[from " + item.origin + "]")}` : "";
-      console.log(
-        `${ui.bold(fm.id)}  ${ui.dim(fm.scope + "/" + fm.type)}  ${badge}${draftMarker}${unverifiedMarker}${originMarker}`
+      const reads = usageIndex?.by_id[fm.id]?.read_count ?? 0;
+      const hitMarker = reads > 0 ? ` ${ui.dim("\xB7 " + reads + "\xD7 read")}` : "";
+      out(
+        `${ui.bold(fm.id)}  ${ui.dim(fm.scope + "/" + fm.type)}  ${badge}${draftMarker}${unverifiedMarker}${originMarker}${hitMarker}`
       );
-      console.log(item.memory.body.trim());
-      console.log();
+      if (opts.explainSource) {
+        const relPath = path.relative(root, item.filePath);
+        const anchorPaths = fm.anchor?.paths ?? [];
+        const anchorSymbols = fm.anchor?.symbols ?? [];
+        const parts = [`source: ${relPath}`];
+        if (anchorPaths.length > 0) parts.push(`paths: ${anchorPaths.join(", ")}`);
+        if (anchorSymbols.length > 0) parts.push(`symbols: ${anchorSymbols.join(", ")}`);
+        out(ui.dim(`  [${parts.join(" \xB7 ")}]`));
+      }
+      out(item.memory.body.trim());
+      out("");
     }
-    console.log(ui.dim(`${top.length} memor${top.length === 1 ? "y" : "ies"} surfaced`));
+    if (!stopped()) out(ui.dim(`${top.length} memor${top.length === 1 ? "y" : "ies"} surfaced`));
     const ids = top.map(({ memory: mem }) => mem.frontmatter.id);
     if (ids.length > 0) {
       await trackReads(paths, ids).catch(() => {
       });
     }
+    const radarForced = opts.radar === true;
+    const radarAuto = opts.radar !== false && top.length < RADAR_AUTO_THRESHOLD;
+    if ((radarForced || radarAuto) && !stopped()) {
+      const radar = await buildRadar({ root, taskTokens: tokens, filePaths });
+      if (radarHasContent(radar)) {
+        out("");
+        printRadar(radar, out, radarForced ? "forced" : "low-memory-signal");
+      }
+    }
     const requestedSymbols = (opts.symbols ?? "").split(",").map((s) => s.trim()).filter(Boolean);
-    if (requestedSymbols.length > 0) {
+    if (requestedSymbols.length > 0 && !stopped()) {
       const codeMap = await loadCodeMap(paths);
       if (!codeMap) {
         ui.warn("No code-map found. Run `haive index code` first to enable symbol lookup.");
       } else {
-        console.log(`
+        out(`
 ${ui.bold("=== Symbol Locations ===")}
 `);
         for (const sym of requestedSymbols) {
+          if (stopped()) break;
           const { files } = queryCodeMap(codeMap, { symbol: sym });
           if (files.length === 0) {
-            console.log(`${ui.dim(sym)}  (not found in code-map)`);
+            out(`${ui.dim(sym)}  (not found in code-map)`);
           } else {
             for (const f of files) {
+              if (stopped()) break;
               const exports = f.entry.exports.filter(
                 (e) => e.name.toLowerCase().includes(sym.toLowerCase())
               );
               for (const e of exports) {
+                if (stopped()) break;
                 const desc = e.description ? `  \u2014 ${e.description}` : "";
-                console.log(`${ui.bold(e.name)}  ${ui.dim(f.path + ":" + e.line)}  [${e.kind}]${desc}`);
+                out(`${ui.bold(e.name)}  ${ui.dim(f.path + ":" + e.line)}  [${e.kind}]${desc}`);
               }
             }
           }
         }
-        console.log();
+        out("");
       }
     }
   });
@@ -759,6 +1035,13 @@ var HAIVE_MCP_ENTRY = {
   command: "haive-mcp",
   args: []
 };
+function projectMcpEntry(root) {
+  return {
+    command: "haive-mcp",
+    args: [],
+    env: { HAIVE_PROJECT_ROOT: root }
+  };
+}
 function cursorMcpPath() {
   return path5.join(HOME, ".cursor", "mcp.json");
 }
@@ -877,6 +1160,61 @@ async function autoConfigureMcpClients() {
   }
   return results;
 }
+async function configureProjectMcpClients(root) {
+  const entry = projectMcpEntry(root);
+  const results = [];
+  try {
+    const cursorPath = path5.join(root, ".cursor", "mcp.json");
+    let config = {};
+    if (existsSync4(cursorPath)) {
+      try {
+        config = JSON.parse(await readFile3(cursorPath, "utf8"));
+      } catch {
+      }
+    }
+    config.mcpServers ??= {};
+    config.mcpServers["haive"] = entry;
+    await mkdir(path5.dirname(cursorPath), { recursive: true });
+    await writeFile(cursorPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+    results.push({ client: "Cursor (project)", status: "configured", path: cursorPath });
+  } catch (err) {
+    results.push({ client: "Cursor (project)", status: "error", error: String(err) });
+  }
+  try {
+    const vscodePath = path5.join(root, ".vscode", "mcp.json");
+    let config = {};
+    if (existsSync4(vscodePath)) {
+      try {
+        config = JSON.parse(await readFile3(vscodePath, "utf8"));
+      } catch {
+      }
+    }
+    config.servers ??= {};
+    config.servers["haive"] = { ...entry, type: "stdio" };
+    await mkdir(path5.dirname(vscodePath), { recursive: true });
+    await writeFile(vscodePath, JSON.stringify(config, null, 2) + "\n", "utf8");
+    results.push({ client: "VS Code (workspace)", status: "configured", path: vscodePath });
+  } catch (err) {
+    results.push({ client: "VS Code (workspace)", status: "error", error: String(err) });
+  }
+  try {
+    const mcpPath = path5.join(root, ".mcp.json");
+    let config = {};
+    if (existsSync4(mcpPath)) {
+      try {
+        config = JSON.parse(await readFile3(mcpPath, "utf8"));
+      } catch {
+      }
+    }
+    config.mcpServers ??= {};
+    config.mcpServers["haive"] = { ...entry, type: "stdio" };
+    await writeFile(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+    results.push({ client: "Claude Code (project)", status: "configured", path: mcpPath });
+  } catch (err) {
+    results.push({ client: "Claude Code (project)", status: "error", error: String(err) });
+  }
+  return results;
+}
 
 // src/commands/init-stack-packs.ts
 import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
@@ -1671,18 +2009,21 @@ jobs:
 `;
 function registerInit(program2) {
   program2.command("init").description(
-    "Initialize a hAIve project \u2014 autopilot mode ON by default (zero human intervention).\n  Add --manual if you want to control memory approval and session recaps yourself."
+    "Initialize a hAIve project \u2014 autopilot mode ON by default (zero human intervention).\n  Auto-bootstraps project-context.md from local files and seeds detected stack packs.\n  Add --manual to control memory approval and session recaps yourself.\n  Add --no-bootstrap and --stack none to disable the auto-features."
   ).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)"
+    "auto-generate .ai/project-context.md from package.json, README, and directory structure (ON by default in autopilot)"
+  ).option(
+    "--no-bootstrap",
+    "skip the project-context auto-generation (only the default template is written)"
   ).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.`
+  Defaults to 'auto' in autopilot mode (detects from package.json). Pass 'none' to disable.`
   ).option(
     "--no-mcp-setup",
     "skip auto-configuring haive-mcp in Cursor / VS Code / Claude Code"
@@ -1690,6 +2031,8 @@ function registerInit(program2) {
     const root = path7.resolve(opts.dir);
     const paths = resolveHaivePaths4(root);
     const autopilot = opts.manual !== true;
+    const wantBootstrap = opts.bootstrap === void 0 ? autopilot : opts.bootstrap;
+    const wantStack = opts.stack === void 0 ? autopilot ? "auto" : void 0 : opts.stack === "none" ? void 0 : opts.stack;
     if (existsSync6(paths.haiveDir)) {
       ui.warn(`.ai/ already exists at ${paths.haiveDir} \u2014 leaving existing files in place.`);
     }
@@ -1698,7 +2041,7 @@ function registerInit(program2) {
     await mkdir3(paths.moduleDir, { recursive: true });
     await mkdir3(paths.modulesContextDir, { recursive: true });
     if (!existsSync6(paths.projectContext)) {
-      if (opts.bootstrap) {
+      if (wantBootstrap) {
         ui.info("Bootstrapping project context from local files\u2026");
         try {
           const context = await generateBootstrapContext(root);
@@ -1727,7 +2070,7 @@ function registerInit(program2) {
       await writeBridge(root, ".cursorrules");
       await writeBridge(root, path7.join(".github", "copilot-instructions.md"));
     }
-    const stacksToSeed = await resolveStacksToSeed(root, opts.stack);
+    const stacksToSeed = await resolveStacksToSeed(root, wantStack);
     if (stacksToSeed.length > 0) {
       let totalSeeded = 0;
       for (const stack of stacksToSeed) {
@@ -1792,7 +2135,18 @@ function registerInit(program2) {
           "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) {
+      const projectMcpResults = await configureProjectMcpClients(root);
+      for (const r of projectMcpResults) {
+        if (r.status === "configured") {
+          ui.success(`haive-mcp project config written (${path7.relative(root, r.path)})`);
+        }
+      }
+      await ensureGitignoreEntries(root, [
+        ".cursor/mcp.json",
+        ".vscode/mcp.json",
+        ".mcp.json"
+      ]);
+      if (configured.length > 0 || projectMcpResults.some((r) => r.status === "configured")) {
         ui.info(
           ui.dim("  \u2192 Restart your AI client for MCP changes to take effect.")
         );
@@ -1867,13 +2221,123 @@ async function writeBridge(root, relPath) {
   await writeFile3(target, BRIDGE_BODY, "utf8");
   ui.success(`Created bridge ${relPath}`);
 }
+async function ensureGitignoreEntries(root, patterns) {
+  try {
+    const gitignorePath = path7.join(root, ".gitignore");
+    let existing = "";
+    if (existsSync6(gitignorePath)) {
+      existing = await readFile4(gitignorePath, "utf8");
+    }
+    const lines = existing.split("\n");
+    const missing = patterns.filter((p) => !lines.some((l) => l.trim() === p));
+    if (missing.length === 0) return;
+    const toAppend = (existing.endsWith("\n") || existing === "" ? "" : "\n") + "# hAIve project-level MCP configs (machine-specific absolute paths)\n" + missing.join("\n") + "\n";
+    await writeFile3(gitignorePath, existing + toAppend, "utf8");
+  } catch {
+  }
+}
 
 // src/commands/install-hooks.ts
-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 { mkdir as mkdir5, writeFile as writeFile5, chmod, readFile as readFile6 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
+import path9 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot6 } from "@hiveai/core";
+
+// src/utils/claude-hooks.ts
+import { existsSync as existsSync7 } from "fs";
+import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import path8 from "path";
+var HAIVE_HOOK_TAG = "haive-passive-capture";
+var POST_TOOL_USE_GROUP = {
+  matcher: "Edit|Write|Bash",
+  hooks: [
+    {
+      type: "command",
+      command: "haive observe",
+      haive_tag: HAIVE_HOOK_TAG
+    }
+  ]
+};
+var SESSION_END_GROUP = {
+  hooks: [
+    {
+      type: "command",
+      command: "haive session end --quiet --auto",
+      haive_tag: HAIVE_HOOK_TAG
+    }
+  ]
+};
+function dropHaiveGroups(groups) {
+  return groups.filter(
+    (g) => !g.hooks.some((h) => h.haive_tag === HAIVE_HOOK_TAG)
+  );
+}
+function patchClaudeSettings(input) {
+  const settings = input ? { ...input } : {};
+  const hooks = settings.hooks ? { ...settings.hooks } : {};
+  hooks.PostToolUse = [
+    ...dropHaiveGroups(hooks.PostToolUse ?? []),
+    POST_TOOL_USE_GROUP
+  ];
+  hooks.SessionEnd = [
+    ...dropHaiveGroups(hooks.SessionEnd ?? []),
+    SESSION_END_GROUP
+  ];
+  settings.hooks = hooks;
+  return settings;
+}
+function unpatchClaudeSettings(input) {
+  const settings = input ? { ...input } : {};
+  if (!settings.hooks) return settings;
+  const hooks = { ...settings.hooks };
+  for (const [event, groups] of Object.entries(hooks)) {
+    const cleaned = dropHaiveGroups(groups);
+    if (cleaned.length === 0) {
+      delete hooks[event];
+    } else {
+      hooks[event] = cleaned;
+    }
+  }
+  settings.hooks = hooks;
+  if (Object.keys(hooks).length === 0) delete settings.hooks;
+  return settings;
+}
+async function installClaudeHooksAtPath(settingsPath) {
+  let raw = null;
+  let created = false;
+  if (existsSync7(settingsPath)) {
+    try {
+      raw = JSON.parse(await readFile5(settingsPath, "utf8"));
+    } catch {
+      throw new Error(`${settingsPath} exists but is not valid JSON. Fix it manually first.`);
+    }
+  } else {
+    created = true;
+  }
+  const patched = patchClaudeSettings(raw);
+  await mkdir4(path8.dirname(settingsPath), { recursive: true });
+  await writeFile4(settingsPath, JSON.stringify(patched, null, 2) + "\n", "utf8");
+  return { settingsPath, created };
+}
+async function uninstallClaudeHooksAtPath(settingsPath) {
+  if (!existsSync7(settingsPath)) {
+    return { settingsPath, created: false };
+  }
+  const raw = JSON.parse(await readFile5(settingsPath, "utf8"));
+  const cleaned = unpatchClaudeSettings(raw);
+  await writeFile4(settingsPath, JSON.stringify(cleaned, null, 2) + "\n", "utf8");
+  return { settingsPath, created: false };
+}
+function defaultClaudeSettingsPath(scope, projectRoot) {
+  if (scope === "user") {
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+    return path8.join(home, ".claude", "settings.json");
+  }
+  return path8.join(projectRoot, ".claude", "settings.local.json");
+}
+
+// src/commands/install-hooks.ts
 var HOOK_MARKER = "# hAIve auto-generated";
 var POST_MERGE_BODY = `#!/bin/sh
 ${HOOK_MARKER} \u2014 keep this block to allow upgrades. Hand-edit anything outside it.
@@ -1922,50 +2386,192 @@ var HOOKS = [
   { name: "post-rewrite", body: POST_MERGE_BODY },
   { name: "pre-push", body: PRE_PUSH_BODY }
 ];
+async function installGitHooks(opts) {
+  const root = findProjectRoot6(opts.dir);
+  const gitDir = path9.join(root, ".git");
+  if (!existsSync8(gitDir)) {
+    ui.error(`No .git directory at ${root}.`);
+    process.exitCode = 1;
+    return;
+  }
+  const hooksDir = path9.join(gitDir, "hooks");
+  await mkdir5(hooksDir, { recursive: true });
+  let installed = 0;
+  let skipped = 0;
+  for (const { name, body } of HOOKS) {
+    const file = path9.join(hooksDir, name);
+    if (existsSync8(file) && !opts.force) {
+      const existing = await readFile6(file, "utf8");
+      if (!existing.includes(HOOK_MARKER)) {
+        ui.warn(`${name} already exists and was not written by hAIve. Re-run with --force to overwrite.`);
+        skipped++;
+        continue;
+      }
+    }
+    await writeFile5(file, body, "utf8");
+    await chmod(file, 493);
+    installed++;
+  }
+  ui.success(`Installed ${installed} git hook(s) in .git/hooks/${skipped ? `, skipped ${skipped}` : ""}`);
+  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.");
+}
+async function installClaudeHooks(opts) {
+  const root = findProjectRoot6(opts.dir);
+  const scope = opts.scope ?? "user";
+  const settingsPath = opts.settings ?? defaultClaudeSettingsPath(scope, root);
+  if (opts.uninstall) {
+    const result = await uninstallClaudeHooksAtPath(settingsPath);
+    ui.success(`Removed hAIve hooks from ${result.settingsPath}`);
+    return;
+  }
+  try {
+    const result = await installClaudeHooksAtPath(settingsPath);
+    if (result.created) {
+      ui.success(`Created ${result.settingsPath} with hAIve passive-capture hooks`);
+    } else {
+      ui.success(`Patched ${result.settingsPath} (existing user hooks preserved)`);
+    }
+  } catch (err) {
+    ui.error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+    return;
+  }
+  ui.info("PostToolUse hook: `haive observe` runs after every Edit/Write/Bash");
+  ui.info("                   (appends a JSON line to .ai/.cache/observations.jsonl)");
+  ui.info("SessionEnd hook:   `haive session end --auto --quiet` distills observations");
+  ui.info("                   into a session_recap memory at session close");
+  ui.info("Restart Claude Code (or open a new conversation) for the hooks to take effect.");
+  ui.info(`Run \`haive install-hooks claude --uninstall\` to remove.`);
+}
 function registerInstallHooks(program2) {
-  program2.command("install-hooks").description(
-    "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 = path8.join(root, ".git");
-    if (!existsSync7(gitDir)) {
-      ui.error(`No .git directory at ${root}.`);
+  program2.command("install-hooks [target]").description(
+    "Install hAIve hooks. Targets:\n\n    git     (default) post-merge / post-rewrite / pre-push for haive sync + precommit\n    claude  PostToolUse + SessionEnd hooks in ~/.claude/settings.json\n            for passive observation capture (Claude Code only)\n\n  Examples:\n    haive install-hooks           # git hooks (legacy default)\n    haive install-hooks git\n    haive install-hooks claude\n    haive install-hooks claude --scope project\n    haive install-hooks claude --uninstall\n"
+  ).option("-d, --dir <dir>", "project root").option("--force", "overwrite existing hooks (git target only)").option("--scope <scope>", "claude target: 'user' (~/.claude) or 'project' (.claude/)", "user").option("--uninstall", "remove previously installed hAIve hooks (claude target only)").option("--settings <path>", "explicit path to settings.json (claude target only)").action(async (target, opts) => {
+    const t = (target ?? "git").toLowerCase();
+    if (t === "git") {
+      await installGitHooks(opts);
+    } else if (t === "claude") {
+      await installClaudeHooks(opts);
+    } else {
+      ui.error(`Unknown target: ${target}. Available: git, claude`);
       process.exitCode = 1;
-      return;
     }
-    const hooksDir = path8.join(gitDir, "hooks");
-    await mkdir4(hooksDir, { recursive: true });
-    let installed = 0;
-    let skipped = 0;
-    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;
-        }
+  });
+}
+
+// src/commands/observe.ts
+import { appendFile, mkdir as mkdir6 } from "fs/promises";
+import { existsSync as existsSync9 } from "fs";
+import path10 from "path";
+import "commander";
+import { findProjectRoot as findProjectRoot7, resolveHaivePaths as resolveHaivePaths5 } from "@hiveai/core";
+var MAX_STDIN_BYTES = 256 * 1024;
+var TRUNCATE_FIELD = 800;
+function truncate(s, max = TRUNCATE_FIELD) {
+  if (s == null) return "";
+  const str = typeof s === "string" ? s : JSON.stringify(s);
+  return str.length > max ? str.slice(0, max) + "\u2026" : str;
+}
+function extractFiles(payload) {
+  const files = /* @__PURE__ */ new Set();
+  const input = payload.tool_input ?? {};
+  for (const k of ["file_path", "path", "notebook_path"]) {
+    const v = input[k];
+    if (typeof v === "string") files.add(v);
+  }
+  const cmd = input["command"];
+  if (typeof cmd === "string") {
+    const matches = cmd.match(/[\w./-]+\.(?:ts|tsx|js|jsx|py|go|rs|java|kt|swift|rb|php|cs|cpp|c|h|md|json|yml|yaml)\b/g);
+    if (matches) for (const m of matches) files.add(m);
+  }
+  return [...files].slice(0, 8);
+}
+function buildSummary(payload) {
+  const tool = payload.tool_name ?? "?";
+  const input = payload.tool_input ?? {};
+  if (tool === "Bash") return `Bash: ${truncate(input["command"], 200)}`;
+  if (tool === "Edit") return `Edit ${truncate(input["file_path"], 200)}`;
+  if (tool === "Write") return `Write ${truncate(input["file_path"], 200)}`;
+  return `${tool}: ${truncate(input, 200)}`;
+}
+async function readStdin(maxBytes) {
+  if (process.stdin.isTTY) return "";
+  return await new Promise((resolve) => {
+    const chunks = [];
+    let total = 0;
+    let done = false;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    };
+    process.stdin.on("data", (c) => {
+      total += c.length;
+      if (total > maxBytes) {
+        process.stdin.destroy();
+        finish();
+        return;
+      }
+      chunks.push(c);
+    });
+    process.stdin.on("end", finish);
+    process.stdin.on("error", finish);
+    setTimeout(finish, 2e3);
+  });
+}
+function registerObserve(program2) {
+  program2.command("observe").description(
+    "Passive-capture endpoint for Claude Code PostToolUse hooks.\n\n  Reads a JSON payload on stdin and appends an observation record to\n  .ai/.cache/observations.jsonl. Always exits 0; never blocks the agent.\n  Wired up automatically by `haive install-hooks claude`."
+  ).option("-d, --dir <dir>", "project root").action(async (opts) => {
+    try {
+      const raw = await readStdin(MAX_STDIN_BYTES);
+      if (!raw.trim()) return;
+      let payload;
+      try {
+        payload = JSON.parse(raw);
+      } catch {
+        return;
       }
-      await writeFile4(file, body, "utf8");
-      await chmod(file, 493);
-      installed++;
-    }
-    ui.success(`Installed ${installed} hook(s) in .git/hooks/${skipped ? `, skipped ${skipped}` : ""}`);
-    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.");
+      const root = (() => {
+        try {
+          return findProjectRoot7(opts.dir ?? payload.cwd);
+        } catch {
+          return null;
+        }
+      })();
+      if (!root) return;
+      const paths = resolveHaivePaths5(root);
+      if (!existsSync9(paths.haiveDir)) return;
+      const observation = {
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        session_id: payload.session_id,
+        cwd: payload.cwd,
+        tool: payload.tool_name ?? "?",
+        summary: buildSummary(payload),
+        files: extractFiles(payload)
+      };
+      const cacheDir = path10.join(paths.haiveDir, ".cache");
+      await mkdir6(cacheDir, { recursive: true });
+      await appendFile(
+        path10.join(cacheDir, "observations.jsonl"),
+        JSON.stringify(observation) + "\n",
+        "utf8"
+      );
+    } catch {
+    }
   });
 }
 
 // src/commands/mcp.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { createRequire } from "module";
-import path9 from "path";
+import path11 from "path";
 import { fileURLToPath } from "url";
 import "commander";
-import { findProjectRoot as findProjectRoot7 } from "@hiveai/core";
+import { findProjectRoot as findProjectRoot8 } from "@hiveai/core";
 var require2 = createRequire(import.meta.url);
 function registerMcp(program2) {
   program2.command("mcp").description(
@@ -1982,7 +2588,7 @@ function registerMcp(program2) {
     VS Code:     code --add-mcp '{"name":"haive","command":"haive-mcp",...}'
 `
   ).option("-d, --dir <dir>", "project root (defaults to nearest .ai/ or .git/)").action((opts) => {
-    const root = findProjectRoot7(opts.dir);
+    const root = findProjectRoot8(opts.dir);
     const bin = locateMcpBin();
     if (!bin) {
       ui.error(
@@ -2000,36 +2606,36 @@ function registerMcp(program2) {
 function locateMcpBin() {
   try {
     const pkgPath = require2.resolve("@hiveai/mcp/package.json");
-    const pkgDir = path9.dirname(pkgPath);
-    const candidate = path9.join(pkgDir, "dist", "index.js");
-    if (existsSync8(candidate)) return candidate;
+    const pkgDir = path11.dirname(pkgPath);
+    const candidate = path11.join(pkgDir, "dist", "index.js");
+    if (existsSync10(candidate)) return candidate;
   } catch {
   }
-  const here = path9.dirname(fileURLToPath(import.meta.url));
-  const sibling = path9.resolve(here, "..", "..", "..", "mcp", "dist", "index.js");
-  if (existsSync8(sibling)) return sibling;
+  const here = path11.dirname(fileURLToPath(import.meta.url));
+  const sibling = path11.resolve(here, "..", "..", "..", "mcp", "dist", "index.js");
+  if (existsSync10(sibling)) return sibling;
   return null;
 }
 
 // src/commands/sync.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { readFile as readFile6, writeFile as writeFile5, mkdir as mkdir5 } from "fs/promises";
-import { existsSync as existsSync9 } from "fs";
-import path10 from "path";
+import { readFile as readFile7, writeFile as writeFile6, mkdir as mkdir7 } from "fs/promises";
+import { existsSync as existsSync11 } from "fs";
+import path12 from "path";
 import "commander";
 import {
   DEFAULT_AUTO_PROMOTE_RULE,
   buildFrontmatter as buildFrontmatter2,
-  findProjectRoot as findProjectRoot8,
+  findProjectRoot as findProjectRoot9,
   getUsage,
   isAutoPromoteEligible,
   isDecaying,
   loadCodeMap as loadCodeMap2,
   loadConfig,
   loadMemoriesFromDir as loadMemoriesFromDir2,
-  loadUsageIndex,
+  loadUsageIndex as loadUsageIndex2,
   pullCrossRepoSources,
-  resolveHaivePaths as resolveHaivePaths5,
+  resolveHaivePaths as resolveHaivePaths6,
   resolveManifestFiles,
   serializeMemory as serializeMemory2,
   trackDependencies,
@@ -2048,9 +2654,9 @@ function registerSync(program2) {
     "--inject-bridge",
     "inject top validated memories into CLAUDE.md (or --bridge-file) between <!-- haive:memories-start/end --> markers"
   ).option("--bridge-file <path>", "bridge file to inject into (default: CLAUDE.md)").option("--bridge-max-memories <n>", "max memories to inject into bridge file", "5").option("--embed", "rebuild embeddings index after sync (requires @haive/embeddings)").option("--no-cross-repo", "skip cross-repo memory pull even if crossRepoSources is configured").option("--no-deps", "skip dependency version tracking").option("--no-contracts", "skip contract file diff checking").action(async (opts) => {
-    const root = findProjectRoot8(opts.dir);
-    const paths = resolveHaivePaths5(root);
-    if (!existsSync9(paths.memoriesDir)) {
+    const root = findProjectRoot9(opts.dir);
+    const paths = resolveHaivePaths6(root);
+    if (!existsSync11(paths.memoriesDir)) {
       if (!opts.quiet) ui.warn(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -2070,7 +2676,7 @@ function registerSync(program2) {
       for (const { memory: memory2, filePath } of memories) {
         if (memory2.frontmatter.type === "session_recap") {
           if (memory2.frontmatter.status === "stale") {
-            await writeFile5(
+            await writeFile6(
               filePath,
               serializeMemory2({
                 frontmatter: {
@@ -2093,7 +2699,7 @@ function registerSync(program2) {
         const verifiedAt = (/* @__PURE__ */ new Date()).toISOString();
         if (result.stale) {
           if (memory2.frontmatter.status !== "stale") {
-            await writeFile5(
+            await writeFile6(
               filePath,
               serializeMemory2({
                 frontmatter: {
@@ -2109,7 +2715,7 @@ function registerSync(program2) {
             staleMarked++;
           }
         } else if (memory2.frontmatter.status === "stale") {
-          await writeFile5(
+          await writeFile6(
             filePath,
             serializeMemory2({
               frontmatter: {
@@ -2128,7 +2734,7 @@ function registerSync(program2) {
     }
     if (opts.promote !== false) {
       const memories = await loadMemoriesFromDir2(paths.memoriesDir);
-      const usage = await loadUsageIndex(paths);
+      const usage = await loadUsageIndex2(paths);
       const nowMs = Date.now();
       for (const { memory: memory2, filePath } of memories) {
         const fm = memory2.frontmatter;
@@ -2137,7 +2743,7 @@ function registerSync(program2) {
           minReads: autoPromoteMinReads,
           maxRejections: DEFAULT_AUTO_PROMOTE_RULE.maxRejections
         })) {
-          await writeFile5(
+          await writeFile6(
             filePath,
             serializeMemory2({ frontmatter: { ...fm, status: "validated" }, body: memory2.body }),
             "utf8"
@@ -2148,7 +2754,7 @@ 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 writeFile5(
+            await writeFile6(
               filePath,
               serializeMemory2({
                 frontmatter: {
@@ -2182,7 +2788,7 @@ function registerSync(program2) {
       );
     }
     if (opts.injectBridge) {
-      const bridgeFile = opts.bridgeFile ? path10.resolve(opts.bridgeFile) : path10.join(root, "CLAUDE.md");
+      const bridgeFile = opts.bridgeFile ? path12.resolve(opts.bridgeFile) : path12.join(root, "CLAUDE.md");
       const maxInject = Math.max(1, Number(opts.bridgeMaxMemories ?? 5));
       await injectBridge(bridgeFile, paths.memoriesDir, maxInject, root, opts.quiet);
     }
@@ -2202,7 +2808,7 @@ function registerSync(program2) {
     }
     if (!opts.quiet) {
       const allForDecay = await loadMemoriesFromDir2(paths.memoriesDir);
-      const usageForDecay = await loadUsageIndex(paths);
+      const usageForDecay = await loadUsageIndex2(paths);
       const decaying = allForDecay.filter(({ memory: memory2 }) => {
         const fm = memory2.frontmatter;
         if (fm.status === "rejected" || fm.status === "deprecated" || fm.status === "stale") return false;
@@ -2288,10 +2894,10 @@ Attends une **confirmation explicite** avant d'agir.
                   paths: [result.file],
                   topic: `dep-bump-${slugParts}`
                 });
-                const teamDir = path10.join(paths.memoriesDir, "team");
-                await mkdir5(teamDir, { recursive: true });
-                await writeFile5(
-                  path10.join(teamDir, `${fm.id}.md`),
+                const teamDir = path12.join(paths.memoriesDir, "team");
+                await mkdir7(teamDir, { recursive: true });
+                await writeFile6(
+                  path12.join(teamDir, `${fm.id}.md`),
                   serializeMemory2({ frontmatter: { ...fm, requires_human_approval: true }, body }),
                   "utf8"
                 );
@@ -2355,10 +2961,10 @@ Attends une **confirmation explicite** avant d'agir.
               paths: [diff.file],
               topic: `contract-breaking-${diff.contract}`
             });
-            const teamDir = path10.join(paths.memoriesDir, "team");
-            await mkdir5(teamDir, { recursive: true });
-            await writeFile5(
-              path10.join(teamDir, `${fm.id}.md`),
+            const teamDir = path12.join(paths.memoriesDir, "team");
+            await mkdir7(teamDir, { recursive: true });
+            await writeFile6(
+              path12.join(teamDir, `${fm.id}.md`),
               serializeMemory2({ frontmatter: { ...fm, requires_human_approval: true }, body }),
               "utf8"
             );
@@ -2419,7 +3025,7 @@ Attends une **confirmation explicite** avant d'agir.
   });
 }
 async function injectBridge(bridgeFile, memoriesDir, maxMemories, root, quiet) {
-  if (!existsSync9(memoriesDir)) return;
+  if (!existsSync11(memoriesDir)) return;
   const all = await loadMemoriesFromDir2(memoriesDir);
   const top = all.filter(({ memory: memory2 }) => {
     const s = memory2.frontmatter.status;
@@ -2444,17 +3050,17 @@ ${m.memory.body.trim()}`;
 ` + block + `
 
 ${BRIDGE_END}`;
-  const fileExists = existsSync9(bridgeFile);
-  let existing = fileExists ? await readFile6(bridgeFile, "utf8") : "";
+  const fileExists = existsSync11(bridgeFile);
+  let existing = fileExists ? await readFile7(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(`${path10.relative(root, bridgeFile)}: found ${BRIDGE_START} without ${BRIDGE_END}. Fix the file manually before running --inject-bridge.`);
+    ui.warn(`${path12.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(`${path10.relative(root, bridgeFile)}: found ${BRIDGE_END} without ${BRIDGE_START}. Fix the file manually before running --inject-bridge.`);
+    ui.warn(`${path12.relative(root, bridgeFile)}: found ${BRIDGE_END} without ${BRIDGE_START}. Fix the file manually before running --inject-bridge.`);
     return;
   }
   let updated;
@@ -2462,14 +3068,14 @@ ${BRIDGE_END}`;
     updated = existing.slice(0, startIdx) + injected + existing.slice(endIdx + BRIDGE_END.length);
   } else {
     if (!fileExists && !quiet) {
-      ui.info(`Creating ${path10.relative(root, bridgeFile)} with haive memory block.`);
+      ui.info(`Creating ${path12.relative(root, bridgeFile)} with haive memory block.`);
     }
     updated = existing + (existing.endsWith("\n") ? "" : "\n") + "\n" + injected + "\n";
   }
-  await writeFile5(bridgeFile, updated, "utf8");
+  await writeFile6(bridgeFile, updated, "utf8");
   if (!quiet) {
     console.log(
-      ui.dim(`bridge: injected ${top.length} memor${top.length === 1 ? "y" : "ies"} into ${path10.relative(root, bridgeFile)}`)
+      ui.dim(`bridge: injected ${top.length} memor${top.length === 1 ? "y" : "ies"} into ${path12.relative(root, bridgeFile)}`)
     );
   }
 }
@@ -2494,17 +3100,17 @@ function collectSinceChanges(root, ref) {
 
 // src/commands/memory-add.ts
 import { createHash } from "crypto";
-import { mkdir as mkdir6, readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
-import { existsSync as existsSync10 } from "fs";
-import path11 from "path";
+import { mkdir as mkdir8, readFile as readFile8, writeFile as writeFile7 } from "fs/promises";
+import { existsSync as existsSync12 } from "fs";
+import path13 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter3,
-  findProjectRoot as findProjectRoot9,
+  findProjectRoot as findProjectRoot10,
   inferModulesFromPaths,
   loadMemoriesFromDir as loadMemoriesFromDir3,
   memoryFilePath as memoryFilePath2,
-  resolveHaivePaths as resolveHaivePaths6,
+  resolveHaivePaths as resolveHaivePaths7,
   serializeMemory as serializeMemory3
 } from "@hiveai/core";
 function registerMemoryAdd(memory2) {
@@ -2532,9 +3138,9 @@ function registerMemoryAdd(memory2) {
       --scope team --body "Never modify existing migrations. Create V{n+1}__desc.sql."
 `
   ).requiredOption("--type <type>", "convention | decision | gotcha | architecture | glossary | attempt").requiredOption("--slug <slug>", "short kebab-case identifier used in the file name").option("--title <text>", "memory title \u2014 becomes the first heading of the body").option("--scope <scope>", "personal | team | module (default: personal, or team in autopilot)", "personal").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags for easier retrieval").option("--domain <domain>", "domain (e.g. transactions)").option("--author <author>", "author email or handle").option("--paths <csv>", "anchor to source files \u2014 used for staleness detection by haive sync").option("--symbols <csv>", "anchor to specific symbols (class/function names)").option("--commit <sha>", "anchor to a specific commit SHA").option("--body <text>", "memory body content (Markdown) \u2014 overrides --title default body").option("--body-file <path>", "read memory body from a Markdown file \u2014 for long content").option("--no-auto-tag", "disable automatic tag suggestions inferred from anchor paths").option("--topic <key>", "stable key for upsert: if a memory with this topic+scope already exists, update it in-place (revision_count++)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot9(opts.dir);
-    const paths = resolveHaivePaths6(root);
-    if (!existsSync10(paths.haiveDir)) {
+    const root = findProjectRoot10(opts.dir);
+    const paths = resolveHaivePaths7(root);
+    if (!existsSync12(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -2545,7 +3151,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) => !existsSync10(path11.resolve(root, p)));
+      const missing = anchorPaths.filter((p) => !existsSync12(path13.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}`);
@@ -2557,12 +3163,12 @@ function registerMemoryAdd(memory2) {
     const title = opts.title ?? opts.slug;
     let body;
     if (opts.bodyFile !== void 0) {
-      if (!existsSync10(opts.bodyFile)) {
+      if (!existsSync12(opts.bodyFile)) {
         ui.error(`--body-file not found: ${opts.bodyFile}`);
         process.exitCode = 1;
         return;
       }
-      const fileContent = await readFile7(opts.bodyFile, "utf8");
+      const fileContent = await readFile8(opts.bodyFile, "utf8");
       body = opts.title ? `# ${opts.title}
 
 ${fileContent.trim()}
@@ -2578,7 +3184,7 @@ TODO \u2014 write the memory body.
 `;
     }
     const scope = opts.scope ?? "personal";
-    if (existsSync10(paths.memoriesDir)) {
+    if (existsSync12(paths.memoriesDir)) {
       const incomingHash = createHash("sha256").update(body.trim()).digest("hex").slice(0, 12);
       const allForHash = await loadMemoriesFromDir3(paths.memoriesDir);
       const hashDup = allForHash.find(
@@ -2591,7 +3197,7 @@ TODO \u2014 write the memory body.
         return;
       }
     }
-    if (opts.topic && existsSync10(paths.memoriesDir)) {
+    if (opts.topic && existsSync12(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)
@@ -2609,8 +3215,8 @@ TODO \u2014 write the memory body.
             symbols: parseCsv2(opts.symbols).length ? parseCsv2(opts.symbols) : fm.anchor.symbols
           }
         };
-        await writeFile6(topicMatch.filePath, serializeMemory3({ frontmatter: newFrontmatter, body }), "utf8");
-        ui.success(`Updated (topic upsert) ${path11.relative(root, topicMatch.filePath)}`);
+        await writeFile7(topicMatch.filePath, serializeMemory3({ frontmatter: newFrontmatter, body }), "utf8");
+        ui.success(`Updated (topic upsert) ${path13.relative(root, topicMatch.filePath)}`);
         ui.info(`id=${fm.id}  revision=${revisionCount}`);
         return;
       }
@@ -2629,13 +3235,13 @@ TODO \u2014 write the memory body.
       topic: opts.topic
     });
     const file = memoryFilePath2(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir6(path11.dirname(file), { recursive: true });
-    if (existsSync10(file)) {
+    await mkdir8(path13.dirname(file), { recursive: true });
+    if (existsSync12(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
       return;
     }
-    if (existsSync10(paths.memoriesDir)) {
+    if (existsSync12(paths.memoriesDir)) {
       const existing = await loadMemoriesFromDir3(paths.memoriesDir);
       const slugTokens = opts.slug.toLowerCase().split(/[-_\s]+/).filter(Boolean);
       const similar = existing.filter(({ memory: memory3 }) => {
@@ -2647,8 +3253,8 @@ TODO \u2014 write the memory body.
         ui.warn("Consider updating one of these with `haive memory update` instead.");
       }
     }
-    await writeFile6(file, serializeMemory3({ frontmatter, body }), "utf8");
-    ui.success(`Created ${path11.relative(root, file)}`);
+    await writeFile7(file, serializeMemory3({ frontmatter, body }), "utf8");
+    ui.success(`Created ${path13.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)`);
@@ -2678,10 +3284,10 @@ function parseCsv2(value) {
 }
 
 // src/commands/memory-list.ts
-import { existsSync as existsSync11 } from "fs";
-import path12 from "path";
+import { existsSync as existsSync13 } from "fs";
+import path14 from "path";
 import "commander";
-import { findProjectRoot as findProjectRoot10, resolveHaivePaths as resolveHaivePaths7 } from "@hiveai/core";
+import { findProjectRoot as findProjectRoot11, resolveHaivePaths as resolveHaivePaths8 } from "@hiveai/core";
 
 // src/utils/fs.ts
 import {
@@ -2693,9 +3299,9 @@ import {
 // src/commands/memory-list.ts
 function registerMemoryList(memory2) {
   memory2.command("list").description("List memories with optional filters").option("--scope <scope>", "personal | team | module").option("--type <type>", "filter by type").option("--tag <tag>", "filter by tag").option("--module <name>", "filter by module name").option("--status <csv>", "filter by status (draft,proposed,validated,stale,rejected,deprecated)").option("--show-rejected", "include rejected memories (hidden by default)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot10(opts.dir);
-    const paths = resolveHaivePaths7(root);
-    if (!existsSync11(paths.memoriesDir)) {
+    const root = findProjectRoot11(opts.dir);
+    const paths = resolveHaivePaths8(root);
+    if (!existsSync13(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -2727,7 +3333,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(path12.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path14.relative(root, filePath))}`);
     }
     console.log(ui.dim(`
 ${filtered.length} memor${filtered.length === 1 ? "y" : "ies"}`));
@@ -2762,21 +3368,21 @@ function matchesFilters(loaded, opts) {
 }
 
 // src/commands/memory-promote.ts
-import { mkdir as mkdir7, unlink, writeFile as writeFile7 } from "fs/promises";
-import { existsSync as existsSync12 } from "fs";
-import path13 from "path";
+import { mkdir as mkdir9, unlink, writeFile as writeFile8 } from "fs/promises";
+import { existsSync as existsSync14 } from "fs";
+import path15 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot11,
+  findProjectRoot as findProjectRoot12,
   memoryFilePath as memoryFilePath3,
-  resolveHaivePaths as resolveHaivePaths8,
+  resolveHaivePaths as resolveHaivePaths9,
   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 (!existsSync12(paths.memoriesDir)) {
+    const root = findProjectRoot12(opts.dir);
+    const paths = resolveHaivePaths9(root);
+    if (!existsSync14(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -2811,30 +3417,30 @@ function registerMemoryPromote(memory2) {
       body: found.memory.body
     };
     const newPath = memoryFilePath3(paths, "team", updated.frontmatter.id);
-    await mkdir7(path13.dirname(newPath), { recursive: true });
-    await writeFile7(newPath, serializeMemory4(updated), "utf8");
+    await mkdir9(path15.dirname(newPath), { recursive: true });
+    await writeFile8(newPath, serializeMemory4(updated), "utf8");
     await unlink(found.filePath);
     ui.success(`Promoted ${id} to team scope (status=proposed)`);
-    ui.info(`Now at ${path13.relative(root, newPath)}`);
+    ui.info(`Now at ${path15.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 existsSync13 } from "fs";
-import { writeFile as writeFile8 } from "fs/promises";
-import path14 from "path";
+import { existsSync as existsSync15 } from "fs";
+import { writeFile as writeFile9 } from "fs/promises";
+import path16 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot12,
-  resolveHaivePaths as resolveHaivePaths9,
+  findProjectRoot as findProjectRoot13,
+  resolveHaivePaths as resolveHaivePaths10,
   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 (!existsSync13(paths.memoriesDir)) {
+    const root = findProjectRoot13(opts.dir);
+    const paths = resolveHaivePaths10(root);
+    if (!existsSync15(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -2856,7 +3462,7 @@ function registerMemoryApprove(memory2) {
           frontmatter: { ...found2.memory.frontmatter, status: "validated" },
           body: found2.memory.body
         };
-        await writeFile8(found2.filePath, serializeMemory5(next2), "utf8");
+        await writeFile9(found2.filePath, serializeMemory5(next2), "utf8");
         count++;
       }
       ui.success(`Approved ${count} memor${count === 1 ? "y" : "ies"} (status=validated)`);
@@ -2885,27 +3491,27 @@ function registerMemoryApprove(memory2) {
       frontmatter: { ...found.memory.frontmatter, status: "validated" },
       body: found.memory.body
     };
-    await writeFile8(found.filePath, serializeMemory5(next), "utf8");
+    await writeFile9(found.filePath, serializeMemory5(next), "utf8");
     ui.success(`Approved ${id} (status=validated)`);
-    ui.info(path14.relative(root, found.filePath));
+    ui.info(path16.relative(root, found.filePath));
   });
 }
 
 // src/commands/memory-update.ts
-import { writeFile as writeFile9 } from "fs/promises";
-import { existsSync as existsSync14 } from "fs";
-import path15 from "path";
+import { writeFile as writeFile10 } from "fs/promises";
+import { existsSync as existsSync16 } from "fs";
+import path17 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot13,
-  resolveHaivePaths as resolveHaivePaths10,
+  findProjectRoot as findProjectRoot14,
+  resolveHaivePaths as resolveHaivePaths11,
   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 (!existsSync14(paths.memoriesDir)) {
+    const root = findProjectRoot14(opts.dir);
+    const paths = resolveHaivePaths11(root);
+    if (!existsSync16(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -2952,12 +3558,12 @@ function registerMemoryUpdate(memory2) {
       ui.warn("Nothing to update \u2014 provide at least one option.");
       return;
     }
-    await writeFile9(
+    await writeFile10(
       loaded.filePath,
       serializeMemory6({ frontmatter: newFrontmatter, body: newBody }),
       "utf8"
     );
-    ui.success(`Updated ${path15.relative(root, loaded.filePath)}`);
+    ui.success(`Updated ${path17.relative(root, loaded.filePath)}`);
     ui.info(`fields: ${updated.join(", ")}`);
   });
 }
@@ -2976,17 +3582,17 @@ function parseCsv3(value) {
 }
 
 // src/commands/memory-auto-promote.ts
-import { writeFile as writeFile10 } from "fs/promises";
-import { existsSync as existsSync15 } from "fs";
-import path16 from "path";
+import { writeFile as writeFile11 } from "fs/promises";
+import { existsSync as existsSync17 } from "fs";
+import path18 from "path";
 import "commander";
 import {
   DEFAULT_AUTO_PROMOTE_RULE as DEFAULT_AUTO_PROMOTE_RULE2,
-  findProjectRoot as findProjectRoot14,
+  findProjectRoot as findProjectRoot15,
   getUsage as getUsage2,
   isAutoPromoteEligible as isAutoPromoteEligible2,
-  loadUsageIndex as loadUsageIndex2,
-  resolveHaivePaths as resolveHaivePaths11,
+  loadUsageIndex as loadUsageIndex3,
+  resolveHaivePaths as resolveHaivePaths12,
   serializeMemory as serializeMemory7
 } from "@hiveai/core";
 function registerMemoryAutoPromote(memory2) {
@@ -2995,9 +3601,9 @@ function registerMemoryAutoPromote(memory2) {
     "memories with more rejections than this are skipped",
     String(DEFAULT_AUTO_PROMOTE_RULE2.maxRejections)
   ).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 (!existsSync15(paths.memoriesDir)) {
+    const root = findProjectRoot15(opts.dir);
+    const paths = resolveHaivePaths12(root);
+    if (!existsSync17(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -3007,7 +3613,7 @@ function registerMemoryAutoPromote(memory2) {
       maxRejections: Number(opts.maxRejections ?? DEFAULT_AUTO_PROMOTE_RULE2.maxRejections)
     };
     const memories = await loadMemoriesFromDir4(paths.memoriesDir);
-    const usage = await loadUsageIndex2(paths);
+    const usage = await loadUsageIndex3(paths);
     const eligible = memories.filter(
       ({ memory: memory3 }) => isAutoPromoteEligible2(memory3.frontmatter, getUsage2(usage, memory3.frontmatter.id), rule)
     );
@@ -3023,13 +3629,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(path16.relative(root, filePath))}`);
+      console.log(`             ${ui.dim(path18.relative(root, filePath))}`);
       if (opts.apply) {
         const next = {
           frontmatter: { ...mem.frontmatter, status: "validated" },
           body: mem.body
         };
-        await writeFile10(filePath, serializeMemory7(next), "utf8");
+        await writeFile11(filePath, serializeMemory7(next), "utf8");
         written++;
       }
     }
@@ -3040,20 +3646,20 @@ function registerMemoryAutoPromote(memory2) {
 
 // src/commands/memory-edit.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync16 } from "fs";
-import { readFile as readFile8 } from "fs/promises";
-import path17 from "path";
+import { existsSync as existsSync18 } from "fs";
+import { readFile as readFile9 } from "fs/promises";
+import path19 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot15,
+  findProjectRoot as findProjectRoot16,
   parseMemory,
-  resolveHaivePaths as resolveHaivePaths12
+  resolveHaivePaths as resolveHaivePaths13
 } from "@hiveai/core";
 function registerMemoryEdit(memory2) {
   memory2.command("edit <id>").description("Open a memory in $EDITOR and re-validate when you save").option("-e, --editor <cmd>", "editor command (defaults to $EDITOR or 'vi')").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
-    const root = findProjectRoot15(opts.dir);
-    const paths = resolveHaivePaths12(root);
-    if (!existsSync16(paths.memoriesDir)) {
+    const root = findProjectRoot16(opts.dir);
+    const paths = resolveHaivePaths13(root);
+    if (!existsSync18(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -3066,13 +3672,13 @@ function registerMemoryEdit(memory2) {
       return;
     }
     const editor = opts.editor ?? process.env.EDITOR ?? process.env.VISUAL ?? "vi";
-    ui.info(`Opening ${path17.relative(root, found.filePath)} with ${editor}\u2026`);
+    ui.info(`Opening ${path19.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 readFile8(found.filePath, "utf8");
+      const fresh = await readFile9(found.filePath, "utf8");
       parseMemory(fresh);
       ui.success("Memory still parses cleanly.");
     } catch (err) {
@@ -3093,29 +3699,29 @@ function runEditor(editor, file) {
 }
 
 // src/commands/memory-for-files.ts
-import { existsSync as existsSync17 } from "fs";
-import path18 from "path";
+import { existsSync as existsSync19 } from "fs";
+import path20 from "path";
 import "commander";
 import {
   deriveConfidence,
-  findProjectRoot as findProjectRoot16,
+  findProjectRoot as findProjectRoot17,
   getUsage as getUsage3,
   inferModulesFromPaths as inferModulesFromPaths2,
-  loadUsageIndex as loadUsageIndex3,
+  loadUsageIndex as loadUsageIndex4,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
-  resolveHaivePaths as resolveHaivePaths13
+  resolveHaivePaths as resolveHaivePaths14
 } from "@hiveai/core";
 function registerMemoryForFiles(memory2) {
   memory2.command("for-files <files...>").description("Show memories relevant to the given files (anchor overlap, module, domain)").option("-d, --dir <dir>", "project root").action(async (files, opts) => {
-    const root = findProjectRoot16(opts.dir);
-    const paths = resolveHaivePaths13(root);
-    if (!existsSync17(paths.memoriesDir)) {
+    const root = findProjectRoot17(opts.dir);
+    const paths = resolveHaivePaths14(root);
+    if (!existsSync19(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
     const all = await loadMemoriesFromDir4(paths.memoriesDir);
-    const usage = await loadUsageIndex3(paths);
+    const usage = await loadUsageIndex4(paths);
     const inferred = inferModulesFromPaths2(files);
     const byAnchor = [];
     const byModule = [];
@@ -3216,32 +3822,32 @@ 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(path18.relative(root, filePath))}`);
+    console.log(`  ${ui.dim(path20.relative(root, filePath))}`);
   }
 }
 
 // src/commands/memory-hot.ts
-import { existsSync as existsSync18 } from "fs";
-import path19 from "path";
+import { existsSync as existsSync20 } from "fs";
+import path21 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot17,
+  findProjectRoot as findProjectRoot18,
   getUsage as getUsage4,
-  loadUsageIndex as loadUsageIndex4,
-  resolveHaivePaths as resolveHaivePaths14
+  loadUsageIndex as loadUsageIndex5,
+  resolveHaivePaths as resolveHaivePaths15
 } from "@hiveai/core";
 function registerMemoryHot(memory2) {
   memory2.command("hot").description("List memories actively used but not yet validated (good promotion candidates)").option("--threshold <n>", "minimum read_count to qualify", "3").option("--status <status>", "limit to one status (default: draft + proposed)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot17(opts.dir);
-    const paths = resolveHaivePaths14(root);
-    if (!existsSync18(paths.memoriesDir)) {
+    const root = findProjectRoot18(opts.dir);
+    const paths = resolveHaivePaths15(root);
+    if (!existsSync20(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
     const threshold = Math.max(1, Number(opts.threshold ?? 3));
     const all = await loadMemoriesFromDir4(paths.memoriesDir);
-    const usage = await loadUsageIndex4(paths);
+    const usage = await loadUsageIndex5(paths);
     const candidates = all.filter(({ memory: mem }) => {
       const fm = mem.frontmatter;
       if (opts.status && fm.status !== opts.status) return false;
@@ -3262,7 +3868,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(path19.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path21.relative(root, filePath))}`);
     }
     ui.info(
       `${candidates.length} hot \u2014 promote drafts with \`haive memory promote <id>\`, then \`haive memory auto-promote --apply\`.`
@@ -3271,15 +3877,15 @@ function registerMemoryHot(memory2) {
 }
 
 // src/commands/memory-tried.ts
-import { mkdir as mkdir8, writeFile as writeFile11 } from "fs/promises";
-import { existsSync as existsSync19 } from "fs";
-import path20 from "path";
+import { mkdir as mkdir10, writeFile as writeFile12 } from "fs/promises";
+import { existsSync as existsSync21 } from "fs";
+import path22 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter4,
-  findProjectRoot as findProjectRoot18,
+  findProjectRoot as findProjectRoot19,
   memoryFilePath as memoryFilePath4,
-  resolveHaivePaths as resolveHaivePaths15,
+  resolveHaivePaths as resolveHaivePaths16,
   serializeMemory as serializeMemory8
 } from "@hiveai/core";
 function registerMemoryTried(memory2) {
@@ -3299,9 +3905,9 @@ function registerMemoryTried(memory2) {
       --paths packages/cli/src/index.ts
 `
   ).requiredOption("--what <text>", "what approach was tried (short, descriptive title)").requiredOption("--why-failed <text>", "why it failed or should NOT be used (include the exact error if possible)").option("--instead <text>", "the correct approach to use instead").option("--scope <scope>", "personal | team | module (default: personal)", "personal").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags").option("--paths <csv>", "anchor paths, comma-separated").option("--author <author>", "author email or handle").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot18(opts.dir);
-    const paths = resolveHaivePaths15(root);
-    if (!existsSync19(paths.haiveDir)) {
+    const root = findProjectRoot19(opts.dir);
+    const paths = resolveHaivePaths16(root);
+    if (!existsSync21(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -3324,14 +3930,14 @@ function registerMemoryTried(memory2) {
     }
     const body = lines.join("\n") + "\n";
     const file = memoryFilePath4(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir8(path20.dirname(file), { recursive: true });
-    if (existsSync19(file)) {
+    await mkdir10(path22.dirname(file), { recursive: true });
+    if (existsSync21(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
       return;
     }
-    await writeFile11(file, serializeMemory8({ frontmatter, body }), "utf8");
-    ui.success(`Recorded: ${path20.relative(root, file)}`);
+    await writeFile12(file, serializeMemory8({ frontmatter, body }), "utf8");
+    ui.success(`Recorded: ${path22.relative(root, file)}`);
     ui.info(`id=${frontmatter.id}  type=attempt  status=validated (auto-approved)`);
   });
 }
@@ -3341,26 +3947,26 @@ function parseCsv4(value) {
 }
 
 // src/commands/memory-pending.ts
-import { existsSync as existsSync20 } from "fs";
-import path21 from "path";
+import { existsSync as existsSync22 } from "fs";
+import path23 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot19,
+  findProjectRoot as findProjectRoot20,
   getUsage as getUsage5,
-  loadUsageIndex as loadUsageIndex5,
-  resolveHaivePaths as resolveHaivePaths16
+  loadUsageIndex as loadUsageIndex6,
+  resolveHaivePaths as resolveHaivePaths17
 } from "@hiveai/core";
 function registerMemoryPending(memory2) {
   memory2.command("pending").description("List 'proposed' memories awaiting review (sorted by reads desc)").option("--scope <scope>", "filter by scope (personal | team | module)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot19(opts.dir);
-    const paths = resolveHaivePaths16(root);
-    if (!existsSync20(paths.memoriesDir)) {
+    const root = findProjectRoot20(opts.dir);
+    const paths = resolveHaivePaths17(root);
+    if (!existsSync22(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
     const all = await loadMemoriesFromDir4(paths.memoriesDir);
-    const usage = await loadUsageIndex5(paths);
+    const usage = await loadUsageIndex6(paths);
     const proposed = all.filter(({ memory: mem }) => {
       if (mem.frontmatter.status !== "proposed") return false;
       if (opts.scope && mem.frontmatter.scope !== opts.scope) return false;
@@ -3382,31 +3988,31 @@ 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(path21.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path23.relative(root, filePath))}`);
     }
     ui.info(`${proposed.length} pending`);
   });
 }
 
 // src/commands/memory-query.ts
-import { existsSync as existsSync21 } from "fs";
-import path22 from "path";
+import { existsSync as existsSync23 } from "fs";
+import path24 from "path";
 import "commander";
 import {
   extractSnippet,
-  findProjectRoot as findProjectRoot20,
+  findProjectRoot as findProjectRoot21,
   literalMatchesAllTokens as literalMatchesAllTokens2,
   literalMatchesAnyToken as literalMatchesAnyToken2,
   pickSnippetNeedle,
-  resolveHaivePaths as resolveHaivePaths17,
+  resolveHaivePaths as resolveHaivePaths18,
   tokenizeQuery as tokenizeQuery2,
   trackReads as trackReads2
 } from "@hiveai/core";
 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 (!existsSync21(paths.memoriesDir)) {
+  memory2.command("query <text>").alias("search").description("Search memories by id, tag, or substring (AND, OR fallback). Alias: search").option("-d, --dir <dir>", "project root").option("--limit <n>", "max results", "20").option("--scope <scope>", "personal | team | module").option("--status <csv>", "filter by status (draft,proposed,validated,stale,rejected)").option("--show-rejected", "include rejected memories (hidden by default)").action(async (text, opts) => {
+    const root = findProjectRoot21(opts.dir);
+    const paths = resolveHaivePaths18(root);
+    if (!existsSync23(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -3447,7 +4053,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(path22.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path24.relative(root, filePath))}`);
       const snippet = extractSnippet(mem.body, snippetNeedle);
       if (snippet) console.log(`  ${snippet}`);
     }
@@ -3464,22 +4070,22 @@ ${top.length} of ${matches.length} match${matches.length === 1 ? "" : "es"}`)
 }
 
 // src/commands/memory-reject.ts
-import { writeFile as writeFile12 } from "fs/promises";
-import { existsSync as existsSync22 } from "fs";
+import { writeFile as writeFile13 } from "fs/promises";
+import { existsSync as existsSync24 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot21,
-  loadUsageIndex as loadUsageIndex6,
+  findProjectRoot as findProjectRoot22,
+  loadUsageIndex as loadUsageIndex7,
   recordRejection,
-  resolveHaivePaths as resolveHaivePaths18,
+  resolveHaivePaths as resolveHaivePaths19,
   saveUsageIndex,
   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 (!existsSync22(paths.memoriesDir)) {
+    const root = findProjectRoot22(opts.dir);
+    const paths = resolveHaivePaths19(root);
+    if (!existsSync24(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -3491,7 +4097,7 @@ function registerMemoryReject(memory2) {
       process.exitCode = 1;
       return;
     }
-    await writeFile12(
+    await writeFile13(
       loaded.filePath,
       serializeMemory9({
         frontmatter: {
@@ -3503,7 +4109,7 @@ function registerMemoryReject(memory2) {
       }),
       "utf8"
     );
-    const idx = await loadUsageIndex6(paths);
+    const idx = await loadUsageIndex7(paths);
     recordRejection(idx, id, opts.reason ?? null);
     await saveUsageIndex(paths, idx);
     const u = idx.by_id[id];
@@ -3515,22 +4121,22 @@ function registerMemoryReject(memory2) {
 }
 
 // src/commands/memory-rm.ts
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import { unlink as unlink2 } from "fs/promises";
-import path23 from "path";
+import path25 from "path";
 import { createInterface } from "readline/promises";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot22,
-  loadUsageIndex as loadUsageIndex7,
-  resolveHaivePaths as resolveHaivePaths19,
+  findProjectRoot as findProjectRoot23,
+  loadUsageIndex as loadUsageIndex8,
+  resolveHaivePaths as resolveHaivePaths20,
   saveUsageIndex as saveUsageIndex2
 } from "@hiveai/core";
 function registerMemoryRm(memory2) {
   memory2.command("rm <id>").description("Delete a memory file (and its usage entry by default)").option("-y, --yes", "skip the confirmation prompt").option("--keep-usage", "do not remove the usage.json entry").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
-    const root = findProjectRoot22(opts.dir);
-    const paths = resolveHaivePaths19(root);
-    if (!existsSync23(paths.memoriesDir)) {
+    const root = findProjectRoot23(opts.dir);
+    const paths = resolveHaivePaths20(root);
+    if (!existsSync25(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -3542,7 +4148,7 @@ function registerMemoryRm(memory2) {
       process.exitCode = 1;
       return;
     }
-    const rel = path23.relative(root, found.filePath);
+    const rel = path25.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();
@@ -3555,7 +4161,7 @@ function registerMemoryRm(memory2) {
     await unlink2(found.filePath);
     ui.success(`Deleted ${rel}`);
     if (!opts.keepUsage) {
-      const idx = await loadUsageIndex7(paths);
+      const idx = await loadUsageIndex8(paths);
       if (idx.by_id[id]) {
         delete idx.by_id[id];
         await saveUsageIndex2(paths, idx);
@@ -3566,22 +4172,22 @@ function registerMemoryRm(memory2) {
 }
 
 // src/commands/memory-show.ts
-import { existsSync as existsSync24 } from "fs";
-import { readFile as readFile9 } from "fs/promises";
-import path24 from "path";
+import { existsSync as existsSync26 } from "fs";
+import { readFile as readFile10 } from "fs/promises";
+import path26 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence2,
-  findProjectRoot as findProjectRoot23,
+  findProjectRoot as findProjectRoot24,
   getUsage as getUsage6,
-  loadUsageIndex as loadUsageIndex8,
-  resolveHaivePaths as resolveHaivePaths20
+  loadUsageIndex as loadUsageIndex9,
+  resolveHaivePaths as resolveHaivePaths21
 } from "@hiveai/core";
 function registerMemoryShow(memory2) {
   memory2.command("show <id>").description("Print a memory's frontmatter, body, and confidence/usage").option("--raw", "print the raw file contents instead of a summary").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
-    const root = findProjectRoot23(opts.dir);
-    const paths = resolveHaivePaths20(root);
-    if (!existsSync24(paths.memoriesDir)) {
+    const root = findProjectRoot24(opts.dir);
+    const paths = resolveHaivePaths21(root);
+    if (!existsSync26(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -3594,11 +4200,11 @@ function registerMemoryShow(memory2) {
       return;
     }
     if (opts.raw) {
-      console.log(await readFile9(found.filePath, "utf8"));
+      console.log(await readFile10(found.filePath, "utf8"));
       return;
     }
     const fm = found.memory.frontmatter;
-    const usage = await loadUsageIndex8(paths);
+    const usage = await loadUsageIndex9(paths);
     const u = getUsage6(usage, fm.id);
     const conf = deriveConfidence2(fm, u);
     console.log(ui.bold(fm.id));
@@ -3610,7 +4216,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:")}       ${path24.relative(root, found.filePath)}`);
+    console.log(`${ui.dim("file:")}       ${path26.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}`);
@@ -3625,27 +4231,27 @@ function registerMemoryShow(memory2) {
 }
 
 // src/commands/memory-stats.ts
-import { existsSync as existsSync25 } from "fs";
-import path25 from "path";
+import { existsSync as existsSync27 } from "fs";
+import path27 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence3,
-  findProjectRoot as findProjectRoot24,
+  findProjectRoot as findProjectRoot25,
   getUsage as getUsage7,
-  loadUsageIndex as loadUsageIndex9,
-  resolveHaivePaths as resolveHaivePaths21
+  loadUsageIndex as loadUsageIndex10,
+  resolveHaivePaths as resolveHaivePaths22
 } from "@hiveai/core";
 function registerMemoryStats(memory2) {
   memory2.command("stats").description("Show usage stats and confidence levels per memory").option("--id <id>", "show stats for a single memory id").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot24(opts.dir);
-    const paths = resolveHaivePaths21(root);
-    if (!existsSync25(paths.memoriesDir)) {
+    const root = findProjectRoot25(opts.dir);
+    const paths = resolveHaivePaths22(root);
+    if (!existsSync27(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
     const all = await loadMemoriesFromDir4(paths.memoriesDir);
-    const usage = await loadUsageIndex9(paths);
+    const usage = await loadUsageIndex10(paths);
     const target = opts.id ? all.filter((m) => m.memory.frontmatter.id === opts.id) : all;
     if (target.length === 0) {
       ui.info(opts.id ? `No memory with id "${opts.id}".` : "No memories.");
@@ -3664,19 +4270,19 @@ 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(path25.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path27.relative(root, filePath))}`);
     }
   });
 }
 
 // src/commands/memory-verify.ts
-import { writeFile as writeFile13 } from "fs/promises";
-import { existsSync as existsSync26 } from "fs";
-import path26 from "path";
+import { writeFile as writeFile14 } from "fs/promises";
+import { existsSync as existsSync28 } from "fs";
+import path28 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot25,
-  resolveHaivePaths as resolveHaivePaths22,
+  findProjectRoot as findProjectRoot26,
+  resolveHaivePaths as resolveHaivePaths23,
   serializeMemory as serializeMemory10,
   verifyAnchor as verifyAnchor2
 } from "@hiveai/core";
@@ -3684,9 +4290,9 @@ function registerMemoryVerify(memory2) {
   memory2.command("verify").description(
     "Check that memory anchor paths still exist in the current codebase.\n\n  A memory is 'stale' when its anchored file or symbol was moved, deleted, or renamed.\n  Stale memories are shown with a warning in get_briefing and should be updated or deleted.\n\n  haive sync runs this automatically. Use this command for on-demand checks or in CI.\n\n  CI recommendation: add 'haive memory verify' to your haive-sync.yml PR check job\n  to catch stale memories before they reach main.\n\n  Examples:\n    haive memory verify                          # check all, report only\n    haive memory verify --update                 # mark stale/fresh on disk\n    haive memory verify --id 2026-04-28-gotcha-x # check one memory\n"
   ).option("--id <id>", "verify a single memory by id").option("--all", "verify every memory (default if --id is omitted)").option("--update", "write status=stale or status=validated back to disk").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot25(opts.dir);
-    const paths = resolveHaivePaths22(root);
-    if (!existsSync26(paths.memoriesDir)) {
+    const root = findProjectRoot26(opts.dir);
+    const paths = resolveHaivePaths23(root);
+    if (!existsSync28(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -3709,7 +4315,7 @@ function registerMemoryVerify(memory2) {
         anchorlessIds.push(mem.frontmatter.id);
         continue;
       }
-      const rel = path26.relative(root, filePath);
+      const rel = path28.relative(root, filePath);
       if (result.stale) {
         staleCount++;
         console.log(`${ui.bold("STALE")}  ${mem.frontmatter.id}`);
@@ -3724,7 +4330,7 @@ function registerMemoryVerify(memory2) {
       }
       if (opts.update) {
         const next = applyVerification(mem, result);
-        await writeFile13(filePath, serializeMemory10(next), "utf8");
+        await writeFile14(filePath, serializeMemory10(next), "utf8");
         updated++;
       }
     }
@@ -3772,30 +4378,30 @@ function applyVerification(mem, result) {
 }
 
 // src/commands/memory-import.ts
-import { readFile as readFile10 } from "fs/promises";
-import { existsSync as existsSync27 } from "fs";
+import { readFile as readFile11 } from "fs/promises";
+import { existsSync as existsSync29 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot26,
-  resolveHaivePaths as resolveHaivePaths23
+  findProjectRoot as findProjectRoot27,
+  resolveHaivePaths as resolveHaivePaths24
 } from "@hiveai/core";
 function registerMemoryImport(memory2) {
   memory2.command("import").description(
     "Parse a Markdown file and suggest memories via the import_docs MCP prompt (prints a ready-to-use prompt invocation)"
   ).requiredOption("--from <file>", "Markdown/text file to import from").option("--scope <scope>", "personal | team (default: team)", "team").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot26(opts.dir);
-    const paths = resolveHaivePaths23(root);
-    if (!existsSync27(paths.haiveDir)) {
+    const root = findProjectRoot27(opts.dir);
+    const paths = resolveHaivePaths24(root);
+    if (!existsSync29(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    if (!existsSync27(opts.from)) {
+    if (!existsSync29(opts.from)) {
       ui.error(`File not found: ${opts.from}`);
       process.exitCode = 1;
       return;
     }
-    const content = await readFile10(opts.from, "utf8");
+    const content = await readFile11(opts.from, "utf8");
     const scope = opts.scope ?? "team";
     ui.info(`Preparing import from: ${opts.from}  (scope=${scope})`);
     ui.info(`Content length: ${content.length} chars`);
@@ -3823,14 +4429,14 @@ function registerMemoryImport(memory2) {
 }
 
 // src/commands/memory-import-changelog.ts
-import { existsSync as existsSync28 } from "fs";
-import { readFile as readFile11, mkdir as mkdir9, writeFile as writeFile14 } from "fs/promises";
-import path27 from "path";
+import { existsSync as existsSync30 } from "fs";
+import { readFile as readFile12, mkdir as mkdir11, writeFile as writeFile15 } from "fs/promises";
+import path29 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter5,
-  findProjectRoot as findProjectRoot27,
-  resolveHaivePaths as resolveHaivePaths24,
+  findProjectRoot as findProjectRoot28,
+  resolveHaivePaths as resolveHaivePaths25,
   serializeMemory as serializeMemory11
 } from "@hiveai/core";
 function parseChangelog(content) {
@@ -3894,15 +4500,15 @@ function registerMemoryImportChangelog(memory2) {
     "--versions <csv>",
     "only import specific versions (comma-separated), or 'latest' for the most recent breaking version"
   ).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot27(opts.dir);
-    const paths = resolveHaivePaths24(root);
-    const changelogPath = path27.resolve(root, opts.fromChangelog);
-    if (!existsSync28(changelogPath)) {
+    const root = findProjectRoot28(opts.dir);
+    const paths = resolveHaivePaths25(root);
+    const changelogPath = path29.resolve(root, opts.fromChangelog);
+    if (!existsSync30(changelogPath)) {
       ui.error(`CHANGELOG not found: ${changelogPath}`);
       process.exitCode = 1;
       return;
     }
-    const content = await readFile11(changelogPath, "utf8");
+    const content = await readFile12(changelogPath, "utf8");
     let entries = parseChangelog(content);
     if (entries.length === 0) {
       ui.warn("No breaking changes, deprecations, or removals found in the CHANGELOG.");
@@ -3916,10 +4522,10 @@ function registerMemoryImportChangelog(memory2) {
         entries = entries.filter((e) => requested.includes(e.version));
       }
     }
-    const pkgName = opts.package ?? path27.basename(path27.dirname(changelogPath));
+    const pkgName = opts.package ?? path29.basename(path29.dirname(changelogPath));
     const scope = opts.scope ?? "team";
-    const teamDir = path27.join(paths.memoriesDir, scope);
-    await mkdir9(teamDir, { recursive: true });
+    const teamDir = path29.join(paths.memoriesDir, scope);
+    await mkdir11(teamDir, { recursive: true });
     let saved = 0;
     for (const entry of entries) {
       const lines = [];
@@ -3941,7 +4547,7 @@ function registerMemoryImportChangelog(memory2) {
         lines.push("");
       }
       lines.push(
-        `**Source:** \`${path27.relative(root, changelogPath)}\`  
+        `**Source:** \`${path29.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, "-")}`;
@@ -3956,11 +4562,11 @@ function registerMemoryImportChangelog(memory2) {
           pkgName.replace(/[^a-z0-9]/gi, "-").toLowerCase(),
           `v${entry.version}`
         ],
-        paths: [path27.relative(root, changelogPath)],
+        paths: [path29.relative(root, changelogPath)],
         topic: `changelog-${pkgName}-${entry.version}`
       });
-      await writeFile14(
-        path27.join(teamDir, `${fm.id}.md`),
+      await writeFile15(
+        path29.join(teamDir, `${fm.id}.md`),
         serializeMemory11({ frontmatter: fm, body: lines.join("\n") }),
         "utf8"
       );
@@ -3983,17 +4589,17 @@ ${ui.bold(`Imported ${saved} changelog entr${saved === 1 ? "y" : "ies"} from ${p
 }
 
 // src/commands/memory-digest.ts
-import { existsSync as existsSync29 } from "fs";
-import { writeFile as writeFile15 } from "fs/promises";
-import path28 from "path";
+import { existsSync as existsSync31 } from "fs";
+import { writeFile as writeFile16 } from "fs/promises";
+import path30 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence4,
-  findProjectRoot as findProjectRoot28,
+  findProjectRoot as findProjectRoot29,
   getUsage as getUsage8,
   loadMemoriesFromDir as loadMemoriesFromDir5,
-  loadUsageIndex as loadUsageIndex10,
-  resolveHaivePaths as resolveHaivePaths25
+  loadUsageIndex as loadUsageIndex11,
+  resolveHaivePaths as resolveHaivePaths26
 } from "@hiveai/core";
 var CONFIDENCE_EMOJI = {
   unverified: "\u2B1C",
@@ -4006,9 +4612,9 @@ function registerMemoryDigest(program2) {
   program2.command("digest").description(
     "Generate a Markdown review digest of recently added or updated memories.\n\n  Groups memories by type, shows confidence, status, read count, and anchor info.\n  Each memory has action checkboxes (approve / reject / keep as-is) for peer review.\n\n  Use this to do a bulk weekly review of team memories, or share with teammates\n  as a pull-request attachment so humans can validate what the AI captured.\n\n  Examples:\n    haive memory digest                         # last 7 days, team scope\n    haive memory digest --days 30 --scope all   # last 30 days, all scopes\n    haive memory digest --out review.md         # write to file\n"
   ).option("--days <n>", "look-back window in days (default: 7)", "7").option("--scope <scope>", "personal | team | module | all (default: team)", "team").option("--out <file>", "write digest to a file instead of stdout").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot28(opts.dir);
-    const paths = resolveHaivePaths25(root);
-    if (!existsSync29(paths.memoriesDir)) {
+    const root = findProjectRoot29(opts.dir);
+    const paths = resolveHaivePaths26(root);
+    if (!existsSync31(paths.memoriesDir)) {
       ui.error("No .ai/memories found. Run `haive init` first.");
       process.exitCode = 1;
       return;
@@ -4017,7 +4623,7 @@ function registerMemoryDigest(program2) {
     const scopeFilter = opts.scope ?? "team";
     const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1e3);
     const all = await loadMemoriesFromDir5(paths.memoriesDir);
-    const usage = await loadUsageIndex10(paths);
+    const usage = await loadUsageIndex11(paths);
     const recent = all.filter(({ memory: mem }) => {
       const fm = mem.frontmatter;
       if (fm.type === "session_recap") return false;
@@ -4080,8 +4686,8 @@ function registerMemoryDigest(program2) {
     );
     const digest = lines.join("\n");
     if (opts.out) {
-      const outPath = path28.resolve(process.cwd(), opts.out);
-      await writeFile15(outPath, digest, "utf8");
+      const outPath = path30.resolve(process.cwd(), opts.out);
+      await writeFile16(outPath, digest, "utf8");
       ui.success(`Digest written to ${opts.out}  (${recent.length} memor${recent.length === 1 ? "y" : "ies"})`);
     } else {
       console.log(digest);
@@ -4090,18 +4696,52 @@ function registerMemoryDigest(program2) {
 }
 
 // src/commands/session-end.ts
-import { writeFile as writeFile16, mkdir as mkdir10 } from "fs/promises";
-import { existsSync as existsSync30 } from "fs";
-import path29 from "path";
+import { writeFile as writeFile17, mkdir as mkdir12, readFile as readFile13, rm } from "fs/promises";
+import { existsSync as existsSync32 } from "fs";
+import path31 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter6,
-  findProjectRoot as findProjectRoot29,
+  findProjectRoot as findProjectRoot30,
   loadMemoriesFromDir as loadMemoriesFromDir6,
   memoryFilePath as memoryFilePath5,
-  resolveHaivePaths as resolveHaivePaths26,
+  resolveHaivePaths as resolveHaivePaths27,
   serializeMemory as serializeMemory12
 } from "@hiveai/core";
+async function buildAutoRecap(paths) {
+  const obsFile = path31.join(paths.haiveDir, ".cache", "observations.jsonl");
+  if (!existsSync32(obsFile)) return null;
+  const raw = await readFile13(obsFile, "utf8").catch(() => "");
+  if (!raw.trim()) return null;
+  const lines = raw.split("\n").filter(Boolean);
+  const obs = [];
+  for (const line of lines) {
+    try {
+      obs.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  if (obs.length === 0) return null;
+  const toolCounts = /* @__PURE__ */ new Map();
+  const fileCounts = /* @__PURE__ */ new Map();
+  const summaries = [];
+  for (const o of obs) {
+    toolCounts.set(o.tool, (toolCounts.get(o.tool) ?? 0) + 1);
+    for (const f of o.files ?? []) fileCounts.set(f, (fileCounts.get(f) ?? 0) + 1);
+    if (summaries.length < 10) summaries.push(`- ${o.summary}`);
+  }
+  const topTools = [...toolCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([t, c]) => `${t} \xD7${c}`).join(", ");
+  const topFiles = [...fileCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 8);
+  const goal = `Auto-captured session \u2014 ${obs.length} tool calls (${topTools})`;
+  const accomplished = summaries.length ? `Recent activity:
+${summaries.join("\n")}` : `Activity captured but no parseable summaries.`;
+  return {
+    goal,
+    accomplished,
+    files: topFiles.map(([f]) => f),
+    rawCount: obs.length
+  };
+}
 function buildRecapBody(opts) {
   const lines = [];
   lines.push(`## Goal
@@ -4148,24 +4788,53 @@ function registerSessionEnd(session2) {
       --files src/payments/WebhookController.ts,src/payments/WebhookService.ts \\\\
       --next "Add integration tests for webhook signature validation"
 `
-  ).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 (!existsSync30(paths.haiveDir)) {
+  ).option("--goal <text>", "what you were trying to accomplish (1\u20132 sentences)").option("--accomplished <text>", "what was actually done (bullet list recommended)").option("--discoveries <text>", "bugs, surprises, or inconsistencies found during this session").option("--files <csv>", "key files touched, comma-separated (used as anchor for staleness detection)").option("--next <text>", "what should happen next (for the next session or a teammate)").option("--scope <scope>", "personal | team | module (default: personal)", "personal").option("--module <name>", "module name (required when scope=module)").option("--auto", "synthesize the recap from .ai/.cache/observations.jsonl (used by Claude Code SessionEnd hook)").option("--quiet", "suppress non-error output (for hook use)").option("-d, --dir <dir>", "project root").action(async (opts) => {
+    const root = findProjectRoot30(opts.dir);
+    const paths = resolveHaivePaths27(root);
+    if (!existsSync32(paths.haiveDir)) {
+      if (opts.auto || opts.quiet) return;
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
+    let resolvedFiles = opts.files;
+    let goal = opts.goal;
+    let accomplished = opts.accomplished;
+    if (opts.auto) {
+      const synth = await buildAutoRecap(paths);
+      if (!synth) return;
+      goal = goal ?? synth.goal;
+      accomplished = accomplished ?? synth.accomplished;
+      if (!resolvedFiles && synth.files.length) resolvedFiles = synth.files.join(",");
+    }
+    if (!goal || !accomplished) {
+      if (opts.quiet) return;
+      ui.error("session-end requires --goal and --accomplished (or pass --auto with captured observations).");
+      process.exitCode = 1;
+      return;
+    }
     const scope = opts.scope ?? "personal";
-    const body = buildRecapBody(opts);
+    const body = buildRecapBody({
+      goal,
+      accomplished,
+      discoveries: opts.discoveries,
+      files: resolvedFiles,
+      next: opts.next
+    });
     const topic = recapTopic(scope, opts.module);
-    const filesTouched = parseCsv5(opts.files);
-    const missingPaths = filesTouched.filter((p) => !existsSync30(path29.resolve(root, p)));
-    if (missingPaths.length > 0) {
+    const filesTouched = parseCsv5(resolvedFiles);
+    const missingPaths = filesTouched.filter((p) => !existsSync32(path31.resolve(root, p)));
+    if (missingPaths.length > 0 && !opts.quiet) {
       ui.warn(`Anchor path${missingPaths.length > 1 ? "s" : ""} not found in project (will be stale):`);
       for (const p of missingPaths) ui.warn(`  \u2717 ${p}`);
     }
-    if (existsSync30(paths.memoriesDir)) {
+    const cleanupObservations = async () => {
+      if (!opts.auto) return;
+      const obsFile = path31.join(paths.haiveDir, ".cache", "observations.jsonl");
+      if (existsSync32(obsFile)) await rm(obsFile).catch(() => {
+      });
+    };
+    if (existsSync32(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)
@@ -4181,9 +4850,12 @@ function registerSessionEnd(session2) {
             paths: filesTouched.length ? filesTouched : fm.anchor.paths
           }
         };
-        await writeFile16(topicMatch.filePath, serializeMemory12({ frontmatter: newFrontmatter, body }), "utf8");
-        ui.success(`Session recap updated (revision #${revisionCount})`);
-        ui.info(`id=${fm.id}  file=${path29.relative(root, topicMatch.filePath)}`);
+        await writeFile17(topicMatch.filePath, serializeMemory12({ frontmatter: newFrontmatter, body }), "utf8");
+        await cleanupObservations();
+        if (!opts.quiet) {
+          ui.success(`Session recap updated (revision #${revisionCount})`);
+          ui.info(`id=${fm.id}  file=${path31.relative(root, topicMatch.filePath)}`);
+        }
         return;
       }
     }
@@ -4198,11 +4870,14 @@ function registerSessionEnd(session2) {
       status: "validated"
     });
     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=${path29.relative(root, file)}`);
-    ui.info("Next session: call `get_briefing` \u2014 the recap will be surfaced automatically.");
+    await mkdir12(path31.dirname(file), { recursive: true });
+    await writeFile17(file, serializeMemory12({ frontmatter, body }), "utf8");
+    await cleanupObservations();
+    if (!opts.quiet) {
+      ui.success(`Session recap created`);
+      ui.info(`id=${frontmatter.id}  scope=${scope}  file=${path31.relative(root, file)}`);
+      ui.info("Next session: call `get_briefing` \u2014 the recap will be surfaced automatically.");
+    }
   });
 }
 function parseCsv5(value) {
@@ -4211,15 +4886,15 @@ function parseCsv5(value) {
 }
 
 // src/commands/snapshot.ts
-import { existsSync as existsSync31 } from "fs";
+import { existsSync as existsSync33 } from "fs";
 import { readdir as readdir2 } from "fs/promises";
-import path30 from "path";
+import path32 from "path";
 import "commander";
 import {
   diffContract,
-  findProjectRoot as findProjectRoot30,
+  findProjectRoot as findProjectRoot31,
   loadConfig as loadConfig2,
-  resolveHaivePaths as resolveHaivePaths27,
+  resolveHaivePaths as resolveHaivePaths28,
   snapshotContract
 } from "@hiveai/core";
 function registerSnapshot(program2) {
@@ -4244,16 +4919,16 @@ function registerSnapshot(program2) {
     "--format <format>",
     "contract format: openapi | graphql | proto | typescript | json-schema (auto-detected if omitted)"
   ).option("--diff", "compare the contract against its stored snapshot").option("--list", "list all stored contract snapshots").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot30(opts.dir);
-    const paths = resolveHaivePaths27(root);
-    if (!existsSync31(paths.haiveDir)) {
+    const root = findProjectRoot31(opts.dir);
+    const paths = resolveHaivePaths28(root);
+    if (!existsSync33(paths.haiveDir)) {
       ui.error("No .ai/ found. Run `haive init` first.");
       process.exitCode = 1;
       return;
     }
     if (opts.list) {
-      const contractsDir = path30.join(paths.haiveDir, "contracts");
-      if (!existsSync31(contractsDir)) {
+      const contractsDir = path32.join(paths.haiveDir, "contracts");
+      if (!existsSync33(contractsDir)) {
         console.log(ui.dim("No contract snapshots found."));
         return;
       }
@@ -4308,7 +4983,7 @@ function registerSnapshot(program2) {
       return;
     }
     const contractPath = opts.contract;
-    const name = opts.name ?? path30.basename(contractPath, path30.extname(contractPath));
+    const name = opts.name ?? path32.basename(contractPath, path32.extname(contractPath));
     const format = opts.format ?? detectFormat(contractPath) ?? "openapi";
     const contract = { name, path: contractPath, format };
     try {
@@ -4363,8 +5038,8 @@ async function runDiff(root, haiveDir, contract) {
   }
 }
 function detectFormat(filePath) {
-  const ext = path30.extname(filePath).toLowerCase();
-  const base = path30.basename(filePath).toLowerCase();
+  const ext = path32.extname(filePath).toLowerCase();
+  const base = path32.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";
@@ -4377,16 +5052,16 @@ function detectFormat(filePath) {
 }
 
 // src/commands/hub.ts
-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 { existsSync as existsSync34 } from "fs";
+import { mkdir as mkdir13, readFile as readFile14, writeFile as writeFile18, copyFile } from "fs/promises";
+import path33 from "path";
 import { spawnSync as spawnSync3 } from "child_process";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot31,
+  findProjectRoot as findProjectRoot32,
   loadConfig as loadConfig3,
   loadMemoriesFromDir as loadMemoriesFromDir7,
-  resolveHaivePaths as resolveHaivePaths28,
+  resolveHaivePaths as resolveHaivePaths29,
   saveConfig as saveConfig2,
   serializeMemory as serializeMemory13
 } from "@hiveai/core";
@@ -4398,8 +5073,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 = path31.resolve(hubPath);
-    await mkdir11(absPath, { recursive: true });
+    const absPath = path33.resolve(hubPath);
+    await mkdir13(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" });
@@ -4409,10 +5084,10 @@ function registerHub(program2) {
         return;
       }
     }
-    const sharedDir = path31.join(absPath, ".ai", "memories", "shared");
-    await mkdir11(sharedDir, { recursive: true });
-    await writeFile17(
-      path31.join(absPath, ".ai", "README.md"),
+    const sharedDir = path33.join(absPath, ".ai", "memories", "shared");
+    await mkdir13(sharedDir, { recursive: true });
+    await writeFile18(
+      path33.join(absPath, ".ai", "README.md"),
       `# hAIve Team Knowledge Hub
 
 This repo is a shared knowledge hub for hAIve.
@@ -4433,8 +5108,8 @@ haive hub pull   # import into a project
 `,
       "utf8"
     );
-    await writeFile17(
-      path31.join(absPath, ".gitignore"),
+    await writeFile18(
+      path33.join(absPath, ".gitignore"),
       ".ai/.cache/\n.ai/memories/personal/\n",
       "utf8"
     );
@@ -4449,7 +5124,7 @@ haive hub pull   # import into a project
         `
 Next steps:
   1. Add hubPath to your project's .ai/haive.config.json:
-       { "hubPath": "${path31.relative(process.cwd(), absPath)}" }
+       { "hubPath": "${path33.relative(process.cwd(), absPath)}" }
   2. Run \`haive hub push\` to publish your shared memories
   3. Share ${absPath} with teammates (git remote, NFS, etc.)
 `
@@ -4468,8 +5143,8 @@ Next steps:
     haive hub push --commit --message "feat: add payment API contract memories"
 `
   ).option("-d, --dir <dir>", "project root").option("--commit", "auto-commit to the hub repo after pushing").option("--message <msg>", "commit message for the hub (used with --commit)").action(async (opts) => {
-    const root = findProjectRoot31(opts.dir);
-    const paths = resolveHaivePaths28(root);
+    const root = findProjectRoot32(opts.dir);
+    const paths = resolveHaivePaths29(root);
     const config = await loadConfig3(paths);
     if (!config.hubPath) {
       ui.error(
@@ -4478,15 +5153,15 @@ Next steps:
       process.exitCode = 1;
       return;
     }
-    const hubRoot = path31.resolve(root, config.hubPath);
-    if (!existsSync32(hubRoot)) {
+    const hubRoot = path33.resolve(root, config.hubPath);
+    if (!existsSync34(hubRoot)) {
       ui.error(`Hub not found at ${hubRoot}. Run \`haive hub init ${config.hubPath}\` first.`);
       process.exitCode = 1;
       return;
     }
-    const projectName = path31.basename(root);
-    const destDir = path31.join(hubRoot, ".ai", "memories", "shared", projectName);
-    await mkdir11(destDir, { recursive: true });
+    const projectName = path33.basename(root);
+    const destDir = path33.join(hubRoot, ".ai", "memories", "shared", projectName);
+    await mkdir13(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)
@@ -4504,15 +5179,15 @@ Next steps:
     for (const { memory: memory2 } of shared) {
       const fm = memory2.frontmatter;
       const fileName = `${fm.id}.md`;
-      const destPath = path31.join(destDir, fileName);
-      await writeFile17(destPath, serializeMemory13(memory2), "utf8");
+      const destPath = path33.join(destDir, fileName);
+      await writeFile18(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", path31.join(".ai", "memories", "shared", projectName)], {
+      spawnSync3("git", ["add", path33.join(".ai", "memories", "shared", projectName)], {
         cwd: hubRoot
       });
       const commit = spawnSync3("git", ["commit", "-m", message], {
@@ -4537,8 +5212,8 @@ Next steps:
   hub.command("pull").description(
     "Pull shared memories from the hub into this project.\n\n  Imports all memories from hub/.ai/memories/shared/ EXCEPT this project's own.\n  Imported memories land in .ai/memories/shared/<source-project-name>/.\n\n  Examples:\n    haive hub pull\n"
   ).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot31(opts.dir);
-    const paths = resolveHaivePaths28(root);
+    const root = findProjectRoot32(opts.dir);
+    const paths = resolveHaivePaths29(root);
     const config = await loadConfig3(paths);
     if (!config.hubPath) {
       ui.error(
@@ -4547,13 +5222,13 @@ Next steps:
       process.exitCode = 1;
       return;
     }
-    const hubRoot = path31.resolve(root, config.hubPath);
-    const hubSharedDir = path31.join(hubRoot, ".ai", "memories", "shared");
-    if (!existsSync32(hubSharedDir)) {
+    const hubRoot = path33.resolve(root, config.hubPath);
+    const hubSharedDir = path33.join(hubRoot, ".ai", "memories", "shared");
+    if (!existsSync34(hubSharedDir)) {
       ui.warn("Hub has no shared memories yet. Run `haive hub push` from other projects first.");
       return;
     }
-    const projectName = path31.basename(root);
+    const projectName = path33.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) {
@@ -4563,17 +5238,17 @@ Next steps:
     let totalImported = 0;
     let totalUpdated = 0;
     for (const sourceName of projectDirs) {
-      const sourceDir = path31.join(hubSharedDir, sourceName);
-      const destDir = path31.join(paths.memoriesDir, "shared", sourceName);
-      await mkdir11(destDir, { recursive: true });
+      const sourceDir = path33.join(hubSharedDir, sourceName);
+      const destDir = path33.join(paths.memoriesDir, "shared", sourceName);
+      await mkdir13(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 = path31.join(sourceDir, file);
-        const destPath = path31.join(destDir, file);
-        const fileContent = await readFile12(srcPath, "utf8");
+        const srcPath = path33.join(sourceDir, file);
+        const destPath = path33.join(destDir, file);
+        const fileContent = await readFile14(srcPath, "utf8");
         const alreadyTagged = fileContent.includes(`cross-repo:${sourceName}`);
         if (!alreadyTagged) {
           await copyFile(srcPath, destPath);
@@ -4596,21 +5271,21 @@ Next steps:
     );
   });
   hub.command("status").description("Show hub sync status.").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot31(opts.dir);
-    const paths = resolveHaivePaths28(root);
+    const root = findProjectRoot32(opts.dir);
+    const paths = resolveHaivePaths29(root);
     const config = await loadConfig3(paths);
     console.log(ui.bold("Hub status"));
     console.log(
       `  hubPath: ${config.hubPath ? ui.green(config.hubPath) : ui.dim("not configured")}`
     );
-    const sharedDir = path31.join(paths.memoriesDir, "shared");
-    if (existsSync32(sharedDir)) {
+    const sharedDir = path33.join(paths.memoriesDir, "shared");
+    if (existsSync34(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 readdir3(path31.join(sharedDir, src))).filter((f) => f.endsWith(".md"));
+        const files = (await readdir3(path33.join(sharedDir, src))).filter((f) => f.endsWith(".md"));
         console.log(`    ${src}: ${files.length} memor${files.length === 1 ? "y" : "ies"}`);
       }
     } else {
@@ -4625,8 +5300,8 @@ Next steps:
     if (outgoing.length > 0) {
       console.log(ui.dim("  Run `haive hub push` to publish them to the hub."));
     }
-    void readFile12;
-    void writeFile17;
+    void readFile14;
+    void writeFile18;
     void saveConfig2;
   });
 }
@@ -4635,16 +5310,21 @@ Next steps:
 import "commander";
 import {
   aggregateUsage,
-  findProjectRoot as findProjectRoot32,
+  findProjectRoot as findProjectRoot33,
+  loadUsageIndex as loadUsageIndex12,
   parseSince,
   readUsageEvents,
-  resolveHaivePaths as resolveHaivePaths29,
+  resolveHaivePaths as resolveHaivePaths30,
   usageLogSize
 } from "@hiveai/core";
 function registerStats(program2) {
-  program2.command("stats").description("Show MCP tool-usage stats over a window (e.g. --since 7d).").option("--since <window>", "ISO date or relative (e.g. '7d', '24h', '30m')", "30d").option("--json", "emit JSON instead of human-readable output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot32(opts.dir);
-    const paths = resolveHaivePaths29(root);
+  program2.command("stats").description("Show MCP tool-usage stats over a window (e.g. --since 7d).").option("--since <window>", "ISO date or relative (e.g. '7d', '24h', '30m')", "30d").option("--json", "emit JSON instead of human-readable output", false).option("--memory-hits", "show top-read memories (which mems are actually being used)", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
+    const root = findProjectRoot33(opts.dir);
+    const paths = resolveHaivePaths30(root);
+    if (opts.memoryHits) {
+      await renderMemoryHits(paths, opts);
+      return;
+    }
     const size = await usageLogSize(paths);
     if (!size.exists) {
       if (opts.json) {
@@ -4689,14 +5369,57 @@ function registerStats(program2) {
     }
   });
 }
+async function renderMemoryHits(paths, opts) {
+  const index = await loadUsageIndex12(paths);
+  const since = parseSince(opts.since ?? "30d");
+  const sinceMs = since ? new Date(since).getTime() : null;
+  const entries = Object.entries(index.by_id).map(([id, usage]) => ({ id, ...usage })).filter((e) => e.read_count > 0).filter((e) => {
+    if (!sinceMs || !e.last_read_at) return !sinceMs;
+    return new Date(e.last_read_at).getTime() >= sinceMs;
+  }).sort((a, b) => b.read_count - a.read_count);
+  if (opts.json) {
+    console.log(JSON.stringify({
+      window: opts.since ?? "30d",
+      total_mems_with_hits: entries.length,
+      top: entries.slice(0, 50)
+    }, null, 2));
+    return;
+  }
+  const window = opts.since ?? "30d";
+  console.log(ui.bold(`Memory hits (${window})`));
+  if (entries.length === 0) {
+    ui.info(
+      `No memory reads recorded in window. Reads are logged when \`haive briefing\` or \`haive memory query\` surface a memory.`
+    );
+    return;
+  }
+  console.log(
+    `  ${ui.dim("memories with hits:")} ${entries.length}  ${ui.dim("total reads:")} ${entries.reduce((a, e) => a + e.read_count, 0)}`
+  );
+  console.log();
+  console.log(ui.bold("Top read memories:"));
+  const maxCount = entries[0].read_count;
+  for (const e of entries.slice(0, 25)) {
+    const bar = "\u2588".repeat(Math.max(1, Math.round(e.read_count / maxCount * 20)));
+    const lastRead = e.last_read_at?.slice(0, 10) ?? "?";
+    console.log(
+      `  ${ui.bold(String(e.read_count).padStart(4))}  ${ui.green(bar.padEnd(20))}  ${e.id}  ${ui.dim(`last: ${lastRead}`)}`
+    );
+  }
+  const dead = Object.keys(index.by_id).length - entries.length;
+  if (dead > 0) {
+    console.log();
+    ui.info(`${dead} memor${dead === 1 ? "y" : "ies"} never read in window \u2014 candidates for cleanup (run \`haive doctor\`).`);
+  }
+}
 
 // src/commands/bench.ts
 import { performance } from "perf_hooks";
 import "commander";
 import {
   estimateTokens,
-  findProjectRoot as findProjectRoot33,
-  resolveHaivePaths as resolveHaivePaths30
+  findProjectRoot as findProjectRoot34,
+  resolveHaivePaths as resolveHaivePaths31
 } from "@hiveai/core";
 import {
   antiPatternsCheck,
@@ -4708,8 +5431,8 @@ import {
 } from "@hiveai/mcp";
 function registerBench(program2) {
   program2.command("bench").description("Self-test the local hAIve setup: runs core MCP tools against this project and reports latency + payload size.").option("-t, --task <task>", "task description for ranking-aware tools", "audit dependencies for security risks").option("--json", "emit JSON instead of a table", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot33(opts.dir);
-    const paths = resolveHaivePaths30(root);
+    const root = findProjectRoot34(opts.dir);
+    const paths = resolveHaivePaths31(root);
     const ctx = { paths };
     const task = opts.task ?? "audit dependencies for security risks";
     const scenarios = [
@@ -4828,19 +5551,19 @@ function summarize(name, t0, payload, notes) {
 }
 
 // src/commands/memory-suggest.ts
-import { mkdir as mkdir12, writeFile as writeFile18 } from "fs/promises";
-import { existsSync as existsSync33 } from "fs";
-import path32 from "path";
+import { mkdir as mkdir14, writeFile as writeFile19 } from "fs/promises";
+import { existsSync as existsSync35 } from "fs";
+import path34 from "path";
 import "commander";
 import {
   aggregateUsage as aggregateUsage2,
   buildFrontmatter as buildFrontmatter7,
-  findProjectRoot as findProjectRoot34,
+  findProjectRoot as findProjectRoot35,
   loadMemoriesFromDir as loadMemoriesFromDir8,
   memoryFilePath as memoryFilePath6,
   parseSince as parseSince2,
   readUsageEvents as readUsageEvents2,
-  resolveHaivePaths as resolveHaivePaths31,
+  resolveHaivePaths as resolveHaivePaths32,
   serializeMemory as serializeMemory14
 } from "@hiveai/core";
 var SEARCH_TOOLS = /* @__PURE__ */ new Set([
@@ -4853,8 +5576,8 @@ function registerMemorySuggest(memory2) {
   memory2.command("suggest").description(
     "Suggest memories to create based on recurring search queries in the usage log.\n\n  Use --auto-save to draft the top-N suggestions as draft memories. They land\n  in personal scope by default with status=draft, ready for you to edit and promote."
   ).option("--since <window>", "ISO date or relative (e.g. '7d', '24h')", "30d").option("--min <count>", "minimum repeat count to surface a query", "2").option("--top-n <n>", "with --auto-save, draft this many top suggestions", "3").option("--scope <scope>", "with --auto-save, scope of drafted memories (personal | team)", "personal").option("--auto-save", "draft top-N suggestions as draft memories on disk", false).option("--json", "emit JSON instead of human-readable output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot34(opts.dir);
-    const paths = resolveHaivePaths31(root);
+    const root = findProjectRoot35(opts.dir);
+    const paths = resolveHaivePaths32(root);
     const events = await readUsageEvents2(paths);
     if (events.length === 0) {
       if (opts.json) {
@@ -4900,7 +5623,7 @@ function registerMemorySuggest(memory2) {
       }
       const created = [];
       const skipped = [];
-      const existing = existsSync33(paths.memoriesDir) ? await loadMemoriesFromDir8(paths.memoriesDir) : [];
+      const existing = existsSync35(paths.memoriesDir) ? await loadMemoriesFromDir8(paths.memoriesDir) : [];
       for (const s of top) {
         const slug = slugify(s.query);
         if (!slug) {
@@ -4923,13 +5646,13 @@ function registerMemorySuggest(memory2) {
         fm.status = "draft";
         const body = renderTemplate(s);
         const file = memoryFilePath6(paths, fm.scope, fm.id, fm.module);
-        await mkdir12(path32.dirname(file), { recursive: true });
-        if (existsSync33(file)) {
-          skipped.push({ query: s.query, reason: `file already exists at ${path32.relative(root, file)}` });
+        await mkdir14(path34.dirname(file), { recursive: true });
+        if (existsSync35(file)) {
+          skipped.push({ query: s.query, reason: `file already exists at ${path34.relative(root, file)}` });
           continue;
         }
-        await writeFile18(file, serializeMemory14({ frontmatter: fm, body }), "utf8");
-        created.push({ id: fm.id, file: path32.relative(root, file), query: s.query });
+        await writeFile19(file, serializeMemory14({ frontmatter: fm, body }), "utf8");
+        created.push({ id: fm.id, file: path34.relative(root, file), query: s.query });
       }
       if (opts.json) {
         console.log(JSON.stringify({ created, skipped }, null, 2));
@@ -4937,10 +5660,10 @@ function registerMemorySuggest(memory2) {
       }
       for (const c of created) {
         ui.success(`Drafted ${c.id} \u2192 ${c.file}`);
-        console.log(`     ${ui.dim("from query:")} ${truncate(c.query, 60)}`);
+        console.log(`     ${ui.dim("from query:")} ${truncate2(c.query, 60)}`);
       }
       for (const s of skipped) {
-        ui.warn(`Skipped: ${truncate(s.query, 50)} \u2014 ${s.reason}`);
+        ui.warn(`Skipped: ${truncate2(s.query, 50)} \u2014 ${s.reason}`);
       }
       if (created.length > 0) {
         console.log();
@@ -4964,7 +5687,7 @@ function registerMemorySuggest(memory2) {
     }
     for (const s of suggestions.slice(0, 30)) {
       console.log(
-        `  ${ui.bold(`\xD7${s.count}`)} ${ui.dim(`[${s.tools.join(",")}]`)}  ${truncate(s.query, 70)}`
+        `  ${ui.bold(`\xD7${s.count}`)} ${ui.dim(`[${s.tools.join(",")}]`)}  ${truncate2(s.query, 70)}`
       );
       console.log(`     ${ui.dim("\u2192")} ${s.reason}`);
     }
@@ -5010,28 +5733,28 @@ function renderTemplate(s) {
     `- **Why** \u2014 the rationale or root cause`,
     `- **How to apply** \u2014 what an agent should do when this comes up again`,
     ``,
-    `Then run \`haive memory promote ${truncate(s.query, 30)}\` to mark it validated.`
+    `Then run \`haive memory promote ${truncate2(s.query, 30)}\` to mark it validated.`
   ].join("\n");
 }
 function slugify(s) {
   return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
 }
-function truncate(text, max) {
+function truncate2(text, max) {
   if (text.length <= max) return text;
   return text.slice(0, max - 1) + "\u2026";
 }
 
 // src/commands/memory-archive.ts
-import { existsSync as existsSync34 } from "fs";
-import { writeFile as writeFile19 } from "fs/promises";
-import path33 from "path";
+import { existsSync as existsSync36 } from "fs";
+import { writeFile as writeFile20 } from "fs/promises";
+import path35 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot35,
+  findProjectRoot as findProjectRoot36,
   getUsage as getUsage9,
   loadMemoriesFromDir as loadMemoriesFromDir9,
-  loadUsageIndex as loadUsageIndex11,
-  resolveHaivePaths as resolveHaivePaths32,
+  loadUsageIndex as loadUsageIndex13,
+  resolveHaivePaths as resolveHaivePaths33,
   serializeMemory as serializeMemory15
 } from "@hiveai/core";
 var MS_PER_DAY = 24 * 60 * 60 * 1e3;
@@ -5039,9 +5762,9 @@ function registerMemoryArchive(memory2) {
   memory2.command("archive").description(
     "Archive obsolete memories: marks status='deprecated' for memories not read in N days\n  whose anchored paths have all disappeared (or have no anchor at all).\n\n  Defaults to a DRY RUN \u2014 pass --apply to actually rewrite files.\n  Targets `attempt` memories by default since they age the fastest.\n\n  Recover later with `haive memory edit <id>` to set status back to validated."
   ).option("--since <window>", "minimum age since last read (e.g. '180d', '6m')", "180d").option("--type <type>", "limit to a memory type (default 'attempt'). Pass 'all' to scan all types.", "attempt").option("--apply", "actually rewrite files (default: dry run)", false).option("--json", "emit JSON instead of human-readable output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot35(opts.dir);
-    const paths = resolveHaivePaths32(root);
-    if (!existsSync34(paths.memoriesDir)) {
+    const root = findProjectRoot36(opts.dir);
+    const paths = resolveHaivePaths33(root);
+    if (!existsSync36(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -5054,7 +5777,7 @@ function registerMemoryArchive(memory2) {
     }
     const cutoff = Date.now() - minDays * MS_PER_DAY;
     const all = await loadMemoriesFromDir9(paths.memoriesDir);
-    const usage = await loadUsageIndex11(paths);
+    const usage = await loadUsageIndex13(paths);
     const typeFilter = opts.type === "all" ? null : opts.type ?? "attempt";
     const candidates = [];
     for (const { memory: mem, filePath } of all) {
@@ -5062,7 +5785,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) => !existsSync34(path33.join(paths.root, p)));
+      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync36(path35.join(paths.root, p)));
       const isAnchorless = !hasAnyAnchor;
       if (!isAnchorless && !allPathsGone) continue;
       const u = getUsage9(usage, fm.id);
@@ -5110,7 +5833,7 @@ function registerMemoryArchive(memory2) {
       if (!found) continue;
       const fm = { ...found.memory.frontmatter, status: "deprecated" };
       try {
-        await writeFile19(c.filePath, serializeMemory15({ frontmatter: fm, body: found.memory.body }), "utf8");
+        await writeFile20(c.filePath, serializeMemory15({ frontmatter: fm, body: found.memory.body }), "utf8");
         archived++;
       } catch (err) {
         if (!opts.json) {
@@ -5136,30 +5859,30 @@ function parseDays(input) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync35 } from "fs";
+import { existsSync as existsSync37 } from "fs";
 import { stat } from "fs/promises";
 import "path";
 import "commander";
 import {
   codeMapPath as codeMapPath2,
-  findProjectRoot as findProjectRoot36,
+  findProjectRoot as findProjectRoot37,
   getUsage as getUsage10,
   loadCodeMap as loadCodeMap3,
   loadConfig as loadConfig4,
   loadMemoriesFromDir as loadMemoriesFromDir10,
-  loadUsageIndex as loadUsageIndex12,
+  loadUsageIndex as loadUsageIndex14,
   readUsageEvents as readUsageEvents3,
-  resolveHaivePaths as resolveHaivePaths33
+  resolveHaivePaths as resolveHaivePaths34
 } from "@hiveai/core";
 var MS_PER_DAY2 = 24 * 60 * 60 * 1e3;
 function registerDoctor(program2) {
   program2.command("doctor").description(
     "Analyze the local hAIve setup and emit actionable recommendations.\n\n  Inspects: project-context status, memory health (stale/anchorless/decay/pending),\n  code-map freshness, usage log signals (low-hit briefings, repeated empty searches).\n\n  Read-only by default. Pass --fix to suggest commands you can copy-paste."
   ).option("--json", "emit JSON instead of human-readable output", false).option("--fix", "include suggested fix commands in human output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot36(opts.dir);
-    const paths = resolveHaivePaths33(root);
+    const root = findProjectRoot37(opts.dir);
+    const paths = resolveHaivePaths34(root);
     const findings = [];
-    if (!existsSync35(paths.haiveDir)) {
+    if (!existsSync37(paths.haiveDir)) {
       findings.push({
         severity: "error",
         code: "not-initialized",
@@ -5168,7 +5891,7 @@ function registerDoctor(program2) {
       });
       return emit(findings, opts);
     }
-    if (!existsSync35(paths.projectContext)) {
+    if (!existsSync37(paths.projectContext)) {
       findings.push({
         severity: "warn",
         code: "no-project-context",
@@ -5176,8 +5899,8 @@ function registerDoctor(program2) {
         fix: "haive init"
       });
     } else {
-      const { readFile: readFile13 } = await import("fs/promises");
-      const content = await readFile13(paths.projectContext, "utf8");
+      const { readFile: readFile15 } = await import("fs/promises");
+      const content = await readFile15(paths.projectContext, "utf8");
       const isTemplate = content.includes("TODO \u2014 high-level overview") || content.includes("Generated by `haive init`");
       if (isTemplate) {
         findings.push({
@@ -5188,7 +5911,7 @@ function registerDoctor(program2) {
         });
       }
     }
-    const memories = existsSync35(paths.memoriesDir) ? await loadMemoriesFromDir10(paths.memoriesDir) : [];
+    const memories = existsSync37(paths.memoriesDir) ? await loadMemoriesFromDir10(paths.memoriesDir) : [];
     const now = Date.now();
     if (memories.length === 0) {
       findings.push({
@@ -5197,7 +5920,7 @@ function registerDoctor(program2) {
         message: "No memories yet. Capture knowledge as agents work via mem_save / mem_observe / mem_tried."
       });
     } else {
-      const usage = await loadUsageIndex12(paths);
+      const usage = await loadUsageIndex14(paths);
       const stale = memories.filter((m) => m.memory.frontmatter.status === "stale");
       if (stale.length > 0) {
         findings.push({
@@ -5342,22 +6065,22 @@ function isSearchTool(name) {
 }
 
 // src/commands/playback.ts
-import { existsSync as existsSync36 } from "fs";
+import { existsSync as existsSync38 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot37,
+  findProjectRoot as findProjectRoot38,
   loadMemoriesFromDir as loadMemoriesFromDir11,
   parseSince as parseSince3,
   readUsageEvents as readUsageEvents4,
-  resolveHaivePaths as resolveHaivePaths34
+  resolveHaivePaths as resolveHaivePaths35
 } from "@hiveai/core";
 var MS_PER_MINUTE = 6e4;
 function registerPlayback(program2) {
   program2.command("playback").description(
     "Replay past sessions from the usage log. For each session, show:\n  - tool calls (what kind, how many)\n  - briefing tasks asked\n  - memories that have been created since then (that the session didn't have)\n\n  Useful to ask 'would today's haive have helped past me on this task?'"
   ).option("--since <window>", "limit to events in this window (e.g. '7d')", "30d").option("--session-gap <minutes>", "minutes of inactivity that splits a session", "30").option("--limit <n>", "show at most this many sessions (newest first)", "10").option("--json", "emit JSON instead of human-readable output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot37(opts.dir);
-    const paths = resolveHaivePaths34(root);
+    const root = findProjectRoot38(opts.dir);
+    const paths = resolveHaivePaths35(root);
     const events = await readUsageEvents4(paths);
     if (events.length === 0) {
       if (opts.json) {
@@ -5372,7 +6095,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 = existsSync36(paths.memoriesDir) ? await loadMemoriesFromDir11(paths.memoriesDir) : [];
+    const all = existsSync38(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);
@@ -5412,7 +6135,7 @@ function registerPlayback(program2) {
       if (s.briefing_tasks.length > 0) {
         console.log(`  ${ui.dim("briefings asked:")}`);
         for (const t of s.briefing_tasks) {
-          console.log(`    \u2022 ${truncate2(t, 80)}`);
+          console.log(`    \u2022 ${truncate3(t, 80)}`);
         }
       }
       if (s.memories_created_since > 0) {
@@ -5453,7 +6176,7 @@ function countTools(events) {
   for (const e of events) out[e.tool] = (out[e.tool] ?? 0) + 1;
   return out;
 }
-function truncate2(text, max) {
+function truncate3(text, max) {
   if (text.length <= max) return text;
   return text.slice(0, max - 1) + "\u2026";
 }
@@ -5462,8 +6185,8 @@ function truncate2(text, max) {
 import { spawn as spawn3 } from "child_process";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot38,
-  resolveHaivePaths as resolveHaivePaths35
+  findProjectRoot as findProjectRoot39,
+  resolveHaivePaths as resolveHaivePaths36
 } from "@hiveai/core";
 import { preCommitCheck } from "@hiveai/mcp";
 function registerPrecommit(program2) {
@@ -5474,8 +6197,8 @@ function registerPrecommit(program2) {
     "'any' | 'high-confidence' (default) | 'never' (report only)",
     "high-confidence"
   ).option("--no-semantic", "disable semantic search in anti-patterns matching").option("--json", "emit JSON instead of human-readable output", false).option("--paths <paths...>", "explicit paths to check (skips git diff)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot38(opts.dir);
-    const paths = resolveHaivePaths35(root);
+    const root = findProjectRoot39(opts.dir);
+    const paths = resolveHaivePaths36(root);
     const ctx = { paths };
     let diff = "";
     let touchedPaths = opts.paths ?? [];
@@ -5567,8 +6290,8 @@ 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.7.2");
+var program = new Command40();
+program.name("haive").description("hAIve \u2014 team-first persistent memory layer for AI coding agents").version("0.9.0");
 registerInit(program);
 registerMcp(program);
 registerBriefing(program);
@@ -5576,6 +6299,7 @@ registerTui(program);
 registerEmbeddings(program);
 registerSync(program);
 registerInstallHooks(program);
+registerObserve(program);
 registerIndexCode(program);
 var memory = program.command("memory").description("Manage memory entries");
 registerMemoryAdd(memory);