@hiveai/cli 0.9.16 → 0.9.18

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(([path48, changes]) => ({ path: path48, 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)));
@@ -288,7 +288,7 @@ var TokenBudgetWriter = class {
 function registerBriefing(program2) {
   program2.command("briefing").description(
     'Print the full project briefing: last session recap + project context + relevant memories.\n  Equivalent to calling get_briefing via MCP. Run before starting any task.\n\n  Examples:\n    haive briefing\n    haive briefing --task "add Stripe payment" --files src/payments/PaymentService.ts\n    haive briefing --budget quick --task "tiny fix"\n'
-  ).option("--task <text>", "what you are about to do \u2014 filters memories by relevance").option("--files <csv>", "comma-separated file paths being worked on (surfaces anchored memories)").option("--symbols <csv>", "symbol names to look up in the code-map (e.g. PaymentService,TenantFilter) \u2014 requires haive index code").option("--max-memories <n>", "cap on memories surfaced", "10").option("--max-tokens <n>", "approximate token budget for the entire briefing (truncates if exceeded)").option("--explain-source", "annotate each memory with [source: <relative-path> \xB7 anchors: <files>] for traceable citations").option("--radar", "force project radar (recent commits, open TODOs, hot files) even when memories are plentiful").option("--no-radar", "disable the project radar even when memories are scarce").option(
+  ).option("--task <text>", "what you are about to do \u2014 filters memories by relevance").option("--files <csv>", "comma-separated file paths being worked on (surfaces anchored memories)").option("--symbols <csv>", "symbol names to look up in the code-map (e.g. PaymentService,TenantFilter) \u2014 requires haive index code").option("--max-memories <n>", "cap on memories surfaced", "8").option("--max-tokens <n>", "approximate token budget for the entire briefing (truncates if exceeded)").option("--explain-source", "annotate each memory with [source: <relative-path> \xB7 anchors: <files>] for traceable citations").option("--radar", "force project radar (recent commits, open TODOs, hot files) even when memories are plentiful").option("--no-radar", "disable the project radar even when memories are scarce").option(
     "--budget <preset>",
     "align with MCP get_briefing budget_preset: quick | balanced | deep \u2014 sets cap + truncation budget (overrides --max-memories / replaces default open-ended output)",
     void 0
@@ -325,7 +325,7 @@ function registerBriefing(program2) {
       if (b === "quick" || b === "balanced" || b === "deep") budgetPreset = b;
       else ui.warn(`Unknown --budget '${opts.budget}' \u2014 ignoring (use quick|balanced|deep).`);
     }
-    let maxMemories = Math.max(1, Number(opts.maxMemories ?? 10));
+    let maxMemories = Math.max(1, Number(opts.maxMemories ?? 8));
     let budgetTokensCap = opts.maxTokens ? Math.max(100, Number(opts.maxTokens)) : null;
     if (budgetPreset !== null) {
       const presetNums = resolveBriefingBudget(budgetPreset, {
@@ -470,7 +470,22 @@ function registerBriefing(program2) {
     const usageIndex = await loadUsageIndex(paths).catch(() => null);
     out(`${ui.bold("=== Relevant Memories ===")}
 `);
-    for (const item of top) {
+    const priorities = top.map(
+      (item) => classifyCliPriority(
+        item,
+        filePaths,
+        tokens,
+        Boolean(andTaskHits?.has(item.memory.frontmatter.id)),
+        Boolean(useOrFallback && tokens && literalMatchesAnyToken(item.memory, tokens))
+      )
+    );
+    const mustReadCount = priorities.filter((p) => p === "must_read").length;
+    const usefulCount = priorities.filter((p) => p === "useful").length;
+    const backgroundCount = priorities.filter((p) => p === "background").length;
+    const quality = mustReadCount > 0 || usefulCount > 0 ? backgroundCount > mustReadCount + usefulCount && backgroundCount > 2 ? "noisy" : "strong" : "thin";
+    out(ui.dim(`briefing_quality: ${quality} \xB7 must_read=${mustReadCount} useful=${usefulCount} background=${backgroundCount}`));
+    out("");
+    for (const [idx, item] of top.entries()) {
       if (stopped()) break;
       const fm = item.memory.frontmatter;
       const badge = ui.statusBadge(fm.status);
@@ -479,8 +494,9 @@ function registerBriefing(program2) {
       const originMarker = item.origin ? ` ${ui.yellow("[from " + item.origin + "]")}` : "";
       const reads = usageIndex?.by_id[fm.id]?.read_count ?? 0;
       const hitMarker = reads > 0 ? ` ${ui.dim("\xB7 " + reads + "\xD7 read")}` : "";
+      const priority = priorities[idx] ?? "background";
       out(
-        `${ui.bold(fm.id)}  ${ui.dim(fm.scope + "/" + fm.type)}  ${badge}${draftMarker}${unverifiedMarker}${originMarker}${hitMarker}`
+        `${ui.bold(fm.id)}  ${priorityBadge(priority)}  ${ui.dim(fm.scope + "/" + fm.type)}  ${badge}${draftMarker}${unverifiedMarker}${originMarker}${hitMarker}`
       );
       if (opts.explainSource) {
         const relPath = path.relative(root, item.filePath);
@@ -551,6 +567,20 @@ ${ui.bold("=== Symbol Locations ===")}
     }
   });
 }
+function classifyCliPriority(item, filePaths, tokens, exactTaskHit, partialTaskHit) {
+  const fm = item.memory.frontmatter;
+  const anchored = filePaths.length > 0 && memoryMatchesAnchorPaths(item.memory, filePaths);
+  if (anchored || fm.type === "attempt" && exactTaskHit) return "must_read";
+  if (exactTaskHit || partialTaskHit || item.score >= 4 || tokens && fm.tags.some((tag) => tokens.includes(tag))) {
+    return "useful";
+  }
+  return "background";
+}
+function priorityBadge(priority) {
+  if (priority === "must_read") return ui.red("[must_read]");
+  if (priority === "useful") return ui.yellow("[useful]");
+  return ui.dim("[background]");
+}
 function parseCsv(value) {
   if (!value) return [];
   return value.split(",").map((s) => s.trim()).filter(Boolean);
@@ -2432,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"));
@@ -2447,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"));
@@ -3054,6 +3084,7 @@ import {
   extractActionsBriefBody as extractActionsBriefBody2,
   getUsage as getUsage5,
   inferModulesFromPaths as inferModulesFromPaths2,
+  isGlobPath,
   isAutoPromoteEligible,
   isDecaying,
   literalMatchesAllTokens as literalMatchesAllTokens22,
@@ -3352,7 +3383,6 @@ async function memSave(input, ctx) {
       const { similarityWarning: simW, body_similar: bs } = bodySimilarWarnings(/* @__PURE__ */ new Set([fm.id]));
       const newFrontmatter = {
         ...fm,
-        body: input.body,
         tags: input.tags.length ? input.tags : fm.tags,
         revision_count: (fm.revision_count ?? 0) + 1,
         anchor: {
@@ -3368,6 +3398,7 @@ async function memSave(input, ctx) {
       );
       const mergedTw = [
         invalidPaths.length > 0 ? `Anchor path(s) not found in project: ${invalidPaths.join(", ")}. They will be marked stale by haive sync.` : null,
+        criticalAnchorWarning(input.type, fm.status, newFrontmatter.anchor.paths, newFrontmatter.anchor.symbols),
         simW ?? null
       ].filter(Boolean).join(" \u2014 ") || void 0;
       return {
@@ -3423,6 +3454,7 @@ async function memSave(input, ctx) {
   const { similarityWarning: simWarnNew, body_similar: bsNew } = bodySimilarWarnings();
   const finalWarning = [
     invalidPaths.length > 0 ? `Anchor path(s) not found in project: ${invalidPaths.join(", ")}. They will be marked stale by \`haive sync\`.` : null,
+    criticalAnchorWarning(frontmatter.type, frontmatter.status, frontmatter.anchor.paths, frontmatter.anchor.symbols),
     warning ?? null,
     simWarnNew ?? null
   ].filter(Boolean).join(" \u2014 ") || void 0;
@@ -3437,6 +3469,12 @@ async function memSave(input, ctx) {
     ...invalidPaths.length > 0 ? { invalid_paths: invalidPaths } : {}
   };
 }
+function criticalAnchorWarning(type, status, paths, symbols) {
+  if (!["decision", "gotcha", "architecture"].includes(type)) return null;
+  if (status !== "validated") return null;
+  if (paths.length > 0 || symbols.length > 0) return null;
+  return `${type} is validated without paths or symbols; add anchors so hAIve can detect drift.`;
+}
 var MemSearchInputSchema = {
   query: z5.string().describe("Substring matched against id, tags, and body"),
   scope: z5.enum(["personal", "team", "module"]).optional().describe("Restrict results to a single scope"),
@@ -4458,6 +4496,7 @@ async function getBriefing(input, ctx) {
         reasons: [reason],
         match_quality: matchQuality ?? "partial",
         ...score !== void 0 ? { semantic_score: score } : {},
+        priority: "background",
         body: loaded.memory.body,
         file_path: loaded.filePath
       });
@@ -4473,6 +4512,13 @@ async function getBriefing(input, ctx) {
         if (fm.tags.some((t) => inferred.includes(t))) addOrUpdate(loaded, "module", void 0, "partial");
       }
     }
+    if (input.symbols.length > 0) {
+      const wanted = new Set(input.symbols.map((s) => s.toLowerCase()));
+      for (const loaded of allMemories) {
+        const symbols = loaded.memory.frontmatter.anchor.symbols.map((s) => s.toLowerCase());
+        if (symbols.some((s) => wanted.has(s))) addOrUpdate(loaded, "symbol", void 0, "exact");
+      }
+    }
     if (input.task) {
       const tokens = tokenizeQuery22(input.task);
       const andHits = allMemories.filter((m) => literalMatchesAllTokens22(m.memory, tokens));
@@ -4498,11 +4544,12 @@ async function getBriefing(input, ctx) {
       }
     }
     const ranked = [...seen.values()].sort((a, b) => {
+      const priorityScore = (m) => priorityRank(classifyMemoryPriority(m, byId.get(m.id), input.files, input.symbols));
       const reasonScore = (m) => (m.type === "attempt" ? 3 : 0) + // attempt = negative knowledge, surface first to prevent repeating mistakes
-      (m.reasons.includes("anchor") ? 4 : 0) + (m.reasons.includes("module") ? 2 : 0) + (m.reasons.includes("semantic") ? 2 : 0) + (m.reasons.includes("domain") ? 1 : 0);
+      (m.reasons.includes("anchor") ? 4 : 0) + (m.reasons.includes("symbol") ? 4 : 0) + (m.reasons.includes("module") ? 2 : 0) + (m.reasons.includes("semantic") ? 2 : 0) + (m.reasons.includes("domain") ? 1 : 0);
       const confidenceScore = (m) => m.confidence === "authoritative" ? 4 : m.confidence === "trusted" ? 3 : m.confidence === "low" ? 1 : m.confidence === "stale" ? -2 : 0;
-      const sa = reasonScore(a) + confidenceScore(a) + (a.semantic_score ?? 0);
-      const sb = reasonScore(b) + confidenceScore(b) + (b.semantic_score ?? 0);
+      const sa = priorityScore(a) * 100 + reasonScore(a) + confidenceScore(a) + (a.semantic_score ?? 0);
+      const sb = priorityScore(b) * 100 + reasonScore(b) + confidenceScore(b) + (b.semantic_score ?? 0);
       return sb - sa;
     });
     for (const mem of ranked.slice(0, briefingMaxMemories)) {
@@ -4661,8 +4708,15 @@ ${m.content}`).join("\n\n---\n\n"),
   })) : trimmedMemories;
   const outputMemories = formattedMemories.map((m) => ({
     ...m,
+    priority: classifyMemoryPriority(m, byId.get(m.id), input.files, input.symbols),
     why: explainWhySurfaced(m, byId.get(m.id), input.files, inferred)
   }));
+  const briefingQuality = classifyBriefingQuality(outputMemories, {
+    isTemplateContext,
+    autoContextGenerated,
+    hasLastSession: Boolean(lastSession),
+    searchMode
+  });
   let symbolLocations;
   const symbolsToLookup = new Set(input.symbols);
   for (const m of outputMemories) {
@@ -4803,6 +4857,7 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
     } : null,
     module_contexts: trimmedModules,
     memories: outputMemories,
+    briefing_quality: briefingQuality,
     ...symbolLocations ? { symbol_locations: symbolLocations } : {},
     action_required: actionRequired,
     decay_warnings: decayWarnings,
@@ -4828,6 +4883,53 @@ function compactSummary(body) {
   }
   return body.slice(0, 120);
 }
+function classifyMemoryPriority(memory2, loaded, inputFiles, inputSymbols) {
+  const fm = loaded?.memory.frontmatter;
+  const directAnchor = Boolean(
+    fm && inputFiles.length > 0 && fm.anchor.paths.some((p) => inputFiles.some((file) => pathsOverlap(p, file)))
+  );
+  const directSymbol = Boolean(
+    fm && inputSymbols.length > 0 && fm.anchor.symbols.some(
+      (sym) => inputSymbols.some((wanted) => wanted.toLowerCase() === sym.toLowerCase())
+    )
+  );
+  const strongSemantic = (memory2.semantic_score ?? 0) >= 0.65;
+  const usefulSemantic = (memory2.semantic_score ?? 0) >= 0.35;
+  if (fm?.requires_human_approval || directAnchor || directSymbol || memory2.type === "attempt" && (memory2.match_quality === "exact" || strongSemantic)) {
+    return "must_read";
+  }
+  if (memory2.reasons.includes("module") || memory2.reasons.includes("domain") || memory2.match_quality === "exact" || usefulSemantic) {
+    return "useful";
+  }
+  return "background";
+}
+function priorityRank(priority) {
+  return priority === "must_read" ? 3 : priority === "useful" ? 2 : 1;
+}
+function classifyBriefingQuality(memories, context) {
+  const mustRead = memories.filter((m) => m.priority === "must_read").length;
+  const useful = memories.filter((m) => m.priority === "useful").length;
+  const background = memories.filter((m) => m.priority === "background").length;
+  const weakSemantic = memories.filter(
+    (m) => m.reasons.length === 1 && m.reasons.includes("semantic") && (m.semantic_score ?? 0) > 0 && (m.semantic_score ?? 0) < 0.35
+  ).length;
+  const reasons = [];
+  if (memories.length === 0) reasons.push("no memories matched the task or files");
+  if (context.isTemplateContext && !context.autoContextGenerated) reasons.push("project context is still a template");
+  if (!context.hasLastSession) reasons.push("no previous session recap");
+  if (mustRead > 0) reasons.push(`${mustRead} must_read memor${mustRead === 1 ? "y" : "ies"} matched directly`);
+  if (useful > 0) reasons.push(`${useful} useful memor${useful === 1 ? "y" : "ies"} matched`);
+  if (background > useful + mustRead && background > 2) reasons.push(`${background} background memories dominate the result`);
+  if (weakSemantic > 0) reasons.push(`${weakSemantic} weak semantic-only match${weakSemantic === 1 ? "" : "es"}`);
+  if (context.searchMode === "literal_fallback") reasons.push("semantic index unavailable or empty; literal fallback used");
+  if (memories.length === 0 || mustRead === 0 && useful === 0) {
+    return { level: "thin", reasons };
+  }
+  if (background > useful + mustRead && background > 2) {
+    return { level: "noisy", reasons };
+  }
+  return { level: "strong", reasons };
+}
 function explainWhySurfaced(memory2, loaded, inputFiles, inferredModules) {
   const why = [];
   const fm = loaded?.memory.frontmatter;
@@ -4836,7 +4938,19 @@ function explainWhySurfaced(memory2, loaded, inputFiles, inferredModules) {
       (p) => inputFiles.length === 0 || inputFiles.some((file) => pathsOverlap(p, file))
     );
     if (matching.length > 0) {
-      why.push(`Anchored to touched path${matching.length === 1 ? "" : "s"}: ${matching.slice(0, 4).join(", ")}`);
+      const exact = matching.filter(
+        (p) => !isGlobPath(p) && inputFiles.some((file) => p === file || pathsOverlap(p, file))
+      );
+      const glob = matching.filter((p) => isGlobPath(p));
+      if (exact.length > 0) {
+        why.push(`Exact/file anchor match: ${exact.slice(0, 4).join(", ")}`);
+      }
+      if (glob.length > 0) {
+        why.push(`Glob anchor match: ${glob.slice(0, 4).join(", ")}`);
+      }
+      if (exact.length === 0 && glob.length === 0) {
+        why.push(`Anchored to touched path${matching.length === 1 ? "" : "s"}: ${matching.slice(0, 4).join(", ")}`);
+      }
     } else if (fm.anchor.paths.length > 0) {
       why.push(`Pulled by related anchor: ${fm.anchor.paths.slice(0, 4).join(", ")}`);
     }
@@ -4844,6 +4958,9 @@ function explainWhySurfaced(memory2, loaded, inputFiles, inferredModules) {
       why.push(`Anchor symbol${fm.anchor.symbols.length === 1 ? "" : "s"}: ${fm.anchor.symbols.slice(0, 4).join(", ")}`);
     }
   }
+  if (memory2.reasons.includes("symbol") && fm) {
+    why.push(`Explicit symbol match: ${fm.anchor.symbols.slice(0, 4).join(", ")}`);
+  }
   if (memory2.reasons.includes("module")) {
     const moduleHints = [
       ...memory2.module ? [memory2.module] : [],
@@ -5068,7 +5185,8 @@ async function memRelevantTo(input, ctx) {
   const out = {
     task: input.task,
     search_mode: briefing.search_mode,
-    memories: briefing.memories
+    memories: briefing.memories,
+    briefing_quality: briefing.briefing_quality
   };
   if (briefing.hints && briefing.hints.length > 0) out.hints = briefing.hints;
   if (briefing.memories.length === 0) out.empty = true;
@@ -5750,7 +5868,7 @@ async function preCommitCheck(input, ctx) {
   const filesTouching = new Set(relevantMatches.map((m) => m.id));
   const staleHits = verifyResult.results.filter((r) => r.stale && filesTouching.has(r.id));
   const blockOn = input.block_on;
-  const classifiedWarnings = apResult.warnings.map(classifyWarning);
+  const classifiedWarnings = apResult.warnings.map((warning) => classifyWarning(warning, input.paths));
   const blockingWarnings = classifiedWarnings.filter((w) => w.level === "blocking");
   const reviewWarnings = classifiedWarnings.filter((w) => w.level === "review");
   const infoWarnings = classifiedWarnings.filter((w) => w.level === "info");
@@ -5785,12 +5903,26 @@ async function preCommitCheck(input, ctx) {
     }))
   };
 }
-function classifyWarning(warning) {
+function classifyWarning(warning, paths) {
+  const affectedFiles = paths.filter((p) => !p.startsWith(".ai/.usage/"));
+  const repairCommand = repairCommandForWarning(warning, affectedFiles);
+  const fileDowngrade = fileTypeDowngradeReason(warning, affectedFiles);
+  if (fileDowngrade) {
+    return {
+      ...warning,
+      level: "info",
+      rationale: fileDowngrade,
+      affected_files: affectedFiles,
+      repair_command: repairCommand
+    };
+  }
   if (isBlockingWarning(warning)) {
     return {
       ...warning,
       level: "blocking",
-      rationale: "authoritative/trusted memory plus strong semantic match to the diff (score >= 0.65)"
+      rationale: "authoritative/trusted memory plus strong semantic match to the diff (score >= 0.65)",
+      affected_files: affectedFiles,
+      repair_command: repairCommand
     };
   }
   const hasSemantic = warning.reasons.includes("semantic");
@@ -5800,13 +5932,17 @@ function classifyWarning(warning) {
     return {
       ...warning,
       level: "review",
-      rationale: hasSemantic ? "semantic match is plausible but below blocking threshold" : "anchored high-confidence memory also matched diff tokens, but no strong semantic proof"
+      rationale: hasSemantic ? "semantic match is plausible but below blocking threshold" : "anchored high-confidence memory also matched diff tokens, but no strong semantic proof",
+      affected_files: affectedFiles,
+      repair_command: repairCommand
     };
   }
   return {
     ...warning,
     level: "info",
-    rationale: "weak signal only (literal/anchor/low semantic evidence); surfaced for audit, hidden in concise CLI output"
+    rationale: "weak signal only (literal/anchor/low semantic evidence); surfaced for audit, hidden in concise CLI output",
+    affected_files: affectedFiles,
+    repair_command: repairCommand
   };
 }
 function isBlockingWarning(warning) {
@@ -5814,6 +5950,40 @@ function isBlockingWarning(warning) {
   if (!highConfidence) return false;
   return warning.reasons.includes("semantic") && (warning.semantic_score ?? 0) >= 0.65;
 }
+function fileTypeDowngradeReason(warning, paths) {
+  if (paths.length === 0) return null;
+  if (paths.every((p) => p.startsWith(".ai/.usage/") || p === ".ai/.usage/tool-usage.jsonl")) {
+    return ".ai usage logs are local telemetry and never block commits.";
+  }
+  const docsOnly = paths.every(isDocLikePath);
+  if (docsOnly && !hasStrongSemantic(warning)) {
+    return "docs/changelog-only change; anti-pattern is downgraded unless semantic evidence is strong.";
+  }
+  const configOnly = paths.every(isPackageOrConfigPath);
+  if (configOnly && looksRuntimeSpecific(warning) && !warning.reasons.includes("anchor") && !hasStrongSemantic(warning)) {
+    return "package/config-only change; runtime-specific gotcha is not anchored or semantically strong.";
+  }
+  return null;
+}
+function hasStrongSemantic(warning) {
+  return warning.reasons.includes("semantic") && (warning.semantic_score ?? 0) >= 0.65;
+}
+function isDocLikePath(file) {
+  const lower = file.toLowerCase();
+  return lower.endsWith(".md") || lower.includes("changelog") || lower.startsWith("docs/") || lower.startsWith(".github/") && lower.endsWith(".md");
+}
+function isPackageOrConfigPath(file) {
+  const lower = file.toLowerCase();
+  return lower.endsWith("package.json") || lower.endsWith("package-lock.json") || lower.endsWith("pnpm-lock.yaml") || lower.endsWith("yarn.lock") || lower.endsWith("bun.lockb") || lower.endsWith(".config.ts") || lower.endsWith(".config.js") || lower.endsWith(".json") || lower.endsWith(".yml") || lower.endsWith(".yaml") || lower.startsWith(".github/workflows/");
+}
+function looksRuntimeSpecific(warning) {
+  const text = `${warning.body_preview} ${warning.id}`.toLowerCase();
+  return /\b(runtime|controller|request|response|database|transaction|auth|cache|production|service|api|endpoint)\b/.test(text);
+}
+function repairCommandForWarning(warning, paths) {
+  const firstPath = paths[0];
+  return firstPath ? `haive briefing --files "${firstPath}" --task "review ${warning.id}"` : `haive memory show ${warning.id}`;
+}
 var CONFIG_PATTERNS = [
   ".eslintrc",
   "eslint.config",
@@ -6345,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.16";
+var SERVER_VERSION = "0.9.18";
 function jsonResult(data) {
   return {
     content: [
@@ -7313,161 +7483,652 @@ 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(
+  }
+  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;
@@ -7483,7 +8144,7 @@ function registerSync(program2) {
       );
     }
     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);
     }
@@ -7502,12 +8163,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) {
@@ -7589,11 +8250,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}`));
@@ -7656,11 +8317,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}`));
@@ -7670,10 +8331,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",
@@ -7698,22 +8368,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.");
       }
@@ -7721,8 +8401,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;
@@ -7746,17 +8426,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;
@@ -7764,19 +8444,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" }
@@ -7796,18 +8476,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(
@@ -7833,21 +8514,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}`);
@@ -7859,12 +8541,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()}
@@ -7879,10 +8561,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
       );
@@ -7893,8 +8575,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)
       );
@@ -7911,8 +8593,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;
       }
@@ -7928,17 +8610,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();
@@ -7949,8 +8632,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)`);
@@ -7961,7 +8644,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)`
@@ -7980,14 +8665,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";
@@ -7995,14 +8680,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;
@@ -8029,7 +8714,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"}`));
@@ -8064,26 +8749,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")
     );
@@ -8097,7 +8782,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.)`);
@@ -8113,35 +8798,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;
@@ -8158,7 +8843,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)`);
@@ -8187,32 +8872,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}".`);
@@ -8254,12 +8939,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(", ")}`);
   });
 }
@@ -8278,18 +8963,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(
@@ -8297,9 +8982,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;
@@ -8308,10 +8993,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(
@@ -8321,17 +9006,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++;
       }
     }
@@ -8342,25 +9027,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}".`);
@@ -8368,13 +9053,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) {
@@ -8395,29 +9080,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 = [];
@@ -8515,44 +9200,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}).`);
@@ -8560,11 +9245,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\`.`
@@ -8573,16 +9258,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(
@@ -8601,9 +9286,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;
@@ -8626,14 +9311,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)`);
   });
 }
@@ -8643,26 +9328,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;
@@ -8673,42 +9358,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;
@@ -8719,7 +9404,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;
@@ -8749,7 +9434,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}`);
     }
