@hiveai/cli 0.9.17 → 0.9.19

package/dist/index.js

@@ -198,7 +198,7 @@ async function getHotFiles(root, daysBack, maxHotFiles, filePaths) {
       if (!f) continue;
       counts.set(f, (counts.get(f) ?? 0) + 1);
     }
-    let entries = [...counts.entries()].map(([path49, changes]) => ({ path: path49, changes }));
+    let entries = [...counts.entries()].map(([path50, changes]) => ({ path: path50, changes }));
     const lowerPaths = filePaths.map((p) => p.toLowerCase());
     if (lowerPaths.length > 0) {
       entries = entries.filter((e) => lowerPaths.some((p) => e.path.toLowerCase().includes(p)));
@@ -2462,7 +2462,7 @@ function registerInit(program2) {
         console.log(ui.dim(`  \u2713 Stack memory packs pre-seeded (${stacksToSeed.join(", ")})`));
       }
       console.log();
-      if (!opts.bootstrap) {
+      if (!wantBootstrap) {
         console.log(ui.bold("One remaining step (optional but recommended):"));
         console.log("  " + ui.bold("haive init --bootstrap") + ui.dim("  \u2190 fill project-context.md without AI"));
         console.log("  " + ui.dim("Or in your AI client: invoke the MCP prompt ") + ui.bold("bootstrap_project"));
@@ -2477,7 +2477,7 @@ function registerInit(program2) {
       console.log(ui.dim("    haive memory import README.md   \u2014 from README / docs"));
     } else {
       console.log(ui.bold("Next steps:"));
-      if (!opts.bootstrap) {
+      if (!wantBootstrap) {
         console.log(ui.dim("  1. Fill project context (pick one):"));
         console.log("     " + ui.bold("haive init --bootstrap") + ui.dim("  \u2190 instant, no AI needed"));
         console.log("     or invoke the MCP prompt " + ui.bold("bootstrap_project") + ui.dim(" in your AI client"));
@@ -6515,7 +6515,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
   };
 }
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.9.17";
+var SERVER_VERSION = "0.9.19";
 function jsonResult(data) {
   return {
     content: [
@@ -6535,6 +6535,7 @@ var ENFORCEMENT_PROFILE_TOOLS = [
   "mem_verify",
   "mem_relevant_to",
   "code_map",
+  "code_search",
   "pre_commit_check",
   "mem_session_end"
 ];
@@ -7483,177 +7484,668 @@ function registerMcp(program2) {
 }
 
 // src/commands/sync.ts
-import { spawnSync as spawnSync3 } from "child_process";
-import { readFile as readFile8, writeFile as writeFile13, mkdir as mkdir10 } from "fs/promises";
-import { existsSync as existsSync29 } from "fs";
-import path13 from "path";
+import { spawnSync as spawnSync4 } from "child_process";
+import { readFile as readFile9, writeFile as writeFile15, mkdir as mkdir10 } from "fs/promises";
+import { existsSync as existsSync31 } from "fs";
+import path15 from "path";
 import "commander";
 import {
   DEFAULT_AUTO_PROMOTE_RULE as DEFAULT_AUTO_PROMOTE_RULE2,
   buildFrontmatter as buildFrontmatter6,
-  findProjectRoot as findProjectRoot11,
-  getUsage as getUsage10,
+  findProjectRoot as findProjectRoot12,
+  getUsage as getUsage11,
   isAutoPromoteEligible as isAutoPromoteEligible2,
   isDecaying as isDecaying2,
-  loadCodeMap as loadCodeMap4,
-  loadConfig as loadConfig4,
-  loadMemoriesFromDir as loadMemoriesFromDir23,
-  loadUsageIndex as loadUsageIndex12,
+  loadCodeMap as loadCodeMap6,
+  loadConfig as loadConfig5,
+  loadMemoriesFromDir as loadMemoriesFromDir24,
+  loadUsageIndex as loadUsageIndex13,
   pullCrossRepoSources,
-  resolveHaivePaths as resolveHaivePaths8,
+  resolveHaivePaths as resolveHaivePaths9,
   resolveManifestFiles,
-  serializeMemory as serializeMemory11,
+  serializeMemory as serializeMemory12,
   trackDependencies,
   verifyAnchor as verifyAnchor2,
   watchContracts
 } from "@hiveai/core";
-var BRIDGE_START = "<!-- haive:memories-start -->";
-var BRIDGE_END = "<!-- haive:memories-end -->";
-function registerSync(program2) {
-  program2.command("sync").description(
-    "Refresh memory state after a git pull or merge.\n  What it does:\n    1. Verifies anchor paths \u2014 marks stale if files/symbols moved or deleted\n    2. Re-validates previously stale memories that are now fresh\n    3. Auto-promotes proposed memories (by usage count or time delay in autopilot)\n    4. Auto-refreshes code-map if source files changed\n    5. Reports decay warnings for memories unused >90 days\n\n  Install git hooks to run sync automatically: haive install-hooks\n\n  Examples:\n    haive sync\n    haive sync --since main   # also report memories changed since main\n    haive sync --embed        # also rebuild embeddings index\n"
-  ).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").option(
-    "--inject-bridge",
-    "inject top validated memories into CLAUDE.md (or --bridge-file) between <!-- haive:memories-start/end --> markers"
-  ).option("--bridge-file <path>", "bridge file to inject into (default: CLAUDE.md)").option("--bridge-max-memories <n>", "max memories to inject into bridge file", "5").option("--embed", "rebuild embeddings index after sync (requires @haive/embeddings)").option("--no-cross-repo", "skip cross-repo memory pull even if crossRepoSources is configured").option("--no-deps", "skip dependency version tracking").option("--no-contracts", "skip contract file diff checking").action(async (opts) => {
-    const root = findProjectRoot11(opts.dir);
-    const paths = resolveHaivePaths8(root);
-    if (!existsSync29(paths.memoriesDir)) {
-      if (!opts.quiet) ui.warn(`No .ai/memories at ${root}. Run \`haive init\` first.`);
-      process.exitCode = 1;
-      return;
+
+// src/utils/autopilot.ts
+import { existsSync as existsSync30 } from "fs";
+import { readFile as readFile8, writeFile as writeFile14 } from "fs/promises";
+import path14 from "path";
+import {
+  AUTOPILOT_DEFAULTS as AUTOPILOT_DEFAULTS2,
+  buildCodeMap as buildCodeMap3,
+  loadCodeMap as loadCodeMap5,
+  loadConfig as loadConfig4,
+  saveCodeMap as saveCodeMap3,
+  saveConfig as saveConfig2
+} from "@hiveai/core";
+
+// src/commands/memory-lint.ts
+import { existsSync as existsSync29 } from "fs";
+import { writeFile as writeFile13 } from "fs/promises";
+import { spawnSync as spawnSync3 } from "child_process";
+import path13 from "path";
+import "commander";
+import {
+  findProjectRoot as findProjectRoot11,
+  getUsage as getUsage10,
+  loadCodeMap as loadCodeMap4,
+  loadMemoriesFromDir as loadMemoriesFromDir23,
+  loadUsageIndex as loadUsageIndex12,
+  resolveHaivePaths as resolveHaivePaths8,
+  serializeMemory as serializeMemory11
+} from "@hiveai/core";
+async function lintMemoriesAsync(root, options = {}) {
+  const paths = resolveHaivePaths8(root);
+  const out = [];
+  const fixes = [];
+  if (!existsSync29(paths.memoriesDir)) return { findings: out, fixes };
+  const loaded = await loadMemoriesFromDir23(paths.memoriesDir);
+  const usage = await loadUsageIndex12(paths);
+  const codeMap = await loadCodeMap4(paths);
+  const trackedFiles = gitTrackedFiles(root);
+  const ANCHOR_TYPES = /* @__PURE__ */ new Set(["decision", "architecture", "gotcha"]);
+  const actionableWords = /\b(always|never|prefer|use|run|avoid|because|instead|why|rationale|do not|must|should|require|required|requires|fix|fail|failed|fails|prevent|prevents|allow|allows|lets|ensure|ensures|catch|catches)\b/i;
+  for (const { filePath, memory: memory2 } of loaded) {
+    const fm = memory2.frontmatter;
+    if (fm.type === "session_recap") continue;
+    const body = memory2.body.trim();
+    const naked = body.replace(/^#.*$/gm, "").replace(/```[\s\S]*?```/g, "").trim();
+    if (naked.length < 40 && fm.status !== "rejected") {
+      out.push({
+        file: filePath,
+        id: fm.id,
+        severity: "warn",
+        code: "SHORT_BODY",
+        message: "Body looks very short (< ~40 chars of prose after headings). Prefer actionable detail."
+      });
     }
-    const log = (msg) => {
-      if (!opts.quiet) console.log(msg);
-    };
-    const config = await loadConfig4(paths);
-    const autoApproveDelayHours = config.autoApproveDelayHours ?? null;
-    const autoPromoteMinReads = config.autoPromoteMinReads ?? DEFAULT_AUTO_PROMOTE_RULE2.minReads;
-    let staleMarked = 0;
-    let revalidated = 0;
-    let promoted = 0;
-    let autoApproved = 0;
-    if (opts.verify !== false) {
-      const memories = await loadMemoriesFromDir23(paths.memoriesDir);
-      for (const { memory: memory2, filePath } of memories) {
-        if (memory2.frontmatter.type === "session_recap") {
-          if (memory2.frontmatter.status === "stale") {
-            await writeFile13(
-              filePath,
-              serializeMemory11({
-                frontmatter: {
-                  ...memory2.frontmatter,
-                  status: "validated",
-                  stale_reason: null,
-                  verified_at: (/* @__PURE__ */ new Date()).toISOString()
-                },
-                body: memory2.body
-              }),
-              "utf8"
-            );
-            revalidated++;
-          }
-          continue;
-        }
-        const isAnchored = memory2.frontmatter.anchor.paths.length > 0 || memory2.frontmatter.anchor.symbols.length > 0;
-        if (!isAnchored) continue;
-        const result = await verifyAnchor2(memory2, { projectRoot: root });
-        const verifiedAt = (/* @__PURE__ */ new Date()).toISOString();
-        if (result.stale) {
-          if (memory2.frontmatter.status !== "stale") {
-            await writeFile13(
-              filePath,
-              serializeMemory11({
-                frontmatter: {
-                  ...memory2.frontmatter,
-                  status: "stale",
-                  verified_at: verifiedAt,
-                  stale_reason: result.reason
-                },
-                body: memory2.body
-              }),
-              "utf8"
-            );
-            staleMarked++;
-          }
-        } else if (memory2.frontmatter.status === "stale") {
-          await writeFile13(
-            filePath,
-            serializeMemory11({
-              frontmatter: {
-                ...memory2.frontmatter,
-                status: "validated",
-                verified_at: verifiedAt,
-                stale_reason: null
-              },
-              body: memory2.body
-            }),
-            "utf8"
-          );
-          revalidated++;
+    if (["decision", "gotcha", "convention", "architecture", "attempt"].includes(fm.type) && fm.status !== "rejected" && !actionableWords.test(naked)) {
+      out.push({
+        file: filePath,
+        id: fm.id,
+        severity: "info",
+        code: "LOW_ACTIONABILITY",
+        message: "Record does not contain obvious action/rationale words. Add the concrete rule, why it exists, and what to do instead."
+      });
+    }
+    const suggestedAnchors = suggestAnchors(root, { filePath, memory: memory2 }, codeMap, trackedFiles);
+    if (ANCHOR_TYPES.has(fm.type) && fm.anchor.paths.length === 0 && fm.status === "validated") {
+      out.push({
+        file: filePath,
+        id: fm.id,
+        severity: "warn",
+        code: "MISSING_ANCHOR",
+        message: `${fm.type} is validated without anchor paths \u2014 add anchor.paths so haive sync can flag staleness.`,
+        ...suggestedAnchors.paths.length > 0 || suggestedAnchors.symbols.length > 0 ? { suggested_anchors: suggestedAnchors } : {}
+      });
+    }
+    if (fm.status === "stale" && !fm.stale_reason) {
+      out.push({
+        file: filePath,
+        id: fm.id,
+        severity: "info",
+        code: "STALE_NO_REASON",
+        message: "Status is stale but stale_reason is empty \u2014 document why when possible."
+      });
+    }
+    if (fm.type === "glossary" && naked.length > 6e3) {
+      out.push({
+        file: filePath,
+        id: fm.id,
+        severity: "info",
+        code: "LONG_GLOSSARY",
+        message: "Very long glossary \u2014 consider splitting concepts for tighter briefings."
+      });
+    }
+    const hasMarkdownHeading = /^#{1,3}\s+\S/m.test(memory2.body.trim());
+    if (!hasMarkdownHeading) {
+      out.push({
+        file: filePath,
+        id: fm.id,
+        severity: "warn",
+        code: "NO_MD_HEADING",
+        message: "No Markdown heading (#/##/###) \u2014 add one so humans and auditors can skim the memo quickly."
+      });
+    }
+    const u = getUsage10(usage, fm.id);
+    if (fm.status === "validated" && u.read_count === 0) {
+      out.push({
+        file: filePath,
+        id: fm.id,
+        severity: "info",
+        code: "NEVER_READ",
+        message: "Validated record has never been surfaced/read. Consider improving tags/anchors or archiving it if it is not useful."
+      });
+    }
+    if (options.fix) {
+      const actions = [];
+      let nextBody = memory2.body;
+      let nextFrontmatter = memory2.frontmatter;
+      if (!hasMarkdownHeading) {
+        nextBody = `# ${titleFromId(fm.id)}
+
+${nextBody.trim()}`;
+        actions.push("add missing Markdown heading");
+      }
+      if (ANCHOR_TYPES.has(fm.type) && fm.anchor.paths.length === 0 && fm.status === "validated" && suggestedAnchors.paths.length > 0) {
+        nextFrontmatter = {
+          ...nextFrontmatter,
+          anchor: {
+            ...nextFrontmatter.anchor,
+            paths: [.../* @__PURE__ */ new Set([...nextFrontmatter.anchor.paths, ...suggestedAnchors.paths])],
+            symbols: [
+              .../* @__PURE__ */ new Set([...nextFrontmatter.anchor.symbols, ...suggestedAnchors.symbols])
+            ]
+          },
+          tags: nextFrontmatter.tags.filter((tag) => tag !== "needs_anchor")
+        };
+        actions.push("add suggested tracked anchor paths");
+        if (suggestedAnchors.symbols.length > 0) {
+          actions.push("add suggested anchor symbols");
         }
       }
-    }
-    if (opts.promote !== false) {
-      const memories = await loadMemoriesFromDir23(paths.memoriesDir);
-      const usage = await loadUsageIndex12(paths);
-      const nowMs = Date.now();
-      for (const { memory: memory2, filePath } of memories) {
-        const fm = memory2.frontmatter;
-        if (fm.type === "session_recap") continue;
-        if (isAutoPromoteEligible2(fm, getUsage10(usage, fm.id), {
-          minReads: autoPromoteMinReads,
-          maxRejections: DEFAULT_AUTO_PROMOTE_RULE2.maxRejections
-        })) {
+      if (ANCHOR_TYPES.has(fm.type) && fm.anchor.paths.length === 0 && fm.anchor.symbols.length === 0 && suggestedAnchors.paths.length === 0 && fm.status === "validated" && !fm.tags.includes("needs_anchor")) {
+        nextFrontmatter = {
+          ...nextFrontmatter,
+          tags: [...nextFrontmatter.tags, "needs_anchor"]
+        };
+        actions.push("tag validated anchorless record with needs_anchor");
+      }
+      if (actions.length > 0) {
+        fixes.push({ file: filePath, id: fm.id, actions, applied: Boolean(options.apply) });
+        if (options.apply) {
           await writeFile13(
             filePath,
-            serializeMemory11({ frontmatter: { ...fm, status: "validated" }, body: memory2.body }),
+            serializeMemory11({ frontmatter: nextFrontmatter, body: nextBody }),
             "utf8"
           );
-          promoted++;
-          continue;
-        }
-        if (autoApproveDelayHours !== null && fm.status === "proposed" && fm.scope === "team") {
-          const ageHours = (nowMs - new Date(fm.created_at).getTime()) / (1e3 * 60 * 60);
-          if (ageHours >= autoApproveDelayHours) {
-            await writeFile13(
-              filePath,
-              serializeMemory11({
-                frontmatter: {
-                  ...fm,
-                  status: "validated",
-                  verified_at: (/* @__PURE__ */ new Date()).toISOString()
-                },
-                body: memory2.body
-              }),
-              "utf8"
-            );
-            autoApproved++;
-          }
         }
       }
     }
-    const sinceReport = opts.since ? collectSinceChanges(root, opts.since) : null;
-    const draftMemories = (await loadMemoriesFromDir23(paths.memoriesDir)).filter(
-      (m) => m.memory.frontmatter.status === "draft"
-    );
-    const draftCount = draftMemories.length;
-    const autoApprovedNote = autoApproved > 0 ? ` \xB7 ${autoApproved} auto-approved` : "";
-    log(
-      `${ui.dim("sync:")} ${staleMarked} stale \xB7 ${revalidated} revalidated \xB7 ${promoted} promoted${autoApprovedNote}${sinceReport ? ` \xB7 ${sinceReport.added.length}+/${sinceReport.modified.length}~/${sinceReport.removed.length}- since ${opts.since}` : ""}`
-    );
-    if (!opts.quiet && draftCount > 0) {
-      log(
-        ui.dim(
-          `\u2139 ${draftCount} memor${draftCount === 1 ? "y" : "ies"} in draft \u2014 run \`haive memory approve <id>\` to activate or \`haive memory list --status draft\` to review`
-        )
+  }
+  for (const dup of nearDuplicatePairs(loaded)) {
+    out.push({
+      file: dup.file,
+      id: dup.id,
+      severity: "warn",
+      code: "NEAR_DUPLICATE",
+      message: `Body overlaps ~${Math.round(dup.score * 100)}% with ${dup.otherId}. Merge or deprecate one record to reduce briefing noise.`
+    });
+  }
+  return { findings: out, fixes };
+}
+function titleFromId(id) {
+  const withoutDate = id.replace(/^\d{4}-\d{2}-\d{2}-/, "");
+  return withoutDate.split("-").filter(Boolean).map((part) => part.slice(0, 1).toUpperCase() + part.slice(1)).join(" ");
+}
+function suggestAnchors(root, loaded, codeMap, trackedFiles) {
+  const body = loaded.memory.body;
+  const paths = /* @__PURE__ */ new Set();
+  const symbols = /* @__PURE__ */ new Set();
+  for (const match of body.matchAll(/`([^`\n]+\.[A-Za-z0-9]+)`|(?:^|\s)([A-Za-z0-9_./-]+\.[A-Za-z0-9]+)/gm)) {
+    const candidate = (match[1] ?? match[2] ?? "").replace(/^\.?\//, "");
+    if (!candidate || candidate.startsWith("http")) continue;
+    if (existsSync29(path13.join(root, candidate)) && isSafeAnchorPath(candidate, trackedFiles)) {
+      paths.add(candidate);
+    }
+  }
+  if (codeMap) {
+    const lowered = body.toLowerCase();
+    for (const [file, entry] of Object.entries(codeMap.files)) {
+      for (const exp of entry.exports) {
+        if (!exp.name || exp.name.length < 4) continue;
+        if (lowered.includes(exp.name.toLowerCase())) {
+          if (isSafeAnchorPath(file, trackedFiles)) {
+            paths.add(file);
+            symbols.add(exp.name);
+          }
+        }
+        if (paths.size >= 5 && symbols.size >= 5) break;
+      }
+      if (paths.size >= 5 && symbols.size >= 5) break;
+    }
+  }
+  return {
+    paths: [...paths].slice(0, 5),
+    symbols: [...symbols].slice(0, 5)
+  };
+}
+function gitTrackedFiles(root) {
+  const result = spawnSync3("git", ["ls-files"], {
+    cwd: root,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  if (result.status !== 0) return null;
+  const files = result.stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+  return new Set(files);
+}
+function isSafeAnchorPath(file, trackedFiles) {
+  const normalized = file.replace(/\\/g, "/").replace(/^\.?\//, "");
+  if (normalized.startsWith(".ai/.cache/") || normalized.startsWith(".ai/.runtime/")) return false;
+  if (normalized.includes("/node_modules/") || normalized.startsWith("node_modules/")) return false;
+  if (normalized.includes("/dist/") || normalized.startsWith("dist/")) return false;
+  if (trackedFiles && !trackedFiles.has(normalized)) return false;
+  return true;
+}
+function nearDuplicatePairs(loaded) {
+  const out = [];
+  const candidates = loaded.filter(({ memory: memory2 }) => {
+    const fm = memory2.frontmatter;
+    return fm.type !== "session_recap" && fm.status !== "rejected" && fm.status !== "deprecated";
+  });
+  for (let i = 0; i < candidates.length; i++) {
+    for (let j = i + 1; j < candidates.length; j++) {
+      const a = candidates[i];
+      const b = candidates[j];
+      if (a.memory.frontmatter.scope !== b.memory.frontmatter.scope) continue;
+      if (a.memory.frontmatter.type !== b.memory.frontmatter.type) continue;
+      const score = jaccard2(tokenSet(a.memory.body), tokenSet(b.memory.body));
+      if (score >= 0.72) {
+        out.push({
+          id: a.memory.frontmatter.id,
+          otherId: b.memory.frontmatter.id,
+          file: a.filePath,
+          score
+        });
+      }
+    }
+  }
+  return out;
+}
+function tokenSet(body) {
+  return new Set(
+    (body.toLowerCase().match(/\b[a-z0-9]{4,}\b/g) ?? []).filter((word) => !["this", "that", "with", "from", "have"].includes(word))
+  );
+}
+function jaccard2(a, b) {
+  if (a.size === 0 || b.size === 0) return 0;
+  let inter = 0;
+  for (const item of a) if (b.has(item)) inter++;
+  return inter / (a.size + b.size - inter);
+}
+function registerMemoryLint(parent) {
+  parent.command("lint").description(
+    "Heuristic corpus checks (anchors on key types, headings, verbosity). Static analysis only."
+  ).option("--json", "emit findings as JSON", false).option("--fix", "prepare simple automatic fixes (use with --dry-run or --apply)", false).option("--dry-run", "with --fix, show files that would change without writing", false).option("--apply", "with --fix, write simple fixes to disk", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
+    const root = findProjectRoot11(opts.dir);
+    const apply = Boolean(opts.fix && opts.apply);
+    const dryRun = Boolean(opts.fix && (opts.dryRun || !opts.apply));
+    const report = await lintMemoriesAsync(root, { fix: Boolean(opts.fix), apply });
+    const findings = report.findings;
+    if (opts.json) {
+      console.log(JSON.stringify({
+        findings_count: findings.length,
+        findings,
+        fixes_count: report.fixes.length,
+        fixes: report.fixes,
+        fix_mode: opts.fix ? apply ? "apply" : "dry-run" : "off"
+      }, null, 2));
+      process.exitCode = findings.some((f) => f.severity === "error") ? 1 : 0;
+      return;
+    }
+    if (findings.length === 0) {
+      ui.success(`memory lint OK \u2014 ${root}`);
+      return;
+    }
+    console.log(ui.bold(`memory lint (${findings.length} finding${findings.length === 1 ? "" : "s"})`) + `
+`);
+    if (opts.fix) {
+      const mode = apply ? "apply" : dryRun ? "dry-run" : "dry-run";
+      const verb = apply ? "changed" : "would change";
+      console.log(ui.bold(`fix ${mode}: ${report.fixes.length} file${report.fixes.length === 1 ? "" : "s"} ${verb}`));
+      for (const fix of report.fixes) {
+        console.log(`  ${ui.dim(fix.id)} ${fix.actions.join("; ")}`);
+        console.log(ui.dim(`       \u2192 ${fix.file}`));
+      }
+      console.log();
+    }
+    const order = { error: 0, warn: 1, info: 2 };
+    findings.sort((a, b) => order[a.severity] - order[b.severity] || a.id.localeCompare(b.id));
+    for (const f of findings) {
+      const color = f.severity === "error" ? ui.red : f.severity === "warn" ? ui.yellow : ui.dim;
+      console.log(
+        `${color(f.severity.padEnd(5))} ${ui.dim(f.code)} ${f.id}`
+      );
+      console.log(`       ${f.message}`);
+      if (f.suggested_anchors) {
+        const pathHints = f.suggested_anchors.paths.length > 0 ? `paths: ${f.suggested_anchors.paths.join(", ")}` : "";
+        const symbolHints = f.suggested_anchors.symbols.length > 0 ? `symbols: ${f.suggested_anchors.symbols.join(", ")}` : "";
+        console.log(ui.dim(`       suggested anchors: ${[pathHints, symbolHints].filter(Boolean).join(" \xB7 ")}`));
+      }
+      console.log(ui.dim(`       \u2192 ${f.file}`));
+    }
+    process.exitCode = findings.some((x) => x.severity === "error") ? 1 : 0;
+  });
+}
+
+// src/utils/autopilot.ts
+async function applyAutopilotRepairs(root, paths, options = {}) {
+  const repairs = [];
+  const config = await loadConfig4(paths);
+  if (options.applyConfig) {
+    const changed = await ensureAutopilotConfig(paths, config);
+    if (changed) {
+      repairs.push({
+        code: "autopilot-config",
+        message: "Enabled autopilot defaults in .ai/haive.config.json."
+      });
+    }
+  }
+  const current = await loadConfig4(paths);
+  const autoRepair = current.autoRepair ?? {};
+  if (options.applyContext ?? autoRepair.context ?? current.autopilot) {
+    const changed = await syncProjectContextVersion(root, paths);
+    if (changed) {
+      repairs.push({
+        code: "project-context-version",
+        message: "Updated .ai/project-context.md version metadata from package.json."
+      });
+    }
+  }
+  if (options.applyCorpus ?? autoRepair.corpus ?? current.autopilot) {
+    const report = await lintMemoriesAsync(root, { fix: true, apply: true });
+    const applied = report.fixes.filter((fix) => fix.applied);
+    if (applied.length > 0) {
+      repairs.push({
+        code: "memory-lint-fix",
+        message: `Applied ${applied.length} safe memory lint fix${applied.length === 1 ? "" : "es"}.`
+      });
+    }
+  }
+  if (options.applyCodeMap ?? autoRepair.codeMap ?? current.autopilot) {
+    const refreshed = await refreshCodeMap(root, paths, Boolean(options.forceCodeMap));
+    if (refreshed) {
+      repairs.push({
+        code: "code-map-refresh",
+        message: "Refreshed .ai/code-map.json."
+      });
+    }
+  }
+  if (options.applyCodeSearch ?? autoRepair.codeSearch ?? current.autopilot) {
+    const indexed = await refreshCodeSearchIndex(paths);
+    if (indexed) {
+      repairs.push({
+        code: "code-search-index",
+        message: "Refreshed code-search embeddings index."
+      });
+    }
+  }
+  return repairs;
+}
+async function ensureAutopilotConfig(paths, currentConfig) {
+  const current = currentConfig ?? await loadConfig4(paths);
+  const next = {
+    ...current,
+    autopilot: true,
+    defaultScope: "team",
+    defaultStatus: "validated",
+    autoApproveDelayHours: current.autoApproveDelayHours ?? AUTOPILOT_DEFAULTS2.autoApproveDelayHours,
+    autoPromoteMinReads: current.autoPromoteMinReads ?? AUTOPILOT_DEFAULTS2.autoPromoteMinReads,
+    autoSessionEnd: true,
+    autoContext: true,
+    autoRepair: {
+      context: true,
+      corpus: true,
+      codeMap: true,
+      codeSearch: current.autoRepair?.codeSearch ?? true
+    },
+    enforcement: {
+      ...AUTOPILOT_DEFAULTS2.enforcement,
+      ...current.enforcement,
+      mode: "strict",
+      requireBriefingFirst: true,
+      requireSessionRecap: true,
+      requireMemoryVerify: true,
+      blockStaleDecisionChanges: true,
+      requireDecisionCoverage: true,
+      cleanupGeneratedArtifacts: true,
+      toolProfile: current.enforcement?.toolProfile ?? "enforcement"
+    }
+  };
+  if (JSON.stringify(current) === JSON.stringify(next)) return false;
+  await saveConfig2(paths, next);
+  return true;
+}
+async function syncProjectContextVersion(root, paths) {
+  const status = await projectContextVersionStatus(root, paths);
+  if (!status.canSync || !status.expectedVersion) return false;
+  const original = await readFile8(paths.projectContext, "utf8");
+  let updated = original.replace(
+    /^# Project context — hAIve \(v[^)]+\)$/m,
+    `# Project context \u2014 hAIve (v${status.expectedVersion})`
+  ).replace(
+    /> \*\*Current version\*\*: [^—\n]+—/m,
+    `> **Current version**: ${status.expectedVersion} \u2014`
+  );
+  if (updated === original && !original.includes("Current version")) {
+    updated = original.replace(
+      /^(> Repo-native context enforcement[^\n]*\n)/m,
+      `$1> **Current version**: ${status.expectedVersion} \u2014 @hiveai/core, cli, mcp, embeddings are versioned together.
+`
+    );
+  }
+  if (updated === original) return false;
+  await writeFile14(paths.projectContext, updated, "utf8");
+  return true;
+}
+async function projectContextVersionStatus(root, paths) {
+  if (!existsSync30(paths.projectContext)) {
+    return { mismatch: false, canSync: false };
+  }
+  const packagePath = path14.join(root, "package.json");
+  if (!existsSync30(packagePath)) {
+    return { mismatch: false, canSync: false };
+  }
+  const packageJson = JSON.parse(await readFile8(packagePath, "utf8"));
+  const expectedVersion = packageJson.version;
+  if (!expectedVersion) {
+    return { mismatch: false, canSync: false };
+  }
+  const content = await readFile8(paths.projectContext, "utf8");
+  const headingVersion = content.match(/^# Project context — hAIve \(v([^)]+)\)$/m)?.[1];
+  const currentLineVersion = content.match(/^> \*\*Current version\*\*: ([^—\n]+)—/m)?.[1]?.trim();
+  const currentVersion = currentLineVersion ?? headingVersion;
+  return {
+    expectedVersion,
+    currentVersion,
+    mismatch: currentVersion !== expectedVersion,
+    canSync: true
+  };
+}
+async function refreshCodeMap(root, paths, force) {
+  if (!force) {
+    const existing = await loadCodeMap5(paths);
+    if (existing) return false;
+  }
+  const map = await buildCodeMap3(root, {
+    excludeDirs: [
+      "node_modules",
+      "dist",
+      "build",
+      "out",
+      ".git",
+      ".next",
+      ".turbo",
+      ".vitest-cache",
+      "coverage"
+    ]
+  });
+  await saveCodeMap3(paths, map);
+  return true;
+}
+async function refreshCodeSearchIndex(paths) {
+  try {
+    const mod = await import("@hiveai/embeddings");
+    const embedder = await mod.Embedder.create();
+    const { report } = await mod.rebuildCodeIndex(paths, embedder);
+    return report.added > 0 || report.updated > 0 || report.removed > 0;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/sync.ts
+var BRIDGE_START = "<!-- haive:memories-start -->";
+var BRIDGE_END = "<!-- haive:memories-end -->";
+function registerSync(program2) {
+  program2.command("sync").description(
+    "Refresh memory state after a git pull or merge.\n  What it does:\n    1. Verifies anchor paths \u2014 marks stale if files/symbols moved or deleted\n    2. Re-validates previously stale memories that are now fresh\n    3. Auto-promotes proposed memories (by usage count or time delay in autopilot)\n    4. Auto-refreshes code-map if source files changed\n    5. Reports decay warnings for memories unused >90 days\n\n  Install git hooks to run sync automatically: haive install-hooks\n\n  Examples:\n    haive sync\n    haive sync --since main   # also report memories changed since main\n    haive sync --embed        # also rebuild embeddings index\n"
+  ).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").option(
+    "--inject-bridge",
+    "inject top validated memories into CLAUDE.md (or --bridge-file) between <!-- haive:memories-start/end --> markers"
+  ).option("--bridge-file <path>", "bridge file to inject into (default: CLAUDE.md)").option("--bridge-max-memories <n>", "max memories to inject into bridge file", "5").option("--embed", "rebuild embeddings index after sync (requires @haive/embeddings)").option("--no-cross-repo", "skip cross-repo memory pull even if crossRepoSources is configured").option("--no-deps", "skip dependency version tracking").option("--no-contracts", "skip contract file diff checking").action(async (opts) => {
+    const root = findProjectRoot12(opts.dir);
+    const paths = resolveHaivePaths9(root);
+    if (!existsSync31(paths.memoriesDir)) {
+      if (!opts.quiet) ui.warn(`No .ai/memories at ${root}. Run \`haive init\` first.`);
+      process.exitCode = 1;
+      return;
+    }
+    const log = (msg) => {
+      if (!opts.quiet) console.log(msg);
+    };
+    const config = await loadConfig5(paths);
+    const autoApproveDelayHours = config.autoApproveDelayHours ?? null;
+    const autoPromoteMinReads = config.autoPromoteMinReads ?? DEFAULT_AUTO_PROMOTE_RULE2.minReads;
+    const autoRepair = config.autoRepair ?? {};
+    let staleMarked = 0;
+    let revalidated = 0;
+    let promoted = 0;
+    let autoApproved = 0;
+    if (opts.verify !== false) {
+      const memories = await loadMemoriesFromDir24(paths.memoriesDir);
+      for (const { memory: memory2, filePath } of memories) {
+        if (memory2.frontmatter.type === "session_recap") {
+          if (memory2.frontmatter.status === "stale") {
+            await writeFile15(
+              filePath,
+              serializeMemory12({
+                frontmatter: {
+                  ...memory2.frontmatter,
+                  status: "validated",
+                  stale_reason: null,
+                  verified_at: (/* @__PURE__ */ new Date()).toISOString()
+                },
+                body: memory2.body
+              }),
+              "utf8"
+            );
+            revalidated++;
+          }
+          continue;
+        }
+        const isAnchored = memory2.frontmatter.anchor.paths.length > 0 || memory2.frontmatter.anchor.symbols.length > 0;
+        if (!isAnchored) continue;
+        const result = await verifyAnchor2(memory2, { projectRoot: root });
+        const verifiedAt = (/* @__PURE__ */ new Date()).toISOString();
+        if (result.stale) {
+          if (memory2.frontmatter.status !== "stale") {
+            await writeFile15(
+              filePath,
+              serializeMemory12({
+                frontmatter: {
+                  ...memory2.frontmatter,
+                  status: "stale",
+                  verified_at: verifiedAt,
+                  stale_reason: result.reason
+                },
+                body: memory2.body
+              }),
+              "utf8"
+            );
+            staleMarked++;
+          }
+        } else if (memory2.frontmatter.status === "stale") {
+          await writeFile15(
+            filePath,
+            serializeMemory12({
+              frontmatter: {
+                ...memory2.frontmatter,
+                status: "validated",
+                verified_at: verifiedAt,
+                stale_reason: null
+              },
+              body: memory2.body
+            }),
+            "utf8"
+          );
+          revalidated++;
+        }
+      }
+    }
+    if (opts.promote !== false) {
+      const memories = await loadMemoriesFromDir24(paths.memoriesDir);
+      const usage = await loadUsageIndex13(paths);
+      const nowMs = Date.now();
+      for (const { memory: memory2, filePath } of memories) {
+        const fm = memory2.frontmatter;
+        if (fm.type === "session_recap") continue;
+        if (isAutoPromoteEligible2(fm, getUsage11(usage, fm.id), {
+          minReads: autoPromoteMinReads,
+          maxRejections: DEFAULT_AUTO_PROMOTE_RULE2.maxRejections
+        })) {
+          await writeFile15(
+            filePath,
+            serializeMemory12({ frontmatter: { ...fm, status: "validated" }, body: memory2.body }),
+            "utf8"
+          );
+          promoted++;
+          continue;
+        }
+        if (autoApproveDelayHours !== null && fm.status === "proposed" && fm.scope === "team") {
+          const ageHours = (nowMs - new Date(fm.created_at).getTime()) / (1e3 * 60 * 60);
+          if (ageHours >= autoApproveDelayHours) {
+            await writeFile15(
+              filePath,
+              serializeMemory12({
+                frontmatter: {
+                  ...fm,
+                  status: "validated",
+                  verified_at: (/* @__PURE__ */ new Date()).toISOString()
+                },
+                body: memory2.body
+              }),
+              "utf8"
+            );
+            autoApproved++;
+          }
+        }
+      }
+    }
+    if (config.autopilot || autoRepair.context || autoRepair.corpus) {
+      const repairs = await applyAutopilotRepairs(root, paths, {
+        applyContext: autoRepair.context ?? config.autopilot,
+        applyCorpus: autoRepair.corpus ?? config.autopilot,
+        applyCodeMap: false,
+        applyCodeSearch: false
+      });
+      for (const repair of repairs) log(ui.dim(`autopilot: ${repair.message}`));
+    }
+    const sinceReport = opts.since ? collectSinceChanges(root, opts.since) : null;
+    const draftMemories = (await loadMemoriesFromDir24(paths.memoriesDir)).filter(
+      (m) => m.memory.frontmatter.status === "draft"
+    );
+    const draftCount = draftMemories.length;
+    const autoApprovedNote = autoApproved > 0 ? ` \xB7 ${autoApproved} auto-approved` : "";
+    log(
+      `${ui.dim("sync:")} ${staleMarked} stale \xB7 ${revalidated} revalidated \xB7 ${promoted} promoted${autoApprovedNote}${sinceReport ? ` \xB7 ${sinceReport.added.length}+/${sinceReport.modified.length}~/${sinceReport.removed.length}- since ${opts.since}` : ""}`
+    );
+    if (!opts.quiet && draftCount > 0) {
+      log(
+        ui.dim(
+          `\u2139 ${draftCount} memor${draftCount === 1 ? "y" : "ies"} in draft \u2014 run \`haive memory approve <id>\` to activate or \`haive memory list --status draft\` to review`
+        )
       );
     }
     if (opts.injectBridge) {
-      const bridgeFile = opts.bridgeFile ? path13.resolve(opts.bridgeFile) : path13.join(root, "CLAUDE.md");
+      const bridgeFile = opts.bridgeFile ? path15.resolve(opts.bridgeFile) : path15.join(root, "CLAUDE.md");
       const maxInject = Math.max(1, Number(opts.bridgeMaxMemories ?? 5));
       await injectBridge(bridgeFile, paths.memoriesDir, maxInject, root, opts.quiet);
     }
@@ -7672,12 +8164,12 @@ function registerSync(program2) {
       }
     }
     if (!opts.quiet) {
-      const allForDecay = await loadMemoriesFromDir23(paths.memoriesDir);
-      const usageForDecay = await loadUsageIndex12(paths);
+      const allForDecay = await loadMemoriesFromDir24(paths.memoriesDir);
+      const usageForDecay = await loadUsageIndex13(paths);
       const decaying = allForDecay.filter(({ memory: memory2 }) => {
         const fm = memory2.frontmatter;
         if (fm.status === "rejected" || fm.status === "deprecated" || fm.status === "stale") return false;
-        const u = getUsage10(usageForDecay, fm.id);
+        const u = getUsage11(usageForDecay, fm.id);
         return isDecaying2(u, fm.created_at);
       });
       if (decaying.length > 0) {
@@ -7759,11 +8251,11 @@ Attends une **confirmation explicite** avant d'agir.
                   paths: [result.file],
                   topic: `dep-bump-${slugParts}`
                 });
-                const teamDir = path13.join(paths.memoriesDir, "team");
+                const teamDir = path15.join(paths.memoriesDir, "team");
                 await mkdir10(teamDir, { recursive: true });
-                await writeFile13(
-                  path13.join(teamDir, `${fm.id}.md`),
-                  serializeMemory11({ frontmatter: { ...fm, requires_human_approval: true }, body }),
+                await writeFile15(
+                  path15.join(teamDir, `${fm.id}.md`),
+                  serializeMemory12({ frontmatter: { ...fm, requires_human_approval: true }, body }),
                   "utf8"
                 );
                 log(ui.yellow(`   \u2192 memory created: ${fm.id}`));
@@ -7826,11 +8318,11 @@ Attends une **confirmation explicite** avant d'agir.
               paths: [diff.file],
               topic: `contract-breaking-${diff.contract}`
             });
-            const teamDir = path13.join(paths.memoriesDir, "team");
+            const teamDir = path15.join(paths.memoriesDir, "team");
             await mkdir10(teamDir, { recursive: true });
-            await writeFile13(
-              path13.join(teamDir, `${fm.id}.md`),
-              serializeMemory11({ frontmatter: { ...fm, requires_human_approval: true }, body }),
+            await writeFile15(
+              path15.join(teamDir, `${fm.id}.md`),
+              serializeMemory12({ frontmatter: { ...fm, requires_human_approval: true }, body }),
               "utf8"
             );
             log(ui.yellow(`   \u2192 memory created: ${fm.id}`));
@@ -7840,10 +8332,19 @@ Attends une **confirmation explicite** avant d'agir.
         ui.warn(`contract watcher failed: ${String(err)}`);
       }
     }
-    const existingMap = await loadCodeMap4(paths);
-    if (existingMap) {
+    const existingMap = await loadCodeMap6(paths);
+    if (!existingMap && (config.autopilot || autoRepair.codeMap)) {
+      try {
+        const { buildCodeMap: buildCodeMap4, saveCodeMap: saveCodeMap4 } = await import("@hiveai/core");
+        log(ui.dim("code-map: missing \u2014 building index\u2026"));
+        const newMap = await buildCodeMap4(root);
+        await saveCodeMap4(paths, newMap);
+        log(ui.dim(`code-map: built (${Object.keys(newMap.files).length} files)`));
+      } catch {
+      }
+    } else if (existingMap) {
       const mapAge = new Date(existingMap.generated_at).getTime();
-      const gitResult = spawnSync3(
+      const gitResult = spawnSync4(
         "git",
         [
           "diff",
@@ -7868,22 +8369,32 @@ Attends une **confirmation explicite** avant d'agir.
       const changedSourceFiles = (gitResult.stdout ?? "").trim();
       if (changedSourceFiles.length > 0) {
         try {
-          const { buildCodeMap: buildCodeMap3, saveCodeMap: saveCodeMap3 } = await import("@hiveai/core");
+          const { buildCodeMap: buildCodeMap4, saveCodeMap: saveCodeMap4 } = await import("@hiveai/core");
           log(ui.dim("code-map: source files changed \u2014 refreshing index\u2026"));
-          const newMap = await buildCodeMap3(root);
-          await saveCodeMap3(paths, newMap);
+          const newMap = await buildCodeMap4(root);
+          await saveCodeMap4(paths, newMap);
           log(ui.dim(`code-map: refreshed (${Object.keys(newMap.files).length} files)`));
         } catch {
         }
       }
     }
-    if (opts.embed) {
+    if (opts.embed || autoRepair.codeSearch) {
       try {
-        const { Embedder, rebuildIndex } = await import("@hiveai/embeddings");
+        const { Embedder, rebuildCodeIndex, rebuildIndex } = await import("@hiveai/embeddings");
         log(ui.dim("embed: rebuilding index\u2026"));
         const embedder = await Embedder.create();
         const { report } = await rebuildIndex(paths, embedder);
-        log(ui.dim(`embed: index rebuilt (${report.added} added, ${report.updated} updated, ${report.removed} removed)`));
+        const { report: codeReport } = await rebuildCodeIndex(paths, embedder);
+        log(
+          ui.dim(
+            `embed: memory index rebuilt (${report.added} added, ${report.updated} updated, ${report.removed} removed)`
+          )
+        );
+        log(
+          ui.dim(
+            `embed: code index rebuilt (${codeReport.total} symbols, ${codeReport.added} added, ${codeReport.updated} updated, ${codeReport.removed} removed)`
+          )
+        );
       } catch {
         ui.warn("--embed: @hiveai/embeddings not available or index build failed. Run `haive embeddings index` manually.");
       }
@@ -7891,8 +8402,8 @@ Attends une **confirmation explicite** avant d'agir.
   });
 }
 async function injectBridge(bridgeFile, memoriesDir, maxMemories, root, quiet) {
-  if (!existsSync29(memoriesDir)) return;
-  const all = await loadMemoriesFromDir23(memoriesDir);
+  if (!existsSync31(memoriesDir)) return;
+  const all = await loadMemoriesFromDir24(memoriesDir);
   const top = all.filter(({ memory: memory2 }) => {
     const s = memory2.frontmatter.status;
     if (memory2.frontmatter.type === "session_recap") return false;
@@ -7916,17 +8427,17 @@ ${m.memory.body.trim()}`;
 ` + block + `
 
 ${BRIDGE_END}`;
-  const fileExists = existsSync29(bridgeFile);
-  let existing = fileExists ? await readFile8(bridgeFile, "utf8") : "";
+  const fileExists = existsSync31(bridgeFile);
+  let existing = fileExists ? await readFile9(bridgeFile, "utf8") : "";
   existing = existing.replace(/\r\n/g, "\n");
   const startIdx = existing.indexOf(BRIDGE_START);
   const endIdx = existing.indexOf(BRIDGE_END);
   if (startIdx !== -1 && endIdx === -1) {
-    ui.warn(`${path13.relative(root, bridgeFile)}: found ${BRIDGE_START} without ${BRIDGE_END}. Fix the file manually before running --inject-bridge.`);
+    ui.warn(`${path15.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(`${path13.relative(root, bridgeFile)}: found ${BRIDGE_END} without ${BRIDGE_START}. Fix the file manually before running --inject-bridge.`);
+    ui.warn(`${path15.relative(root, bridgeFile)}: found ${BRIDGE_END} without ${BRIDGE_START}. Fix the file manually before running --inject-bridge.`);
     return;
   }
   let updated;
@@ -7934,19 +8445,19 @@ ${BRIDGE_END}`;
     updated = existing.slice(0, startIdx) + injected + existing.slice(endIdx + BRIDGE_END.length);
   } else {
     if (!fileExists && !quiet) {
-      ui.info(`Creating ${path13.relative(root, bridgeFile)} with haive memory block.`);
+      ui.info(`Creating ${path15.relative(root, bridgeFile)} with haive memory block.`);
     }
     updated = existing + (existing.endsWith("\n") ? "" : "\n") + "\n" + injected + "\n";
   }
-  await writeFile13(bridgeFile, updated, "utf8");
+  await writeFile15(bridgeFile, updated, "utf8");
   if (!quiet) {
     console.log(
-      ui.dim(`bridge: injected ${top.length} memor${top.length === 1 ? "y" : "ies"} into ${path13.relative(root, bridgeFile)}`)
+      ui.dim(`bridge: injected ${top.length} memor${top.length === 1 ? "y" : "ies"} into ${path15.relative(root, bridgeFile)}`)
     );
   }
 }
 function collectSinceChanges(root, ref) {
-  const result = spawnSync3(
+  const result = spawnSync4(
     "git",
     ["-C", root, "diff", "--name-status", "--diff-filter=AMD", `${ref}...HEAD`, "--", ".ai/memories"],
     { encoding: "utf8" }
@@ -7966,18 +8477,19 @@ function collectSinceChanges(root, ref) {
 
 // src/commands/memory-add.ts
 import { createHash as createHash2 } from "crypto";
-import { mkdir as mkdir11, readFile as readFile9, writeFile as writeFile14 } from "fs/promises";
-import { existsSync as existsSync30 } from "fs";
-import path14 from "path";
+import { mkdir as mkdir11, readFile as readFile10, writeFile as writeFile16 } from "fs/promises";
+import { existsSync as existsSync33 } from "fs";
+import path16 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter7,
-  findProjectRoot as findProjectRoot12,
+  findProjectRoot as findProjectRoot13,
   inferModulesFromPaths as inferModulesFromPaths3,
-  loadMemoriesFromDir as loadMemoriesFromDir24,
+  loadConfig as loadConfig6,
+  loadMemoriesFromDir as loadMemoriesFromDir25,
   memoryFilePath as memoryFilePath6,
-  resolveHaivePaths as resolveHaivePaths9,
-  serializeMemory as serializeMemory12
+  resolveHaivePaths as resolveHaivePaths10,
+  serializeMemory as serializeMemory13
 } from "@hiveai/core";
 function registerMemoryAdd(memory2) {
   memory2.command("add").description(
@@ -8003,21 +8515,22 @@ function registerMemoryAdd(memory2) {
     haive memory add --type convention --slug flyway-no-modify --topic flyway \\\\
       --scope team --body "Never modify existing migrations. Create V{n+1}__desc.sql."
 `
-  ).requiredOption("--type <type>", "convention | decision | gotcha | architecture | glossary | attempt").requiredOption("--slug <slug>", "short kebab-case identifier used in the file name").option("--title <text>", "memory title \u2014 becomes the first heading of the body").option("--scope <scope>", "personal | team | module (default: personal, or team in autopilot)", "personal").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags for easier retrieval").option("--domain <domain>", "domain (e.g. transactions)").option("--author <author>", "author email or handle").option("--paths <csv>", "anchor to source files \u2014 used for staleness detection by haive sync").option("--symbols <csv>", "anchor to specific symbols (class/function names)").option("--commit <sha>", "anchor to a specific commit SHA").option("--body <text>", "memory body content (Markdown) \u2014 overrides --title default body").option("--body-file <path>", "read memory body from a Markdown file \u2014 for long content").option("--no-auto-tag", "disable automatic tag suggestions inferred from anchor paths").option("--topic <key>", "stable key for upsert: if a memory with this topic+scope already exists, update it in-place (revision_count++)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot12(opts.dir);
-    const paths = resolveHaivePaths9(root);
-    if (!existsSync30(paths.haiveDir)) {
+  ).requiredOption("--type <type>", "convention | decision | gotcha | architecture | glossary | attempt").requiredOption("--slug <slug>", "short kebab-case identifier used in the file name").option("--title <text>", "memory title \u2014 becomes the first heading of the body").option("--scope <scope>", "personal | team | module (default: config default; team in autopilot)").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags for easier retrieval").option("--domain <domain>", "domain (e.g. transactions)").option("--author <author>", "author email or handle").option("--paths <csv>", "anchor to source files \u2014 used for staleness detection by haive sync").option("--symbols <csv>", "anchor to specific symbols (class/function names)").option("--commit <sha>", "anchor to a specific commit SHA").option("--body <text>", "memory body content (Markdown) \u2014 overrides --title default body").option("--body-file <path>", "read memory body from a Markdown file \u2014 for long content").option("--no-auto-tag", "disable automatic tag suggestions inferred from anchor paths").option("--topic <key>", "stable key for upsert: if a memory with this topic+scope already exists, update it in-place (revision_count++)").option("-d, --dir <dir>", "project root").action(async (opts) => {
+    const root = findProjectRoot13(opts.dir);
+    const paths = resolveHaivePaths10(root);
+    if (!existsSync33(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
+    const config = await loadConfig6(paths);
     const userTags = parseCsv2(opts.tags);
     const anchorPaths = parseCsv2(opts.paths);
     const autoTagsEnabled = opts.autoTag !== false;
     const inferredTags = autoTagsEnabled ? inferModulesFromPaths3(anchorPaths) : [];
     const mergedTags = Array.from(/* @__PURE__ */ new Set([...userTags, ...inferredTags]));
     if (anchorPaths.length > 0) {
-      const missing = anchorPaths.filter((p) => !existsSync30(path14.resolve(root, p)));
+      const missing = anchorPaths.filter((p) => !existsSync33(path16.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}`);
@@ -8029,12 +8542,12 @@ function registerMemoryAdd(memory2) {
     const title = opts.title ?? opts.slug;
     let body;
     if (opts.bodyFile !== void 0) {
-      if (!existsSync30(opts.bodyFile)) {
+      if (!existsSync33(opts.bodyFile)) {
         ui.error(`--body-file not found: ${opts.bodyFile}`);
         process.exitCode = 1;
         return;
       }
-      const fileContent = await readFile9(opts.bodyFile, "utf8");
+      const fileContent = await readFile10(opts.bodyFile, "utf8");
       body = opts.title ? `# ${opts.title}
 
 ${fileContent.trim()}
@@ -8049,10 +8562,10 @@ ${opts.body}` : opts.body;
 TODO \u2014 write the memory body.
 `;
     }
-    const scope = opts.scope ?? "personal";
-    if (existsSync30(paths.memoriesDir)) {
+    const scope = opts.scope ?? config.defaultScope ?? "personal";
+    if (existsSync33(paths.memoriesDir)) {
       const incomingHash = createHash2("sha256").update(body.trim()).digest("hex").slice(0, 12);
-      const allForHash = await loadMemoriesFromDir24(paths.memoriesDir);
+      const allForHash = await loadMemoriesFromDir25(paths.memoriesDir);
       const hashDup = allForHash.find(
         ({ memory: memory3 }) => createHash2("sha256").update(memory3.body.trim()).digest("hex").slice(0, 12) === incomingHash && memory3.frontmatter.scope === scope
       );
@@ -8063,8 +8576,8 @@ TODO \u2014 write the memory body.
         return;
       }
     }
-    if (opts.topic && existsSync30(paths.memoriesDir)) {
-      const existing = await loadMemoriesFromDir24(paths.memoriesDir);
+    if (opts.topic && existsSync33(paths.memoriesDir)) {
+      const existing = await loadMemoriesFromDir25(paths.memoriesDir);
       const topicMatch = existing.find(
         ({ memory: memory3 }) => memory3.frontmatter.topic === opts.topic && memory3.frontmatter.scope === scope && (!opts.module || memory3.frontmatter.module === opts.module)
       );
@@ -8081,8 +8594,8 @@ TODO \u2014 write the memory body.
             symbols: parseCsv2(opts.symbols).length ? parseCsv2(opts.symbols) : fm.anchor.symbols
           }
         };
-        await writeFile14(topicMatch.filePath, serializeMemory12({ frontmatter: newFrontmatter, body }), "utf8");
-        ui.success(`Updated (topic upsert) ${path14.relative(root, topicMatch.filePath)}`);
+        await writeFile16(topicMatch.filePath, serializeMemory13({ frontmatter: newFrontmatter, body }), "utf8");
+        ui.success(`Updated (topic upsert) ${path16.relative(root, topicMatch.filePath)}`);
         ui.info(`id=${fm.id}  revision=${revisionCount}`);
         return;
       }
@@ -8098,17 +8611,18 @@ TODO \u2014 write the memory body.
       paths: anchorPaths,
       symbols: parseCsv2(opts.symbols),
       commit: opts.commit,
-      topic: opts.topic
+      topic: opts.topic,
+      status: config.defaultStatus === "validated" ? "validated" : void 0
     });
     const file = memoryFilePath6(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir11(path14.dirname(file), { recursive: true });
-    if (existsSync30(file)) {
+    await mkdir11(path16.dirname(file), { recursive: true });
+    if (existsSync33(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
       return;
     }
-    if (existsSync30(paths.memoriesDir)) {
-      const existing = await loadMemoriesFromDir24(paths.memoriesDir);
+    if (existsSync33(paths.memoriesDir)) {
+      const existing = await loadMemoriesFromDir25(paths.memoriesDir);
       const slugTokens = opts.slug.toLowerCase().split(/[-_\s]+/).filter(Boolean);
       const similar = existing.filter(({ memory: memory3 }) => {
         const id = memory3.frontmatter.id.toLowerCase();
@@ -8119,8 +8633,8 @@ TODO \u2014 write the memory body.
         ui.warn("Consider updating one of these with `haive memory update` instead.");
       }
     }
-    await writeFile14(file, serializeMemory12({ frontmatter, body }), "utf8");
-    ui.success(`Created ${path14.relative(root, file)}`);
+    await writeFile16(file, serializeMemory13({ frontmatter, body }), "utf8");
+    ui.success(`Created ${path16.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)`);
@@ -8131,7 +8645,9 @@ TODO \u2014 write the memory body.
   Add file anchors: haive memory update ${frontmatter.id} --paths <file1,file2>`
       );
     }
-    if (scope === "personal") {
+    if (frontmatter.status === "validated") {
+      console.log(ui.dim("\u2192 autopilot: memory is already validated and active"));
+    } else if (scope === "personal") {
       console.log(
         ui.dim(
           `\u2192 next: haive memory approve ${frontmatter.id}  (activate)  |  haive memory promote ${frontmatter.id}  (share with team)`
@@ -8150,14 +8666,14 @@ function parseCsv2(value) {
 }
 
 // src/commands/memory-list.ts
-import { existsSync as existsSync31 } from "fs";
-import path15 from "path";
+import { existsSync as existsSync34 } from "fs";
+import path17 from "path";
 import "commander";
-import { findProjectRoot as findProjectRoot13, resolveHaivePaths as resolveHaivePaths10 } from "@hiveai/core";
+import { findProjectRoot as findProjectRoot14, resolveHaivePaths as resolveHaivePaths11 } from "@hiveai/core";
 
 // src/utils/fs.ts
 import {
-  loadMemoriesFromDir as loadMemoriesFromDir25,
+  loadMemoriesFromDir as loadMemoriesFromDir26,
   loadMemory,
   listMarkdownFilesRecursive
 } from "@hiveai/core";
@@ -8165,14 +8681,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("--status <csv>", "filter by status (draft,proposed,validated,stale,rejected,deprecated)").option("--show-rejected", "include rejected memories (hidden by default)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot13(opts.dir);
-    const paths = resolveHaivePaths10(root);
-    if (!existsSync31(paths.memoriesDir)) {
+    const root = findProjectRoot14(opts.dir);
+    const paths = resolveHaivePaths11(root);
+    if (!existsSync34(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir25(paths.memoriesDir);
+    const all = await loadMemoriesFromDir26(paths.memoriesDir);
     const statusFilter = opts.status ? opts.status.split(",").map((s) => s.trim()) : null;
     const filtered = all.filter((m) => {
       if (!matchesFilters(m, opts)) return false;
@@ -8199,7 +8715,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(path15.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path17.relative(root, filePath))}`);
     }
     console.log(ui.dim(`
 ${filtered.length} memor${filtered.length === 1 ? "y" : "ies"}`));
@@ -8234,26 +8750,26 @@ function matchesFilters(loaded, opts) {
 }
 
 // src/commands/memory-promote.ts
-import { mkdir as mkdir12, unlink as unlink2, writeFile as writeFile15 } from "fs/promises";
-import { existsSync as existsSync33 } from "fs";
-import path16 from "path";
+import { mkdir as mkdir12, unlink as unlink2, writeFile as writeFile17 } from "fs/promises";
+import { existsSync as existsSync35 } from "fs";
+import path18 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot14,
+  findProjectRoot as findProjectRoot15,
   memoryFilePath as memoryFilePath7,
-  resolveHaivePaths as resolveHaivePaths11,
-  serializeMemory as serializeMemory13
+  resolveHaivePaths as resolveHaivePaths12,
+  serializeMemory as serializeMemory14
 } 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 = findProjectRoot14(opts.dir);
-    const paths = resolveHaivePaths11(root);
-    if (!existsSync33(paths.memoriesDir)) {
+    const root = findProjectRoot15(opts.dir);
+    const paths = resolveHaivePaths12(root);
+    if (!existsSync35(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const teamAndModule = await loadMemoriesFromDir25(paths.memoriesDir);
+    const teamAndModule = await loadMemoriesFromDir26(paths.memoriesDir);
     const alreadyShared = teamAndModule.find(
       (m) => m.memory.frontmatter.id === id && (m.memory.frontmatter.scope === "team" || m.memory.frontmatter.scope === "module")
     );
@@ -8267,7 +8783,7 @@ function registerMemoryPromote(memory2) {
       }
       return;
     }
-    const all = await loadMemoriesFromDir25(paths.personalDir);
+    const all = await loadMemoriesFromDir26(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.)`);
@@ -8283,35 +8799,35 @@ function registerMemoryPromote(memory2) {
       body: found.memory.body
     };
     const newPath = memoryFilePath7(paths, "team", updated.frontmatter.id);
-    await mkdir12(path16.dirname(newPath), { recursive: true });
-    await writeFile15(newPath, serializeMemory13(updated), "utf8");
+    await mkdir12(path18.dirname(newPath), { recursive: true });
+    await writeFile17(newPath, serializeMemory14(updated), "utf8");
     await unlink2(found.filePath);
     ui.success(`Promoted ${id} to team scope (status=proposed)`);
-    ui.info(`Now at ${path16.relative(root, newPath)}`);
+    ui.info(`Now at ${path18.relative(root, newPath)}`);
     console.log(ui.dim(`\u2192 next: haive memory approve ${id}  (validate for team use)`));
   });
 }
 
 // src/commands/memory-approve.ts
-import { existsSync as existsSync34 } from "fs";
-import { writeFile as writeFile16 } from "fs/promises";
-import path17 from "path";
+import { existsSync as existsSync36 } from "fs";
+import { writeFile as writeFile18 } from "fs/promises";
+import path19 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot15,
-  resolveHaivePaths as resolveHaivePaths12,
-  serializeMemory as serializeMemory14
+  findProjectRoot as findProjectRoot16,
+  resolveHaivePaths as resolveHaivePaths13,
+  serializeMemory as serializeMemory15
 } from "@hiveai/core";
 function registerMemoryApprove(memory2) {
   memory2.command("approve [id]").description("Mark a memory as 'validated'. Use --all to bulk-approve all proposed/draft memories.").option("--all", "approve all proposed and draft memories at once").option("--pending", "approve all memories with status 'proposed'").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
-    const root = findProjectRoot15(opts.dir);
-    const paths = resolveHaivePaths12(root);
-    if (!existsSync34(paths.memoriesDir)) {
+    const root = findProjectRoot16(opts.dir);
+    const paths = resolveHaivePaths13(root);
+    if (!existsSync36(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir25(paths.memoriesDir);
+    const all = await loadMemoriesFromDir26(paths.memoriesDir);
     if (opts.all || opts.pending) {
       const candidates = all.filter((m) => {
         const s = m.memory.frontmatter.status;
@@ -8328,7 +8844,7 @@ function registerMemoryApprove(memory2) {
           frontmatter: { ...found2.memory.frontmatter, status: "validated" },
           body: found2.memory.body
         };
-        await writeFile16(found2.filePath, serializeMemory14(next2), "utf8");
+        await writeFile18(found2.filePath, serializeMemory15(next2), "utf8");
         count++;
       }
       ui.success(`Approved ${count} memor${count === 1 ? "y" : "ies"} (status=validated)`);
@@ -8357,32 +8873,32 @@ function registerMemoryApprove(memory2) {
       frontmatter: { ...found.memory.frontmatter, status: "validated" },
       body: found.memory.body
     };
-    await writeFile16(found.filePath, serializeMemory14(next), "utf8");
+    await writeFile18(found.filePath, serializeMemory15(next), "utf8");
     ui.success(`Approved ${id} (status=validated)`);
-    ui.info(path17.relative(root, found.filePath));
+    ui.info(path19.relative(root, found.filePath));
   });
 }
 
 // src/commands/memory-update.ts
-import { writeFile as writeFile17 } from "fs/promises";
-import { existsSync as existsSync35 } from "fs";
-import path18 from "path";
+import { writeFile as writeFile19 } from "fs/promises";
+import { existsSync as existsSync37 } from "fs";
+import path20 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot16,
-  resolveHaivePaths as resolveHaivePaths13,
-  serializeMemory as serializeMemory15
+  findProjectRoot as findProjectRoot17,
+  resolveHaivePaths as resolveHaivePaths14,
+  serializeMemory as serializeMemory16
 } from "@hiveai/core";
 function registerMemoryUpdate(memory2) {
   memory2.command("update <id>").description("Update body, tags, or anchor of an existing memory (preserves id and usage history)").option("--title <text>", "new title \u2014 replaces the first heading of the body").option("--body <text>", "new Markdown body \u2014 replaces the existing body").option("--tags <csv>", "new tags, comma-separated \u2014 fully replaces existing tags").option("--paths <csv>", "new anchor paths, comma-separated").option("--symbols <csv>", "new anchor symbols, comma-separated").option("--commit <sha>", "new anchor commit SHA").option("--domain <domain>", "new domain label").option("--author <author>", "new author handle or email").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
-    const root = findProjectRoot16(opts.dir);
-    const paths = resolveHaivePaths13(root);
-    if (!existsSync35(paths.memoriesDir)) {
+    const root = findProjectRoot17(opts.dir);
+    const paths = resolveHaivePaths14(root);
+    if (!existsSync37(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const memories = await loadMemoriesFromDir25(paths.memoriesDir);
+    const memories = await loadMemoriesFromDir26(paths.memoriesDir);
     const loaded = memories.find((m) => m.memory.frontmatter.id === id);
     if (!loaded) {
       ui.error(`No memory with id "${id}".`);
@@ -8424,12 +8940,12 @@ function registerMemoryUpdate(memory2) {
       ui.warn("Nothing to update \u2014 provide at least one option.");
       return;
     }
-    await writeFile17(
+    await writeFile19(
       loaded.filePath,
-      serializeMemory15({ frontmatter: newFrontmatter, body: newBody }),
+      serializeMemory16({ frontmatter: newFrontmatter, body: newBody }),
       "utf8"
     );
-    ui.success(`Updated ${path18.relative(root, loaded.filePath)}`);
+    ui.success(`Updated ${path20.relative(root, loaded.filePath)}`);
     ui.info(`fields: ${updated.join(", ")}`);
   });
 }
@@ -8448,18 +8964,18 @@ function parseCsv3(value) {
 }
 
 // src/commands/memory-auto-promote.ts
-import { writeFile as writeFile18 } from "fs/promises";
-import { existsSync as existsSync36 } from "fs";
-import path19 from "path";
+import { writeFile as writeFile20 } from "fs/promises";
+import { existsSync as existsSync38 } from "fs";
+import path21 from "path";
 import "commander";
 import {
   DEFAULT_AUTO_PROMOTE_RULE as DEFAULT_AUTO_PROMOTE_RULE3,
-  findProjectRoot as findProjectRoot17,
-  getUsage as getUsage11,
+  findProjectRoot as findProjectRoot18,
+  getUsage as getUsage12,
   isAutoPromoteEligible as isAutoPromoteEligible3,
-  loadUsageIndex as loadUsageIndex13,
-  resolveHaivePaths as resolveHaivePaths14,
-  serializeMemory as serializeMemory16
+  loadUsageIndex as loadUsageIndex14,
+  resolveHaivePaths as resolveHaivePaths15,
+  serializeMemory as serializeMemory17
 } 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_RULE3.minReads)).option(
@@ -8467,9 +8983,9 @@ function registerMemoryAutoPromote(memory2) {
     "memories with more rejections than this are skipped",
     String(DEFAULT_AUTO_PROMOTE_RULE3.maxRejections)
   ).option("--apply", "actually write status=validated to disk (default: dry-run)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot17(opts.dir);
-    const paths = resolveHaivePaths14(root);
-    if (!existsSync36(paths.memoriesDir)) {
+    const root = findProjectRoot18(opts.dir);
+    const paths = resolveHaivePaths15(root);
+    if (!existsSync38(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -8478,10 +8994,10 @@ function registerMemoryAutoPromote(memory2) {
       minReads: Number(opts.minReads ?? DEFAULT_AUTO_PROMOTE_RULE3.minReads),
       maxRejections: Number(opts.maxRejections ?? DEFAULT_AUTO_PROMOTE_RULE3.maxRejections)
     };
-    const memories = await loadMemoriesFromDir25(paths.memoriesDir);
-    const usage = await loadUsageIndex13(paths);
+    const memories = await loadMemoriesFromDir26(paths.memoriesDir);
+    const usage = await loadUsageIndex14(paths);
     const eligible = memories.filter(
-      ({ memory: memory3 }) => isAutoPromoteEligible3(memory3.frontmatter, getUsage11(usage, memory3.frontmatter.id), rule)
+      ({ memory: memory3 }) => isAutoPromoteEligible3(memory3.frontmatter, getUsage12(usage, memory3.frontmatter.id), rule)
     );
     if (eligible.length === 0) {
       ui.info(
@@ -8491,17 +9007,17 @@ function registerMemoryAutoPromote(memory2) {
     }
     let written = 0;
     for (const { memory: mem, filePath } of eligible) {
-      const u = getUsage11(usage, mem.frontmatter.id);
+      const u = getUsage12(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(path19.relative(root, filePath))}`);
+      console.log(`             ${ui.dim(path21.relative(root, filePath))}`);
       if (opts.apply) {
         const next = {
           frontmatter: { ...mem.frontmatter, status: "validated" },
           body: mem.body
         };
-        await writeFile18(filePath, serializeMemory16(next), "utf8");
+        await writeFile20(filePath, serializeMemory17(next), "utf8");
         written++;
       }
     }
@@ -8512,25 +9028,25 @@ function registerMemoryAutoPromote(memory2) {
 
 // src/commands/memory-edit.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync37 } from "fs";
-import { readFile as readFile10 } from "fs/promises";
-import path20 from "path";
+import { existsSync as existsSync39 } from "fs";
+import { readFile as readFile11 } from "fs/promises";
+import path23 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot18,
+  findProjectRoot as findProjectRoot19,
   parseMemory,
-  resolveHaivePaths as resolveHaivePaths15
+  resolveHaivePaths as resolveHaivePaths16
 } 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 = findProjectRoot18(opts.dir);
-    const paths = resolveHaivePaths15(root);
-    if (!existsSync37(paths.memoriesDir)) {
+    const root = findProjectRoot19(opts.dir);
+    const paths = resolveHaivePaths16(root);
+    if (!existsSync39(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir25(paths.memoriesDir);
+    const all = await loadMemoriesFromDir26(paths.memoriesDir);
     const found = all.find((m) => m.memory.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory with id "${id}".`);
@@ -8538,13 +9054,13 @@ function registerMemoryEdit(memory2) {
       return;
     }
     const editor = opts.editor ?? process.env.EDITOR ?? process.env.VISUAL ?? "vi";
-    ui.info(`Opening ${path20.relative(root, found.filePath)} with ${editor}\u2026`);
+    ui.info(`Opening ${path23.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 readFile10(found.filePath, "utf8");
+      const fresh = await readFile11(found.filePath, "utf8");
       parseMemory(fresh);
       ui.success("Memory still parses cleanly.");
     } catch (err) {
@@ -8565,29 +9081,29 @@ function runEditor(editor, file) {
 }
 
 // src/commands/memory-for-files.ts
-import { existsSync as existsSync38 } from "fs";
-import path21 from "path";
+import { existsSync as existsSync40 } from "fs";
+import path24 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence9,
-  findProjectRoot as findProjectRoot19,
-  getUsage as getUsage12,
+  findProjectRoot as findProjectRoot20,
+  getUsage as getUsage13,
   inferModulesFromPaths as inferModulesFromPaths4,
-  loadUsageIndex as loadUsageIndex14,
+  loadUsageIndex as loadUsageIndex15,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths5,
-  resolveHaivePaths as resolveHaivePaths16
+  resolveHaivePaths as resolveHaivePaths17
 } 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 = findProjectRoot19(opts.dir);
-    const paths = resolveHaivePaths16(root);
-    if (!existsSync38(paths.memoriesDir)) {
+    const root = findProjectRoot20(opts.dir);
+    const paths = resolveHaivePaths17(root);
+    if (!existsSync40(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir25(paths.memoriesDir);
-    const usage = await loadUsageIndex14(paths);
+    const all = await loadMemoriesFromDir26(paths.memoriesDir);
+    const usage = await loadUsageIndex15(paths);
     const inferred = inferModulesFromPaths4(files);
     const byAnchor = [];
     const byModule = [];
@@ -8685,44 +9201,44 @@ function printGroup(root, label, loaded, usage) {
 \u2014 ${label} \u2014`));
   for (const { memory: mem, filePath } of loaded) {
     const fm = mem.frontmatter;
-    const u = getUsage12(usage, fm.id);
+    const u = getUsage13(usage, fm.id);
     const conf = deriveConfidence9(fm, u);
     console.log(`${ui.bold(fm.id)}  ${ui.dim(`${fm.scope}/${fm.type}`)}  ${ui.bold(conf)}`);
-    console.log(`  ${ui.dim(path21.relative(root, filePath))}`);
+    console.log(`  ${ui.dim(path24.relative(root, filePath))}`);
   }
 }
 
 // src/commands/memory-hot.ts
-import { existsSync as existsSync39 } from "fs";
-import path23 from "path";
+import { existsSync as existsSync41 } from "fs";
+import path25 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot20,
-  getUsage as getUsage13,
-  loadUsageIndex as loadUsageIndex15,
-  resolveHaivePaths as resolveHaivePaths17
+  findProjectRoot as findProjectRoot21,
+  getUsage as getUsage14,
+  loadUsageIndex as loadUsageIndex16,
+  resolveHaivePaths as resolveHaivePaths18
 } 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 = findProjectRoot20(opts.dir);
-    const paths = resolveHaivePaths17(root);
-    if (!existsSync39(paths.memoriesDir)) {
+    const root = findProjectRoot21(opts.dir);
+    const paths = resolveHaivePaths18(root);
+    if (!existsSync41(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 loadMemoriesFromDir25(paths.memoriesDir);
-    const usage = await loadUsageIndex15(paths);
+    const all = await loadMemoriesFromDir26(paths.memoriesDir);
+    const usage = await loadUsageIndex16(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 getUsage13(usage, fm.id).read_count >= threshold;
+      return getUsage14(usage, fm.id).read_count >= threshold;
     }).sort(
-      (a, b) => getUsage13(usage, b.memory.frontmatter.id).read_count - getUsage13(usage, a.memory.frontmatter.id).read_count
+      (a, b) => getUsage14(usage, b.memory.frontmatter.id).read_count - getUsage14(usage, a.memory.frontmatter.id).read_count
     );
     if (candidates.length === 0) {
       ui.info(`No hot memories (threshold=${threshold}).`);
@@ -8730,11 +9246,11 @@ function registerMemoryHot(memory2) {
     }
     for (const { memory: mem, filePath } of candidates) {
       const fm = mem.frontmatter;
-      const u = getUsage13(usage, fm.id);
+      const u = getUsage14(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(path23.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path25.relative(root, filePath))}`);
     }
     ui.info(
       `${candidates.length} hot \u2014 promote drafts with \`haive memory promote <id>\`, then \`haive memory auto-promote --apply\`.`
@@ -8743,16 +9259,16 @@ function registerMemoryHot(memory2) {
 }
 
 // src/commands/memory-tried.ts
-import { mkdir as mkdir13, writeFile as writeFile19 } from "fs/promises";
-import { existsSync as existsSync40 } from "fs";
-import path24 from "path";
+import { mkdir as mkdir13, writeFile as writeFile21 } from "fs/promises";
+import { existsSync as existsSync43 } from "fs";
+import path26 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter8,
-  findProjectRoot as findProjectRoot21,
+  findProjectRoot as findProjectRoot22,
   memoryFilePath as memoryFilePath8,
-  resolveHaivePaths as resolveHaivePaths18,
-  serializeMemory as serializeMemory17
+  resolveHaivePaths as resolveHaivePaths19,
+  serializeMemory as serializeMemory18
 } from "@hiveai/core";
 function registerMemoryTried(memory2) {
   memory2.command("tried").description(
@@ -8771,9 +9287,9 @@ function registerMemoryTried(memory2) {
       --paths packages/cli/src/index.ts
 `
   ).requiredOption("--what <text>", "what approach was tried (short, descriptive title)").requiredOption("--why-failed <text>", "why it failed or should NOT be used (include the exact error if possible)").option("--instead <text>", "the correct approach to use instead").option("--scope <scope>", "personal | team | module (default: personal)", "personal").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags").option("--paths <csv>", "anchor paths, comma-separated").option("--author <author>", "author email or handle").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot21(opts.dir);
-    const paths = resolveHaivePaths18(root);
-    if (!existsSync40(paths.haiveDir)) {
+    const root = findProjectRoot22(opts.dir);
+    const paths = resolveHaivePaths19(root);
+    if (!existsSync43(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -8796,14 +9312,14 @@ function registerMemoryTried(memory2) {
     }
     const body = lines.join("\n") + "\n";
     const file = memoryFilePath8(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir13(path24.dirname(file), { recursive: true });
-    if (existsSync40(file)) {
+    await mkdir13(path26.dirname(file), { recursive: true });
+    if (existsSync43(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
       return;
     }
-    await writeFile19(file, serializeMemory17({ frontmatter, body }), "utf8");
-    ui.success(`Recorded: ${path24.relative(root, file)}`);
+    await writeFile21(file, serializeMemory18({ frontmatter, body }), "utf8");
+    ui.success(`Recorded: ${path26.relative(root, file)}`);
     ui.info(`id=${frontmatter.id}  type=attempt  status=validated (auto-approved)`);
   });
 }
@@ -8813,26 +9329,26 @@ function parseCsv4(value) {
 }
 
 // src/commands/memory-pending.ts
-import { existsSync as existsSync41 } from "fs";
-import path25 from "path";
+import { existsSync as existsSync44 } from "fs";
+import path27 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot22,
-  getUsage as getUsage14,
-  loadUsageIndex as loadUsageIndex16,
-  resolveHaivePaths as resolveHaivePaths19
+  findProjectRoot as findProjectRoot23,
+  getUsage as getUsage15,
+  loadUsageIndex as loadUsageIndex17,
+  resolveHaivePaths as resolveHaivePaths20
 } 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 = findProjectRoot22(opts.dir);
-    const paths = resolveHaivePaths19(root);
-    if (!existsSync41(paths.memoriesDir)) {
+    const root = findProjectRoot23(opts.dir);
+    const paths = resolveHaivePaths20(root);
+    if (!existsSync44(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir25(paths.memoriesDir);
-    const usage = await loadUsageIndex16(paths);
+    const all = await loadMemoriesFromDir26(paths.memoriesDir);
+    const usage = await loadUsageIndex17(paths);
     const proposed = all.filter(({ memory: mem }) => {
       if (mem.frontmatter.status !== "proposed") return false;
       if (opts.scope && mem.frontmatter.scope !== opts.scope) return false;
@@ -8843,42 +9359,42 @@ function registerMemoryPending(memory2) {
       return;
     }
     proposed.sort(
-      (a, b) => getUsage14(usage, b.memory.frontmatter.id).read_count - getUsage14(usage, a.memory.frontmatter.id).read_count
+      (a, b) => getUsage15(usage, b.memory.frontmatter.id).read_count - getUsage15(usage, a.memory.frontmatter.id).read_count
     );
     const now = Date.now();
     for (const { memory: mem, filePath } of proposed) {
       const fm = mem.frontmatter;
-      const u = getUsage14(usage, fm.id);
+      const u = getUsage15(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(path25.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path27.relative(root, filePath))}`);
     }
     ui.info(`${proposed.length} pending`);
   });
 }
 
 // src/commands/memory-query.ts
-import { existsSync as existsSync43 } from "fs";
-import path26 from "path";
+import { existsSync as existsSync45 } from "fs";
+import path28 from "path";
 import "commander";
 import {
   extractSnippet as extractSnippet2,
-  findProjectRoot as findProjectRoot23,
+  findProjectRoot as findProjectRoot24,
   literalMatchesAllTokens as literalMatchesAllTokens3,
   literalMatchesAnyToken as literalMatchesAnyToken4,
   pickSnippetNeedle as pickSnippetNeedle2,
-  resolveHaivePaths as resolveHaivePaths20,
+  resolveHaivePaths as resolveHaivePaths21,
   tokenizeQuery as tokenizeQuery6,
   trackReads as trackReads4
 } from "@hiveai/core";
 function registerMemoryQuery(memory2) {
   memory2.command("query <text>").alias("search").description("Search memories by id, tag, or substring (AND, OR fallback). Alias: search").option("-d, --dir <dir>", "project root").option("--limit <n>", "max results", "20").option("--scope <scope>", "personal | team | module").option("--status <csv>", "filter by status (draft,proposed,validated,stale,rejected)").option("--show-rejected", "include rejected memories (hidden by default)").action(async (text, opts) => {
-    const root = findProjectRoot23(opts.dir);
-    const paths = resolveHaivePaths20(root);
-    if (!existsSync43(paths.memoriesDir)) {
+    const root = findProjectRoot24(opts.dir);
+    const paths = resolveHaivePaths21(root);
+    if (!existsSync45(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -8889,7 +9405,7 @@ function registerMemoryQuery(memory2) {
       return;
     }
     const statusFilter = opts.status ? opts.status.split(",").map((s) => s.trim()) : null;
-    const all = await loadMemoriesFromDir25(paths.memoriesDir);
+    const all = await loadMemoriesFromDir26(paths.memoriesDir);
     const passesFilters2 = (mem) => {
       const fm = mem.frontmatter;
       if (opts.scope && fm.scope !== opts.scope) return false;
@@ -8919,7 +9435,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(path26.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path28.relative(root, filePath))}`);
       const snippet = extractSnippet2(mem.body, snippetNeedle);
       if (snippet) console.log(`  ${snippet}`);
     }
@@ -8936,36 +9452,36 @@ ${top.length} of ${matches.length} match${matches.length === 1 ? "" : "es"}`)
 }
 
 // src/commands/memory-reject.ts
-import { writeFile as writeFile20 } from "fs/promises";
-import { existsSync as existsSync44 } from "fs";
+import { writeFile as writeFile23 } from "fs/promises";
+import { existsSync as existsSync46 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot24,
-  loadUsageIndex as loadUsageIndex17,
+  findProjectRoot as findProjectRoot25,
+  loadUsageIndex as loadUsageIndex18,
   recordRejection as recordRejection2,
-  resolveHaivePaths as resolveHaivePaths21,
+  resolveHaivePaths as resolveHaivePaths22,
   saveUsageIndex as saveUsageIndex3,
-  serializeMemory as serializeMemory18
+  serializeMemory as serializeMemory19
 } 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 = findProjectRoot24(opts.dir);
-    const paths = resolveHaivePaths21(root);
-    if (!existsSync44(paths.memoriesDir)) {
+    const root = findProjectRoot25(opts.dir);
+    const paths = resolveHaivePaths22(root);
+    if (!existsSync46(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const memories = await loadMemoriesFromDir25(paths.memoriesDir);
+    const memories = await loadMemoriesFromDir26(paths.memoriesDir);
     const loaded = memories.find((m) => m.memory.frontmatter.id === id);
     if (!loaded) {
       ui.error(`No memory with id "${id}".`);
       process.exitCode = 1;
       return;
     }
-    await writeFile20(
+    await writeFile23(
       loaded.filePath,
-      serializeMemory18({
+      serializeMemory19({
         frontmatter: {
           ...loaded.memory.frontmatter,
           status: "rejected",
@@ -8975,7 +9491,7 @@ function registerMemoryReject(memory2) {
       }),
       "utf8"
     );
-    const idx = await loadUsageIndex17(paths);
+    const idx = await loadUsageIndex18(paths);
     recordRejection2(idx, id, opts.reason ?? null);
     await saveUsageIndex3(paths, idx);
     const u = idx.by_id[id];
@@ -8987,34 +9503,34 @@ function registerMemoryReject(memory2) {
 }
 
 // src/commands/memory-rm.ts
-import { existsSync as existsSync45 } from "fs";
+import { existsSync as existsSync47 } from "fs";
 import { unlink as unlink3 } from "fs/promises";
-import path27 from "path";
+import path29 from "path";
 import { createInterface as createInterface2 } from "readline/promises";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot25,
-  loadUsageIndex as loadUsageIndex18,
-  resolveHaivePaths as resolveHaivePaths22,
+  findProjectRoot as findProjectRoot26,
+  loadUsageIndex as loadUsageIndex19,
+  resolveHaivePaths as resolveHaivePaths23,
   saveUsageIndex as saveUsageIndex4
 } 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 = findProjectRoot25(opts.dir);
-    const paths = resolveHaivePaths22(root);
-    if (!existsSync45(paths.memoriesDir)) {
+    const root = findProjectRoot26(opts.dir);
+    const paths = resolveHaivePaths23(root);
+    if (!existsSync47(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir25(paths.memoriesDir);
+    const all = await loadMemoriesFromDir26(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 = path27.relative(root, found.filePath);
+    const rel = path29.relative(root, found.filePath);
     if (!opts.yes) {
       const rl = createInterface2({ input: process.stdin, output: process.stdout });
       const answer = (await rl.question(`Delete ${rel}? [y/N] `)).trim().toLowerCase();
@@ -9027,7 +9543,7 @@ function registerMemoryRm(memory2) {
     await unlink3(found.filePath);
     ui.success(`Deleted ${rel}`);
     if (!opts.keepUsage) {
-      const idx = await loadUsageIndex18(paths);
+      const idx = await loadUsageIndex19(paths);
       if (idx.by_id[id]) {
         delete idx.by_id[id];
         await saveUsageIndex4(paths, idx);
@@ -9038,27 +9554,27 @@ function registerMemoryRm(memory2) {
 }
 
 // src/commands/memory-show.ts
-import { existsSync as existsSync46 } from "fs";
-import { readFile as readFile11 } from "fs/promises";
-import path28 from "path";
+import { existsSync as existsSync48 } from "fs";
+import { readFile as readFile12 } from "fs/promises";
+import path30 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence10,
-  findProjectRoot as findProjectRoot26,
-  getUsage as getUsage15,
-  loadUsageIndex as loadUsageIndex19,
-  resolveHaivePaths as resolveHaivePaths23
+  findProjectRoot as findProjectRoot27,
+  getUsage as getUsage16,
+  loadUsageIndex as loadUsageIndex20,
+  resolveHaivePaths as resolveHaivePaths24
 } 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 = findProjectRoot26(opts.dir);
-    const paths = resolveHaivePaths23(root);
-    if (!existsSync46(paths.memoriesDir)) {
+    const root = findProjectRoot27(opts.dir);
+    const paths = resolveHaivePaths24(root);
+    if (!existsSync48(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir25(paths.memoriesDir);
+    const all = await loadMemoriesFromDir26(paths.memoriesDir);
     const found = all.find((m) => m.memory.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory with id "${id}".`);
@@ -9066,12 +9582,12 @@ function registerMemoryShow(memory2) {
       return;
     }
     if (opts.raw) {
-      console.log(await readFile11(found.filePath, "utf8"));
+      console.log(await readFile12(found.filePath, "utf8"));
       return;
     }
     const fm = found.memory.frontmatter;
-    const usage = await loadUsageIndex19(paths);
-    const u = getUsage15(usage, fm.id);
+    const usage = await loadUsageIndex20(paths);
+    const u = getUsage16(usage, fm.id);
     const conf = deriveConfidence10(fm, u);
     console.log(ui.bold(fm.id));
     console.log(`${ui.dim("scope:")}      ${fm.scope}${fm.module ? ` / ${fm.module}` : ""}`);
@@ -9082,7 +9598,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:")}       ${path28.relative(root, found.filePath)}`);
+    console.log(`${ui.dim("file:")}       ${path30.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}`);
@@ -9097,38 +9613,38 @@ function registerMemoryShow(memory2) {
 }
 
 // src/commands/memory-stats.ts
-import { existsSync as existsSync47 } from "fs";
-import path29 from "path";
+import { existsSync as existsSync49 } from "fs";
+import path31 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence11,
-  findProjectRoot as findProjectRoot27,
-  getUsage as getUsage16,
-  loadUsageIndex as loadUsageIndex20,
-  resolveHaivePaths as resolveHaivePaths24
+  findProjectRoot as findProjectRoot28,
+  getUsage as getUsage17,
+  loadUsageIndex as loadUsageIndex21,
+  resolveHaivePaths as resolveHaivePaths25
 } 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 = findProjectRoot27(opts.dir);
-    const paths = resolveHaivePaths24(root);
-    if (!existsSync47(paths.memoriesDir)) {
+    const root = findProjectRoot28(opts.dir);
+    const paths = resolveHaivePaths25(root);
+    if (!existsSync49(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir25(paths.memoriesDir);
-    const usage = await loadUsageIndex20(paths);
+    const all = await loadMemoriesFromDir26(paths.memoriesDir);
+    const usage = await loadUsageIndex21(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) => getUsage16(usage, b.memory.frontmatter.id).read_count - getUsage16(usage, a.memory.frontmatter.id).read_count
+      (a, b) => getUsage17(usage, b.memory.frontmatter.id).read_count - getUsage17(usage, a.memory.frontmatter.id).read_count
     );
     for (const { memory: mem, filePath } of target) {
       const fm = mem.frontmatter;
-      const u = getUsage16(usage, fm.id);
+      const u = getUsage17(usage, fm.id);
       const conf = deriveConfidence11(fm, u);
       console.log(
         `${ui.bold(fm.id)}  ${ui.dim(`${fm.scope}/${fm.type}`)}  ${ui.bold(conf)}`
@@ -9136,34 +9652,34 @@ 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(path29.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path31.relative(root, filePath))}`);
     }
   });
 }
 
 // src/commands/memory-verify.ts
-import { writeFile as writeFile21 } from "fs/promises";
-import { existsSync as existsSync48 } from "fs";
-import path30 from "path";
+import { writeFile as writeFile24 } from "fs/promises";
+import { existsSync as existsSync50 } from "fs";
+import path33 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot28,
-  resolveHaivePaths as resolveHaivePaths25,
-  serializeMemory as serializeMemory19,
+  findProjectRoot as findProjectRoot29,
+  resolveHaivePaths as resolveHaivePaths26,
+  serializeMemory as serializeMemory20,
   verifyAnchor as verifyAnchor3
 } from "@hiveai/core";
 function registerMemoryVerify(memory2) {
   memory2.command("verify").description(
     "Check that memory anchor paths still exist in the current codebase.\n\n  A memory is 'stale' when its anchored file or symbol was moved, deleted, or renamed.\n  Stale memories are shown with a warning in get_briefing and should be updated or deleted.\n\n  haive sync runs this automatically. Use this command for on-demand checks or in CI.\n\n  CI recommendation: add 'haive memory verify' to your haive-sync.yml PR check job\n  to catch stale memories before they reach main.\n\n  Examples:\n    haive memory verify                          # check all, report only\n    haive memory verify --update                 # mark stale/fresh on disk\n    haive memory verify --id 2026-04-28-gotcha-x # check one memory\n"
   ).option("--id <id>", "verify a single memory by id").option("--all", "verify every memory (default if --id is omitted)").option("--update", "write status=stale or status=validated back to disk").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot28(opts.dir);
-    const paths = resolveHaivePaths25(root);
-    if (!existsSync48(paths.memoriesDir)) {
+    const root = findProjectRoot29(opts.dir);
+    const paths = resolveHaivePaths26(root);
+    if (!existsSync50(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir25(paths.memoriesDir);
+    const all = await loadMemoriesFromDir26(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}".`);
@@ -9181,7 +9697,7 @@ function registerMemoryVerify(memory2) {
         anchorlessIds.push(mem.frontmatter.id);
         continue;
       }
-      const rel = path30.relative(root, filePath);
+      const rel = path33.relative(root, filePath);
       if (result.stale) {
         staleCount++;
         console.log(`${ui.bold("STALE")}  ${mem.frontmatter.id}`);
@@ -9196,7 +9712,7 @@ function registerMemoryVerify(memory2) {
       }
       if (opts.update) {
         const next = applyVerification2(mem, result);
-        await writeFile21(filePath, serializeMemory19(next), "utf8");
+        await writeFile24(filePath, serializeMemory20(next), "utf8");
         updated++;
       }
     }
@@ -9244,30 +9760,30 @@ function applyVerification2(mem, result) {
 }
 
 // src/commands/memory-import.ts
-import { readFile as readFile12 } from "fs/promises";
-import { existsSync as existsSync49 } from "fs";
+import { readFile as readFile13 } from "fs/promises";
+import { existsSync as existsSync51 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot29,
-  resolveHaivePaths as resolveHaivePaths26
+  findProjectRoot as findProjectRoot30,
+  resolveHaivePaths as resolveHaivePaths27
 } from "@hiveai/core";
 function registerMemoryImport(memory2) {
   memory2.command("import").description(
     "Parse a Markdown file and suggest memories via the import_docs MCP prompt (prints a ready-to-use prompt invocation)"
   ).requiredOption("--from <file>", "Markdown/text file to import from").option("--scope <scope>", "personal | team (default: team)", "team").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot29(opts.dir);
-    const paths = resolveHaivePaths26(root);
-    if (!existsSync49(paths.haiveDir)) {
+    const root = findProjectRoot30(opts.dir);
+    const paths = resolveHaivePaths27(root);
+    if (!existsSync51(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    if (!existsSync49(opts.from)) {
+    if (!existsSync51(opts.from)) {
       ui.error(`File not found: ${opts.from}`);
       process.exitCode = 1;
       return;
     }
-    const content = await readFile12(opts.from, "utf8");
+    const content = await readFile13(opts.from, "utf8");
     const scope = opts.scope ?? "team";
     ui.info(`Preparing import from: ${opts.from}  (scope=${scope})`);
     ui.info(`Content length: ${content.length} chars`);
@@ -9295,15 +9811,15 @@ function registerMemoryImport(memory2) {
 }
 
 // src/commands/memory-import-changelog.ts
-import { existsSync as existsSync50 } from "fs";
-import { readFile as readFile13, mkdir as mkdir14, writeFile as writeFile23 } from "fs/promises";
-import path31 from "path";
+import { existsSync as existsSync53 } from "fs";
+import { readFile as readFile14, mkdir as mkdir14, writeFile as writeFile25 } from "fs/promises";
+import path34 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter9,
-  findProjectRoot as findProjectRoot30,
-  resolveHaivePaths as resolveHaivePaths27,
-  serializeMemory as serializeMemory20
+  findProjectRoot as findProjectRoot31,
+  resolveHaivePaths as resolveHaivePaths28,
+  serializeMemory as serializeMemory21
 } from "@hiveai/core";
 function parseChangelog(content) {
   const entries = [];
@@ -9367,15 +9883,15 @@ function registerMemoryImportChangelog(memory2) {
     "--versions <csv>",
     "only import specific versions (comma-separated), or 'latest' for the most recent breaking version"
   ).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot30(opts.dir);
-    const paths = resolveHaivePaths27(root);
-    const changelogPath = path31.resolve(root, opts.fromChangelog);
-    if (!existsSync50(changelogPath)) {
+    const root = findProjectRoot31(opts.dir);
+    const paths = resolveHaivePaths28(root);
+    const changelogPath = path34.resolve(root, opts.fromChangelog);
+    if (!existsSync53(changelogPath)) {
       ui.error(`CHANGELOG not found: ${changelogPath}`);
       process.exitCode = 1;
       return;
     }
-    const content = await readFile13(changelogPath, "utf8");
+    const content = await readFile14(changelogPath, "utf8");
     let entries = parseChangelog(content);
     if (entries.length === 0) {
       ui.warn("No breaking changes, deprecations, or removals found in the CHANGELOG.");
@@ -9390,9 +9906,9 @@ function registerMemoryImportChangelog(memory2) {
         entries = entries.filter((e) => requested.includes(e.version));
       }
     }
-    const pkgName = opts.package ?? path31.basename(path31.dirname(changelogPath));
+    const pkgName = opts.package ?? path34.basename(path34.dirname(changelogPath));
     const scope = opts.scope ?? "team";
-    const teamDir = path31.join(paths.memoriesDir, scope);
+    const teamDir = path34.join(paths.memoriesDir, scope);
     await mkdir14(teamDir, { recursive: true });
     let saved = 0;
     for (const entry of entries) {
@@ -9415,7 +9931,7 @@ function registerMemoryImportChangelog(memory2) {
         lines.push("");
       }
       lines.push(
-        `**Source:** \`${path31.relative(root, changelogPath)}\`  
+        `**Source:** \`${path34.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, "-")}`;
@@ -9430,12 +9946,12 @@ function registerMemoryImportChangelog(memory2) {
           pkgName.replace(/[^a-z0-9]/gi, "-").toLowerCase(),
           `v${entry.version}`
         ],
-        paths: [path31.relative(root, changelogPath)],
+        paths: [path34.relative(root, changelogPath)],
         topic: `changelog-${pkgName}-${entry.version}`
       });
-      await writeFile23(
-        path31.join(teamDir, `${fm.id}.md`),
-        serializeMemory20({ frontmatter: fm, body: lines.join("\n") }),
+      await writeFile25(
+        path34.join(teamDir, `${fm.id}.md`),
+        serializeMemory21({ frontmatter: fm, body: lines.join("\n") }),
         "utf8"
       );
       console.log(ui.green(`  \u2713 ${fm.id}`));
@@ -9457,17 +9973,17 @@ ${ui.bold(`Imported ${saved} changelog entr${saved === 1 ? "y" : "ies"} from ${p
 }
 
 // src/commands/memory-digest.ts
-import { existsSync as existsSync51 } from "fs";
-import { writeFile as writeFile24 } from "fs/promises";
-import path33 from "path";
+import { existsSync as existsSync54 } from "fs";
+import { writeFile as writeFile26 } from "fs/promises";
+import path35 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence12,
-  findProjectRoot as findProjectRoot31,
-  getUsage as getUsage17,
-  loadMemoriesFromDir as loadMemoriesFromDir26,
-  loadUsageIndex as loadUsageIndex21,
-  resolveHaivePaths as resolveHaivePaths28
+  findProjectRoot as findProjectRoot32,
+  getUsage as getUsage18,
+  loadMemoriesFromDir as loadMemoriesFromDir27,
+  loadUsageIndex as loadUsageIndex23,
+  resolveHaivePaths as resolveHaivePaths29
 } from "@hiveai/core";
 var CONFIDENCE_EMOJI = {
   unverified: "\u2B1C",
@@ -9480,9 +9996,9 @@ function registerMemoryDigest(program2) {
   program2.command("digest").description(
     "Generate a Markdown review digest of recently added or updated memories.\n\n  Groups memories by type, shows confidence, status, read count, and anchor info.\n  Each memory has action checkboxes (approve / reject / keep as-is) for peer review.\n\n  Use this to do a bulk weekly review of team memories, or share with teammates\n  as a pull-request attachment so humans can validate what the AI captured.\n\n  Examples:\n    haive memory digest                         # last 7 days, team scope\n    haive memory digest --days 30 --scope all   # last 30 days, all scopes\n    haive memory digest --out review.md         # write to file\n"
   ).option("--days <n>", "look-back window in days (default: 7)", "7").option("--scope <scope>", "personal | team | module | all (default: team)", "team").option("--out <file>", "write digest to a file instead of stdout").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot31(opts.dir);
-    const paths = resolveHaivePaths28(root);
-    if (!existsSync51(paths.memoriesDir)) {
+    const root = findProjectRoot32(opts.dir);
+    const paths = resolveHaivePaths29(root);
+    if (!existsSync54(paths.memoriesDir)) {
       ui.error("No .ai/memories found. Run `haive init` first.");
       process.exitCode = 1;
       return;
@@ -9490,8 +10006,8 @@ function registerMemoryDigest(program2) {
     const days = Math.max(1, Number(opts.days ?? 7));
     const scopeFilter = opts.scope ?? "team";
     const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1e3);
-    const all = await loadMemoriesFromDir26(paths.memoriesDir);
-    const usage = await loadUsageIndex21(paths);
+    const all = await loadMemoriesFromDir27(paths.memoriesDir);
+    const usage = await loadUsageIndex23(paths);
     const recent = all.filter(({ memory: mem }) => {
       const fm = mem.frontmatter;
       if (fm.type === "session_recap") return false;
@@ -9522,7 +10038,7 @@ function registerMemoryDigest(program2) {
         lines.push(``);
         for (const { memory: mem } of mems) {
           const fm = mem.frontmatter;
-          const u = getUsage17(usage, fm.id);
+          const u = getUsage18(usage, fm.id);
           const confidence = deriveConfidence12(fm, u);
           const emoji = CONFIDENCE_EMOJI[confidence] ?? "\u2B1C";
           const anchor = fm.anchor.paths.length > 0 ? `\`${fm.anchor.paths[0]}\`` + (fm.anchor.paths.length > 1 ? ` +${fm.anchor.paths.length - 1}` : "") : "_no anchor_";
@@ -9554,8 +10070,8 @@ function registerMemoryDigest(program2) {
     );
     const digest = lines.join("\n");
     if (opts.out) {
-      const outPath = path33.resolve(process.cwd(), opts.out);
-      await writeFile24(outPath, digest, "utf8");
+      const outPath = path35.resolve(process.cwd(), opts.out);
+      await writeFile26(outPath, digest, "utf8");
       ui.success(`Digest written to ${opts.out}  (${recent.length} memor${recent.length === 1 ? "y" : "ies"})`);
     } else {
       console.log(digest);
@@ -9564,22 +10080,22 @@ function registerMemoryDigest(program2) {
 }
 
 // src/commands/session-end.ts
-import { writeFile as writeFile25, mkdir as mkdir15, readFile as readFile14, rm as rm2 } from "fs/promises";
-import { existsSync as existsSync53 } from "fs";
-import path34 from "path";
+import { writeFile as writeFile27, mkdir as mkdir15, readFile as readFile15, rm as rm2 } from "fs/promises";
+import { existsSync as existsSync55 } from "fs";
+import path36 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter10,
-  findProjectRoot as findProjectRoot32,
-  loadMemoriesFromDir as loadMemoriesFromDir27,
+  findProjectRoot as findProjectRoot33,
+  loadMemoriesFromDir as loadMemoriesFromDir28,
   memoryFilePath as memoryFilePath9,
-  resolveHaivePaths as resolveHaivePaths29,
-  serializeMemory as serializeMemory21
+  resolveHaivePaths as resolveHaivePaths30,
+  serializeMemory as serializeMemory23
 } from "@hiveai/core";
 async function buildAutoRecap(paths) {
-  const obsFile = path34.join(paths.haiveDir, ".cache", "observations.jsonl");
-  if (!existsSync53(obsFile)) return null;
-  const raw = await readFile14(obsFile, "utf8").catch(() => "");
+  const obsFile = path36.join(paths.haiveDir, ".cache", "observations.jsonl");
+  if (!existsSync55(obsFile)) return null;
+  const raw = await readFile15(obsFile, "utf8").catch(() => "");
   if (!raw.trim()) return null;
   const lines = raw.split("\n").filter(Boolean);
   const obs = [];
@@ -9657,9 +10173,9 @@ function registerSessionEnd(session2) {
       --next "Add integration tests for webhook signature validation"
 `
   ).option("--goal <text>", "what you were trying to accomplish (1\u20132 sentences)").option("--accomplished <text>", "what was actually done (bullet list recommended)").option("--discoveries <text>", "bugs, surprises, or inconsistencies found during this session").option("--files <csv>", "key files touched, comma-separated (used as anchor for staleness detection)").option("--next <text>", "what should happen next (for the next session or a teammate)").option("--scope <scope>", "personal | team | module (default: personal)", "personal").option("--module <name>", "module name (required when scope=module)").option("--auto", "synthesize the recap from .ai/.cache/observations.jsonl (used by Claude Code SessionEnd hook)").option("--quiet", "suppress non-error output (for hook use)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot32(opts.dir);
-    const paths = resolveHaivePaths29(root);
-    if (!existsSync53(paths.haiveDir)) {
+    const root = findProjectRoot33(opts.dir);
+    const paths = resolveHaivePaths30(root);
+    if (!existsSync55(paths.haiveDir)) {
       if (opts.auto || opts.quiet) return;
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
@@ -9691,19 +10207,19 @@ function registerSessionEnd(session2) {
     });
     const topic = recapTopic2(scope, opts.module);
     const filesTouched = parseCsv5(resolvedFiles);
-    const missingPaths = filesTouched.filter((p) => !existsSync53(path34.resolve(root, p)));
+    const missingPaths = filesTouched.filter((p) => !existsSync55(path36.resolve(root, p)));
     if (missingPaths.length > 0 && !opts.quiet) {
       ui.warn(`Anchor path${missingPaths.length > 1 ? "s" : ""} not found in project (will be stale):`);
       for (const p of missingPaths) ui.warn(`  \u2717 ${p}`);
     }
     const cleanupObservations = async () => {
       if (!opts.auto) return;
-      const obsFile = path34.join(paths.haiveDir, ".cache", "observations.jsonl");
-      if (existsSync53(obsFile)) await rm2(obsFile).catch(() => {
+      const obsFile = path36.join(paths.haiveDir, ".cache", "observations.jsonl");
+      if (existsSync55(obsFile)) await rm2(obsFile).catch(() => {
       });
     };
-    if (existsSync53(paths.memoriesDir)) {
-      const existing = await loadMemoriesFromDir27(paths.memoriesDir);
+    if (existsSync55(paths.memoriesDir)) {
+      const existing = await loadMemoriesFromDir28(paths.memoriesDir);
       const topicMatch = existing.find(
         ({ memory: memory2 }) => memory2.frontmatter.topic === topic && memory2.frontmatter.scope === scope && (!opts.module || memory2.frontmatter.module === opts.module)
       );
@@ -9719,11 +10235,11 @@ function registerSessionEnd(session2) {
             paths: filesTouched.length ? filesTouched : fm.anchor.paths
           }
         };
-        await writeFile25(topicMatch.filePath, serializeMemory21({ frontmatter: newFrontmatter, body }), "utf8");
+        await writeFile27(topicMatch.filePath, serializeMemory23({ frontmatter: newFrontmatter, body }), "utf8");
         await cleanupObservations();
         if (!opts.quiet) {
           ui.success(`Session recap updated (revision #${revisionCount})`);
-          ui.info(`id=${fm.id}  file=${path34.relative(root, topicMatch.filePath)}`);
+          ui.info(`id=${fm.id}  file=${path36.relative(root, topicMatch.filePath)}`);
           ui.info("Tip: `haive stats --export-report` generates a usage JSON suitable for dashboards.");
         }
         return;
@@ -9740,12 +10256,12 @@ function registerSessionEnd(session2) {
       status: "validated"
     });
     const file = memoryFilePath9(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir15(path34.dirname(file), { recursive: true });
-    await writeFile25(file, serializeMemory21({ frontmatter, body }), "utf8");
+    await mkdir15(path36.dirname(file), { recursive: true });
+    await writeFile27(file, serializeMemory23({ frontmatter, body }), "utf8");
     await cleanupObservations();
     if (!opts.quiet) {
       ui.success(`Session recap created`);
-      ui.info(`id=${frontmatter.id}  scope=${scope}  file=${path34.relative(root, file)}`);
+      ui.info(`id=${frontmatter.id}  scope=${scope}  file=${path36.relative(root, file)}`);
       ui.info("Next session: call `get_briefing` \u2014 the recap will be surfaced automatically.");
       ui.info("Tip: export a local MCP usage rollup with `haive stats --export-report .ai/tool-usage-roi-report.json`.");
     }
@@ -9757,15 +10273,15 @@ function parseCsv5(value) {
 }
 
 // src/commands/snapshot.ts
-import { existsSync as existsSync54 } from "fs";
+import { existsSync as existsSync56 } from "fs";
 import { readdir as readdir4 } from "fs/promises";
-import path35 from "path";
+import path37 from "path";
 import "commander";
 import {
   diffContract,
-  findProjectRoot as findProjectRoot33,
-  loadConfig as loadConfig5,
-  resolveHaivePaths as resolveHaivePaths30,
+  findProjectRoot as findProjectRoot34,
+  loadConfig as loadConfig7,
+  resolveHaivePaths as resolveHaivePaths31,
   snapshotContract
 } from "@hiveai/core";
 function registerSnapshot(program2) {
@@ -9790,16 +10306,16 @@ function registerSnapshot(program2) {
     "--format <format>",
     "contract format: openapi | graphql | proto | typescript | json-schema (auto-detected if omitted)"
   ).option("--diff", "compare the contract against its stored snapshot").option("--list", "list all stored contract snapshots").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot33(opts.dir);
-    const paths = resolveHaivePaths30(root);
-    if (!existsSync54(paths.haiveDir)) {
+    const root = findProjectRoot34(opts.dir);
+    const paths = resolveHaivePaths31(root);
+    if (!existsSync56(paths.haiveDir)) {
       ui.error("No .ai/ found. Run `haive init` first.");
       process.exitCode = 1;
       return;
     }
     if (opts.list) {
-      const contractsDir = path35.join(paths.haiveDir, "contracts");
-      if (!existsSync54(contractsDir)) {
+      const contractsDir = path37.join(paths.haiveDir, "contracts");
+      if (!existsSync56(contractsDir)) {
         console.log(ui.dim("No contract snapshots found."));
         return;
       }
@@ -9819,7 +10335,7 @@ function registerSnapshot(program2) {
     }
     if (opts.diff) {
       if (!opts.name) {
-        const config2 = await loadConfig5(paths);
+        const config2 = await loadConfig7(paths);
         const contracts = config2.contractFiles ?? [];
         if (contracts.length === 0) {
           ui.error("--diff requires --name, or configure contractFiles in haive.config.json");
@@ -9831,7 +10347,7 @@ function registerSnapshot(program2) {
         }
         return;
       }
-      const config = await loadConfig5(paths);
+      const config = await loadConfig7(paths);
       const configured = (config.contractFiles ?? []).find((c) => c.name === opts.name);
       if (!configured && !opts.contract) {
         ui.error(
@@ -9854,7 +10370,7 @@ function registerSnapshot(program2) {
       return;
     }
     const contractPath = opts.contract;
-    const name = opts.name ?? path35.basename(contractPath, path35.extname(contractPath));
+    const name = opts.name ?? path37.basename(contractPath, path37.extname(contractPath));
     const format = opts.format ?? detectFormat(contractPath) ?? "openapi";
     const contract = { name, path: contractPath, format };
     try {
@@ -9909,8 +10425,8 @@ async function runDiff(root, haiveDir, contract) {
   }
 }
 function detectFormat(filePath) {
-  const ext = path35.extname(filePath).toLowerCase();
-  const base = path35.basename(filePath).toLowerCase();
+  const ext = path37.extname(filePath).toLowerCase();
+  const base = path37.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";
@@ -9923,18 +10439,18 @@ function detectFormat(filePath) {
 }
 
 // src/commands/hub.ts
-import { existsSync as existsSync55 } from "fs";
-import { mkdir as mkdir16, readFile as readFile15, writeFile as writeFile26, copyFile } from "fs/promises";
-import path36 from "path";
-import { spawnSync as spawnSync4 } from "child_process";
+import { existsSync as existsSync57 } from "fs";
+import { mkdir as mkdir16, readFile as readFile16, writeFile as writeFile28, copyFile } from "fs/promises";
+import path38 from "path";
+import { spawnSync as spawnSync5 } from "child_process";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot34,
-  loadConfig as loadConfig6,
-  loadMemoriesFromDir as loadMemoriesFromDir28,
-  resolveHaivePaths as resolveHaivePaths31,
-  saveConfig as saveConfig2,
-  serializeMemory as serializeMemory23
+  findProjectRoot as findProjectRoot35,
+  loadConfig as loadConfig8,
+  loadMemoriesFromDir as loadMemoriesFromDir29,
+  resolveHaivePaths as resolveHaivePaths32,
+  saveConfig as saveConfig3,
+  serializeMemory as serializeMemory24
 } from "@hiveai/core";
 function registerHub(program2) {
   const hub = program2.command("hub").description(
@@ -9944,21 +10460,21 @@ 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 = path36.resolve(hubPath);
+    const absPath = path38.resolve(hubPath);
     await mkdir16(absPath, { recursive: true });
-    const gitCheck = spawnSync4("git", ["rev-parse", "--git-dir"], { cwd: absPath });
+    const gitCheck = spawnSync5("git", ["rev-parse", "--git-dir"], { cwd: absPath });
     if (gitCheck.status !== 0) {
-      const init = spawnSync4("git", ["init"], { cwd: absPath, encoding: "utf8" });
+      const init = spawnSync5("git", ["init"], { cwd: absPath, encoding: "utf8" });
       if (init.status !== 0) {
         ui.error(`git init failed: ${init.stderr}`);
         process.exitCode = 1;
         return;
       }
     }
-    const sharedDir = path36.join(absPath, ".ai", "memories", "shared");
+    const sharedDir = path38.join(absPath, ".ai", "memories", "shared");
     await mkdir16(sharedDir, { recursive: true });
-    await writeFile26(
-      path36.join(absPath, ".ai", "README.md"),
+    await writeFile28(
+      path38.join(absPath, ".ai", "README.md"),
       `# hAIve Team Knowledge Hub
 
 This repo is a shared knowledge hub for hAIve.
@@ -9979,13 +10495,13 @@ haive hub pull   # import into a project
 `,
       "utf8"
     );
-    await writeFile26(
-      path36.join(absPath, ".gitignore"),
+    await writeFile28(
+      path38.join(absPath, ".gitignore"),
       ".ai/.cache/\n.ai/memories/personal/\n",
       "utf8"
     );
-    spawnSync4("git", ["add", "."], { cwd: absPath });
-    spawnSync4("git", ["commit", "-m", "chore: initialize hAIve team-knowledge hub"], {
+    spawnSync5("git", ["add", "."], { cwd: absPath });
+    spawnSync5("git", ["commit", "-m", "chore: initialize hAIve team-knowledge hub"], {
       cwd: absPath,
       encoding: "utf8"
     });
@@ -9995,7 +10511,7 @@ haive hub pull   # import into a project
         `
 Next steps:
   1. Add hubPath to your project's .ai/haive.config.json:
-       { "hubPath": "${path36.relative(process.cwd(), absPath)}" }
+       { "hubPath": "${path38.relative(process.cwd(), absPath)}" }
   2. Run \`haive hub push\` to publish your shared memories
   3. Share ${absPath} with teammates (git remote, NFS, etc.)
 `
@@ -10014,9 +10530,9 @@ Next steps:
     haive hub push --commit --message "feat: add payment API contract memories"
 `
   ).option("-d, --dir <dir>", "project root").option("--commit", "auto-commit to the hub repo after pushing").option("--message <msg>", "commit message for the hub (used with --commit)").action(async (opts) => {
-    const root = findProjectRoot34(opts.dir);
-    const paths = resolveHaivePaths31(root);
-    const config = await loadConfig6(paths);
+    const root = findProjectRoot35(opts.dir);
+    const paths = resolveHaivePaths32(root);
+    const config = await loadConfig8(paths);
     if (!config.hubPath) {
       ui.error(
         'hubPath not configured in .ai/haive.config.json.\n  Add: { "hubPath": "../team-hub" }\n  Or run: haive hub init <path> first.'
@@ -10024,16 +10540,16 @@ Next steps:
       process.exitCode = 1;
       return;
     }
-    const hubRoot = path36.resolve(root, config.hubPath);
-    if (!existsSync55(hubRoot)) {
+    const hubRoot = path38.resolve(root, config.hubPath);
+    if (!existsSync57(hubRoot)) {
       ui.error(`Hub not found at ${hubRoot}. Run \`haive hub init ${config.hubPath}\` first.`);
       process.exitCode = 1;
       return;
     }
-    const projectName = path36.basename(root);
-    const destDir = path36.join(hubRoot, ".ai", "memories", "shared", projectName);
+    const projectName = path38.basename(root);
+    const destDir = path38.join(hubRoot, ".ai", "memories", "shared", projectName);
     await mkdir16(destDir, { recursive: true });
-    const all = await loadMemoriesFromDir28(paths.memoriesDir);
+    const all = await loadMemoriesFromDir29(paths.memoriesDir);
     const shared = all.filter(
       ({ memory: memory2 }) => memory2.frontmatter.scope === "shared" && memory2.frontmatter.status !== "rejected" && memory2.frontmatter.status !== "deprecated" && // Don't push imported memories (avoid echo loops)
       !memory2.frontmatter.tags.some((t) => t.startsWith("cross-repo:"))
@@ -10050,18 +10566,18 @@ Next steps:
     for (const { memory: memory2 } of shared) {
       const fm = memory2.frontmatter;
       const fileName = `${fm.id}.md`;
-      const destPath = path36.join(destDir, fileName);
-      await writeFile26(destPath, serializeMemory23(memory2), "utf8");
+      const destPath = path38.join(destDir, fileName);
+      await writeFile28(destPath, serializeMemory24(memory2), "utf8");
       pushed++;
     }
     console.log(ui.green(`\u2713 Pushed ${pushed} shared memor${pushed === 1 ? "y" : "ies"} to hub`));
     console.log(ui.dim(`  Location: ${destDir}`));
     if (opts.commit) {
       const message = opts.message ?? `haive: sync shared memories from ${projectName} (${pushed} memories)`;
-      spawnSync4("git", ["add", path36.join(".ai", "memories", "shared", projectName)], {
+      spawnSync5("git", ["add", path38.join(".ai", "memories", "shared", projectName)], {
         cwd: hubRoot
       });
-      const commit = spawnSync4("git", ["commit", "-m", message], {
+      const commit = spawnSync5("git", ["commit", "-m", message], {
         cwd: hubRoot,
         encoding: "utf8"
       });
@@ -10083,9 +10599,9 @@ Next steps:
   hub.command("pull").description(
     "Pull shared memories from the hub into this project.\n\n  Imports all memories from hub/.ai/memories/shared/ EXCEPT this project's own.\n  Imported memories land in .ai/memories/shared/<source-project-name>/.\n\n  Examples:\n    haive hub pull\n"
   ).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot34(opts.dir);
-    const paths = resolveHaivePaths31(root);
-    const config = await loadConfig6(paths);
+    const root = findProjectRoot35(opts.dir);
+    const paths = resolveHaivePaths32(root);
+    const config = await loadConfig8(paths);
     if (!config.hubPath) {
       ui.error(
         'hubPath not configured in .ai/haive.config.json.\n  Add: { "hubPath": "../team-hub" }\n  Or run: haive hub init <path> first.'
@@ -10093,13 +10609,13 @@ Next steps:
       process.exitCode = 1;
       return;
     }
-    const hubRoot = path36.resolve(root, config.hubPath);
-    const hubSharedDir = path36.join(hubRoot, ".ai", "memories", "shared");
-    if (!existsSync55(hubSharedDir)) {
+    const hubRoot = path38.resolve(root, config.hubPath);
+    const hubSharedDir = path38.join(hubRoot, ".ai", "memories", "shared");
+    if (!existsSync57(hubSharedDir)) {
       ui.warn("Hub has no shared memories yet. Run `haive hub push` from other projects first.");
       return;
     }
-    const projectName = path36.basename(root);
+    const projectName = path38.basename(root);
     const { readdir: readdir6 } = await import("fs/promises");
     const projectDirs = (await readdir6(hubSharedDir, { withFileTypes: true })).filter((d) => d.isDirectory() && d.name !== projectName).map((d) => d.name);
     if (projectDirs.length === 0) {
@@ -10109,17 +10625,17 @@ Next steps:
     let totalImported = 0;
     let totalUpdated = 0;
     for (const sourceName of projectDirs) {
-      const sourceDir = path36.join(hubSharedDir, sourceName);
-      const destDir = path36.join(paths.memoriesDir, "shared", sourceName);
+      const sourceDir = path38.join(hubSharedDir, sourceName);
+      const destDir = path38.join(paths.memoriesDir, "shared", sourceName);
       await mkdir16(destDir, { recursive: true });
       const sourceFiles = (await readdir6(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 = path36.join(sourceDir, file);
-        const destPath = path36.join(destDir, file);
-        const fileContent = await readFile15(srcPath, "utf8");
+        const srcPath = path38.join(sourceDir, file);
+        const destPath = path38.join(destDir, file);
+        const fileContent = await readFile16(srcPath, "utf8");
         const alreadyTagged = fileContent.includes(`cross-repo:${sourceName}`);
         if (!alreadyTagged) {
           await copyFile(srcPath, destPath);
@@ -10142,27 +10658,27 @@ Next steps:
     );
   });
   hub.command("status").description("Show hub sync status.").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot34(opts.dir);
-    const paths = resolveHaivePaths31(root);
-    const config = await loadConfig6(paths);
+    const root = findProjectRoot35(opts.dir);
+    const paths = resolveHaivePaths32(root);
+    const config = await loadConfig8(paths);
     console.log(ui.bold("Hub status"));
     console.log(
       `  hubPath: ${config.hubPath ? ui.green(config.hubPath) : ui.dim("not configured")}`
     );
-    const sharedDir = path36.join(paths.memoriesDir, "shared");
-    if (existsSync55(sharedDir)) {
+    const sharedDir = path38.join(paths.memoriesDir, "shared");
+    if (existsSync57(sharedDir)) {
       const { readdir: readdir6 } = await import("fs/promises");
       const sources = (await readdir6(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 readdir6(path36.join(sharedDir, src))).filter((f) => f.endsWith(".md"));
+        const files = (await readdir6(path38.join(sharedDir, src))).filter((f) => f.endsWith(".md"));
         console.log(`    ${src}: ${files.length} memor${files.length === 1 ? "y" : "ies"}`);
       }
     } else {
       console.log(ui.dim("  No imported shared memories yet."));
     }
-    const all = await loadMemoriesFromDir28(paths.memoriesDir);
+    const all = await loadMemoriesFromDir29(paths.memoriesDir);
     const outgoing = all.filter(
       ({ memory: memory2 }) => memory2.frontmatter.scope === "shared" && !memory2.frontmatter.tags.some((t) => t.startsWith("cross-repo:"))
     );
@@ -10171,25 +10687,25 @@ Next steps:
     if (outgoing.length > 0) {
       console.log(ui.dim("  Run `haive hub push` to publish them to the hub."));
     }
-    void readFile15;
-    void writeFile26;
-    void saveConfig2;
+    void readFile16;
+    void writeFile28;
+    void saveConfig3;
   });
 }
 
 // src/commands/stats.ts
 import "commander";
-import { existsSync as existsSync56 } from "fs";
-import { mkdir as mkdir17, writeFile as writeFile27 } from "fs/promises";
-import path37 from "path";
+import { existsSync as existsSync58 } from "fs";
+import { mkdir as mkdir17, writeFile as writeFile29 } from "fs/promises";
+import path39 from "path";
 import {
   aggregateUsage,
-  findProjectRoot as findProjectRoot35,
-  loadMemoriesFromDir as loadMemoriesFromDir29,
-  loadUsageIndex as loadUsageIndex23,
+  findProjectRoot as findProjectRoot36,
+  loadMemoriesFromDir as loadMemoriesFromDir30,
+  loadUsageIndex as loadUsageIndex24,
   parseSince,
   readUsageEvents as readUsageEvents2,
-  resolveHaivePaths as resolveHaivePaths32,
+  resolveHaivePaths as resolveHaivePaths33,
   usageLogSize
 } from "@hiveai/core";
 function registerStats(program2) {
@@ -10198,8 +10714,8 @@ function registerStats(program2) {
     "write a JSON rollup (tools + briefing counts + heuristic ROI hints). Parent dirs are created if needed.",
     void 0
   ).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot35(opts.dir);
-    const paths = resolveHaivePaths32(root);
+    const root = findProjectRoot36(opts.dir);
+    const paths = resolveHaivePaths33(root);
     if (opts.exportReport) {
       await writeRoiReport(paths, root, opts.since ?? "30d", opts.exportReport);
       return;
@@ -10253,12 +10769,12 @@ function registerStats(program2) {
   });
 }
 async function writeRoiReport(paths, root, sinceRaw, outRelative) {
-  const outAbs = path37.isAbsolute(outRelative) ? path37.resolve(outRelative) : path37.resolve(root, outRelative);
+  const outAbs = path39.isAbsolute(outRelative) ? path39.resolve(outRelative) : path39.resolve(root, outRelative);
   const size = await usageLogSize(paths);
   let events = await readUsageEvents2(paths);
   let memoryCount = { team: 0, personal: 0, total_skipped_session: 0 };
-  if (existsSync56(paths.memoriesDir)) {
-    const mems = await loadMemoriesFromDir29(paths.memoriesDir);
+  if (existsSync58(paths.memoriesDir)) {
+    const mems = await loadMemoriesFromDir30(paths.memoriesDir);
     for (const { memory: memory2 } of mems) {
       const fm = memory2.frontmatter;
       if (fm.type === "session_recap") memoryCount.total_skipped_session++;
@@ -10272,7 +10788,7 @@ async function writeRoiReport(paths, root, sinceRaw, outRelative) {
   const briefingCalls = events.filter((e) => inWindow(e.at) && e.tool === "get_briefing").length;
   let memoryHitsLeader = null;
   try {
-    const usageIdx = await loadUsageIndex23(paths);
+    const usageIdx = await loadUsageIndex24(paths);
     const tops = Object.entries(usageIdx.by_id).map(([id, v]) => ({ id, read_count: v.read_count })).filter((x) => x.read_count > 0).sort((a, b) => b.read_count - a.read_count);
     memoryHitsLeader = tops[0] ?? null;
   } catch {
@@ -10288,7 +10804,7 @@ async function writeRoiReport(paths, root, sinceRaw, outRelative) {
     ui.warn("Usage log missing or empty \u2014 report still written with partial data.");
     events = [];
   }
-  await mkdir17(path37.dirname(outAbs), { recursive: true });
+  await mkdir17(path39.dirname(outAbs), { recursive: true });
   const payload = {
     generated_at: (/* @__PURE__ */ new Date()).toISOString(),
     project_root: root,
@@ -10300,11 +10816,11 @@ async function writeRoiReport(paths, root, sinceRaw, outRelative) {
     top_memory_reads: memoryHitsLeader,
     roi_hints: roiHints
   };
-  await writeFile27(outAbs, JSON.stringify(payload, null, 2), "utf8");
+  await writeFile29(outAbs, JSON.stringify(payload, null, 2), "utf8");
   ui.success(`Wrote ROI / usage rollup \u2192 ${outAbs}`);
 }
 async function renderMemoryHits(paths, opts) {
-  const index = await loadUsageIndex23(paths);
+  const index = await loadUsageIndex24(paths);
   const since = parseSince(opts.since ?? "30d");
   const sinceMs = since ? new Date(since).getTime() : null;
   const entries = Object.entries(index.by_id).map(([id, usage]) => ({ id, ...usage })).filter((e) => e.read_count > 0).filter((e) => {
@@ -10352,13 +10868,13 @@ import { performance } from "perf_hooks";
 import "commander";
 import {
   estimateTokens as estimateTokens3,
-  findProjectRoot as findProjectRoot36,
-  resolveHaivePaths as resolveHaivePaths33
+  findProjectRoot as findProjectRoot37,
+  resolveHaivePaths as resolveHaivePaths34
 } from "@hiveai/core";
 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 = findProjectRoot36(opts.dir);
-    const paths = resolveHaivePaths33(root);
+    const root = findProjectRoot37(opts.dir);
+    const paths = resolveHaivePaths34(root);
     const ctx = { paths };
     const task = opts.task ?? "audit dependencies for security risks";
     const scenarios = [
@@ -10477,11 +10993,11 @@ function summarize(name, t0, payload, notes) {
 }
 
 // src/commands/benchmark.ts
-import { existsSync as existsSync57 } from "fs";
-import { readdir as readdir5, readFile as readFile16, writeFile as writeFile28 } from "fs/promises";
-import path38 from "path";
+import { existsSync as existsSync59 } from "fs";
+import { readdir as readdir5, readFile as readFile17, writeFile as writeFile30 } from "fs/promises";
+import path40 from "path";
 import "commander";
-import { estimateTokens as estimateTokens4, findProjectRoot as findProjectRoot37 } from "@hiveai/core";
+import { estimateTokens as estimateTokens4, findProjectRoot as findProjectRoot38 } from "@hiveai/core";
 function registerBenchmark(program2) {
   const benchmark = program2.command("benchmark").description("Official hAIve benchmark/demo utilities for measuring agent enforcement value.");
   benchmark.command("report").description("Summarize BENCHMARK_AGENT_REPORT.md files from a paired hAIve/plain agent benchmark.").option("-d, --dir <dir>", "benchmark root", "benchmarks/agent-benchmark").option("--out <file>", "write a Markdown report").option("--json", "emit JSON", false).action(async (opts) => {
@@ -10494,9 +11010,9 @@ function registerBenchmark(program2) {
     }
     const markdown = renderMarkdown(root, summary, rows);
     if (opts.out) {
-      const outFile = path38.isAbsolute(opts.out) ? opts.out : path38.join(root, opts.out);
-      await writeFile28(outFile, markdown, "utf8");
-      ui.success(`wrote ${path38.relative(process.cwd(), outFile)}`);
+      const outFile = path40.isAbsolute(opts.out) ? opts.out : path40.join(root, opts.out);
+      await writeFile30(outFile, markdown, "utf8");
+      ui.success(`wrote ${path40.relative(process.cwd(), outFile)}`);
       return;
     }
     console.log(markdown);
@@ -10520,20 +11036,20 @@ function registerBenchmark(program2) {
 }
 function resolveBenchmarkRoot(dir) {
   const candidate = dir ?? "benchmarks/agent-benchmark";
-  if (path38.isAbsolute(candidate)) return candidate;
-  const projectRoot = findProjectRoot37(process.cwd());
-  return path38.join(projectRoot, candidate);
+  if (path40.isAbsolute(candidate)) return candidate;
+  const projectRoot = findProjectRoot38(process.cwd());
+  return path40.join(projectRoot, candidate);
 }
 async function collectRows(root) {
-  if (!existsSync57(root)) throw new Error(`Benchmark directory not found: ${root}`);
+  if (!existsSync59(root)) throw new Error(`Benchmark directory not found: ${root}`);
   const entries = await readdir5(root, { withFileTypes: true });
   const rows = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const fixtureDir = path38.join(root, entry.name);
-    const reportFile = path38.join(fixtureDir, "BENCHMARK_AGENT_REPORT.md");
-    if (!existsSync57(reportFile)) continue;
-    const report = await readFile16(reportFile, "utf8");
+    const fixtureDir = path40.join(root, entry.name);
+    const reportFile = path40.join(fixtureDir, "BENCHMARK_AGENT_REPORT.md");
+    if (!existsSync59(reportFile)) continue;
+    const report = await readFile17(reportFile, "utf8");
     rows.push(parseAgentReport(entry.name, report));
   }
   return rows.sort((a, b) => a.fixture.localeCompare(b.fixture));
@@ -10622,20 +11138,21 @@ function escapeRegExp(value) {
 }
 
 // src/commands/memory-suggest.ts
-import { mkdir as mkdir18, writeFile as writeFile29 } from "fs/promises";
-import { existsSync as existsSync58 } from "fs";
-import path39 from "path";
+import { mkdir as mkdir18, writeFile as writeFile31 } from "fs/promises";
+import { existsSync as existsSync60 } from "fs";
+import path41 from "path";
 import "commander";
 import {
   aggregateUsage as aggregateUsage2,
   buildFrontmatter as buildFrontmatter11,
-  findProjectRoot as findProjectRoot38,
-  loadMemoriesFromDir as loadMemoriesFromDir30,
+  findProjectRoot as findProjectRoot39,
+  loadConfig as loadConfig9,
+  loadMemoriesFromDir as loadMemoriesFromDir31,
   memoryFilePath as memoryFilePath10,
   parseSince as parseSince2,
   readUsageEvents as readUsageEvents3,
-  resolveHaivePaths as resolveHaivePaths34,
-  serializeMemory as serializeMemory24
+  resolveHaivePaths as resolveHaivePaths35,
+  serializeMemory as serializeMemory25
 } from "@hiveai/core";
 var SEARCH_TOOLS = /* @__PURE__ */ new Set([
   "mem_search",
@@ -10643,12 +11160,16 @@ var SEARCH_TOOLS = /* @__PURE__ */ new Set([
   "mem_relevant_to",
   "get_briefing"
 ]);
+var SYNTHETIC_QUERY_RE = /\b(auto-promote-marker|local enforcement smoke|cli-test-session)\b/i;
+function isSyntheticSuggestionQuery(query) {
+  return SYNTHETIC_QUERY_RE.test(query);
+}
 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 = findProjectRoot38(opts.dir);
-    const paths = resolveHaivePaths34(root);
+    "Suggest memories to create based on recurring search queries in the usage log.\n\n  Use --auto-save to save the top-N suggestions using the project defaults.\n  In autopilot, suggestions land as validated team records; in manual mode they stay draft."
+  ).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 saved memories (personal | team; default: config default)").option("--auto-save", "save top-N suggestions as 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 = findProjectRoot39(opts.dir);
+    const paths = resolveHaivePaths35(root);
     const events = await readUsageEvents3(paths);
     if (events.length === 0) {
       if (opts.json) {
@@ -10667,6 +11188,7 @@ function registerMemorySuggest(memory2) {
       if (!SEARCH_TOOLS.has(e.tool)) continue;
       const key = (e.summary ?? "").toLowerCase().trim();
       if (!key) continue;
+      if (isSyntheticSuggestionQuery(key)) continue;
       const prior = queries.get(key);
       if (prior) {
         prior.count++;
@@ -10685,16 +11207,18 @@ function registerMemorySuggest(memory2) {
       inferred_type: inferType(v.tools, query)
     })).sort((a, b) => b.count - a.count);
     if (opts.autoSave) {
+      const config = await loadConfig9(paths);
       const topN = Math.max(1, parseInt(opts.topN ?? "3", 10));
-      const scope = opts.scope === "team" ? "team" : "personal";
+      const scope = opts.scope === "personal" || opts.scope === "team" ? opts.scope : config.defaultScope ?? "personal";
+      const status = config.defaultStatus === "validated" ? "validated" : "draft";
       const top = suggestions.slice(0, topN);
       if (top.length === 0) {
-        ui.warn(`No suggestions met --min=${minCount} \u2014 nothing to draft.`);
+        ui.warn(`No suggestions met --min=${minCount} \u2014 nothing to save.`);
         return;
       }
       const created = [];
       const skipped = [];
-      const existing = existsSync58(paths.memoriesDir) ? await loadMemoriesFromDir30(paths.memoriesDir) : [];
+      const existing = existsSync60(paths.memoriesDir) ? await loadMemoriesFromDir31(paths.memoriesDir) : [];
       for (const s of top) {
         const slug = slugify(s.query);
         if (!slug) {
@@ -10712,25 +11236,25 @@ function registerMemorySuggest(memory2) {
           scope,
           tags: ["auto-suggested", ...s.tools],
           paths: [],
-          symbols: []
+          symbols: [],
+          status
         });
-        fm.status = "draft";
-        const body = renderTemplate(s);
+        const body = renderTemplate(s, fm.id, status);
         const file = memoryFilePath10(paths, fm.scope, fm.id, fm.module);
-        await mkdir18(path39.dirname(file), { recursive: true });
-        if (existsSync58(file)) {
-          skipped.push({ query: s.query, reason: `file already exists at ${path39.relative(root, file)}` });
+        await mkdir18(path41.dirname(file), { recursive: true });
+        if (existsSync60(file)) {
+          skipped.push({ query: s.query, reason: `file already exists at ${path41.relative(root, file)}` });
           continue;
         }
-        await writeFile29(file, serializeMemory24({ frontmatter: fm, body }), "utf8");
-        created.push({ id: fm.id, file: path39.relative(root, file), query: s.query });
+        await writeFile31(file, serializeMemory25({ frontmatter: fm, body }), "utf8");
+        created.push({ id: fm.id, file: path41.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}`);
+        ui.success(`${status === "validated" ? "Saved" : "Drafted"} ${c.id} \u2192 ${c.file}`);
         console.log(`     ${ui.dim("from query:")} ${truncate2(c.query, 60)}`);
       }
       for (const s of skipped) {
@@ -10738,7 +11262,11 @@ function registerMemorySuggest(memory2) {
       }
       if (created.length > 0) {
         console.log();
-        ui.info("Drafts are status=draft \u2014 edit them, then `haive memory promote` to validate.");
+        if (status === "validated") {
+          ui.info("Autopilot defaults applied: suggestions are status=validated and active.");
+        } else {
+          ui.info("Drafts are status=draft \u2014 edit them, then run `haive memory promote <id>`.");
+        }
       }
       return;
     }
@@ -10763,7 +11291,7 @@ function registerMemorySuggest(memory2) {
       console.log(`     ${ui.dim("\u2192")} ${s.reason}`);
     }
     console.log();
-    ui.info("Run with --auto-save to draft the top-3 as draft memories.");
+    ui.info("Run with --auto-save to save the top-3 using the project defaults.");
   });
 }
 function chooseReason(tools, count) {
@@ -10784,7 +11312,8 @@ function inferType(tools, query) {
   }
   return "convention";
 }
-function renderTemplate(s) {
+function renderTemplate(s, id, status) {
+  const nextStep = status === "validated" ? `This record is already active because project autopilot defaults set status=validated. Replace the template body with the actual answer when known.` : `Then run \`haive memory promote ${id}\` to move it into team review.`;
   return [
     `# Auto-drafted from recurring searches`,
     ``,
@@ -10804,7 +11333,7 @@ function renderTemplate(s) {
     `- **Why** \u2014 the rationale or root cause`,
     `- **How to apply** \u2014 what an agent should do when this comes up again`,
     ``,
-    `Then run \`haive memory promote ${truncate2(s.query, 30)}\` to mark it validated.`
+    nextStep
   ].join("\n");
 }
 function slugify(s) {
@@ -10816,26 +11345,26 @@ function truncate2(text, max) {
 }
 
 // src/commands/memory-archive.ts
-import { existsSync as existsSync59 } from "fs";
-import { writeFile as writeFile30 } from "fs/promises";
-import path40 from "path";
+import { existsSync as existsSync61 } from "fs";
+import { writeFile as writeFile33 } from "fs/promises";
+import path43 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot39,
-  getUsage as getUsage18,
-  loadMemoriesFromDir as loadMemoriesFromDir31,
-  loadUsageIndex as loadUsageIndex24,
-  resolveHaivePaths as resolveHaivePaths35,
-  serializeMemory as serializeMemory25
+  findProjectRoot as findProjectRoot40,
+  getUsage as getUsage19,
+  loadMemoriesFromDir as loadMemoriesFromDir32,
+  loadUsageIndex as loadUsageIndex25,
+  resolveHaivePaths as resolveHaivePaths36,
+  serializeMemory as serializeMemory26
 } from "@hiveai/core";
 var MS_PER_DAY2 = 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 = findProjectRoot39(opts.dir);
-    const paths = resolveHaivePaths35(root);
-    if (!existsSync59(paths.memoriesDir)) {
+    const root = findProjectRoot40(opts.dir);
+    const paths = resolveHaivePaths36(root);
+    if (!existsSync61(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -10847,8 +11376,8 @@ function registerMemoryArchive(memory2) {
       return;
     }
     const cutoff = Date.now() - minDays * MS_PER_DAY2;
-    const all = await loadMemoriesFromDir31(paths.memoriesDir);
-    const usage = await loadUsageIndex24(paths);
+    const all = await loadMemoriesFromDir32(paths.memoriesDir);
+    const usage = await loadUsageIndex25(paths);
     const typeFilter = opts.type === "all" ? null : opts.type ?? "attempt";
     const candidates = [];
     for (const { memory: mem, filePath } of all) {
@@ -10856,10 +11385,10 @@ function registerMemoryArchive(memory2) {
       if (typeFilter && fm.type !== typeFilter) continue;
       if (fm.status === "deprecated" || fm.status === "rejected") continue;
       const hasAnyAnchor = fm.anchor.paths.length + fm.anchor.symbols.length > 0;
-      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync59(path40.join(paths.root, p)));
+      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync61(path43.join(paths.root, p)));
       const isAnchorless = !hasAnyAnchor;
       if (!isAnchorless && !allPathsGone) continue;
-      const u = getUsage18(usage, fm.id);
+      const u = getUsage19(usage, fm.id);
       const lastSeen = u.last_read_at ?? fm.created_at;
       if (Date.parse(lastSeen) >= cutoff) continue;
       candidates.push({
@@ -10904,7 +11433,7 @@ function registerMemoryArchive(memory2) {
       if (!found) continue;
       const fm = { ...found.memory.frontmatter, status: "deprecated" };
       try {
-        await writeFile30(c.filePath, serializeMemory25({ frontmatter: fm, body: found.memory.body }), "utf8");
+        await writeFile33(c.filePath, serializeMemory26({ frontmatter: fm, body: found.memory.body }), "utf8");
         archived++;
       } catch (err) {
         if (!opts.json) {
@@ -10930,31 +11459,33 @@ function parseDays(input) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync60 } from "fs";
-import { readFile as readFile17, stat } from "fs/promises";
-import path41 from "path";
+import { existsSync as existsSync63 } from "fs";
+import { readFile as readFile18, stat } from "fs/promises";
+import path44 from "path";
 import { execFileSync, execSync as execSync3 } from "child_process";
 import "commander";
 import {
   codeMapPath as codeMapPath2,
-  findProjectRoot as findProjectRoot40,
-  getUsage as getUsage19,
-  loadCodeMap as loadCodeMap5,
-  loadConfig as loadConfig7,
-  loadMemoriesFromDir as loadMemoriesFromDir32,
-  loadUsageIndex as loadUsageIndex25,
+  findProjectRoot as findProjectRoot41,
+  getUsage as getUsage20,
+  loadCodeMap as loadCodeMap7,
+  loadConfig as loadConfig10,
+  loadMemoriesFromDir as loadMemoriesFromDir33,
+  loadUsageIndex as loadUsageIndex26,
   readUsageEvents as readUsageEvents4,
-  resolveHaivePaths as resolveHaivePaths36
+  resolveHaivePaths as resolveHaivePaths37
 } from "@hiveai/core";
 var MS_PER_DAY3 = 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("--dry-run", "with --fix, show delegated repairs without applying them", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot40(opts.dir);
-    const paths = resolveHaivePaths36(root);
+    const root = findProjectRoot41(opts.dir);
+    const paths = resolveHaivePaths37(root);
     const findings = [];
-    if (!existsSync60(paths.haiveDir)) {
+    const repairs = [];
+    const config = await loadConfig10(paths);
+    if (!existsSync63(paths.haiveDir)) {
       findings.push({
         severity: "error",
         code: "not-initialized",
@@ -10963,7 +11494,18 @@ function registerDoctor(program2) {
       });
       return emit(findings, opts);
     }
-    if (!existsSync60(paths.projectContext)) {
+    if (opts.fix && !opts.dryRun) {
+      repairs.push(
+        ...await applyAutopilotRepairs(root, paths, {
+          applyConfig: true,
+          applyContext: true,
+          applyCorpus: true,
+          applyCodeMap: true,
+          applyCodeSearch: true
+        })
+      );
+    }
+    if (!existsSync63(paths.projectContext)) {
       findings.push({
         severity: "warn",
         code: "no-project-context",
@@ -10971,8 +11513,8 @@ function registerDoctor(program2) {
         fix: "haive init"
       });
     } else {
-      const { readFile: readFile19 } = await import("fs/promises");
-      const content = await readFile19(paths.projectContext, "utf8");
+      const { readFile: readFile20 } = await import("fs/promises");
+      const content = await readFile20(paths.projectContext, "utf8");
       const isTemplate = content.includes("TODO \u2014 high-level overview") || content.includes("Generated by `haive init`");
       if (isTemplate) {
         findings.push({
@@ -10982,8 +11524,17 @@ function registerDoctor(program2) {
           fix: "Invoke the bootstrap_project MCP prompt from your AI client."
         });
       }
+      const versionStatus = await projectContextVersionStatus(root, paths);
+      if (versionStatus.mismatch) {
+        findings.push({
+          severity: "warn",
+          code: "project-context-version-mismatch",
+          message: `.ai/project-context.md version metadata (${versionStatus.currentVersion ?? "missing"}) does not match package.json (${versionStatus.expectedVersion}).`,
+          fix: "haive doctor --fix"
+        });
+      }
     }
-    const memories = existsSync60(paths.memoriesDir) ? await loadMemoriesFromDir32(paths.memoriesDir) : [];
+    const memories = existsSync63(paths.memoriesDir) ? await loadMemoriesFromDir33(paths.memoriesDir) : [];
     const now = Date.now();
     if (memories.length === 0) {
       findings.push({
@@ -10992,7 +11543,7 @@ function registerDoctor(program2) {
         message: "No memories yet. Capture knowledge as agents work via mem_save / mem_observe / mem_tried."
       });
     } else {
-      const usage = await loadUsageIndex25(paths);
+      const usage = await loadUsageIndex26(paths);
       const stale = memories.filter((m) => m.memory.frontmatter.status === "stale");
       if (stale.length > 0) {
         findings.push({
@@ -11024,7 +11575,7 @@ function registerDoctor(program2) {
       }
       const decayCandidates = memories.filter((m) => {
         if (m.memory.frontmatter.status !== "validated") return false;
-        const u = getUsage19(usage, m.memory.frontmatter.id);
+        const u = getUsage20(usage, m.memory.frontmatter.id);
         const last = u.last_read_at ?? m.memory.frontmatter.created_at;
         return (now - Date.parse(last)) / MS_PER_DAY3 > 180;
       });
@@ -11037,7 +11588,19 @@ function registerDoctor(program2) {
         });
       }
     }
-    const codeMap = await loadCodeMap5(paths);
+    const lintReport = await lintMemoriesAsync(root);
+    if (lintReport.findings.length > 0) {
+      const warnCount = lintReport.findings.filter((finding) => finding.severity === "warn").length;
+      const errorCount = lintReport.findings.filter((finding) => finding.severity === "error").length;
+      const severity = errorCount > 0 ? "error" : warnCount > 0 ? "warn" : "info";
+      findings.push({
+        severity,
+        code: "memory-lint-findings",
+        message: `memory lint reports ${lintReport.findings.length} finding${lintReport.findings.length === 1 ? "" : "s"} (${errorCount} error, ${warnCount} warn, ${lintReport.findings.length - errorCount - warnCount} info).`,
+        fix: "haive memory lint --fix --apply"
+      });
+    }
+    const codeMap = await loadCodeMap7(paths);
     if (!codeMap) {
       findings.push({
         severity: "warn",
@@ -11058,6 +11621,7 @@ function registerDoctor(program2) {
         });
       }
     }
+    findings.push(...await collectSemanticIndexFindings(paths, config, memories.length, codeMap));
     const events = await readUsageEvents4(paths);
     if (events.length === 0) {
       findings.push({
@@ -11071,6 +11635,7 @@ function registerDoctor(program2) {
         if (!isSearchTool(e.tool)) continue;
         const key = (e.summary ?? "").toLowerCase().trim();
         if (!key) continue;
+        if (isSyntheticSuggestionQuery(key)) continue;
         queryRepeats.set(key, (queryRepeats.get(key) ?? 0) + 1);
       }
       const repeated = [...queryRepeats.entries()].filter(([, n]) => n >= 3);
@@ -11092,14 +11657,13 @@ function registerDoctor(program2) {
         });
       }
     }
-    const config = await loadConfig7(paths);
     if (config.enforcement?.requireBriefingFirst) {
-      const claudeSettings = path41.join(root, ".claude", "settings.local.json");
+      const claudeSettings = path44.join(root, ".claude", "settings.local.json");
       let hasClaudeEnforcement = false;
-      if (existsSync60(claudeSettings)) {
+      if (existsSync63(claudeSettings)) {
         try {
-          const { readFile: readFile19 } = await import("fs/promises");
-          const raw = await readFile19(claudeSettings, "utf8");
+          const { readFile: readFile20 } = await import("fs/promises");
+          const raw = await readFile20(claudeSettings, "utf8");
           hasClaudeEnforcement = raw.includes("haive enforce session-start") && raw.includes("haive enforce pre-tool-use");
         } catch {
           hasClaudeEnforcement = false;
@@ -11122,14 +11686,14 @@ function registerDoctor(program2) {
         fix: "Edit .ai/haive.config.json: set autoSessionEnd: true (or re-run `haive init` without --manual)."
       });
     }
-    findings.push(...await collectInstallFindings(root, "0.9.17"));
+    findings.push(...await collectInstallFindings(root, "0.9.19"));
     try {
       const legacyRaw = execSync3("haive-mcp --version", {
         encoding: "utf8",
         timeout: 3e3,
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      const cliVersion = "0.9.17";
+      const cliVersion = "0.9.19";
       if (legacyRaw && legacyRaw !== cliVersion) {
         findings.push({
           severity: "warn",
@@ -11142,10 +11706,18 @@ npm uninstall -g @hiveai/mcp`
       }
     } catch {
     }
-    emit(findings, opts);
+    if (repairs.length > 0) {
+      findings.push({
+        severity: "info",
+        code: "autopilot-repairs-applied",
+        message: repairs.map((repair) => repair.message).join(" "),
+        section: "Next actions"
+      });
+    }
+    emit(findings, opts, repairs);
   });
 }
-function emit(findings, opts) {
+function emit(findings, opts, repairs = []) {
   const classified = findings.map((finding) => ({
     ...finding,
     section: finding.section ?? sectionForFinding(finding)
@@ -11157,12 +11729,13 @@ function emit(findings, opts) {
       findings: classified,
       sections: groupBySection(classified),
       next_actions: nextActions(classified),
-      fix_mode: opts.fix ? opts.dryRun ? "dry-run" : "suggest" : "off"
+      repairs,
+      fix_mode: opts.fix ? opts.dryRun ? "dry-run" : "apply" : "off"
     }, null, 2));
     return;
   }
   if (classified.length === 0) {
-    ui.success("hAIve doctor \u2014 no issues found.");
+    ui.success(repairs.length > 0 ? "hAIve doctor \u2014 autopilot repairs applied." : "hAIve doctor \u2014 no issues found.");
     return;
   }
   console.log(ui.bold(`hAIve doctor \u2014 ${classified.length} finding${classified.length === 1 ? "" : "s"}`));
@@ -11198,6 +11771,11 @@ function emit(findings, opts) {
     }
     console.log();
   }
+  if (repairs.length > 0) {
+    console.log(ui.bold("Autopilot repairs applied"));
+    for (const repair of repairs) console.log(`  ${ui.dim("\u2713")} ${repair.message}`);
+    console.log();
+  }
   const actions = nextActions(classified);
   if (actions.length > 0) {
     console.log(ui.bold("Next actions"));
@@ -11245,6 +11823,56 @@ function groupBySection(findings) {
 function nextActions(findings) {
   return [...new Set(findings.flatMap((finding) => finding.fix ? finding.fix.split("\n") : []))].filter(Boolean);
 }
+async function collectSemanticIndexFindings(paths, config, memoryCount, codeMap) {
+  const findings = [];
+  const autoWantsCodeSearch = Boolean(config.autopilot || config.autoRepair?.codeSearch);
+  let mod;
+  try {
+    mod = await import("@hiveai/embeddings");
+  } catch {
+    findings.push({
+      severity: autoWantsCodeSearch ? "warn" : "info",
+      code: "embeddings-unavailable",
+      message: "@hiveai/embeddings is not available, so get_briefing falls back to lexical ranking and code_search cannot run.",
+      fix: "npm install -g @hiveai/cli@latest\nhaive embeddings status",
+      section: "Index health"
+    });
+    return findings;
+  }
+  if (memoryCount > 0) {
+    const stat2 = await mod.indexStat(paths).catch(() => ({ exists: false, count: 0 }));
+    if (!stat2.exists || stat2.count === 0) {
+      findings.push({
+        severity: "warn",
+        code: "semantic-memory-index-missing",
+        message: "Memory embeddings index is missing or empty; get_briefing will report literal_fallback instead of semantic ranking.",
+        fix: "haive embeddings index",
+        section: "Index health"
+      });
+    }
+  }
+  if (autoWantsCodeSearch || codeMap) {
+    const codeIndex = await mod.loadCodeIndex(paths).catch(() => null);
+    if (!codeIndex || codeIndex.entries.length === 0) {
+      findings.push({
+        severity: autoWantsCodeSearch ? "warn" : "info",
+        code: "code-search-index-missing",
+        message: "Code-search embeddings index is missing or empty; MCP code_search is unavailable until it is built.",
+        fix: "haive index code-search",
+        section: "Index health"
+      });
+    } else if (codeMap && codeIndex.source_generated_at !== codeMap.generated_at) {
+      findings.push({
+        severity: "info",
+        code: "code-search-index-outdated",
+        message: "Code-search embeddings index was built from an older code-map; semantic code search may miss recent symbols.",
+        fix: "haive index code-search",
+        section: "Index health"
+      });
+    }
+  }
+  return findings;
+}
 function isSearchTool(name) {
   return ["mem_search", "code_search", "mem_relevant_to", "get_briefing"].includes(name);
 }
@@ -11289,9 +11917,9 @@ which -a haive`
     ".vscode/mcp.json"
   ];
   for (const rel of integrationFiles) {
-    const file = path41.join(root, rel);
-    if (!existsSync60(file)) continue;
-    const text = await readFile17(file, "utf8").catch(() => "");
+    const file = path44.join(root, rel);
+    if (!existsSync63(file)) continue;
+    const text = await readFile18(file, "utf8").catch(() => "");
     for (const bin of extractAbsoluteHaiveBins(text)) {
       const version = versionForBinary(bin);
       if (!version) {
@@ -11347,22 +11975,22 @@ function extractAbsoluteHaiveBins(text) {
 }
 
 // src/commands/playback.ts
-import { existsSync as existsSync61 } from "fs";
+import { existsSync as existsSync64 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot41,
-  loadMemoriesFromDir as loadMemoriesFromDir33,
+  findProjectRoot as findProjectRoot42,
+  loadMemoriesFromDir as loadMemoriesFromDir34,
   parseSince as parseSince3,
   readUsageEvents as readUsageEvents5,
-  resolveHaivePaths as resolveHaivePaths37
+  resolveHaivePaths as resolveHaivePaths38
 } 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 = findProjectRoot41(opts.dir);
-    const paths = resolveHaivePaths37(root);
+    const root = findProjectRoot42(opts.dir);
+    const paths = resolveHaivePaths38(root);
     const events = await readUsageEvents5(paths);
     if (events.length === 0) {
       if (opts.json) {
@@ -11377,7 +12005,7 @@ function registerPlayback(program2) {
     const filtered = cutoff > 0 ? events.filter((e) => Date.parse(e.at) >= cutoff) : events;
     const gapMs = Math.max(1, parseInt(opts.sessionGap ?? "30", 10)) * MS_PER_MINUTE;
     const sessions = bucketSessions(filtered, gapMs);
-    const all = existsSync61(paths.memoriesDir) ? await loadMemoriesFromDir33(paths.memoriesDir) : [];
+    const all = existsSync64(paths.memoriesDir) ? await loadMemoriesFromDir34(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);
@@ -11467,8 +12095,8 @@ function truncate3(text, max) {
 import { spawn as spawn4 } from "child_process";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot42,
-  resolveHaivePaths as resolveHaivePaths38
+  findProjectRoot as findProjectRoot43,
+  resolveHaivePaths as resolveHaivePaths39
 } from "@hiveai/core";
 function registerPrecommit(program2) {
   program2.command("precommit").description(
@@ -11478,8 +12106,8 @@ function registerPrecommit(program2) {
     "'any' | 'high-confidence' (default) | 'never' (report only)",
     "high-confidence"
   ).option("--no-semantic", "disable semantic search in anti-patterns matching").option("--json", "emit JSON instead of human-readable output", false).option("--paths <paths...>", "explicit paths to check (skips git diff)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot42(opts.dir);
-    const paths = resolveHaivePaths38(root);
+    const root = findProjectRoot43(opts.dir);
+    const paths = resolveHaivePaths39(root);
     const ctx = { paths };
     let diff = "";
     let touchedPaths = opts.paths ?? [];
@@ -11513,401 +12141,142 @@ function registerPrecommit(program2) {
         `  anti-patterns: ${result.summary.anti_patterns}  blocking: ${result.summary.blocking_warnings ?? result.summary.anti_patterns}  review: ${result.summary.review_warnings ?? 0}  info: ${result.summary.info_warnings ?? 0}  relevant memories: ${result.summary.relevant_memories}  stale anchors: ${result.summary.stale_anchors}`
       )
     );
-    console.log();
-    const blocking = result.warnings.filter((w) => w.level === "blocking");
-    const review = result.warnings.filter((w) => w.level === "review");
-    const info = result.warnings.filter((w) => w.level === "info");
-    printWarnings("Blocking anti-patterns", blocking, "error");
-    printWarnings("Review anti-patterns", review.slice(0, 8), "warn");
-    if (info.length > 0) {
-      console.log(
-        ui.dim(
-          `${info.length} weak anti-pattern signal${info.length === 1 ? "" : "s"} hidden. Use --json to inspect FYI matches.`
-        )
-      );
-      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 printWarnings(title, warnings, tone) {
-  if (warnings.length === 0) return;
-  console.log(ui.bold(tone === "error" ? `\u2717 ${title}:` : `\u26A0 ${title}:`));
-  for (const w of warnings) {
-    const marker = tone === "error" ? ui.red("\u2717") : ui.yellow("\u26A0");
-    console.log(`  ${marker} ${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(", ")}`);
-    if (w.affected_files && w.affected_files.length > 0) {
-      console.log(`     ${ui.dim("files:")} ${w.affected_files.slice(0, 4).join(", ")}`);
-    }
-    if (w.rationale) console.log(`     ${ui.dim("why shown:")} ${w.rationale}`);
-    if (w.repair_command) console.log(`     ${ui.dim("repair:")} ${w.repair_command}`);
-  }
-  console.log();
-}
-function runCommand3(cmd, args, cwd) {
-  return new Promise((resolve, reject) => {
-    const proc = spawn4(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/commands/welcome.ts
-import { existsSync as existsSync63 } from "fs";
-import "commander";
-import {
-  findProjectRoot as findProjectRoot43,
-  loadMemoriesFromDir as loadMemoriesFromDir34,
-  resolveHaivePaths as resolveHaivePaths39
-} from "@hiveai/core";
-var TYPE_RANK = {
-  decision: 0,
-  architecture: 1,
-  convention: 2,
-  glossary: 3,
-  gotcha: 4,
-  attempt: 5
-};
-function registerWelcome(program2) {
-  program2.command("welcome").description(
-    "Onboarding checklist: ranks validated/proposed **team** memories by type.\nUse after `haive init` so new devs skim institutional knowledge quickly.\n\n  haive welcome\n  haive welcome --limit 15\n"
-  ).option("--limit <n>", "maximum memories listed", "20").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot43(opts.dir);
-    const paths = resolveHaivePaths39(root);
-    if (!existsSync63(paths.memoriesDir)) {
-      ui.error(`No memories at ${paths.memoriesDir}. Run 'haive init' first.`);
-      process.exitCode = 1;
-      return;
-    }
-    const all = await loadMemoriesFromDir34(paths.memoriesDir);
-    const team = all.filter(
-      ({ memory: memory2 }) => memory2.frontmatter.scope === "team" && memory2.frontmatter.status !== "rejected" && memory2.frontmatter.status !== "deprecated" && memory2.frontmatter.status !== "stale" && memory2.frontmatter.type !== "session_recap"
-    );
-    team.sort((a, b) => {
-      const ta = TYPE_RANK[a.memory.frontmatter.type] ?? 99;
-      const tb = TYPE_RANK[b.memory.frontmatter.type] ?? 99;
-      if (ta !== tb) return ta - tb;
-      const sta = a.memory.frontmatter.status === "validated" ? 0 : 1;
-      const stb = b.memory.frontmatter.status === "validated" ? 0 : 1;
-      if (sta !== stb) return sta - stb;
-      return b.memory.frontmatter.created_at.localeCompare(a.memory.frontmatter.created_at);
-    });
-    const cap = Math.max(1, Math.min(500, Number(opts.limit) || 20));
-    const pick = team.slice(0, cap);
-    console.log(ui.bold(`hAIve welcome \u2014 ${pick.length} team memories (${root})`));
-    console.log(ui.dim(`Next: invoke get_briefing with your task or run 'haive briefing --task "\u2026"'`));
-    if (pick.length === 0) {
-      ui.warn("No team memories yet \u2014 add some with 'haive memory add' or promote personal ones.");
-      return;
-    }
-    let i = 1;
-    for (const { memory: memory2 } of pick) {
-      const fm = memory2.frontmatter;
-      const head = memory2.body.match(/^#\s+(.+)/m)?.[1]?.trim();
-      const line = head ?? fm.id;
-      console.log(
-        `${String(i).padStart(2, " ")}  ${fm.type.padEnd(12)} ${fm.status.padEnd(10)} ${ui.dim(fm.id)}
-    ${line}`
-      );
-      i++;
-    }
-  });
-}
-
-// src/commands/memory-lint.ts
-import { existsSync as existsSync64 } from "fs";
-import { writeFile as writeFile31 } from "fs/promises";
-import path43 from "path";
-import "commander";
-import {
-  findProjectRoot as findProjectRoot44,
-  getUsage as getUsage20,
-  loadCodeMap as loadCodeMap6,
-  loadMemoriesFromDir as loadMemoriesFromDir35,
-  loadUsageIndex as loadUsageIndex26,
-  resolveHaivePaths as resolveHaivePaths40,
-  serializeMemory as serializeMemory26
-} from "@hiveai/core";
-async function lintMemoriesAsync(root, options = {}) {
-  const paths = resolveHaivePaths40(root);
-  const out = [];
-  const fixes = [];
-  if (!existsSync64(paths.memoriesDir)) return { findings: out, fixes };
-  const loaded = await loadMemoriesFromDir35(paths.memoriesDir);
-  const usage = await loadUsageIndex26(paths);
-  const codeMap = await loadCodeMap6(paths);
-  const ANCHOR_TYPES = /* @__PURE__ */ new Set(["decision", "architecture", "gotcha"]);
-  const actionableWords = /\b(always|never|prefer|use|avoid|because|instead|why|rationale|do not|must|should)\b/i;
-  for (const { filePath, memory: memory2 } of loaded) {
-    const fm = memory2.frontmatter;
-    if (fm.type === "session_recap") continue;
-    const body = memory2.body.trim();
-    const naked = body.replace(/^#.*$/gm, "").replace(/```[\s\S]*?```/g, "").trim();
-    if (naked.length < 40 && fm.status !== "rejected") {
-      out.push({
-        file: filePath,
-        id: fm.id,
-        severity: "warn",
-        code: "SHORT_BODY",
-        message: "Body looks very short (< ~40 chars of prose after headings). Prefer actionable detail."
-      });
-    }
-    if (["decision", "gotcha", "convention", "architecture", "attempt"].includes(fm.type) && fm.status !== "rejected" && !actionableWords.test(naked)) {
-      out.push({
-        file: filePath,
-        id: fm.id,
-        severity: "info",
-        code: "LOW_ACTIONABILITY",
-        message: "Record does not contain obvious action/rationale words. Add the concrete rule, why it exists, and what to do instead."
-      });
-    }
-    const suggestedAnchors = suggestAnchors(root, { filePath, memory: memory2 }, codeMap);
-    if (ANCHOR_TYPES.has(fm.type) && fm.anchor.paths.length === 0 && fm.status === "validated") {
-      out.push({
-        file: filePath,
-        id: fm.id,
-        severity: "warn",
-        code: "MISSING_ANCHOR",
-        message: `${fm.type} is validated without anchor paths \u2014 add anchor.paths so haive sync can flag staleness.`,
-        ...suggestedAnchors.paths.length > 0 || suggestedAnchors.symbols.length > 0 ? { suggested_anchors: suggestedAnchors } : {}
-      });
-    }
-    if (fm.status === "stale" && !fm.stale_reason) {
-      out.push({
-        file: filePath,
-        id: fm.id,
-        severity: "info",
-        code: "STALE_NO_REASON",
-        message: "Status is stale but stale_reason is empty \u2014 document why when possible."
-      });
-    }
-    if (fm.type === "glossary" && naked.length > 6e3) {
-      out.push({
-        file: filePath,
-        id: fm.id,
-        severity: "info",
-        code: "LONG_GLOSSARY",
-        message: "Very long glossary \u2014 consider splitting concepts for tighter briefings."
-      });
-    }
-    const hasMarkdownHeading = /^#{1,3}\s+\S/m.test(memory2.body.trim());
-    if (!hasMarkdownHeading) {
-      out.push({
-        file: filePath,
-        id: fm.id,
-        severity: "warn",
-        code: "NO_MD_HEADING",
-        message: "No Markdown heading (#/##/###) \u2014 add one so humans and auditors can skim the memo quickly."
-      });
-    }
-    const u = getUsage20(usage, fm.id);
-    if (fm.status === "validated" && u.read_count === 0) {
-      out.push({
-        file: filePath,
-        id: fm.id,
-        severity: "info",
-        code: "NEVER_READ",
-        message: "Validated record has never been surfaced/read. Consider improving tags/anchors or archiving it if it is not useful."
-      });
-    }
-    if (options.fix) {
-      const actions = [];
-      let nextBody = memory2.body;
-      let nextFrontmatter = memory2.frontmatter;
-      if (!hasMarkdownHeading) {
-        nextBody = `# ${titleFromId(fm.id)}
-
-${nextBody.trim()}`;
-        actions.push("add missing Markdown heading");
-      }
-      if (ANCHOR_TYPES.has(fm.type) && fm.anchor.paths.length === 0 && fm.anchor.symbols.length === 0 && fm.status === "validated" && !fm.tags.includes("needs_anchor")) {
-        nextFrontmatter = {
-          ...nextFrontmatter,
-          tags: [...nextFrontmatter.tags, "needs_anchor"]
-        };
-        actions.push("tag validated anchorless record with needs_anchor");
-      }
-      if (actions.length > 0) {
-        fixes.push({ file: filePath, id: fm.id, actions, applied: Boolean(options.apply) });
-        if (options.apply) {
-          await writeFile31(
-            filePath,
-            serializeMemory26({ frontmatter: nextFrontmatter, body: nextBody }),
-            "utf8"
-          );
-        }
+    console.log();
+    const blocking = result.warnings.filter((w) => w.level === "blocking");
+    const review = result.warnings.filter((w) => w.level === "review");
+    const info = result.warnings.filter((w) => w.level === "info");
+    printWarnings("Blocking anti-patterns", blocking, "error");
+    printWarnings("Review anti-patterns", review.slice(0, 8), "warn");
+    if (info.length > 0) {
+      console.log(
+        ui.dim(
+          `${info.length} weak anti-pattern signal${info.length === 1 ? "" : "s"} hidden. Use --json to inspect FYI matches.`
+        )
+      );
+      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();
     }
-  }
-  for (const dup of nearDuplicatePairs(loaded)) {
-    out.push({
-      file: dup.file,
-      id: dup.id,
-      severity: "warn",
-      code: "NEAR_DUPLICATE",
-      message: `Body overlaps ~${Math.round(dup.score * 100)}% with ${dup.otherId}. Merge or deprecate one record to reduce briefing noise.`
-    });
-  }
-  return { findings: out, fixes };
-}
-function titleFromId(id) {
-  const withoutDate = id.replace(/^\d{4}-\d{2}-\d{2}-/, "");
-  return withoutDate.split("-").filter(Boolean).map((part) => part.slice(0, 1).toUpperCase() + part.slice(1)).join(" ");
-}
-function suggestAnchors(root, loaded, codeMap) {
-  const body = loaded.memory.body;
-  const paths = /* @__PURE__ */ new Set();
-  const symbols = /* @__PURE__ */ new Set();
-  for (const match of body.matchAll(/`([^`\n]+\.[A-Za-z0-9]+)`|(?:^|\s)([A-Za-z0-9_./-]+\.[A-Za-z0-9]+)/gm)) {
-    const candidate = (match[1] ?? match[2] ?? "").replace(/^\.?\//, "");
-    if (!candidate || candidate.startsWith("http")) continue;
-    if (existsSync64(path43.join(root, candidate))) paths.add(candidate);
-  }
-  if (codeMap) {
-    const lowered = body.toLowerCase();
-    for (const [file, entry] of Object.entries(codeMap.files)) {
-      for (const exp of entry.exports) {
-        if (!exp.name || exp.name.length < 4) continue;
-        if (lowered.includes(exp.name.toLowerCase())) {
-          paths.add(file);
-          symbols.add(exp.name);
-        }
-        if (paths.size >= 5 && symbols.size >= 5) break;
+    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)}`);
       }
-      if (paths.size >= 5 && symbols.size >= 5) break;
+      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).");
     }
-  }
-  return {
-    paths: [...paths].slice(0, 5),
-    symbols: [...symbols].slice(0, 5)
-  };
-}
-function nearDuplicatePairs(loaded) {
-  const out = [];
-  const candidates = loaded.filter(({ memory: memory2 }) => {
-    const fm = memory2.frontmatter;
-    return fm.type !== "session_recap" && fm.status !== "rejected" && fm.status !== "deprecated";
   });
-  for (let i = 0; i < candidates.length; i++) {
-    for (let j = i + 1; j < candidates.length; j++) {
-      const a = candidates[i];
-      const b = candidates[j];
-      if (a.memory.frontmatter.scope !== b.memory.frontmatter.scope) continue;
-      if (a.memory.frontmatter.type !== b.memory.frontmatter.type) continue;
-      const score = jaccard2(tokenSet(a.memory.body), tokenSet(b.memory.body));
-      if (score >= 0.72) {
-        out.push({
-          id: a.memory.frontmatter.id,
-          otherId: b.memory.frontmatter.id,
-          file: a.filePath,
-          score
-        });
-      }
+}
+function printWarnings(title, warnings, tone) {
+  if (warnings.length === 0) return;
+  console.log(ui.bold(tone === "error" ? `\u2717 ${title}:` : `\u26A0 ${title}:`));
+  for (const w of warnings) {
+    const marker = tone === "error" ? ui.red("\u2717") : ui.yellow("\u26A0");
+    console.log(`  ${marker} ${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(", ")}`);
+    if (w.affected_files && w.affected_files.length > 0) {
+      console.log(`     ${ui.dim("files:")} ${w.affected_files.slice(0, 4).join(", ")}`);
     }
+    if (w.rationale) console.log(`     ${ui.dim("why shown:")} ${w.rationale}`);
+    if (w.repair_command) console.log(`     ${ui.dim("repair:")} ${w.repair_command}`);
   }
-  return out;
-}
-function tokenSet(body) {
-  return new Set(
-    (body.toLowerCase().match(/\b[a-z0-9]{4,}\b/g) ?? []).filter((word) => !["this", "that", "with", "from", "have"].includes(word))
-  );
+  console.log();
 }
-function jaccard2(a, b) {
-  if (a.size === 0 || b.size === 0) return 0;
-  let inter = 0;
-  for (const item of a) if (b.has(item)) inter++;
-  return inter / (a.size + b.size - inter);
+function runCommand3(cmd, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn4(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}`));
+    });
+  });
 }
-function registerMemoryLint(parent) {
-  parent.command("lint").description(
-    "Heuristic corpus checks (anchors on key types, headings, verbosity). Static analysis only."
-  ).option("--json", "emit findings as JSON", false).option("--fix", "prepare simple automatic fixes (use with --dry-run or --apply)", false).option("--dry-run", "with --fix, show files that would change without writing", false).option("--apply", "with --fix, write simple fixes to disk", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
+
+// src/commands/welcome.ts
+import { existsSync as existsSync65 } from "fs";
+import "commander";
+import {
+  findProjectRoot as findProjectRoot44,
+  loadMemoriesFromDir as loadMemoriesFromDir35,
+  resolveHaivePaths as resolveHaivePaths40
+} from "@hiveai/core";
+var TYPE_RANK = {
+  decision: 0,
+  architecture: 1,
+  convention: 2,
+  glossary: 3,
+  gotcha: 4,
+  attempt: 5
+};
+function registerWelcome(program2) {
+  program2.command("welcome").description(
+    "Onboarding checklist: ranks validated/proposed **team** memories by type.\nUse after `haive init` so new devs skim institutional knowledge quickly.\n\n  haive welcome\n  haive welcome --limit 15\n"
+  ).option("--limit <n>", "maximum memories listed", "20").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot44(opts.dir);
-    const apply = Boolean(opts.fix && opts.apply);
-    const dryRun = Boolean(opts.fix && (opts.dryRun || !opts.apply));
-    const report = await lintMemoriesAsync(root, { fix: Boolean(opts.fix), apply });
-    const findings = report.findings;
-    if (opts.json) {
-      console.log(JSON.stringify({
-        findings_count: findings.length,
-        findings,
-        fixes_count: report.fixes.length,
-        fixes: report.fixes,
-        fix_mode: opts.fix ? apply ? "apply" : "dry-run" : "off"
-      }, null, 2));
-      process.exitCode = findings.some((f) => f.severity === "error") ? 1 : 0;
+    const paths = resolveHaivePaths40(root);
+    if (!existsSync65(paths.memoriesDir)) {
+      ui.error(`No memories at ${paths.memoriesDir}. Run 'haive init' first.`);
+      process.exitCode = 1;
       return;
     }
-    if (findings.length === 0) {
-      ui.success(`memory lint OK \u2014 ${root}`);
+    const all = await loadMemoriesFromDir35(paths.memoriesDir);
+    const team = all.filter(
+      ({ memory: memory2 }) => memory2.frontmatter.scope === "team" && memory2.frontmatter.status !== "rejected" && memory2.frontmatter.status !== "deprecated" && memory2.frontmatter.status !== "stale" && memory2.frontmatter.type !== "session_recap"
+    );
+    team.sort((a, b) => {
+      const ta = TYPE_RANK[a.memory.frontmatter.type] ?? 99;
+      const tb = TYPE_RANK[b.memory.frontmatter.type] ?? 99;
+      if (ta !== tb) return ta - tb;
+      const sta = a.memory.frontmatter.status === "validated" ? 0 : 1;
+      const stb = b.memory.frontmatter.status === "validated" ? 0 : 1;
+      if (sta !== stb) return sta - stb;
+      return b.memory.frontmatter.created_at.localeCompare(a.memory.frontmatter.created_at);
+    });
+    const cap = Math.max(1, Math.min(500, Number(opts.limit) || 20));
+    const pick = team.slice(0, cap);
+    console.log(ui.bold(`hAIve welcome \u2014 ${pick.length} team memories (${root})`));
+    console.log(ui.dim(`Next: invoke get_briefing with your task or run 'haive briefing --task "\u2026"'`));
+    if (pick.length === 0) {
+      ui.warn("No team memories yet \u2014 add some with 'haive memory add' or promote personal ones.");
       return;
     }
-    console.log(ui.bold(`memory lint (${findings.length} finding${findings.length === 1 ? "" : "s"})`) + `
-`);
-    if (opts.fix) {
-      const mode = apply ? "apply" : dryRun ? "dry-run" : "dry-run";
-      const verb = apply ? "changed" : "would change";
-      console.log(ui.bold(`fix ${mode}: ${report.fixes.length} file${report.fixes.length === 1 ? "" : "s"} ${verb}`));
-      for (const fix of report.fixes) {
-        console.log(`  ${ui.dim(fix.id)} ${fix.actions.join("; ")}`);
-        console.log(ui.dim(`       \u2192 ${fix.file}`));
-      }
-      console.log();
-    }
-    const order = { error: 0, warn: 1, info: 2 };
-    findings.sort((a, b) => order[a.severity] - order[b.severity] || a.id.localeCompare(b.id));
-    for (const f of findings) {
-      const color = f.severity === "error" ? ui.red : f.severity === "warn" ? ui.yellow : ui.dim;
+    let i = 1;
+    for (const { memory: memory2 } of pick) {
+      const fm = memory2.frontmatter;
+      const head = memory2.body.match(/^#\s+(.+)/m)?.[1]?.trim();
+      const line = head ?? fm.id;
       console.log(
-        `${color(f.severity.padEnd(5))} ${ui.dim(f.code)} ${f.id}`
+        `${String(i).padStart(2, " ")}  ${fm.type.padEnd(12)} ${fm.status.padEnd(10)} ${ui.dim(fm.id)}
+    ${line}`
       );
-      console.log(`       ${f.message}`);
-      if (f.suggested_anchors) {
-        const pathHints = f.suggested_anchors.paths.length > 0 ? `paths: ${f.suggested_anchors.paths.join(", ")}` : "";
-        const symbolHints = f.suggested_anchors.symbols.length > 0 ? `symbols: ${f.suggested_anchors.symbols.join(", ")}` : "";
-        console.log(ui.dim(`       suggested anchors: ${[pathHints, symbolHints].filter(Boolean).join(" \xB7 ")}`));
-      }
-      console.log(ui.dim(`       \u2192 ${f.file}`));
+      i++;
     }
-    process.exitCode = findings.some((x) => x.severity === "error") ? 1 : 0;
   });
 }
 
@@ -11930,21 +12299,21 @@ function registerMemorySuggestTopic(memory2) {
 }
 
 // src/commands/resolve-project.ts
-import path44 from "path";
+import path45 from "path";
 import "commander";
 import { resolveProjectInfo as resolveProjectInfo2 } from "@hiveai/core";
 function registerResolveProject(program2) {
   program2.command("resolve-project").description(
     "Print JSON for hAIve project root resolution (HAIVE_PROJECT_ROOT, markers, .ai layout)."
   ).option("-d, --dir <dir>", "working directory", process.cwd()).action((opts) => {
-    const info = resolveProjectInfo2({ cwd: path44.resolve(opts.dir) });
+    const info = resolveProjectInfo2({ cwd: path45.resolve(opts.dir) });
     console.log(JSON.stringify({ ok: true, info }, null, 2));
   });
 }
 
 // src/commands/runtime-journal.ts
-import { existsSync as existsSync65 } from "fs";
-import path45 from "path";
+import { existsSync as existsSync66 } from "fs";
+import path46 from "path";
 import "commander";
 import {
   appendRuntimeJournalEntry as appendRuntimeJournalEntry3,
@@ -11958,18 +12327,18 @@ function registerRuntime(program2) {
   );
   const journal = runtime.command("journal").description("Append or read the machine-local session journal (NDJSON)");
   journal.command("append").description("Append one JSON line to .ai/.runtime/session-journal.ndjson").argument("<message>", "short text to log").option("-k, --kind <kind>", "note | session_end | mcp", "note").option("-d, --dir <dir>", "project root", process.cwd()).action(async (message, opts) => {
-    const root = path45.resolve(opts.dir ?? process.cwd());
+    const root = path46.resolve(opts.dir ?? process.cwd());
     const paths = resolveHaivePaths41(findProjectRoot45(root));
     const raw = opts.kind ?? "note";
     const kind = ["note", "session_end", "mcp"].includes(raw) ? raw : "note";
     await appendRuntimeJournalEntry3(paths, { kind, message });
-    ui.success(`Appended to ${path45.relative(root, paths.runtimeDir)}/session-journal.ndjson`);
+    ui.success(`Appended to ${path46.relative(root, paths.runtimeDir)}/session-journal.ndjson`);
   });
   journal.command("tail").description("Print the last N entries from the runtime session journal as JSON").option("-n, --limit <n>", "number of lines", "30").option("-d, --dir <dir>", "project root", process.cwd()).action(async (opts) => {
-    const root = path45.resolve(opts.dir ?? process.cwd());
+    const root = path46.resolve(opts.dir ?? process.cwd());
     const paths = resolveHaivePaths41(findProjectRoot45(root));
     const limit = Math.min(500, Math.max(1, parseInt(opts.limit, 10) || 30));
-    if (!existsSync65(paths.haiveDir)) {
+    if (!existsSync66(paths.haiveDir)) {
       ui.error("No .ai/ \u2014 run `haive init` first.");
       process.exitCode = 1;
       return;
@@ -11984,8 +12353,8 @@ function registerRuntime(program2) {
 }
 
 // src/commands/memory-timeline.ts
-import { existsSync as existsSync66 } from "fs";
-import path46 from "path";
+import { existsSync as existsSync67 } from "fs";
+import path47 from "path";
 import "commander";
 import {
   collectTimelineEntries as collectTimelineEntries2,
@@ -12001,15 +12370,15 @@ function registerMemoryTimeline(memory2) {
       process.exitCode = 1;
       return;
     }
-    const root = path46.resolve(opts.dir ?? process.cwd());
+    const root = path47.resolve(opts.dir ?? process.cwd());
     const paths = resolveHaivePaths42(findProjectRoot46(root));
-    if (!existsSync66(paths.memoriesDir)) {
+    if (!existsSync67(paths.memoriesDir)) {
       ui.error("No memories \u2014 run `haive init`.");
       process.exitCode = 1;
       return;
     }
     const limit = Math.min(100, Math.max(1, parseInt(opts.limit, 10) || 30));
-    const all = await loadMemoriesFromDir25(paths.memoriesDir);
+    const all = await loadMemoriesFromDir26(paths.memoriesDir);
     const { entries, notice } = collectTimelineEntries2(all, {
       memoryId: opts.id,
       topic: opts.topic,
@@ -12021,8 +12390,8 @@ function registerMemoryTimeline(memory2) {
 }
 
 // src/commands/memory-conflict-candidates.ts
-import { existsSync as existsSync67 } from "fs";
-import path47 from "path";
+import { existsSync as existsSync68 } from "fs";
+import path48 from "path";
 import "commander";
 import {
   findLexicalConflictPairs as findLexicalConflictPairs2,
@@ -12044,9 +12413,9 @@ function registerMemoryConflictCandidates(memory2) {
     "decision,architecture,convention,gotcha (lexical scan)",
     "decision,architecture"
   ).option("--min-jaccard <x>", "minimum Jaccard for lexical pairs", "0.45").option("--max-pairs <n>", "cap lexical pairs", "20").option("--max-scan <n>", "max memories scanned (lexical)", "500").option("--max-topic-pairs <n>", "cap topic/status pairs", "20").action(async (opts) => {
-    const root = path47.resolve(opts.dir ?? process.cwd());
+    const root = path48.resolve(opts.dir ?? process.cwd());
     const paths = resolveHaivePaths43(findProjectRoot47(root));
-    if (!existsSync67(paths.memoriesDir)) {
+    if (!existsSync68(paths.memoriesDir)) {
       ui.error("No memories \u2014 run `haive init`.");
       process.exitCode = 1;
       return;
@@ -12056,7 +12425,7 @@ function registerMemoryConflictCandidates(memory2) {
     const maxPairs = Math.min(100, Math.max(1, parseInt(opts.maxPairs, 10) || 20));
     const maxScan = Math.min(2e3, Math.max(1, parseInt(opts.maxScan, 10) || 500));
     const maxTopicPairs = Math.min(100, Math.max(1, parseInt(opts.maxTopicPairs, 10) || 20));
-    const all = await loadMemoriesFromDir25(paths.memoriesDir);
+    const all = await loadMemoriesFromDir26(paths.memoriesDir);
     const lexical = findLexicalConflictPairs2(all, {
       sinceDays,
       types: parseTypes(opts.types),
@@ -12082,21 +12451,21 @@ function registerMemoryConflictCandidates(memory2) {
 
 // src/commands/enforce.ts
 import { execFileSync as execFileSync2, spawn as spawn5 } from "child_process";
-import { existsSync as existsSync68 } from "fs";
-import { chmod as chmod2, mkdir as mkdir19, readFile as readFile18, rm as rm3, writeFile as writeFile33 } from "fs/promises";
-import path48 from "path";
+import { existsSync as existsSync69 } from "fs";
+import { chmod as chmod2, mkdir as mkdir19, readFile as readFile19, rm as rm3, writeFile as writeFile34 } from "fs/promises";
+import path49 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot48,
   hasRecentBriefingMarker,
   isFreshIsoDate,
-  loadConfig as loadConfig8,
+  loadConfig as loadConfig11,
   loadMemoriesFromDir as loadMemoriesFromDir36,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths6,
   readRecentBriefingMarker,
   resolveBriefingBudget as resolveBriefingBudget3,
   resolveHaivePaths as resolveHaivePaths44,
-  saveConfig as saveConfig3,
+  saveConfig as saveConfig4,
   SESSION_RECAP_TTL_MS,
   verifyAnchor as verifyAnchor4,
   writeBriefingMarker as writeBriefingMarker2
@@ -12111,8 +12480,8 @@ function registerEnforce(program2) {
     const root = findProjectRoot48(opts.dir);
     const paths = resolveHaivePaths44(root);
     await mkdir19(paths.haiveDir, { recursive: true });
-    const current = await loadConfig8(paths);
-    await saveConfig3(paths, {
+    const current = await loadConfig11(paths);
+    await saveConfig4(paths, {
       ...current,
       enforcement: {
         ...current.enforcement,
@@ -12134,7 +12503,7 @@ function registerEnforce(program2) {
     if (opts.claude !== false) {
       try {
         const result = await installClaudeHooksAtPath(defaultClaudeSettingsPath("project", root));
-        ui.success(`${result.created ? "Created" : "Patched"} Claude Code hooks (${path48.relative(root, result.settingsPath)})`);
+        ui.success(`${result.created ? "Created" : "Patched"} Claude Code hooks (${path49.relative(root, result.settingsPath)})`);
       } catch (err) {
         ui.warn(`Claude Code hooks not installed: ${err instanceof Error ? err.message : String(err)}`);
       }
@@ -12156,12 +12525,12 @@ function registerEnforce(program2) {
     const root = findProjectRoot48(opts.dir);
     const paths = resolveHaivePaths44(root);
     const targets = [
-      path48.join(paths.haiveDir, ".cache"),
-      path48.join(paths.haiveDir, ".runtime")
+      path49.join(paths.haiveDir, ".cache"),
+      path49.join(paths.haiveDir, ".runtime")
     ];
     for (const target of targets) {
-      if (!existsSync68(target)) continue;
-      const rel = path48.relative(root, target);
+      if (!existsSync69(target)) continue;
+      const rel = path49.relative(root, target);
       if (opts.dryRun) ui.info(`would remove ${rel}`);
       else {
         await rm3(target, { recursive: true, force: true });
@@ -12179,7 +12548,7 @@ function registerEnforce(program2) {
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
     const paths = resolveHaivePaths44(root);
-    if (!existsSync68(paths.haiveDir)) return;
+    if (!existsSync69(paths.haiveDir)) return;
     await mkdir19(paths.runtimeDir, { recursive: true });
     const sessionId = opts.sessionId ?? payload.session_id;
     const task = opts.task ?? payload.prompt ?? "Start an AI coding session in this hAIve-initialized project.";
@@ -12241,7 +12610,7 @@ ${briefing.project_context.content.slice(0, 1800)}`);
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
     const paths = resolveHaivePaths44(root);
-    if (!existsSync68(paths.haiveDir)) return;
+    if (!existsSync69(paths.haiveDir)) return;
     if (!isWriteLikeTool(payload)) return;
     const ok = await hasRecentBriefingMarker(paths, payload.session_id);
     if (ok) return;
@@ -12265,7 +12634,7 @@ ${briefing.project_context.content.slice(0, 1800)}`);
 async function runWithEnforcement(command, args, opts) {
   const root = findProjectRoot48(opts.dir);
   const paths = resolveHaivePaths44(root);
-  if (!existsSync68(paths.haiveDir)) {
+  if (!existsSync69(paths.haiveDir)) {
     ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
     process.exit(1);
   }
@@ -12284,7 +12653,7 @@ async function runWithEnforcement(command, args, opts) {
     process.exit(2);
   }
   ui.info(`hAIve briefing marker created for wrapped agent session: ${sessionId}`);
-  ui.info(`Briefing written to ${path48.relative(root, briefingFile)} and exported as HAIVE_BRIEFING_FILE`);
+  ui.info(`Briefing written to ${path49.relative(root, briefingFile)} and exported as HAIVE_BRIEFING_FILE`);
   const child = spawn5(command, args, {
     cwd: root,
     stdio: "inherit",
@@ -12333,9 +12702,9 @@ async function writeWrapperBriefing(paths, sessionId, task) {
     source: "haive-run",
     memoryIds: briefing.memories.map((m) => m.id)
   });
-  const dir = path48.join(paths.runtimeDir, "enforcement", "briefings");
+  const dir = path49.join(paths.runtimeDir, "enforcement", "briefings");
   await mkdir19(dir, { recursive: true });
-  const file = path48.join(dir, `${sessionId}.md`);
+  const file = path49.join(dir, `${sessionId}.md`);
   const parts = [
     "# hAIve Briefing",
     "",
@@ -12353,14 +12722,14 @@ async function writeWrapperBriefing(paths, sessionId, task) {
   if (briefing.setup_warnings.length > 0) {
     parts.push("", "## Setup Warnings", ...briefing.setup_warnings.map((w) => `- ${w}`));
   }
-  await writeFile33(file, parts.join("\n") + "\n", "utf8");
+  await writeFile34(file, parts.join("\n") + "\n", "utf8");
   return file;
 }
 async function buildEnforcementReport(dir, stage, sessionId) {
   const root = findProjectRoot48(dir);
   const paths = resolveHaivePaths44(root);
-  const initialized = existsSync68(paths.haiveDir);
-  const config = initialized ? await loadConfig8(paths) : {};
+  const initialized = existsSync69(paths.haiveDir);
+  const config = initialized ? await loadConfig11(paths) : {};
   const mode = config.enforcement?.mode ?? "strict";
   const findings = [];
   if (!initialized) {
@@ -12389,7 +12758,7 @@ async function buildEnforcementReport(dir, stage, sessionId) {
       findings: [{ severity: "info", code: "enforcement-off", message: "hAIve enforcement is disabled." }]
     });
   }
-  findings.push(...await inspectIntegrationVersions(root, "0.9.17"));
+  findings.push(...await inspectIntegrationVersions(root, "0.9.19"));
   if (config.enforcement?.requireBriefingFirst !== false && stage !== "ci") {
     const hasBriefing = await hasRecentBriefingMarker(paths, sessionId);
     findings.push(hasBriefing ? { severity: "ok", code: "briefing-loaded", message: "A recent hAIve briefing marker exists." } : {
@@ -12459,7 +12828,7 @@ function withCategories(report) {
   };
 }
 async function hasRecentSessionRecap(paths) {
-  if (!existsSync68(paths.memoriesDir)) return false;
+  if (!existsSync69(paths.memoriesDir)) return false;
   const all = await loadMemoriesFromDir36(paths.memoriesDir);
   return all.some(({ memory: memory2 }) => {
     const fm = memory2.frontmatter;
@@ -12468,7 +12837,7 @@ async function hasRecentSessionRecap(paths) {
   });
 }
 async function verifyMemoryPolicy(paths, config) {
-  if (!existsSync68(paths.memoriesDir)) return [];
+  if (!existsSync69(paths.memoriesDir)) return [];
   const all = await loadMemoriesFromDir36(paths.memoriesDir);
   const findings = [];
   const staleImportant = [];
@@ -12506,7 +12875,7 @@ async function verifyMemoryPolicy(paths, config) {
   return findings;
 }
 async function verifyDecisionCoverage(paths, stage, sessionId) {
-  if (!existsSync68(paths.memoriesDir)) return [];
+  if (!existsSync69(paths.memoriesDir)) return [];
   const changedFiles = await getChangedFiles(paths.root, stage);
   if (changedFiles.length === 0) {
     return [{ severity: "info", code: "decision-coverage-no-changes", message: "No changed files to match against policy memories." }];
@@ -12599,9 +12968,9 @@ async function inspectIntegrationVersions(root, expectedVersion) {
   ];
   const findings = [];
   for (const rel of files) {
-    const file = path48.join(root, rel);
-    if (!existsSync68(file)) continue;
-    const text = await readFile18(file, "utf8").catch(() => "");
+    const file = path49.join(root, rel);
+    if (!existsSync69(file)) continue;
+    const text = await readFile19(file, "utf8").catch(() => "");
     for (const bin of extractAbsoluteHaiveBins2(text)) {
       const version = versionForBinary2(bin);
       if (!version) {
@@ -12689,8 +13058,8 @@ function buildScore(findings, threshold = 80) {
   };
 }
 async function installGitEnforcement(root) {
-  const hooksDir = path48.join(root, ".git", "hooks");
-  if (!existsSync68(path48.join(root, ".git"))) {
+  const hooksDir = path49.join(root, ".git", "hooks");
+  if (!existsSync69(path49.join(root, ".git"))) {
     ui.warn("No .git directory found; git enforcement hooks skipped.");
     return;
   }
@@ -12712,31 +13081,31 @@ haive enforce check --stage pre-push --dir . || exit $?
     }
   ];
   for (const hook of hooks) {
-    const file = path48.join(hooksDir, hook.name);
-    if (existsSync68(file)) {
-      const current = await readFile18(file, "utf8").catch(() => "");
+    const file = path49.join(hooksDir, hook.name);
+    if (existsSync69(file)) {
+      const current = await readFile19(file, "utf8").catch(() => "");
       if (current.includes(ENFORCE_HOOK_MARKER)) {
-        await writeFile33(file, hook.body, "utf8");
+        await writeFile34(file, hook.body, "utf8");
       } else {
-        await writeFile33(file, `${current.trimEnd()}
+        await writeFile34(file, `${current.trimEnd()}
 
 ${hook.body}`, "utf8");
       }
     } else {
-      await writeFile33(file, hook.body, "utf8");
+      await writeFile34(file, hook.body, "utf8");
     }
     await chmod2(file, 493);
   }
   ui.success("Installed blocking git enforcement hooks: pre-commit, pre-push");
 }
 async function installCiEnforcement(root) {
-  const workflowPath = path48.join(root, ".github", "workflows", "haive-enforcement.yml");
-  await mkdir19(path48.dirname(workflowPath), { recursive: true });
-  if (existsSync68(workflowPath)) {
+  const workflowPath = path49.join(root, ".github", "workflows", "haive-enforcement.yml");
+  await mkdir19(path49.dirname(workflowPath), { recursive: true });
+  if (existsSync69(workflowPath)) {
     ui.info("GitHub Actions enforcement workflow already exists \u2014 skipped");
     return;
   }
-  await writeFile33(workflowPath, `name: haive-enforcement
+  await writeFile34(workflowPath, `name: haive-enforcement
 
 on:
   pull_request:
@@ -12760,7 +13129,7 @@ jobs:
       - name: Enforce hAIve policy
         run: haive enforce ci
 `, "utf8");
-  ui.success(`Created ${path48.relative(root, workflowPath)}`);
+  ui.success(`Created ${path49.relative(root, workflowPath)}`);
 }
 function printReport(report, json, explain = false) {
   if (json) {
@@ -12877,7 +13246,7 @@ function registerRun(program2) {
 
 // src/index.ts
 var program = new Command51();
-program.name("haive").description("hAIve \u2014 policy enforcement layer for AI coding agents").version("0.9.17").option("--advanced", "show maintenance and experimental commands in help");
+program.name("haive").description("hAIve \u2014 policy enforcement layer for AI coding agents").version("0.9.19").option("--advanced", "show maintenance and experimental commands in help");
 registerInit(program);
 registerWelcome(program);
 registerResolveProject(program);