@hiveai/cli 0.11.0 → 0.12.1

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command55 } from "commander";
+import { Command as Command56 } from "commander";
 
 // src/commands/briefing.ts
 import { existsSync as existsSync3 } from "fs";
@@ -2743,7 +2743,7 @@ ${SEED_FOOTER(stack)}` });
 }
 
 // src/commands/init.ts
-var HAIVE_GITHUB_ACTION_REF = `v${"0.11.0"}`;
+var HAIVE_GITHUB_ACTION_REF = `v${"0.12.1"}`;
 var PROJECT_CONTEXT_TEMPLATE = `# Project context
 
 > Generated by \`haive init\`. Run \`haive init --bootstrap\` to auto-fill from your codebase,
@@ -3782,6 +3782,7 @@ import {
   loadMemoriesFromDir as loadMemoriesFromDir14,
   loadUsageIndex as loadUsageIndex8,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths22,
+  rankMemoriesLexical as rankMemoriesLexical2,
   queryCodeMap as queryCodeMap2,
   resolveBriefingBudget as resolveBriefingBudget2,
   serializeMemory as serializeMemory9,
@@ -3822,7 +3823,10 @@ import { z as z24 } from "zod";
 import { existsSync as existsSync24 } from "fs";
 import {
   addedLinesFromDiff,
+  buildDocFrequency,
+  CODE_STOPWORDS,
   deriveConfidence as deriveConfidence6,
+  diffHasDistinctiveOverlap,
   getUsage as getUsage8,
   isRetiredMemory as isRetiredMemory2,
   loadMemoriesFromDir as loadMemoriesFromDir18,
@@ -5469,13 +5473,25 @@ async function getBriefing(input, ctx) {
       }
       if (act.applicable && act.activated) activatedSkills.add(id);
     }
+    const lexNorm = /* @__PURE__ */ new Map();
+    if (input.task) {
+      const candidates = [...seen.keys()].map((id) => byId.get(id)).filter((x) => Boolean(x));
+      const lex = rankMemoriesLexical2(candidates, input.task, candidates.length);
+      const maxScore = lex.scores.reduce((m, s) => s > m ? s : m, 0);
+      if (maxScore > 0) {
+        lex.ranked.forEach((loaded, i) => {
+          lexNorm.set(loaded.memory.frontmatter.id, (lex.scores[i] ?? 0) / maxScore);
+        });
+      }
+    }
     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 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);
+      const lexScore = (m) => 12 * (lexNorm.get(m.id) ?? 0);
+      const sa = priorityRank(classifyMemoryPriority(a, byId.get(a.id), input.files, input.symbols)) * 100 + reasonScore(a) + confidenceScore(a) + impactScore(a) + activationBoost(a) + lexScore(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) + lexScore(b) + (b.semantic_score ?? 0);
       return sb - sa;
     });
     for (const mem of ranked.slice(0, briefingMaxMemories)) {
@@ -6145,53 +6161,6 @@ var AntiPatternsCheckInputSchema = {
     "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."
   )
 };
-var CODE_STOPWORDS = /* @__PURE__ */ new Set([
-  "import",
-  "export",
-  "function",
-  "return",
-  "const",
-  "let",
-  "var",
-  "class",
-  "public",
-  "private",
-  "protected",
-  "static",
-  "this",
-  "true",
-  "false",
-  "null",
-  "undefined",
-  "void",
-  "async",
-  "await",
-  "from",
-  "type",
-  "interface",
-  "extends",
-  "implements",
-  "number",
-  "string",
-  "boolean",
-  "value",
-  "default",
-  "case",
-  "break",
-  "continue",
-  "throw",
-  "catch",
-  "finally",
-  "else",
-  "while",
-  "for",
-  "new",
-  "super",
-  "yield",
-  "module",
-  "require",
-  "console"
-]);
 function tokenizeDiffForLiteral(diff) {
   const lines = diff.split("\n");
   const looksLikeDiff = lines.some((l) => /^[+-]/.test(l));
@@ -6224,6 +6193,7 @@ async function antiPatternsCheck(input, ctx) {
     return { scanned: 0, warnings: [], notice: "No attempt/gotcha memories found yet." };
   }
   const usage = await loadUsageIndex10(ctx.paths);
+  const docFreq = buildDocFrequency(negative.map(({ memory: memory2 }) => memory2.body));
   const seen = /* @__PURE__ */ new Map();
   const upsert = (fm, body, reason, score) => {
     const existing = seen.get(fm.id);
@@ -6257,10 +6227,16 @@ async function antiPatternsCheck(input, ctx) {
   }
   if (input.diff) {
     const tokens = tokenizeDiffForLiteral(input.diff);
+    const added = addedLinesFromDiff(input.diff);
+    const addedText = added.trim().length > 0 ? added : input.diff;
     if (tokens.length > 0) {
       for (const { memory: memory2 } of negative) {
         if (literalMatchesAnyToken3(memory2, tokens)) {
           upsert(memory2.frontmatter, memory2.body, "literal");
+          if (diffHasDistinctiveOverlap(addedText, memory2.body, docFreq)) {
+            const w = seen.get(memory2.frontmatter.id);
+            if (w) w.distinctive_literal = true;
+          }
         }
       }
     }
@@ -6858,7 +6834,12 @@ 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.scope !== "personal" && warning.reasons.includes("anchor") && (warning.reasons.includes("literal") || hasSemantic && semanticScore >= 0.45)) {
+  if (anchoredBlocks && highConfidence && warning.scope !== "personal" && warning.reasons.includes("anchor") && // A literal overlap only corroborates a BLOCK when it is on a token *distinctive*
+  // to this gotcha (rare in the corpus). Sharing a common domain word ("memory",
+  // "scope", "version") — or a version-bump diff — no longer hard-blocks; it falls
+  // through to `review` below. This kills the incidental-token false positives that
+  // made agents work for nothing. A moderate semantic match still corroborates.
+  (warning.distinctive_literal === true || hasSemantic && semanticScore >= 0.45)) {
     if (warning.has_sensor && !warning.reasons.includes("sensor")) {
       return {
         ...warning,
@@ -7550,7 +7531,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
   };
 }
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.11.0";
+var SERVER_VERSION = "0.12.1";
 function jsonResult(data) {
   return {
     content: [
@@ -9126,7 +9107,7 @@ function registerMemoryAdd(memory2) {
     haive memory add --type convention --slug flyway-no-modify --topic flyway \\\\
       --scope team --body "Never modify existing migrations. Create V{n+1}__desc.sql."
 `
