@hiveai/cli 0.10.8 → 0.11.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command53 } from "commander";
+import { Command as Command55 } from "commander";
 
 // src/commands/briefing.ts
 import { existsSync as existsSync3 } from "fs";
@@ -199,7 +199,7 @@ async function getHotFiles(root, daysBack, maxHotFiles, filePaths) {
       if (!f) continue;
       counts.set(f, (counts.get(f) ?? 0) + 1);
     }
-    let entries = [...counts.entries()].map(([path53, changes]) => ({ path: path53, changes }));
+    let entries = [...counts.entries()].map(([path54, changes]) => ({ path: path54, changes }));
     const lowerPaths = filePaths.map((p) => p.toLowerCase());
     if (lowerPaths.length > 0) {
       entries = entries.filter((e) => lowerPaths.some((p) => e.path.toLowerCase().includes(p)));
@@ -2743,6 +2743,7 @@ ${SEED_FOOTER(stack)}` });
 }
 
 // src/commands/init.ts
+var HAIVE_GITHUB_ACTION_REF = `v${"0.11.0"}`;
 var PROJECT_CONTEXT_TEMPLATE = `# Project context
 
 > Generated by \`haive init\`. Run \`haive init --bootstrap\` to auto-fill from your codebase,
@@ -2777,6 +2778,7 @@ This repo uses **hAIve** for shared context. The map:
 1. **Before editing** for a goal, call \`get_briefing\` (task + files/symbols) to load ranked context \u2014 or \`mem_relevant_to\` if project context is already loaded this session.
 2. **When an approach fails**, call \`mem_tried\` right away so the next agent skips the dead end.
 3. **Before closing** a substantive session, run the \`post_task\` prompt to capture what was learned.
+4. **Before final response**, run \`haive enforce finish\`. If it blocks, commit/push, bump/tag shippable releases, then rerun it.
 
 If the haive MCP server is not available, tell the developer rather than silently skipping it.
 
@@ -2803,6 +2805,7 @@ This repository uses **hAIve**. Running \`haive init\` means the team expects ag
 
 - On failure: **\`mem_tried\`** immediately.
 - Before closing a substantive session: MCP prompt **\`post_task\`** when there is something worth capturing.
+- Before final response: **\`haive enforce finish\`** must pass; it checks commit/push and release version/tag protocol.
 
 ## If haive MCP is missing
 
@@ -2898,7 +2901,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - uses: Doucs91/hAIve/packages/github-action@main
+      - uses: Doucs91/hAIve/packages/github-action@${HAIVE_GITHUB_ACTION_REF}
         with:
           github-token: \${{ secrets.GITHUB_TOKEN }}
           # post-if-empty: 'true'   # uncomment to always post (even when no memories found)
@@ -3660,55 +3663,66 @@ import {
   serializeMemory as serializeMemory32
 } from "@hiveai/core";
 import { z as z7 } from "zod";
-import { readFile as readFile22, readdir as readdir22 } from "fs/promises";
-import { existsSync as existsSync82 } from "fs";
-import path42 from "path";
 import {
-  deriveConfidence as deriveConfidence2,
+  computeImpact,
   getUsage as getUsage22,
-  inferModulesFromPaths,
   loadMemoriesFromDir as loadMemoriesFromDir6,
   loadUsageIndex as loadUsageIndex32,
-  memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
-  trackReads as trackReads22
+  recordApplied,
+  recordRejection as recordRejection2,
+  saveUsageIndex as saveUsageIndex2
 } from "@hiveai/core";
+import { existsSync as existsSync82 } from "fs";
 import { z as z8 } from "zod";
+import { readFile as readFile22, readdir as readdir22 } from "fs/promises";
 import { existsSync as existsSync92 } from "fs";
+import path42 from "path";
 import {
-  deriveConfidence as deriveConfidence3,
+  deriveConfidence as deriveConfidence2,
   getUsage as getUsage3,
+  inferModulesFromPaths,
   loadMemoriesFromDir as loadMemoriesFromDir7,
-  loadUsageIndex as loadUsageIndex4
+  loadUsageIndex as loadUsageIndex4,
+  memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
+  trackReads as trackReads22
 } from "@hiveai/core";
 import { z as z9 } from "zod";
 import { existsSync as existsSync102 } from "fs";
-import { unlink } from "fs/promises";
 import {
+  deriveConfidence as deriveConfidence3,
+  getUsage as getUsage4,
   loadMemoriesFromDir as loadMemoriesFromDir8,
-  loadUsageIndex as loadUsageIndex5,
-  saveUsageIndex as saveUsageIndex2
+  loadUsageIndex as loadUsageIndex5
 } from "@hiveai/core";
 import { z as z10 } from "zod";
-import { writeFile as writeFile52 } from "fs/promises";
 import { existsSync as existsSync112 } from "fs";
-import { loadMemoriesFromDir as loadMemoriesFromDir9, serializeMemory as serializeMemory4 } from "@hiveai/core";
-import { z as z11 } from "zod";
-import { existsSync as existsSync122 } from "fs";
+import { unlink } from "fs/promises";
 import {
-  getUsage as getUsage4,
-  loadMemoriesFromDir as loadMemoriesFromDir10,
-  loadUsageIndex as loadUsageIndex6
+  loadMemoriesFromDir as loadMemoriesFromDir9,
+  loadUsageIndex as loadUsageIndex6,
+  saveUsageIndex as saveUsageIndex3
 } from "@hiveai/core";
+import { z as z11 } from "zod";
+import { writeFile as writeFile52 } from "fs/promises";
+import { existsSync as existsSync122 } from "fs";
+import { loadMemoriesFromDir as loadMemoriesFromDir10, serializeMemory as serializeMemory4 } from "@hiveai/core";
 import { z as z12 } from "zod";
-import { writeFile as writeFile62 } from "fs/promises";
 import { existsSync as existsSync132 } from "fs";
 import {
+  getUsage as getUsage5,
   loadMemoriesFromDir as loadMemoriesFromDir11,
-  serializeMemory as serializeMemory5
+  loadUsageIndex as loadUsageIndex7
 } from "@hiveai/core";
 import { z as z13 } from "zod";
-import { mkdir as mkdir32, writeFile as writeFile72 } from "fs/promises";
+import { writeFile as writeFile62 } from "fs/promises";
 import { existsSync as existsSync142 } from "fs";
+import {
+  loadMemoriesFromDir as loadMemoriesFromDir12,
+  serializeMemory as serializeMemory5
+} from "@hiveai/core";
+import { z as z14 } from "zod";
+import { mkdir as mkdir32, writeFile as writeFile72 } from "fs/promises";
+import { existsSync as existsSync15 } from "fs";
 import path52 from "path";
 import {
   buildFrontmatter as buildFrontmatter22,
@@ -3716,9 +3730,9 @@ import {
   serializeMemory as serializeMemory6,
   suggestSensorFromMemory as suggestSensorFromMemory2
 } from "@hiveai/core";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 import { mkdir as mkdir42, writeFile as writeFile82 } from "fs/promises";
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import path62 from "path";
 import {
   buildFrontmatter as buildFrontmatter3,
@@ -3726,35 +3740,37 @@ import {
   memoryFilePath as memoryFilePath3,
   serializeMemory as serializeMemory7
 } from "@hiveai/core";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 import { writeFile as writeFile10, mkdir as mkdir62 } from "fs/promises";
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync18 } from "fs";
 import path82 from "path";
 import {
   buildFrontmatter as buildFrontmatter4,
-  loadMemoriesFromDir as loadMemoriesFromDir12,
+  loadMemoriesFromDir as loadMemoriesFromDir13,
   memoryFilePath as memoryFilePath4,
   serializeMemory as serializeMemory8
 } from "@hiveai/core";
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 import {
   appendUsageEvent,
   appendRuntimeJournalEntry,
   loadConfig as loadConfig22
 } from "@hiveai/core";
 import { mkdir as mkdir52, writeFile as writeFile92, rm } from "fs/promises";
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import path72 from "path";
 import { execSync } from "child_process";
 import { readFile as readFile42, writeFile as writeFile11 } from "fs/promises";
-import { existsSync as existsSync19 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 import {
   allocateBudget,
+  computeImpact as computeImpact2,
   DEFAULT_AUTO_PROMOTE_RULE,
   deriveConfidence as deriveConfidence4,
   estimateTokens,
+  evaluateSkillActivation,
   extractActionsBriefBody as extractActionsBriefBody2,
-  getUsage as getUsage5,
+  getUsage as getUsage6,
   inferModulesFromPaths as inferModulesFromPaths2,
   isAutoPromoteEligible,
   isDecaying,
@@ -3763,8 +3779,8 @@ import {
   literalMatchesAnyToken as literalMatchesAnyToken22,
   loadCodeMap as loadCodeMap5,
   loadConfig as loadConfig3,
-  loadMemoriesFromDir as loadMemoriesFromDir13,
-  loadUsageIndex as loadUsageIndex7,
+  loadMemoriesFromDir as loadMemoriesFromDir14,
+  loadUsageIndex as loadUsageIndex8,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths22,
   queryCodeMap as queryCodeMap2,
   resolveBriefingBudget as resolveBriefingBudget2,
@@ -3776,77 +3792,77 @@ import {
   truncateToTokens,
   writeBriefingMarker as writeBriefingMarker2
 } from "@hiveai/core";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 import { readdir as readdir3, readFile as readFile32 } from "fs/promises";
-import { existsSync as existsSync18 } from "fs";
+import { existsSync as existsSync19 } from "fs";
 import path92 from "path";
 import { isGlobPath, isStackPackSeed as isStackPackSeed2, pathsOverlap } from "@hiveai/core";
 import { estimateTokens as estimateTokens2, loadCodeMap as loadCodeMap22, queryCodeMap as queryCodeMap22 } from "@hiveai/core";
-import { z as z18 } from "zod";
-import { existsSync as existsSync20 } from "fs";
-import { loadMemoriesFromDir as loadMemoriesFromDir14 } from "@hiveai/core";
 import { z as z19 } from "zod";
 import { existsSync as existsSync21 } from "fs";
 import { loadMemoriesFromDir as loadMemoriesFromDir15 } from "@hiveai/core";
 import { z as z20 } from "zod";
+import { existsSync as existsSync222 } from "fs";
+import { loadMemoriesFromDir as loadMemoriesFromDir16 } from "@hiveai/core";
 import { z as z21 } from "zod";
 import { z as z22 } from "zod";
-import { existsSync as existsSync222 } from "fs";
+import { z as z23 } from "zod";
+import { existsSync as existsSync23 } from "fs";
 import { spawn } from "child_process";
 import path102 from "path";
 import {
   deriveConfidence as deriveConfidence5,
-  getUsage as getUsage6,
+  getUsage as getUsage7,
   loadCodeMap as loadCodeMap32,
-  loadMemoriesFromDir as loadMemoriesFromDir16,
-  loadUsageIndex as loadUsageIndex8,
+  loadMemoriesFromDir as loadMemoriesFromDir17,
+  loadUsageIndex as loadUsageIndex9,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths3
 } from "@hiveai/core";
-import { z as z23 } from "zod";
-import { existsSync as existsSync23 } from "fs";
+import { z as z24 } from "zod";
+import { existsSync as existsSync24 } from "fs";
 import {
   addedLinesFromDiff,
   deriveConfidence as deriveConfidence6,
-  getUsage as getUsage7,
+  getUsage as getUsage8,
   isRetiredMemory as isRetiredMemory2,
-  loadMemoriesFromDir as loadMemoriesFromDir17,
-  loadUsageIndex as loadUsageIndex9,
+  loadMemoriesFromDir as loadMemoriesFromDir18,
+  loadUsageIndex as loadUsageIndex10,
   literalMatchesAnyToken as literalMatchesAnyToken3,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths4,
   runSensors,
   sensorTargetsFromDiff,
   tokenizeQuery as tokenizeQuery3
 } from "@hiveai/core";
-import { z as z24 } from "zod";
-import { existsSync as existsSync24 } from "fs";
-import {
-  loadMemoriesFromDir as loadMemoriesFromDir18,
-  tokenizeQuery as tokenizeQuery4
-} from "@hiveai/core";
 import { z as z25 } from "zod";
 import { existsSync as existsSync25 } from "fs";
-import { spawn as spawn2 } from "child_process";
 import {
-  deriveConfidence as deriveConfidence7,
-  getUsage as getUsage8,
   loadMemoriesFromDir as loadMemoriesFromDir19,
-  loadUsageIndex as loadUsageIndex10,
-  pathsOverlap as singlePathsOverlap
+  tokenizeQuery as tokenizeQuery4
 } from "@hiveai/core";
 import { z as z26 } from "zod";
 import { existsSync as existsSync26 } from "fs";
+import { spawn as spawn2 } from "child_process";
 import {
-  deriveConfidence as deriveConfidence8,
+  deriveConfidence as deriveConfidence7,
   getUsage as getUsage9,
   loadMemoriesFromDir as loadMemoriesFromDir20,
   loadUsageIndex as loadUsageIndex11,
+  pathsOverlap as singlePathsOverlap
+} from "@hiveai/core";
+import { z as z27 } from "zod";
+import { existsSync as existsSync27 } from "fs";
+import {
+  deriveConfidence as deriveConfidence8,
+  getUsage as getUsage10,
+  loadMemoriesFromDir as loadMemoriesFromDir21,
+  loadUsageIndex as loadUsageIndex12,
   pathsOverlap as pathsOverlap2,
   tokenizeQuery as tokenizeQuery5
 } from "@hiveai/core";
-import { z as z27 } from "zod";
 import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 import { mkdir as mkdir72, writeFile as writeFile12 } from "fs/promises";
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 import path112 from "path";
 import { execSync as execSync2 } from "child_process";
 import {
@@ -3855,28 +3871,28 @@ import {
   readUsageEvents,
   serializeMemory as serializeMemory10
 } from "@hiveai/core";
-import { z as z29 } from "zod";
-import { existsSync as existsSync28 } from "fs";
+import { z as z30 } from "zod";
+import { existsSync as existsSync29 } from "fs";
 import {
   findLexicalConflictPairs,
   findTopicStatusConflictPairs,
-  loadMemoriesFromDir as loadMemoriesFromDir21
+  loadMemoriesFromDir as loadMemoriesFromDir222
 } from "@hiveai/core";
-import { z as z30 } from "zod";
-import { resolveProjectInfo } from "@hiveai/core";
 import { z as z31 } from "zod";
-import { MemoryTypeSchema, suggestTopicKey } from "@hiveai/core";
+import { resolveProjectInfo } from "@hiveai/core";
 import { z as z32 } from "zod";
-import { existsSync as existsSync29 } from "fs";
-import { collectTimelineEntries, loadMemoriesFromDir as loadMemoriesFromDir222 } from "@hiveai/core";
+import { MemoryTypeSchema, suggestTopicKey } from "@hiveai/core";
 import { z as z33 } from "zod";
-import { appendRuntimeJournalEntry as appendRuntimeJournalEntry2 } from "@hiveai/core";
+import { existsSync as existsSync30 } from "fs";
+import { collectTimelineEntries, loadMemoriesFromDir as loadMemoriesFromDir23 } from "@hiveai/core";
 import { z as z34 } from "zod";
-import { readRuntimeJournalTail } from "@hiveai/core";
+import { appendRuntimeJournalEntry as appendRuntimeJournalEntry2 } from "@hiveai/core";
 import { z as z35 } from "zod";
+import { readRuntimeJournalTail } from "@hiveai/core";
 import { z as z36 } from "zod";
 import { z as z37 } from "zod";
 import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 import { hasRecentBriefingMarker, loadConfigSync } from "@hiveai/core";
 function createContext(options = {}) {
   const env = options.env ?? process.env;
@@ -3993,6 +4009,13 @@ var MemSaveInputSchema = {
   commit: z4.string().optional().describe("Anchor commit SHA (for staleness detection later)"),
   topic: z4.string().optional().describe(
     "Stable key for this memory. If a memory with the same topic already exists in this scope, it is updated in-place (revision_count++). Use for knowledge that evolves over time."
+  ),
+  activation: z4.object({
+    keywords: z4.array(z4.string()).default([]),
+    globs: z4.array(z4.string()).default([]),
+    always: z4.boolean().default(false)
+  }).optional().describe(
+    "Only for type='skill'. Progressive-disclosure triggers: the skill is surfaced ONLY when a keyword matches the task or a glob matches the edited files (or always=true). Omit to keep the skill always-eligible."
   )
 };
 function bodyHash(body) {
@@ -4111,7 +4134,8 @@ async function memSave(input, ctx) {
     commit: input.commit,
     topic: input.topic,
     status: haiveConfig.defaultStatus === "validated" ? "validated" : void 0,
-    sensor: suggestSensorForSavedMemory(input.type, input.body, input.paths) ?? void 0
+    sensor: suggestSensorForSavedMemory(input.type, input.body, input.paths) ?? void 0,
+    activation: input.type === "skill" ? input.activation : void 0
   });
   const file = memoryFilePath2(
     ctx.paths,
@@ -4460,14 +4484,51 @@ async function memReject(input, ctx) {
     rejection_reason: u?.rejection_reason ?? null
   };
 }
+var MemFeedbackInputSchema = {
+  id: z8.string().min(1).describe("Full memory id the feedback is about"),
+  outcome: z8.enum(["applied", "rejected"]).describe(
+    "'applied' = this memory changed what you did (strong positive utility signal); 'rejected' = it was wrong/outdated/unhelpful (negative signal, blocks auto-promotion)."
+  ),
+  reason: z8.string().optional().describe("Why it was rejected (stored on the memory's usage record). Only used for outcome='rejected'.")
+};
+async function memFeedback(input, ctx) {
+  if (!existsSync82(ctx.paths.memoriesDir)) {
+    return { ok: false, id: input.id, error: "No .ai/memories \u2014 run `haive init` first." };
+  }
+  const all = await loadMemoriesFromDir6(ctx.paths.memoriesDir);
+  const target = all.find((m) => m.memory.frontmatter.id === input.id);
+  if (!target) {
+    return { ok: false, id: input.id, error: `No memory with id '${input.id}'.` };
+  }
+  const index = await loadUsageIndex32(ctx.paths);
+  if (input.outcome === "applied") {
+    recordApplied(index, input.id);
+  } else {
+    recordRejection2(index, input.id, input.reason ?? null);
+  }
+  await saveUsageIndex2(ctx.paths, index);
+  const usage = getUsage22(index, input.id);
+  const impact = computeImpact(target.memory.frontmatter, usage);
+  return {
+    ok: true,
+    id: input.id,
+    outcome: input.outcome,
+    usage: {
+      read_count: usage.read_count,
+      applied_count: usage.applied_count,
+      rejected_count: usage.rejected_count
+    },
+    impact: { score: impact.score, tier: impact.tier, signals: impact.signals }
+  };
+}
 var MemForFilesInputSchema = {
-  files: z8.array(z8.string()).min(1).describe("Project-relative file paths the agent is currently working on"),
-  include_module_contexts: z8.boolean().default(true).describe("Inline the matching .ai/modules/<name>/context.md contents"),
-  track: z8.boolean().default(true).describe("Increment read_count on returned memories")
+  files: z9.array(z9.string()).min(1).describe("Project-relative file paths the agent is currently working on"),
+  include_module_contexts: z9.boolean().default(true).describe("Inline the matching .ai/modules/<name>/context.md contents"),
+  track: z9.boolean().default(true).describe("Increment read_count on returned memories")
 };
 async function memForFiles(input, ctx) {
   const inferred = inferModulesFromPaths(input.files);
-  if (!existsSync82(ctx.paths.memoriesDir)) {
+  if (!existsSync92(ctx.paths.memoriesDir)) {
     return {
       inferred_modules: inferred,
       by_anchor: [],
@@ -4476,8 +4537,8 @@ async function memForFiles(input, ctx) {
       module_contexts: await loadModuleContexts(ctx, inferred, input.include_module_contexts)
     };
   }
-  const all = await loadMemoriesFromDir6(ctx.paths.memoriesDir);
-  const usage = await loadUsageIndex32(ctx.paths);
+  const all = await loadMemoriesFromDir7(ctx.paths.memoriesDir);
+  const usage = await loadUsageIndex4(ctx.paths);
   const seen = /* @__PURE__ */ new Set();
   const byAnchor = [];
   const byModule = [];
@@ -4525,7 +4586,7 @@ async function memForFiles(input, ctx) {
 }
 function toMatch(loaded, reason, usage) {
   const fm = loaded.memory.frontmatter;
-  const u = getUsage22(usage, fm.id);
+  const u = getUsage3(usage, fm.id);
   return {
     id: fm.id,
     scope: fm.scope,
@@ -4589,7 +4650,7 @@ function extractPathSegments(files) {
 }
 async function loadModuleContexts(ctx, modules, enabled) {
   if (!enabled || modules.length === 0) return [];
-  if (!existsSync82(ctx.paths.modulesContextDir)) return [];
+  if (!existsSync92(ctx.paths.modulesContextDir)) return [];
   const available = new Set(
     (await readdir22(ctx.paths.modulesContextDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name)
   );
@@ -4597,24 +4658,24 @@ async function loadModuleContexts(ctx, modules, enabled) {
   for (const m of modules) {
     if (!available.has(m)) continue;
     const file = path42.join(ctx.paths.modulesContextDir, m, "context.md");
-    if (existsSync82(file)) {
+    if (existsSync92(file)) {
       out.push({ name: m, content: await readFile22(file, "utf8") });
     }
   }
   return out;
 }
 var MemGetInputSchema = {
-  id: z9.string().min(1).describe("Memory id to fetch")
+  id: z10.string().min(1).describe("Memory id to fetch")
 };
 async function memGet(input, ctx) {
-  if (!existsSync92(ctx.paths.memoriesDir)) {
+  if (!existsSync102(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const all = await loadMemoriesFromDir7(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir8(ctx.paths.memoriesDir);
   const found = all.find((m) => m.memory.frontmatter.id === input.id);
   if (!found) throw new Error(`No memory with id "${input.id}".`);
   const fm = found.memory.frontmatter;
-  const u = getUsage3(await loadUsageIndex4(ctx.paths), fm.id);
+  const u = getUsage4(await loadUsageIndex5(ctx.paths), fm.id);
   return {
     id: fm.id,
     scope: fm.scope,
@@ -4638,43 +4699,43 @@ async function memGet(input, ctx) {
   };
 }
 var MemDeleteInputSchema = {
-  id: z10.string().min(1).describe("Memory id to delete"),
-  keep_usage: z10.boolean().default(false).describe("Keep the usage.json entry instead of removing it alongside the file")
+  id: z11.string().min(1).describe("Memory id to delete"),
+  keep_usage: z11.boolean().default(false).describe("Keep the usage.json entry instead of removing it alongside the file")
 };
 async function memDelete(input, ctx) {
-  if (!existsSync102(ctx.paths.memoriesDir)) {
+  if (!existsSync112(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const all = await loadMemoriesFromDir8(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir9(ctx.paths.memoriesDir);
   const found = all.find((m) => m.memory.frontmatter.id === input.id);
   if (!found) throw new Error(`No memory with id "${input.id}".`);
   await unlink(found.filePath);
   let usageRemoved = false;
   if (!input.keep_usage) {
-    const idx = await loadUsageIndex5(ctx.paths);
+    const idx = await loadUsageIndex6(ctx.paths);
     if (idx.by_id[input.id]) {
       delete idx.by_id[input.id];
-      await saveUsageIndex2(ctx.paths, idx);
+      await saveUsageIndex3(ctx.paths, idx);
       usageRemoved = true;
     }
   }
   return { id: input.id, deleted_file: found.filePath, usage_removed: usageRemoved };
 }
 var MemUpdateInputSchema = {
-  id: z11.string().min(1).describe("Id of the memory to update"),
-  body: z11.string().optional().describe("New Markdown body \u2014 replaces the existing body"),
-  tags: z11.array(z11.string()).optional().describe("New tags array \u2014 fully replaces existing tags"),
-  paths: z11.array(z11.string()).optional().describe("New anchor paths \u2014 fully replaces existing anchor.paths"),
-  symbols: z11.array(z11.string()).optional().describe("New anchor symbols \u2014 fully replaces existing anchor.symbols"),
-  commit: z11.string().optional().describe("New anchor commit SHA"),
-  domain: z11.string().optional().describe("New domain label"),
-  author: z11.string().optional().describe("New author handle or email")
+  id: z12.string().min(1).describe("Id of the memory to update"),
+  body: z12.string().optional().describe("New Markdown body \u2014 replaces the existing body"),
+  tags: z12.array(z12.string()).optional().describe("New tags array \u2014 fully replaces existing tags"),
+  paths: z12.array(z12.string()).optional().describe("New anchor paths \u2014 fully replaces existing anchor.paths"),
+  symbols: z12.array(z12.string()).optional().describe("New anchor symbols \u2014 fully replaces existing anchor.symbols"),
+  commit: z12.string().optional().describe("New anchor commit SHA"),
+  domain: z12.string().optional().describe("New domain label"),
+  author: z12.string().optional().describe("New author handle or email")
 };
 async function memUpdate(input, ctx) {
-  if (!existsSync112(ctx.paths.memoriesDir)) {
+  if (!existsSync122(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const memories = await loadMemoriesFromDir9(ctx.paths.memoriesDir);
+  const memories = await loadMemoriesFromDir10(ctx.paths.memoriesDir);
   const loaded = memories.find((m) => m.memory.frontmatter.id === input.id);
   if (!loaded) throw new Error(`No memory with id "${input.id}".`);
   const { frontmatter, body } = loaded.memory;
@@ -4715,12 +4776,12 @@ async function memUpdate(input, ctx) {
   return { id: input.id, file_path: loaded.filePath, updated_fields };
 }
 var MemPendingInputSchema = {
-  scope: z12.enum(["personal", "team", "module"]).optional()
+  scope: z13.enum(["personal", "team", "module"]).optional()
 };
 async function memPending(input, ctx) {
-  if (!existsSync122(ctx.paths.memoriesDir)) return { pending: [] };
-  const all = await loadMemoriesFromDir10(ctx.paths.memoriesDir);
-  const usage = await loadUsageIndex6(ctx.paths);
+  if (!existsSync132(ctx.paths.memoriesDir)) return { pending: [] };
+  const all = await loadMemoriesFromDir11(ctx.paths.memoriesDir);
+  const usage = await loadUsageIndex7(ctx.paths);
   const now = Date.now();
   const proposed = all.filter(({ memory: memory2 }) => {
     if (memory2.frontmatter.status !== "proposed") return false;
@@ -4728,12 +4789,12 @@ async function memPending(input, ctx) {
     return true;
   });
   proposed.sort(
-    (a, b) => getUsage4(usage, b.memory.frontmatter.id).read_count - getUsage4(usage, a.memory.frontmatter.id).read_count
+    (a, b) => getUsage5(usage, b.memory.frontmatter.id).read_count - getUsage5(usage, a.memory.frontmatter.id).read_count
   );
   return {
     pending: proposed.map(({ memory: memory2, filePath }) => {
       const fm = memory2.frontmatter;
-      const u = getUsage4(usage, fm.id);
+      const u = getUsage5(usage, fm.id);
       return {
         id: fm.id,
         scope: fm.scope,
@@ -4749,13 +4810,13 @@ async function memPending(input, ctx) {
   };
 }
 var MemApproveInputSchema = {
-  id: z13.string().min(1).describe("Memory id to approve (sets status=validated immediately)")
+  id: z14.string().min(1).describe("Memory id to approve (sets status=validated immediately)")
 };
 async function memApprove(input, ctx) {
-  if (!existsSync132(ctx.paths.memoriesDir)) {
+  if (!existsSync142(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const all = await loadMemoriesFromDir11(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir12(ctx.paths.memoriesDir);
   const found = all.find((m) => m.memory.frontmatter.id === input.id);
   if (!found) throw new Error(`No memory with id "${input.id}".`);
   const previous = found.memory.frontmatter.status;
@@ -4772,17 +4833,17 @@ async function memApprove(input, ctx) {
   };
 }
 var MemTriedInputSchema = {
-  what: z14.string().min(1).describe("Brief description of the approach that was tried"),
-  why_failed: z14.string().min(1).describe("Why it failed or why it should NOT be used"),
-  instead: z14.string().optional().describe("What to use or do instead (recommended alternative)"),
-  scope: z14.enum(["personal", "team", "module"]).default("personal").describe("Visibility scope"),
-  module: z14.string().optional().describe("Module name (required when scope=module)"),
-  tags: z14.array(z14.string()).default([]).describe("Tags for filtering"),
-  paths: z14.array(z14.string()).default([]).describe("Anchor file paths this applies to"),
-  author: z14.string().optional().describe("Author handle or email")
+  what: z15.string().min(1).describe("Brief description of the approach that was tried"),
+  why_failed: z15.string().min(1).describe("Why it failed or why it should NOT be used"),
+  instead: z15.string().optional().describe("What to use or do instead (recommended alternative)"),
+  scope: z15.enum(["personal", "team", "module"]).default("personal").describe("Visibility scope"),
+  module: z15.string().optional().describe("Module name (required when scope=module)"),
+  tags: z15.array(z15.string()).default([]).describe("Tags for filtering"),
+  paths: z15.array(z15.string()).default([]).describe("Anchor file paths this applies to"),
+  author: z15.string().optional().describe("Author handle or email")
 };
 async function memTried(input, ctx) {
-  if (!existsSync142(ctx.paths.haiveDir)) {
+  if (!existsSync15(ctx.paths.haiveDir)) {
     throw new Error(`No .ai/ directory at ${ctx.paths.root}. Run 'haive init' first.`);
   }
   const slug = input.what.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim().split(/\s+/).slice(0, 5).join("-");
@@ -4808,27 +4869,27 @@ async function memTried(input, ctx) {
   }
   const file = memoryFilePath22(ctx.paths, frontmatter.scope, frontmatter.id, frontmatter.module);
   await mkdir32(path52.dirname(file), { recursive: true });
-  if (existsSync142(file)) {
+  if (existsSync15(file)) {
     throw new Error(`Memory already exists at ${file}`);
   }
   await writeFile72(file, serializeMemory6({ frontmatter, body }), "utf8");
   return { id: frontmatter.id, scope: frontmatter.scope, file_path: file };
 }
 var MemObserveInputSchema = {
-  what: z15.string().min(1).describe("Short title: what did you observe? (e.g. 'MobilePaymentController has two @RequestBody on handleWebhook')"),
-  where: z15.string().min(1).describe("File path(s) where the issue lives \u2014 be specific"),
-  impact: z15.string().min(1).describe("What breaks or could break because of this (e.g. 'Spring MVC rejects the handler at startup')"),
-  fix: z15.string().optional().describe("Suggested fix or workaround (optional \u2014 leave empty if unknown)"),
-  scope: z15.enum(["personal", "team", "module"]).default("team").describe("Visibility scope \u2014 defaults to team since discoveries benefit everyone"),
-  module: z15.string().optional().describe("Module name (required when scope=module)"),
-  tags: z15.array(z15.string()).default([]).describe("Tags for filtering"),
-  author: z15.string().optional().describe("Author handle or email"),
-  force: z15.boolean().default(false).describe(
+  what: z16.string().min(1).describe("Short title: what did you observe? (e.g. 'MobilePaymentController has two @RequestBody on handleWebhook')"),
+  where: z16.string().min(1).describe("File path(s) where the issue lives \u2014 be specific"),
+  impact: z16.string().min(1).describe("What breaks or could break because of this (e.g. 'Spring MVC rejects the handler at startup')"),
+  fix: z16.string().optional().describe("Suggested fix or workaround (optional \u2014 leave empty if unknown)"),
+  scope: z16.enum(["personal", "team", "module"]).default("team").describe("Visibility scope \u2014 defaults to team since discoveries benefit everyone"),
+  module: z16.string().optional().describe("Module name (required when scope=module)"),
+  tags: z16.array(z16.string()).default([]).describe("Tags for filtering"),
+  author: z16.string().optional().describe("Author handle or email"),
+  force: z16.boolean().default(false).describe(
     "Save even if the observation looks like generic, guessable knowledge. By default, low-specificity observations (things a capable model already knows) are SKIPPED to keep the corpus high-signal \u2014 only unguessable, team-specific discoveries are worth storing."
   )
 };
 async function memObserve(input, ctx) {
-  if (!existsSync15(ctx.paths.haiveDir)) {
+  if (!existsSync16(ctx.paths.haiveDir)) {
     throw new Error(`No .ai/ directory at ${ctx.paths.root}. Run 'haive init' first.`);
   }
   const signalText = [input.what, input.impact, input.fix ?? ""].join(" ");
@@ -4862,7 +4923,7 @@ async function memObserve(input, ctx) {
   const body = lines.join("\n") + "\n";
   const file = memoryFilePath3(ctx.paths, frontmatter.scope, frontmatter.id, frontmatter.module);
   await mkdir42(path62.dirname(file), { recursive: true });
-  if (existsSync15(file)) {
+  if (existsSync16(file)) {
     throw new Error(`Memory already exists at ${file}`);
   }
   await writeFile82(file, serializeMemory7({ frontmatter, body }), "utf8");
@@ -4948,7 +5009,7 @@ var SessionTracker = class {
         (e) => e.tool === "mem_session_end" && !e.summary?.startsWith("Auto-captured")
       );
       const isSubstantialSession = totalCalls >= 3 || writingTools.length > 0;
-      if (!ranPostTask && isSubstantialSession && existsSync16(this.ctx.paths.haiveDir)) {
+      if (!ranPostTask && isSubstantialSession && existsSync17(this.ctx.paths.haiveDir)) {
         try {
           const memoriesSaved = writingTools.map((e) => e.summary ?? "").filter(Boolean).slice(0, 20);
           const payload = {
@@ -4982,7 +5043,7 @@ var SessionTracker = class {
 };
 async function clearPendingDistill(ctx) {
   const p = pendingDistillPath(ctx);
-  if (existsSync16(p)) {
+  if (existsSync17(p)) {
     try {
       await rm(p);
     } catch {
@@ -4997,15 +5058,15 @@ function summarizeTools(events) {
   return [...counts.entries()].sort((a, b) => b[1] - a[1]).map(([t, n]) => `${t} \xD7${n}`).join(", ");
 }
 var MemSessionEndInputSchema = {
-  goal: z16.string().min(1).describe("What you were trying to accomplish this session (1\u20132 sentences)"),
-  accomplished: z16.string().describe("What was actually done \u2014 bullet list recommended"),
-  discoveries: z16.string().default("").describe(
+  goal: z17.string().min(1).describe("What you were trying to accomplish this session (1\u20132 sentences)"),
+  accomplished: z17.string().describe("What was actually done \u2014 bullet list recommended"),
+  discoveries: z17.string().default("").describe(
     "Any bugs, inconsistencies, surprises, or missing knowledge found during this session. Empty if nothing surprising was found."
   ),
-  files_touched: z16.array(z16.string()).default([]).describe("Key files that were read or modified \u2014 used as anchor paths"),
-  next_steps: z16.string().default("").describe("What should happen next (for the next session or a teammate)"),
-  scope: z16.enum(["personal", "team", "module"]).default("personal").describe("Visibility: personal = private to you, team = shared with the team"),
-  module: z16.string().optional().describe("Module name (required when scope=module)")
+  files_touched: z17.array(z17.string()).default([]).describe("Key files that were read or modified \u2014 used as anchor paths"),
+  next_steps: z17.string().default("").describe("What should happen next (for the next session or a teammate)"),
+  scope: z17.enum(["personal", "team", "module"]).default("personal").describe("Visibility: personal = private to you, team = shared with the team"),
+  module: z17.string().optional().describe("Module name (required when scope=module)")
 };
 function recapTopic(scope, module) {
   return module ? `session-recap-${scope}-${module}` : `session-recap-${scope}`;
@@ -5035,7 +5096,7 @@ ${input.next_steps}`);
   return lines.join("\n");
 }
 async function memSessionEnd(input, ctx) {
-  if (!existsSync17(ctx.paths.haiveDir)) {
+  if (!existsSync18(ctx.paths.haiveDir)) {
     throw new Error(`No .ai/ directory at ${ctx.paths.root}. Run 'haive init' first.`);
   }
   const body = buildBody(input);
@@ -5046,12 +5107,12 @@ async function memSessionEnd(input, ctx) {
     return rel.startsWith("..") ? p : rel;
   });
   const invalidPaths = normalizedFiles.filter(
-    (p) => !existsSync17(path82.resolve(ctx.paths.root, p))
+    (p) => !existsSync18(path82.resolve(ctx.paths.root, p))
   );
   if (invalidPaths.length > 0) {
     console.warn(`[haive] session end: anchor path(s) not found: ${invalidPaths.join(", ")}`);
   }
-  const existing = existsSync17(ctx.paths.memoriesDir) ? await loadMemoriesFromDir12(ctx.paths.memoriesDir) : [];
+  const existing = existsSync18(ctx.paths.memoriesDir) ? await loadMemoriesFromDir13(ctx.paths.memoriesDir) : [];
   const topicMatch = existing.find(
     ({ memory: memory2 }) => memory2.frontmatter.topic === topic && memory2.frontmatter.scope === input.scope && (!input.module || memory2.frontmatter.module === input.module)
   );
@@ -5232,7 +5293,7 @@ async function trySemanticHits(ctx, task, limit) {
 }
 async function loadModuleContexts2(ctx, modules) {
   if (modules.length === 0) return [];
-  if (!existsSync18(ctx.paths.modulesContextDir)) return [];
+  if (!existsSync19(ctx.paths.modulesContextDir)) return [];
   const available = new Set(
     (await readdir3(ctx.paths.modulesContextDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name)
   );
@@ -5240,42 +5301,42 @@ async function loadModuleContexts2(ctx, modules) {
   for (const m of modules) {
     if (!available.has(m)) continue;
     const file = path92.join(ctx.paths.modulesContextDir, m, "context.md");
-    if (existsSync18(file)) {
+    if (existsSync19(file)) {
       out.push({ name: m, content: await readFile32(file, "utf8") });
     }
   }
   return out;
 }
 var GetBriefingInputSchema = {
-  task: z17.string().optional().describe(
+  task: z18.string().optional().describe(
     "What you are about to do, in 1\u20132 sentences. Used to rank relevant memories semantically."
   ),
-  files: z17.array(z17.string()).default([]).describe("Project-relative file paths the agent is currently looking at or about to edit"),
-  max_tokens: z17.number().int().positive().default(8e3).describe(
+  files: z18.array(z18.string()).default([]).describe("Project-relative file paths the agent is currently looking at or about to edit"),
+  max_tokens: z18.number().int().positive().default(8e3).describe(
     "Approximate token budget for the entire briefing. Each section is allocated a share and truncated to fit."
   ),
-  max_memories: z17.number().int().positive().default(8).describe("Cap on memories surfaced regardless of token budget"),
-  include_project_context: z17.boolean().default(true),
-  include_module_contexts: z17.boolean().default(true),
-  semantic: z17.boolean().default(true).describe(
+  max_memories: z18.number().int().positive().default(8).describe("Cap on memories surfaced regardless of token budget"),
+  include_project_context: z18.boolean().default(true),
+  include_module_contexts: z18.boolean().default(true),
+  semantic: z18.boolean().default(true).describe(
     "Use semantic ranking when a task is provided (requires `haive embeddings index`)."
   ),
-  include_stale: z17.boolean().default(false).describe("Include stale memories (excluded by default \u2014 they may be outdated)"),
-  track: z17.boolean().default(true).describe("Increment read_count on returned memories"),
-  format: z17.enum(["full", "compact", "actions"]).default("full").describe(
+  include_stale: z18.boolean().default(false).describe("Include stale memories (excluded by default \u2014 they may be outdated)"),
+  track: z18.boolean().default(true).describe("Increment read_count on returned memories"),
+  format: z18.enum(["full", "compact", "actions"]).default("full").describe(
     "Output format: 'full' returns memory bodies (honors token budget via truncation); 'compact' returns a 1-line summary per memory (call mem_get for detail); 'actions' squeezes bodies to actionable bullet lines \u2014 fewer tokens vs full."
   ),
-  symbols: z17.array(z17.string()).default([]).describe(
+  symbols: z18.array(z18.string()).default([]).describe(
     "Symbol names to look up in the code-map (e.g. ['PaymentService', 'TenantFilter']). Returns the file(s) exporting each symbol so agents don't need to grep. Requires `haive index code` to have been run."
   ),
-  min_semantic_score: z17.number().min(0).max(1).default(0).describe(
+  min_semantic_score: z18.number().min(0).max(1).default(0).describe(
     "Drop semantic-only memory hits whose cosine score is below this threshold. Useful to avoid weakly-related noise when the task is short or the corpus is broad. Has no effect on memories matched via anchor/module/literal \u2014 those are always kept. Try 0.25\u20130.4 for stricter matching."
   ),
-  budget_preset: z17.enum(["quick", "balanced", "deep"]).optional().describe(
+  budget_preset: z18.enum(["quick", "balanced", "deep"]).optional().describe(
     "Shortcut token budget: 'quick' minimizes tokens/skip module CONTEXT slices; 'balanced' mirrors historical defaults; 'deep' uses a larger briefing. When set, overrides max_tokens, max_memories, and include_module_contexts."
   )
 };
-var GetBriefingZod = z17.object(GetBriefingInputSchema);
+var GetBriefingZod = z18.object(GetBriefingInputSchema);
 async function getBriefing(input, ctx) {
   const resolvedBudget = resolveBriefingBudget2(input.budget_preset, {
     max_tokens: input.max_tokens,
@@ -5291,8 +5352,8 @@ async function getBriefing(input, ctx) {
   let usage = { version: 1, updated_at: "", by_id: {} };
   let byId = /* @__PURE__ */ new Map();
   let lastSession;
-  if (existsSync19(ctx.paths.memoriesDir)) {
-    const allLoaded = await loadMemoriesFromDir13(ctx.paths.memoriesDir);
+  if (existsSync20(ctx.paths.memoriesDir)) {
+    const allLoaded = await loadMemoriesFromDir14(ctx.paths.memoriesDir);
     const recaps = allLoaded.filter(({ memory: memory2 }) => memory2.frontmatter.type === "session_recap").sort(
       (a, b) => new Date(b.memory.frontmatter.created_at).getTime() - new Date(a.memory.frontmatter.created_at).getTime()
     );
@@ -5314,7 +5375,7 @@ async function getBriefing(input, ctx) {
       if (memory2.frontmatter.type === "session_recap") return false;
       return true;
     });
-    usage = await loadUsageIndex7(ctx.paths);
+    usage = await loadUsageIndex8(ctx.paths);
     byId = new Map(allMemories.map((m) => [m.memory.frontmatter.id, m]));
     const semanticHits = input.task && input.semantic ? await trySemanticHits(ctx, input.task, allMemories.length * 2) : null;
     if (input.task && input.semantic) {
@@ -5336,7 +5397,8 @@ async function getBriefing(input, ctx) {
         }
         return;
       }
-      const u = getUsage5(usage, fm.id);
+      const u = getUsage6(usage, fm.id);
+      const imp = computeImpact2(fm, u);
       seen.set(fm.id, {
         id: fm.id,
         scope: fm.scope,
@@ -5347,6 +5409,8 @@ async function getBriefing(input, ctx) {
         confidence: deriveConfidence4(fm, u),
         ...fm.status === "draft" || fm.status === "proposed" ? { unverified: true } : {},
         read_count: u.read_count,
+        impact_score: imp.score,
+        impact_tier: imp.tier,
         reasons: [reason],
         match_quality: matchQuality ?? "partial",
         ...score !== void 0 ? { semantic_score: score } : {},
@@ -5390,11 +5454,28 @@ async function getBriefing(input, ctx) {
         }
       }
     }
+    const activatedSkills = /* @__PURE__ */ new Set();
+    for (const [id, m] of seen) {
+      if (m.type !== "skill") continue;
+      const loaded = byId.get(id);
+      if (!loaded) continue;
+      const act = evaluateSkillActivation(loaded.memory.frontmatter, {
+        task: input.task,
+        files: input.files
+      });
+      if (act.applicable && !act.activated) {
+        seen.delete(id);
+        continue;
+      }
+      if (act.applicable && act.activated) activatedSkills.add(id);
+    }
     const ranked = [...seen.values()].sort((a, b) => {
       const reasonScore = (m) => (m.type === "attempt" ? 3 : 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 = priorityRank(classifyMemoryPriority(a, byId.get(a.id), input.files, input.symbols)) * 100 + reasonScore(a) + confidenceScore(a) + (a.semantic_score ?? 0);
-      const sb = priorityRank(classifyMemoryPriority(b, byId.get(b.id), input.files, input.symbols)) * 100 + reasonScore(b) + confidenceScore(b) + (b.semantic_score ?? 0);
+      const impactScore = (m) => (m.impact_score ?? 0) * 3;
+      const activationBoost = (m) => activatedSkills.has(m.id) ? 5 : 0;
+      const sa = priorityRank(classifyMemoryPriority(a, byId.get(a.id), input.files, input.symbols)) * 100 + reasonScore(a) + confidenceScore(a) + impactScore(a) + activationBoost(a) + (a.semantic_score ?? 0);
+      const sb = priorityRank(classifyMemoryPriority(b, byId.get(b.id), input.files, input.symbols)) * 100 + reasonScore(b) + confidenceScore(b) + impactScore(b) + activationBoost(b) + (b.semantic_score ?? 0);
       return sb - sa;
     });
     for (const mem of ranked.slice(0, briefingMaxMemories)) {
@@ -5410,7 +5491,7 @@ async function getBriefing(input, ctx) {
     memories.push(...ranked.slice(0, briefingMaxMemories));
     if (input.track && memories.length > 0) {
       await trackReads3(ctx.paths, memories.map((m) => m.id));
-      const freshUsage = await loadUsageIndex7(ctx.paths);
+      const freshUsage = await loadUsageIndex8(ctx.paths);
       const cfg = await loadConfig3(ctx.paths);
       const rule = {
         minReads: cfg.autoPromoteMinReads ?? DEFAULT_AUTO_PROMOTE_RULE.minReads,
@@ -5419,7 +5500,7 @@ async function getBriefing(input, ctx) {
       for (const m of memories) {
         const loaded = byId.get(m.id);
         if (!loaded) continue;
-        const u = getUsage5(freshUsage, m.id);
+        const u = getUsage6(freshUsage, m.id);
         if (!isAutoPromoteEligible(loaded.memory.frontmatter, u, rule)) continue;
         const newFm = { ...loaded.memory.frontmatter, status: "validated" };
         try {
@@ -5431,12 +5512,12 @@ async function getBriefing(input, ctx) {
       }
     }
   }
-  const projectContextRaw = input.include_project_context && existsSync19(ctx.paths.projectContext) ? await readFile42(ctx.paths.projectContext, "utf8") : "";
+  const projectContextRaw = input.include_project_context && existsSync20(ctx.paths.projectContext) ? await readFile42(ctx.paths.projectContext, "utf8") : "";
   const isTemplateContext = projectContextRaw.includes("TODO \u2014 high-level overview") || projectContextRaw.includes("Generated by `haive init`");
   const setupWarnings = [];
   let autoContextGenerated = false;
   let projectContext = isTemplateContext ? "" : projectContextRaw;
-  if ((isTemplateContext || !existsSync19(ctx.paths.projectContext)) && input.include_project_context) {
+  if ((isTemplateContext || !existsSync20(ctx.paths.projectContext)) && input.include_project_context) {
     const haiveConfig = await loadConfig3(ctx.paths);
     if (haiveConfig.autoContext) {
       const codeMap = await loadCodeMap5(ctx.paths);
@@ -5532,7 +5613,7 @@ ${m.content}`).join("\n\n---\n\n"),
   const totalTokens = projectSlice.estimatedTokens + modulesSlice.estimatedTokens + memoriesSlice.estimatedTokens;
   const decayWarnings = [];
   for (const m of trimmedMemories) {
-    const u = getUsage5(usage, m.id);
+    const u = getUsage6(usage, m.id);
     const loaded = byId.get(m.id);
     const createdAt = loaded?.memory.frontmatter.created_at ?? (/* @__PURE__ */ new Date()).toISOString();
     if (isDecaying(u, createdAt)) decayWarnings.push(m.id);
@@ -5597,8 +5678,8 @@ ${m.content}`).join("\n\n---\n\n"),
       actionRequired.push(extractActionItem(m.id, loaded.memory.body));
     }
   }
-  if (existsSync19(ctx.paths.memoriesDir)) {
-    const allMems = await loadMemoriesFromDir13(ctx.paths.memoriesDir);
+  if (existsSync20(ctx.paths.memoriesDir)) {
+    const allMems = await loadMemoriesFromDir14(ctx.paths.memoriesDir);
     for (const { memory: memory2 } of allMems) {
       const fm = memory2.frontmatter;
       if (!fm.requires_human_approval) continue;
@@ -5608,7 +5689,7 @@ ${m.content}`).join("\n\n---\n\n"),
     }
   }
   const pendingDistillFile = pendingDistillPath(ctx);
-  if (existsSync19(pendingDistillFile)) {
+  if (existsSync20(pendingDistillFile)) {
     try {
       const raw = await readFile42(pendingDistillFile, "utf8");
       const pd = JSON.parse(raw);
@@ -5637,7 +5718,7 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
     }
   }
   const memoriesEmpty = outputMemories.length === 0;
-  const hasMemoriesDir = existsSync19(ctx.paths.memoriesDir);
+  const hasMemoriesDir = existsSync20(ctx.paths.memoriesDir);
   const isColdStart = isTemplateContext && memoriesEmpty && !lastSession && !autoContextGenerated;
   const hasUnguessableSignal = outputMemories.some(
     (m) => (m.priority === "must_read" || m.priority === "useful") && specificityScore2(m.body) >= GUESSABLE_THRESHOLD
@@ -5684,7 +5765,7 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
       "No team-specific policy matched these files/task \u2014 nothing here a capable model can't infer. The auto-generated project context was trimmed to keep this briefing near-zero-cost; proceed with normal Read/Grep."
     );
   }
-  if (existsSync19(ctx.paths.haiveDir)) {
+  if (existsSync20(ctx.paths.haiveDir)) {
     await writeBriefingMarker2(ctx.paths, {
       sessionId: process.env.HAIVE_SESSION_ID,
       ...input.task ? { task: input.task } : {},
@@ -5733,17 +5814,17 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
   };
 }
 var CodeMapInputSchema = {
-  file: z18.string().optional().describe("Filter to files whose path contains this substring"),
-  symbol: z18.string().optional().describe("Filter to files exporting a symbol whose name contains this substring"),
-  paths: z18.array(z18.string()).default([]).describe(
+  file: z19.string().optional().describe("Filter to files whose path contains this substring"),
+  symbol: z19.string().optional().describe("Filter to files exporting a symbol whose name contains this substring"),
+  paths: z19.array(z19.string()).default([]).describe(
     "Filter to files under any of these path prefixes (e.g. ['packages/mcp/src/tools/', 'src/auth/']). OR-joined with `file` substring; useful to get a focused view of one module."
   ),
-  max_files: z18.number().int().positive().default(40).describe("Cap on returned files (hard limit, applied after token budget)"),
-  max_tokens: z18.number().int().positive().optional().describe(
+  max_files: z19.number().int().positive().default(40).describe("Cap on returned files (hard limit, applied after token budget)"),
+  max_tokens: z19.number().int().positive().optional().describe(
     "Approximate token budget for the response. When the matching set exceeds it, files are ranked by export density (exports per LOC) and the highest-signal ones are kept first. Omit to disable budgeting (legacy behavior)."
   )
 };
-var CodeMapInputZod = z18.object(CodeMapInputSchema);
+var CodeMapInputZod = z19.object(CodeMapInputSchema);
 async function codeMapTool(input, ctx) {
   const map = await loadCodeMap22(ctx.paths);
   if (!map) {
@@ -5811,14 +5892,14 @@ function estimateFileEntryTokens(f) {
   return estimateTokens2(f.path) + estimateTokens2(f.entry.summary ?? "") + exportsCost + 4;
 }
 var MemDiffInputSchema = {
-  id_a: z19.string().min(1).describe("First memory id"),
-  id_b: z19.string().min(1).describe("Second memory id")
+  id_a: z20.string().min(1).describe("First memory id"),
+  id_b: z20.string().min(1).describe("Second memory id")
 };
 async function memDiff(input, ctx) {
-  if (!existsSync20(ctx.paths.memoriesDir)) {
+  if (!existsSync21(ctx.paths.memoriesDir)) {
     throw new Error(`No .ai/memories at ${ctx.paths.root}.`);
   }
-  const all = await loadMemoriesFromDir14(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir15(ctx.paths.memoriesDir);
   const foundA = all.find((m) => m.memory.frontmatter.id === input.id_a);
   const foundB = all.find((m) => m.memory.frontmatter.id === input.id_b);
   if (!foundA) throw new Error(`No memory with id "${input.id_a}".`);
@@ -5851,15 +5932,15 @@ async function memDiff(input, ctx) {
   };
 }
 var GetRecapInputSchema = {
-  scope: z20.enum(["personal", "team", "any"]).default("any").describe(
+  scope: z21.enum(["personal", "team", "any"]).default("any").describe(
     "Limit to a specific scope's recap. Default 'any' returns the most recent recap across both personal and team scopes."
   )
 };
 async function getRecap(input, ctx) {
-  if (!existsSync21(ctx.paths.memoriesDir)) {
+  if (!existsSync222(ctx.paths.memoriesDir)) {
     return { recap: null, notice: "No .ai/memories directory \u2014 haive not initialized here." };
   }
-  const all = await loadMemoriesFromDir15(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir16(ctx.paths.memoriesDir);
   const recaps = all.filter(({ memory: memory2 }) => memory2.frontmatter.type === "session_recap").filter(({ memory: memory2 }) => input.scope === "any" || memory2.frontmatter.scope === input.scope).sort(
     (a, b) => new Date(b.memory.frontmatter.created_at).getTime() - new Date(a.memory.frontmatter.created_at).getTime()
   );
@@ -5882,11 +5963,11 @@ async function getRecap(input, ctx) {
   };
 }
 var MemRelevantToInputSchema = {
-  task: z21.string().min(1).describe("What you are about to do, in 1\u20132 sentences. Used to rank relevant memories."),
-  files: z21.array(z21.string()).default([]).describe("Optional: files you are about to edit \u2014 surfaces anchored memories."),
-  limit: z21.number().int().positive().max(30).default(8).describe("Cap on returned memories."),
-  min_semantic_score: z21.number().min(0).max(1).default(0.25).describe("Drop weakly-related semantic hits below this cosine threshold."),
-  format: z21.enum(["full", "compact", "actions"]).default("full").describe("'compact' = id + 1-line summary; 'full' = complete bodies; 'actions' = bullet-first excerpts.")
+  task: z22.string().min(1).describe("What you are about to do, in 1\u20132 sentences. Used to rank relevant memories."),
+  files: z22.array(z22.string()).default([]).describe("Optional: files you are about to edit \u2014 surfaces anchored memories."),
+  limit: z22.number().int().positive().max(30).default(8).describe("Cap on returned memories."),
+  min_semantic_score: z22.number().min(0).max(1).default(0.25).describe("Drop weakly-related semantic hits below this cosine threshold."),
+  format: z22.enum(["full", "compact", "actions"]).default("full").describe("'compact' = id + 1-line summary; 'full' = complete bodies; 'actions' = bullet-first excerpts.")
 };
 async function memRelevantTo(input, ctx) {
   const briefingInput = {
@@ -5915,11 +5996,11 @@ async function memRelevantTo(input, ctx) {
   return out;
 }
 var CodeSearchInputSchema = {
-  query: z22.string().min(1).describe(
+  query: z23.string().min(1).describe(
     "Natural-language description of what you are looking for in the codebase (e.g. 'function that hashes passwords', 'JWT signing logic', 'route registration')."
   ),
-  k: z22.number().int().positive().max(50).default(5).describe("Number of top hits to return."),
-  min_score: z22.number().min(0).max(1).default(0.2).describe(
+  k: z23.number().int().positive().max(50).default(5).describe("Number of top hits to return."),
+  min_score: z23.number().min(0).max(1).default(0.2).describe(
     "Minimum cosine similarity. Hits below this threshold are dropped to avoid noise. Try 0.3+ for stricter matching."
   )
 };
@@ -5948,14 +6029,14 @@ async function codeSearch(input, ctx) {
   return { available: true, hits: result.hits };
 }
 var WhyThisFileInputSchema = {
-  path: z23.string().min(1).describe(
+  path: z24.string().min(1).describe(
     "Project-relative path to the file you want context on (e.g. 'packages/mcp/src/tools/mem-save.ts')."
   ),
-  git_log_limit: z23.number().int().positive().max(20).default(5).describe("How many recent commits touching this file to include."),
-  memory_limit: z23.number().int().positive().max(20).default(5).describe("Cap on memories anchored to this path.")
+  git_log_limit: z24.number().int().positive().max(20).default(5).describe("How many recent commits touching this file to include."),
+  memory_limit: z24.number().int().positive().max(20).default(5).describe("Cap on memories anchored to this path.")
 };
 async function whyThisFile(input, ctx) {
-  const fileExists = existsSync222(path102.join(ctx.paths.root, input.path));
+  const fileExists = existsSync23(path102.join(ctx.paths.root, input.path));
   const [commits, memories, codeMap] = await Promise.all([
     runGitLog(ctx.paths.root, input.path, input.git_log_limit).catch(() => []),
     collectAnchoredMemories(ctx, input.path, input.memory_limit),
@@ -5996,16 +6077,16 @@ async function whyThisFile(input, ctx) {
   };
 }
 async function collectAnchoredMemories(ctx, filePath, limit) {
-  if (!existsSync222(ctx.paths.memoriesDir)) return [];
-  const all = await loadMemoriesFromDir16(ctx.paths.memoriesDir);
-  const usage = await loadUsageIndex8(ctx.paths);
+  if (!existsSync23(ctx.paths.memoriesDir)) return [];
+  const all = await loadMemoriesFromDir17(ctx.paths.memoriesDir);
+  const usage = await loadUsageIndex9(ctx.paths);
   const out = [];
   for (const { memory: memory2 } of all) {
     const fm = memory2.frontmatter;
     if (fm.status === "rejected" || fm.status === "deprecated") continue;
     if (fm.type === "session_recap") continue;
     if (!memoryMatchesAnchorPaths3(memory2, [filePath])) continue;
-    const u = getUsage6(usage, fm.id);
+    const u = getUsage7(usage, fm.id);
     out.push({
       id: fm.id,
       type: fm.type,
@@ -6050,17 +6131,17 @@ function runCommand(cmd, args, cwd) {
   });
 }
 var AntiPatternsCheckInputSchema = {
-  diff: z24.string().optional().describe(
+  diff: z25.string().optional().describe(
     "Raw unified diff text (or any code/text snippet) to scan for previously documented anti-patterns. Tokens from the diff are used to match memory bodies and the embeddings index."
   ),
-  paths: z24.array(z24.string()).default([]).describe(
+  paths: z25.array(z25.string()).default([]).describe(
     "File paths affected by the change. Memories anchored to any of these paths are surfaced regardless of the diff content."
   ),
-  limit: z24.number().int().positive().max(20).default(8).describe("Cap on returned warnings."),
-  semantic: z24.boolean().default(true).describe(
+  limit: z25.number().int().positive().max(20).default(8).describe("Cap on returned warnings."),
+  semantic: z25.boolean().default(true).describe(
     "When true, also use semantic search (requires @hiveai/embeddings + memory index) to find related anti-patterns."
   ),
-  min_semantic_score: z24.number().min(0).max(1).default(0.45).describe(
+  min_semantic_score: z25.number().min(0).max(1).default(0.45).describe(
     "Minimum cosine score for semantic-only anti-pattern hits. Anchor/literal matches still surface. Default 0.45 keeps broad, weakly-related memories out of review noise."
   )
 };
@@ -6128,10 +6209,10 @@ async function antiPatternsCheck(input, ctx) {
       notice: "Nothing to check \u2014 provide either `diff` text or `paths`."
     };
   }
-  if (!existsSync23(ctx.paths.memoriesDir)) {
+  if (!existsSync24(ctx.paths.memoriesDir)) {
     return { scanned: 0, warnings: [], notice: "No .ai/memories directory \u2014 nothing to check against." };
   }
-  const all = await loadMemoriesFromDir17(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir18(ctx.paths.memoriesDir);
   const minSemanticScore = input.min_semantic_score ?? 0.45;
   const negative = all.filter(({ memory: memory2 }) => {
     const t = memory2.frontmatter.type;
@@ -6142,7 +6223,7 @@ async function antiPatternsCheck(input, ctx) {
   if (negative.length === 0) {
     return { scanned: 0, warnings: [], notice: "No attempt/gotcha memories found yet." };
   }
-  const usage = await loadUsageIndex9(ctx.paths);
+  const usage = await loadUsageIndex10(ctx.paths);
   const seen = /* @__PURE__ */ new Map();
   const upsert = (fm, body, reason, score) => {
     const existing = seen.get(fm.id);
@@ -6153,7 +6234,7 @@ async function antiPatternsCheck(input, ctx) {
       }
       return;
     }
-    const u = getUsage7(usage, fm.id);
+    const u = getUsage8(usage, fm.id);
     seen.set(fm.id, {
       id: fm.id,
       type: fm.type,
@@ -6231,12 +6312,12 @@ async function antiPatternsCheck(input, ctx) {
   };
 }
 var MemDistillInputSchema = {
-  since_days: z25.number().int().positive().default(30).describe("Only consider memories created in the last N days."),
-  min_cluster: z25.number().int().min(2).default(3).describe("Minimum cluster size to surface."),
-  type_filter: z25.enum(["gotcha", "attempt", "all"]).default("gotcha").describe(
+  since_days: z26.number().int().positive().default(30).describe("Only consider memories created in the last N days."),
+  min_cluster: z26.number().int().min(2).default(3).describe("Minimum cluster size to surface."),
+  type_filter: z26.enum(["gotcha", "attempt", "all"]).default("gotcha").describe(
     "Memory type to scan. 'gotcha' targets observe-style discoveries that recur, 'attempt' surfaces failed approaches that repeat, 'all' considers both."
   ),
-  scope: z25.enum(["personal", "team", "module", "any"]).default("any").describe("Restrict to a specific scope.")
+  scope: z26.enum(["personal", "team", "module", "any"]).default("any").describe("Restrict to a specific scope.")
 };
 var MS_PER_DAY = 24 * 60 * 60 * 1e3;
 var STOP_WORDS = /* @__PURE__ */ new Set([
@@ -6276,11 +6357,11 @@ var STOP_WORDS = /* @__PURE__ */ new Set([
   "error"
 ]);
 async function memDistill(input, ctx) {
-  if (!existsSync24(ctx.paths.memoriesDir)) {
+  if (!existsSync25(ctx.paths.memoriesDir)) {
     return { scanned: 0, singletons: 0, clusters: [], notice: "No .ai/memories directory." };
   }
   const cutoff = Date.now() - input.since_days * MS_PER_DAY;
-  const all = await loadMemoriesFromDir18(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir19(ctx.paths.memoriesDir);
   const candidates = all.filter(({ memory: memory2 }) => {
     const fm = memory2.frontmatter;
     if (fm.status === "rejected" || fm.status === "deprecated" || fm.status === "stale") return false;
@@ -6383,11 +6464,11 @@ function firstHeading(body) {
   return void 0;
 }
 var WhyThisDecisionInputSchema = {
-  id: z26.string().min(1).describe("Memory id to inspect (e.g. '2026-04-25-decision-esm-only')."),
-  git_log_limit: z26.number().int().positive().max(20).default(5).describe("How many recent commits per anchor path to surface.")
+  id: z27.string().min(1).describe("Memory id to inspect (e.g. '2026-04-25-decision-esm-only')."),
+  git_log_limit: z27.number().int().positive().max(20).default(5).describe("How many recent commits per anchor path to surface.")
 };
 async function whyThisDecision(input, ctx) {
-  if (!existsSync25(ctx.paths.memoriesDir)) {
+  if (!existsSync26(ctx.paths.memoriesDir)) {
     return {
       found: false,
       related: [],
@@ -6396,8 +6477,8 @@ async function whyThisDecision(input, ctx) {
       notice: "No .ai/memories directory."
     };
   }
-  const all = await loadMemoriesFromDir19(ctx.paths.memoriesDir);
-  const usage = await loadUsageIndex10(ctx.paths);
+  const all = await loadMemoriesFromDir20(ctx.paths.memoriesDir);
+  const usage = await loadUsageIndex11(ctx.paths);
   const target = all.find(({ memory: memory2 }) => memory2.frontmatter.id === input.id);
   if (!target) {
     return {
@@ -6409,7 +6490,7 @@ async function whyThisDecision(input, ctx) {
     };
   }
   const fm = target.memory.frontmatter;
-  const targetUsage = getUsage8(usage, fm.id);
+  const targetUsage = getUsage9(usage, fm.id);
   const decision = {
     id: fm.id,
     type: fm.type,
@@ -6426,7 +6507,7 @@ async function whyThisDecision(input, ctx) {
     const isExplicit = relatedSet.has(memory2.frontmatter.id);
     const isBackLink = (memory2.frontmatter.related_ids ?? []).includes(fm.id);
     if (!isExplicit && !isBackLink) continue;
-    const u = getUsage8(usage, memory2.frontmatter.id);
+    const u = getUsage9(usage, memory2.frontmatter.id);
     related.push({
       id: memory2.frontmatter.id,
       type: memory2.frontmatter.type,
@@ -6446,7 +6527,7 @@ async function whyThisDecision(input, ctx) {
         (p) => targetPaths.some((tp) => singlePathsOverlap(p, tp))
       );
       if (overlappingPaths.length === 0) continue;
-      const u = getUsage8(usage, memory2.frontmatter.id);
+      const u = getUsage9(usage, memory2.frontmatter.id);
       path_neighbors.push({
         id: memory2.frontmatter.id,
         type: memory2.frontmatter.type,
@@ -6518,22 +6599,22 @@ function runCommand2(cmd, args, cwd) {
   });
 }
 var MemConflictsInputSchema = {
-  id: z27.string().min(1).describe("Memory id to check for conflicts."),
-  min_score: z27.number().min(0).max(1).default(0.5).describe("Minimum cosine similarity to consider a memory as a potential conflict (semantic mode)."),
-  semantic: z27.boolean().default(true).describe("Use embeddings for similarity. Falls back to keyword overlap when embeddings are not installed.")
+  id: z28.string().min(1).describe("Memory id to check for conflicts."),
+  min_score: z28.number().min(0).max(1).default(0.5).describe("Minimum cosine similarity to consider a memory as a potential conflict (semantic mode)."),
+  semantic: z28.boolean().default(true).describe("Use embeddings for similarity. Falls back to keyword overlap when embeddings are not installed.")
 };
 var POSITIVE_PATTERNS = /\b(use|prefer|always|should use|do this|recommended|ok to)\b/i;
 var NEGATIVE_PATTERNS = /\b(do not use|don'?t use|never|avoid|forbidden|deprecated|stop using|do NOT|❌)\b/i;
 async function memConflicts(input, ctx) {
-  if (!existsSync26(ctx.paths.memoriesDir)) {
+  if (!existsSync27(ctx.paths.memoriesDir)) {
     return { found: false, scanned: 0, conflicts: [], notice: "No .ai/memories directory." };
   }
-  const all = await loadMemoriesFromDir20(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir21(ctx.paths.memoriesDir);
   const target = all.find(({ memory: memory2 }) => memory2.frontmatter.id === input.id);
   if (!target) {
     return { found: false, scanned: 0, conflicts: [], notice: `Memory '${input.id}' not found.` };
   }
-  const usage = await loadUsageIndex11(ctx.paths);
+  const usage = await loadUsageIndex12(ctx.paths);
   const others = all.filter(
     ({ memory: memory2 }) => memory2.frontmatter.id !== input.id && memory2.frontmatter.type !== "session_recap"
   );
@@ -6574,7 +6655,7 @@ async function memConflicts(input, ctx) {
       }
     }
     if (reasons.length === 0) continue;
-    const u = getUsage9(usage, fm.id);
+    const u = getUsage10(usage, fm.id);
     conflicts.push({
       id: fm.id,
       type: fm.type,
@@ -6639,15 +6720,15 @@ async function trySemanticSimilarities(ctx, target, others) {
   return map;
 }
 var PreCommitCheckInputSchema = {
-  diff: z28.string().optional().describe(
+  diff: z29.string().optional().describe(
     "Raw unified diff text to scan. If omitted, only `paths` is used. When called from a pre-commit hook, pipe the output of `git diff --cached`."
   ),
-  paths: z28.array(z28.string()).default([]).describe("Project-relative paths affected by the change. At least one of `diff` or `paths` should be provided."),
-  block_on: z28.enum(["any", "high-confidence", "never"]).default("high-confidence").describe(
+  paths: z29.array(z29.string()).default([]).describe("Project-relative paths affected by the change. At least one of `diff` or `paths` should be provided."),
+  block_on: z29.enum(["any", "high-confidence", "never"]).default("high-confidence").describe(
     "When to set should_block=true: 'any' = any warning blocks; 'high-confidence' = only warnings from authoritative/trusted memories block; 'never' = report only, never block."
   ),
-  semantic: z28.boolean().default(true).describe("Enable semantic search in anti_patterns_check (requires embeddings index)."),
-  anchored_blocks: z28.boolean().default(false).describe(
+  semantic: z29.boolean().default(true).describe("Enable semantic search in anti_patterns_check (requires embeddings index)."),
+  anchored_blocks: z29.boolean().default(false).describe(
     "When true, ALSO block a high-confidence anti-pattern (attempt/gotcha) that is anchored to a touched file AND corroborated by the diff (literal token overlap, or semantic >= 0.45) \u2014 not just very strong semantic matches. Powers the 'anchored' enforcement gate. Config/docs-only commits are still downgraded. Default false preserves the soft, semantic-only blocking behavior."
   )
 };
@@ -6715,7 +6796,9 @@ async function preCommitCheck(input, ctx) {
   };
 }
 function classifyWarning(warning, paths, anchoredBlocks = false) {
-  const affectedFiles = paths.filter((p) => !p.startsWith(".ai/.usage/"));
+  const affectedFiles = paths.filter(
+    (p) => !p.startsWith(".ai/.usage/") && !p.startsWith(".ai/.cache/") && !p.startsWith(".ai/.runtime/")
+  );
   const repairCommand = repairCommandForWarning(warning, affectedFiles);
   const fileDowngrade = fileTypeDowngradeReason(warning, affectedFiles);
   if (fileDowngrade) {
@@ -6746,6 +6829,15 @@ function classifyWarning(warning, paths, anchoredBlocks = false) {
     };
   }
   if (isBlockingWarning(warning)) {
+    if (warning.scope === "personal") {
+      return {
+        ...warning,
+        level: "review",
+        rationale: "personal anti-pattern memories are review guidance unless a deterministic block-severity sensor fires",
+        affected_files: affectedFiles,
+        repair_command: repairCommand
+      };
+    }
     if (warning.has_sensor && !warning.reasons.includes("sensor")) {
       return {
         ...warning,
@@ -6766,7 +6858,7 @@ function classifyWarning(warning, paths, anchoredBlocks = false) {
   const hasSemantic = warning.reasons.includes("semantic");
   const semanticScore = warning.semantic_score ?? 0;
   const highConfidence = warning.confidence === "authoritative" || warning.confidence === "trusted";
-  if (anchoredBlocks && highConfidence && warning.reasons.includes("anchor") && (warning.reasons.includes("literal") || hasSemantic && semanticScore >= 0.45)) {
+  if (anchoredBlocks && highConfidence && warning.scope !== "personal" && warning.reasons.includes("anchor") && (warning.reasons.includes("literal") || hasSemantic && semanticScore >= 0.45)) {
     if (warning.has_sensor && !warning.reasons.includes("sensor")) {
       return {
         ...warning,
@@ -6900,8 +6992,20 @@ function isJsonConfigFile(base) {
   return false;
 }
 function repairCommandForWarning(warning, paths) {
-  const firstPath = paths[0];
-  return firstPath ? `haive briefing --files "${firstPath}" --task "review ${warning.id}"` : `haive memory show ${warning.id}`;
+  const targetPath = repairTargetPathForWarning(warning, paths);
+  return targetPath ? `haive briefing --files "${targetPath}" --task "review ${warning.id}"` : `haive memory show ${warning.id}`;
+}
+function repairTargetPathForWarning(warning, paths) {
+  const usablePaths = paths.filter(
+    (p) => !p.startsWith(".ai/.usage/") && !p.startsWith(".ai/.cache/") && !p.startsWith(".ai/.runtime/")
+  );
+  const anchors = warning.anchor_paths ?? [];
+  for (const file of usablePaths) {
+    if (anchors.some((anchor) => anchor === file || file.startsWith(`${anchor}/`) || anchor.startsWith(`${file}/`))) {
+      return file;
+    }
+  }
+  return usablePaths[0];
 }
 var CONFIG_PATTERNS = [
   ".eslintrc",
@@ -6925,12 +7029,12 @@ var CONFIG_PATTERNS = [
 var MAX_DIFF_BYTES = 4096;
 var HOT_FILE_MIN = 3;
 var PatternDetectInputSchema = {
-  since_days: z29.number().int().min(1).default(7).describe("Look-back window in days for both git history and usage log."),
-  dry_run: z29.boolean().default(false).describe("When true, report matches without writing any memory files."),
-  scope: z29.enum(["personal", "team"]).default("team").describe("Scope for proposed memories.")
+  since_days: z30.number().int().min(1).default(7).describe("Look-back window in days for both git history and usage log."),
+  dry_run: z30.boolean().default(false).describe("When true, report matches without writing any memory files."),
+  scope: z30.enum(["personal", "team"]).default("team").describe("Scope for proposed memories.")
 };
 async function patternDetect(input, ctx) {
-  if (!existsSync27(ctx.paths.haiveDir)) {
+  if (!existsSync28(ctx.paths.haiveDir)) {
     return {
       scanned_events: 0,
       matches: [],
@@ -7059,7 +7163,7 @@ async function patternDetect(input, ctx) {
         fm.id,
         void 0
       );
-      if (existsSync27(file)) continue;
+      if (existsSync28(file)) continue;
       await mkdir72(path112.dirname(file), { recursive: true });
       await writeFile12(
         file,
@@ -7104,17 +7208,17 @@ function gitFileDiff(root, file, sinceDays) {
   }
 }
 var MemConflictCandidatesInputSchema = {
-  since_days: z30.number().int().positive().max(3650).default(365).describe("Only memories created since N days ago"),
-  types: z30.array(z30.enum(["decision", "architecture", "convention", "gotcha"])).default(["decision", "architecture"]).describe("Memory types scanned for pairwise lexical overlap"),
-  min_jaccard: z30.number().min(0).max(1).default(0.45).describe("Minimum Jaccard token similarity to surface as a candidate pair"),
-  max_pairs: z30.number().int().positive().max(100).default(20).describe("Cap pairs returned"),
-  max_scan: z30.number().int().positive().max(2e3).default(500).describe("Maximum memories sampled for O(n\xB2) scan \u2014 excess dropped after chronological sort."),
-  max_topic_pairs: z30.number().int().positive().max(100).default(20).describe(
+  since_days: z31.number().int().positive().max(3650).default(365).describe("Only memories created since N days ago"),
+  types: z31.array(z31.enum(["decision", "architecture", "convention", "gotcha"])).default(["decision", "architecture"]).describe("Memory types scanned for pairwise lexical overlap"),
+  min_jaccard: z31.number().min(0).max(1).default(0.45).describe("Minimum Jaccard token similarity to surface as a candidate pair"),
+  max_pairs: z31.number().int().positive().max(100).default(20).describe("Cap pairs returned"),
+  max_scan: z31.number().int().positive().max(2e3).default(500).describe("Maximum memories sampled for O(n\xB2) scan \u2014 excess dropped after chronological sort."),
+  max_topic_pairs: z31.number().int().positive().max(100).default(20).describe(
     "Cap for extra signal: memories sharing the same topic with validated vs rejected status."
   )
 };
 async function memConflictCandidates(input, ctx) {
-  if (!existsSync28(ctx.paths.memoriesDir)) {
+  if (!existsSync29(ctx.paths.memoriesDir)) {
     return {
       pairs: [],
       topic_status_pairs: [],
@@ -7123,7 +7227,7 @@ async function memConflictCandidates(input, ctx) {
       notice: "No .ai/memories directory."
     };
   }
-  const all = await loadMemoriesFromDir21(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir222(ctx.paths.memoriesDir);
   const { pairs, scanned, truncated } = findLexicalConflictPairs(all, {
     sinceDays: input.since_days,
     types: input.types,
@@ -7136,7 +7240,7 @@ async function memConflictCandidates(input, ctx) {
   return { pairs, topic_status_pairs: topicStatusPairs, scanned, truncated, notice };
 }
 var MemResolveProjectInputSchema = {
-  cwd: z31.string().optional().describe("Directory used for root discovery when HAIVE_PROJECT_ROOT is unset.")
+  cwd: z32.string().optional().describe("Directory used for root discovery when HAIVE_PROJECT_ROOT is unset.")
 };
 async function memResolveProject(input, _ctx) {
   void _ctx;
@@ -7149,7 +7253,7 @@ async function memResolveProject(input, _ctx) {
 }
 var MemSuggestTopicInputSchema = {
   type: MemoryTypeSchema.describe("Memory kind \u2014 drives the suggested topic family."),
-  title: z32.string().min(1).describe("Short title or phrase (headers, headings) \u2014 turned into slug")
+  title: z33.string().min(1).describe("Short title or phrase (headers, headings) \u2014 turned into slug")
 };
 async function memSuggestTopic(input, _ctx) {
   void _ctx;
@@ -7157,15 +7261,15 @@ async function memSuggestTopic(input, _ctx) {
   return { topic_key: suggestion.topic_key, family: suggestion.family, type: input.type };
 }
 var MemTimelineInputSchema = {
-  memory_id: z33.string().optional().describe("Seed id \u2014 expands via related_ids, topic, anchors"),
-  topic: z33.string().optional().describe("Frontmatter.topic value \u2014 chronological list when memory_id omitted"),
-  limit: z33.number().int().positive().max(100).default(30).describe("Max timeline entries returned")
+  memory_id: z34.string().optional().describe("Seed id \u2014 expands via related_ids, topic, anchors"),
+  topic: z34.string().optional().describe("Frontmatter.topic value \u2014 chronological list when memory_id omitted"),
+  limit: z34.number().int().positive().max(100).default(30).describe("Max timeline entries returned")
 };
 async function memTimeline(input, ctx) {
-  if (!existsSync29(ctx.paths.memoriesDir)) {
+  if (!existsSync30(ctx.paths.memoriesDir)) {
     return { entries: [], total: 0, notice: "No .ai/memories directory." };
   }
-  const all = await loadMemoriesFromDir222(ctx.paths.memoriesDir);
+  const all = await loadMemoriesFromDir23(ctx.paths.memoriesDir);
   const { entries, notice } = collectTimelineEntries(all, {
     memoryId: input.memory_id,
     topic: input.topic,
@@ -7174,9 +7278,9 @@ async function memTimeline(input, ctx) {
   return { entries, total: entries.length, notice };
 }
 var RuntimeJournalAppendInputSchema = {
-  message: z34.string().min(1).describe("Short line to append to the runtime session journal"),
-  kind: z34.enum(["note", "session_end", "mcp"]).default("note"),
-  tool: z34.string().optional().describe("When kind=mcp, which tool name (optional)")
+  message: z35.string().min(1).describe("Short line to append to the runtime session journal"),
+  kind: z35.enum(["note", "session_end", "mcp"]).default("note"),
+  tool: z35.string().optional().describe("When kind=mcp, which tool name (optional)")
 };
 async function runtimeJournalAppend(input, ctx) {
   await appendRuntimeJournalEntry2(ctx.paths, {
@@ -7190,7 +7294,7 @@ async function runtimeJournalAppend(input, ctx) {
   };
 }
 var RuntimeJournalTailInputSchema = {
-  limit: z35.number().int().positive().max(500).default(30).describe("Last N journal entries to return")
+  limit: z36.number().int().positive().max(500).default(30).describe("Last N journal entries to return")
 };
 async function runtimeJournalTail(input, ctx) {
   const entries = await readRuntimeJournalTail(ctx.paths, input.limit);
@@ -7200,10 +7304,10 @@ async function runtimeJournalTail(input, ctx) {
   return { entries };
 }
 var BootstrapProjectArgsSchema = {
-  module: z36.string().optional().describe(
+  module: z37.string().optional().describe(
     "Optional module name to scope the analysis to (writes to .ai/modules/<module>/context.md)"
   ),
-  focus: z36.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
+  focus: z37.string().optional().describe("Optional area to emphasize (e.g. 'data layer', 'API surface')")
 };
 var ROOT_TEMPLATE = `# Project context
 
@@ -7284,8 +7388,8 @@ ${template}\`\`\`
   };
 }
 var PostTaskArgsSchema = {
-  task_summary: z37.string().optional().describe("One sentence describing what you just did"),
-  files_touched: z37.array(z37.string()).optional().describe("Files you created or modified during the task")
+  task_summary: z38.string().optional().describe("One sentence describing what you just did"),
+  files_touched: z38.array(z38.string()).optional().describe("Files you created or modified during the task")
 };
 function postTaskPrompt(args, ctx) {
   const taskLine = args.task_summary ? `
@@ -7355,7 +7459,19 @@ This creates/updates a single rolling recap that **get_briefing automatically su
 
 Calling \`mem_session_end\` also **clears the pending-distill marker** (if any), confirming that this session's learnings have been properly captured rather than left as an auto-recap skeleton.
 
-When done, respond with a brief summary: "Saved N memories: [list of IDs]. Session recap saved."
+### 7. Verify the git/release exit protocol \u2014 always
+Run **\`haive enforce finish\`** before your final response.
+
+This executable gate checks the multi-agent git-sync decision:
+- no completed work is left as an uncommitted local diff
+- shippable package changes have a lockstep version bump
+- the release tag \`vX.Y.Z\` exists when a version was bumped
+- commits and tags have been pushed
+- agents never run \`npm publish\` (publication remains human-owned)
+
+If it blocks, fix the reported Git/version/tag/push issue before telling the developer the task is done.
+
+When done, respond with a brief summary: "Saved N memories: [list of IDs]. Session recap saved. hAIve finish gate passed."
 `;
   return {
     description: "Post-task reflection: capture what you learned before closing the session",
@@ -7368,10 +7484,10 @@ When done, respond with a brief summary: "Saved N memories: [list of IDs]. Sessi
   };
 }
 var ImportDocsArgsSchema = {
-  content: z38.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
-  source: z38.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
-  scope: z38.enum(["personal", "team"]).default("team").describe("Scope to assign to created memories"),
-  dry_run: z38.boolean().default(false).describe("If true, describe what would be saved without actually calling mem_save")
+  content: z39.string().describe("The documentation content to analyze and import as memories (Markdown, README, ADR, etc.)"),
+  source: z39.string().optional().describe("Origin of the content (file path, URL, or document title) \u2014 used to anchor memories"),
+  scope: z39.enum(["personal", "team"]).default("team").describe("Scope to assign to created memories"),
+  dry_run: z39.boolean().default(false).describe("If true, describe what would be saved without actually calling mem_save")
 };
 function importDocsPrompt(args, ctx) {
   const sourceLine = args.source ? `
@@ -7434,7 +7550,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
   };
 }
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.10.8";
+var SERVER_VERSION = "0.11.0";
 function jsonResult(data) {
   return {
     content: [
@@ -7476,7 +7592,8 @@ var MAINTENANCE_PROFILE_TOOLS = [
   "anti_patterns_check",
   "mem_distill",
   "mem_timeline",
-  "mem_conflict_candidates"
+  "mem_conflict_candidates",
+  "mem_feedback"
 ];
 var EXPERIMENTAL_PROFILE_TOOLS = [
   ...MAINTENANCE_PROFILE_TOOLS,
@@ -7508,6 +7625,7 @@ var MUTATING_TOOLS = /* @__PURE__ */ new Set([
   "mem_approve",
   "mem_reject",
   "mem_delete",
+  "mem_feedback",
   "runtime_journal_append",
   "pattern_detect"
 ]);
@@ -8003,6 +8121,28 @@ function createHaiveServer(options = {}) {
     MemRejectInputSchema,
     async (input) => jsonResult(await memReject(input, context))
   );
+  registerTool(
+    "mem_feedback",
+    [
+      "Record whether a memory actually HELPED \u2014 the closed-loop utility signal.",
+      "",
+      "USE right after a memory changed (or failed to change) what you did:",
+      "  - outcome='applied'  \u2192 the memory steered your work (strong positive signal)",
+      "  - outcome='rejected' \u2192 it was wrong/outdated/unhelpful (negative signal)",
+      "",
+      "A read only means a memory was surfaced; 'applied' means it demonstrably helped.",
+      "This powers `haive memory impact` (impact tiers + prune candidates) and future ranking.",
+      "",
+      "PARAMETERS:",
+      "  id      \u2014 full memory id the feedback is about",
+      "  outcome \u2014 'applied' | 'rejected'",
+      "  reason  \u2014 why it was rejected (optional, stored on the usage record)",
+      "",
+      "RETURNS: { ok, id, outcome, usage:{read_count,applied_count,rejected_count}, impact:{score,tier,signals} }"
+    ].join("\n"),
+    MemFeedbackInputSchema,
+    async (input) => jsonResult(await memFeedback(input, context))
+  );
   registerTool(
     "mem_pending",
     [
@@ -8409,21 +8549,21 @@ function registerMcp(program2) {
 // src/commands/sync.ts
 import { spawnSync as spawnSync4 } from "child_process";
 import { readFile as readFile9, writeFile as writeFile13, mkdir as mkdir10 } from "fs/promises";
-import { existsSync as existsSync30 } from "fs";
+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 findProjectRoot12,
-  getUsage as getUsage10,
+  getUsage as getUsage11,
   isAutoPromoteEligible as isAutoPromoteEligible2,
   isDecaying as isDecaying2,
   isStackPackSeed as isStackPackSeed3,
   loadCodeMap as loadCodeMap6,
   loadConfig as loadConfig4,
-  loadMemoriesFromDir as loadMemoriesFromDir23,
-  loadUsageIndex as loadUsageIndex12,
+  loadMemoriesFromDir as loadMemoriesFromDir24,
+  loadUsageIndex as loadUsageIndex13,
   pullCrossRepoSources,
   resolveHaivePaths as resolveHaivePaths9,
   resolveManifestFiles,
@@ -8446,7 +8586,7 @@ function registerSync(program2) {
   ).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").option("--dry-run", "report what would change without writing any files").action(async (opts) => {
     const root = findProjectRoot12(opts.dir);
     const paths = resolveHaivePaths9(root);
-    if (!existsSync30(paths.memoriesDir)) {
+    if (!existsSync31(paths.memoriesDir)) {
       if (!opts.quiet) ui.warn(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -8465,7 +8605,7 @@ function registerSync(program2) {
     let promoted = 0;
     let autoApproved = 0;
     if (opts.verify !== false) {
-      const memories = await loadMemoriesFromDir23(paths.memoriesDir);
+      const memories = await loadMemoriesFromDir24(paths.memoriesDir);
       for (const { memory: memory2, filePath } of memories) {
         if (memory2.frontmatter.type === "session_recap") {
           if (memory2.frontmatter.status === "stale") {
@@ -8532,13 +8672,13 @@ function registerSync(program2) {
       }
     }
     if (opts.promote !== false) {
-      const memories = await loadMemoriesFromDir23(paths.memoriesDir);
-      const usage = await loadUsageIndex12(paths);
+      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, getUsage10(usage, fm.id), {
+        if (isAutoPromoteEligible2(fm, getUsage11(usage, fm.id), {
           minReads: autoPromoteMinReads,
           maxRejections: DEFAULT_AUTO_PROMOTE_RULE2.maxRejections
         })) {
@@ -8584,7 +8724,7 @@ function registerSync(program2) {
       for (const repair of repairs) log(ui.dim(`autopilot: ${repair.message}`));
     }
     const sinceReport = opts.since ? collectSinceChanges(root, opts.since) : null;
-    const draftMemories = (await loadMemoriesFromDir23(paths.memoriesDir)).filter(
+    const draftMemories = (await loadMemoriesFromDir24(paths.memoriesDir)).filter(
       (m) => m.memory.frontmatter.status === "draft"
     );
     const draftCount = draftMemories.length;
@@ -8619,12 +8759,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) {
@@ -8870,8 +9010,8 @@ function bridgeSummaryLine(body) {
   return oneLine.length > 140 ? oneLine.slice(0, 137) + "\u2026" : oneLine;
 }
 async function injectBridge(bridgeFile, memoriesDir, maxMemories, root, quiet) {
-  if (!existsSync30(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;
@@ -8896,7 +9036,7 @@ async function injectBridge(bridgeFile, memoriesDir, maxMemories, root, quiet) {
 ` + block + `
 
 ${BRIDGE_END}`;
-  const fileExists = existsSync30(bridgeFile);
+  const fileExists = existsSync31(bridgeFile);
   let existing = fileExists ? await readFile9(bridgeFile, "utf8") : "";
   existing = existing.replace(/\r\n/g, "\n");
   const startIdx = existing.indexOf(BRIDGE_START);
@@ -8947,7 +9087,7 @@ function collectSinceChanges(root, ref) {
 // src/commands/memory-add.ts
 import { createHash as createHash2 } from "crypto";
 import { mkdir as mkdir11, readFile as readFile10, writeFile as writeFile14 } from "fs/promises";
-import { existsSync as existsSync31 } from "fs";
+import { existsSync as existsSync33 } from "fs";
 import path16 from "path";
 import "commander";
 import {
@@ -8955,7 +9095,7 @@ import {
   findProjectRoot as findProjectRoot13,
   inferModulesFromPaths as inferModulesFromPaths3,
   loadConfig as loadConfig5,
-  loadMemoriesFromDir as loadMemoriesFromDir24,
+  loadMemoriesFromDir as loadMemoriesFromDir25,
   memoryFilePath as memoryFilePath6,
   resolveHaivePaths as resolveHaivePaths10,
   serializeMemory as serializeMemory12,
@@ -8989,7 +9129,7 @@ function registerMemoryAdd(memory2) {
   ).requiredOption("--type <type>", "skill | convention | decision | gotcha | architecture | glossary | attempt").option("--slug <slug>", "short kebab-case identifier used in the file name (auto-derived from --title/--body when omitted)").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("--files <csv>", "alias for --paths (matches the MCP `files` parameter)").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 (!existsSync31(paths.haiveDir)) {
+    if (!existsSync33(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -9001,7 +9141,7 @@ function registerMemoryAdd(memory2) {
     const inferredTags = autoTagsEnabled ? inferModulesFromPaths3(anchorPaths) : [];
     const mergedTags = Array.from(/* @__PURE__ */ new Set([...userTags, ...inferredTags]));
     if (anchorPaths.length > 0) {
-      const missing = anchorPaths.filter((p) => !existsSync31(path16.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}`);
@@ -9014,7 +9154,7 @@ function registerMemoryAdd(memory2) {
     const slug = slugify(opts.slug ?? opts.title ?? opts.topic ?? opts.body ?? `${opts.type}-memory`);
     let body;
     if (opts.bodyFile !== void 0) {
-      if (!existsSync31(opts.bodyFile)) {
+      if (!existsSync33(opts.bodyFile)) {
         ui.error(`--body-file not found: ${opts.bodyFile}`);
         process.exitCode = 1;
         return;
@@ -9030,9 +9170,9 @@ TODO \u2014 write the memory body.
 `;
     }
     const scope = opts.scope ?? config.defaultScope ?? "personal";
-    if (existsSync31(paths.memoriesDir)) {
+    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
       );
@@ -9043,8 +9183,8 @@ TODO \u2014 write the memory body.
         return;
       }
     }
-    if (opts.topic && existsSync31(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)
       );
@@ -9088,13 +9228,13 @@ TODO \u2014 write the memory body.
     });
     const file = memoryFilePath6(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
     await mkdir11(path16.dirname(file), { recursive: true });
-    if (existsSync31(file)) {
+    if (existsSync33(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
       return;
     }
-    if (existsSync31(paths.memoriesDir)) {
-      const existing = await loadMemoriesFromDir24(paths.memoriesDir);
+    if (existsSync33(paths.memoriesDir)) {
+      const existing = await loadMemoriesFromDir25(paths.memoriesDir);
       const slugTokens = slug.toLowerCase().split(/[-_\s]+/).filter(Boolean);
       const similar = existing.filter(({ memory: memory3 }) => {
         const id = memory3.frontmatter.id.toLowerCase();
@@ -9185,14 +9325,14 @@ function slugify(value) {
 }
 
 // src/commands/memory-list.ts
-import { existsSync as existsSync33 } from "fs";
+import { existsSync as existsSync34 } from "fs";
 import path17 from "path";
 import "commander";
 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";
@@ -9202,12 +9342,12 @@ 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("--limit <n>", "max memories to display").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot14(opts.dir);
     const paths = resolveHaivePaths11(root);
-    if (!existsSync33(paths.memoriesDir)) {
+    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 limit = opts.limit ? Math.max(1, parseInt(opts.limit, 10)) : void 0;
     const filtered = all.filter((m) => {
@@ -9277,7 +9417,7 @@ 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 existsSync34 } from "fs";
+import { existsSync as existsSync35 } from "fs";
 import path18 from "path";
 import "commander";
 import {
@@ -9290,12 +9430,12 @@ 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 = findProjectRoot15(opts.dir);
     const paths = resolveHaivePaths12(root);
-    if (!existsSync34(paths.memoriesDir)) {
+    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")
     );
@@ -9309,7 +9449,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.)`);
@@ -9335,7 +9475,7 @@ function registerMemoryPromote(memory2) {
 }
 
 // src/commands/memory-approve.ts
-import { existsSync as existsSync35 } from "fs";
+import { existsSync as existsSync36 } from "fs";
 import { writeFile as writeFile16 } from "fs/promises";
 import path19 from "path";
 import "commander";
@@ -9348,12 +9488,12 @@ 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 = findProjectRoot16(opts.dir);
     const paths = resolveHaivePaths13(root);
-    if (!existsSync35(paths.memoriesDir)) {
+    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;
@@ -9407,7 +9547,7 @@ function registerMemoryApprove(memory2) {
 
 // src/commands/memory-update.ts
 import { readFile as readFile11, writeFile as writeFile17 } from "fs/promises";
-import { existsSync as existsSync36 } from "fs";
+import { existsSync as existsSync37 } from "fs";
 import path20 from "path";
 import "commander";
 import {
@@ -9419,12 +9559,12 @@ function registerMemoryUpdate(memory2) {
   memory2.command("update <id>").description("Update body, tags, or anchor of an existing memory (preserves id and usage history)").option("--type <type>", "change the memory type (convention | decision | gotcha | architecture | glossary | skill | attempt)").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("--body-file <path>", "read new body from a Markdown file \u2014 for long content").option("--tags <csv>", "new tags, comma-separated \u2014 fully replaces existing tags").option("--paths <csv>", "new anchor paths, comma-separated").option("--files <csv>", "alias for --paths (matches the MCP `files` parameter)").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 = findProjectRoot17(opts.dir);
     const paths = resolveHaivePaths14(root);
-    if (!existsSync36(paths.memoriesDir)) {
+    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}".`);
@@ -9461,7 +9601,7 @@ function registerMemoryUpdate(memory2) {
     if (opts.author !== void 0) updated.push("author");
     let newBody;
     if (opts.bodyFile !== void 0) {
-      if (!existsSync36(opts.bodyFile)) {
+      if (!existsSync37(opts.bodyFile)) {
         ui.error(`--body-file not found: ${opts.bodyFile}`);
         process.exitCode = 1;
         return;
@@ -9507,15 +9647,15 @@ function parseCsv3(value) {
 
 // src/commands/memory-auto-promote.ts
 import { writeFile as writeFile18 } from "fs/promises";
-import { existsSync as existsSync37 } from "fs";
+import { existsSync as existsSync38 } from "fs";
 import path21 from "path";
 import "commander";
 import {
   DEFAULT_AUTO_PROMOTE_RULE as DEFAULT_AUTO_PROMOTE_RULE3,
   findProjectRoot as findProjectRoot18,
-  getUsage as getUsage11,
+  getUsage as getUsage12,
   isAutoPromoteEligible as isAutoPromoteEligible3,
-  loadUsageIndex as loadUsageIndex13,
+  loadUsageIndex as loadUsageIndex14,
   resolveHaivePaths as resolveHaivePaths15,
   serializeMemory as serializeMemory16
 } from "@hiveai/core";
@@ -9527,7 +9667,7 @@ function registerMemoryAutoPromote(memory2) {
   ).option("--apply", "actually write status=validated to disk (default: dry-run)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot18(opts.dir);
     const paths = resolveHaivePaths15(root);
-    if (!existsSync37(paths.memoriesDir)) {
+    if (!existsSync38(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -9536,10 +9676,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(
@@ -9549,7 +9689,7 @@ 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}`)}`
       );
@@ -9570,7 +9710,7 @@ function registerMemoryAutoPromote(memory2) {
 
 // src/commands/memory-edit.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync38 } from "fs";
+import { existsSync as existsSync39 } from "fs";
 import { readFile as readFile12 } from "fs/promises";
 import path23 from "path";
 import "commander";
@@ -9583,12 +9723,12 @@ 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 = findProjectRoot19(opts.dir);
     const paths = resolveHaivePaths16(root);
-    if (!existsSync38(paths.memoriesDir)) {
+    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}".`);
@@ -9623,15 +9763,15 @@ function runEditor(editor, file) {
 }
 
 // src/commands/memory-for-files.ts
-import { existsSync as existsSync39 } from "fs";
+import { existsSync as existsSync40 } from "fs";
 import path24 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence9,
   findProjectRoot as findProjectRoot20,
-  getUsage as getUsage12,
+  getUsage as getUsage13,
   inferModulesFromPaths as inferModulesFromPaths4,
-  loadUsageIndex as loadUsageIndex14,
+  loadUsageIndex as loadUsageIndex15,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths5,
   resolveHaivePaths as resolveHaivePaths17
 } from "@hiveai/core";
@@ -9639,13 +9779,13 @@ 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 = findProjectRoot20(opts.dir);
     const paths = resolveHaivePaths17(root);
-    if (!existsSync39(paths.memoriesDir)) {
+    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 = [];
@@ -9743,7 +9883,7 @@ 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(path24.relative(root, filePath))}`);
@@ -9751,13 +9891,13 @@ function printGroup(root, label, loaded, usage) {
 }
 
 // src/commands/memory-hot.ts
-import { existsSync as existsSync40 } from "fs";
+import { existsSync as existsSync41 } from "fs";
 import path25 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot21,
-  getUsage as getUsage13,
-  loadUsageIndex as loadUsageIndex15,
+  getUsage as getUsage14,
+  loadUsageIndex as loadUsageIndex16,
   resolveHaivePaths as resolveHaivePaths18
 } from "@hiveai/core";
 function registerMemoryHot(memory2) {
@@ -9766,23 +9906,23 @@ function registerMemoryHot(memory2) {
   ).option("--threshold <n>", "minimum read_count to qualify (default: 3)", "3").option("--status <status>", "limit to one status (default: draft + proposed)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot21(opts.dir);
     const paths = resolveHaivePaths18(root);
-    if (!existsSync40(paths.memoriesDir)) {
+    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}).`);
@@ -9790,7 +9930,7 @@ 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}`)}`
       );
@@ -9805,7 +9945,7 @@ function registerMemoryHot(memory2) {
 
 // src/commands/memory-tried.ts
 import { mkdir as mkdir13, writeFile as writeFile19 } from "fs/promises";
-import { existsSync as existsSync41 } from "fs";
+import { existsSync as existsSync43 } from "fs";
 import path26 from "path";
 import "commander";
 import {
@@ -9835,7 +9975,7 @@ function registerMemoryTried(memory2) {
   ).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", "personal").option("--module <name>", "module name (required when scope=module)").option("--tags <csv>", "comma-separated tags").option("--paths <csv>", "anchor paths, comma-separated").option("--files <csv>", "alias for --paths (matches the MCP `files` parameter)").option("--author <author>", "author email or handle").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot22(opts.dir);
     const paths = resolveHaivePaths19(root);
-    if (!existsSync41(paths.haiveDir)) {
+    if (!existsSync43(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -9863,7 +10003,7 @@ function registerMemoryTried(memory2) {
     }
     const file = memoryFilePath8(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
     await mkdir13(path26.dirname(file), { recursive: true });
-    if (existsSync41(file)) {
+    if (existsSync43(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
       return;
@@ -9881,7 +10021,7 @@ function parseCsv4(value) {
 
 // src/commands/memory-seed.ts
 import { readFile as readFile13 } from "fs/promises";
-import { existsSync as existsSync43 } from "fs";
+import { existsSync as existsSync44 } from "fs";
 import path27 from "path";
 import "commander";
 import {
@@ -9921,7 +10061,7 @@ function registerMemorySeed(memory2) {
       }
       return;
     }
-    if (!existsSync43(paths.haiveDir)) {
+    if (!existsSync44(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -9977,26 +10117,26 @@ function registerMemorySeed(memory2) {
 }
 
 // src/commands/memory-pending.ts
-import { existsSync as existsSync44 } from "fs";
+import { existsSync as existsSync45 } from "fs";
 import path28 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot24,
-  getUsage as getUsage14,
-  loadUsageIndex as loadUsageIndex16,
+  getUsage as getUsage15,
+  loadUsageIndex as loadUsageIndex17,
   resolveHaivePaths as resolveHaivePaths21
 } from "@hiveai/core";
 function registerMemoryPending(memory2) {
   memory2.command("pending").description("List draft and proposed memories awaiting review (sorted by reads desc).\n\n  draft = created but not yet activated \xB7 proposed = promoted, awaiting team validation").option("--scope <scope>", "filter by scope (personal | team | module)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot24(opts.dir);
     const paths = resolveHaivePaths21(root);
-    if (!existsSync44(paths.memoriesDir)) {
+    if (!existsSync45(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 filterFn = ({ memory: mem }) => {
       if (mem.frontmatter.status !== "proposed" && mem.frontmatter.status !== "draft") return false;
       if (opts.scope && mem.frontmatter.scope !== opts.scope) return false;
@@ -10009,7 +10149,7 @@ function registerMemoryPending(memory2) {
       return;
     }
     pending.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();
     const drafts = pending.filter((m) => m.memory.frontmatter.status === "draft");
@@ -10018,7 +10158,7 @@ function registerMemoryPending(memory2) {
       console.log(ui.bold(`Proposed (${proposed.length}) \u2014 awaiting team validation`));
       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(
@@ -10033,7 +10173,7 @@ function registerMemoryPending(memory2) {
       console.log(ui.bold(`Draft (${drafts.length}) \u2014 created but not yet activated`));
       for (const { memory: mem, filePath } of drafts) {
         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(
@@ -10048,7 +10188,7 @@ function registerMemoryPending(memory2) {
 }
 
 // src/commands/memory-query.ts
-import { existsSync as existsSync45 } from "fs";
+import { existsSync as existsSync46 } from "fs";
 import path29 from "path";
 import "commander";
 import {
@@ -10065,7 +10205,7 @@ 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 = findProjectRoot25(opts.dir);
     const paths = resolveHaivePaths22(root);
-    if (!existsSync45(paths.memoriesDir)) {
+    if (!existsSync46(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -10076,7 +10216,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;
@@ -10124,26 +10264,26 @@ ${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 existsSync46 } from "fs";
+import { existsSync as existsSync47 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot26,
-  loadUsageIndex as loadUsageIndex17,
-  recordRejection as recordRejection2,
+  loadUsageIndex as loadUsageIndex18,
+  recordRejection as recordRejection3,
   resolveHaivePaths as resolveHaivePaths23,
-  saveUsageIndex as saveUsageIndex3,
+  saveUsageIndex as saveUsageIndex4,
   serializeMemory as serializeMemory18
 } 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 = findProjectRoot26(opts.dir);
     const paths = resolveHaivePaths23(root);
-    if (!existsSync46(paths.memoriesDir)) {
+    if (!existsSync47(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}".`);
@@ -10162,9 +10302,9 @@ function registerMemoryReject(memory2) {
       }),
       "utf8"
     );
-    const idx = await loadUsageIndex17(paths);
-    recordRejection2(idx, id, opts.reason ?? null);
-    await saveUsageIndex3(paths, idx);
+    const idx = await loadUsageIndex18(paths);
+    recordRejection3(idx, id, opts.reason ?? null);
+    await saveUsageIndex4(paths, idx);
     const u = idx.by_id[id];
     ui.success(
       `Rejected ${id} (status=rejected, ${u.rejected_count} rejection${u.rejected_count === 1 ? "" : "s"})`
@@ -10174,27 +10314,27 @@ function registerMemoryReject(memory2) {
 }
 
 // src/commands/memory-rm.ts
-import { existsSync as existsSync47 } from "fs";
+import { existsSync as existsSync48 } from "fs";
 import { unlink as unlink3 } from "fs/promises";
 import path30 from "path";
 import { createInterface as createInterface2 } from "readline/promises";
 import "commander";
 import {
   findProjectRoot as findProjectRoot27,
-  loadUsageIndex as loadUsageIndex18,
+  loadUsageIndex as loadUsageIndex19,
   resolveHaivePaths as resolveHaivePaths24,
-  saveUsageIndex as saveUsageIndex4
+  saveUsageIndex as saveUsageIndex5
 } 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 = findProjectRoot27(opts.dir);
     const paths = resolveHaivePaths24(root);
-    if (!existsSync47(paths.memoriesDir)) {
+    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}".`);
@@ -10214,10 +10354,10 @@ 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);
+        await saveUsageIndex5(paths, idx);
         ui.info("Removed usage entry");
       }
     }
@@ -10225,27 +10365,27 @@ function registerMemoryRm(memory2) {
 }
 
 // src/commands/memory-show.ts
-import { existsSync as existsSync48 } from "fs";
+import { existsSync as existsSync49 } from "fs";
 import { readFile as readFile14 } from "fs/promises";
 import path31 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence10,
   findProjectRoot as findProjectRoot28,
-  getUsage as getUsage15,
-  loadUsageIndex as loadUsageIndex19,
+  getUsage as getUsage16,
+  loadUsageIndex as loadUsageIndex20,
   resolveHaivePaths as resolveHaivePaths25
 } 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 = findProjectRoot28(opts.dir);
     const paths = resolveHaivePaths25(root);
-    if (!existsSync48(paths.memoriesDir)) {
+    if (!existsSync49(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}".`);
@@ -10257,8 +10397,8 @@ function registerMemoryShow(memory2) {
       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}` : ""}`);
@@ -10284,38 +10424,38 @@ function registerMemoryShow(memory2) {
 }
 
 // src/commands/memory-stats.ts
-import { existsSync as existsSync49 } from "fs";
+import { existsSync as existsSync50 } from "fs";
 import path33 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence11,
   findProjectRoot as findProjectRoot29,
-  getUsage as getUsage16,
-  loadUsageIndex as loadUsageIndex20,
+  getUsage as getUsage17,
+  loadUsageIndex as loadUsageIndex21,
   resolveHaivePaths as resolveHaivePaths26
 } 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 = findProjectRoot29(opts.dir);
     const paths = resolveHaivePaths26(root);
-    if (!existsSync49(paths.memoriesDir)) {
+    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 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)}`
@@ -10328,14 +10468,102 @@ function registerMemoryStats(memory2) {
   });
 }
 
+// src/commands/memory-impact.ts
+import { existsSync as existsSync51 } from "fs";
+import "commander";
+import {
+  compareImpact,
+  computeImpact as computeImpact3,
+  findProjectRoot as findProjectRoot30,
+  getUsage as getUsage18,
+  loadUsageIndex as loadUsageIndex23,
+  resolveHaivePaths as resolveHaivePaths27,
+  summarizeImpact
+} from "@hiveai/core";
+function registerMemoryImpact(memory2) {
+  memory2.command("impact").description(
+    "Score memories by demonstrated utility (reads + applied outcomes + sensor fires vs rejections, staleness, dormancy) and surface prune candidates."
+  ).option("--id <id>", "show impact for a single memory id").option("--prune", "list only prune candidates (dead weight worth reviewing)", false).option("--tier <tier>", "filter to a tier: high | medium | low | dormant").option("--json", "emit JSON", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
+    const root = findProjectRoot30(opts.dir);
+    const paths = resolveHaivePaths27(root);
+    if (!existsSync51(paths.memoriesDir)) {
+      ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
+      process.exitCode = 1;
+      return;
+    }
+    const all = await loadMemoriesFromDir26(paths.memoriesDir);
+    const usageIndex = await loadUsageIndex23(paths);
+    let rows = all.filter((m) => !opts.id || m.memory.frontmatter.id === opts.id).map(({ memory: mem }) => {
+      const fm = mem.frontmatter;
+      return {
+        id: fm.id,
+        type: fm.type,
+        scope: fm.scope,
+        status: fm.status,
+        impact: computeImpact3(fm, getUsage18(usageIndex, fm.id))
+      };
+    });
+    if (opts.prune) rows = rows.filter((r) => r.impact.pruneCandidate);
+    if (opts.tier) {
+      const tier = opts.tier;
+      rows = rows.filter((r) => r.impact.tier === tier);
+    }
+    rows.sort((a, b) => compareImpact(a.impact, b.impact));
+    const summary = summarizeImpact(all.map((m) => computeImpact3(m.memory.frontmatter, getUsage18(usageIndex, m.memory.frontmatter.id))));
+    if (opts.json) {
+      console.log(JSON.stringify({ root, summary, rows }, null, 2));
+      return;
+    }
+    if (rows.length === 0) {
+      ui.info(opts.prune ? "No prune candidates \u2014 every memory earns its keep." : "No memories matched.");
+      return;
+    }
+    console.log(ui.bold(`hAIve memory impact \u2014 ${root}`));
+    console.log(
+      ui.dim(
+        `${summary.total} memories \xB7 ${summary.high} high \xB7 ${summary.medium} medium \xB7 ${summary.low} low \xB7 ${summary.dormant} dormant \xB7 ${summary.prune_candidates} prune candidates`
+      )
+    );
+    console.log();
+    console.log(`${"score".padStart(5)}  ${"tier".padEnd(7)} ${pad("id", 52)} ${"prune".padEnd(5)} signals`);
+    console.log("\u2500".repeat(108));
+    for (const r of rows) {
+      const score = r.impact.score.toFixed(2).padStart(5);
+      const tier = tierBadge(r.impact.tier).padEnd(7);
+      const prune = r.impact.pruneCandidate ? ui.yellow("prune") : "     ";
+      console.log(`${score}  ${tier} ${pad(r.id, 52)} ${prune} ${ui.dim(r.impact.signals.join(", ") || "no signals")}`);
+    }
+    if (!opts.prune && summary.prune_candidates > 0) {
+      console.log();
+      console.log(ui.dim(`Tip: \`haive memory impact --prune\` lists the ${summary.prune_candidates} prune candidate(s).`));
+    }
+  });
+}
+function tierBadge(tier) {
+  switch (tier) {
+    case "high":
+      return ui.green(tier);
+    case "medium":
+      return ui.yellow(tier);
+    case "dormant":
+      return ui.dim(tier);
+    default:
+      return tier;
+  }
+}
+function pad(value, width) {
+  if (value.length <= width) return value.padEnd(width);
+  return value.slice(0, width - 1) + "\u2026";
+}
+
 // src/commands/memory-verify.ts
 import { writeFile as writeFile21 } from "fs/promises";
-import { existsSync as existsSync50 } from "fs";
+import { existsSync as existsSync53 } from "fs";
 import path34 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot30,
-  resolveHaivePaths as resolveHaivePaths27,
+  findProjectRoot as findProjectRoot31,
+  resolveHaivePaths as resolveHaivePaths28,
   serializeMemory as serializeMemory19,
   verifyAnchor as verifyAnchor3
 } from "@hiveai/core";
@@ -10343,9 +10571,9 @@ function registerMemoryVerify(memory2) {
   memory2.command("verify").description(
     "Check that memory anchor paths still exist in the current codebase.\n\n  A memory is 'stale' when its anchored file or symbol was moved, deleted, or renamed.\n  Stale memories are shown with a warning in get_briefing and should be updated or deleted.\n\n  haive sync runs this automatically. Use this command for on-demand checks or in CI.\n\n  CI recommendation: add 'haive memory verify' to your haive-sync.yml PR check job\n  to catch stale memories before they reach main.\n\n  Examples:\n    haive memory verify                          # check all, report only\n    haive memory verify --update                 # mark stale/fresh on disk\n    haive memory verify --id 2026-04-28-gotcha-x # check one memory\n"
   ).option("--id <id>", "verify a single memory by id").option("--all", "verify every memory (default if --id is omitted)").option("--update", "write status=stale or status=validated back to disk").option("--json", "emit machine-readable JSON (for CI / agents)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot30(opts.dir);
-    const paths = resolveHaivePaths27(root);
-    if (!existsSync50(paths.memoriesDir)) {
+    const root = findProjectRoot31(opts.dir);
+    const paths = resolveHaivePaths28(root);
+    if (!existsSync53(paths.memoriesDir)) {
       if (opts.json) {
         console.log(JSON.stringify({ error: "not-initialized", root }, null, 2));
       } else {
@@ -10354,7 +10582,7 @@ function registerMemoryVerify(memory2) {
       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) {
       if (opts.json) {
@@ -10466,24 +10694,24 @@ function applyVerification2(mem, result) {
 
 // src/commands/memory-import.ts
 import { readFile as readFile15 } from "fs/promises";
-import { existsSync as existsSync51 } from "fs";
+import { existsSync as existsSync54 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot31,
-  resolveHaivePaths as resolveHaivePaths28
+  findProjectRoot as findProjectRoot32,
+  resolveHaivePaths as resolveHaivePaths29
 } 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 = findProjectRoot31(opts.dir);
-    const paths = resolveHaivePaths28(root);
-    if (!existsSync51(paths.haiveDir)) {
+    const root = findProjectRoot32(opts.dir);
+    const paths = resolveHaivePaths29(root);
+    if (!existsSync54(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    if (!existsSync51(opts.from)) {
+    if (!existsSync54(opts.from)) {
       ui.error(`File not found: ${opts.from}`);
       process.exitCode = 1;
       return;
@@ -10516,14 +10744,14 @@ function registerMemoryImport(memory2) {
 }
 
 // src/commands/memory-import-changelog.ts
-import { existsSync as existsSync53 } from "fs";
+import { existsSync as existsSync55 } from "fs";
 import { readFile as readFile16, mkdir as mkdir14, writeFile as writeFile23 } from "fs/promises";
 import path35 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter9,
-  findProjectRoot as findProjectRoot32,
-  resolveHaivePaths as resolveHaivePaths29,
+  findProjectRoot as findProjectRoot33,
+  resolveHaivePaths as resolveHaivePaths30,
   serializeMemory as serializeMemory20
 } from "@hiveai/core";
 function parseChangelog(content) {
@@ -10588,10 +10816,10 @@ 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 = findProjectRoot32(opts.dir);
-    const paths = resolveHaivePaths29(root);
+    const root = findProjectRoot33(opts.dir);
+    const paths = resolveHaivePaths30(root);
     const changelogPath = path35.resolve(root, opts.fromChangelog);
-    if (!existsSync53(changelogPath)) {
+    if (!existsSync55(changelogPath)) {
       ui.error(`CHANGELOG not found: ${changelogPath}`);
       process.exitCode = 1;
       return;
@@ -10678,17 +10906,17 @@ ${ui.bold(`Imported ${saved} changelog entr${saved === 1 ? "y" : "ies"} from ${p
 }
 
 // src/commands/memory-digest.ts
-import { existsSync as existsSync54 } from "fs";
+import { existsSync as existsSync56 } from "fs";
 import { writeFile as writeFile24 } from "fs/promises";
 import path36 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence12,
-  findProjectRoot as findProjectRoot33,
-  getUsage as getUsage17,
-  loadMemoriesFromDir as loadMemoriesFromDir26,
-  loadUsageIndex as loadUsageIndex21,
-  resolveHaivePaths as resolveHaivePaths30
+  findProjectRoot as findProjectRoot34,
+  getUsage as getUsage19,
+  loadMemoriesFromDir as loadMemoriesFromDir27,
+  loadUsageIndex as loadUsageIndex24,
+  resolveHaivePaths as resolveHaivePaths31
 } from "@hiveai/core";
 var CONFIDENCE_EMOJI = {
   unverified: "\u2B1C",
@@ -10701,9 +10929,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 = findProjectRoot33(opts.dir);
-    const paths = resolveHaivePaths30(root);
-    if (!existsSync54(paths.memoriesDir)) {
+    const root = findProjectRoot34(opts.dir);
+    const paths = resolveHaivePaths31(root);
+    if (!existsSync56(paths.memoriesDir)) {
       ui.error("No .ai/memories found. Run `haive init` first.");
       process.exitCode = 1;
       return;
@@ -10711,8 +10939,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 loadUsageIndex24(paths);
     const recent = all.filter(({ memory: mem }) => {
       const fm = mem.frontmatter;
       if (fm.type === "session_recap") return false;
@@ -10743,7 +10971,7 @@ function registerMemoryDigest(program2) {
         lines.push(``);
         for (const { memory: mem } of mems) {
           const fm = mem.frontmatter;
-          const u = getUsage17(usage, fm.id);
+          const u = getUsage19(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_";
@@ -10786,21 +11014,21 @@ function registerMemoryDigest(program2) {
 
 // src/commands/session-end.ts
 import { writeFile as writeFile25, mkdir as mkdir15, readFile as readFile17, rm as rm2 } from "fs/promises";
-import { existsSync as existsSync55 } from "fs";
+import { existsSync as existsSync57 } from "fs";
 import { spawn as spawn4 } from "child_process";
 import path37 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter10,
-  findProjectRoot as findProjectRoot34,
-  loadMemoriesFromDir as loadMemoriesFromDir27,
+  findProjectRoot as findProjectRoot35,
+  loadMemoriesFromDir as loadMemoriesFromDir28,
   memoryFilePath as memoryFilePath9,
-  resolveHaivePaths as resolveHaivePaths31,
+  resolveHaivePaths as resolveHaivePaths32,
   serializeMemory as serializeMemory21
 } from "@hiveai/core";
 async function buildAutoRecap(paths) {
   const obsFile = path37.join(paths.haiveDir, ".cache", "observations.jsonl");
-  if (!existsSync55(obsFile)) return await buildGitAutoRecap(paths);
+  if (!existsSync57(obsFile)) return await buildGitAutoRecap(paths);
   const raw = await readFile17(obsFile, "utf8").catch(() => "");
   if (!raw.trim()) return await buildGitAutoRecap(paths);
   const lines = raw.split("\n").filter(Boolean);
@@ -10989,9 +11217,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 = findProjectRoot34(opts.dir);
-    const paths = resolveHaivePaths31(root);
-    if (!existsSync55(paths.haiveDir)) {
+    const root = findProjectRoot35(opts.dir);
+    const paths = resolveHaivePaths32(root);
+    if (!existsSync57(paths.haiveDir)) {
       if (opts.auto || opts.quiet) return;
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
@@ -11024,7 +11252,7 @@ function registerSessionEnd(session2) {
     });
     const topic = recapTopic2(scope, opts.module);
     const filesTouched = parseCsv5(resolvedFiles).map((p) => normalizeAnchorPath(root, p));
-    const missingPaths = filesTouched.filter((p) => !existsSync55(path37.resolve(root, p)));
+    const missingPaths = filesTouched.filter((p) => !existsSync57(path37.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}`);
@@ -11032,11 +11260,11 @@ function registerSessionEnd(session2) {
     const cleanupObservations = async () => {
       if (!opts.auto) return;
       const obsFile = path37.join(paths.haiveDir, ".cache", "observations.jsonl");
-      if (existsSync55(obsFile)) await rm2(obsFile).catch(() => {
+      if (existsSync57(obsFile)) await rm2(obsFile).catch(() => {
       });
     };
-    if (existsSync55(paths.memoriesDir)) {
-      const existing = await loadMemoriesFromDir27(paths.memoriesDir);
+    if (existsSync57(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)
       );
@@ -11097,15 +11325,15 @@ function normalizeAnchorPath(root, filePath) {
 }
 
 // src/commands/snapshot.ts
-import { existsSync as existsSync56 } from "fs";
+import { existsSync as existsSync58 } from "fs";
 import { readdir as readdir4 } from "fs/promises";
 import path38 from "path";
 import "commander";
 import {
   diffContract,
-  findProjectRoot as findProjectRoot35,
+  findProjectRoot as findProjectRoot36,
   loadConfig as loadConfig7,
-  resolveHaivePaths as resolveHaivePaths32,
+  resolveHaivePaths as resolveHaivePaths33,
   snapshotContract
 } from "@hiveai/core";
 function registerSnapshot(program2) {
@@ -11130,16 +11358,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 = findProjectRoot35(opts.dir);
-    const paths = resolveHaivePaths32(root);
-    if (!existsSync56(paths.haiveDir)) {
+    const root = findProjectRoot36(opts.dir);
+    const paths = resolveHaivePaths33(root);
+    if (!existsSync58(paths.haiveDir)) {
       ui.error("No .ai/ found. Run `haive init` first.");
       process.exitCode = 1;
       return;
     }
     if (opts.list) {
       const contractsDir = path38.join(paths.haiveDir, "contracts");
-      if (!existsSync56(contractsDir)) {
+      if (!existsSync58(contractsDir)) {
         console.log(ui.dim("No contract snapshots found."));
         return;
       }
@@ -11263,16 +11491,16 @@ function detectFormat(filePath) {
 }
 
 // src/commands/hub.ts
-import { existsSync as existsSync57 } from "fs";
+import { existsSync as existsSync59 } from "fs";
 import { mkdir as mkdir16, readFile as readFile18, writeFile as writeFile26, copyFile } from "fs/promises";
 import path39 from "path";
 import { spawnSync as spawnSync5 } from "child_process";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot36,
+  findProjectRoot as findProjectRoot37,
   loadConfig as loadConfig8,
-  loadMemoriesFromDir as loadMemoriesFromDir28,
-  resolveHaivePaths as resolveHaivePaths33,
+  loadMemoriesFromDir as loadMemoriesFromDir29,
+  resolveHaivePaths as resolveHaivePaths34,
   saveConfig as saveConfig3,
   serializeMemory as serializeMemory23
 } from "@hiveai/core";
@@ -11354,8 +11582,8 @@ Next steps:
     haive hub push --commit --message "feat: add payment API contract memories"
 `
   ).option("-d, --dir <dir>", "project root").option("--commit", "auto-commit to the hub repo after pushing").option("--message <msg>", "commit message for the hub (used with --commit)").action(async (opts) => {
-    const root = findProjectRoot36(opts.dir);
-    const paths = resolveHaivePaths33(root);
+    const root = findProjectRoot37(opts.dir);
+    const paths = resolveHaivePaths34(root);
     const config = await loadConfig8(paths);
     if (!config.hubPath) {
       ui.error(
@@ -11365,7 +11593,7 @@ Next steps:
       return;
     }
     const hubRoot = path39.resolve(root, config.hubPath);
-    if (!existsSync57(hubRoot)) {
+    if (!existsSync59(hubRoot)) {
       ui.error(`Hub not found at ${hubRoot}. Run \`haive hub init ${config.hubPath}\` first.`);
       process.exitCode = 1;
       return;
@@ -11373,7 +11601,7 @@ Next steps:
     const projectName = path39.basename(root);
     const destDir = path39.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:"))
@@ -11423,8 +11651,8 @@ Next steps:
   hub.command("pull").description(
     "Pull shared memories from the hub into this project.\n\n  Imports all memories from hub/.ai/memories/shared/ EXCEPT this project's own.\n  Imported memories land in .ai/memories/shared/<source-project-name>/.\n\n  Examples:\n    haive hub pull\n"
   ).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot36(opts.dir);
-    const paths = resolveHaivePaths33(root);
+    const root = findProjectRoot37(opts.dir);
+    const paths = resolveHaivePaths34(root);
     const config = await loadConfig8(paths);
     if (!config.hubPath) {
       ui.error(
@@ -11435,7 +11663,7 @@ Next steps:
     }
     const hubRoot = path39.resolve(root, config.hubPath);
     const hubSharedDir = path39.join(hubRoot, ".ai", "memories", "shared");
-    if (!existsSync57(hubSharedDir)) {
+    if (!existsSync59(hubSharedDir)) {
       ui.warn("Hub has no shared memories yet. Run `haive hub push` from other projects first.");
       return;
     }
@@ -11482,15 +11710,15 @@ Next steps:
     );
   });
   hub.command("status").description("Show hub sync status.").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 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 = path39.join(paths.memoriesDir, "shared");
-    if (existsSync57(sharedDir)) {
+    if (existsSync59(sharedDir)) {
       const { readdir: readdir7 } = await import("fs/promises");
       const sources = (await readdir7(sharedDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
       console.log(`
@@ -11502,7 +11730,7 @@ Next steps:
     } 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:"))
     );
@@ -11519,17 +11747,17 @@ Next steps:
 
 // src/commands/stats.ts
 import "commander";
-import { existsSync as existsSync58 } from "fs";
+import { existsSync as existsSync60 } from "fs";
 import { mkdir as mkdir17, writeFile as writeFile27 } from "fs/promises";
 import path40 from "path";
 import {
   aggregateUsage,
-  findProjectRoot as findProjectRoot37,
-  loadMemoriesFromDir as loadMemoriesFromDir29,
-  loadUsageIndex as loadUsageIndex23,
+  findProjectRoot as findProjectRoot38,
+  loadMemoriesFromDir as loadMemoriesFromDir30,
+  loadUsageIndex as loadUsageIndex25,
   parseSince,
   readUsageEvents as readUsageEvents2,
-  resolveHaivePaths as resolveHaivePaths34,
+  resolveHaivePaths as resolveHaivePaths35,
   usageLogSize
 } from "@hiveai/core";
 function registerStats(program2) {
@@ -11538,8 +11766,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 = findProjectRoot37(opts.dir);
-    const paths = resolveHaivePaths34(root);
+    const root = findProjectRoot38(opts.dir);
+    const paths = resolveHaivePaths35(root);
     if (opts.exportReport) {
       await writeRoiReport(paths, root, opts.since ?? "30d", opts.exportReport);
       return;
@@ -11585,9 +11813,9 @@ function registerStats(program2) {
     const maxCount = aggregate.by_tool[0]?.count ?? 1;
     for (const t of aggregate.by_tool.slice(0, 20)) {
       const bar = "\u2588".repeat(Math.max(1, Math.round(t.count / maxCount * 30)));
-      const pct = (t.count / aggregate.total * 100).toFixed(1);
+      const pct2 = (t.count / aggregate.total * 100).toFixed(1);
       console.log(
-        `  ${t.tool.padEnd(28)} ${ui.green(bar)} ${ui.bold(String(t.count))} ${ui.dim(`(${pct}%, last ${t.last_used.slice(0, 19)})`)}`
+        `  ${t.tool.padEnd(28)} ${ui.green(bar)} ${ui.bold(String(t.count))} ${ui.dim(`(${pct2}%, last ${t.last_used.slice(0, 19)})`)}`
       );
     }
   });
@@ -11597,8 +11825,8 @@ async function writeRoiReport(paths, root, sinceRaw, outRelative) {
   const size = await usageLogSize(paths);
   let events = await readUsageEvents2(paths);
   let memoryCount = { team: 0, personal: 0, total_skipped_session: 0 };
-  if (existsSync58(paths.memoriesDir)) {
-    const mems = await loadMemoriesFromDir29(paths.memoriesDir);
+  if (existsSync60(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++;
@@ -11612,7 +11840,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 loadUsageIndex25(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 {
@@ -11644,7 +11872,7 @@ async function writeRoiReport(paths, root, sinceRaw, outRelative) {
   ui.success(`Wrote ROI / usage rollup \u2192 ${outAbs}`);
 }
 async function renderMemoryHits(paths, opts) {
-  const index = await loadUsageIndex23(paths);
+  const index = await loadUsageIndex25(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) => {
@@ -11692,13 +11920,13 @@ import { performance } from "perf_hooks";
 import "commander";
 import {
   estimateTokens as estimateTokens3,
-  findProjectRoot as findProjectRoot38,
-  resolveHaivePaths as resolveHaivePaths35
+  findProjectRoot as findProjectRoot39,
+  resolveHaivePaths as resolveHaivePaths36
 } 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 = findProjectRoot38(opts.dir);
-    const paths = resolveHaivePaths35(root);
+    const root = findProjectRoot39(opts.dir);
+    const paths = resolveHaivePaths36(root);
     const ctx = { paths };
     const task = opts.task ?? "audit dependencies for security risks";
     const scenarios = [
@@ -11817,11 +12045,11 @@ function summarize(name, t0, payload, notes) {
 }
 
 // src/commands/benchmark.ts
-import { existsSync as existsSync59 } from "fs";
+import { existsSync as existsSync61 } from "fs";
 import { readdir as readdir5, readFile as readFile19, writeFile as writeFile28 } from "fs/promises";
 import path41 from "path";
 import "commander";
-import { estimateTokens as estimateTokens4, findProjectRoot as findProjectRoot39 } from "@hiveai/core";
+import { estimateTokens as estimateTokens4, findProjectRoot as findProjectRoot40 } 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) => {
@@ -11861,18 +12089,18 @@ function registerBenchmark(program2) {
 function resolveBenchmarkRoot(dir) {
   const candidate = dir ?? "benchmarks/agent-benchmark";
   if (path41.isAbsolute(candidate)) return candidate;
-  const projectRoot = findProjectRoot39(process.cwd());
+  const projectRoot = findProjectRoot40(process.cwd());
   return path41.join(projectRoot, candidate);
 }
 async function collectRows(root) {
-  if (!existsSync59(root)) throw new Error(`Benchmark directory not found: ${root}`);
+  if (!existsSync61(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 = path41.join(root, entry.name);
     const reportFile = path41.join(fixtureDir, "BENCHMARK_AGENT_REPORT.md");
-    if (!existsSync59(reportFile)) continue;
+    if (!existsSync61(reportFile)) continue;
     const report = await readFile19(reportFile, "utf8");
     rows.push(parseAgentReport(entry.name, report));
   }
@@ -11961,22 +12189,179 @@ function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-// src/commands/memory-suggest.ts
-import { mkdir as mkdir18, writeFile as writeFile29 } from "fs/promises";
-import { existsSync as existsSync60 } from "fs";
+// src/commands/eval.ts
+import { readFile as readFile20, writeFile as writeFile29 } from "fs/promises";
+import { existsSync as existsSync63 } from "fs";
 import path43 from "path";
 import "commander";
 import {
-  aggregateUsage as aggregateUsage2,
-  buildFrontmatter as buildFrontmatter11,
-  findProjectRoot as findProjectRoot40,
-  loadConfig as loadConfig9,
-  loadMemoriesFromDir as loadMemoriesFromDir30,
-  memoryFilePath as memoryFilePath10,
-  parseSince as parseSince2,
-  readUsageEvents as readUsageEvents3,
-  resolveHaivePaths as resolveHaivePaths36,
-  serializeMemory as serializeMemory24
+  aggregateRetrieval,
+  aggregateSensors,
+  buildReport,
+  findProjectRoot as findProjectRoot41,
+  resolveHaivePaths as resolveHaivePaths37,
+  scoreRetrievalCase,
+  scoreSensorCase,
+  synthesizeSelfEvalCases
+} from "@hiveai/core";
+function registerEval(program2) {
+  program2.command("eval").description(
+    "Rigorous, repeatable quality eval: do the right memories surface (retrieval) and do the right sensors fire (catch-rate)? Emits a chiffr\xE9 0\u2013100 score. Uses .ai/eval cases via --spec, or auto-synthesizes cases from anchored memories."
+  ).option("--spec <file>", "JSON eval spec ({ retrieval: [...], sensors: [...] })").option("--semantic-only", "self-eval probes by title alone (no anchor files) \u2014 harder retrieval", false).option("-k, --top <n>", "briefing top-k considered a hit", "8").option("--json", "emit JSON", false).option("--out <file>", "write a Markdown report").option("-d, --dir <dir>", "project root").action(async (opts) => {
+    const root = findProjectRoot41(opts.dir);
+    const paths = resolveHaivePaths37(root);
+    if (!existsSync63(paths.memoriesDir)) {
+      ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
+      process.exitCode = 1;
+      return;
+    }
+    const k = Math.max(1, parseInt(opts.top ?? "8", 10) || 8);
+    const ctx = { paths };
+    const spec = await resolveSpec(opts, paths.memoriesDir);
+    if ((spec.retrieval?.length ?? 0) === 0 && (spec.sensors?.length ?? 0) === 0) {
+      ui.warn("No eval cases (no anchored memories and no --spec). Nothing to score.");
+      return;
+    }
+    let retrievalAgg = null;
+    if (spec.retrieval && spec.retrieval.length > 0) {
+      const results = [];
+      for (const c of spec.retrieval) {
+        const surfaced = await runRetrieval(c, k, ctx);
+        results.push(scoreRetrievalCase(c.name, c.expect_ids, surfaced));
+      }
+      retrievalAgg = aggregateRetrieval(results);
+    }
+    let sensorAgg = null;
+    if (spec.sensors && spec.sensors.length > 0) {
+      const results = [];
+      for (const c of spec.sensors) {
+        const fired = await runSensorCase(c, ctx);
+        results.push(scoreSensorCase(c.name, c.expect_fire_ids, fired));
+      }
+      sensorAgg = aggregateSensors(results);
+    }
+    const report = buildReport(retrievalAgg, sensorAgg);
+    if (opts.json) {
+      console.log(JSON.stringify({ root, k, report }, null, 2));
+      return;
+    }
+    const md = renderMarkdown2(root, k, report);
+    if (opts.out) {
+      const outFile = path43.isAbsolute(opts.out) ? opts.out : path43.join(root, opts.out);
+      await writeFile29(outFile, md, "utf8");
+      ui.success(`wrote ${path43.relative(process.cwd(), outFile)}`);
+      return;
+    }
+    console.log(md);
+  });
+}
+async function resolveSpec(opts, memoriesDir) {
+  if (opts.spec) {
+    const file = path43.resolve(opts.spec);
+    const raw = await readFile20(file, "utf8");
+    return JSON.parse(raw);
+  }
+  const memories = await loadMemoriesFromDir26(memoriesDir);
+  return { retrieval: synthesizeSelfEvalCases(memories, { includeFiles: !opts.semanticOnly }) };
+}
+async function runRetrieval(c, k, ctx) {
+  const out = await getBriefing(
+    {
+      task: c.task,
+      files: c.files ?? [],
+      symbols: c.symbols ?? [],
+      max_tokens: 6e3,
+      max_memories: k,
+      include_project_context: false,
+      include_module_contexts: false,
+      semantic: true,
+      include_stale: false,
+      track: false,
+      format: "compact",
+      min_semantic_score: 0
+    },
+    ctx
+  );
+  return out.memories.map((m) => m.id);
+}
+async function runSensorCase(c, ctx) {
+  const out = await antiPatternsCheck(
+    { diff: c.diff, paths: c.paths ?? [], limit: 50, semantic: false },
+    ctx
+  );
+  return out.warnings.filter((w) => w.reasons.includes("sensor")).map((w) => w.id);
+}
+function pct(n) {
+  return `${Math.round(n * 100)}%`;
+}
+function renderMarkdown2(root, k, report) {
+  const lines = [
+    "# hAIve eval report",
+    "",
+    `Project: \`${root}\` \xB7 top-k: ${k}`,
+    "",
+    `## Overall score: ${report.score}/100`,
+    ""
+  ];
+  if (report.retrieval) {
+    const r = report.retrieval;
+    lines.push(
+      "## Retrieval",
+      "",
+      `- cases: ${r.cases.length}`,
+      `- mean recall: ${pct(r.mean_recall)}`,
+      `- mean precision: ${pct(r.mean_precision)}`,
+      `- MRR: ${r.mrr.toFixed(3)}`,
+      ""
+    );
+    const misses = r.cases.filter((c) => c.misses.length > 0);
+    if (misses.length > 0) {
+      lines.push(`### ${misses.length} retrieval miss(es)`, "");
+      for (const c of misses.slice(0, 25)) {
+        lines.push(`- \`${c.name}\` \u2014 expected not in top-${k}`);
+      }
+      lines.push("");
+    }
+  }
+  if (report.sensors) {
+    const s = report.sensors;
+    lines.push("## Sensors", "", `- cases: ${s.cases.length}`, `- catch-rate: ${pct(s.catch_rate)}`, "");
+    const misses = s.cases.filter((c) => c.misses.length > 0);
+    if (misses.length > 0) {
+      lines.push(`### ${misses.length} sensor miss(es)`, "");
+      for (const c of misses.slice(0, 25)) {
+        lines.push(`- \`${c.name}\` \u2014 sensor did not fire (expected: ${c.misses.join(", ")})`);
+      }
+      lines.push("");
+    }
+  }
+  lines.push(
+    "## Reading",
+    "",
+    "Retrieval recall = share of expected memories that surfaced in the briefing top-k.",
+    "MRR rewards ranking the right memory high. Catch-rate = share of known-bad diffs a sensor flagged.",
+    "Run in CI to fail the build on a ranking/sensor regression.",
+    ""
+  );
+  return lines.join("\n");
+}
+
+// src/commands/memory-suggest.ts
+import { mkdir as mkdir18, writeFile as writeFile30 } from "fs/promises";
+import { existsSync as existsSync64 } from "fs";
+import path44 from "path";
+import "commander";
+import {
+  aggregateUsage as aggregateUsage2,
+  buildFrontmatter as buildFrontmatter11,
+  findProjectRoot as findProjectRoot42,
+  loadConfig as loadConfig9,
+  loadMemoriesFromDir as loadMemoriesFromDir31,
+  memoryFilePath as memoryFilePath10,
+  parseSince as parseSince2,
+  readUsageEvents as readUsageEvents3,
+  resolveHaivePaths as resolveHaivePaths38,
+  serializeMemory as serializeMemory24
 } from "@hiveai/core";
 var SEARCH_TOOLS = /* @__PURE__ */ new Set([
   "mem_search",
@@ -11992,8 +12377,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 save the top-N suggestions using the project defaults.\n  In autopilot, suggestions land as validated team records; in manual mode they stay draft."
   ).option("--since <window>", "ISO date or relative (e.g. '7d', '24h')", "30d").option("--min <count>", "minimum repeat count to surface a query", "2").option("--top-n <n>", "with --auto-save, draft this many top suggestions", "3").option("--scope <scope>", "with --auto-save, scope of saved memories (personal | team; default: config default)").option("--auto-save", "save top-N suggestions as memories on disk", false).option("--json", "emit JSON instead of human-readable output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot40(opts.dir);
-    const paths = resolveHaivePaths36(root);
+    const root = findProjectRoot42(opts.dir);
+    const paths = resolveHaivePaths38(root);
     const events = await readUsageEvents3(paths);
     if (events.length === 0) {
       if (opts.json) {
@@ -12042,7 +12427,7 @@ function registerMemorySuggest(memory2) {
       }
       const created = [];
       const skipped = [];
-      const existing = existsSync60(paths.memoriesDir) ? await loadMemoriesFromDir30(paths.memoriesDir) : [];
+      const existing = existsSync64(paths.memoriesDir) ? await loadMemoriesFromDir31(paths.memoriesDir) : [];
       for (const s of top) {
         const slug = slugify2(s.query);
         if (!slug) {
@@ -12065,13 +12450,13 @@ function registerMemorySuggest(memory2) {
         });
         const body = renderTemplate(s, fm.id, status);
         const file = memoryFilePath10(paths, fm.scope, fm.id, fm.module);
-        await mkdir18(path43.dirname(file), { recursive: true });
-        if (existsSync60(file)) {
-          skipped.push({ query: s.query, reason: `file already exists at ${path43.relative(root, file)}` });
+        await mkdir18(path44.dirname(file), { recursive: true });
+        if (existsSync64(file)) {
+          skipped.push({ query: s.query, reason: `file already exists at ${path44.relative(root, file)}` });
           continue;
         }
-        await writeFile29(file, serializeMemory24({ frontmatter: fm, body }), "utf8");
-        created.push({ id: fm.id, file: path43.relative(root, file), query: s.query });
+        await writeFile30(file, serializeMemory24({ frontmatter: fm, body }), "utf8");
+        created.push({ id: fm.id, file: path44.relative(root, file), query: s.query });
       }
       if (opts.json) {
         console.log(JSON.stringify({ created, skipped }, null, 2));
@@ -12169,18 +12554,18 @@ function truncate2(text, max) {
 }
 
 // src/commands/memory-archive.ts
-import { existsSync as existsSync61 } from "fs";
-import { writeFile as writeFile30 } from "fs/promises";
-import path44 from "path";
+import { existsSync as existsSync65 } from "fs";
+import { writeFile as writeFile31 } from "fs/promises";
+import path45 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot41,
-  getUsage as getUsage18,
+  findProjectRoot as findProjectRoot43,
+  getUsage as getUsage20,
   retirementSignal as retirementSignal2,
   loadConfig as loadConfig10,
-  loadMemoriesFromDir as loadMemoriesFromDir31,
-  loadUsageIndex as loadUsageIndex24,
-  resolveHaivePaths as resolveHaivePaths37,
+  loadMemoriesFromDir as loadMemoriesFromDir33,
+  loadUsageIndex as loadUsageIndex26,
+  resolveHaivePaths as resolveHaivePaths39,
   serializeMemory as serializeMemory25
 } from "@hiveai/core";
 var MS_PER_DAY2 = 24 * 60 * 60 * 1e3;
@@ -12188,9 +12573,9 @@ function registerMemoryArchive(memory2) {
   memory2.command("archive").description(
     "Archive obsolete memories: marks status='deprecated' for memories not read in N days\n  whose anchored paths have all disappeared (or have no anchor at all).\n\n  Defaults to a DRY RUN \u2014 pass --apply to actually rewrite files.\n  Targets `attempt` memories by default since they age the fastest.\n\n  Recover later with `haive memory edit <id>` to set status back to validated."
   ).option("--since <window>", "minimum age since last read (e.g. '180d', '6m'). Default: enforcement.decayAfterDays or 180d").option("--type <type>", "limit to a memory type (default 'attempt'). Pass 'all' to scan all types.", "attempt").option("--unread", "decay by unread-age ALONE (ignore anchor status) \u2014 more aggressive corpus hygiene", false).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 = findProjectRoot41(opts.dir);
-    const paths = resolveHaivePaths37(root);
-    if (!existsSync61(paths.memoriesDir)) {
+    const root = findProjectRoot43(opts.dir);
+    const paths = resolveHaivePaths39(root);
+    if (!existsSync65(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -12204,8 +12589,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 loadMemoriesFromDir33(paths.memoriesDir);
+    const usage = await loadUsageIndex26(paths);
     const typeFilter = opts.type === "all" ? null : opts.type ?? "attempt";
     const candidates = [];
     for (const { memory: mem, filePath } of all) {
@@ -12215,10 +12600,10 @@ function registerMemoryArchive(memory2) {
       if (fm.status === "deprecated" || fm.status === "rejected") continue;
       const retired = retirementSignal2(fm, mem.body);
       const hasAnyAnchor = fm.anchor.paths.length + fm.anchor.symbols.length > 0;
-      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync61(path44.join(paths.root, p)));
+      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync65(path45.join(paths.root, p)));
       const isAnchorless = !hasAnyAnchor;
       if (!retired.retired && !opts.unread && !isAnchorless && !allPathsGone) continue;
-      const u = getUsage18(usage, fm.id);
+      const u = getUsage20(usage, fm.id);
       const lastSeen = u.last_read_at ?? fm.created_at;
       if (!retired.retired && Date.parse(lastSeen) >= cutoff) continue;
       const reason = retired.retired ? `retired lifecycle signal: ${retired.reason ?? "unknown"}` : isAnchorless ? `anchorless and not read since ${lastSeen.slice(0, 10)}` : allPathsGone ? `all ${fm.anchor.paths.length} anchored path(s) missing and not read since ${lastSeen.slice(0, 10)}` : `not read since ${lastSeen.slice(0, 10)} (unread decay)`;
@@ -12264,7 +12649,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 writeFile31(c.filePath, serializeMemory25({ frontmatter: fm, body: found.memory.body }), "utf8");
         archived++;
       } catch (err) {
         if (!opts.json) {
@@ -12290,33 +12675,34 @@ function parseDays(input) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync63, statSync as statSync2 } from "fs";
-import { readFile as readFile20, stat, writeFile as writeFile31 } from "fs/promises";
-import path45 from "path";
+import { existsSync as existsSync66, statSync as statSync2 } from "fs";
+import { readFile as readFile21, stat, writeFile as writeFile33 } from "fs/promises";
+import path46 from "path";
 import { execFileSync, execSync as execSync3 } from "child_process";
 import "commander";
 import {
   codeMapPath as codeMapPath2,
-  findProjectRoot as findProjectRoot42,
-  getUsage as getUsage19,
+  findProjectRoot as findProjectRoot44,
+  getUsage as getUsage21,
+  isStackPackSeed as isStackPackSeed4,
   loadCodeMap as loadCodeMap7,
   loadConfig as loadConfig11,
-  loadMemoriesFromDir as loadMemoriesFromDir33,
-  loadUsageIndex as loadUsageIndex25,
+  loadMemoriesFromDir as loadMemoriesFromDir34,
+  loadUsageIndex as loadUsageIndex27,
   readUsageEvents as readUsageEvents4,
-  resolveHaivePaths as resolveHaivePaths38
+  resolveHaivePaths as resolveHaivePaths40
 } 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 apply safe autopilot repairs."
   ).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 = findProjectRoot42(opts.dir);
-    const paths = resolveHaivePaths38(root);
+    const root = findProjectRoot44(opts.dir);
+    const paths = resolveHaivePaths40(root);
     const findings = [];
     const repairs = [];
     const config = await loadConfig11(paths);
-    if (!existsSync63(paths.haiveDir)) {
+    if (!existsSync66(paths.haiveDir)) {
       findings.push({
         severity: "error",
         code: "not-initialized",
@@ -12337,7 +12723,7 @@ function registerDoctor(program2) {
         })
       );
     }
-    if (!existsSync63(paths.projectContext)) {
+    if (!existsSync66(paths.projectContext)) {
       findings.push({
         severity: "warn",
         code: "no-project-context",
@@ -12345,8 +12731,8 @@ function registerDoctor(program2) {
         fix: "haive init"
       });
     } else {
-      const { readFile: readFile24 } = await import("fs/promises");
-      const content = await readFile24(paths.projectContext, "utf8");
+      const { readFile: readFile25 } = await import("fs/promises");
+      const content = await readFile25(paths.projectContext, "utf8");
       const isTemplate = content.includes("TODO \u2014 high-level overview") || content.includes("Generated by `haive init`");
       if (isTemplate) {
         findings.push({
@@ -12366,7 +12752,7 @@ function registerDoctor(program2) {
         });
       }
     }
-    const memories = existsSync63(paths.memoriesDir) ? await loadMemoriesFromDir33(paths.memoriesDir) : [];
+    const memories = existsSync66(paths.memoriesDir) ? await loadMemoriesFromDir34(paths.memoriesDir) : [];
     const now = Date.now();
     if (memories.length === 0) {
       findings.push({
@@ -12375,7 +12761,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 loadUsageIndex27(paths);
       const stale = memories.filter((m) => m.memory.frontmatter.status === "stale");
       if (stale.length > 0) {
         findings.push({
@@ -12410,20 +12796,29 @@ function registerDoctor(program2) {
           fix: "haive memory approve <id>   # activate\nhaive memory rm <id>         # or delete if obsolete"
         });
       }
-      const anchorless = memories.filter(
+      const policyMemories = memories.filter((m) => !isStackPackSeed4(m.memory.frontmatter));
+      const anchorless = policyMemories.filter(
         (m) => m.memory.frontmatter.anchor.paths.length === 0 && m.memory.frontmatter.anchor.symbols.length === 0 && m.memory.frontmatter.type !== "session_recap" && m.memory.frontmatter.type !== "glossary" && m.memory.frontmatter.type !== "skill"
       );
-      if (anchorless.length / Math.max(memories.length, 1) > 0.3) {
+      const stackSeeds = memories.filter((m) => isStackPackSeed4(m.memory.frontmatter));
+      if (anchorless.length / Math.max(policyMemories.length, 1) > 0.3) {
         findings.push({
           severity: "warn",
           code: "anchorless-majority",
-          message: `${anchorless.length}/${memories.length} memories have no anchor path/symbol \u2014 staleness undetectable.`,
+          message: `${anchorless.length}/${policyMemories.length} repo-specific memories have no anchor path/symbol \u2014 staleness undetectable.`,
           fix: "Add `paths:` + `symbols:` to mem_save calls to enable haive memory verify."
         });
+      } else if (stackSeeds.length > 0 && policyMemories.length === 0) {
+        findings.push({
+          severity: "info",
+          code: "stack-pack-seeds",
+          message: `${stackSeeds.length} starter stack memor${stackSeeds.length === 1 ? "y is" : "ies are"} present as generic background guidance.`,
+          fix: "Replace or anchor stack-pack seeds when they become repo-specific policy."
+        });
       }
       const decayCandidates = memories.filter((m) => {
         if (m.memory.frontmatter.status !== "validated") return false;
-        const u = getUsage19(usage, m.memory.frontmatter.id);
+        const u = getUsage21(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;
       });
@@ -12507,12 +12902,12 @@ function registerDoctor(program2) {
       }
     }
     if (config.enforcement?.requireBriefingFirst) {
-      const claudeSettings = path45.join(root, ".claude", "settings.local.json");
+      const claudeSettings = path46.join(root, ".claude", "settings.local.json");
       let hasClaudeEnforcement = false;
-      if (existsSync63(claudeSettings)) {
+      if (existsSync66(claudeSettings)) {
         try {
-          const { readFile: readFile24 } = await import("fs/promises");
-          const raw = await readFile24(claudeSettings, "utf8");
+          const { readFile: readFile25 } = await import("fs/promises");
+          const raw = await readFile25(claudeSettings, "utf8");
           hasClaudeEnforcement = raw.includes("haive enforce session-start") && raw.includes("haive enforce pre-tool-use");
         } catch {
           hasClaudeEnforcement = false;
@@ -12535,14 +12930,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.10.8"));
+    findings.push(...await collectInstallFindings(root, "0.11.0"));
     try {
       const legacyRaw = execSync3("haive-mcp --version", {
         encoding: "utf8",
         timeout: 3e3,
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      const cliVersion = "0.10.8";
+      const cliVersion = "0.11.0";
       if (legacyRaw && legacyRaw !== cliVersion) {
         findings.push({
           severity: "warn",
@@ -12558,20 +12953,20 @@ npm uninstall -g @hiveai/mcp`
     }
     {
       const configPaths = [
-        path45.join(root, ".mcp.json"),
-        path45.join(root, ".cursor", "mcp.json"),
-        path45.join(root, ".vscode", "mcp.json")
+        path46.join(root, ".mcp.json"),
+        path46.join(root, ".cursor", "mcp.json"),
+        path46.join(root, ".vscode", "mcp.json")
       ];
       const staleConfigs = [];
       for (const cfgPath of configPaths) {
-        if (!existsSync63(cfgPath)) continue;
+        if (!existsSync66(cfgPath)) continue;
         try {
-          const raw = await readFile20(cfgPath, "utf8");
+          const raw = await readFile21(cfgPath, "utf8");
           if (raw.includes('"haive-mcp"') || raw.includes("'haive-mcp'")) {
-            staleConfigs.push(path45.relative(root, cfgPath));
+            staleConfigs.push(path46.relative(root, cfgPath));
             if (opts.fix && !opts.dryRun) {
               const updated = raw.replace(/"command"\s*:\s*"haive-mcp"/g, '"command": "haive"').replace(/"args"\s*:\s*\[\]/g, '"args": ["mcp", "--stdio"]');
-              await writeFile31(cfgPath, updated, "utf8");
+              await writeFile33(cfgPath, updated, "utf8");
             }
           }
         } catch {
@@ -12742,23 +13137,23 @@ async function collectHarnessCoverageFindings(codeMap, memories) {
     }
   }
   const covered = coveredFiles.size;
-  const pct = Math.round(covered / total * 100);
+  const pct2 = Math.round(covered / total * 100);
   const uncovered = codeFiles.filter((f) => !coveredFiles.has(f)).sort((a, b) => {
     const depthA = a.split("/").length;
     const depthB = b.split("/").length;
     if (depthA !== depthB) return depthA - depthB;
     return a.localeCompare(b);
   }).slice(0, 5);
-  const coverageDesc = pct < 10 && total > 10 ? "Low coverage \u2014 add memory anchors on key modules to improve harness enforcement." : pct < 50 ? "Partial coverage \u2014 useful but not yet broad enough to call the harness mature." : pct < 80 ? "Good coverage \u2014 critical modules are increasingly protected." : "Good harness coverage.";
+  const coverageDesc = pct2 < 10 && total > 10 ? "Low coverage \u2014 add memory anchors on key modules to improve harness enforcement." : pct2 < 50 ? "Partial coverage \u2014 useful but not yet broad enough to call the harness mature." : pct2 < 80 ? "Good coverage \u2014 critical modules are increasingly protected." : "Good harness coverage.";
   const uncoveredHint = uncovered.length > 0 ? `
   Top uncovered: ${uncovered.map((f) => `\`${f}\``).join(", ")}` : "";
   const findings = [];
   findings.push({
     severity: "info",
     code: "harness-coverage",
-    coverage_percent: pct,
-    message: `${covered}/${total} code-map files have validated memory anchors (${pct}%). ` + coverageDesc + uncoveredHint,
-    fix: pct < 50 && total > 10 ? `haive memory add --type gotcha|convention|architecture --paths <key-file> --scope team` : void 0,
+    coverage_percent: pct2,
+    message: `${covered}/${total} code-map files have validated memory anchors (${pct2}%). ` + coverageDesc + uncoveredHint,
+    fix: pct2 < 50 && total > 10 ? `haive memory add --type gotcha|convention|architecture --paths <key-file> --scope team` : void 0,
     section: "Harness coverage"
   });
   return findings;
@@ -12858,9 +13253,9 @@ which -a haive`
     ".vscode/mcp.json"
   ];
   for (const rel of integrationFiles) {
-    const file = path45.join(root, rel);
-    if (!existsSync63(file)) continue;
-    const text = await readFile20(file, "utf8").catch(() => "");
+    const file = path46.join(root, rel);
+    if (!existsSync66(file)) continue;
+    const text = await readFile21(file, "utf8").catch(() => "");
     for (const bin of extractAbsoluteHaiveBins(text)) {
       const version = versionForBinary(bin);
       if (!version) {
@@ -12884,7 +13279,7 @@ which -a haive`
 }
 async function collectWorkspaceVersionFindings(root, expectedVersion) {
   const findings = [];
-  const rootPkg = await readJson(path45.join(root, "package.json"));
+  const rootPkg = await readJson(path46.join(root, "package.json"));
   const workspacePackages = [
     "packages/core/package.json",
     "packages/embeddings/package.json",
@@ -12893,7 +13288,7 @@ async function collectWorkspaceVersionFindings(root, expectedVersion) {
   ];
   const existing = (await Promise.all(workspacePackages.map(async (rel) => ({
     rel,
-    pkg: await readJson(path45.join(root, rel))
+    pkg: await readJson(path46.join(root, rel))
   })))).filter((item) => item.pkg);
   const isHaiveWorkspace = rootPkg?.name === "haive-monorepo" || existing.some((item) => item.pkg?.name?.startsWith("@hiveai/"));
   if (!isHaiveWorkspace) return findings;
@@ -12955,9 +13350,9 @@ function collectGlobalHivemoduleFindings(expectedVersion) {
   }
 }
 async function readJson(file) {
-  if (!existsSync63(file)) return null;
+  if (!existsSync66(file)) return null;
   try {
-    return JSON.parse(await readFile20(file, "utf8"));
+    return JSON.parse(await readFile21(file, "utf8"));
   } catch {
     return null;
   }
@@ -13002,22 +13397,22 @@ function extractAbsoluteHaiveBins(text) {
 }
 
 // src/commands/playback.ts
-import { existsSync as existsSync64 } from "fs";
+import { existsSync as existsSync67 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot43,
-  loadMemoriesFromDir as loadMemoriesFromDir34,
+  findProjectRoot as findProjectRoot45,
+  loadMemoriesFromDir as loadMemoriesFromDir35,
   parseSince as parseSince3,
   readUsageEvents as readUsageEvents5,
-  resolveHaivePaths as resolveHaivePaths39
+  resolveHaivePaths as resolveHaivePaths41
 } 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 = findProjectRoot43(opts.dir);
-    const paths = resolveHaivePaths39(root);
+    const root = findProjectRoot45(opts.dir);
+    const paths = resolveHaivePaths41(root);
     const events = await readUsageEvents5(paths);
     if (events.length === 0) {
       if (opts.json) {
@@ -13032,7 +13427,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 = existsSync64(paths.memoriesDir) ? await loadMemoriesFromDir34(paths.memoriesDir) : [];
+    const all = existsSync67(paths.memoriesDir) ? await loadMemoriesFromDir35(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);
@@ -13123,9 +13518,9 @@ import { spawn as spawn5 } from "child_process";
 import "commander";
 import {
   antiPatternGateParams,
-  findProjectRoot as findProjectRoot44,
+  findProjectRoot as findProjectRoot46,
   loadConfig as loadConfig12,
-  resolveHaivePaths as resolveHaivePaths40
+  resolveHaivePaths as resolveHaivePaths42
 } from "@hiveai/core";
 function registerPrecommit(program2) {
   program2.command("precommit").description(
@@ -13137,8 +13532,8 @@ function registerPrecommit(program2) {
     "--no-anchored-blocks",
     "do not block on anchored, diff-corroborated anti-patterns (only block on very strong semantic matches)"
   ).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 = findProjectRoot44(opts.dir);
-    const paths = resolveHaivePaths40(root);
+    const root = findProjectRoot46(opts.dir);
+    const paths = resolveHaivePaths42(root);
     const ctx = { paths };
     const config = await loadConfig12(paths);
     const gate = config.enforcement?.antiPatternGate ?? "anchored";
@@ -13274,12 +13669,12 @@ function runCommand3(cmd, args, cwd) {
 }
 
 // src/commands/welcome.ts
-import { existsSync as existsSync65 } from "fs";
+import { existsSync as existsSync68 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot45,
-  loadMemoriesFromDir as loadMemoriesFromDir35,
-  resolveHaivePaths as resolveHaivePaths41
+  findProjectRoot as findProjectRoot47,
+  loadMemoriesFromDir as loadMemoriesFromDir36,
+  resolveHaivePaths as resolveHaivePaths43
 } from "@hiveai/core";
 var TYPE_RANK = {
   skill: 0,
@@ -13294,14 +13689,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 = findProjectRoot45(opts.dir);
-    const paths = resolveHaivePaths41(root);
-    if (!existsSync65(paths.memoriesDir)) {
+    const root = findProjectRoot47(opts.dir);
+    const paths = resolveHaivePaths43(root);
+    if (!existsSync68(paths.memoriesDir)) {
       ui.error(`No memories at ${paths.memoriesDir}. Run 'haive init' first.`);
       process.exitCode = 1;
       return;
     }
-    const all = await loadMemoriesFromDir35(paths.memoriesDir);
+    const all = await loadMemoriesFromDir36(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"
     );
@@ -13355,27 +13750,27 @@ function registerMemorySuggestTopic(memory2) {
 }
 
 // src/commands/resolve-project.ts
-import path46 from "path";
+import path47 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: path46.resolve(opts.dir) });
+    const info = resolveProjectInfo2({ cwd: path47.resolve(opts.dir) });
     console.log(JSON.stringify({ ok: true, info }, null, 2));
   });
 }
 
 // src/commands/runtime-journal.ts
-import { existsSync as existsSync66 } from "fs";
-import path47 from "path";
+import { existsSync as existsSync69 } from "fs";
+import path48 from "path";
 import "commander";
 import {
   appendRuntimeJournalEntry as appendRuntimeJournalEntry3,
-  findProjectRoot as findProjectRoot46,
+  findProjectRoot as findProjectRoot48,
   readRuntimeJournalTail as readRuntimeJournalTail2,
-  resolveHaivePaths as resolveHaivePaths42
+  resolveHaivePaths as resolveHaivePaths44
 } from "@hiveai/core";
 function registerRuntime(program2) {
   const runtime = program2.command("runtime").description(
@@ -13383,18 +13778,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 = path47.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths42(findProjectRoot46(root));
+    const root = path48.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths44(findProjectRoot48(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 ${path47.relative(root, paths.runtimeDir)}/session-journal.ndjson`);
+    ui.success(`Appended to ${path48.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 = path47.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths42(findProjectRoot46(root));
+    const root = path48.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths44(findProjectRoot48(root));
     const limit = Math.min(500, Math.max(1, parseInt(opts.limit, 10) || 30));
-    if (!existsSync66(paths.haiveDir)) {
+    if (!existsSync69(paths.haiveDir)) {
       ui.error("No .ai/ \u2014 run `haive init` first.");
       process.exitCode = 1;
       return;
@@ -13409,13 +13804,13 @@ function registerRuntime(program2) {
 }
 
 // src/commands/memory-timeline.ts
-import { existsSync as existsSync67 } from "fs";
-import path48 from "path";
+import { existsSync as existsSync70 } from "fs";
+import path49 from "path";
 import "commander";
 import {
   collectTimelineEntries as collectTimelineEntries2,
-  findProjectRoot as findProjectRoot47,
-  resolveHaivePaths as resolveHaivePaths43
+  findProjectRoot as findProjectRoot49,
+  resolveHaivePaths as resolveHaivePaths45
 } from "@hiveai/core";
 function registerMemoryTimeline(memory2) {
   memory2.command("timeline").description(
@@ -13426,15 +13821,15 @@ function registerMemoryTimeline(memory2) {
       process.exitCode = 1;
       return;
     }
-    const root = path48.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths43(findProjectRoot47(root));
-    if (!existsSync67(paths.memoriesDir)) {
+    const root = path49.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths45(findProjectRoot49(root));
+    if (!existsSync70(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,
@@ -13446,14 +13841,14 @@ function registerMemoryTimeline(memory2) {
 }
 
 // src/commands/memory-conflict-candidates.ts
-import { existsSync as existsSync68 } from "fs";
-import path49 from "path";
+import { existsSync as existsSync71 } from "fs";
+import path50 from "path";
 import "commander";
 import {
   findLexicalConflictPairs as findLexicalConflictPairs2,
   findTopicStatusConflictPairs as findTopicStatusConflictPairs2,
-  findProjectRoot as findProjectRoot48,
-  resolveHaivePaths as resolveHaivePaths44
+  findProjectRoot as findProjectRoot50,
+  resolveHaivePaths as resolveHaivePaths46
 } from "@hiveai/core";
 function parseTypes(csv) {
   const allowed = ["decision", "architecture", "convention", "gotcha"];
@@ -13469,9 +13864,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 = path49.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths44(findProjectRoot48(root));
-    if (!existsSync68(paths.memoriesDir)) {
+    const root = path50.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths46(findProjectRoot50(root));
+    if (!existsSync71(paths.memoriesDir)) {
       ui.error("No memories \u2014 run `haive init`.");
       process.exitCode = 1;
       return;
@@ -13481,7 +13876,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),
@@ -13507,21 +13902,21 @@ function registerMemoryConflictCandidates(memory2) {
 
 // src/commands/enforce.ts
 import { execFileSync as execFileSync2, spawn as spawn6 } from "child_process";
-import { existsSync as existsSync69, statSync as statSync3 } from "fs";
-import { chmod as chmod2, mkdir as mkdir19, readFile as readFile21, readdir as readdir6, rm as rm3, writeFile as writeFile33 } from "fs/promises";
-import path50 from "path";
+import { existsSync as existsSync73, statSync as statSync3 } from "fs";
+import { chmod as chmod2, mkdir as mkdir19, readFile as readFile23, readdir as readdir6, rm as rm3, writeFile as writeFile34 } from "fs/promises";
+import path51 from "path";
 import "commander";
 import {
   antiPatternGateParams as antiPatternGateParams2,
-  findProjectRoot as findProjectRoot49,
+  findProjectRoot as findProjectRoot51,
   hasRecentBriefingMarker as hasRecentBriefingMarker2,
   isFreshIsoDate,
   loadConfig as loadConfig13,
-  loadMemoriesFromDir as loadMemoriesFromDir36,
+  loadMemoriesFromDir as loadMemoriesFromDir37,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths6,
   readRecentBriefingMarker,
   resolveBriefingBudget as resolveBriefingBudget3,
-  resolveHaivePaths as resolveHaivePaths45,
+  resolveHaivePaths as resolveHaivePaths47,
   saveConfig as saveConfig4,
   SESSION_RECAP_TTL_MS,
   verifyAnchor as verifyAnchor4,
@@ -13534,8 +13929,8 @@ function registerEnforce(program2) {
     "Agent-agnostic enforcement helpers: install policy gates, report status, and block unsafe workflows."
   );
   enforce.command("install").description("Install hAIve enforcement across MCP config, git hooks, CI template, and supported client hooks.").option("-d, --dir <dir>", "project root").option("--no-git", "skip git pre-commit/pre-push enforcement hooks").option("--no-claude", "skip Claude Code hooks").option("--no-ci", "skip GitHub Actions enforcement workflow").action(async (opts) => {
-    const root = findProjectRoot49(opts.dir);
-    const paths = resolveHaivePaths45(root);
+    const root = findProjectRoot51(opts.dir);
+    const paths = resolveHaivePaths47(root);
     await mkdir19(paths.haiveDir, { recursive: true });
     const current = await loadConfig13(paths);
     await saveConfig4(paths, {
@@ -13560,7 +13955,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 (${path50.relative(root, result.settingsPath)})`);
+        ui.success(`${result.created ? "Created" : "Patched"} Claude Code hooks (${path51.relative(root, result.settingsPath)})`);
       } catch (err) {
         ui.warn(`Claude Code hooks not installed: ${err instanceof Error ? err.message : String(err)}`);
       }
@@ -13579,21 +13974,21 @@ function registerEnforce(program2) {
     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 = findProjectRoot49(opts.dir);
-    const paths = resolveHaivePaths45(root);
-    const cacheDir = path50.join(paths.haiveDir, ".cache");
-    if (existsSync69(cacheDir)) {
-      if (opts.dryRun) ui.info(`would clean ${path50.relative(root, cacheDir)} (preserving .gitignore)`);
+    const root = findProjectRoot51(opts.dir);
+    const paths = resolveHaivePaths47(root);
+    const cacheDir = path51.join(paths.haiveDir, ".cache");
+    if (existsSync73(cacheDir)) {
+      if (opts.dryRun) ui.info(`would clean ${path51.relative(root, cacheDir)} (preserving .gitignore)`);
       else {
         const removed = await cleanupCacheDir(cacheDir);
-        ui.success(`cleaned ${path50.relative(root, cacheDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
+        ui.success(`cleaned ${path51.relative(root, cacheDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
       }
     }
-    if (existsSync69(paths.runtimeDir)) {
-      if (opts.dryRun) ui.info(`would clean ${path50.relative(root, paths.runtimeDir)} (preserving briefing markers)`);
+    if (existsSync73(paths.runtimeDir)) {
+      if (opts.dryRun) ui.info(`would clean ${path51.relative(root, paths.runtimeDir)} (preserving briefing markers)`);
       else {
         const removed = await cleanupRuntimeDir(paths.runtimeDir);
-        ui.success(`cleaned ${path50.relative(root, paths.runtimeDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
+        ui.success(`cleaned ${path51.relative(root, paths.runtimeDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
       }
     }
   });
@@ -13602,12 +13997,19 @@ function registerEnforce(program2) {
     printReport(report, Boolean(opts.json), Boolean(opts.explain));
     if (report.should_block) process.exit(2);
   });
+  enforce.command("finish").alias("completion").description(
+    "Final agent-exit gate: verify the git sync/release protocol before reporting a task done."
+  ).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 buildFinishReport(opts.dir);
+    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) => {
     const payload = await readHookPayload();
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
-    const paths = resolveHaivePaths45(root);
-    if (!existsSync69(paths.haiveDir)) return;
+    const paths = resolveHaivePaths47(root);
+    if (!existsSync73(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.";
@@ -13669,8 +14071,8 @@ ${briefing.project_context.content.slice(0, 1800)}`);
     const payload = await readHookPayload();
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
-    const paths = resolveHaivePaths45(root);
-    if (!existsSync69(paths.haiveDir)) return;
+    const paths = resolveHaivePaths47(root);
+    if (!existsSync73(paths.haiveDir)) return;
     if (!isWriteLikeTool(payload)) return;
     const ok = await hasRecentBriefingMarker2(paths, payload.session_id);
     if (ok) {
@@ -13711,10 +14113,206 @@ ${briefing.project_context.content.slice(0, 1800)}`);
     process.exit(2);
   });
 }
+async function buildFinishReport(dir) {
+  const root = findProjectRoot51(dir);
+  const paths = resolveHaivePaths47(root);
+  const initialized = existsSync73(paths.haiveDir);
+  const config = initialized ? await loadConfig13(paths) : {};
+  const mode = config.enforcement?.mode ?? "strict";
+  const findings = [];
+  if (!initialized) {
+    return withCategories({
+      root,
+      initialized,
+      mode,
+      score: buildScore([], config.enforcement?.scoreThreshold),
+      should_block: true,
+      findings: [{
+        severity: "error",
+        code: "not-initialized",
+        message: "This repository is not initialized with hAIve.",
+        fix: "Run `haive init` or `haive enforce install`.",
+        impact: 100
+      }]
+    });
+  }
+  const status = await getGitSyncStatus(root);
+  if (!status.available) {
+    findings.push({
+      severity: "error",
+      code: "git-unavailable",
+      message: "Git status could not be inspected, so hAIve cannot verify the exit protocol.",
+      fix: "Run `git status` manually, then commit/push according to the hAIve git-sync protocol.",
+      impact: 100
+    });
+    return finishReport(root, initialized, mode, findings, config);
+  }
+  const shippableDirty = status.dirtyFiles.filter(isShippablePath);
+  if (status.dirtyFiles.length > 0) {
+    findings.push({
+      severity: "error",
+      code: shippableDirty.length > 0 ? "git-sync-uncommitted-shippable" : "git-sync-uncommitted-changes",
+      message: shippableDirty.length > 0 ? `${shippableDirty.length} shippable file(s) are modified but not committed.` : `${status.dirtyFiles.length} file(s) are modified but not committed.`,
+      fix: shippableDirty.length > 0 ? "Bump the lockstep package version if needed, then `git add`, `git commit`, `git tag vX.Y.Z`, `git push && git push --tags`." : "Commit and push these changes before reporting the task done.",
+      reason: "The multi-agent git-sync decision requires agents to leave completed work committed and pushed, not as a local diff.",
+      affected_files: status.dirtyFiles.slice(0, 12),
+      impact: 100
+    });
+    return finishReport(root, initialized, mode, findings, config);
+  }
+  findings.push({
+    severity: "ok",
+    code: "git-worktree-clean",
+    message: "No uncommitted worktree changes remain."
+  });
+  if (!status.upstream) {
+    findings.push({
+      severity: "warn",
+      code: "git-sync-no-upstream",
+      message: "This branch has no upstream, so hAIve cannot verify that commits/tags were pushed.",
+      fix: "Set an upstream with `git push -u origin <branch>`.",
+      impact: 15
+    });
+    return finishReport(root, initialized, mode, findings, config);
+  }
+  if (status.behind > 0) {
+    findings.push({
+      severity: "error",
+      code: "git-sync-behind-upstream",
+      message: `This branch is ${status.behind} commit(s) behind ${status.upstream}.`,
+      fix: "Run `git pull --ff-only` and resolve any conflicts before finishing.",
+      impact: 40
+    });
+  }
+  if (status.ahead > 0) {
+    findings.push({
+      severity: "error",
+      code: "git-sync-unpushed-commits",
+      message: `This branch is ${status.ahead} commit(s) ahead of ${status.upstream}.`,
+      fix: "Run `git push` before reporting the task done.",
+      reason: "The multi-agent git-sync decision requires agents to push completed commits.",
+      impact: 60
+    });
+  } else {
+    findings.push({
+      severity: "ok",
+      code: "git-sync-pushed",
+      message: `Branch is not ahead of ${status.upstream}.`
+    });
+  }
+  const releaseChangedFiles = status.releaseChangedFiles ?? status.changedSinceUpstream;
+  const releaseBaseRef = status.releaseBaseRef ?? status.upstream;
+  const shippableChanged = releaseChangedFiles.filter(isShippablePath);
+  if (shippableChanged.length === 0) {
+    findings.push({
+      severity: "ok",
+      code: "release-version-not-required",
+      message: "No shippable package code changed since upstream; no version/tag required."
+    });
+    return finishReport(root, initialized, mode, findings, config);
+  }
+  findings.push({
+    severity: "info",
+    code: "release-shippable-changes",
+    message: `${shippableChanged.length} shippable file(s) changed since ${releaseBaseRef}.`,
+    affected_files: shippableChanged.slice(0, 12)
+  });
+  const versionState = await inspectReleaseVersionState(root, releaseBaseRef);
+  if (!versionState.lockstep) {
+    findings.push({
+      severity: "error",
+      code: "release-version-not-lockstep",
+      message: `Publishable package versions are not in lockstep: ${versionState.localVersionsLabel}.`,
+      fix: "Set root, core, cli, mcp, and embeddings package.json versions to the same X.Y.Z.",
+      impact: 60
+    });
+    return finishReport(root, initialized, mode, findings, config);
+  }
+  const version = versionState.version;
+  if (!version) {
+    findings.push({
+      severity: "error",
+      code: "release-version-unreadable",
+      message: "Could not read the lockstep package version.",
+      fix: "Verify package.json files are valid JSON.",
+      impact: 60
+    });
+    return finishReport(root, initialized, mode, findings, config);
+  }
+  if (versionState.baseVersion && compareSemver(version, versionState.baseVersion) <= 0) {
+    findings.push({
+      severity: "error",
+      code: "release-version-missing",
+      message: `Shippable code changed, but version stayed at ${version} (base: ${versionState.baseVersion}).`,
+      fix: "Bump the lockstep package version (patch by default), commit the bump, tag it, then push code and tags.",
+      impact: 70
+    });
+  } else {
+    findings.push({
+      severity: "ok",
+      code: "release-version-bumped",
+      message: versionState.baseVersion ? `Lockstep version bumped from ${versionState.baseVersion} to ${version}.` : `Lockstep version is ${version}.`
+    });
+  }
+  const tag = `v${version}`;
+  const localTagAtHead = await tagPointsAtHead(root, tag);
+  if (!localTagAtHead) {
+    findings.push({
+      severity: "error",
+      code: "release-tag-missing",
+      message: `Expected git tag ${tag} to point at HEAD.`,
+      fix: `Run \`git tag ${tag}\` after committing the version bump.`,
+      impact: 50
+    });
+  } else {
+    findings.push({
+      severity: "ok",
+      code: "release-tag-present",
+      message: `Tag ${tag} points at HEAD.`
+    });
+  }
+  const remoteTag = await remoteTagExists(root, tag);
+  if (remoteTag === false) {
+    findings.push({
+      severity: "error",
+      code: "release-tag-unpushed",
+      message: `Tag ${tag} is not present on the remote.`,
+      fix: "Run `git push --tags`.",
+      impact: 50
+    });
+  } else if (remoteTag === true) {
+    findings.push({
+      severity: "ok",
+      code: "release-tag-pushed",
+      message: `Tag ${tag} exists on the remote.`
+    });
+  } else {
+    findings.push({
+      severity: "warn",
+      code: "release-tag-remote-unverified",
+      message: `Could not verify whether tag ${tag} exists on the remote.`,
+      fix: "Run `git push --tags` if you have not already.",
+      impact: 10
+    });
+  }
+  return finishReport(root, initialized, mode, findings, config);
+}
+function finishReport(root, initialized, mode, findings, config) {
+  const score = buildScore(findings, config.enforcement?.scoreThreshold);
+  const hasErrors = findings.some((f) => f.severity === "error");
+  return withCategories({
+    root,
+    initialized,
+    mode,
+    score,
+    should_block: mode === "strict" && hasErrors,
+    findings
+  });
+}
 async function runWithEnforcement(command, args, opts) {
-  const root = findProjectRoot49(opts.dir);
-  const paths = resolveHaivePaths45(root);
-  if (!existsSync69(paths.haiveDir)) {
+  const root = findProjectRoot51(opts.dir);
+  const paths = resolveHaivePaths47(root);
+  if (!existsSync73(paths.haiveDir)) {
     ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
     process.exit(1);
   }
@@ -13733,7 +14331,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 ${path50.relative(root, briefingFile)} and exported as HAIVE_BRIEFING_FILE`);
+  ui.info(`Briefing written to ${path51.relative(root, briefingFile)} and exported as HAIVE_BRIEFING_FILE`);
   const child = spawn6(command, args, {
     cwd: root,
     stdio: "inherit",
@@ -13783,9 +14381,9 @@ async function writeWrapperBriefing(paths, sessionId, task) {
     source: "haive-run",
     memoryIds: briefing.memories.map((m) => m.id)
   });
-  const dir = path50.join(paths.runtimeDir, "enforcement", "briefings");
+  const dir = path51.join(paths.runtimeDir, "enforcement", "briefings");
   await mkdir19(dir, { recursive: true });
-  const file = path50.join(dir, `${sessionId}.md`);
+  const file = path51.join(dir, `${sessionId}.md`);
   const parts = [
     "# hAIve Briefing",
     "",
@@ -13803,13 +14401,13 @@ async function writeWrapperBriefing(paths, sessionId, task) {
   if (briefing.setup_warnings.length > 0) {
     parts.push("", "## Setup Warnings", ...briefing.setup_warnings.map((w) => `- ${w}`));
   }
-  await writeFile33(file, parts.join("\n") + "\n", "utf8");
+  await writeFile34(file, parts.join("\n") + "\n", "utf8");
   return file;
 }
 async function buildEnforcementReport(dir, stage, sessionId) {
-  const root = findProjectRoot49(dir);
-  const paths = resolveHaivePaths45(root);
-  const initialized = existsSync69(paths.haiveDir);
+  const root = findProjectRoot51(dir);
+  const paths = resolveHaivePaths47(root);
+  const initialized = existsSync73(paths.haiveDir);
   const config = initialized ? await loadConfig13(paths) : {};
   if (initialized) await applyLightweightRepairs(root, paths);
   const mode = config.enforcement?.mode ?? "strict";
@@ -13840,7 +14438,7 @@ async function buildEnforcementReport(dir, stage, sessionId) {
       findings: [{ severity: "info", code: "enforcement-off", message: "hAIve enforcement is disabled." }]
     });
   }
-  findings.push(...await inspectIntegrationVersions(root, "0.10.8"));
+  findings.push(...await inspectIntegrationVersions(root, "0.11.0"));
   if (config.enforcement?.requireBriefingFirst !== false && stage !== "ci") {
     const hasBriefing = await hasRecentBriefingMarker2(paths, sessionId);
     findings.push(hasBriefing ? { severity: "ok", code: "briefing-loaded", message: "A recent hAIve briefing marker exists." } : {
@@ -13874,7 +14472,7 @@ async function buildEnforcementReport(dir, stage, sessionId) {
     findings.push(...await verifyDecisionCoverage(paths, stage, sessionId));
   }
   if (stage === "pre-commit" || stage === "ci") {
-    findings.push(...await runPrecommitPolicy(paths, config.enforcement?.antiPatternGate ?? "anchored"));
+    findings.push(...await runPrecommitPolicy(paths, config.enforcement?.antiPatternGate ?? "anchored", stage));
   }
   if (config.enforcement?.cleanupGeneratedArtifacts !== false) {
     findings.push(...await findGeneratedArtifacts(paths));
@@ -13910,8 +14508,8 @@ function withCategories(report) {
   };
 }
 async function hasRecentSessionRecap(paths) {
-  if (!existsSync69(paths.memoriesDir)) return false;
-  const all = await loadMemoriesFromDir36(paths.memoriesDir);
+  if (!existsSync73(paths.memoriesDir)) return false;
+  const all = await loadMemoriesFromDir37(paths.memoriesDir);
   return all.some(({ memory: memory2 }) => {
     const fm = memory2.frontmatter;
     const freshnessDate = fm.verified_at ?? fm.created_at;
@@ -13919,8 +14517,8 @@ async function hasRecentSessionRecap(paths) {
   });
 }
 async function verifyMemoryPolicy(paths, config) {
-  if (!existsSync69(paths.memoriesDir)) return [];
-  const all = await loadMemoriesFromDir36(paths.memoriesDir);
+  if (!existsSync73(paths.memoriesDir)) return [];
+  const all = await loadMemoriesFromDir37(paths.memoriesDir);
   const findings = [];
   const staleImportant = [];
   let verified = 0;
@@ -13957,12 +14555,12 @@ async function verifyMemoryPolicy(paths, config) {
   return findings;
 }
 async function verifyDecisionCoverage(paths, stage, sessionId) {
-  if (!existsSync69(paths.memoriesDir)) return [];
+  if (!existsSync73(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." }];
   }
-  const all = await loadMemoriesFromDir36(paths.memoriesDir);
+  const all = await loadMemoriesFromDir37(paths.memoriesDir);
   const policyTypes = /* @__PURE__ */ new Set(["decision", "gotcha", "architecture", "convention"]);
   const relevant = all.map(({ memory: memory2 }) => memory2).filter((memory2) => {
     const fm = memory2.frontmatter;
@@ -13998,19 +14596,20 @@ async function verifyDecisionCoverage(paths, stage, sessionId) {
     impact: Math.min(35, 10 + missing.length * 5)
   }];
 }
-async function runPrecommitPolicy(paths, gate) {
+async function runPrecommitPolicy(paths, gate, stage) {
   if (gate === "off") {
     return [{ severity: "info", code: "precommit-policy-off", message: "Anti-pattern gate is disabled (enforcement.antiPatternGate=off)." }];
   }
-  const staged = await runCommand4("git", ["diff", "--cached", "--name-only"], paths.root).catch(() => "");
-  const touchedPaths = staged.split("\n").map((s) => s.trim()).filter(Boolean);
+  const snapshot = await getPolicyDiffSnapshot(paths.root, stage);
+  const touchedPaths = snapshot.paths;
   if (touchedPaths.length === 0) {
-    return [{ severity: "info", code: "no-staged-changes", message: "No staged changes found for pre-commit policy." }];
+    const code = stage === "ci" ? "no-ci-diff-changes" : "no-staged-changes";
+    const message = stage === "ci" ? "No changed files found for CI policy diff." : "No staged changes found for pre-commit policy.";
+    return [{ severity: "info", code, message }];
   }
-  const diff = await runCommand4("git", ["diff", "--cached"], paths.root).catch(() => "");
   const { block_on, anchored_blocks } = antiPatternGateParams2(gate);
   const result = await preCommitCheck({
-    diff,
+    diff: snapshot.diff,
     paths: touchedPaths,
     block_on,
     anchored_blocks,
@@ -14020,7 +14619,7 @@ async function runPrecommitPolicy(paths, gate) {
     return [{
       severity: "ok",
       code: "precommit-policy-pass",
-      message: `Pre-commit policy passed for ${touchedPaths.length} staged file(s).`
+      message: `${stage === "ci" ? "CI" : "Pre-commit"} policy passed for ${touchedPaths.length} changed file(s).`
     }];
   }
   return [{
@@ -14061,16 +14660,16 @@ async function cleanupRuntimeDir(runtimeDir) {
   for (const entry of entries) {
     if (entry.name === ".gitignore" || entry.name === "README.md") continue;
     if (entry.name === "enforcement") {
-      removed += await cleanupEnforcementDir(path50.join(runtimeDir, entry.name));
+      removed += await cleanupEnforcementDir(path51.join(runtimeDir, entry.name));
       continue;
     }
-    await rm3(path50.join(runtimeDir, entry.name), { recursive: true, force: true });
+    await rm3(path51.join(runtimeDir, entry.name), { recursive: true, force: true });
     removed++;
   }
-  await writeFile33(path50.join(runtimeDir, ".gitignore"), "*\n!.gitignore\n!README.md\n", "utf8");
-  if (!existsSync69(path50.join(runtimeDir, "README.md"))) {
-    await writeFile33(
-      path50.join(runtimeDir, "README.md"),
+  await writeFile34(path51.join(runtimeDir, ".gitignore"), "*\n!.gitignore\n!README.md\n", "utf8");
+  if (!existsSync73(path51.join(runtimeDir, "README.md"))) {
+    await writeFile34(
+      path51.join(runtimeDir, "README.md"),
       "# .ai/.runtime \u2014 disposable local layer\n\nRuntime data is local. hAIve cleanup preserves briefing markers so enforcement state remains valid.\n",
       "utf8"
     );
@@ -14083,10 +14682,10 @@ async function cleanupCacheDir(cacheDir) {
   const entries = await readdir6(cacheDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.name === ".gitignore") continue;
-    await rm3(path50.join(cacheDir, entry.name), { recursive: true, force: true });
+    await rm3(path51.join(cacheDir, entry.name), { recursive: true, force: true });
     removed++;
   }
-  await writeFile33(path50.join(cacheDir, ".gitignore"), "*\n!.gitignore\n", "utf8");
+  await writeFile34(path51.join(cacheDir, ".gitignore"), "*\n!.gitignore\n", "utf8");
   return removed;
 }
 async function cleanupEnforcementDir(enforcementDir) {
@@ -14094,7 +14693,7 @@ async function cleanupEnforcementDir(enforcementDir) {
   const entries = await readdir6(enforcementDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.name === "briefings") continue;
-    await rm3(path50.join(enforcementDir, entry.name), { recursive: true, force: true });
+    await rm3(path51.join(enforcementDir, entry.name), { recursive: true, force: true });
     removed++;
   }
   return removed;
@@ -14110,9 +14709,9 @@ async function inspectIntegrationVersions(root, expectedVersion) {
   ];
   const findings = [];
   for (const rel of files) {
-    const file = path50.join(root, rel);
-    if (!existsSync69(file)) continue;
-    const text = await readFile21(file, "utf8").catch(() => "");
+    const file = path51.join(root, rel);
+    if (!existsSync73(file)) continue;
+    const text = await readFile23(file, "utf8").catch(() => "");
     for (const bin of extractAbsoluteHaiveBins2(text)) {
       const version = versionForBinary2(bin);
       if (!version) {
@@ -14171,22 +14770,217 @@ function versionForBinary2(bin) {
   }
 }
 async function getChangedFiles(root, stage) {
-  const commands = stage === "pre-commit" ? [["diff", "--cached", "--name-only"]] : [
-    ["diff", "--cached", "--name-only"],
-    ["diff", "--name-only"]
-  ];
+  if (stage === "ci") {
+    return (await getPolicyDiffSnapshot(root, "ci")).paths;
+  }
+  if (stage === "pre-commit") {
+    return normalizeChangedFileList(
+      await runCommand4("git", ["diff", "--cached", "--name-only"], root).catch(() => "")
+    );
+  }
   const files = /* @__PURE__ */ new Set();
-  for (const args of commands) {
-    const out = await runCommand4("git", args, root).catch(() => "");
-    for (const line of out.split("\n")) {
-      const file = line.trim();
-      if (file) files.add(file);
-    }
+  for (const args of [["diff", "--cached", "--name-only"], ["diff", "--name-only"]]) {
+    for (const file of normalizeChangedFileList(await runCommand4("git", args, root).catch(() => ""))) {
+      files.add(file);
+    }
+  }
+  return [...files];
+}
+async function getPolicyDiffSnapshot(root, stage) {
+  if (stage === "pre-commit") {
+    const diff = await runCommand4("git", ["diff", "--cached"], root).catch(() => "");
+    const names = await runCommand4("git", ["diff", "--cached", "--name-only"], root).catch(() => "");
+    return { diff, paths: normalizeChangedFileList(names), source: "staged" };
+  }
+  const range = await resolveCiDiffRange(root);
+  if (range) {
+    const diff = await runCommand4("git", ["diff", range], root).catch(() => "");
+    const names = await runCommand4("git", ["diff", "--name-only", range], root).catch(() => "");
+    return { diff, paths: normalizeChangedFileList(names), source: range };
+  }
+  return { diff: "", paths: [], source: "none" };
+}
+async function resolveCiDiffRange(root) {
+  const explicitBase = cleanGitSha(process.env.HAIVE_BASE_SHA ?? process.env.HAIVE_BASE_REF);
+  const explicitHead = cleanGitSha(process.env.HAIVE_HEAD_SHA ?? process.env.GITHUB_SHA) ?? "HEAD";
+  if (explicitBase && await gitCommitExists(root, explicitBase)) {
+    return `${explicitBase}...${explicitHead}`;
+  }
+  const eventRange = await resolveGithubEventRange(root);
+  if (eventRange) return eventRange;
+  const baseRef = process.env.GITHUB_BASE_REF?.trim();
+  if (baseRef) {
+    const remoteRef = `origin/${baseRef}`;
+    if (await gitCommitExists(root, remoteRef)) return `${remoteRef}...${explicitHead}`;
+  }
+  if (await gitCommitExists(root, "origin/main")) return `origin/main...${explicitHead}`;
+  if (await gitCommitExists(root, "origin/master")) return `origin/master...${explicitHead}`;
+  if (await gitCommitExists(root, "HEAD^")) return `HEAD^..${explicitHead}`;
+  return null;
+}
+async function resolveGithubEventRange(root) {
+  const eventPath = process.env.GITHUB_EVENT_PATH;
+  if (!eventPath || !existsSync73(eventPath)) return null;
+  try {
+    const event = JSON.parse(await readFile23(eventPath, "utf8"));
+    const prBase = cleanGitSha(event.pull_request?.base?.sha);
+    const prHead = cleanGitSha(event.pull_request?.head?.sha ?? event.after ?? process.env.GITHUB_SHA) ?? "HEAD";
+    if (prBase && await gitCommitExists(root, prBase)) return `${prBase}...${prHead}`;
+    const pushBase = cleanGitSha(event.before);
+    const pushHead = cleanGitSha(event.after ?? process.env.GITHUB_SHA) ?? "HEAD";
+    if (pushBase && await gitCommitExists(root, pushBase)) return `${pushBase}..${pushHead}`;
+  } catch {
+    return null;
+  }
+  return null;
+}
+function cleanGitSha(value) {
+  const trimmed = value?.trim();
+  if (!trimmed || /^0+$/.test(trimmed)) return null;
+  return trimmed;
+}
+async function gitCommitExists(root, ref) {
+  try {
+    await runCommand4("git", ["rev-parse", "--verify", `${ref}^{commit}`], root);
+    return true;
+  } catch {
+    return false;
   }
-  return [...files].filter(
+}
+function normalizeChangedFileList(raw) {
+  return raw.split("\n").map((s) => s.trim()).filter(Boolean).filter(
     (file) => !file.startsWith(".ai/.runtime/") && !file.startsWith(".ai/.cache/") && !file.startsWith(".ai/.usage/") && file !== ".ai/.usage/tool-usage.jsonl"
   );
 }
+async function getGitSyncStatus(root) {
+  const dirty = (await runCommand4("git", ["status", "--short", "--untracked-files=all"], root).catch(() => "")).split("\n").map((line) => statusLineToPath(line.trim())).filter(Boolean).filter((file) => normalizeChangedFileList(file).length > 0);
+  const branch = (await runCommand4("git", ["branch", "--show-current"], root).catch(() => "")).trim() || void 0;
+  const upstream = (await runCommand4("git", ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], root).catch(() => "")).trim() || void 0;
+  if (!branch && !upstream) {
+    const inside = (await runCommand4("git", ["rev-parse", "--is-inside-work-tree"], root).catch(() => "")).trim();
+    if (inside !== "true") return { available: false, ahead: 0, behind: 0, dirtyFiles: [], changedSinceUpstream: [] };
+  }
+  let ahead = 0;
+  let behind = 0;
+  let changedSinceUpstream = [];
+  let releaseBaseRef;
+  let releaseChangedFiles;
+  if (upstream) {
+    const counts = (await runCommand4("git", ["rev-list", "--left-right", "--count", `${upstream}...HEAD`], root).catch(() => "")).trim();
+    const [behindRaw, aheadRaw] = counts.split(/\s+/);
+    behind = Number.parseInt(behindRaw ?? "0", 10) || 0;
+    ahead = Number.parseInt(aheadRaw ?? "0", 10) || 0;
+    changedSinceUpstream = normalizeChangedFileList(
+      await runCommand4("git", ["diff", "--name-only", `${upstream}...HEAD`], root).catch(() => "")
+    );
+    if (changedSinceUpstream.length > 0) {
+      releaseBaseRef = upstream;
+      releaseChangedFiles = changedSinceUpstream;
+    }
+  }
+  if (!releaseChangedFiles || releaseChangedFiles.length === 0) {
+    const hasParent = (await runCommand4("git", ["rev-parse", "--verify", "--quiet", "HEAD^"], root).catch(() => "")).trim().length > 0;
+    if (hasParent) {
+      const changedSinceParent = normalizeChangedFileList(
+        await runCommand4("git", ["diff", "--name-only", "HEAD^..HEAD"], root).catch(() => "")
+      );
+      if (changedSinceParent.length > 0) {
+        releaseBaseRef = "HEAD^";
+        releaseChangedFiles = changedSinceParent;
+      }
+    }
+  }
+  return {
+    available: true,
+    branch,
+    upstream,
+    ahead,
+    behind,
+    dirtyFiles: dirty,
+    changedSinceUpstream,
+    ...releaseBaseRef ? { releaseBaseRef } : {},
+    ...releaseChangedFiles ? { releaseChangedFiles } : {}
+  };
+}
+function statusLineToPath(line) {
+  const body = line.replace(/^[ MADRCU?!]{1,2}\s+/, "").trim();
+  const renamed = body.match(/.+ -> (.+)$/);
+  return renamed?.[1]?.trim() ?? body;
+}
+var VERSION_FILES = [
+  "package.json",
+  "packages/core/package.json",
+  "packages/cli/package.json",
+  "packages/mcp/package.json",
+  "packages/embeddings/package.json"
+];
+var SHIPPABLE_PATH_PREFIXES = [
+  "packages/core/src/",
+  "packages/cli/src/",
+  "packages/mcp/src/",
+  "packages/embeddings/src/"
+];
+function isShippablePath(file) {
+  return SHIPPABLE_PATH_PREFIXES.some((prefix) => file.startsWith(prefix)) || VERSION_FILES.includes(file);
+}
+async function inspectReleaseVersionState(root, upstream) {
+  const localEntries = await Promise.all(VERSION_FILES.map(async (file) => [file, await readPackageVersion(root, file)]));
+  const localVersions = new Map(localEntries);
+  const unique = new Set([...localVersions.values()].filter(Boolean));
+  const version = unique.size === 1 ? [...unique][0] : void 0;
+  const localVersionsLabel = VERSION_FILES.map((file) => `${file}=${localVersions.get(file) ?? "unreadable"}`).join(", ");
+  const baseVersion = await readPackageVersionAtRef(root, upstream, "package.json");
+  return {
+    lockstep: unique.size === 1 && localVersions.size === VERSION_FILES.length,
+    ...version ? { version } : {},
+    ...baseVersion ? { baseVersion } : {},
+    localVersionsLabel
+  };
+}
+async function readPackageVersion(root, relPath) {
+  try {
+    const data = JSON.parse(await readFile23(path51.join(root, relPath), "utf8"));
+    return typeof data.version === "string" ? data.version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function readPackageVersionAtRef(root, ref, relPath) {
+  try {
+    const raw = await runCommand4("git", ["show", `${ref}:${relPath}`], root);
+    const data = JSON.parse(raw);
+    return typeof data.version === "string" ? data.version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function compareSemver(a, b) {
+  const pa = a.split(/[.-]/).map((part) => Number.parseInt(part, 10) || 0);
+  const pb = b.split(/[.-]/).map((part) => Number.parseInt(part, 10) || 0);
+  const len = Math.max(pa.length, pb.length, 3);
+  for (let i = 0; i < len; i++) {
+    const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+async function tagPointsAtHead(root, tag) {
+  const tags = await runCommand4("git", ["tag", "--points-at", "HEAD"], root).catch(() => "");
+  return tags.split("\n").map((line) => line.trim()).includes(tag);
+}
+async function remoteTagExists(root, tag) {
+  const branch = (await runCommand4("git", ["branch", "--show-current"], root).catch(() => "")).trim();
+  const branchRemote = branch ? (await runCommand4("git", ["config", "--get", `branch.${branch}.remote`], root).catch(() => "")).trim() : "";
+  const hasOrigin = (await runCommand4("git", ["config", "--get", "remote.origin.url"], root).catch(() => "")).trim().length > 0;
+  const remote = branchRemote || (hasOrigin ? "origin" : "");
+  if (!remote) return null;
+  try {
+    const out = await runCommand4("git", ["ls-remote", "--tags", remote, `refs/tags/${tag}`], root);
+    return out.trim().length > 0;
+  } catch {
+    return null;
+  }
+}
 function buildScore(findings, threshold = 80) {
   const checks = {
     total: findings.length,
@@ -14206,8 +15000,8 @@ function buildScore(findings, threshold = 80) {
   };
 }
 async function installGitEnforcement(root) {
-  const hooksDir = path50.join(root, ".git", "hooks");
-  if (!existsSync69(path50.join(root, ".git"))) {
+  const hooksDir = path51.join(root, ".git", "hooks");
+  if (!existsSync73(path51.join(root, ".git"))) {
     ui.warn("No .git directory found; git enforcement hooks skipped.");
     return;
   }
@@ -14229,31 +15023,31 @@ haive enforce check --stage pre-push --dir . || exit $?
     }
   ];
   for (const hook of hooks) {
-    const file = path50.join(hooksDir, hook.name);
-    if (existsSync69(file)) {
-      const current = await readFile21(file, "utf8").catch(() => "");
+    const file = path51.join(hooksDir, hook.name);
+    if (existsSync73(file)) {
+      const current = await readFile23(file, "utf8").catch(() => "");
       if (current.includes(ENFORCE_HOOK_MARKER)) {
-        await writeFile33(file, hook.body, "utf8");
+        await writeFile34(file, hook.body, "utf8");
       } else {
-        await writeFile33(file, `${current.trimEnd()}
+        await writeFile34(file, `${current.trimEnd()}
 
 ${hook.body}`, "utf8");
       }
     } else {
-      await writeFile33(file, hook.body, "utf8");
+      await writeFile34(file, hook.body, "utf8");
     }
     await chmod2(file, 493);
   }
   ui.success("Installed blocking git enforcement hooks: pre-commit, pre-push");
 }
 async function installCiEnforcement(root) {
-  const workflowPath = path50.join(root, ".github", "workflows", "haive-enforcement.yml");
-  await mkdir19(path50.dirname(workflowPath), { recursive: true });
-  if (existsSync69(workflowPath)) {
+  const workflowPath = path51.join(root, ".github", "workflows", "haive-enforcement.yml");
+  await mkdir19(path51.dirname(workflowPath), { recursive: true });
+  if (existsSync73(workflowPath)) {
     ui.info("GitHub Actions enforcement workflow already exists \u2014 skipped");
     return;
   }
-  await writeFile33(workflowPath, `name: haive-enforcement
+  await writeFile34(workflowPath, `name: haive-enforcement
 
 on:
   pull_request:
@@ -14275,9 +15069,12 @@ jobs:
       - name: Install hAIve
         run: npm install -g @hiveai/cli
       - name: Enforce hAIve policy
+        env:
+          HAIVE_BASE_SHA: \${{ github.event.pull_request.base.sha || github.event.before }}
+          HAIVE_HEAD_SHA: \${{ github.event.pull_request.head.sha || github.sha }}
         run: haive enforce ci
 `, "utf8");
-  ui.success(`Created ${path50.relative(root, workflowPath)}`);
+  ui.success(`Created ${path51.relative(root, workflowPath)}`);
 }
 function printReport(report, json, explain = false) {
   if (json) {
@@ -14337,7 +15134,7 @@ async function readHookPayload() {
 }
 function resolveRoot(dir, payload) {
   try {
-    return findProjectRoot49(dir ?? payload.cwd);
+    return findProjectRoot51(dir ?? payload.cwd);
   } catch {
     return null;
   }
@@ -14374,15 +15171,15 @@ function extractToolPaths(payload, root) {
 }
 function normalizeToolPath(file, root) {
   const normalized = file.replace(/\\/g, "/");
-  if (!path50.isAbsolute(normalized)) return normalized.replace(/^\.\//, "");
-  return path50.relative(root, normalized).replace(/\\/g, "/");
+  if (!path51.isAbsolute(normalized)) return normalized.replace(/^\.\//, "");
+  return path51.relative(root, normalized).replace(/\\/g, "/");
 }
 async function missingRequiredMemoriesForFiles(paths, files, sessionId) {
-  if (!existsSync69(paths.memoriesDir)) return [];
+  if (!existsSync73(paths.memoriesDir)) return [];
   const marker = await readRecentBriefingMarker(paths, sessionId);
   const consulted = new Set(marker?.memory_ids ?? []);
   const policyTypes = /* @__PURE__ */ new Set(["decision", "gotcha", "architecture", "convention", "attempt"]);
-  const all = await loadMemoriesFromDir36(paths.memoriesDir);
+  const all = await loadMemoriesFromDir37(paths.memoriesDir);
   return all.filter(({ memory: memory2 }) => {
     const fm = memory2.frontmatter;
     if (!policyTypes.has(fm.type)) return false;
@@ -14452,16 +15249,16 @@ function registerRun(program2) {
 
 // src/commands/sensors.ts
 import { execFile as execFile2 } from "child_process";
-import { existsSync as existsSync70 } from "fs";
-import { chmod as chmod3, mkdir as mkdir20, readFile as readFile23, writeFile as writeFile34 } from "fs/promises";
-import path51 from "path";
+import { existsSync as existsSync74 } from "fs";
+import { chmod as chmod3, mkdir as mkdir20, readFile as readFile24, writeFile as writeFile35 } from "fs/promises";
+import path53 from "path";
 import { promisify as promisify2 } from "util";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot50,
+  findProjectRoot as findProjectRoot52,
   isRetiredMemory as isRetiredMemory3,
-  loadMemoriesFromDir as loadMemoriesFromDir37,
-  resolveHaivePaths as resolveHaivePaths46,
+  loadMemoriesFromDir as loadMemoriesFromDir38,
+  resolveHaivePaths as resolveHaivePaths48,
   runSensors as runSensors2,
   sensorTargetsFromDiff as sensorTargetsFromDiff2,
   serializeMemory as serializeMemory26
@@ -14470,8 +15267,8 @@ var exec2 = promisify2(execFile2);
 function registerSensors(program2) {
   const sensors = program2.command("sensors").description("Operate executable sensors derived from hAIve memories");
   sensors.command("list").description("List memories carrying executable sensors").option("--json", "emit JSON", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot50(opts.dir);
-    const paths = resolveHaivePaths46(root);
+    const root = findProjectRoot52(opts.dir);
+    const paths = resolveHaivePaths48(root);
     const rows = await sensorRows(paths);
     if (opts.json) {
       console.log(JSON.stringify(rows, null, 2));
@@ -14491,10 +15288,10 @@ function registerSensors(program2) {
     }
   });
   sensors.command("check").description("Run regex sensors against a diff; defaults to `git diff --cached`").option("--diff-file <path>", "read unified diff from a file instead of staged changes").option("--json", "emit JSON", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot50(opts.dir);
-    const paths = resolveHaivePaths46(root);
+    const root = findProjectRoot52(opts.dir);
+    const paths = resolveHaivePaths48(root);
     const memories = await runnableSensorMemories(paths);
-    const diff = opts.diffFile ? await readFile23(path51.resolve(root, opts.diffFile), "utf8") : await stagedDiff(root);
+    const diff = opts.diffFile ? await readFile24(path53.resolve(root, opts.diffFile), "utf8") : await stagedDiff(root);
     const targets = sensorTargetsFromDiff2(diff);
     const hits = runSensors2(memories, targets.length > 0 ? targets : [{ path: "", content: diff }]);
     const output = {
@@ -14533,9 +15330,9 @@ function registerSensors(program2) {
       process.exitCode = 1;
       return;
     }
-    const root = findProjectRoot50(opts.dir);
-    const paths = resolveHaivePaths46(root);
-    const loaded = existsSync70(paths.memoriesDir) ? await loadMemoriesFromDir37(paths.memoriesDir) : [];
+    const root = findProjectRoot52(opts.dir);
+    const paths = resolveHaivePaths48(root);
+    const loaded = existsSync74(paths.memoriesDir) ? await loadMemoriesFromDir38(paths.memoriesDir) : [];
     const found = loaded.find(({ memory: memory2 }) => memory2.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory found with id ${id}`);
@@ -14555,7 +15352,7 @@ function registerSensors(program2) {
       },
       body: found.memory.body
     };
-    await writeFile34(found.filePath, serializeMemory26(next), "utf8");
+    await writeFile35(found.filePath, serializeMemory26(next), "utf8");
     ui.success(`Updated ${id}: sensor severity=${severity}`);
     if (sensor.pattern) ui.info(`pattern=${JSON.stringify(sensor.pattern)}`);
     ui.info(`message=${sensor.message}`);
@@ -14567,16 +15364,16 @@ function registerSensors(program2) {
       process.exitCode = 1;
       return;
     }
-    const root = findProjectRoot50(opts.dir);
-    const paths = resolveHaivePaths46(root);
+    const root = findProjectRoot52(opts.dir);
+    const paths = resolveHaivePaths48(root);
     const rows = await sensorRows(paths);
-    const outDir = path51.resolve(root, opts.outDir ?? ".ai/generated");
+    const outDir = path53.resolve(root, opts.outDir ?? ".ai/generated");
     await mkdir20(outDir, { recursive: true });
-    const outPath = path51.join(outDir, format === "grep" ? "haive-sensors-grep.sh" : "haive-sensors-eslint.json");
+    const outPath = path53.join(outDir, format === "grep" ? "haive-sensors-grep.sh" : "haive-sensors-eslint.json");
     const content = format === "grep" ? renderGrepScript(rows) : JSON.stringify({ sensors: rows }, null, 2) + "\n";
-    await writeFile34(outPath, content, "utf8");
+    await writeFile35(outPath, content, "utf8");
     if (format === "grep") await chmod3(outPath, 493);
-    ui.success(`Exported ${rows.length} sensor(s): ${path51.relative(root, outPath)}`);
+    ui.success(`Exported ${rows.length} sensor(s): ${path53.relative(root, outPath)}`);
   });
 }
 async function sensorRows(paths) {
@@ -14597,8 +15394,8 @@ async function sensorRows(paths) {
   });
 }
 async function runnableSensorMemories(paths, regexOnly = true) {
-  if (!existsSync70(paths.memoriesDir)) return [];
-  const loaded = await loadMemoriesFromDir37(paths.memoriesDir);
+  if (!existsSync74(paths.memoriesDir)) return [];
+  const loaded = await loadMemoriesFromDir38(paths.memoriesDir);
   return loaded.map(({ memory: memory2 }) => memory2).filter((memory2) => {
     const sensor = memory2.frontmatter.sensor;
     if (!sensor) return false;
@@ -14639,8 +15436,8 @@ function shellQuote(value) {
 }
 
 // src/index.ts
-var program = new Command53();
-program.name("haive").description("hAIve - repo-native memory and context policy for coding-agent harnesses").version("0.10.8").option("--advanced", "show maintenance and experimental commands in help");
+var program = new Command55();
+program.name("haive").description("hAIve - repo-native memory and context policy for coding-agent harnesses").version("0.11.0").option("--advanced", "show maintenance and experimental commands in help");
 registerInit(program);
 registerWelcome(program);
 registerResolveProject(program);
@@ -14664,6 +15461,7 @@ registerMemoryQuery(memory);
 registerMemoryPromote(memory);
 registerMemoryVerify(memory);
 registerMemoryStats(memory);
+registerMemoryImpact(memory);
 registerMemoryReject(memory);
 registerMemoryAutoPromote(memory);
 registerMemoryForFiles(memory);
@@ -14694,6 +15492,7 @@ registerHub(program);
 registerStats(program);
 registerBench(program);
 registerBenchmark(program);
+registerEval(program);
 registerDoctor(program);
 registerPlayback(program);
 registerPrecommit(program);