@@ -8766,36 +9451,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",
@@ -8805,7 +9490,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];
@@ -8817,34 +9502,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();
@@ -8857,7 +9542,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);
@@ -8868,27 +9553,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}".`);
@@ -8896,12 +9581,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}` : ""}`);
@@ -8912,7 +9597,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}`);
@@ -8927,38 +9612,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)}`
@@ -8966,34 +9651,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}".`);
@@ -9011,7 +9696,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}`);
@@ -9026,7 +9711,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++;
       }
     }
@@ -9074,30 +9759,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`);
@@ -9125,15 +9810,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 = [];
@@ -9197,15 +9882,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.");
@@ -9220,9 +9905,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) {
@@ -9245,7 +9930,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, "-")}`;
@@ -9260,12 +9945,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}`));
@@ -9287,17 +9972,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",
@@ -9310,9 +9995,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;
@@ -9320,8 +10005,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;
@@ -9352,7 +10037,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_";
@@ -9384,8 +10069,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);
@@ -9394,22 +10079,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 = [];
@@ -9487,9 +10172,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;
@@ -9521,19 +10206,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)
       );
@@ -9549,11 +10234,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;
@@ -9570,12 +10255,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`.");
     }
@@ -9587,15 +10272,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) {
@@ -9620,16 +10305,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;
       }
@@ -9649,7 +10334,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");
@@ -9661,7 +10346,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(
@@ -9684,7 +10369,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 {
@@ -9739,8 +10424,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";
@@ -9753,18 +10438,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(
@@ -9774,21 +10459,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.
@@ -9809,13 +10494,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"
     });
@@ -9825,7 +10510,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.)
 `