-  ).requiredOption("--type <type>", "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) => {
+  ).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("--activation-keyword <csv>", "skill only: comma-separated keywords that trigger progressive disclosure of this skill").option("--activation-glob <csv>", "skill only: comma-separated path globs that trigger this skill").option("--activation-always", "skill only: always surface this skill (no triggers needed)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot13(opts.dir);
     const paths = resolveHaivePaths10(root);
     if (!existsSync33(paths.haiveDir)) {
@@ -9137,6 +9118,11 @@ function registerMemoryAdd(memory2) {
     const config = await loadConfig5(paths);
     const userTags = parseCsv2(opts.tags);
     const anchorPaths = parseCsv2(opts.paths ?? opts.files);
+    const activation = opts.type === "skill" && (opts.activationKeyword || opts.activationGlob || opts.activationAlways) ? {
+      keywords: parseCsv2(opts.activationKeyword),
+      globs: parseCsv2(opts.activationGlob),
+      always: Boolean(opts.activationAlways)
+    } : void 0;
     const autoTagsEnabled = opts.autoTag !== false;
     const inferredTags = autoTagsEnabled ? inferModulesFromPaths3(anchorPaths) : [];
     const mergedTags = Array.from(/* @__PURE__ */ new Set([...userTags, ...inferredTags]));
@@ -9194,6 +9180,7 @@ TODO \u2014 write the memory body.
         const newFrontmatter = {
           ...fm,
           revision_count: revisionCount,
+          ...activation ? { activation } : {},
           tags: mergedTags.length ? mergedTags : fm.tags,
           anchor: {
             commit: opts.commit ?? fm.anchor.commit,
@@ -9224,7 +9211,8 @@ TODO \u2014 write the memory body.
       commit: opts.commit,
       topic: opts.topic,
       status: config.defaultStatus === "validated" ? "validated" : void 0,
-      sensor: suggestSensorForCliMemory(opts.type, body, anchorPaths) ?? void 0
+      sensor: suggestSensorForCliMemory(opts.type, body, anchorPaths) ?? void 0,
+      activation
     });
     const file = memoryFilePath6(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
     await mkdir11(path16.dirname(file), { recursive: true });
@@ -10556,14 +10544,68 @@ function pad(value, width) {
   return value.slice(0, width - 1) + "\u2026";
 }
 
-// src/commands/memory-verify.ts
-import { writeFile as writeFile21 } from "fs/promises";
+// src/commands/memory-feedback.ts
 import { existsSync as existsSync53 } from "fs";
-import path34 from "path";
 import "commander";
 import {
+  computeImpact as computeImpact4,
   findProjectRoot as findProjectRoot31,
+  getUsage as getUsage19,
+  loadUsageIndex as loadUsageIndex24,
+  recordApplied as recordApplied2,
+  recordRejection as recordRejection4,
   resolveHaivePaths as resolveHaivePaths28,
+  saveUsageIndex as saveUsageIndex6
+} from "@hiveai/core";
+function registerMemoryFeedback(memory2) {
+  memory2.command("feedback <id>").description(
+    "Record whether a memory actually helped \u2014 the closed-loop utility signal (mirror of the mem_feedback MCP tool). 'applied' = it steered your work; 'rejected' = it was wrong/unhelpful. Feeds `haive memory impact`."
+  ).option("--applied", "the memory changed what you did (positive signal)", false).option("--rejected", "the memory was wrong/outdated/unhelpful (negative signal)", false).option("--reason <text>", "why it was rejected (stored on the usage record)").option("--json", "emit JSON", false).option("-d, --dir <dir>", "project root").action(async (id, opts) => {
+    if (opts.applied === opts.rejected) {
+      ui.error("Specify exactly one of --applied or --rejected.");
+      process.exitCode = 1;
+      return;
+    }
+    const root = findProjectRoot31(opts.dir);
+    const paths = resolveHaivePaths28(root);
+    if (!existsSync53(paths.memoriesDir)) {
+      ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
+      process.exitCode = 1;
+      return;
+    }
+    const all = await loadMemoriesFromDir26(paths.memoriesDir);
+    const target = all.find((m) => m.memory.frontmatter.id === id);
+    if (!target) {
+      ui.error(`No memory with id '${id}'.`);
+      process.exitCode = 1;
+      return;
+    }
+    const index = await loadUsageIndex24(paths);
+    const outcome = opts.applied ? "applied" : "rejected";
+    if (opts.applied) recordApplied2(index, id);
+    else recordRejection4(index, id, opts.reason ?? null);
+    await saveUsageIndex6(paths, index);
+    const usage = getUsage19(index, id);
+    const impact = computeImpact4(target.memory.frontmatter, usage);
+    if (opts.json) {
+      console.log(JSON.stringify({ id, outcome, usage, impact }, null, 2));
+      return;
+    }
+    ui.success(`Recorded '${outcome}' for ${id}`);
+    ui.info(
+      `applied=${usage.applied_count} \xB7 rejected=${usage.rejected_count} \xB7 read=${usage.read_count} \u2192 impact ${impact.score.toFixed(2)} (${impact.tier})`
+    );
+  });
+}
+
+// src/commands/memory-verify.ts
+import { writeFile as writeFile21 } from "fs/promises";
+import { existsSync as existsSync54 } from "fs";
+import path34 from "path";
+import "commander";
+import {
+  findProjectRoot as findProjectRoot32,
+  resolveHaivePaths as resolveHaivePaths29,
   serializeMemory as serializeMemory19,
   verifyAnchor as verifyAnchor3
 } from "@hiveai/core";
@@ -10571,9 +10613,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 = findProjectRoot31(opts.dir);
-    const paths = resolveHaivePaths28(root);
-    if (!existsSync53(paths.memoriesDir)) {
+    const root = findProjectRoot32(opts.dir);
+    const paths = resolveHaivePaths29(root);
+    if (!existsSync54(paths.memoriesDir)) {
       if (opts.json) {
         console.log(JSON.stringify({ error: "not-initialized", root }, null, 2));
       } else {
@@ -10694,24 +10736,24 @@ function applyVerification2(mem, result) {
 
 // src/commands/memory-import.ts
 import { readFile as readFile15 } from "fs/promises";
-import { existsSync as existsSync54 } from "fs";
+import { existsSync as existsSync55 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot32,
-  resolveHaivePaths as resolveHaivePaths29
+  findProjectRoot as findProjectRoot33,
+  resolveHaivePaths as resolveHaivePaths30
 } 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 = findProjectRoot32(opts.dir);
-    const paths = resolveHaivePaths29(root);
-    if (!existsSync54(paths.haiveDir)) {
+    const root = findProjectRoot33(opts.dir);
+    const paths = resolveHaivePaths30(root);
+    if (!existsSync55(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    if (!existsSync54(opts.from)) {
+    if (!existsSync55(opts.from)) {
       ui.error(`File not found: ${opts.from}`);
       process.exitCode = 1;
       return;
@@ -10744,14 +10786,14 @@ function registerMemoryImport(memory2) {
 }
 
 // src/commands/memory-import-changelog.ts
-import { existsSync as existsSync55 } from "fs";
+import { existsSync as existsSync56 } 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 findProjectRoot33,
-  resolveHaivePaths as resolveHaivePaths30,
+  findProjectRoot as findProjectRoot34,
+  resolveHaivePaths as resolveHaivePaths31,
   serializeMemory as serializeMemory20
 } from "@hiveai/core";
 function parseChangelog(content) {
@@ -10816,10 +10858,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 = findProjectRoot33(opts.dir);
-    const paths = resolveHaivePaths30(root);
+    const root = findProjectRoot34(opts.dir);
+    const paths = resolveHaivePaths31(root);
     const changelogPath = path35.resolve(root, opts.fromChangelog);
-    if (!existsSync55(changelogPath)) {
+    if (!existsSync56(changelogPath)) {
       ui.error(`CHANGELOG not found: ${changelogPath}`);
       process.exitCode = 1;
       return;
@@ -10906,17 +10948,17 @@ ${ui.bold(`Imported ${saved} changelog entr${saved === 1 ? "y" : "ies"} from ${p
 }
 
 // src/commands/memory-digest.ts
-import { existsSync as existsSync56 } from "fs";
+import { existsSync as existsSync57 } from "fs";
 import { writeFile as writeFile24 } from "fs/promises";
 import path36 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence12,
-  findProjectRoot as findProjectRoot34,
-  getUsage as getUsage19,
+  findProjectRoot as findProjectRoot35,
+  getUsage as getUsage20,
   loadMemoriesFromDir as loadMemoriesFromDir27,
-  loadUsageIndex as loadUsageIndex24,
-  resolveHaivePaths as resolveHaivePaths31
+  loadUsageIndex as loadUsageIndex25,
+  resolveHaivePaths as resolveHaivePaths32
 } from "@hiveai/core";
 var CONFIDENCE_EMOJI = {
   unverified: "\u2B1C",
@@ -10929,9 +10971,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 = findProjectRoot34(opts.dir);
-    const paths = resolveHaivePaths31(root);
-    if (!existsSync56(paths.memoriesDir)) {
+    const root = findProjectRoot35(opts.dir);
+    const paths = resolveHaivePaths32(root);
+    if (!existsSync57(paths.memoriesDir)) {
       ui.error("No .ai/memories found. Run `haive init` first.");
       process.exitCode = 1;
       return;
@@ -10940,7 +10982,7 @@ function registerMemoryDigest(program2) {
     const scopeFilter = opts.scope ?? "team";
     const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1e3);
     const all = await loadMemoriesFromDir27(paths.memoriesDir);
-    const usage = await loadUsageIndex24(paths);
+    const usage = await loadUsageIndex25(paths);
     const recent = all.filter(({ memory: mem }) => {
       const fm = mem.frontmatter;
       if (fm.type === "session_recap") return false;
@@ -10971,7 +11013,7 @@ function registerMemoryDigest(program2) {
         lines.push(``);
         for (const { memory: mem } of mems) {
           const fm = mem.frontmatter;
-          const u = getUsage19(usage, fm.id);
+          const u = getUsage20(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_";
@@ -11014,21 +11056,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 existsSync57 } from "fs";
+import { existsSync as existsSync58 } from "fs";
 import { spawn as spawn4 } from "child_process";
 import path37 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter10,
-  findProjectRoot as findProjectRoot35,
+  findProjectRoot as findProjectRoot36,
   loadMemoriesFromDir as loadMemoriesFromDir28,
   memoryFilePath as memoryFilePath9,
-  resolveHaivePaths as resolveHaivePaths32,
+  resolveHaivePaths as resolveHaivePaths33,
   serializeMemory as serializeMemory21
 } from "@hiveai/core";
 async function buildAutoRecap(paths) {
   const obsFile = path37.join(paths.haiveDir, ".cache", "observations.jsonl");
-  if (!existsSync57(obsFile)) return await buildGitAutoRecap(paths);
+  if (!existsSync58(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);
@@ -11217,9 +11259,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 = findProjectRoot35(opts.dir);
-    const paths = resolveHaivePaths32(root);
-    if (!existsSync57(paths.haiveDir)) {
+    const root = findProjectRoot36(opts.dir);
+    const paths = resolveHaivePaths33(root);
+    if (!existsSync58(paths.haiveDir)) {
       if (opts.auto || opts.quiet) return;
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
@@ -11252,7 +11294,7 @@ function registerSessionEnd(session2) {
     });
     const topic = recapTopic2(scope, opts.module);
     const filesTouched = parseCsv5(resolvedFiles).map((p) => normalizeAnchorPath(root, p));
-    const missingPaths = filesTouched.filter((p) => !existsSync57(path37.resolve(root, p)));
+    const missingPaths = filesTouched.filter((p) => !existsSync58(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}`);
@@ -11260,10 +11302,10 @@ function registerSessionEnd(session2) {
     const cleanupObservations = async () => {
       if (!opts.auto) return;
       const obsFile = path37.join(paths.haiveDir, ".cache", "observations.jsonl");
-      if (existsSync57(obsFile)) await rm2(obsFile).catch(() => {
+      if (existsSync58(obsFile)) await rm2(obsFile).catch(() => {
       });
     };
-    if (existsSync57(paths.memoriesDir)) {
+    if (existsSync58(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)
@@ -11325,15 +11367,15 @@ function normalizeAnchorPath(root, filePath) {
 }
 
 // src/commands/snapshot.ts
-import { existsSync as existsSync58 } from "fs";
+import { existsSync as existsSync59 } from "fs";
 import { readdir as readdir4 } from "fs/promises";
 import path38 from "path";
 import "commander";
 import {
   diffContract,
-  findProjectRoot as findProjectRoot36,
+  findProjectRoot as findProjectRoot37,
   loadConfig as loadConfig7,
-  resolveHaivePaths as resolveHaivePaths33,
+  resolveHaivePaths as resolveHaivePaths34,
   snapshotContract
 } from "@hiveai/core";
 function registerSnapshot(program2) {
@@ -11358,16 +11400,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 = findProjectRoot36(opts.dir);
-    const paths = resolveHaivePaths33(root);
-    if (!existsSync58(paths.haiveDir)) {
+    const root = findProjectRoot37(opts.dir);
+    const paths = resolveHaivePaths34(root);
+    if (!existsSync59(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 (!existsSync58(contractsDir)) {
+      if (!existsSync59(contractsDir)) {
         console.log(ui.dim("No contract snapshots found."));
         return;
       }
@@ -11491,16 +11533,16 @@ function detectFormat(filePath) {
 }
 
 // src/commands/hub.ts
-import { existsSync as existsSync59 } from "fs";
+import { existsSync as existsSync60 } 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 findProjectRoot37,
+  findProjectRoot as findProjectRoot38,
   loadConfig as loadConfig8,
   loadMemoriesFromDir as loadMemoriesFromDir29,
-  resolveHaivePaths as resolveHaivePaths34,
+  resolveHaivePaths as resolveHaivePaths35,
   saveConfig as saveConfig3,
   serializeMemory as serializeMemory23
 } from "@hiveai/core";
@@ -11582,8 +11624,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 = findProjectRoot37(opts.dir);
-    const paths = resolveHaivePaths34(root);
+    const root = findProjectRoot38(opts.dir);
+    const paths = resolveHaivePaths35(root);
     const config = await loadConfig8(paths);
     if (!config.hubPath) {
       ui.error(
@@ -11593,7 +11635,7 @@ Next steps:
       return;
     }
     const hubRoot = path39.resolve(root, config.hubPath);
-    if (!existsSync59(hubRoot)) {
+    if (!existsSync60(hubRoot)) {
       ui.error(`Hub not found at ${hubRoot}. Run \`haive hub init ${config.hubPath}\` first.`);
       process.exitCode = 1;
       return;
@@ -11651,8 +11693,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 = findProjectRoot37(opts.dir);
-    const paths = resolveHaivePaths34(root);
+    const root = findProjectRoot38(opts.dir);
+    const paths = resolveHaivePaths35(root);
     const config = await loadConfig8(paths);
     if (!config.hubPath) {
       ui.error(
@@ -11663,7 +11705,7 @@ Next steps:
     }
     const hubRoot = path39.resolve(root, config.hubPath);
     const hubSharedDir = path39.join(hubRoot, ".ai", "memories", "shared");
-    if (!existsSync59(hubSharedDir)) {
+    if (!existsSync60(hubSharedDir)) {
       ui.warn("Hub has no shared memories yet. Run `haive hub push` from other projects first.");
       return;
     }
@@ -11710,15 +11752,15 @@ Next steps:
     );
   });
   hub.command("status").description("Show hub sync status.").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);
     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 (existsSync59(sharedDir)) {
+    if (existsSync60(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(`
@@ -11747,17 +11789,17 @@ Next steps:
 
 // src/commands/stats.ts
 import "commander";
-import { existsSync as existsSync60 } from "fs";
+import { existsSync as existsSync61 } from "fs";
 import { mkdir as mkdir17, writeFile as writeFile27 } from "fs/promises";
 import path40 from "path";
 import {
   aggregateUsage,
-  findProjectRoot as findProjectRoot38,
+  findProjectRoot as findProjectRoot39,
   loadMemoriesFromDir as loadMemoriesFromDir30,
-  loadUsageIndex as loadUsageIndex25,
+  loadUsageIndex as loadUsageIndex26,
   parseSince,
   readUsageEvents as readUsageEvents2,
-  resolveHaivePaths as resolveHaivePaths35,
+  resolveHaivePaths as resolveHaivePaths36,
   usageLogSize
 } from "@hiveai/core";
 function registerStats(program2) {
@@ -11766,8 +11808,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 = findProjectRoot38(opts.dir);
-    const paths = resolveHaivePaths35(root);
+    const root = findProjectRoot39(opts.dir);
+    const paths = resolveHaivePaths36(root);
     if (opts.exportReport) {
       await writeRoiReport(paths, root, opts.since ?? "30d", opts.exportReport);
       return;
@@ -11825,7 +11867,7 @@ 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 (existsSync60(paths.memoriesDir)) {
+  if (existsSync61(paths.memoriesDir)) {
     const mems = await loadMemoriesFromDir30(paths.memoriesDir);
     for (const { memory: memory2 } of mems) {
       const fm = memory2.frontmatter;
@@ -11840,7 +11882,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 loadUsageIndex25(paths);
+    const usageIdx = await loadUsageIndex26(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 {
@@ -11872,7 +11914,7 @@ async function writeRoiReport(paths, root, sinceRaw, outRelative) {
   ui.success(`Wrote ROI / usage rollup \u2192 ${outAbs}`);
 }
 async function renderMemoryHits(paths, opts) {
-  const index = await loadUsageIndex25(paths);
+  const index = await loadUsageIndex26(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) => {
@@ -11920,13 +11962,13 @@ import { performance } from "perf_hooks";
 import "commander";
 import {
   estimateTokens as estimateTokens3,
-  findProjectRoot as findProjectRoot39,
-  resolveHaivePaths as resolveHaivePaths36
+  findProjectRoot as findProjectRoot40,
+  resolveHaivePaths as resolveHaivePaths37
 } 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 = findProjectRoot39(opts.dir);
-    const paths = resolveHaivePaths36(root);
+    const root = findProjectRoot40(opts.dir);
+    const paths = resolveHaivePaths37(root);
     const ctx = { paths };
     const task = opts.task ?? "audit dependencies for security risks";
     const scenarios = [
@@ -12045,11 +12087,11 @@ function summarize(name, t0, payload, notes) {
 }
 
 // src/commands/benchmark.ts
-import { existsSync as existsSync61 } from "fs";
+import { existsSync as existsSync63 } 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 findProjectRoot40 } from "@hiveai/core";
+import { estimateTokens as estimateTokens4, findProjectRoot as findProjectRoot41 } 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) => {
@@ -12089,18 +12131,18 @@ function registerBenchmark(program2) {
 function resolveBenchmarkRoot(dir) {
   const candidate = dir ?? "benchmarks/agent-benchmark";
   if (path41.isAbsolute(candidate)) return candidate;
-  const projectRoot = findProjectRoot40(process.cwd());
+  const projectRoot = findProjectRoot41(process.cwd());
   return path41.join(projectRoot, candidate);
 }
 async function collectRows(root) {
-  if (!existsSync61(root)) throw new Error(`Benchmark directory not found: ${root}`);
+  if (!existsSync63(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 (!existsSync61(reportFile)) continue;
+    if (!existsSync63(reportFile)) continue;
     const report = await readFile19(reportFile, "utf8");
     rows.push(parseAgentReport(entry.name, report));
   }
@@ -12191,15 +12233,15 @@ function escapeRegExp(value) {
 
 // src/commands/eval.ts
 import { readFile as readFile20, writeFile as writeFile29 } from "fs/promises";
-import { existsSync as existsSync63 } from "fs";
+import { existsSync as existsSync64 } from "fs";
 import path43 from "path";
 import "commander";
 import {
   aggregateRetrieval,
   aggregateSensors,
   buildReport,
-  findProjectRoot as findProjectRoot41,
-  resolveHaivePaths as resolveHaivePaths37,
+  findProjectRoot as findProjectRoot42,
+  resolveHaivePaths as resolveHaivePaths38,
   scoreRetrievalCase,
   scoreSensorCase,
   synthesizeSelfEvalCases
@@ -12207,10 +12249,10 @@ import {
 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)) {
+  ).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("--fail-under <score>", "exit non-zero if the overall score is below this (0\u2013100) \u2014 for CI gates").option("-d, --dir <dir>", "project root").action(async (opts) => {
+    const root = findProjectRoot42(opts.dir);
+    const paths = resolveHaivePaths38(root);
+    if (!existsSync64(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -12243,16 +12285,26 @@ function registerEval(program2) {
     const report = buildReport(retrievalAgg, sensorAgg);
     if (opts.json) {
       console.log(JSON.stringify({ root, k, report }, null, 2));
-      return;
+    } else {
+      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)}`);
+      } else {
+        console.log(md);
+      }
     }
-    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;
+    if (opts.failUnder !== void 0) {
+      const threshold = Number(opts.failUnder);
+      if (Number.isNaN(threshold)) {
+        ui.error(`--fail-under expects a number, got "${opts.failUnder}"`);
+        process.exitCode = 1;
+      } else if (report.score < threshold) {
+        ui.error(`eval score ${report.score} is below --fail-under ${threshold}`);
+        process.exitCode = 1;
+      }
     }
-    console.log(md);
   });
 }
 async function resolveSpec(opts, memoriesDir) {
@@ -12348,19 +12400,19 @@ function renderMarkdown2(root, k, report) {
 
 // src/commands/memory-suggest.ts
 import { mkdir as mkdir18, writeFile as writeFile30 } from "fs/promises";
-import { existsSync as existsSync64 } from "fs";
+import { existsSync as existsSync65 } from "fs";
 import path44 from "path";
 import "commander";
 import {
   aggregateUsage as aggregateUsage2,
   buildFrontmatter as buildFrontmatter11,
-  findProjectRoot as findProjectRoot42,
+  findProjectRoot as findProjectRoot43,
   loadConfig as loadConfig9,
   loadMemoriesFromDir as loadMemoriesFromDir31,
   memoryFilePath as memoryFilePath10,
   parseSince as parseSince2,
   readUsageEvents as readUsageEvents3,
-  resolveHaivePaths as resolveHaivePaths38,
+  resolveHaivePaths as resolveHaivePaths39,
   serializeMemory as serializeMemory24
 } from "@hiveai/core";
 var SEARCH_TOOLS = /* @__PURE__ */ new Set([
@@ -12377,8 +12429,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 = findProjectRoot42(opts.dir);
-    const paths = resolveHaivePaths38(root);
+    const root = findProjectRoot43(opts.dir);
+    const paths = resolveHaivePaths39(root);
     const events = await readUsageEvents3(paths);
     if (events.length === 0) {
       if (opts.json) {
@@ -12427,7 +12479,7 @@ function registerMemorySuggest(memory2) {
       }
       const created = [];
       const skipped = [];
-      const existing = existsSync64(paths.memoriesDir) ? await loadMemoriesFromDir31(paths.memoriesDir) : [];
+      const existing = existsSync65(paths.memoriesDir) ? await loadMemoriesFromDir31(paths.memoriesDir) : [];
       for (const s of top) {
         const slug = slugify2(s.query);
         if (!slug) {
@@ -12451,7 +12503,7 @@ function registerMemorySuggest(memory2) {
         const body = renderTemplate(s, fm.id, status);
         const file = memoryFilePath10(paths, fm.scope, fm.id, fm.module);
         await mkdir18(path44.dirname(file), { recursive: true });
-        if (existsSync64(file)) {
+        if (existsSync65(file)) {
           skipped.push({ query: s.query, reason: `file already exists at ${path44.relative(root, file)}` });
           continue;
         }
@@ -12554,18 +12606,18 @@ function truncate2(text, max) {
 }
 
 // src/commands/memory-archive.ts
-import { existsSync as existsSync65 } from "fs";
+import { existsSync as existsSync66 } from "fs";
 import { writeFile as writeFile31 } from "fs/promises";
 import path45 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot43,
-  getUsage as getUsage20,
+  findProjectRoot as findProjectRoot44,
+  getUsage as getUsage21,
   retirementSignal as retirementSignal2,
   loadConfig as loadConfig10,
   loadMemoriesFromDir as loadMemoriesFromDir33,
-  loadUsageIndex as loadUsageIndex26,
-  resolveHaivePaths as resolveHaivePaths39,
+  loadUsageIndex as loadUsageIndex27,
+  resolveHaivePaths as resolveHaivePaths40,
   serializeMemory as serializeMemory25
 } from "@hiveai/core";
 var MS_PER_DAY2 = 24 * 60 * 60 * 1e3;
@@ -12573,9 +12625,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 = findProjectRoot43(opts.dir);
-    const paths = resolveHaivePaths39(root);
-    if (!existsSync65(paths.memoriesDir)) {
+    const root = findProjectRoot44(opts.dir);
+    const paths = resolveHaivePaths40(root);
+    if (!existsSync66(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -12590,7 +12642,7 @@ function registerMemoryArchive(memory2) {
     }
     const cutoff = Date.now() - minDays * MS_PER_DAY2;
     const all = await loadMemoriesFromDir33(paths.memoriesDir);
-    const usage = await loadUsageIndex26(paths);
+    const usage = await loadUsageIndex27(paths);
     const typeFilter = opts.type === "all" ? null : opts.type ?? "attempt";
     const candidates = [];
     for (const { memory: mem, filePath } of all) {
@@ -12600,10 +12652,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) => !existsSync65(path45.join(paths.root, p)));
+      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync66(path45.join(paths.root, p)));
       const isAnchorless = !hasAnyAnchor;
       if (!retired.retired && !opts.unread && !isAnchorless && !allPathsGone) continue;
-      const u = getUsage20(usage, fm.id);
+      const u = getUsage21(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)`;
@@ -12675,34 +12727,34 @@ function parseDays(input) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync66, statSync as statSync2 } from "fs";
+import { existsSync as existsSync67, 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 findProjectRoot44,
-  getUsage as getUsage21,
+  findProjectRoot as findProjectRoot45,
+  getUsage as getUsage23,
   isStackPackSeed as isStackPackSeed4,
   loadCodeMap as loadCodeMap7,
   loadConfig as loadConfig11,
   loadMemoriesFromDir as loadMemoriesFromDir34,
-  loadUsageIndex as loadUsageIndex27,
+  loadUsageIndex as loadUsageIndex28,
   readUsageEvents as readUsageEvents4,
-  resolveHaivePaths as resolveHaivePaths40
+  resolveHaivePaths as resolveHaivePaths41
 } 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 = findProjectRoot44(opts.dir);
-    const paths = resolveHaivePaths40(root);
+    const root = findProjectRoot45(opts.dir);
+    const paths = resolveHaivePaths41(root);
     const findings = [];
     const repairs = [];
     const config = await loadConfig11(paths);
-    if (!existsSync66(paths.haiveDir)) {
+    if (!existsSync67(paths.haiveDir)) {
       findings.push({
         severity: "error",
         code: "not-initialized",
@@ -12723,7 +12775,7 @@ function registerDoctor(program2) {
         })
       );
     }
-    if (!existsSync66(paths.projectContext)) {
+    if (!existsSync67(paths.projectContext)) {
       findings.push({
         severity: "warn",
         code: "no-project-context",
@@ -12752,7 +12804,7 @@ function registerDoctor(program2) {
         });
       }
     }
-    const memories = existsSync66(paths.memoriesDir) ? await loadMemoriesFromDir34(paths.memoriesDir) : [];
+    const memories = existsSync67(paths.memoriesDir) ? await loadMemoriesFromDir34(paths.memoriesDir) : [];
     const now = Date.now();
     if (memories.length === 0) {
       findings.push({
@@ -12761,7 +12813,7 @@ function registerDoctor(program2) {
         message: "No memories yet. Capture knowledge as agents work via mem_save / mem_observe / mem_tried."
       });
     } else {
-      const usage = await loadUsageIndex27(paths);
+      const usage = await loadUsageIndex28(paths);
       const stale = memories.filter((m) => m.memory.frontmatter.status === "stale");
       if (stale.length > 0) {
         findings.push({
@@ -12818,7 +12870,7 @@ function registerDoctor(program2) {
       }
       const decayCandidates = memories.filter((m) => {
         if (m.memory.frontmatter.status !== "validated") return false;
-        const u = getUsage21(usage, m.memory.frontmatter.id);
+        const u = getUsage23(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;
       });
@@ -12904,7 +12956,7 @@ function registerDoctor(program2) {
     if (config.enforcement?.requireBriefingFirst) {
       const claudeSettings = path46.join(root, ".claude", "settings.local.json");
       let hasClaudeEnforcement = false;
-      if (existsSync66(claudeSettings)) {
+      if (existsSync67(claudeSettings)) {
         try {
           const { readFile: readFile25 } = await import("fs/promises");
           const raw = await readFile25(claudeSettings, "utf8");
@@ -12930,14 +12982,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.11.0"));
+    findings.push(...await collectInstallFindings(root, "0.12.1"));
     try {
       const legacyRaw = execSync3("haive-mcp --version", {
         encoding: "utf8",
         timeout: 3e3,
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      const cliVersion = "0.11.0";
+      const cliVersion = "0.12.1";
       if (legacyRaw && legacyRaw !== cliVersion) {
         findings.push({
           severity: "warn",
@@ -12959,7 +13011,7 @@ npm uninstall -g @hiveai/mcp`
       ];
       const staleConfigs = [];
       for (const cfgPath of configPaths) {
-        if (!existsSync66(cfgPath)) continue;
+        if (!existsSync67(cfgPath)) continue;
         try {
           const raw = await readFile21(cfgPath, "utf8");
           if (raw.includes('"haive-mcp"') || raw.includes("'haive-mcp'")) {
@@ -13254,7 +13306,7 @@ which -a haive`
   ];
   for (const rel of integrationFiles) {
     const file = path46.join(root, rel);
-    if (!existsSync66(file)) continue;
+    if (!existsSync67(file)) continue;
     const text = await readFile21(file, "utf8").catch(() => "");
     for (const bin of extractAbsoluteHaiveBins(text)) {
       const version = versionForBinary(bin);
@@ -13350,7 +13402,7 @@ function collectGlobalHivemoduleFindings(expectedVersion) {
   }
 }
 async function readJson(file) {
-  if (!existsSync66(file)) return null;
+  if (!existsSync67(file)) return null;
   try {
     return JSON.parse(await readFile21(file, "utf8"));
   } catch {
@@ -13397,22 +13449,22 @@ function extractAbsoluteHaiveBins(text) {
 }
 
 // src/commands/playback.ts
-import { existsSync as existsSync67 } from "fs";
+import { existsSync as existsSync68 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot45,
+  findProjectRoot as findProjectRoot46,
   loadMemoriesFromDir as loadMemoriesFromDir35,
   parseSince as parseSince3,
   readUsageEvents as readUsageEvents5,
-  resolveHaivePaths as resolveHaivePaths41
+  resolveHaivePaths as resolveHaivePaths42
 } 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 = findProjectRoot45(opts.dir);
-    const paths = resolveHaivePaths41(root);
+    const root = findProjectRoot46(opts.dir);
+    const paths = resolveHaivePaths42(root);
     const events = await readUsageEvents5(paths);
     if (events.length === 0) {
       if (opts.json) {
@@ -13427,7 +13479,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 = existsSync67(paths.memoriesDir) ? await loadMemoriesFromDir35(paths.memoriesDir) : [];
+    const all = existsSync68(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);
@@ -13518,9 +13570,9 @@ import { spawn as spawn5 } from "child_process";
 import "commander";
 import {
   antiPatternGateParams,
-  findProjectRoot as findProjectRoot46,
+  findProjectRoot as findProjectRoot47,
   loadConfig as loadConfig12,
-  resolveHaivePaths as resolveHaivePaths42
+  resolveHaivePaths as resolveHaivePaths43
 } from "@hiveai/core";
 function registerPrecommit(program2) {
   program2.command("precommit").description(
@@ -13532,8 +13584,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 = findProjectRoot46(opts.dir);
-    const paths = resolveHaivePaths42(root);
+    const root = findProjectRoot47(opts.dir);
+    const paths = resolveHaivePaths43(root);
     const ctx = { paths };
     const config = await loadConfig12(paths);
     const gate = config.enforcement?.antiPatternGate ?? "anchored";
@@ -13669,12 +13721,12 @@ function runCommand3(cmd, args, cwd) {
 }
 
 // src/commands/welcome.ts
-import { existsSync as existsSync68 } from "fs";
+import { existsSync as existsSync69 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot47,
+  findProjectRoot as findProjectRoot48,
   loadMemoriesFromDir as loadMemoriesFromDir36,
-  resolveHaivePaths as resolveHaivePaths43
+  resolveHaivePaths as resolveHaivePaths44
 } from "@hiveai/core";
 var TYPE_RANK = {
   skill: 0,
@@ -13689,9 +13741,9 @@ 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 = findProjectRoot47(opts.dir);
-    const paths = resolveHaivePaths43(root);
-    if (!existsSync68(paths.memoriesDir)) {
+    const root = findProjectRoot48(opts.dir);
+    const paths = resolveHaivePaths44(root);
+    if (!existsSync69(paths.memoriesDir)) {
       ui.error(`No memories at ${paths.memoriesDir}. Run 'haive init' first.`);
       process.exitCode = 1;
       return;
@@ -13763,14 +13815,14 @@ function registerResolveProject(program2) {
 }
 
 // src/commands/runtime-journal.ts
-import { existsSync as existsSync69 } from "fs";
+import { existsSync as existsSync70 } from "fs";
 import path48 from "path";
 import "commander";
 import {
   appendRuntimeJournalEntry as appendRuntimeJournalEntry3,
-  findProjectRoot as findProjectRoot48,
+  findProjectRoot as findProjectRoot49,
   readRuntimeJournalTail as readRuntimeJournalTail2,
-  resolveHaivePaths as resolveHaivePaths44
+  resolveHaivePaths as resolveHaivePaths45
 } from "@hiveai/core";
 function registerRuntime(program2) {
   const runtime = program2.command("runtime").description(
@@ -13779,7 +13831,7 @@ 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 = path48.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths44(findProjectRoot48(root));
+    const paths = resolveHaivePaths45(findProjectRoot49(root));
     const raw = opts.kind ?? "note";
     const kind = ["note", "session_end", "mcp"].includes(raw) ? raw : "note";
     await appendRuntimeJournalEntry3(paths, { kind, message });
@@ -13787,9 +13839,9 @@ function registerRuntime(program2) {
   });
   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 = path48.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths44(findProjectRoot48(root));
+    const paths = resolveHaivePaths45(findProjectRoot49(root));
     const limit = Math.min(500, Math.max(1, parseInt(opts.limit, 10) || 30));
-    if (!existsSync69(paths.haiveDir)) {
+    if (!existsSync70(paths.haiveDir)) {
       ui.error("No .ai/ \u2014 run `haive init` first.");
       process.exitCode = 1;
       return;
@@ -13804,13 +13856,13 @@ function registerRuntime(program2) {
 }
 
 // src/commands/memory-timeline.ts
-import { existsSync as existsSync70 } from "fs";
+import { existsSync as existsSync71 } from "fs";
 import path49 from "path";
 import "commander";
 import {
   collectTimelineEntries as collectTimelineEntries2,
-  findProjectRoot as findProjectRoot49,
-  resolveHaivePaths as resolveHaivePaths45
+  findProjectRoot as findProjectRoot50,
+  resolveHaivePaths as resolveHaivePaths46
 } from "@hiveai/core";
 function registerMemoryTimeline(memory2) {
   memory2.command("timeline").description(
@@ -13822,8 +13874,8 @@ function registerMemoryTimeline(memory2) {
       return;
     }
     const root = path49.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths45(findProjectRoot49(root));
-    if (!existsSync70(paths.memoriesDir)) {
+    const paths = resolveHaivePaths46(findProjectRoot50(root));
+    if (!existsSync71(paths.memoriesDir)) {
       ui.error("No memories \u2014 run `haive init`.");
       process.exitCode = 1;
       return;
@@ -13841,14 +13893,14 @@ function registerMemoryTimeline(memory2) {
 }
 
 // src/commands/memory-conflict-candidates.ts
-import { existsSync as existsSync71 } from "fs";
+import { existsSync as existsSync73 } from "fs";
 import path50 from "path";
 import "commander";
 import {
   findLexicalConflictPairs as findLexicalConflictPairs2,
   findTopicStatusConflictPairs as findTopicStatusConflictPairs2,
-  findProjectRoot as findProjectRoot50,
-  resolveHaivePaths as resolveHaivePaths46
+  findProjectRoot as findProjectRoot51,
+  resolveHaivePaths as resolveHaivePaths47
 } from "@hiveai/core";
 function parseTypes(csv) {
   const allowed = ["decision", "architecture", "convention", "gotcha"];
@@ -13865,8 +13917,8 @@ function registerMemoryConflictCandidates(memory2) {
     "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 = path50.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths46(findProjectRoot50(root));
-    if (!existsSync71(paths.memoriesDir)) {
+    const paths = resolveHaivePaths47(findProjectRoot51(root));
+    if (!existsSync73(paths.memoriesDir)) {
       ui.error("No memories \u2014 run `haive init`.");
       process.exitCode = 1;
       return;
@@ -13902,13 +13954,13 @@ function registerMemoryConflictCandidates(memory2) {
 
 // src/commands/enforce.ts
 import { execFileSync as execFileSync2, spawn as spawn6 } from "child_process";
-import { existsSync as existsSync73, statSync as statSync3 } from "fs";
+import { existsSync as existsSync74, 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 findProjectRoot51,
+  findProjectRoot as findProjectRoot52,
   hasRecentBriefingMarker as hasRecentBriefingMarker2,
   isFreshIsoDate,
   loadConfig as loadConfig13,
@@ -13916,7 +13968,7 @@ import {
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths6,
   readRecentBriefingMarker,
   resolveBriefingBudget as resolveBriefingBudget3,
-  resolveHaivePaths as resolveHaivePaths47,
+  resolveHaivePaths as resolveHaivePaths48,
   saveConfig as saveConfig4,
   SESSION_RECAP_TTL_MS,
   verifyAnchor as verifyAnchor4,
@@ -13929,8 +13981,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 = findProjectRoot51(opts.dir);
-    const paths = resolveHaivePaths47(root);
+    const root = findProjectRoot52(opts.dir);
+    const paths = resolveHaivePaths48(root);
     await mkdir19(paths.haiveDir, { recursive: true });
     const current = await loadConfig13(paths);
     await saveConfig4(paths, {
@@ -13974,17 +14026,17 @@ 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 = findProjectRoot51(opts.dir);
-    const paths = resolveHaivePaths47(root);
+    const root = findProjectRoot52(opts.dir);
+    const paths = resolveHaivePaths48(root);
     const cacheDir = path51.join(paths.haiveDir, ".cache");
-    if (existsSync73(cacheDir)) {
+    if (existsSync74(cacheDir)) {
       if (opts.dryRun) ui.info(`would clean ${path51.relative(root, cacheDir)} (preserving .gitignore)`);
       else {
         const removed = await cleanupCacheDir(cacheDir);
         ui.success(`cleaned ${path51.relative(root, cacheDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
       }
     }
-    if (existsSync73(paths.runtimeDir)) {
+    if (existsSync74(paths.runtimeDir)) {
       if (opts.dryRun) ui.info(`would clean ${path51.relative(root, paths.runtimeDir)} (preserving briefing markers)`);
       else {
         const removed = await cleanupRuntimeDir(paths.runtimeDir);
@@ -14008,8 +14060,8 @@ function registerEnforce(program2) {
     const payload = await readHookPayload();
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
-    const paths = resolveHaivePaths47(root);
-    if (!existsSync73(paths.haiveDir)) return;
+    const paths = resolveHaivePaths48(root);
+    if (!existsSync74(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.";
@@ -14071,8 +14123,8 @@ ${briefing.project_context.content.slice(0, 1800)}`);
     const payload = await readHookPayload();
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
-    const paths = resolveHaivePaths47(root);
-    if (!existsSync73(paths.haiveDir)) return;
+    const paths = resolveHaivePaths48(root);
+    if (!existsSync74(paths.haiveDir)) return;
     if (!isWriteLikeTool(payload)) return;
     const ok = await hasRecentBriefingMarker2(paths, payload.session_id);
     if (ok) {
@@ -14114,9 +14166,9 @@ ${briefing.project_context.content.slice(0, 1800)}`);
   });
 }
 async function buildFinishReport(dir) {
-  const root = findProjectRoot51(dir);
-  const paths = resolveHaivePaths47(root);
-  const initialized = existsSync73(paths.haiveDir);
+  const root = findProjectRoot52(dir);
+  const paths = resolveHaivePaths48(root);
+  const initialized = existsSync74(paths.haiveDir);
   const config = initialized ? await loadConfig13(paths) : {};
   const mode = config.enforcement?.mode ?? "strict";
   const findings = [];
@@ -14310,9 +14362,9 @@ function finishReport(root, initialized, mode, findings, config) {
   });
 }
 async function runWithEnforcement(command, args, opts) {
-  const root = findProjectRoot51(opts.dir);
-  const paths = resolveHaivePaths47(root);
-  if (!existsSync73(paths.haiveDir)) {
+  const root = findProjectRoot52(opts.dir);
+  const paths = resolveHaivePaths48(root);
+  if (!existsSync74(paths.haiveDir)) {
     ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
     process.exit(1);
   }
@@ -14405,9 +14457,9 @@ async function writeWrapperBriefing(paths, sessionId, task) {
   return file;
 }
 async function buildEnforcementReport(dir, stage, sessionId) {
-  const root = findProjectRoot51(dir);
-  const paths = resolveHaivePaths47(root);
-  const initialized = existsSync73(paths.haiveDir);
+  const root = findProjectRoot52(dir);
+  const paths = resolveHaivePaths48(root);
+  const initialized = existsSync74(paths.haiveDir);
   const config = initialized ? await loadConfig13(paths) : {};
   if (initialized) await applyLightweightRepairs(root, paths);
   const mode = config.enforcement?.mode ?? "strict";
@@ -14438,7 +14490,7 @@ async function buildEnforcementReport(dir, stage, sessionId) {
       findings: [{ severity: "info", code: "enforcement-off", message: "hAIve enforcement is disabled." }]
     });
   }
-  findings.push(...await inspectIntegrationVersions(root, "0.11.0"));
+  findings.push(...await inspectIntegrationVersions(root, "0.12.1"));
   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." } : {
@@ -14508,7 +14560,7 @@ function withCategories(report) {
   };
 }
 async function hasRecentSessionRecap(paths) {
-  if (!existsSync73(paths.memoriesDir)) return false;
+  if (!existsSync74(paths.memoriesDir)) return false;
   const all = await loadMemoriesFromDir37(paths.memoriesDir);
   return all.some(({ memory: memory2 }) => {
     const fm = memory2.frontmatter;
@@ -14517,7 +14569,7 @@ async function hasRecentSessionRecap(paths) {
   });
 }
 async function verifyMemoryPolicy(paths, config) {
-  if (!existsSync73(paths.memoriesDir)) return [];
+  if (!existsSync74(paths.memoriesDir)) return [];
   const all = await loadMemoriesFromDir37(paths.memoriesDir);
   const findings = [];
   const staleImportant = [];
@@ -14555,7 +14607,7 @@ async function verifyMemoryPolicy(paths, config) {
   return findings;
 }
 async function verifyDecisionCoverage(paths, stage, sessionId) {
-  if (!existsSync73(paths.memoriesDir)) return [];
+  if (!existsSync74(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." }];
@@ -14667,7 +14719,7 @@ async function cleanupRuntimeDir(runtimeDir) {
     removed++;
   }
   await writeFile34(path51.join(runtimeDir, ".gitignore"), "*\n!.gitignore\n!README.md\n", "utf8");
-  if (!existsSync73(path51.join(runtimeDir, "README.md"))) {
+  if (!existsSync74(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",
@@ -14710,7 +14762,7 @@ async function inspectIntegrationVersions(root, expectedVersion) {
   const findings = [];
   for (const rel of files) {
     const file = path51.join(root, rel);
-    if (!existsSync73(file)) continue;
+    if (!existsSync74(file)) continue;
     const text = await readFile23(file, "utf8").catch(() => "");
     for (const bin of extractAbsoluteHaiveBins2(text)) {
       const version = versionForBinary2(bin);
@@ -14820,7 +14872,7 @@ async function resolveCiDiffRange(root) {
 }
 async function resolveGithubEventRange(root) {
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !existsSync73(eventPath)) return null;
+  if (!eventPath || !existsSync74(eventPath)) return null;
   try {
     const event = JSON.parse(await readFile23(eventPath, "utf8"));
     const prBase = cleanGitSha(event.pull_request?.base?.sha);
@@ -15001,7 +15053,7 @@ function buildScore(findings, threshold = 80) {
 }
 async function installGitEnforcement(root) {
   const hooksDir = path51.join(root, ".git", "hooks");
-  if (!existsSync73(path51.join(root, ".git"))) {
+  if (!existsSync74(path51.join(root, ".git"))) {
     ui.warn("No .git directory found; git enforcement hooks skipped.");
     return;
   }
@@ -15024,7 +15076,7 @@ haive enforce check --stage pre-push --dir . || exit $?
   ];
   for (const hook of hooks) {
     const file = path51.join(hooksDir, hook.name);
-    if (existsSync73(file)) {
+    if (existsSync74(file)) {
       const current = await readFile23(file, "utf8").catch(() => "");
       if (current.includes(ENFORCE_HOOK_MARKER)) {
         await writeFile34(file, hook.body, "utf8");
@@ -15043,7 +15095,7 @@ ${hook.body}`, "utf8");
 async function installCiEnforcement(root) {
   const workflowPath = path51.join(root, ".github", "workflows", "haive-enforcement.yml");
   await mkdir19(path51.dirname(workflowPath), { recursive: true });
-  if (existsSync73(workflowPath)) {
+  if (existsSync74(workflowPath)) {
     ui.info("GitHub Actions enforcement workflow already exists \u2014 skipped");
     return;
   }
@@ -15134,7 +15186,7 @@ async function readHookPayload() {
 }
 function resolveRoot(dir, payload) {
   try {
-    return findProjectRoot51(dir ?? payload.cwd);
+    return findProjectRoot52(dir ?? payload.cwd);
   } catch {
     return null;
   }
@@ -15175,7 +15227,7 @@ function normalizeToolPath(file, root) {
   return path51.relative(root, normalized).replace(/\\/g, "/");
 }
 async function missingRequiredMemoriesForFiles(paths, files, sessionId) {
-  if (!existsSync73(paths.memoriesDir)) return [];
+  if (!existsSync74(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"]);
@@ -15249,16 +15301,16 @@ function registerRun(program2) {
 
 // src/commands/sensors.ts
 import { execFile as execFile2 } from "child_process";
-import { existsSync as existsSync74 } from "fs";
+import { existsSync as existsSync75 } 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 findProjectRoot52,
+  findProjectRoot as findProjectRoot53,
   isRetiredMemory as isRetiredMemory3,
   loadMemoriesFromDir as loadMemoriesFromDir38,
-  resolveHaivePaths as resolveHaivePaths48,
+  resolveHaivePaths as resolveHaivePaths49,
   runSensors as runSensors2,
   sensorTargetsFromDiff as sensorTargetsFromDiff2,
   serializeMemory as serializeMemory26
@@ -15267,8 +15319,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 = findProjectRoot52(opts.dir);
-    const paths = resolveHaivePaths48(root);
+    const root = findProjectRoot53(opts.dir);
+    const paths = resolveHaivePaths49(root);
     const rows = await sensorRows(paths);
     if (opts.json) {
       console.log(JSON.stringify(rows, null, 2));
@@ -15288,8 +15340,8 @@ 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 = findProjectRoot52(opts.dir);
-    const paths = resolveHaivePaths48(root);
+    const root = findProjectRoot53(opts.dir);
+    const paths = resolveHaivePaths49(root);
     const memories = await runnableSensorMemories(paths);
     const diff = opts.diffFile ? await readFile24(path53.resolve(root, opts.diffFile), "utf8") : await stagedDiff(root);
     const targets = sensorTargetsFromDiff2(diff);
@@ -15330,9 +15382,9 @@ function registerSensors(program2) {
       process.exitCode = 1;
       return;
     }
-    const root = findProjectRoot52(opts.dir);
-    const paths = resolveHaivePaths48(root);
-    const loaded = existsSync74(paths.memoriesDir) ? await loadMemoriesFromDir38(paths.memoriesDir) : [];
+    const root = findProjectRoot53(opts.dir);
+    const paths = resolveHaivePaths49(root);
+    const loaded = existsSync75(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}`);
@@ -15364,8 +15416,8 @@ function registerSensors(program2) {
       process.exitCode = 1;
       return;
     }
-    const root = findProjectRoot52(opts.dir);
-    const paths = resolveHaivePaths48(root);
+    const root = findProjectRoot53(opts.dir);
+    const paths = resolveHaivePaths49(root);
     const rows = await sensorRows(paths);
     const outDir = path53.resolve(root, opts.outDir ?? ".ai/generated");
     await mkdir20(outDir, { recursive: true });
@@ -15394,7 +15446,7 @@ async function sensorRows(paths) {
   });
 }
 async function runnableSensorMemories(paths, regexOnly = true) {
-  if (!existsSync74(paths.memoriesDir)) return [];
+  if (!existsSync75(paths.memoriesDir)) return [];
   const loaded = await loadMemoriesFromDir38(paths.memoriesDir);
   return loaded.map(({ memory: memory2 }) => memory2).filter((memory2) => {
     const sensor = memory2.frontmatter.sensor;
@@ -15436,8 +15488,8 @@ function shellQuote(value) {
 }
 
 // src/index.ts
-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");
+var program = new Command56();
+program.name("haive").description("hAIve - repo-native memory and context policy for coding-agent harnesses").version("0.12.1").option("--advanced", "show maintenance and experimental commands in help");
 registerInit(program);
 registerWelcome(program);
 registerResolveProject(program);
@@ -15462,6 +15514,7 @@ registerMemoryPromote(memory);
 registerMemoryVerify(memory);
 registerMemoryStats(memory);
 registerMemoryImpact(memory);
+registerMemoryFeedback(memory);
 registerMemoryReject(memory);
 registerMemoryAutoPromote(memory);
 registerMemoryForFiles(memory);