@hiveai/cli 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command18 } from "commander";
+import { Command as Command22 } from "commander";
 
 // src/commands/embeddings.ts
 import { existsSync } from "fs";
@@ -89,12 +89,56 @@ async function loadEmbeddings() {
   }
 }
 
+// src/commands/index-code.ts
+import path2 from "path";
+import "commander";
+import {
+  buildCodeMap,
+  codeMapPath,
+  findProjectRoot as findProjectRoot2,
+  resolveHaivePaths as resolveHaivePaths2,
+  saveCodeMap
+} from "@hiveai/core";
+function registerIndexCode(program2) {
+  const idx = program2.command("index").description("Build local indexes that help AIs read less code");
+  idx.command("code").description("Scan source files and write .ai/code-map.json (file \u2192 exports + 1-line description)").option("-d, --dir <dir>", "project root").option(
+    "--exclude <csv>",
+    "extra directory names to skip (comma-separated)",
+    ""
+  ).action(async (opts) => {
+    const root = findProjectRoot2(opts.dir);
+    const paths = resolveHaivePaths2(root);
+    const extraExcludes = (opts.exclude ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+    ui.info(`Indexing source files in ${root}\u2026`);
+    const map = await buildCodeMap(root, {
+      excludeDirs: [
+        "node_modules",
+        "dist",
+        "build",
+        "out",
+        ".git",
+        ".next",
+        ".turbo",
+        ".vitest-cache",
+        "coverage",
+        ...extraExcludes
+      ]
+    });
+    await saveCodeMap(paths, map);
+    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))}`
+    );
+  });
+}
+
 // src/commands/init.ts
 import { mkdir, writeFile } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
-import path2 from "path";
+import path3 from "path";
 import "commander";
-import { resolveHaivePaths as resolveHaivePaths2 } from "@hiveai/core";
+import { resolveHaivePaths as resolveHaivePaths3 } from "@hiveai/core";
 var PROJECT_CONTEXT_TEMPLATE = `# Project context
 
 > Generated by \`haive init\`. Edit this file (or let your AI agent fill it via the upcoming MCP \`bootstrap_project\` tool).
@@ -122,8 +166,8 @@ Memories live under \`.ai/memories/\` (personal/team/module).
 `;
 function registerInit(program2) {
   program2.command("init").description("Initialize a hAIve project (.ai/ structure + bridge files)").option("-d, --dir <dir>", "project root", process.cwd()).option("--no-bridges", "do not generate CLAUDE.md / .cursorrules / copilot-instructions.md").action(async (opts) => {
-    const root = path2.resolve(opts.dir);
-    const paths = resolveHaivePaths2(root);
+    const root = path3.resolve(opts.dir);
+    const paths = resolveHaivePaths3(root);
     if (existsSync2(paths.haiveDir)) {
       ui.warn(`.ai/ already exists at ${paths.haiveDir} \u2014 leaving existing files in place.`);
     }
@@ -133,40 +177,91 @@ function registerInit(program2) {
     await mkdir(paths.modulesContextDir, { recursive: true });
     if (!existsSync2(paths.projectContext)) {
       await writeFile(paths.projectContext, PROJECT_CONTEXT_TEMPLATE, "utf8");
-      ui.success(`Created ${path2.relative(root, paths.projectContext)}`);
+      ui.success(`Created ${path3.relative(root, paths.projectContext)}`);
     }
     if (opts.bridges) {
       await writeBridge(root, "CLAUDE.md");
       await writeBridge(root, ".cursorrules");
-      await writeBridge(root, path2.join(".github", "copilot-instructions.md"));
+      await writeBridge(root, path3.join(".github", "copilot-instructions.md"));
     }
     ui.success(`hAIve initialized at ${root}`);
     ui.info("Next: " + ui.bold("haive memory add --type convention --slug <name>"));
   });
 }
 async function writeBridge(root, relPath) {
-  const target = path2.join(root, relPath);
+  const target = path3.join(root, relPath);
   if (existsSync2(target)) {
     ui.info(`Bridge ${relPath} already exists \u2014 skipped`);
     return;
   }
-  await mkdir(path2.dirname(target), { recursive: true });
+  await mkdir(path3.dirname(target), { recursive: true });
   await writeFile(target, BRIDGE_BODY, "utf8");
   ui.success(`Created bridge ${relPath}`);
 }
 
+// src/commands/install-hooks.ts
+import { mkdir as mkdir2, writeFile as writeFile2, chmod, readFile } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import path4 from "path";
+import "commander";
+import { findProjectRoot as findProjectRoot4 } from "@hiveai/core";
+var HOOK_MARKER = "# hAIve auto-generated";
+var HOOK_BODY = `#!/bin/sh
+${HOOK_MARKER} \u2014 keep this block to allow upgrades. Hand-edit anything outside it.
+
+# After a merge or pull, refresh memory anchors and auto-promote eligible
+# memories so that everyone on this branch sees consistent confidence levels.
+if command -v haive >/dev/null 2>&1; then
+  haive sync --quiet --since ORIG_HEAD || true
+elif [ -x ./node_modules/.bin/haive ]; then
+  ./node_modules/.bin/haive sync --quiet --since ORIG_HEAD || true
+fi
+`;
+var HOOKS = ["post-merge", "post-rewrite"];
+function registerInstallHooks(program2) {
+  program2.command("install-hooks").description("Install git hooks that run `haive sync` after pull/merge").option("-d, --dir <dir>", "project root").option("--force", "overwrite existing hooks").action(async (opts) => {
+    const root = findProjectRoot4(opts.dir);
+    const gitDir = path4.join(root, ".git");
+    if (!existsSync3(gitDir)) {
+      ui.error(`No .git directory at ${root}.`);
+      process.exitCode = 1;
+      return;
+    }
+    const hooksDir = path4.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);
+      if (existsSync3(file) && !opts.force) {
+        const existing = await readFile(file, "utf8");
+        if (!existing.includes(HOOK_MARKER)) {
+          ui.warn(`${name} already exists and was not written by hAIve. Re-run with --force to overwrite.`);
+          skipped++;
+          continue;
+        }
+      }
+      await writeFile2(file, HOOK_BODY, "utf8");
+      await chmod(file, 493);
+      installed++;
+    }
+    ui.success(`Installed ${installed} hook(s) in .git/hooks/${skipped ? `, skipped ${skipped}` : ""}`);
+    ui.info("Test with: git pull (or any merge), then check .ai/memories for status updates.");
+  });
+}
+
 // src/commands/mcp.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { createRequire } from "module";
