@hiveai/cli 0.4.5 → 0.6.0

package/dist/index.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command32 } from "commander";
+import { Command as Command39 } from "commander";
 
 // src/commands/briefing.ts
 import { existsSync } from "fs";
 import { readFile } from "fs/promises";
+import path from "path";
 import "commander";
 import {
   findProjectRoot,
@@ -58,7 +59,12 @@ function registerBriefing(program2) {
     "--scope <scope>",
     "personal | team | shared | all (default: all \u2014 includes team + shared cross-repo memories)",
     "all"
-  ).option("--include-draft", "include draft memories (excluded by default)").option("--include-stale", "include stale memories (excluded by default \u2014 may be outdated)").option("-d, --dir <dir>", "project root").action(async (opts) => {
+  ).option("--include-draft", "include draft memories (excluded by default)").option("--include-stale", "include stale memories (excluded by default \u2014 may be outdated)").option(
+    "--include <path>",
+    "merge memories from another haive-initialized project (repeatable). Useful for teams with multiple coordinated repos (e.g. backend + frontend).",
+    collectInclude,
+    []
+  ).option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot(opts.dir);
     const paths = resolveHaivePaths(root);
     if (!existsSync(paths.memoriesDir)) {
@@ -71,7 +77,34 @@ function registerBriefing(program2) {
       }
       return;
     }
-    const all = await loadMemoriesFromDir(paths.memoriesDir);
+    const ownMemories = await loadMemoriesFromDir(paths.memoriesDir);
+    const externalRoots = [];
+    if (opts.include && opts.include.length > 0) {
+      for (const includePath of opts.include) {
+        try {
+          const otherRoot = findProjectRoot(includePath);
+          if (otherRoot === root) continue;
+          const otherPaths = resolveHaivePaths(otherRoot);
+          if (!existsSync(otherPaths.memoriesDir)) {
+            ui.warn(`--include ${includePath}: no .ai/memories at ${otherRoot} \u2014 skipping`);
+            continue;
+          }
+          const otherMemories = await loadMemoriesFromDir(otherPaths.memoriesDir);
+          const tag = path.basename(otherRoot);
+          for (const m of otherMemories) {
+            ownMemories.push({ ...m, origin: tag });
+          }
+          externalRoots.push(`${tag} (${otherMemories.length})`);
+        } catch (err) {
+          ui.warn(`--include ${includePath}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+      if (externalRoots.length > 0) {
+        ui.info(`merged from: ${externalRoots.join(", ")}`);
+        console.log();
+      }
+    }
+    const all = ownMemories;
     const filePaths = parseCsv(opts.files);
     const tokens = opts.task ? tokenizeQuery(opts.task) : null;
     const maxMemories = Math.max(1, Number(opts.maxMemories ?? 10));
@@ -148,15 +181,16 @@ function registerBriefing(program2) {
     }
     console.log(`${ui.bold("=== Relevant Memories ===")}
 `);
-    for (const { memory: mem } of top) {
-      const fm = mem.frontmatter;
+    for (const item of top) {
+      const fm = item.memory.frontmatter;
       const badge = ui.statusBadge(fm.status);
       const draftMarker = fm.status === "draft" ? ui.yellow(" [DRAFT]") : "";
       const unverifiedMarker = fm.status === "proposed" ? ui.yellow(" [UNVERIFIED]") : "";
+      const originMarker = item.origin ? ` ${ui.yellow("[from " + item.origin + "]")}` : "";
       console.log(
-        `${ui.bold(fm.id)}  ${ui.dim(fm.scope + "/" + fm.type)}  ${badge}${draftMarker}${unverifiedMarker}`
+        `${ui.bold(fm.id)}  ${ui.dim(fm.scope + "/" + fm.type)}  ${badge}${draftMarker}${unverifiedMarker}${originMarker}`
       );
-      console.log(mem.body.trim());
+      console.log(item.memory.body.trim());
       console.log();
     }
     console.log(ui.dim(`${top.length} memor${top.length === 1 ? "y" : "ies"} surfaced`));
@@ -199,6 +233,9 @@ function parseCsv(value) {
   if (!value) return [];
   return value.split(",").map((s) => s.trim()).filter(Boolean);
 }
+function collectInclude(value, previous) {
+  return [...previous, value];
+}
 
 // src/commands/tui.ts
 import "commander";
@@ -223,7 +260,7 @@ function registerTui(program2) {
 
 // src/commands/embeddings.ts
 import { existsSync as existsSync2 } from "fs";
-import path from "path";
+import path2 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot3, resolveHaivePaths as resolveHaivePaths2 } from "@hiveai/core";
 function registerEmbeddings(program2) {
@@ -265,22 +302,22 @@ function registerEmbeddings(program2) {
     for (const hit of result.hits) {
       const score = hit.score.toFixed(3);
       console.log(`${ui.bold(score)}  ${hit.id}`);
-      console.log(`       ${ui.dim(path.relative(root, hit.file_path))}`);
+      console.log(`       ${ui.dim(path2.relative(root, hit.file_path))}`);
     }
   });
   embeddings.command("status").description("Show the embeddings index status").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot3(opts.dir);
     const paths = resolveHaivePaths2(root);
     const { indexStat } = await loadEmbeddings();
-    const stat = await indexStat(paths);
-    if (!stat.exists) {
+    const stat2 = await indexStat(paths);
+    if (!stat2.exists) {
       ui.warn("No embeddings index. Run `haive embeddings index` to create one.");
       return;
     }
-    console.log(`${ui.bold("entries:")}    ${stat.count}`);
-    console.log(`${ui.bold("model:")}      ${stat.model}`);
-    console.log(`${ui.bold("updated_at:")} ${stat.updatedAt}`);
-    console.log(`${ui.bold("size:")}       ${(stat.sizeBytes / 1024).toFixed(1)} KB`);
+    console.log(`${ui.bold("entries:")}    ${stat2.count}`);
+    console.log(`${ui.bold("model:")}      ${stat2.model}`);
+    console.log(`${ui.bold("updated_at:")} ${stat2.updatedAt}`);
+    console.log(`${ui.bold("size:")}       ${(stat2.sizeBytes / 1024).toFixed(1)} KB`);
   });
 }
 async function loadEmbeddings() {
@@ -295,7 +332,7 @@ async function loadEmbeddings() {
 }
 
 // src/commands/index-code.ts
-import path2 from "path";
+import path3 from "path";
 import "commander";
 import {
   buildCodeMap,
@@ -338,15 +375,42 @@ function registerIndexCode(program2) {
     const fileCount = Object.keys(map.files).length;
     const exportCount = Object.values(map.files).reduce((s, f) => s + f.exports.length, 0);
     ui.success(
-      `Indexed ${fileCount} file(s) with ${exportCount} export(s) \u2192 ${path2.relative(root, codeMapPath(paths))}`
+      `Indexed ${fileCount} file(s) with ${exportCount} export(s) \u2192 ${path3.relative(root, codeMapPath(paths))}`
     );
   });
+  idx.command("code-search").description(
+    "Build the semantic-search embeddings index for code (powers the code_search MCP tool).\n\n  Reads .ai/code-map.json (run `haive index code` first) and embeds each exported\n  symbol's metadata (filename + name + kind + description).\n\n  Re-runs are incremental: unchanged entries keep their cached vectors, only the\n  diff is re-embedded. First run downloads the bge-small-en-v1.5 model (~110MB).\n"
+  ).option("-d, --dir <dir>", "project root").action(async (opts) => {
+    const root = findProjectRoot4(opts.dir);
+    const paths = resolveHaivePaths3(root);
+    let mod;
+    try {
+      mod = await import("@hiveai/embeddings");
+    } catch {
+      ui.error(
+        "@hiveai/embeddings is not installed. Install it (`pnpm add @hiveai/embeddings`) or run `haive embeddings install`."
+      );
+      process.exit(1);
+    }
+    ui.info("Loading embedder (first run downloads ~110MB)\u2026");
+    const embedder = await mod.Embedder.create();
+    ui.info(`Embedding code-map symbols\u2026`);
+    try {
+      const { report } = await mod.rebuildCodeIndex(paths, embedder);
+      ui.success(
+        `Code-search index ready: ${report.total} symbols (+${report.added} new, ~${report.updated} updated, =${report.unchanged} cached, -${report.removed} removed)`
+      );
+    } catch (err) {
+      ui.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
 }
 
 // src/commands/init.ts
 import { mkdir, writeFile } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import path3 from "path";
+import path4 from "path";
 import { spawnSync } from "child_process";
 import "commander";
 import {
@@ -517,7 +581,7 @@ function registerInit(program2) {
     "--manual",
     "opt out of autopilot: memories require manual approval, no auto-session recap, no auto-context"
   ).action(async (opts) => {
-    const root = path3.resolve(opts.dir);
+    const root = path4.resolve(opts.dir);
     const paths = resolveHaivePaths4(root);
     const autopilot = opts.manual !== true;
     if (existsSync3(paths.haiveDir)) {
@@ -529,10 +593,10 @@ function registerInit(program2) {
     await mkdir(paths.modulesContextDir, { recursive: true });
     if (!existsSync3(paths.projectContext)) {
       await writeFile(paths.projectContext, PROJECT_CONTEXT_TEMPLATE, "utf8");
-      ui.success(`Created ${path3.relative(root, paths.projectContext)}`);
+      ui.success(`Created ${path4.relative(root, paths.projectContext)}`);
     }
     const configExists = existsSync3(
-      path3.join(paths.haiveDir, "haive.config.json")
+      path4.join(paths.haiveDir, "haive.config.json")
     );
     if (!configExists) {
       await saveConfig(paths, autopilot ? AUTOPILOT_DEFAULTS : { autopilot: false });
@@ -543,17 +607,17 @@ function registerInit(program2) {
     if (opts.bridges) {
       await writeBridge(root, "CLAUDE.md");
       await writeBridge(root, ".cursorrules");
-      await writeBridge(root, path3.join(".github", "copilot-instructions.md"));
+      await writeBridge(root, path4.join(".github", "copilot-instructions.md"));
     }
     const wantCi = opts.withCi || autopilot;
     if (wantCi) {
-      const ciPath = path3.join(root, ".github", "workflows", "haive-sync.yml");
+      const ciPath = path4.join(root, ".github", "workflows", "haive-sync.yml");
       if (existsSync3(ciPath)) {
         ui.info("CI workflow already exists \u2014 skipped");
       } else {
-        await mkdir(path3.dirname(ciPath), { recursive: true });
+        await mkdir(path4.dirname(ciPath), { recursive: true });
         await writeFile(ciPath, CI_WORKFLOW, "utf8");
-        ui.success(`Created ${path3.relative(root, ciPath)}`);
+        ui.success(`Created ${path4.relative(root, ciPath)}`);
       }
     }
     if (autopilot) {
@@ -608,12 +672,12 @@ function registerInit(program2) {
   });
 }
 async function writeBridge(root, relPath) {
-  const target = path3.join(root, relPath);
+  const target = path4.join(root, relPath);
   if (existsSync3(target)) {
     ui.info(`Bridge ${relPath} already exists \u2014 skipped`);
     return;
   }
-  await mkdir(path3.dirname(target), { recursive: true });
+  await mkdir(path4.dirname(target), { recursive: true });
   await writeFile(target, BRIDGE_BODY, "utf8");
   ui.success(`Created bridge ${relPath}`);
 }
@@ -621,7 +685,7 @@ async function writeBridge(root, relPath) {
 // src/commands/install-hooks.ts
 import { mkdir as mkdir2, writeFile as writeFile2, chmod, readFile as readFile2 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import path4 from "path";
+import path5 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot6 } from "@hiveai/core";
 var HOOK_MARKER = "# hAIve auto-generated";
@@ -642,18 +706,18 @@ function registerInstallHooks(program2) {
     "Install git hooks so haive sync runs automatically after every pull or merge.\n\n  Installs a post-merge hook at .git/hooks/post-merge that runs:\n    haive sync --quiet --since ORIG_HEAD --embed\n\n  This ensures memory anchors are always verified and the embeddings index\n  is kept fresh without requiring any manual steps.\n\n  Installed automatically by haive init (autopilot mode).\n  Use --force to overwrite an existing post-merge hook.\n"
   ).option("-d, --dir <dir>", "project root").option("--force", "overwrite existing hooks").action(async (opts) => {
     const root = findProjectRoot6(opts.dir);
-    const gitDir = path4.join(root, ".git");
+    const gitDir = path5.join(root, ".git");
     if (!existsSync4(gitDir)) {
       ui.error(`No .git directory at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const hooksDir = path4.join(gitDir, "hooks");
+    const hooksDir = path5.join(gitDir, "hooks");
     await mkdir2(hooksDir, { recursive: true });
     let installed = 0;
     let skipped = 0;
     for (const name of HOOKS) {
-      const file = path4.join(hooksDir, name);
+      const file = path5.join(hooksDir, name);
       if (existsSync4(file) && !opts.force) {
         const existing = await readFile2(file, "utf8");
         if (!existing.includes(HOOK_MARKER)) {
@@ -675,7 +739,7 @@ function registerInstallHooks(program2) {
 import { spawn } from "child_process";
 import { existsSync as existsSync5 } from "fs";
 import { createRequire } from "module";
-import path5 from "path";
+import path6 from "path";
 import { fileURLToPath } from "url";
 import "commander";
 import { findProjectRoot as findProjectRoot7 } from "@hiveai/core";
@@ -713,13 +777,13 @@ function registerMcp(program2) {
 function locateMcpBin() {
   try {
     const pkgPath = require2.resolve("@hiveai/mcp/package.json");
-    const pkgDir = path5.dirname(pkgPath);
-    const candidate = path5.join(pkgDir, "dist", "index.js");
+    const pkgDir = path6.dirname(pkgPath);
+    const candidate = path6.join(pkgDir, "dist", "index.js");
     if (existsSync5(candidate)) return candidate;
   } catch {
   }
-  const here = path5.dirname(fileURLToPath(import.meta.url));
-  const sibling = path5.resolve(here, "..", "..", "..", "mcp", "dist", "index.js");
+  const here = path6.dirname(fileURLToPath(import.meta.url));
+  const sibling = path6.resolve(here, "..", "..", "..", "mcp", "dist", "index.js");
   if (existsSync5(sibling)) return sibling;
   return null;
 }
@@ -728,7 +792,7 @@ function locateMcpBin() {
 import { spawnSync as spawnSync2 } from "child_process";
 import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
-import path6 from "path";
+import path7 from "path";
 import "commander";
 import {
   DEFAULT_AUTO_PROMOTE_RULE,
@@ -895,7 +959,7 @@ function registerSync(program2) {
       );
     }
     if (opts.injectBridge) {
-      const bridgeFile = opts.bridgeFile ? path6.resolve(opts.bridgeFile) : path6.join(root, "CLAUDE.md");
+      const bridgeFile = opts.bridgeFile ? path7.resolve(opts.bridgeFile) : path7.join(root, "CLAUDE.md");
       const maxInject = Math.max(1, Number(opts.bridgeMaxMemories ?? 5));
       await injectBridge(bridgeFile, paths.memoriesDir, maxInject, root, opts.quiet);
     }
@@ -1001,10 +1065,10 @@ Attends une **confirmation explicite** avant d'agir.
                   paths: [result.file],
                   topic: `dep-bump-${slugParts}`
                 });
-                const teamDir = path6.join(paths.memoriesDir, "team");
+                const teamDir = path7.join(paths.memoriesDir, "team");
                 await mkdir3(teamDir, { recursive: true });
                 await writeFile3(
-                  path6.join(teamDir, `${fm.id}.md`),
+                  path7.join(teamDir, `${fm.id}.md`),
                   serializeMemory({ frontmatter: { ...fm, requires_human_approval: true }, body }),
                   "utf8"
                 );
@@ -1068,10 +1132,10 @@ Attends une **confirmation explicite** avant d'agir.
               paths: [diff.file],
               topic: `contract-breaking-${diff.contract}`
             });
-            const teamDir = path6.join(paths.memoriesDir, "team");
+            const teamDir = path7.join(paths.memoriesDir, "team");
             await mkdir3(teamDir, { recursive: true });
             await writeFile3(
-              path6.join(teamDir, `${fm.id}.md`),
+              path7.join(teamDir, `${fm.id}.md`),
               serializeMemory({ frontmatter: { ...fm, requires_human_approval: true }, body }),
               "utf8"
             );
@@ -1163,11 +1227,11 @@ ${BRIDGE_END}`;
   const startIdx = existing.indexOf(BRIDGE_START);
   const endIdx = existing.indexOf(BRIDGE_END);
   if (startIdx !== -1 && endIdx === -1) {
-    ui.warn(`${path6.relative(root, bridgeFile)}: found ${BRIDGE_START} without ${BRIDGE_END}. Fix the file manually before running --inject-bridge.`);
+    ui.warn(`${path7.relative(root, bridgeFile)}: found ${BRIDGE_START} without ${BRIDGE_END}. Fix the file manually before running --inject-bridge.`);
     return;
   }
   if (startIdx === -1 && endIdx !== -1) {
-    ui.warn(`${path6.relative(root, bridgeFile)}: found ${BRIDGE_END} without ${BRIDGE_START}. Fix the file manually before running --inject-bridge.`);
+    ui.warn(`${path7.relative(root, bridgeFile)}: found ${BRIDGE_END} without ${BRIDGE_START}. Fix the file manually before running --inject-bridge.`);
     return;
   }
   let updated;
@@ -1175,14 +1239,14 @@ ${BRIDGE_END}`;
     updated = existing.slice(0, startIdx) + injected + existing.slice(endIdx + BRIDGE_END.length);
   } else {
     if (!fileExists && !quiet) {
-      ui.info(`Creating ${path6.relative(root, bridgeFile)} with haive memory block.`);
+      ui.info(`Creating ${path7.relative(root, bridgeFile)} with haive memory block.`);
     }
     updated = existing + (existing.endsWith("\n") ? "" : "\n") + "\n" + injected + "\n";
   }
   await writeFile3(bridgeFile, updated, "utf8");
   if (!quiet) {
     console.log(
-      ui.dim(`bridge: injected ${top.length} memor${top.length === 1 ? "y" : "ies"} into ${path6.relative(root, bridgeFile)}`)
+      ui.dim(`bridge: injected ${top.length} memor${top.length === 1 ? "y" : "ies"} into ${path7.relative(root, bridgeFile)}`)
     );
   }
 }
@@ -1209,7 +1273,7 @@ function collectSinceChanges(root, ref) {
 import { createHash } from "crypto";
 import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
 import { existsSync as existsSync7 } from "fs";
-import path7 from "path";
+import path8 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter2,
@@ -1258,7 +1322,7 @@ function registerMemoryAdd(memory2) {
     const inferredTags = autoTagsEnabled ? inferModulesFromPaths(anchorPaths) : [];
     const mergedTags = Array.from(/* @__PURE__ */ new Set([...userTags, ...inferredTags]));
     if (anchorPaths.length > 0) {
-      const missing = anchorPaths.filter((p) => !existsSync7(path7.resolve(root, p)));
+      const missing = anchorPaths.filter((p) => !existsSync7(path8.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}`);
@@ -1323,7 +1387,7 @@ TODO \u2014 write the memory body.
           }
         };
         await writeFile4(topicMatch.filePath, serializeMemory2({ frontmatter: newFrontmatter, body }), "utf8");
-        ui.success(`Updated (topic upsert) ${path7.relative(root, topicMatch.filePath)}`);
+        ui.success(`Updated (topic upsert) ${path8.relative(root, topicMatch.filePath)}`);
         ui.info(`id=${fm.id}  revision=${revisionCount}`);
         return;
       }
@@ -1342,7 +1406,7 @@ TODO \u2014 write the memory body.
       topic: opts.topic
     });
     const file = memoryFilePath(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir4(path7.dirname(file), { recursive: true });
+    await mkdir4(path8.dirname(file), { recursive: true });
     if (existsSync7(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
@@ -1361,7 +1425,7 @@ TODO \u2014 write the memory body.
       }
     }
     await writeFile4(file, serializeMemory2({ frontmatter, body }), "utf8");
-    ui.success(`Created ${path7.relative(root, file)}`);
+    ui.success(`Created ${path8.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)`);
@@ -1392,7 +1456,7 @@ function parseCsv2(value) {
 
 // src/commands/memory-list.ts
 import { existsSync as existsSync8 } from "fs";
-import path8 from "path";
+import path9 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot10, resolveHaivePaths as resolveHaivePaths7 } from "@hiveai/core";
 
@@ -1440,7 +1504,7 @@ function registerMemoryList(memory2) {
       console.log(
         `${ui.bold(fm.id)} ${ui.dim(fm.scope)}/${ui.dim(fm.type)} ${statusBadge}${moduleStr}${tagStr}`
       );
-      console.log(`  ${ui.dim(path8.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path9.relative(root, filePath))}`);
     }
     console.log(ui.dim(`
 ${filtered.length} memor${filtered.length === 1 ? "y" : "ies"}`));
@@ -1477,7 +1541,7 @@ function matchesFilters(loaded, opts) {
 // src/commands/memory-promote.ts
 import { mkdir as mkdir5, unlink, writeFile as writeFile5 } from "fs/promises";
 import { existsSync as existsSync9 } from "fs";
-import path9 from "path";
+import path10 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot11,
@@ -1524,11 +1588,11 @@ function registerMemoryPromote(memory2) {
       body: found.memory.body
     };
     const newPath = memoryFilePath2(paths, "team", updated.frontmatter.id);
-    await mkdir5(path9.dirname(newPath), { recursive: true });
+    await mkdir5(path10.dirname(newPath), { recursive: true });
     await writeFile5(newPath, serializeMemory3(updated), "utf8");
     await unlink(found.filePath);
     ui.success(`Promoted ${id} to team scope (status=proposed)`);
-    ui.info(`Now at ${path9.relative(root, newPath)}`);
+    ui.info(`Now at ${path10.relative(root, newPath)}`);
     console.log(ui.dim(`\u2192 next: haive memory approve ${id}  (validate for team use)`));
   });
 }
@@ -1536,7 +1600,7 @@ function registerMemoryPromote(memory2) {
 // src/commands/memory-approve.ts
 import { existsSync as existsSync10 } from "fs";
 import { writeFile as writeFile6 } from "fs/promises";
-import path10 from "path";
+import path11 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot12,
@@ -1600,14 +1664,14 @@ function registerMemoryApprove(memory2) {
     };
     await writeFile6(found.filePath, serializeMemory4(next), "utf8");
     ui.success(`Approved ${id} (status=validated)`);
-    ui.info(path10.relative(root, found.filePath));
+    ui.info(path11.relative(root, found.filePath));
   });
 }
 
 // src/commands/memory-update.ts
 import { writeFile as writeFile7 } from "fs/promises";
 import { existsSync as existsSync11 } from "fs";
-import path11 from "path";
+import path12 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot13,
@@ -1670,7 +1734,7 @@ function registerMemoryUpdate(memory2) {
       serializeMemory5({ frontmatter: newFrontmatter, body: newBody }),
       "utf8"
     );
-    ui.success(`Updated ${path11.relative(root, loaded.filePath)}`);
+    ui.success(`Updated ${path12.relative(root, loaded.filePath)}`);
     ui.info(`fields: ${updated.join(", ")}`);
   });
 }
@@ -1691,7 +1755,7 @@ function parseCsv3(value) {
 // src/commands/memory-auto-promote.ts
 import { writeFile as writeFile8 } from "fs/promises";
 import { existsSync as existsSync12 } from "fs";
-import path12 from "path";
+import path13 from "path";
 import "commander";
 import {
   DEFAULT_AUTO_PROMOTE_RULE as DEFAULT_AUTO_PROMOTE_RULE2,
@@ -1736,7 +1800,7 @@ function registerMemoryAutoPromote(memory2) {
       console.log(
         `${ui.bold(opts.apply ? "PROMOTE" : "would promote")}  ${mem.frontmatter.id}  ${ui.dim(`reads=${u.read_count} rejections=${u.rejected_count}`)}`
       );
-      console.log(`             ${ui.dim(path12.relative(root, filePath))}`);
+      console.log(`             ${ui.dim(path13.relative(root, filePath))}`);
       if (opts.apply) {
         const next = {
           frontmatter: { ...mem.frontmatter, status: "validated" },
@@ -1755,7 +1819,7 @@ function registerMemoryAutoPromote(memory2) {
 import { spawn as spawn2 } from "child_process";
 import { existsSync as existsSync13 } from "fs";
 import { readFile as readFile5 } from "fs/promises";
-import path13 from "path";
+import path14 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot15,
@@ -1779,7 +1843,7 @@ function registerMemoryEdit(memory2) {
       return;
     }
     const editor = opts.editor ?? process.env.EDITOR ?? process.env.VISUAL ?? "vi";
-    ui.info(`Opening ${path13.relative(root, found.filePath)} with ${editor}\u2026`);
+    ui.info(`Opening ${path14.relative(root, found.filePath)} with ${editor}\u2026`);
     const code = await runEditor(editor, found.filePath);
     if (code !== 0) {
       ui.warn(`Editor exited with status ${code}.`);
@@ -1807,7 +1871,7 @@ function runEditor(editor, file) {
 
 // src/commands/memory-for-files.ts
 import { existsSync as existsSync14 } from "fs";
-import path14 from "path";
+import path15 from "path";
 import "commander";
 import {
   deriveConfidence,
@@ -1929,13 +1993,13 @@ function printGroup(root, label, loaded, usage) {
     const u = getUsage3(usage, fm.id);
     const conf = deriveConfidence(fm, u);
     console.log(`${ui.bold(fm.id)}  ${ui.dim(`${fm.scope}/${fm.type}`)}  ${ui.bold(conf)}`);
-    console.log(`  ${ui.dim(path14.relative(root, filePath))}`);
+    console.log(`  ${ui.dim(path15.relative(root, filePath))}`);
   }
 }
 
 // src/commands/memory-hot.ts
 import { existsSync as existsSync15 } from "fs";
-import path15 from "path";
+import path16 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot17,
@@ -1975,7 +2039,7 @@ function registerMemoryHot(memory2) {
       console.log(
         `${ui.bold(fm.id)}  ${ui.dim(`${fm.scope}/${fm.type}`)}  ${ui.bold(fm.status)}  ${ui.dim(`reads=${u.read_count} rejections=${u.rejected_count}`)}`
       );
-      console.log(`  ${ui.dim(path15.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path16.relative(root, filePath))}`);
     }
     ui.info(
       `${candidates.length} hot \u2014 promote drafts with \`haive memory promote <id>\`, then \`haive memory auto-promote --apply\`.`
@@ -1986,7 +2050,7 @@ function registerMemoryHot(memory2) {
 // src/commands/memory-tried.ts
 import { mkdir as mkdir6, writeFile as writeFile9 } from "fs/promises";
 import { existsSync as existsSync16 } from "fs";
-import path16 from "path";
+import path17 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter3,
@@ -2037,14 +2101,14 @@ function registerMemoryTried(memory2) {
     }
     const body = lines.join("\n") + "\n";
     const file = memoryFilePath3(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir6(path16.dirname(file), { recursive: true });
+    await mkdir6(path17.dirname(file), { recursive: true });
     if (existsSync16(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
       return;
     }
     await writeFile9(file, serializeMemory7({ frontmatter, body }), "utf8");
-    ui.success(`Recorded: ${path16.relative(root, file)}`);
+    ui.success(`Recorded: ${path17.relative(root, file)}`);
     ui.info(`id=${frontmatter.id}  type=attempt  status=validated (auto-approved)`);
   });
 }
@@ -2055,7 +2119,7 @@ function parseCsv4(value) {
 
 // src/commands/memory-pending.ts
 import { existsSync as existsSync17 } from "fs";
-import path17 from "path";
+import path18 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot19,
@@ -2095,7 +2159,7 @@ function registerMemoryPending(memory2) {
       console.log(
         `${ui.bold(fm.id)}  ${ui.dim(`${fm.scope}/${fm.type}`)}  ${ui.dim(`age=${ageStr} reads=${u.read_count} rejections=${u.rejected_count}`)}`
       );
-      console.log(`  ${ui.dim(path17.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path18.relative(root, filePath))}`);
     }
     ui.info(`${proposed.length} pending`);
   });
@@ -2103,7 +2167,7 @@ function registerMemoryPending(memory2) {
 
 // src/commands/memory-query.ts
 import { existsSync as existsSync18 } from "fs";
-import path18 from "path";
+import path19 from "path";
 import "commander";
 import {
   extractSnippet,
@@ -2160,7 +2224,7 @@ function registerMemoryQuery(memory2) {
       const fm = mem.frontmatter;
       const statusBadge = ui.statusBadge(fm.status);
       console.log(`${ui.bold(fm.id)} ${ui.dim(fm.scope)} ${statusBadge}`);
-      console.log(`  ${ui.dim(path18.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path19.relative(root, filePath))}`);
       const snippet = extractSnippet(mem.body, snippetNeedle);
       if (snippet) console.log(`  ${snippet}`);
     }
@@ -2230,7 +2294,7 @@ function registerMemoryReject(memory2) {
 // src/commands/memory-rm.ts
 import { existsSync as existsSync20 } from "fs";
 import { unlink as unlink2 } from "fs/promises";
-import path19 from "path";
+import path20 from "path";
 import { createInterface } from "readline/promises";
 import "commander";
 import {
@@ -2255,7 +2319,7 @@ function registerMemoryRm(memory2) {
       process.exitCode = 1;
       return;
     }
-    const rel = path19.relative(root, found.filePath);
+    const rel = path20.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();
@@ -2281,7 +2345,7 @@ function registerMemoryRm(memory2) {
 // src/commands/memory-show.ts
 import { existsSync as existsSync21 } from "fs";
 import { readFile as readFile6 } from "fs/promises";
-import path20 from "path";
+import path21 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence2,
@@ -2323,7 +2387,7 @@ function registerMemoryShow(memory2) {
     if (fm.verified_at) console.log(`${ui.dim("verified:")}   ${fm.verified_at}`);
     if (fm.stale_reason) console.log(`${ui.dim("stale:")}      ${fm.stale_reason}`);
     console.log(`${ui.dim("reads:")}      ${u.read_count}  ${ui.dim("rejections:")} ${u.rejected_count}`);
-    console.log(`${ui.dim("file:")}       ${path20.relative(root, found.filePath)}`);
+    console.log(`${ui.dim("file:")}       ${path21.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}`);
@@ -2339,7 +2403,7 @@ function registerMemoryShow(memory2) {
 
 // src/commands/memory-stats.ts
 import { existsSync as existsSync22 } from "fs";
-import path21 from "path";
+import path22 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence3,
@@ -2377,7 +2441,7 @@ function registerMemoryStats(memory2) {
       console.log(
         `  ${ui.dim("status:")} ${fm.status}  ${ui.dim("reads:")} ${u.read_count}  ${ui.dim("rejections:")} ${u.rejected_count}`
       );
-      console.log(`  ${ui.dim(path21.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path22.relative(root, filePath))}`);
     }
   });
 }
@@ -2385,7 +2449,7 @@ function registerMemoryStats(memory2) {
 // src/commands/memory-verify.ts
 import { writeFile as writeFile11 } from "fs/promises";
 import { existsSync as existsSync23 } from "fs";
-import path22 from "path";
+import path23 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot25,
@@ -2422,7 +2486,7 @@ function registerMemoryVerify(memory2) {
         anchorlessIds.push(mem.frontmatter.id);
         continue;
       }
-      const rel = path22.relative(root, filePath);
+      const rel = path23.relative(root, filePath);
       if (result.stale) {
         staleCount++;
         console.log(`${ui.bold("STALE")}  ${mem.frontmatter.id}`);
@@ -2538,7 +2602,7 @@ function registerMemoryImport(memory2) {
 // src/commands/memory-import-changelog.ts
 import { existsSync as existsSync25 } from "fs";
 import { readFile as readFile8, mkdir as mkdir7, writeFile as writeFile12 } from "fs/promises";
-import path23 from "path";
+import path24 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter4,
@@ -2609,7 +2673,7 @@ function registerMemoryImportChangelog(memory2) {
   ).option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot27(opts.dir);
     const paths = resolveHaivePaths24(root);
-    const changelogPath = path23.resolve(root, opts.fromChangelog);
+    const changelogPath = path24.resolve(root, opts.fromChangelog);
     if (!existsSync25(changelogPath)) {
       ui.error(`CHANGELOG not found: ${changelogPath}`);
       process.exitCode = 1;
@@ -2629,9 +2693,9 @@ function registerMemoryImportChangelog(memory2) {
         entries = entries.filter((e) => requested.includes(e.version));
       }
     }
-    const pkgName = opts.package ?? path23.basename(path23.dirname(changelogPath));
+    const pkgName = opts.package ?? path24.basename(path24.dirname(changelogPath));
     const scope = opts.scope ?? "team";
-    const teamDir = path23.join(paths.memoriesDir, scope);
+    const teamDir = path24.join(paths.memoriesDir, scope);
     await mkdir7(teamDir, { recursive: true });
     let saved = 0;
     for (const entry of entries) {
@@ -2654,7 +2718,7 @@ function registerMemoryImportChangelog(memory2) {
         lines.push("");
       }
       lines.push(
-        `**Source:** \`${path23.relative(root, changelogPath)}\`  
+        `**Source:** \`${path24.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, "-")}`;
@@ -2669,11 +2733,11 @@ function registerMemoryImportChangelog(memory2) {
           pkgName.replace(/[^a-z0-9]/gi, "-").toLowerCase(),
           `v${entry.version}`
         ],
-        paths: [path23.relative(root, changelogPath)],
+        paths: [path24.relative(root, changelogPath)],
         topic: `changelog-${pkgName}-${entry.version}`
       });
       await writeFile12(
-        path23.join(teamDir, `${fm.id}.md`),
+        path24.join(teamDir, `${fm.id}.md`),
         serializeMemory10({ frontmatter: fm, body: lines.join("\n") }),
         "utf8"
       );
@@ -2698,7 +2762,7 @@ ${ui.bold(`Imported ${saved} changelog entr${saved === 1 ? "y" : "ies"} from ${p
 // src/commands/memory-digest.ts
 import { existsSync as existsSync26 } from "fs";
 import { writeFile as writeFile13 } from "fs/promises";
-import path24 from "path";
+import path25 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence4,
@@ -2793,7 +2857,7 @@ function registerMemoryDigest(program2) {
     );
     const digest = lines.join("\n");
     if (opts.out) {
-      const outPath = path24.resolve(process.cwd(), opts.out);
+      const outPath = path25.resolve(process.cwd(), opts.out);
       await writeFile13(outPath, digest, "utf8");
       ui.success(`Digest written to ${opts.out}  (${recent.length} memor${recent.length === 1 ? "y" : "ies"})`);
     } else {
@@ -2805,7 +2869,7 @@ function registerMemoryDigest(program2) {
 // src/commands/session-end.ts
 import { writeFile as writeFile14, mkdir as mkdir8 } from "fs/promises";
 import { existsSync as existsSync27 } from "fs";
-import path25 from "path";
+import path26 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter5,
@@ -2873,7 +2937,7 @@ function registerSessionEnd(session2) {
     const body = buildRecapBody(opts);
     const topic = recapTopic(scope, opts.module);
     const filesTouched = parseCsv5(opts.files);
-    const missingPaths = filesTouched.filter((p) => !existsSync27(path25.resolve(root, p)));
+    const missingPaths = filesTouched.filter((p) => !existsSync27(path26.resolve(root, p)));
     if (missingPaths.length > 0) {
       ui.warn(`Anchor path${missingPaths.length > 1 ? "s" : ""} not found in project (will be stale):`);
       for (const p of missingPaths) ui.warn(`  \u2717 ${p}`);
@@ -2896,7 +2960,7 @@ function registerSessionEnd(session2) {
         };
         await writeFile14(topicMatch.filePath, serializeMemory11({ frontmatter: newFrontmatter, body }), "utf8");
         ui.success(`Session recap updated (revision #${revisionCount})`);
-        ui.info(`id=${fm.id}  file=${path25.relative(root, topicMatch.filePath)}`);
+        ui.info(`id=${fm.id}  file=${path26.relative(root, topicMatch.filePath)}`);
         return;
       }
     }
@@ -2911,10 +2975,10 @@ function registerSessionEnd(session2) {
       status: "validated"
     });
     const file = memoryFilePath4(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir8(path25.dirname(file), { recursive: true });
+    await mkdir8(path26.dirname(file), { recursive: true });
     await writeFile14(file, serializeMemory11({ frontmatter, body }), "utf8");
     ui.success(`Session recap created`);
-    ui.info(`id=${frontmatter.id}  scope=${scope}  file=${path25.relative(root, file)}`);
+    ui.info(`id=${frontmatter.id}  scope=${scope}  file=${path26.relative(root, file)}`);
     ui.info("Next session: call `get_briefing` \u2014 the recap will be surfaced automatically.");
   });
 }
@@ -2926,7 +2990,7 @@ function parseCsv5(value) {
 // src/commands/snapshot.ts
 import { existsSync as existsSync28 } from "fs";
 import { readdir } from "fs/promises";
-import path26 from "path";
+import path27 from "path";
 import "commander";
 import {
   diffContract,
@@ -2965,7 +3029,7 @@ function registerSnapshot(program2) {
       return;
     }
     if (opts.list) {
-      const contractsDir = path26.join(paths.haiveDir, "contracts");
+      const contractsDir = path27.join(paths.haiveDir, "contracts");
       if (!existsSync28(contractsDir)) {
         console.log(ui.dim("No contract snapshots found."));
         return;
@@ -3021,7 +3085,7 @@ function registerSnapshot(program2) {
       return;
     }
     const contractPath = opts.contract;
-    const name = opts.name ?? path26.basename(contractPath, path26.extname(contractPath));
+    const name = opts.name ?? path27.basename(contractPath, path27.extname(contractPath));
     const format = opts.format ?? detectFormat(contractPath) ?? "openapi";
     const contract = { name, path: contractPath, format };
     try {
@@ -3076,8 +3140,8 @@ async function runDiff(root, haiveDir, contract) {
   }
 }
 function detectFormat(filePath) {
-  const ext = path26.extname(filePath).toLowerCase();
-  const base = path26.basename(filePath).toLowerCase();
+  const ext = path27.extname(filePath).toLowerCase();
+  const base = path27.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";
@@ -3092,7 +3156,7 @@ function detectFormat(filePath) {
 // src/commands/hub.ts
 import { existsSync as existsSync29 } from "fs";
 import { mkdir as mkdir9, readFile as readFile9, writeFile as writeFile15, copyFile } from "fs/promises";
-import path27 from "path";
+import path28 from "path";
 import { spawnSync as spawnSync3 } from "child_process";
 import "commander";
 import {
@@ -3111,7 +3175,7 @@ function registerHub(program2) {
   hub.command("init <hubPath>").description(
     "Initialize a new team-knowledge hub repo at <hubPath>.\n\n  Creates a git repo with a .ai/ directory structure ready for shared memories.\n\n  Example:\n    haive hub init ../team-hub\n    haive hub init /srv/git/team-knowledge\n"
   ).action(async (hubPath) => {
-    const absPath = path27.resolve(hubPath);
+    const absPath = path28.resolve(hubPath);
     await mkdir9(absPath, { recursive: true });
     const gitCheck = spawnSync3("git", ["rev-parse", "--git-dir"], { cwd: absPath });
     if (gitCheck.status !== 0) {
@@ -3122,10 +3186,10 @@ function registerHub(program2) {
         return;
       }
     }
-    const sharedDir = path27.join(absPath, ".ai", "memories", "shared");
+    const sharedDir = path28.join(absPath, ".ai", "memories", "shared");
     await mkdir9(sharedDir, { recursive: true });
     await writeFile15(
-      path27.join(absPath, ".ai", "README.md"),
+      path28.join(absPath, ".ai", "README.md"),
       `# hAIve Team Knowledge Hub
 
 This repo is a shared knowledge hub for hAIve.
@@ -3147,7 +3211,7 @@ haive hub pull   # import into a project
       "utf8"
     );
     await writeFile15(
-      path27.join(absPath, ".gitignore"),
+      path28.join(absPath, ".gitignore"),
       ".ai/.cache/\n.ai/memories/personal/\n",
       "utf8"
     );
@@ -3162,7 +3226,7 @@ haive hub pull   # import into a project
         `
 Next steps:
   1. Add hubPath to your project's .ai/haive.config.json:
-       { "hubPath": "${path27.relative(process.cwd(), absPath)}" }
+       { "hubPath": "${path28.relative(process.cwd(), absPath)}" }
   2. Run \`haive hub push\` to publish your shared memories
   3. Share ${absPath} with teammates (git remote, NFS, etc.)
 `
@@ -3191,14 +3255,14 @@ Next steps:
       process.exitCode = 1;
       return;
     }
-    const hubRoot = path27.resolve(root, config.hubPath);
+    const hubRoot = path28.resolve(root, config.hubPath);
     if (!existsSync29(hubRoot)) {
       ui.error(`Hub not found at ${hubRoot}. Run \`haive hub init ${config.hubPath}\` first.`);
       process.exitCode = 1;
       return;
     }
-    const projectName = path27.basename(root);
-    const destDir = path27.join(hubRoot, ".ai", "memories", "shared", projectName);
+    const projectName = path28.basename(root);
+    const destDir = path28.join(hubRoot, ".ai", "memories", "shared", projectName);
     await mkdir9(destDir, { recursive: true });
     const all = await loadMemoriesFromDir7(paths.memoriesDir);
     const shared = all.filter(
@@ -3217,7 +3281,7 @@ Next steps:
     for (const { memory: memory2 } of shared) {
       const fm = memory2.frontmatter;
       const fileName = `${fm.id}.md`;
-      const destPath = path27.join(destDir, fileName);
+      const destPath = path28.join(destDir, fileName);
       await writeFile15(destPath, serializeMemory12(memory2), "utf8");
       pushed++;
     }
@@ -3225,7 +3289,7 @@ Next steps:
     console.log(ui.dim(`  Location: ${destDir}`));
     if (opts.commit) {
       const message = opts.message ?? `haive: sync shared memories from ${projectName} (${pushed} memories)`;
-      spawnSync3("git", ["add", path27.join(".ai", "memories", "shared", projectName)], {
+      spawnSync3("git", ["add", path28.join(".ai", "memories", "shared", projectName)], {
         cwd: hubRoot
       });
       const commit = spawnSync3("git", ["commit", "-m", message], {
@@ -3260,13 +3324,13 @@ Next steps:
       process.exitCode = 1;
       return;
     }
-    const hubRoot = path27.resolve(root, config.hubPath);
-    const hubSharedDir = path27.join(hubRoot, ".ai", "memories", "shared");
+    const hubRoot = path28.resolve(root, config.hubPath);
+    const hubSharedDir = path28.join(hubRoot, ".ai", "memories", "shared");
     if (!existsSync29(hubSharedDir)) {
       ui.warn("Hub has no shared memories yet. Run `haive hub push` from other projects first.");
       return;
     }
-    const projectName = path27.basename(root);
+    const projectName = path28.basename(root);
     const { readdir: readdir2 } = await import("fs/promises");
     const projectDirs = (await readdir2(hubSharedDir, { withFileTypes: true })).filter((d) => d.isDirectory() && d.name !== projectName).map((d) => d.name);
     if (projectDirs.length === 0) {
@@ -3276,16 +3340,16 @@ Next steps:
     let totalImported = 0;
     let totalUpdated = 0;
     for (const sourceName of projectDirs) {
-      const sourceDir = path27.join(hubSharedDir, sourceName);
-      const destDir = path27.join(paths.memoriesDir, "shared", sourceName);
+      const sourceDir = path28.join(hubSharedDir, sourceName);
+      const destDir = path28.join(paths.memoriesDir, "shared", sourceName);
       await mkdir9(destDir, { recursive: true });
       const sourceFiles = (await readdir2(sourceDir)).filter((f) => f.endsWith(".md"));
       const { loadMemoriesFromDir: loadDir } = await import("@hiveai/core");
       const existingInDest = await loadDir(destDir);
       const existingIds = new Set(existingInDest.map(({ memory: memory2 }) => memory2.frontmatter.id));
       for (const file of sourceFiles) {
-        const srcPath = path27.join(sourceDir, file);
-        const destPath = path27.join(destDir, file);
+        const srcPath = path28.join(sourceDir, file);
+        const destPath = path28.join(destDir, file);
         const fileContent = await readFile9(srcPath, "utf8");
         const alreadyTagged = fileContent.includes(`cross-repo:${sourceName}`);
         if (!alreadyTagged) {
@@ -3316,14 +3380,14 @@ Next steps:
     console.log(
       `  hubPath: ${config.hubPath ? ui.green(config.hubPath) : ui.dim("not configured")}`
     );
-    const sharedDir = path27.join(paths.memoriesDir, "shared");
+    const sharedDir = path28.join(paths.memoriesDir, "shared");
     if (existsSync29(sharedDir)) {
       const { readdir: readdir2 } = await import("fs/promises");
       const sources = (await readdir2(sharedDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
       console.log(`
   Imported from ${sources.length} source(s):`);
       for (const src of sources) {
-        const files = (await readdir2(path27.join(sharedDir, src))).filter((f) => f.endsWith(".md"));
+        const files = (await readdir2(path28.join(sharedDir, src))).filter((f) => f.endsWith(".md"));
         console.log(`    ${src}: ${files.length} memor${files.length === 1 ? "y" : "ies"}`);
       }
     } else {
@@ -3344,9 +3408,944 @@ Next steps:
   });
 }
 
+// src/commands/stats.ts
+import "commander";
+import {
+  aggregateUsage,
+  findProjectRoot as findProjectRoot32,
+  parseSince,
+  readUsageEvents,
+  resolveHaivePaths as resolveHaivePaths29,
+  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);
+    const size = await usageLogSize(paths);
+    if (!size.exists) {
+      if (opts.json) {
+        console.log(JSON.stringify({ error: "no_usage_log" }));
+        return;
+      }
+      ui.warn(
+        `No usage log found at ${root}. Stats are populated as the MCP server logs each tool call. Run a session first, then re-check.`
+      );
+      return;
+    }
+    const events = await readUsageEvents(paths);
+    const since = parseSince(opts.since);
+    const aggregate = aggregateUsage(events, since ?? void 0);
+    if (opts.json) {
+      console.log(JSON.stringify(aggregate, null, 2));
+      return;
+    }
+    const window = opts.since ?? "all time";
+    console.log(ui.bold(`hAIve usage stats (${window})`));
+    console.log(
+      `  ${ui.dim("total calls:")} ${aggregate.total}  ${ui.dim("unique tools:")} ${aggregate.by_tool.length}  ${ui.dim("log lines:")} ${size.lines}`
+    );
+    if (aggregate.window_start) {
+      console.log(
+        `  ${ui.dim("window:")} ${aggregate.window_start.slice(0, 19)} \u2192 ${aggregate.window_end?.slice(0, 19)}`
+      );
+    }
+    if (aggregate.by_tool.length === 0) {
+      ui.info(`No events in window. Try a wider --since (current: ${window}).`);
+      return;
+    }
+    console.log();
+    console.log(ui.bold("Top tools:"));
+    const maxCount = aggregate.by_tool[0]?.count ?? 1;
+    for (const t of aggregate.by_tool.slice(0, 20)) {
+      const bar = "\u2588".repeat(Math.max(1, Math.round(t.count / maxCount * 30)));
+      const pct = (t.count / aggregate.total * 100).toFixed(1);
+      console.log(
+        `  ${t.tool.padEnd(28)} ${ui.green(bar)} ${ui.bold(String(t.count))} ${ui.dim(`(${pct}%, last ${t.last_used.slice(0, 19)})`)}`
+      );
+    }
+  });
+}
+
+// src/commands/bench.ts
+import { performance } from "perf_hooks";
+import "commander";
+import {
+  estimateTokens,
+  findProjectRoot as findProjectRoot33,
+  resolveHaivePaths as resolveHaivePaths30
+} from "@hiveai/core";
+import {
+  antiPatternsCheck,
+  codeMapTool,
+  codeSearch,
+  getBriefing,
+  getRecap,
+  memRelevantTo
+} 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 ctx = { paths };
+    const task = opts.task ?? "audit dependencies for security risks";
+    const scenarios = [
+      async () => {
+        const t0 = performance.now();
+        const out = await getBriefing(
+          {
+            task,
+            files: [],
+            max_tokens: 4e3,
+            max_memories: 8,
+            include_project_context: true,
+            include_module_contexts: true,
+            semantic: true,
+            include_stale: false,
+            track: false,
+            format: "compact",
+            symbols: [],
+            min_semantic_score: 0
+          },
+          ctx
+        );
+        return summarize("get_briefing(compact)", t0, out, [
+          out.low_value ? "low_value (cold-start)" : `${out.memories.length} memories`,
+          `search=${out.search_mode}`
+        ]);
+      },
+      async () => {
+        const t0 = performance.now();
+        const out = await codeMapTool({ paths: [], max_files: 40, max_tokens: 2e3 }, ctx);
+        return summarize("code_map(budget=2k)", t0, out, [
+          out.available ? `${out.files.length}/${out.total_files} files` : "unavailable",
+          out.budget_clipped ? "clipped" : "fits"
+        ]);
+      },
+      async () => {
+        const t0 = performance.now();
+        const out = await getRecap({ scope: "any" }, ctx);
+        return summarize("get_recap", t0, out, [
+          out.recap ? `${out.recap.id.slice(0, 30)}\u2026` : "no recap"
+        ]);
+      },
+      async () => {
+        const t0 = performance.now();
+        const out = await memRelevantTo(
+          { task, files: [], limit: 8, min_semantic_score: 0.25, format: "compact" },
+          ctx
+        );
+        return summarize("mem_relevant_to", t0, out, [
+          `${out.memories.length} memories`,
+          `search=${out.search_mode}`
+        ]);
+      },
+      async () => {
+        const t0 = performance.now();
+        const out = await codeSearch({ query: task, k: 5, min_score: 0.2 }, ctx);
+        return summarize("code_search", t0, out, [
+          out.available ? `${out.hits.length} hits` : "needs index (haive index code-search)"
+        ]);
+      },
+      async () => {
+        const t0 = performance.now();
+        const out = await antiPatternsCheck({ diff: task, paths: [], limit: 5, semantic: true }, ctx);
+        return summarize("anti_patterns_check", t0, out, [
+          `${out.warnings.length}/${out.scanned} warn`
+        ]);
+      }
+    ];
+    const results = [];
+    for (const run of scenarios) {
+      try {
+        results.push(await run());
+      } catch (err) {
+        results.push({
+          name: "(error)",
+          ok: false,
+          latency_ms: 0,
+          payload_tokens: 0,
+          notes: [err instanceof Error ? err.message : String(err)]
+        });
+      }
+    }
+    if (opts.json) {
+      console.log(JSON.stringify({ root, task, scenarios: results }, null, 2));
+      return;
+    }
+    console.log(ui.bold(`hAIve bench \u2014 ${root}`));
+    console.log(ui.dim(`task: ${task}`));
+    console.log();
+    console.log(
+      `${"scenario".padEnd(28)} ${"latency".padStart(8)}  ${"tokens".padStart(7)}  notes`
+    );
+    console.log("\u2500".repeat(88));
+    for (const r of results) {
+      const status = r.ok ? ui.green("\u2713") : ui.red("\u2717");
+      console.log(
+        `${status} ${r.name.padEnd(26)} ${`${r.latency_ms.toFixed(0)} ms`.padStart(8)}  ${String(r.payload_tokens).padStart(7)}  ${r.notes.join("; ")}`
+      );
+    }
+    const totalTokens = results.reduce((s, r) => s + r.payload_tokens, 0);
+    const totalMs = results.reduce((s, r) => s + r.latency_ms, 0);
+    console.log("\u2500".repeat(88));
+    console.log(
+      `${ui.dim("totals:")}                       ${`${totalMs.toFixed(0)} ms`.padStart(8)}  ${String(totalTokens).padStart(7)}`
+    );
+  });
+}
+function summarize(name, t0, payload, notes) {
+  return {
+    name,
+    ok: true,
+    latency_ms: performance.now() - t0,
+    payload_tokens: estimateTokens(JSON.stringify(payload)),
+    notes
+  };
+}
+
+// src/commands/memory-suggest.ts
+import { mkdir as mkdir10, writeFile as writeFile16 } from "fs/promises";
+import { existsSync as existsSync30 } from "fs";
+import path29 from "path";
+import "commander";
+import {
+  aggregateUsage as aggregateUsage2,
+  buildFrontmatter as buildFrontmatter6,
+  findProjectRoot as findProjectRoot34,
+  loadMemoriesFromDir as loadMemoriesFromDir8,
+  memoryFilePath as memoryFilePath5,
+  parseSince as parseSince2,
+  readUsageEvents as readUsageEvents2,
+  resolveHaivePaths as resolveHaivePaths31,
+  serializeMemory as serializeMemory13
+} from "@hiveai/core";
+var SEARCH_TOOLS = /* @__PURE__ */ new Set([
+  "mem_search",
+  "code_search",
+  "mem_relevant_to",
+  "get_briefing"
+]);
+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 events = await readUsageEvents2(paths);
+    if (events.length === 0) {
+      if (opts.json) {
+        console.log(JSON.stringify({ suggestions: [] }));
+        return;
+      }
+      ui.warn("No usage log entries yet. Suggestions appear after the MCP server records some calls.");
+      return;
+    }
+    const since = parseSince2(opts.since);
+    const minCount = Math.max(1, parseInt(opts.min ?? "2", 10));
+    const cutoff = since ? since.getTime() : 0;
+    const queries = /* @__PURE__ */ new Map();
+    for (const e of events) {
+      if (cutoff && Date.parse(e.at) < cutoff) continue;
+      if (!SEARCH_TOOLS.has(e.tool)) continue;
+      const key = (e.summary ?? "").toLowerCase().trim();
+      if (!key) continue;
+      const prior = queries.get(key);
+      if (prior) {
+        prior.count++;
+        prior.tools.add(e.tool);
+        if (e.at > prior.last) prior.last = e.at;
+      } else {
+        queries.set(key, { count: 1, tools: /* @__PURE__ */ new Set([e.tool]), last: e.at });
+      }
+    }
+    const suggestions = [...queries.entries()].filter(([, v]) => v.count >= minCount).map(([query, v]) => ({
+      query,
+      count: v.count,
+      tools: [...v.tools].sort(),
+      last_used: v.last,
+      reason: chooseReason(v.tools, v.count),
+      inferred_type: inferType(v.tools, query)
+    })).sort((a, b) => b.count - a.count);
+    if (opts.autoSave) {
+      const topN = Math.max(1, parseInt(opts.topN ?? "3", 10));
+      const scope = opts.scope === "team" ? "team" : "personal";
+      const top = suggestions.slice(0, topN);
+      if (top.length === 0) {
+        ui.warn(`No suggestions met --min=${minCount} \u2014 nothing to draft.`);
+        return;
+      }
+      const created = [];
+      const skipped = [];
+      const existing = existsSync30(paths.memoriesDir) ? await loadMemoriesFromDir8(paths.memoriesDir) : [];
+      for (const s of top) {
+        const slug = slugify(s.query);
+        if (!slug) {
+          skipped.push({ query: s.query, reason: "could not derive a slug" });
+          continue;
+        }
+        const dup = existing.find(({ memory: memory3 }) => memory3.frontmatter.id.endsWith(`-${slug}`));
+        if (dup) {
+          skipped.push({ query: s.query, reason: `similar memory already exists (${dup.memory.frontmatter.id})` });
+          continue;
+        }
+        const fm = buildFrontmatter6({
+          type: s.inferred_type,
+          slug,
+          scope,
+          tags: ["auto-suggested", ...s.tools],
+          paths: [],
+          symbols: []
+        });
+        fm.status = "draft";
+        const body = renderTemplate(s);
+        const file = memoryFilePath5(paths, fm.scope, fm.id, fm.module);
+        await mkdir10(path29.dirname(file), { recursive: true });
+        if (existsSync30(file)) {
+          skipped.push({ query: s.query, reason: `file already exists at ${path29.relative(root, file)}` });
+          continue;
+        }
+        await writeFile16(file, serializeMemory13({ frontmatter: fm, body }), "utf8");
+        created.push({ id: fm.id, file: path29.relative(root, file), query: s.query });
+      }
+      if (opts.json) {
+        console.log(JSON.stringify({ created, skipped }, null, 2));
+        return;
+      }
+      for (const c of created) {
+        ui.success(`Drafted ${c.id} \u2192 ${c.file}`);
+        console.log(`     ${ui.dim("from query:")} ${truncate(c.query, 60)}`);
+      }
+      for (const s of skipped) {
+        ui.warn(`Skipped: ${truncate(s.query, 50)} \u2014 ${s.reason}`);
+      }
+      if (created.length > 0) {
+        console.log();
+        ui.info("Drafts are status=draft \u2014 edit them, then `haive memory promote` to validate.");
+      }
+      return;
+    }
+    if (opts.json) {
+      console.log(JSON.stringify({ window: opts.since, suggestions }, null, 2));
+      return;
+    }
+    const totals = aggregateUsage2(events, since ?? void 0);
+    console.log(ui.bold(`hAIve memory suggestions (${opts.since ?? "all time"})`));
+    console.log(
+      ui.dim(`scanned ${totals.total} events, ${suggestions.length} repeated queries (\u2265${minCount})`)
+    );
+    console.log();
+    if (suggestions.length === 0) {
+      ui.info("No recurring searches yet \u2014 nothing to suggest.");
+      return;
+    }
+    for (const s of suggestions.slice(0, 30)) {
+      console.log(
+        `  ${ui.bold(`\xD7${s.count}`)} ${ui.dim(`[${s.tools.join(",")}]`)}  ${truncate(s.query, 70)}`
+      );
+      console.log(`     ${ui.dim("\u2192")} ${s.reason}`);
+    }
+    console.log();
+    ui.info("Run with --auto-save to draft the top-3 as draft memories.");
+  });
+}
+function chooseReason(tools, count) {
+  if (tools.has("code_search")) {
+    return `${count} agents searched the code for this \u2014 consider mem_save (architecture/decision) capturing where it lives.`;
+  }
+  if (tools.has("mem_search") || tools.has("mem_relevant_to")) {
+    return `${count} agents asked but the memory layer had no clear answer \u2014 consider mem_save (convention/decision/gotcha).`;
+  }
+  return `${count} agents asked the briefing for this \u2014 consider promoting the answer to a team memory.`;
+}
+function inferType(tools, query) {
+  const q = query.toLowerCase();
+  if (q.includes("bug") || q.includes("error") || q.includes("crash") || q.includes("trap")) return "gotcha";
+  if (q.includes("decid") || q.includes("why") || q.includes("choose") || q.includes("vs ")) return "decision";
+  if (tools.has("code_search") && (q.includes("where") || q.includes("location") || q.includes("structure"))) {
+    return "architecture";
+  }
+  return "convention";
+}
+function renderTemplate(s) {
+  return [
+    `# Auto-drafted from recurring searches`,
+    ``,
+    `> This memory was drafted by \`haive memory suggest --auto-save\` because`,
+    `> agents searched for this **${s.count} times** in the recent window`,
+    `> via ${s.tools.join(", ")}.`,
+    ``,
+    `## Query`,
+    ``,
+    `> ${s.query}`,
+    ``,
+    `## What to fill in`,
+    ``,
+    `Replace this section with the actual answer the team keeps re-discovering:`,
+    ``,
+    `- **What** \u2014 the convention / decision / gotcha (1-3 sentences)`,
+    `- **Why** \u2014 the rationale or root cause`,
+    `- **How to apply** \u2014 what an agent should do when this comes up again`,
+    ``,
+    `Then run \`haive memory promote ${truncate(s.query, 30)}\` to mark it validated.`
+  ].join("\n");
+}
+function slugify(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+}
+function truncate(text, max) {
+  if (text.length <= max) return text;
+  return text.slice(0, max - 1) + "\u2026";
+}
+
+// src/commands/memory-archive.ts
+import { existsSync as existsSync31 } from "fs";
+import { writeFile as writeFile17 } from "fs/promises";
+import path30 from "path";
+import "commander";
+import {
+  findProjectRoot as findProjectRoot35,
+  getUsage as getUsage9,
+  loadMemoriesFromDir as loadMemoriesFromDir9,
+  loadUsageIndex as loadUsageIndex11,
+  resolveHaivePaths as resolveHaivePaths32,
+  serializeMemory as serializeMemory14
+} from "@hiveai/core";
+var MS_PER_DAY = 24 * 60 * 60 * 1e3;
+function registerMemoryArchive(memory2) {
+  memory2.command("archive").description(
+    "Archive obsolete memories: marks status='deprecated' for memories not read in N days\n  whose anchored paths have all disappeared (or have no anchor at all).\n\n  Defaults to a DRY RUN \u2014 pass --apply to actually rewrite files.\n  Targets `attempt` memories by default since they age the fastest.\n\n  Recover later with `haive memory edit <id>` to set status back to validated."
+  ).option("--since <window>", "minimum age since last read (e.g. '180d', '6m')", "180d").option("--type <type>", "limit to a memory type (default 'attempt'). Pass 'all' to scan all types.", "attempt").option("--apply", "actually rewrite files (default: dry run)", false).option("--json", "emit JSON instead of human-readable output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
+    const root = findProjectRoot35(opts.dir);
+    const paths = resolveHaivePaths32(root);
+    if (!existsSync31(paths.memoriesDir)) {
+      ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
+      process.exitCode = 1;
+      return;
+    }
+    const minDays = parseDays(opts.since ?? "180d");
+    if (minDays === null) {
+      ui.error(`Invalid --since value: ${opts.since}. Use formats like '180d', '6m', '1y'.`);
+      process.exitCode = 1;
+      return;
+    }
+    const cutoff = Date.now() - minDays * MS_PER_DAY;
+    const all = await loadMemoriesFromDir9(paths.memoriesDir);
+    const usage = await loadUsageIndex11(paths);
+    const typeFilter = opts.type === "all" ? null : opts.type ?? "attempt";
+    const candidates = [];
+    for (const { memory: mem, filePath } of all) {
+      const fm = mem.frontmatter;
+      if (typeFilter && fm.type !== typeFilter) continue;
+      if (fm.status === "deprecated" || fm.status === "rejected") continue;
+      const hasAnyAnchor = fm.anchor.paths.length + fm.anchor.symbols.length > 0;
+      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync31(path30.join(paths.root, p)));
+      const isAnchorless = !hasAnyAnchor;
+      if (!isAnchorless && !allPathsGone) continue;
+      const u = getUsage9(usage, fm.id);
+      const lastSeen = u.last_read_at ?? fm.created_at;
+      if (Date.parse(lastSeen) >= cutoff) continue;
+      candidates.push({
+        id: fm.id,
+        type: fm.type,
+        status: fm.status,
+        last_seen: lastSeen,
+        reason: isAnchorless ? `anchorless and not read since ${lastSeen.slice(0, 10)}` : `all ${fm.anchor.paths.length} anchored path(s) missing and not read since ${lastSeen.slice(0, 10)}`,
+        filePath
+      });
+    }
+    if (opts.json) {
+      console.log(JSON.stringify({
+        dry_run: !opts.apply,
+        window_days: minDays,
+        candidates: candidates.length,
+        archived: opts.apply ? candidates.length : 0,
+        items: candidates
+      }, null, 2));
+    } else {
+      const header = opts.apply ? "Archiving" : "Would archive";
+      console.log(ui.bold(`${header} ${candidates.length} memor${candidates.length === 1 ? "y" : "ies"} (older than ${minDays}d, type=${typeFilter ?? "all"})`));
+      if (candidates.length === 0) {
+        ui.info("Nothing to archive \u2014 all memories are anchored or read recently.");
+        return;
+      }
+      for (const c of candidates) {
+        console.log(`  ${ui.dim(c.last_seen.slice(0, 10))} ${c.id} ${ui.dim(`(${c.type})`)} \u2014 ${c.reason}`);
+      }
+    }
+    if (!opts.apply) {
+      if (!opts.json) {
+        console.log();
+        ui.info("Dry run \u2014 pass --apply to mark these as deprecated on disk.");
+      }
+      return;
+    }
+    let archived = 0;
+    let failed = 0;
+    for (const c of candidates) {
+      const found = all.find(({ filePath }) => filePath === c.filePath);
+      if (!found) continue;
+      const fm = { ...found.memory.frontmatter, status: "deprecated" };
+      try {
+        await writeFile17(c.filePath, serializeMemory14({ frontmatter: fm, body: found.memory.body }), "utf8");
+        archived++;
+      } catch (err) {
+        if (!opts.json) {
+          ui.error(`Failed to archive ${c.id}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        failed++;
+      }
+    }
+    if (!opts.json) {
+      ui.success(`Archived ${archived} memor${archived === 1 ? "y" : "ies"}${failed > 0 ? ` (${failed} failed)` : ""}`);
+    }
+  });
+}
+function parseDays(input) {
+  const m = input.match(/^(\d+)([dmy])$/);
+  if (!m) return null;
+  const n = parseInt(m[1] ?? "0", 10);
+  const unit = m[2] ?? "d";
+  if (unit === "d") return n;
+  if (unit === "m") return n * 30;
+  if (unit === "y") return n * 365;
+  return null;
+}
+
+// src/commands/doctor.ts
+import { existsSync as existsSync32 } from "fs";
+import { stat } from "fs/promises";
+import "path";
+import "commander";
+import {
+  codeMapPath as codeMapPath2,
+  findProjectRoot as findProjectRoot36,
+  getUsage as getUsage10,
+  loadCodeMap as loadCodeMap3,
+  loadConfig as loadConfig4,
+  loadMemoriesFromDir as loadMemoriesFromDir10,
+  loadUsageIndex as loadUsageIndex12,
+  readUsageEvents as readUsageEvents3,
+  resolveHaivePaths as resolveHaivePaths33
+} from "@hiveai/core";
+var MS_PER_DAY2 = 24 * 60 * 60 * 1e3;
+function registerDoctor(program2) {
+  program2.command("doctor").description(
+    "Analyze the local hAIve setup and emit actionable recommendations.\n\n  Inspects: project-context status, memory health (stale/anchorless/decay/pending),\n  code-map freshness, usage log signals (low-hit briefings, repeated empty searches).\n\n  Read-only by default. Pass --fix to suggest commands you can copy-paste."
+  ).option("--json", "emit JSON instead of human-readable output", false).option("--fix", "include suggested fix commands in human output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
+    const root = findProjectRoot36(opts.dir);
+    const paths = resolveHaivePaths33(root);
+    const findings = [];
+    if (!existsSync32(paths.haiveDir)) {
+      findings.push({
+        severity: "error",
+        code: "not-initialized",
+        message: ".ai/ directory missing \u2014 haive is not initialized in this project.",
+        fix: "haive init"
+      });
+      return emit(findings, opts);
+    }
+    if (!existsSync32(paths.projectContext)) {
+      findings.push({
+        severity: "warn",
+        code: "no-project-context",
+        message: ".ai/project-context.md is missing.",
+        fix: "haive init"
+      });
+    } else {
+      const { readFile: readFile10 } = await import("fs/promises");
+      const content = await readFile10(paths.projectContext, "utf8");
+      const isTemplate = content.includes("TODO \u2014 high-level overview") || content.includes("Generated by `haive init`");
+      if (isTemplate) {
+        findings.push({
+          severity: "warn",
+          code: "template-context",
+          message: "project-context.md still contains the default template \u2014 get_briefing returns little value until filled.",
+          fix: "Invoke the bootstrap_project MCP prompt from your AI client."
+        });
+      }
+    }
+    const memories = existsSync32(paths.memoriesDir) ? await loadMemoriesFromDir10(paths.memoriesDir) : [];
+    const now = Date.now();
+    if (memories.length === 0) {
+      findings.push({
+        severity: "info",
+        code: "no-memories",
+        message: "No memories yet. Capture knowledge as agents work via mem_save / mem_observe / mem_tried."
+      });
+    } else {
+      const usage = await loadUsageIndex12(paths);
+      const stale = memories.filter((m) => m.memory.frontmatter.status === "stale");
+      if (stale.length > 0) {
+        findings.push({
+          severity: "warn",
+          code: "stale-memories",
+          message: `${stale.length} memor${stale.length === 1 ? "y" : "ies"} marked stale (anchored code drifted).`,
+          fix: "haive memory verify --update    # re-check anchors\nhaive memory edit <id>           # manually refresh body"
+        });
+      }
+      const proposed = memories.filter((m) => m.memory.frontmatter.status === "proposed");
+      if (proposed.length > 0) {
+        findings.push({
+          severity: "info",
+          code: "pending-review",
+          message: `${proposed.length} memor${proposed.length === 1 ? "y is" : "ies are"} proposed and awaiting validation.`,
+          fix: "haive memory pending      # list them\nhaive memory auto-promote   # promote those with high read_count"
+        });
+      }
+      const anchorless = memories.filter(
+        (m) => m.memory.frontmatter.anchor.paths.length === 0 && m.memory.frontmatter.anchor.symbols.length === 0 && m.memory.frontmatter.type !== "session_recap" && m.memory.frontmatter.type !== "glossary"
+      );
+      if (anchorless.length / Math.max(memories.length, 1) > 0.3) {
+        findings.push({
+          severity: "warn",
+          code: "anchorless-majority",
+          message: `${anchorless.length}/${memories.length} memories have no anchor path/symbol \u2014 staleness undetectable.`,
+          fix: "Add `paths:` + `symbols:` to mem_save calls to enable haive memory verify."
+        });
+      }
+      const decayCandidates = memories.filter((m) => {
+        if (m.memory.frontmatter.status !== "validated") return false;
+        const u = getUsage10(usage, m.memory.frontmatter.id);
+        const last = u.last_read_at ?? m.memory.frontmatter.created_at;
+        return (now - Date.parse(last)) / MS_PER_DAY2 > 180;
+      });
+      if (decayCandidates.length > 0) {
+        findings.push({
+          severity: "info",
+          code: "decay-candidates",
+          message: `${decayCandidates.length} validated memor${decayCandidates.length === 1 ? "y has" : "ies have"} not been read in 180+ days \u2014 confidence is decaying.`,
+          fix: "haive memory archive --type all --since 365d   # dry run"
+        });
+      }
+    }
+    const codeMap = await loadCodeMap3(paths);
+    if (!codeMap) {
+      findings.push({
+        severity: "warn",
+        code: "no-code-map",
+        message: "No code-map found \u2014 code_map MCP tool and symbol_locations are unavailable.",
+        fix: "haive index code"
+      });
+    } else {
+      const cmFile = codeMapPath2(paths);
+      const cmStat = await stat(cmFile);
+      const ageDays = (now - cmStat.mtimeMs) / MS_PER_DAY2;
+      if (ageDays > 14) {
+        findings.push({
+          severity: "warn",
+          code: "stale-code-map",
+          message: `code-map is ${Math.round(ageDays)} days old (${Object.keys(codeMap.files).length} files indexed).`,
+          fix: "haive index code   # or rely on the post-merge git hook"
+        });
+      }
+    }
+    const events = await readUsageEvents3(paths);
+    if (events.length === 0) {
+      findings.push({
+        severity: "info",
+        code: "no-usage-log",
+        message: "No usage log entries \u2014 MCP server hasn't recorded any calls yet, or this project hasn't been used by an agent."
+      });
+    } else {
+      const queryRepeats = /* @__PURE__ */ new Map();
+      for (const e of events) {
+        if (!isSearchTool(e.tool)) continue;
+        const key = (e.summary ?? "").toLowerCase().trim();
+        if (!key) continue;
+        queryRepeats.set(key, (queryRepeats.get(key) ?? 0) + 1);
+      }
+      const repeated = [...queryRepeats.entries()].filter(([, n]) => n >= 3);
+      if (repeated.length > 0) {
+        findings.push({
+          severity: "info",
+          code: "recurring-searches",
+          message: `${repeated.length} query${repeated.length === 1 ? "" : "ies"} repeated 3+ times \u2014 agents keep asking the same things.`,
+          fix: `haive memory suggest --auto-save --top-n ${Math.min(5, repeated.length)}`
+        });
+      }
+      const codeMapCalls = events.filter((e) => e.tool === "code_map").length;
+      const briefingCalls = events.filter((e) => e.tool === "get_briefing").length;
+      if (codeMapCalls > 0 && memories.length > 0) {
+        findings.push({
+          severity: "info",
+          code: "tool-mix",
+          message: `${briefingCalls} get_briefing call${briefingCalls === 1 ? "" : "s"}, ${codeMapCalls} code_map call${codeMapCalls === 1 ? "" : "s"} recorded.`
+        });
+      }
+    }
+    const config = await loadConfig4(paths);
+    if (!config.autoSessionEnd) {
+      findings.push({
+        severity: "info",
+        code: "no-autopilot",
+        message: "Autopilot is OFF \u2014 session recaps are not auto-saved on shutdown.",
+        fix: "Edit .ai/haive.config.json: set autoSessionEnd: true (or re-run `haive init` without --manual)."
+      });
+    }
+    emit(findings, opts);
+  });
+}
+function emit(findings, opts) {
+  if (opts.json) {
+    console.log(JSON.stringify({ findings }, null, 2));
+    return;
+  }
+  if (findings.length === 0) {
+    ui.success("hAIve doctor \u2014 no issues found.");
+    return;
+  }
+  console.log(ui.bold(`hAIve doctor \u2014 ${findings.length} finding${findings.length === 1 ? "" : "s"}`));
+  console.log();
+  const order = ["error", "warn", "info"];
+  for (const sev of order) {
+    for (const f of findings.filter((x) => x.severity === sev)) {
+      const icon = sev === "error" ? ui.red("\u2717") : sev === "warn" ? ui.yellow("\u26A0") : ui.dim("\u2139");
+      console.log(`${icon} ${ui.bold(f.code)}  ${f.message}`);
+      if (opts.fix && f.fix) {
+        for (const line of f.fix.split("\n")) {
+          console.log(`     ${ui.dim("$")} ${line}`);
+        }
+      }
+    }
+  }
+  if (!opts.fix && findings.some((f) => f.fix)) {
+    console.log();
+    ui.info("Re-run with --fix to see suggested commands.");
+  }
+}
+function isSearchTool(name) {
+  return ["mem_search", "code_search", "mem_relevant_to", "get_briefing"].includes(name);
+}
+
+// src/commands/playback.ts
+import { existsSync as existsSync33 } from "fs";
+import "commander";
+import {
+  findProjectRoot as findProjectRoot37,
+  loadMemoriesFromDir as loadMemoriesFromDir11,
+  parseSince as parseSince3,
+  readUsageEvents as readUsageEvents4,
+  resolveHaivePaths as resolveHaivePaths34
+} from "@hiveai/core";
+var MS_PER_MINUTE = 6e4;
+function registerPlayback(program2) {
+  program2.command("playback").description(
+    "Replay past sessions from the usage log. For each session, show:\n  - tool calls (what kind, how many)\n  - briefing tasks asked\n  - memories that have been created since then (that the session didn't have)\n\n  Useful to ask 'would today's haive have helped past me on this task?'"
+  ).option("--since <window>", "limit to events in this window (e.g. '7d')", "30d").option("--session-gap <minutes>", "minutes of inactivity that splits a session", "30").option("--limit <n>", "show at most this many sessions (newest first)", "10").option("--json", "emit JSON instead of human-readable output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
+    const root = findProjectRoot37(opts.dir);
+    const paths = resolveHaivePaths34(root);
+    const events = await readUsageEvents4(paths);
+    if (events.length === 0) {
+      if (opts.json) {
+        console.log(JSON.stringify({ sessions: [] }));
+        return;
+      }
+      ui.warn("No usage log entries yet.");
+      return;
+    }
+    const since = parseSince3(opts.since);
+    const cutoff = since ? since.getTime() : 0;
+    const filtered = cutoff > 0 ? events.filter((e) => Date.parse(e.at) >= cutoff) : events;
+    const gapMs = Math.max(1, parseInt(opts.sessionGap ?? "30", 10)) * MS_PER_MINUTE;
+    const sessions = bucketSessions(filtered, gapMs);
+    const all = existsSync33(paths.memoriesDir) ? await loadMemoriesFromDir11(paths.memoriesDir) : [];
+    const memByCreatedAt = all.filter(({ memory: memory2 }) => memory2.frontmatter.type !== "session_recap").map(({ memory: memory2 }) => ({ id: memory2.frontmatter.id, at: Date.parse(memory2.frontmatter.created_at) })).sort((a, b) => a.at - b.at);
+    const enriched = sessions.map((s, i) => {
+      const startMs = Date.parse(s.start);
+      const newer = memByCreatedAt.filter((m) => m.at > startMs);
+      return {
+        index: i,
+        start: s.start,
+        end: s.end,
+        duration_minutes: (Date.parse(s.end) - startMs) / MS_PER_MINUTE,
+        events: s.events.length,
+        tools_count: countTools(s.events),
+        briefing_tasks: s.events.filter((e) => e.tool === "get_briefing" && e.summary).map((e) => e.summary).slice(0, 5),
+        memories_created_since: newer.length,
+        new_memories: newer.slice(0, 5).map((m) => m.id)
+      };
+    });
+    enriched.sort((a, b) => Date.parse(b.start) - Date.parse(a.start));
+    const limit = Math.max(1, parseInt(opts.limit ?? "10", 10));
+    const shown = enriched.slice(0, limit);
+    if (opts.json) {
+      console.log(JSON.stringify({
+        window: opts.since,
+        session_gap_minutes: gapMs / MS_PER_MINUTE,
+        total_sessions: enriched.length,
+        sessions: shown
+      }, null, 2));
+      return;
+    }
+    console.log(ui.bold(`hAIve playback \u2014 ${enriched.length} session(s) over ${opts.since ?? "all time"}`));
+    console.log();
+    for (const s of shown) {
+      console.log(
+        `${ui.bold(`Session ${s.index + 1}`)}  ${ui.dim(s.start.slice(0, 19) + " \u2192 " + s.end.slice(11, 19))}  ${ui.dim(`(${Math.round(s.duration_minutes)}m, ${s.events} call${s.events === 1 ? "" : "s"})`)}`
+      );
+      const toolList = Object.entries(s.tools_count).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([t, n]) => `${t}\xD7${n}`).join(", ");
+      if (toolList) console.log(`  ${ui.dim("tools:")} ${toolList}`);
+      if (s.briefing_tasks.length > 0) {
+        console.log(`  ${ui.dim("briefings asked:")}`);
+        for (const t of s.briefing_tasks) {
+          console.log(`    \u2022 ${truncate2(t, 80)}`);
+        }
+      }
+      if (s.memories_created_since > 0) {
+        console.log(
+          `  ${ui.green("\u2934")} ${s.memories_created_since} memor${s.memories_created_since === 1 ? "y has" : "ies have"} been created since this session ` + ui.dim(`\u2014 newer haive could have answered better`)
+        );
+        for (const id of s.new_memories) {
+          console.log(`    + ${ui.dim(id)}`);
+        }
+      }
+      console.log();
+    }
+  });
+}
+function bucketSessions(events, gapMs) {
+  if (events.length === 0) return [];
+  const sorted = [...events].sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+  const buckets = [];
+  let current = null;
+  for (const e of sorted) {
+    if (!current) {
+      current = { start: e.at, end: e.at, events: [e] };
+      continue;
+    }
+    if (Date.parse(e.at) - Date.parse(current.end) > gapMs) {
+      buckets.push(current);
+      current = { start: e.at, end: e.at, events: [e] };
+    } else {
+      current.events.push(e);
+      current.end = e.at;
+    }
+  }
+  if (current) buckets.push(current);
+  return buckets;
+}
+function countTools(events) {
+  const out = {};
+  for (const e of events) out[e.tool] = (out[e.tool] ?? 0) + 1;
+  return out;
+}
+function truncate2(text, max) {
+  if (text.length <= max) return text;
+  return text.slice(0, max - 1) + "\u2026";
+}
+
+// src/commands/precommit.ts
+import { spawn as spawn3 } from "child_process";
+import "commander";
+import {
+  findProjectRoot as findProjectRoot38,
+  resolveHaivePaths as resolveHaivePaths35
+} from "@hiveai/core";
+import { preCommitCheck } from "@hiveai/mcp";
+function registerPrecommit(program2) {
+  program2.command("precommit").description(
+    "Run a pre-commit safety check: scans `git diff --cached` against known anti-patterns,\n  surfaces conventions/decisions anchored to touched files, and warns about stale anchored memories.\n\n  Wire it into git as: `.git/hooks/pre-commit` running `haive precommit` (exit 1 = block).\n\n  Examples:\n    haive precommit                                # auto-detects staged diff\n    haive precommit --block-on any                 # block on any warning, not just high-confidence\n    haive precommit --paths src/auth.ts src/db.ts  # explicit paths instead of git diff"
+  ).option(
+    "--block-on <mode>",
+    "'any' | 'high-confidence' (default) | 'never' (report only)",
+    "high-confidence"
+  ).option("--no-semantic", "disable semantic search in anti-patterns matching").option("--json", "emit JSON instead of human-readable output", false).option("--paths <paths...>", "explicit paths to check (skips git diff)").option("-d, --dir <dir>", "project root").action(async (opts) => {
+    const root = findProjectRoot38(opts.dir);
+    const paths = resolveHaivePaths35(root);
+    const ctx = { paths };
+    let diff = "";
+    let touchedPaths = opts.paths ?? [];
+    if (touchedPaths.length === 0) {
+      try {
+        diff = await runCommand("git", ["diff", "--cached"], root);
+        if (!diff.trim()) {
+          ui.warn("No staged changes \u2014 nothing to check. Stage with `git add` first.");
+          return;
+        }
+        const nameOnly = await runCommand("git", ["diff", "--cached", "--name-only"], root);
+        touchedPaths = nameOnly.split("\n").map((s) => s.trim()).filter(Boolean);
+      } catch (err) {
+        ui.error(`git diff failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+      }
+    }
+    const result = await preCommitCheck({
+      diff: diff || void 0,
+      paths: touchedPaths,
+      block_on: opts.blockOn ?? "high-confidence",
+      semantic: opts.noSemantic ? false : true
+    }, ctx);
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      process.exit(result.should_block ? 1 : 0);
+    }
+    console.log(ui.bold(`hAIve precommit \u2014 ${touchedPaths.length} file(s)`));
+    console.log(
+      ui.dim(
+        `  anti-patterns: ${result.summary.anti_patterns}  relevant memories: ${result.summary.relevant_memories}  stale anchors: ${result.summary.stale_anchors}`
+      )
+    );
+    console.log();
+    if (result.warnings.length > 0) {
+      console.log(ui.bold("\u26A0 Anti-patterns matched:"));
+      for (const w of result.warnings.slice(0, 10)) {
+        console.log(`  ${ui.yellow("\u26A0")} ${w.id} ${ui.dim(`(${w.type}, ${w.confidence})`)}`);
+        for (const line of w.body_preview.split("\n").slice(0, 3)) {
+          console.log(`     ${ui.dim(line)}`);
+        }
+        console.log(`     ${ui.dim("reasons:")} ${w.reasons.join(", ")}`);
+      }
+      console.log();
+    }
+    if (result.relevant_memories.length > 0) {
+      console.log(ui.bold("\u{1F4CC} Relevant conventions/decisions:"));
+      for (const m of result.relevant_memories) {
+        console.log(`  \u2022 ${m.id} ${ui.dim(`(${m.type}, ${m.confidence})`)}`);
+      }
+      console.log();
+    }
+    if (result.stale_anchors.length > 0) {
+      console.log(ui.bold("\u{1F552} Stale anchored memories:"));
+      for (const s of result.stale_anchors) {
+        console.log(`  \u2022 ${s.id}`);
+        if (s.body_preview) console.log(`     ${ui.dim(s.body_preview)}`);
+      }
+      console.log();
+    }
+    if (result.should_block) {
+      ui.error(`Blocking commit (block_on=${opts.blockOn ?? "high-confidence"}). Address the warnings above or pass --block-on never to bypass.`);
+      process.exit(1);
+    }
+    if (result.warnings.length === 0 && result.stale_anchors.length === 0) {
+      ui.success("No anti-patterns or stale anchors found.");
+    } else {
+      ui.success("Check passed (block_on threshold not met).");
+    }
+  });
+}
+function runCommand(cmd, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn3(cmd, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    proc.on("error", reject);
+    proc.on("close", (code) => {
+      if (code === 0) resolve(stdout);
+      else reject(new Error(stderr || `${cmd} exited with code ${code}`));
+    });
+  });
+}
+
 // src/index.ts
-var program = new Command32();
-program.name("haive").description("hAIve \u2014 team-first persistent memory layer for AI coding agents").version("0.4.5");
+var program = new Command39();
+program.name("haive").description("hAIve \u2014 team-first persistent memory layer for AI coding agents").version("0.6.0");
 registerInit(program);
 registerMcp(program);
 registerBriefing(program);
@@ -3376,10 +4375,17 @@ registerMemoryTried(memory);
 registerMemoryImport(memory);
 registerMemoryImportChangelog(memory);
 registerMemoryDigest(memory);
+registerMemorySuggest(memory);
+registerMemoryArchive(memory);
 var session = program.command("session").description("Manage session lifecycle");
 registerSessionEnd(session);
 registerSnapshot(program);
 registerHub(program);
+registerStats(program);
+registerBench(program);
+registerDoctor(program);
+registerPlayback(program);
+registerPrecommit(program);
 program.parseAsync(process.argv).catch((err) => {
   if (isZodError(err)) {
     for (const issue of err.issues) {