@@ -9844,9 +10529,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.'
@@ -9854,16 +10539,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:"))
@@ -9880,18 +10565,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"
       });
@@ -9913,9 +10598,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.'
@@ -9923,13 +10608,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) {
@@ -9939,17 +10624,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);
@@ -9972,27 +10657,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:"))
     );
@@ -10001,25 +10686,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) {
@@ -10028,8 +10713,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;
@@ -10083,12 +10768,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++;
@@ -10102,7 +10787,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 {
@@ -10118,7 +10803,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,
@@ -10130,11 +10815,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) => {
@@ -10182,13 +10867,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 = [
@@ -10307,11 +10992,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) => {
@@ -10324,9 +11009,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);
@@ -10350,20 +11035,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));
@@ -10452,20 +11137,20 @@ 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,
+  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",
@@ -10477,8 +11162,8 @@ function registerMemorySuggest(memory2) {
   memory2.command("suggest").description(
     "Suggest memories to create based on recurring search queries in the usage log.\n\n  Use --auto-save to draft the top-N suggestions as draft memories. They land\n  in personal scope by default with status=draft, ready for you to edit and promote."
   ).option("--since <window>", "ISO date or relative (e.g. '7d', '24h')", "30d").option("--min <count>", "minimum repeat count to surface a query", "2").option("--top-n <n>", "with --auto-save, draft this many top suggestions", "3").option("--scope <scope>", "with --auto-save, scope of drafted memories (personal | team)", "personal").option("--auto-save", "draft top-N suggestions as draft memories on disk", false).option("--json", "emit JSON instead of human-readable output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot38(opts.dir);
-    const paths = resolveHaivePaths34(root);
+    const root = findProjectRoot39(opts.dir);
+    const paths = resolveHaivePaths35(root);
     const events = await readUsageEvents3(paths);
     if (events.length === 0) {
       if (opts.json) {
@@ -10524,7 +11209,7 @@ function registerMemorySuggest(memory2) {
       }
       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) {
@@ -10547,13 +11232,13 @@ function registerMemorySuggest(memory2) {
         fm.status = "draft";
         const body = renderTemplate(s);
         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));
@@ -10646,26 +11331,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;
@@ -10677,8 +11362,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) {
@@ -10686,10 +11371,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({
@@ -10734,7 +11419,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) {
@@ -10760,31 +11445,32 @@ 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 loadConfig9,
+  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("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot40(opts.dir);
-    const paths = resolveHaivePaths36(root);
+  ).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 = findProjectRoot41(opts.dir);
+    const paths = resolveHaivePaths37(root);
     const findings = [];
-    if (!existsSync60(paths.haiveDir)) {
+    const repairs = [];
+    if (!existsSync63(paths.haiveDir)) {
       findings.push({
         severity: "error",
         code: "not-initialized",
@@ -10793,7 +11479,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",
@@ -10801,8 +11498,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({
@@ -10812,8 +11509,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({
@@ -10822,7 +11528,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({
@@ -10854,7 +11560,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;
       });
@@ -10867,7 +11573,7 @@ function registerDoctor(program2) {
         });
       }
     }
-    const codeMap = await loadCodeMap5(paths);
+    const codeMap = await loadCodeMap7(paths);
     if (!codeMap) {
       findings.push({
         severity: "warn",
@@ -10922,14 +11628,14 @@ function registerDoctor(program2) {
         });
       }
     }
-    const config = await loadConfig7(paths);
+    const config = await loadConfig9(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;
@@ -10952,14 +11658,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.16"));
+    findings.push(...await collectInstallFindings(root, "0.9.18"));
     try {
       const legacyRaw = execSync3("haive-mcp --version", {
         encoding: "utf8",
         timeout: 3e3,
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      const cliVersion = "0.9.16";
+      const cliVersion = "0.9.18";
       if (legacyRaw && legacyRaw !== cliVersion) {
         findings.push({
           severity: "warn",
@@ -10972,37 +11678,123 @@ 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)
+  }));
+  const scores = computeDoctorScores(classified);
   if (opts.json) {
-    console.log(JSON.stringify({ findings }, null, 2));
+    console.log(JSON.stringify({
+      scores,
+      findings: classified,
+      sections: groupBySection(classified),
+      next_actions: nextActions(classified),
+      repairs,
+      fix_mode: opts.fix ? opts.dryRun ? "dry-run" : "apply" : "off"
+    }, null, 2));
     return;
   }
-  if (findings.length === 0) {
-    ui.success("hAIve doctor \u2014 no issues found.");
+  if (classified.length === 0) {
+    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 ${findings.length} finding${findings.length === 1 ? "" : "s"}`));
+  console.log(ui.bold(`hAIve doctor \u2014 ${classified.length} finding${classified.length === 1 ? "" : "s"}`));
+  console.log(
+    ui.dim(
+      `  protection=${scores.protection_score}  context=${scores.context_quality_score}  corpus=${scores.corpus_quality_score}`
+    )
+  );
   console.log();
-  const order = ["error", "warn", "info"];
-  for (const sev of order) {
-    for (const f of findings.filter((x) => x.severity === sev)) {
-      const icon = sev === "error" ? ui.red("\u2717") : sev === "warn" ? ui.yellow("\u26A0") : ui.dim("\u2139");
-      console.log(`${icon} ${ui.bold(f.code)}  ${f.message}`);
-      if (opts.fix && f.fix) {
-        for (const line of f.fix.split("\n")) {
-          console.log(`     ${ui.dim("$")} ${line}`);
+  const sectionOrder = [
+    "Protection",
+    "Agent coverage",
+    "Context quality",
+    "Corpus health",
+    "Index health",
+    "Next actions"
+  ];
+  const severityOrder = ["error", "warn", "info"];
+  for (const section2 of sectionOrder) {
+    const sectionFindings = classified.filter((f) => f.section === section2);
+    if (sectionFindings.length === 0) continue;
+    console.log(ui.bold(section2));
+    for (const sev of severityOrder) {
+      for (const f of sectionFindings.filter((x) => x.severity === sev)) {
+        const icon = sev === "error" ? ui.red("\u2717") : sev === "warn" ? ui.yellow("\u26A0") : ui.dim("\u2139");
+        console.log(`${icon} ${ui.bold(f.code)}  ${f.message}`);
+        if (opts.fix && f.fix) {
+          for (const line of f.fix.split("\n")) {
+            console.log(`     ${ui.dim(opts.dryRun ? "would run:" : "$")} ${line}`);
+          }
         }
       }
     }
+    console.log();
   }
-  if (!opts.fix && findings.some((f) => f.fix)) {
+  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"));
+    for (const action of actions.slice(0, 5)) console.log(`  ${ui.dim("$")} ${action}`);
+  } else if (!opts.fix && classified.some((f) => f.fix)) {
     ui.info("Re-run with --fix to see suggested commands.");
   }
 }
+function sectionForFinding(finding) {
+  if (finding.code.includes("haive") || finding.code.includes("integration") || finding.code.includes("claude") || finding.code.includes("autopilot")) return "Agent coverage";
+  if (finding.code.includes("context") || finding.code.includes("briefing") || finding.code.includes("search")) return "Context quality";
+  if (finding.code.includes("code-map") || finding.code.includes("index")) return "Index health";
+  if (finding.code.includes("memory") || finding.code.includes("anchor") || finding.code.includes("pending") || finding.code.includes("decay")) return "Corpus health";
+  if (finding.severity === "error") return "Protection";
+  return "Next actions";
+}
+function computeDoctorScores(findings) {
+  const scoreFor = (sections) => {
+    const scoped = findings.filter((f) => sections.includes(f.section ?? sectionForFinding(f)));
+    const penalty = scoped.reduce((sum, f) => {
+      if (f.severity === "error") return sum + 35;
+      if (f.severity === "warn") return sum + 15;
+      return sum + 4;
+    }, 0);
+    return Math.max(0, 100 - penalty);
+  };
+  return {
+    protection_score: scoreFor(["Protection", "Agent coverage"]),
+    context_quality_score: scoreFor(["Context quality", "Index health"]),
+    corpus_quality_score: scoreFor(["Corpus health"])
+  };
+}
+function groupBySection(findings) {
+  const out = {
+    "Protection": [],
+    "Agent coverage": [],
+    "Context quality": [],
+    "Corpus health": [],
+    "Index health": [],
+    "Next actions": []
+  };
+  for (const finding of findings) out[finding.section ?? sectionForFinding(finding)].push(finding);
+  return out;
+}
+function nextActions(findings) {
+  return [...new Set(findings.flatMap((finding) => finding.fix ? finding.fix.split("\n") : []))].filter(Boolean);
+}
 function isSearchTool(name) {
   return ["mem_search", "code_search", "mem_relevant_to", "get_briefing"].includes(name);
 }
@@ -11047,9 +11839,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) {
@@ -11105,22 +11897,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) {
@@ -11135,7 +11927,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);
@@ -11225,8 +12017,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(
@@ -11236,8 +12028,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 ?? [];
@@ -11321,7 +12113,11 @@ function printWarnings(title, warnings, tone) {
       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();
 }
@@ -11345,12 +12141,12 @@ function runCommand3(cmd, args, cwd) {
 }
 
 // src/commands/welcome.ts
-import { existsSync as existsSync63 } from "fs";
+import { existsSync as existsSync65 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot43,
-  loadMemoriesFromDir as loadMemoriesFromDir34,
-  resolveHaivePaths as resolveHaivePaths39
+  findProjectRoot as findProjectRoot44,
+  loadMemoriesFromDir as loadMemoriesFromDir35,
+  resolveHaivePaths as resolveHaivePaths40
 } from "@hiveai/core";
 var TYPE_RANK = {
   decision: 0,
@@ -11364,14 +12160,14 @@ 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)) {
+    const root = findProjectRoot44(opts.dir);
+    const paths = resolveHaivePaths40(root);
+    if (!existsSync65(paths.memoriesDir)) {
       ui.error(`No memories at ${paths.memoriesDir}. Run 'haive init' first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir34(paths.memoriesDir);
+    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"
     );
@@ -11406,173 +12202,6 @@ function registerWelcome(program2) {
   });
 }
 
-// src/commands/memory-lint.ts
-import { existsSync as existsSync64 } from "fs";
-import "commander";
-import {
-  findProjectRoot as findProjectRoot44,
-  getUsage as getUsage20,
-  loadMemoriesFromDir as loadMemoriesFromDir35,
-  loadUsageIndex as loadUsageIndex26,
-  resolveHaivePaths as resolveHaivePaths40
-} from "@hiveai/core";
-async function lintMemoriesAsync(root) {
-  const paths = resolveHaivePaths40(root);
-  const out = [];
-  if (!existsSync64(paths.memoriesDir)) return out;
-  const loaded = await loadMemoriesFromDir35(paths.memoriesDir);
-  const usage = await loadUsageIndex26(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."
-      });
-    }
-    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.`
-      });
-    }
-    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."
-      });
-    }
-  }
-  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 out;
-}
-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("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot44(opts.dir);
-    const findings = await lintMemoriesAsync(root);
-    if (opts.json) {
-      console.log(JSON.stringify({ findings_count: findings.length, findings }, 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"})`) + `
-`);
-    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}`);
-      console.log(ui.dim(`       \u2192 ${f.file}`));
-    }
-    process.exitCode = findings.some((x) => x.severity === "error") ? 1 : 0;
-  });
-}
-
 // src/commands/memory-suggest-topic.ts
 import "commander";
 import { MemoryTypeSchema as MemoryTypeSchema2, suggestTopicKey as suggestTopicKey2 } from "@hiveai/core";
@@ -11592,21 +12221,21 @@ function registerMemorySuggestTopic(memory2) {
 }
 
 // src/commands/resolve-project.ts
-import path43 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: path43.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 path44 from "path";
+import { existsSync as existsSync66 } from "fs";
+import path46 from "path";
 import "commander";
 import {
   appendRuntimeJournalEntry as appendRuntimeJournalEntry3,
@@ -11620,18 +12249,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 = path44.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 ${path44.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 = path44.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;
@@ -11646,8 +12275,8 @@ function registerRuntime(program2) {
 }
 
 // src/commands/memory-timeline.ts
-import { existsSync as existsSync66 } from "fs";
-import path45 from "path";
+import { existsSync as existsSync67 } from "fs";
+import path47 from "path";
 import "commander";
 import {
   collectTimelineEntries as collectTimelineEntries2,
@@ -11663,15 +12292,15 @@ function registerMemoryTimeline(memory2) {
       process.exitCode = 1;
       return;
     }
-    const root = path45.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,
@@ -11683,8 +12312,8 @@ function registerMemoryTimeline(memory2) {
 }
 
 // src/commands/memory-conflict-candidates.ts
-import { existsSync as existsSync67 } from "fs";
-import path46 from "path";
+import { existsSync as existsSync68 } from "fs";
+import path48 from "path";
 import "commander";
 import {
   findLexicalConflictPairs as findLexicalConflictPairs2,
@@ -11706,9 +12335,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 = path46.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;
@@ -11718,7 +12347,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),
@@ -11744,21 +12373,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 writeFile31 } from "fs/promises";
-import path47 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 loadConfig10,
   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
@@ -11773,8 +12402,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 loadConfig10(paths);
+    await saveConfig4(paths, {
       ...current,
       enforcement: {
         ...current.enforcement,
@@ -11796,7 +12425,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 (${path47.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)}`);
       }
@@ -11804,26 +12433,26 @@ function registerEnforce(program2) {
     ui.info("Agent-agnostic gates are now active at workflow level: MCP, git, CI, and optional client hooks.");
     ui.info("Use `haive run -- <agent command>` for agents that do not expose blocking hooks.");
   });
-  enforce.command("status").description("Show whether this project has agent-agnostic hAIve enforcement installed.").option("-d, --dir <dir>", "project root").option("--json", "emit JSON", false).action(async (opts) => {
+  enforce.command("status").description("Show whether this project has agent-agnostic hAIve enforcement installed.").option("-d, --dir <dir>", "project root").option("--explain", "group findings by blocking/review/info and show repair commands", false).option("--json", "emit JSON", false).action(async (opts) => {
     const report = await buildEnforcementReport(opts.dir, "local");
-    printReport(report, Boolean(opts.json));
+    printReport(report, Boolean(opts.json), Boolean(opts.explain));
     if (report.should_block) process.exitCode = 1;
   });
-  enforce.command("check").description("Run the hAIve policy gate. Intended for pre-commit, pre-push, wrappers, and any agent client.").option("-d, --dir <dir>", "project root").option("--stage <stage>", "local | pre-commit | pre-push | ci", "local").option("--json", "emit JSON", false).action(async (opts) => {
+  enforce.command("check").description("Run the hAIve policy gate. Intended for pre-commit, pre-push, wrappers, and any agent client.").option("-d, --dir <dir>", "project root").option("--stage <stage>", "local | pre-commit | pre-push | ci", "local").option("--explain", "group findings by blocking/review/info and show repair commands", false).option("--json", "emit JSON", false).action(async (opts) => {
     const report = await buildEnforcementReport(opts.dir, opts.stage ?? "local");
-    printReport(report, Boolean(opts.json));
+    printReport(report, Boolean(opts.json), Boolean(opts.explain));
     if (report.should_block) process.exit(2);
   });
   enforce.command("cleanup").description("Remove generated hAIve runtime/cache artifacts that should not appear in commits.").option("-d, --dir <dir>", "project root").option("--dry-run", "print what would be removed without deleting", false).action(async (opts) => {
     const root = findProjectRoot48(opts.dir);
     const paths = resolveHaivePaths44(root);
     const targets = [
-      path47.join(paths.haiveDir, ".cache"),
-      path47.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 = path47.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 });
@@ -11831,9 +12460,9 @@ function registerEnforce(program2) {
       }
     }
   });
-  enforce.command("ci").description("CI entrypoint: fail if the repository violates hAIve enforcement policy.").option("-d, --dir <dir>", "project root").option("--json", "emit JSON", false).action(async (opts) => {
+  enforce.command("ci").description("CI entrypoint: fail if the repository violates hAIve enforcement policy.").option("-d, --dir <dir>", "project root").option("--explain", "group findings by blocking/review/info and show repair commands", false).option("--json", "emit JSON", false).action(async (opts) => {
     const report = await buildEnforcementReport(opts.dir, "ci");
-    printReport(report, Boolean(opts.json));
+    printReport(report, Boolean(opts.json), Boolean(opts.explain));
     if (report.should_block) process.exit(2);
   });
   enforce.command("session-start").description("Claude Code SessionStart hook: inject briefing and write a local briefing marker.").option("-d, --dir <dir>", "project root").option("--task <text>", "task text to rank memories").option("--source <name>", "marker source", "claude-session-start").option("--session-id <id>", "agent session id").action(async (opts) => {
@@ -11841,7 +12470,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.";
@@ -11903,7 +12532,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;
@@ -11927,7 +12556,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);
   }
@@ -11946,7 +12575,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 ${path47.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",
@@ -11995,9 +12624,9 @@ async function writeWrapperBriefing(paths, sessionId, task) {
     source: "haive-run",
     memoryIds: briefing.memories.map((m) => m.id)
   });
-  const dir = path47.join(paths.runtimeDir, "enforcement", "briefings");
+  const dir = path49.join(paths.runtimeDir, "enforcement", "briefings");
   await mkdir19(dir, { recursive: true });
-  const file = path47.join(dir, `${sessionId}.md`);
+  const file = path49.join(dir, `${sessionId}.md`);
   const parts = [
     "# hAIve Briefing",
     "",
@@ -12015,18 +12644,18 @@ async function writeWrapperBriefing(paths, sessionId, task) {
   if (briefing.setup_warnings.length > 0) {
     parts.push("", "## Setup Warnings", ...briefing.setup_warnings.map((w) => `- ${w}`));
   }
-  await writeFile31(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 loadConfig10(paths) : {};
   const mode = config.enforcement?.mode ?? "strict";
   const findings = [];
   if (!initialized) {
-    return {
+    return withCategories({
       root,
       initialized,
       mode,
@@ -12039,19 +12668,19 @@ async function buildEnforcementReport(dir, stage, sessionId) {
         fix: "Run `haive init` or `haive enforce install`.",
         impact: 100
       }]
-    };
+    });
   }
   if (mode === "off") {
-    return {
+    return withCategories({
       root,
       initialized,
       mode,
       score: buildScore([], config.enforcement?.scoreThreshold),
       should_block: false,
       findings: [{ severity: "info", code: "enforcement-off", message: "hAIve enforcement is disabled." }]
-    };
+    });
   }
-  findings.push(...await inspectIntegrationVersions(root, "0.9.16"));
+  findings.push(...await inspectIntegrationVersions(root, "0.9.18"));
   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." } : {
@@ -12101,17 +12730,27 @@ async function buildEnforcementReport(dir, stage, sessionId) {
     });
   }
   const hasErrors = findings.some((f) => f.severity === "error");
-  return {
+  return withCategories({
     root,
     initialized,
     mode,
     score: buildScore(findings, config.enforcement?.scoreThreshold),
     should_block: mode === "strict" && hasErrors,
     findings
+  });
+}
+function withCategories(report) {
+  return {
+    ...report,
+    categories: {
+      blocking: report.findings.filter((f) => f.severity === "error"),
+      review: report.findings.filter((f) => f.severity === "warn"),
+      info: report.findings.filter((f) => f.severity === "info" || f.severity === "ok")
+    }
   };
 }
 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;
@@ -12120,7 +12759,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 = [];
@@ -12158,7 +12797,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." }];
@@ -12168,7 +12807,7 @@ async function verifyDecisionCoverage(paths, stage, sessionId) {
   const relevant = all.map(({ memory: memory2 }) => memory2).filter((memory2) => {
     const fm = memory2.frontmatter;
     if (!policyTypes.has(fm.type)) return false;
-    if (fm.status === "rejected" || fm.status === "deprecated" || fm.status === "stale") return false;
+    if (fm.status !== "validated") return false;
     return memoryMatchesAnchorPaths6(memory2, changedFiles);
   });
   if (relevant.length === 0) {
@@ -12251,9 +12890,9 @@ async function inspectIntegrationVersions(root, expectedVersion) {
   ];
   const findings = [];
   for (const rel of files) {
-    const file = path47.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) {
@@ -12318,7 +12957,9 @@ async function getChangedFiles(root, stage) {
       if (file) files.add(file);
     }
   }
-  return [...files].filter((file) => !file.startsWith(".ai/.runtime/") && !file.startsWith(".ai/.cache/"));
+  return [...files].filter(
+    (file) => !file.startsWith(".ai/.runtime/") && !file.startsWith(".ai/.cache/") && !file.startsWith(".ai/.usage/") && file !== ".ai/.usage/tool-usage.jsonl"
+  );
 }
 function buildScore(findings, threshold = 80) {
   const checks = {
@@ -12339,8 +12980,8 @@ function buildScore(findings, threshold = 80) {
   };
 }
 async function installGitEnforcement(root) {
-  const hooksDir = path47.join(root, ".git", "hooks");
-  if (!existsSync68(path47.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;
   }
@@ -12362,31 +13003,31 @@ haive enforce check --stage pre-push --dir . || exit $?
     }
   ];
   for (const hook of hooks) {
-    const file = path47.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 writeFile31(file, hook.body, "utf8");
+        await writeFile34(file, hook.body, "utf8");
       } else {
-        await writeFile31(file, `${current.trimEnd()}
+        await writeFile34(file, `${current.trimEnd()}
 
 ${hook.body}`, "utf8");
       }
     } else {
-      await writeFile31(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 = path47.join(root, ".github", "workflows", "haive-enforcement.yml");
-  await mkdir19(path47.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 writeFile31(workflowPath, `name: haive-enforcement
+  await writeFile34(workflowPath, `name: haive-enforcement
 
 on:
   pull_request:
@@ -12410,9 +13051,9 @@ jobs:
       - name: Enforce hAIve policy
         run: haive enforce ci
 `, "utf8");
-  ui.success(`Created ${path47.relative(root, workflowPath)}`);
+  ui.success(`Created ${path49.relative(root, workflowPath)}`);
 }
-function printReport(report, json) {
+function printReport(report, json, explain = false) {
   if (json) {
     console.log(JSON.stringify(report, null, 2));
     return;
@@ -12420,14 +13061,32 @@ function printReport(report, json) {
   console.log(ui.bold(`hAIve enforcement \u2014 ${report.mode}`));
   console.log(ui.dim(`  root: ${report.root}`));
   console.log(ui.dim(`  score: ${report.score.score}% / threshold ${report.score.threshold}%`));
-  for (const finding of report.findings) {
-    const marker = finding.severity === "error" ? ui.red("\u2717") : finding.severity === "warn" ? ui.yellow("\u26A0") : finding.severity === "ok" ? ui.green("\u2713") : ui.dim("\u2022");
-    console.log(`${marker} ${finding.code}: ${finding.message}`);
-    if (finding.fix) console.log(ui.dim(`  fix: ${finding.fix}`));
+  if (explain) {
+    printFindingGroup("Blocking", report.categories.blocking, "error");
+    printFindingGroup("Review", report.categories.review, "warn");
+    printFindingGroup("Info", report.categories.info, "info");
+  } else {
+    for (const finding of report.findings) printFinding(finding);
   }
   if (report.should_block) ui.error("hAIve enforcement gate failed.");
   else ui.success("hAIve enforcement gate passed.");
 }
+function printFindingGroup(title, findings, tone) {
+  if (findings.length === 0) return;
+  console.log();
+  const heading = tone === "error" ? ui.red(title) : tone === "warn" ? ui.yellow(title) : ui.bold(title);
+  console.log(ui.bold(`${heading} (${findings.length})`));
+  const scoreFinding = findings.find((f) => f.code === "enforcement-score-below-threshold");
+  for (const finding of findings.filter((f) => f.code !== "enforcement-score-below-threshold")) {
+    printFinding(finding, true);
+  }
+  if (scoreFinding) printFinding(scoreFinding, true);
+}
+function printFinding(finding, explain = false) {
+  const marker = finding.severity === "error" ? ui.red("\u2717") : finding.severity === "warn" ? ui.yellow("\u26A0") : finding.severity === "ok" ? ui.green("\u2713") : ui.dim("\u2022");
+  console.log(`${marker} ${finding.code}: ${finding.message}`);
+  if (finding.fix) console.log(ui.dim(`${explain ? "  repair: " : "  fix: "}${finding.fix}`));
+}
 async function readHookPayload() {
   const raw = await readStdin2(MAX_STDIN_BYTES2);
   if (!raw.trim()) return {};
@@ -12509,7 +13168,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.16").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.18").option("--advanced", "show maintenance and experimental commands in help");
 registerInit(program);
 registerWelcome(program);
 registerResolveProject(program);