-import path3 from "path";
+import path5 from "path";
 import { fileURLToPath } from "url";
 import "commander";
-import { findProjectRoot as findProjectRoot3 } from "@hiveai/core";
+import { findProjectRoot as findProjectRoot5 } from "@hiveai/core";
 var require2 = createRequire(import.meta.url);
 function registerMcp(program2) {
   program2.command("mcp").description("Start the hAIve MCP server (stdio transport)").option("-d, --dir <dir>", "project root (defaults to nearest .ai/ or .git/)").action((opts) => {
-    const root = findProjectRoot3(opts.dir);
+    const root = findProjectRoot5(opts.dir);
     const bin = locateMcpBin();
     if (!bin) {
       ui.error(
@@ -184,47 +279,189 @@ function registerMcp(program2) {
 function locateMcpBin() {
   try {
     const pkgPath = require2.resolve("@hiveai/mcp/package.json");
-    const pkgDir = path3.dirname(pkgPath);
-    const candidate = path3.join(pkgDir, "dist", "index.js");
-    if (existsSync3(candidate)) return candidate;
+    const pkgDir = path5.dirname(pkgPath);
+    const candidate = path5.join(pkgDir, "dist", "index.js");
+    if (existsSync4(candidate)) return candidate;
   } catch {
   }
-  const here = path3.dirname(fileURLToPath(import.meta.url));
-  const sibling = path3.resolve(here, "..", "..", "..", "mcp", "dist", "index.js");
-  if (existsSync3(sibling)) return sibling;
+  const here = path5.dirname(fileURLToPath(import.meta.url));
+  const sibling = path5.resolve(here, "..", "..", "..", "mcp", "dist", "index.js");
+  if (existsSync4(sibling)) return sibling;
   return null;
 }
 
+// src/commands/sync.ts
+import { spawnSync } from "child_process";
+import { writeFile as writeFile3 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import "path";
+import "commander";
+import {
+  DEFAULT_AUTO_PROMOTE_RULE,
+  findProjectRoot as findProjectRoot6,
+  getUsage,
+  isAutoPromoteEligible,
+  loadMemoriesFromDir,
+  loadUsageIndex,
+  resolveHaivePaths as resolveHaivePaths4,
+  serializeMemory,
+  verifyAnchor
+} from "@hiveai/core";
+function registerSync(program2) {
+  program2.command("sync").description("Refresh memory state after a pull/merge: verify anchors, auto-promote, report changes").option("-d, --dir <dir>", "project root").option("--quiet", "minimal output (suitable for git hooks)").option(
+    "--since <ref>",
+    "git ref/commit to compare against; report memories added/modified/removed since"
+  ).option("--no-verify", "skip the anchor verification step").option("--no-promote", "skip the auto-promotion step").action(async (opts) => {
+    const root = findProjectRoot6(opts.dir);
+    const paths = resolveHaivePaths4(root);
+    if (!existsSync5(paths.memoriesDir)) {
+      if (!opts.quiet) ui.warn(`No .ai/memories at ${root} \u2014 skipping sync.`);
+      return;
+    }
+    const log = (msg) => {
+      if (!opts.quiet) console.log(msg);
+    };
+    let staleMarked = 0;
+    let revalidated = 0;
+    let promoted = 0;
+    if (opts.verify !== false) {
+      const memories = await loadMemoriesFromDir(paths.memoriesDir);
+      for (const { memory: memory2, filePath } of memories) {
+        const isAnchored = memory2.frontmatter.anchor.paths.length > 0 || memory2.frontmatter.anchor.symbols.length > 0;
+        if (!isAnchored) continue;
+        const result = await verifyAnchor(memory2, { projectRoot: root });
+        const verifiedAt = (/* @__PURE__ */ new Date()).toISOString();
+        if (result.stale) {
+          if (memory2.frontmatter.status !== "stale") {
+            await writeFile3(
+              filePath,
+              serializeMemory({
+                frontmatter: {
+                  ...memory2.frontmatter,
+                  status: "stale",
+                  verified_at: verifiedAt,
+                  stale_reason: result.reason
+                },
+                body: memory2.body
+              }),
+              "utf8"
+            );
+            staleMarked++;
+          }
+        } else if (memory2.frontmatter.status === "stale") {
+          await writeFile3(
+            filePath,
+            serializeMemory({
+              frontmatter: {
+                ...memory2.frontmatter,
+                status: "validated",
+                verified_at: verifiedAt,
+                stale_reason: null
+              },
+              body: memory2.body
+            }),
+            "utf8"
+          );
+          revalidated++;
+        }
+      }
+    }
+    if (opts.promote !== false) {
+      const memories = await loadMemoriesFromDir(paths.memoriesDir);
+      const usage = await loadUsageIndex(paths);
+      for (const { memory: memory2, filePath } of memories) {
+        if (isAutoPromoteEligible(
+          memory2.frontmatter,
+          getUsage(usage, memory2.frontmatter.id),
+          DEFAULT_AUTO_PROMOTE_RULE
+        )) {
+          await writeFile3(
+            filePath,
+            serializeMemory({
+              frontmatter: { ...memory2.frontmatter, status: "validated" },
+              body: memory2.body
+            }),
+            "utf8"
+          );
+          promoted++;
+        }
+      }
+    }
+    const sinceReport = opts.since ? collectSinceChanges(root, opts.since) : null;
+    log(
+      `${ui.dim("sync:")} ${staleMarked} stale \xB7 ${revalidated} revalidated \xB7 ${promoted} promoted${sinceReport ? ` \xB7 ${sinceReport.added.length}+/${sinceReport.modified.length}~/${sinceReport.removed.length}- since ${opts.since}` : ""}`
+    );
+    if (sinceReport && !opts.quiet) {
+      if (sinceReport.added.length > 0) {
+        log(ui.bold("\nNew memories:"));
+        for (const f of sinceReport.added) log(`  + ${f}`);
+      }
+      if (sinceReport.modified.length > 0) {
+        log(ui.bold("\nModified:"));
+        for (const f of sinceReport.modified) log(`  ~ ${f}`);
+      }
+      if (sinceReport.removed.length > 0) {
+        log(ui.bold("\nRemoved:"));
+        for (const f of sinceReport.removed) log(`  - ${f}`);
+      }
+    }
+  });
+}
+function collectSinceChanges(root, ref) {
+  const result = spawnSync(
+    "git",
+    ["-C", root, "diff", "--name-status", "--diff-filter=AMD", `${ref}...HEAD`, "--", ".ai/memories"],
+    { encoding: "utf8" }
+  );
+  if (result.status !== 0) return null;
+  const report = { added: [], modified: [], removed: [] };
+  for (const line of result.stdout.split("\n")) {
+    const [status, ...rest] = line.split("	");
+    const file = rest.join("	").trim();
+    if (!file) continue;
+    if (status === "A") report.added.push(file);
+    else if (status === "M") report.modified.push(file);
+    else if (status === "D") report.removed.push(file);
+  }
+  return report;
+}
+
 // src/commands/memory-add.ts
-import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import path4 from "path";
+import { mkdir as mkdir3, writeFile as writeFile4 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import path7 from "path";
 import "commander";
 import {
   buildFrontmatter,
-  findProjectRoot as findProjectRoot4,
+  findProjectRoot as findProjectRoot7,
+  inferModulesFromPaths,
   memoryFilePath,
-  resolveHaivePaths as resolveHaivePaths3,
-  serializeMemory
+  resolveHaivePaths as resolveHaivePaths5,
+  serializeMemory as serializeMemory2
 } from "@hiveai/core";
 function registerMemoryAdd(memory2) {
-  memory2.command("add").description("Add a new memory (defaults to personal scope \u2014 v0.1 approach B)").requiredOption("--type <type>", "convention | decision | gotcha | architecture | glossary").requiredOption("--slug <slug>", "short identifier used in the file name").option("--scope <scope>", "personal | team | module", "personal").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags").option("--domain <domain>", "domain (e.g. transactions)").option("--author <author>", "author email or handle").option("--paths <csv>", "anchor paths, comma-separated").option("--symbols <csv>", "anchor symbols, comma-separated").option("--commit <sha>", "anchor commit SHA").option("--body <text>", "memory body content (Markdown)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot4(opts.dir);
-    const paths = resolveHaivePaths3(root);
-    if (!existsSync4(paths.haiveDir)) {
+  memory2.command("add").description("Add a new memory (defaults to personal scope \u2014 v0.1 approach B)").requiredOption("--type <type>", "convention | decision | gotcha | architecture | glossary").requiredOption("--slug <slug>", "short identifier used in the file name").option("--scope <scope>", "personal | team | module", "personal").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags").option("--domain <domain>", "domain (e.g. transactions)").option("--author <author>", "author email or handle").option("--paths <csv>", "anchor paths, comma-separated").option("--symbols <csv>", "anchor symbols, comma-separated").option("--commit <sha>", "anchor commit SHA").option("--body <text>", "memory body content (Markdown)").option("--no-auto-tag", "disable automatic tag suggestions inferred from anchor paths").option("-d, --dir <dir>", "project root").action(async (opts) => {
+    const root = findProjectRoot7(opts.dir);
+    const paths = resolveHaivePaths5(root);
+    if (!existsSync6(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
+    const userTags = parseCsv(opts.tags);
+    const anchorPaths = parseCsv(opts.paths);
+    const autoTagsEnabled = opts.autoTag !== false;
+    const inferredTags = autoTagsEnabled ? inferModulesFromPaths(anchorPaths) : [];
+    const mergedTags = Array.from(/* @__PURE__ */ new Set([...userTags, ...inferredTags]));
     const frontmatter = buildFrontmatter({
       type: opts.type,
       slug: opts.slug,
       scope: opts.scope,
       module: opts.module,
-      tags: parseCsv(opts.tags),
+      tags: mergedTags,
       domain: opts.domain,
       author: opts.author,
-      paths: parseCsv(opts.paths),
+      paths: anchorPaths,
       symbols: parseCsv(opts.symbols),
       commit: opts.commit
     });
@@ -233,15 +470,18 @@ function registerMemoryAdd(memory2) {
 TODO \u2014 write the memory body.
 `;
     const file = memoryFilePath(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir2(path4.dirname(file), { recursive: true });
-    if (existsSync4(file)) {
+    await mkdir3(path7.dirname(file), { recursive: true });
+    if (existsSync6(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
       return;
     }
-    await writeFile2(file, serializeMemory({ frontmatter, body }), "utf8");
-    ui.success(`Created ${path4.relative(root, file)}`);
+    await writeFile4(file, serializeMemory2({ frontmatter, body }), "utf8");
+    ui.success(`Created ${path7.relative(root, file)}`);
     ui.info(`scope=${frontmatter.scope} status=${frontmatter.status} id=${frontmatter.id}`);
+    if (inferredTags.length > 0) {
+      ui.info(`auto-tagged: ${inferredTags.join(", ")}  (use --no-auto-tag to disable)`);
+    }
   });
 }
 function parseCsv(value) {
@@ -250,14 +490,14 @@ function parseCsv(value) {
 }
 
 // src/commands/memory-list.ts
-import { existsSync as existsSync5 } from "fs";
-import path5 from "path";
+import { existsSync as existsSync7 } from "fs";
+import path8 from "path";
 import "commander";
-import { findProjectRoot as findProjectRoot5, resolveHaivePaths as resolveHaivePaths4 } from "@hiveai/core";
+import { findProjectRoot as findProjectRoot8, resolveHaivePaths as resolveHaivePaths6 } from "@hiveai/core";
 
 // src/utils/fs.ts
 import {
-  loadMemoriesFromDir,
+  loadMemoriesFromDir as loadMemoriesFromDir2,
   loadMemory,
   listMarkdownFilesRecursive
 } from "@hiveai/core";
@@ -265,14 +505,14 @@ 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("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot5(opts.dir);
-    const paths = resolveHaivePaths4(root);
-    if (!existsSync5(paths.memoriesDir)) {
+    const root = findProjectRoot8(opts.dir);
+    const paths = resolveHaivePaths6(root);
+    if (!existsSync7(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir(paths.memoriesDir);
+    const all = await loadMemoriesFromDir2(paths.memoriesDir);
     const filtered = all.filter((m) => matchesFilters(m, opts));
     if (filtered.length === 0) {
       ui.info("No memories match the filters.");
@@ -285,7 +525,7 @@ function registerMemoryList(memory2) {
       console.log(
         `${ui.bold(fm.id)} ${ui.dim(fm.scope)}/${ui.dim(fm.type)}${moduleStr}${tagStr}`
       );
-      console.log(`  ${ui.dim(path5.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path8.relative(root, filePath))}`);
     }
     console.log(ui.dim(`
 ${filtered.length} memor${filtered.length === 1 ? "y" : "ies"}`));
@@ -301,26 +541,26 @@ function matchesFilters(loaded, opts) {
 }
 
 // src/commands/memory-promote.ts
-import { mkdir as mkdir3, unlink, writeFile as writeFile3 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import path6 from "path";
+import { mkdir as mkdir4, unlink, writeFile as writeFile5 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
+import path9 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot6,
+  findProjectRoot as findProjectRoot9,
   memoryFilePath as memoryFilePath2,
-  resolveHaivePaths as resolveHaivePaths5,
-  serializeMemory as serializeMemory2
+  resolveHaivePaths as resolveHaivePaths7,
+  serializeMemory as serializeMemory3
 } 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 = findProjectRoot6(opts.dir);
-    const paths = resolveHaivePaths5(root);
-    if (!existsSync6(paths.memoriesDir)) {
+    const root = findProjectRoot9(opts.dir);
+    const paths = resolveHaivePaths7(root);
+    if (!existsSync8(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir(paths.personalDir);
+    const all = await loadMemoriesFromDir2(paths.personalDir);
     const found = all.find((m) => m.memory.frontmatter.id === id);
     if (!found) {
       ui.error(`No personal memory with id "${id}". (Promotion only applies to personal scope.)`);
@@ -336,34 +576,34 @@ function registerMemoryPromote(memory2) {
       body: found.memory.body
     };
     const newPath = memoryFilePath2(paths, "team", updated.frontmatter.id);
-    await mkdir3(path6.dirname(newPath), { recursive: true });
-    await writeFile3(newPath, serializeMemory2(updated), "utf8");
+    await mkdir4(path9.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 ${path6.relative(root, newPath)}`);
+    ui.info(`Now at ${path9.relative(root, newPath)}`);
   });
 }
 
 // src/commands/memory-approve.ts
-import { existsSync as existsSync7 } from "fs";
-import { writeFile as writeFile4 } from "fs/promises";
-import path7 from "path";
+import { existsSync as existsSync9 } from "fs";
+import { writeFile as writeFile6 } from "fs/promises";
+import path10 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot7,
-  resolveHaivePaths as resolveHaivePaths6,
-  serializeMemory as serializeMemory3
+  findProjectRoot as findProjectRoot10,
+  resolveHaivePaths as resolveHaivePaths8,
+  serializeMemory as serializeMemory4
 } from "@hiveai/core";
 function registerMemoryApprove(memory2) {
   memory2.command("approve <id>").description("Mark a 'proposed' memory as 'validated' immediately (explicit review)").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
-    const root = findProjectRoot7(opts.dir);
-    const paths = resolveHaivePaths6(root);
-    if (!existsSync7(paths.memoriesDir)) {
+    const root = findProjectRoot10(opts.dir);
+    const paths = resolveHaivePaths8(root);
+    if (!existsSync9(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir(paths.memoriesDir);
+    const all = await loadMemoriesFromDir2(paths.memoriesDir);
     const found = all.find((m) => m.memory.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory with id "${id}".`);
@@ -382,47 +622,47 @@ function registerMemoryApprove(memory2) {
       frontmatter: { ...found.memory.frontmatter, status: "validated" },
       body: found.memory.body
     };
-    await writeFile4(found.filePath, serializeMemory3(next), "utf8");
+    await writeFile6(found.filePath, serializeMemory4(next), "utf8");
     ui.success(`Approved ${id} (status=validated)`);
-    ui.info(path7.relative(root, found.filePath));
+    ui.info(path10.relative(root, found.filePath));
   });
 }
 
 // src/commands/memory-auto-promote.ts
-import { writeFile as writeFile5 } from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
-import path8 from "path";
+import { writeFile as writeFile7 } from "fs/promises";
+import { existsSync as existsSync10 } from "fs";
+import path11 from "path";
 import "commander";
 import {
-  DEFAULT_AUTO_PROMOTE_RULE,
-  findProjectRoot as findProjectRoot8,
-  getUsage,
-  isAutoPromoteEligible,
-  loadUsageIndex,
-  resolveHaivePaths as resolveHaivePaths7,
-  serializeMemory as serializeMemory4
+  DEFAULT_AUTO_PROMOTE_RULE as DEFAULT_AUTO_PROMOTE_RULE2,
+  findProjectRoot as findProjectRoot11,
+  getUsage as getUsage2,
+  isAutoPromoteEligible as isAutoPromoteEligible2,
+  loadUsageIndex as loadUsageIndex2,
+  resolveHaivePaths as resolveHaivePaths9,
+  serializeMemory as serializeMemory5
 } from "@hiveai/core";
 function registerMemoryAutoPromote(memory2) {
-  memory2.command("auto-promote").description("Promote eligible 'proposed' memories to 'validated' based on usage").option("--min-reads <n>", "minimum read_count to qualify", String(DEFAULT_AUTO_PROMOTE_RULE.minReads)).option(
+  memory2.command("auto-promote").description("Promote eligible 'proposed' memories to 'validated' based on usage").option("--min-reads <n>", "minimum read_count to qualify", String(DEFAULT_AUTO_PROMOTE_RULE2.minReads)).option(
     "--max-rejections <n>",
     "memories with more rejections than this are skipped",
-    String(DEFAULT_AUTO_PROMOTE_RULE.maxRejections)
+    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 = findProjectRoot8(opts.dir);
-    const paths = resolveHaivePaths7(root);
-    if (!existsSync8(paths.memoriesDir)) {
+    const root = findProjectRoot11(opts.dir);
+    const paths = resolveHaivePaths9(root);
+    if (!existsSync10(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
     const rule = {
-      minReads: Number(opts.minReads ?? DEFAULT_AUTO_PROMOTE_RULE.minReads),
-      maxRejections: Number(opts.maxRejections ?? DEFAULT_AUTO_PROMOTE_RULE.maxRejections)
+      minReads: Number(opts.minReads ?? DEFAULT_AUTO_PROMOTE_RULE2.minReads),
+      maxRejections: Number(opts.maxRejections ?? DEFAULT_AUTO_PROMOTE_RULE2.maxRejections)
     };
-    const memories = await loadMemoriesFromDir(paths.memoriesDir);
-    const usage = await loadUsageIndex(paths);
+    const memories = await loadMemoriesFromDir2(paths.memoriesDir);
+    const usage = await loadUsageIndex2(paths);
     const eligible = memories.filter(
-      ({ memory: memory3 }) => isAutoPromoteEligible(memory3.frontmatter, getUsage(usage, memory3.frontmatter.id), rule)
+      ({ memory: memory3 }) => isAutoPromoteEligible2(memory3.frontmatter, getUsage2(usage, memory3.frontmatter.id), rule)
     );
     if (eligible.length === 0) {
       ui.info(
@@ -432,17 +672,17 @@ function registerMemoryAutoPromote(memory2) {
     }
     let written = 0;
     for (const { memory: mem, filePath } of eligible) {
-      const u = getUsage(usage, mem.frontmatter.id);
+      const u = getUsage2(usage, mem.frontmatter.id);
       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(path8.relative(root, filePath))}`);
+      console.log(`             ${ui.dim(path11.relative(root, filePath))}`);
       if (opts.apply) {
         const next = {
           frontmatter: { ...mem.frontmatter, status: "validated" },
           body: mem.body
         };
-        await writeFile5(filePath, serializeMemory4(next), "utf8");
+        await writeFile7(filePath, serializeMemory5(next), "utf8");
         written++;
       }
     }
@@ -453,25 +693,25 @@ function registerMemoryAutoPromote(memory2) {
 
 // src/commands/memory-edit.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync9 } from "fs";
-import { readFile } from "fs/promises";
-import path9 from "path";
+import { existsSync as existsSync11 } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import path12 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot9,
+  findProjectRoot as findProjectRoot12,
   parseMemory,
-  resolveHaivePaths as resolveHaivePaths8
+  resolveHaivePaths as resolveHaivePaths10
 } 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 = findProjectRoot9(opts.dir);
-    const paths = resolveHaivePaths8(root);
-    if (!existsSync9(paths.memoriesDir)) {
+    const root = findProjectRoot12(opts.dir);
+    const paths = resolveHaivePaths10(root);
+    if (!existsSync11(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir(paths.memoriesDir);
+    const all = await loadMemoriesFromDir2(paths.memoriesDir);
     const found = all.find((m) => m.memory.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory with id "${id}".`);
@@ -479,13 +719,13 @@ function registerMemoryEdit(memory2) {
       return;
     }
     const editor = opts.editor ?? process.env.EDITOR ?? process.env.VISUAL ?? "vi";
-    ui.info(`Opening ${path9.relative(root, found.filePath)} with ${editor}\u2026`);
+    ui.info(`Opening ${path12.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 readFile(found.filePath, "utf8");
+      const fresh = await readFile2(found.filePath, "utf8");
       parseMemory(fresh);
       ui.success("Memory still parses cleanly.");
     } catch (err) {
@@ -506,30 +746,30 @@ function runEditor(editor, file) {
 }
 
 // src/commands/memory-for-files.ts
-import { existsSync as existsSync10 } from "fs";
-import path10 from "path";
+import { existsSync as existsSync12 } from "fs";
+import path13 from "path";
 import "commander";
 import {
   deriveConfidence,
-  findProjectRoot as findProjectRoot10,
-  getUsage as getUsage2,
-  inferModulesFromPaths,
-  loadUsageIndex as loadUsageIndex2,
+  findProjectRoot as findProjectRoot13,
+  getUsage as getUsage3,
+  inferModulesFromPaths as inferModulesFromPaths2,
+  loadUsageIndex as loadUsageIndex3,
   memoryMatchesAnchorPaths,
-  resolveHaivePaths as resolveHaivePaths9
+  resolveHaivePaths as resolveHaivePaths11
 } 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 = findProjectRoot10(opts.dir);
-    const paths = resolveHaivePaths9(root);
-    if (!existsSync10(paths.memoriesDir)) {
+    const root = findProjectRoot13(opts.dir);
+    const paths = resolveHaivePaths11(root);
+    if (!existsSync12(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir(paths.memoriesDir);
-    const usage = await loadUsageIndex2(paths);
-    const inferred = inferModulesFromPaths(files);
+    const all = await loadMemoriesFromDir2(paths.memoriesDir);
+    const usage = await loadUsageIndex3(paths);
+    const inferred = inferModulesFromPaths2(files);
     const byAnchor = [];
     const byModule = [];
     const byDomain = [];
@@ -572,34 +812,84 @@ function printGroup(root, label, loaded, usage) {
 \u2014 ${label} \u2014`));
   for (const { memory: mem, filePath } of loaded) {
     const fm = mem.frontmatter;
-    const u = getUsage2(usage, fm.id);
+    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(path10.relative(root, filePath))}`);
+    console.log(`  ${ui.dim(path13.relative(root, filePath))}`);
   }
 }
 
+// src/commands/memory-hot.ts
+import { existsSync as existsSync13 } from "fs";
+import path14 from "path";
+import "commander";
+import {
+  findProjectRoot as findProjectRoot14,
+  getUsage as getUsage4,
+  loadUsageIndex as loadUsageIndex4,
+  resolveHaivePaths as resolveHaivePaths12
+} 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 = findProjectRoot14(opts.dir);
+    const paths = resolveHaivePaths12(root);
+    if (!existsSync13(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 loadMemoriesFromDir2(paths.memoriesDir);
+    const usage = await loadUsageIndex4(paths);
+    const candidates = all.filter(({ memory: mem }) => {
+      const fm = mem.frontmatter;
+      if (opts.status && fm.status !== opts.status) return false;
+      if (opts.status === void 0 && fm.status !== "draft" && fm.status !== "proposed") {
+        return false;
+      }
+      return getUsage4(usage, fm.id).read_count >= threshold;
+    }).sort(
+      (a, b) => getUsage4(usage, b.memory.frontmatter.id).read_count - getUsage4(usage, a.memory.frontmatter.id).read_count
+    );
+    if (candidates.length === 0) {
+      ui.info(`No hot memories (threshold=${threshold}).`);
+      return;
+    }
+    for (const { memory: mem, filePath } of candidates) {
+      const fm = mem.frontmatter;
+      const u = getUsage4(usage, fm.id);
+      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(path14.relative(root, filePath))}`);
+    }
+    ui.info(
+      `${candidates.length} hot \u2014 promote drafts with \`haive memory promote <id>\`, then \`haive memory auto-promote --apply\`.`
+    );
+  });
+}
+
 // src/commands/memory-pending.ts
-import { existsSync as existsSync11 } from "fs";
-import path11 from "path";
+import { existsSync as existsSync14 } from "fs";
+import path15 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot11,
-  getUsage as getUsage3,
-  loadUsageIndex as loadUsageIndex3,
-  resolveHaivePaths as resolveHaivePaths10
+  findProjectRoot as findProjectRoot15,
+  getUsage as getUsage5,
+  loadUsageIndex as loadUsageIndex5,
+  resolveHaivePaths as resolveHaivePaths13
 } 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 = findProjectRoot11(opts.dir);
-    const paths = resolveHaivePaths10(root);
-    if (!existsSync11(paths.memoriesDir)) {
+    const root = findProjectRoot15(opts.dir);
+    const paths = resolveHaivePaths13(root);
+    if (!existsSync14(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir(paths.memoriesDir);
-    const usage = await loadUsageIndex3(paths);
+    const all = await loadMemoriesFromDir2(paths.memoriesDir);
+    const usage = await loadUsageIndex5(paths);
     const proposed = all.filter(({ memory: mem }) => {
       if (mem.frontmatter.status !== "proposed") return false;
       if (opts.scope && mem.frontmatter.scope !== opts.scope) return false;
@@ -610,46 +900,46 @@ function registerMemoryPending(memory2) {
       return;
     }
     proposed.sort(
-      (a, b) => getUsage3(usage, b.memory.frontmatter.id).read_count - getUsage3(usage, a.memory.frontmatter.id).read_count
+      (a, b) => getUsage5(usage, b.memory.frontmatter.id).read_count - getUsage5(usage, a.memory.frontmatter.id).read_count
     );
     const now = Date.now();
     for (const { memory: mem, filePath } of proposed) {
       const fm = mem.frontmatter;
-      const u = getUsage3(usage, fm.id);
+      const u = getUsage5(usage, fm.id);
       const ageDays = Math.floor((now - new Date(fm.created_at).getTime()) / 864e5);
       const ageStr = ageDays === 0 ? "today" : `${ageDays}d`;
       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(path11.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path15.relative(root, filePath))}`);
     }
     ui.info(`${proposed.length} pending`);
   });
 }
 
 // src/commands/memory-query.ts
-import { existsSync as existsSync12 } from "fs";
-import path12 from "path";
+import { existsSync as existsSync15 } from "fs";
+import path16 from "path";
 import "commander";
 import {
   extractSnippet,
-  findProjectRoot as findProjectRoot12,
+  findProjectRoot as findProjectRoot16,
   literalMatchesAllTokens,
   pickSnippetNeedle,
-  resolveHaivePaths as resolveHaivePaths11,
+  resolveHaivePaths as resolveHaivePaths14,
   tokenizeQuery
 } from "@hiveai/core";
 function registerMemoryQuery(memory2) {
   memory2.command("query <text>").description("Search memories by id, tag, or substring (multi-word AND)").option("-d, --dir <dir>", "project root").option("--limit <n>", "max results", "20").action(async (text, opts) => {
-    const root = findProjectRoot12(opts.dir);
-    const paths = resolveHaivePaths11(root);
-    if (!existsSync12(paths.memoriesDir)) {
+    const root = findProjectRoot16(opts.dir);
+    const paths = resolveHaivePaths14(root);
+    if (!existsSync15(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
     const tokens = tokenizeQuery(text);
-    const all = await loadMemoriesFromDir(paths.memoriesDir);
+    const all = await loadMemoriesFromDir2(paths.memoriesDir);
     const matches = all.filter(({ memory: mem }) => literalMatchesAllTokens(mem, tokens));
     const limit = Math.max(1, Number(opts.limit ?? 20));
     const top = matches.slice(0, limit);
@@ -661,7 +951,7 @@ function registerMemoryQuery(memory2) {
     for (const { memory: mem, filePath } of top) {
       const snippet = extractSnippet(mem.body, snippetNeedle);
       console.log(`${ui.bold(mem.frontmatter.id)} ${ui.dim(mem.frontmatter.scope)}`);
-      console.log(`  ${ui.dim(path12.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path16.relative(root, filePath))}`);
       if (snippet) console.log(`  ${snippet}`);
     }
     console.log(
@@ -672,31 +962,31 @@ ${top.length} of ${matches.length} match${matches.length === 1 ? "" : "es"}`)
 }
 
 // src/commands/memory-reject.ts
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot13,
-  loadUsageIndex as loadUsageIndex4,
+  findProjectRoot as findProjectRoot17,
+  loadUsageIndex as loadUsageIndex6,
   recordRejection,
-  resolveHaivePaths as resolveHaivePaths12,
+  resolveHaivePaths as resolveHaivePaths15,
   saveUsageIndex
 } 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 = findProjectRoot13(opts.dir);
-    const paths = resolveHaivePaths12(root);
-    if (!existsSync13(paths.memoriesDir)) {
+    const root = findProjectRoot17(opts.dir);
+    const paths = resolveHaivePaths15(root);
+    if (!existsSync16(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const memories = await loadMemoriesFromDir(paths.memoriesDir);
+    const memories = await loadMemoriesFromDir2(paths.memoriesDir);
     if (!memories.some((m) => m.memory.frontmatter.id === id)) {
       ui.error(`No memory with id "${id}".`);
       process.exitCode = 1;
       return;
     }
-    const idx = await loadUsageIndex4(paths);
+    const idx = await loadUsageIndex6(paths);
     recordRejection(idx, id, opts.reason ?? null);
     await saveUsageIndex(paths, idx);
     const u = idx.by_id[id];
@@ -708,34 +998,34 @@ function registerMemoryReject(memory2) {
 }
 
 // src/commands/memory-rm.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import { unlink as unlink2 } from "fs/promises";
-import path13 from "path";
+import path17 from "path";
 import { createInterface } from "readline/promises";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot14,
-  loadUsageIndex as loadUsageIndex5,
-  resolveHaivePaths as resolveHaivePaths13,
+  findProjectRoot as findProjectRoot18,
+  loadUsageIndex as loadUsageIndex7,
+  resolveHaivePaths as resolveHaivePaths16,
   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 = findProjectRoot14(opts.dir);
-    const paths = resolveHaivePaths13(root);
-    if (!existsSync14(paths.memoriesDir)) {
+    const root = findProjectRoot18(opts.dir);
+    const paths = resolveHaivePaths16(root);
+    if (!existsSync17(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir(paths.memoriesDir);
+    const all = await loadMemoriesFromDir2(paths.memoriesDir);
     const found = all.find((m) => m.memory.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory with id "${id}".`);
       process.exitCode = 1;
       return;
     }
-    const rel = path13.relative(root, found.filePath);
+    const rel = path17.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();
@@ -748,7 +1038,7 @@ function registerMemoryRm(memory2) {
     await unlink2(found.filePath);
     ui.success(`Deleted ${rel}`);
     if (!opts.keepUsage) {
-      const idx = await loadUsageIndex5(paths);
+      const idx = await loadUsageIndex7(paths);
       if (idx.by_id[id]) {
         delete idx.by_id[id];
         await saveUsageIndex2(paths, idx);
@@ -759,27 +1049,27 @@ function registerMemoryRm(memory2) {
 }
 
 // src/commands/memory-show.ts
-import { existsSync as existsSync15 } from "fs";
-import { readFile as readFile2 } from "fs/promises";
-import path14 from "path";
+import { existsSync as existsSync18 } from "fs";
+import { readFile as readFile3 } from "fs/promises";
+import path18 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence2,
-  findProjectRoot as findProjectRoot15,
-  getUsage as getUsage4,
-  loadUsageIndex as loadUsageIndex6,
-  resolveHaivePaths as resolveHaivePaths14
+  findProjectRoot as findProjectRoot19,
+  getUsage as getUsage6,
+  loadUsageIndex as loadUsageIndex8,
+  resolveHaivePaths as resolveHaivePaths17
 } 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 = findProjectRoot15(opts.dir);
-    const paths = resolveHaivePaths14(root);
-    if (!existsSync15(paths.memoriesDir)) {
+    const root = findProjectRoot19(opts.dir);
+    const paths = resolveHaivePaths17(root);
+    if (!existsSync18(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir(paths.memoriesDir);
+    const all = await loadMemoriesFromDir2(paths.memoriesDir);
     const found = all.find((m) => m.memory.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory with id "${id}".`);
@@ -787,12 +1077,12 @@ function registerMemoryShow(memory2) {
       return;
     }
     if (opts.raw) {
-      console.log(await readFile2(found.filePath, "utf8"));
+      console.log(await readFile3(found.filePath, "utf8"));
       return;
     }
     const fm = found.memory.frontmatter;
-    const usage = await loadUsageIndex6(paths);
-    const u = getUsage4(usage, fm.id);
+    const usage = await loadUsageIndex8(paths);
+    const u = getUsage6(usage, fm.id);
     const conf = deriveConfidence2(fm, u);
     console.log(ui.bold(fm.id));
     console.log(`${ui.dim("scope:")}      ${fm.scope}${fm.module ? ` / ${fm.module}` : ""}`);
@@ -803,7 +1093,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:")}       ${path14.relative(root, found.filePath)}`);
+    console.log(`${ui.dim("file:")}       ${path18.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}`);
@@ -818,38 +1108,38 @@ function registerMemoryShow(memory2) {
 }
 
 // src/commands/memory-stats.ts
-import { existsSync as existsSync16 } from "fs";
-import path15 from "path";
+import { existsSync as existsSync19 } from "fs";
+import path19 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence3,
-  findProjectRoot as findProjectRoot16,
-  getUsage as getUsage5,
-  loadUsageIndex as loadUsageIndex7,
-  resolveHaivePaths as resolveHaivePaths15
+  findProjectRoot as findProjectRoot20,
+  getUsage as getUsage7,
+  loadUsageIndex as loadUsageIndex9,
+  resolveHaivePaths as resolveHaivePaths18
 } 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 = findProjectRoot16(opts.dir);
-    const paths = resolveHaivePaths15(root);
-    if (!existsSync16(paths.memoriesDir)) {
+    const root = findProjectRoot20(opts.dir);
+    const paths = resolveHaivePaths18(root);
+    if (!existsSync19(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir(paths.memoriesDir);
-    const usage = await loadUsageIndex7(paths);
+    const all = await loadMemoriesFromDir2(paths.memoriesDir);
+    const usage = await loadUsageIndex9(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.");
       return;
     }
     target.sort(
-      (a, b) => getUsage5(usage, b.memory.frontmatter.id).read_count - getUsage5(usage, a.memory.frontmatter.id).read_count
+      (a, b) => getUsage7(usage, b.memory.frontmatter.id).read_count - getUsage7(usage, a.memory.frontmatter.id).read_count
     );
     for (const { memory: mem, filePath } of target) {
       const fm = mem.frontmatter;
-      const u = getUsage5(usage, fm.id);
+      const u = getUsage7(usage, fm.id);
       const conf = deriveConfidence3(fm, u);
       console.log(
         `${ui.bold(fm.id)}  ${ui.dim(`${fm.scope}/${fm.type}`)}  ${ui.bold(conf)}`
@@ -857,32 +1147,32 @@ 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(path15.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path19.relative(root, filePath))}`);
     }
   });
 }
 
 // src/commands/memory-verify.ts
-import { writeFile as writeFile6 } from "fs/promises";
-import { existsSync as existsSync17 } from "fs";
-import path16 from "path";
+import { writeFile as writeFile8 } from "fs/promises";
+import { existsSync as existsSync20 } from "fs";
+import path20 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot17,
-  resolveHaivePaths as resolveHaivePaths16,
-  serializeMemory as serializeMemory5,
-  verifyAnchor
+  findProjectRoot as findProjectRoot21,
+  resolveHaivePaths as resolveHaivePaths19,
+  serializeMemory as serializeMemory6,
+  verifyAnchor as verifyAnchor2
 } from "@hiveai/core";
 function registerMemoryVerify(memory2) {
   memory2.command("verify").description("Check memory anchors against current code, optionally marking stale ones").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 for re-freshed) back to disk").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot17(opts.dir);
-    const paths = resolveHaivePaths16(root);
-    if (!existsSync17(paths.memoriesDir)) {
+    const root = findProjectRoot21(opts.dir);
+    const paths = resolveHaivePaths19(root);
+    if (!existsSync20(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir(paths.memoriesDir);
+    const all = await loadMemoriesFromDir2(paths.memoriesDir);
     const targets = opts.id ? all.filter((m) => m.memory.frontmatter.id === opts.id) : all;
     if (opts.id && targets.length === 0) {
       ui.error(`No memory with id "${opts.id}".`);
@@ -894,13 +1184,13 @@ function registerMemoryVerify(memory2) {
     let anchorless = 0;
     let updated = 0;
     for (const { memory: mem, filePath } of targets) {
-      const result = await verifyAnchor(mem, { projectRoot: root });
+      const result = await verifyAnchor2(mem, { projectRoot: root });
       const isAnchored = mem.frontmatter.anchor.paths.length > 0 || mem.frontmatter.anchor.symbols.length > 0;
       if (!isAnchored) {
         anchorless++;
         continue;
       }
-      const rel = path16.relative(root, filePath);
+      const rel = path20.relative(root, filePath);
       if (result.stale) {
         staleCount++;
         console.log(`${ui.bold("STALE")}  ${mem.frontmatter.id}`);
@@ -912,7 +1202,7 @@ function registerMemoryVerify(memory2) {
       }
       if (opts.update) {
         const next = applyVerification(mem, result);
-        await writeFile6(filePath, serializeMemory5(next), "utf8");
+        await writeFile8(filePath, serializeMemory6(next), "utf8");
         updated++;
       }
     }
@@ -951,11 +1241,14 @@ function applyVerification(mem, result) {
 }
 
 // src/index.ts
-var program = new Command18();
+var program = new Command22();
 program.name("haive").description("hAIve \u2014 team-first persistent memory layer for AI coding agents").version("0.1.0");
 registerInit(program);
 registerMcp(program);
 registerEmbeddings(program);
+registerSync(program);
+registerInstallHooks(program);
+registerIndexCode(program);
 var memory = program.command("memory").description("Manage memory entries");
 registerMemoryAdd(memory);
 registerMemoryList(memory);
@@ -971,6 +1264,7 @@ registerMemoryEdit(memory);
 registerMemoryRm(memory);
 registerMemoryPending(memory);
 registerMemoryApprove(memory);
+registerMemoryHot(memory);
 program.parseAsync(process.argv).catch((err) => {
   console.error(err instanceof Error ? err.message : err);
   process.exit(1);