@hivelore/cli 0.33.0 → 0.35.0

package/dist/index.js

@@ -10,7 +10,7 @@ import {
   preCommitCheck,
   readPresumedCorrectTargets,
   runHaiveMcpStdio
-} from "./chunk-XDB7EKL4.js";
+} from "./chunk-ZR7UPTRR.js";
 import {
   registerMemoryPending
 } from "./chunk-OYJKHD22.js";
@@ -208,7 +208,7 @@ async function getHotFiles(root, daysBack, maxHotFiles, filePaths) {
       if (!f) continue;
       counts.set(f, (counts.get(f) ?? 0) + 1);
     }
-    let entries = [...counts.entries()].map(([path46, changes]) => ({ path: path46, changes }));
+    let entries = [...counts.entries()].map(([path47, changes]) => ({ path: path47, changes }));
     const lowerPaths = filePaths.map((p) => p.toLowerCase());
     if (lowerPaths.length > 0) {
       entries = entries.filter((e) => lowerPaths.some((p) => e.path.toLowerCase().includes(p)));
@@ -275,7 +275,7 @@ async function lintMemoriesAsync(root, options = {}) {
   const loaded = await loadMemoriesFromDir2(paths.memoriesDir);
   const usage = await loadUsageIndex(paths);
   const codeMap = await loadCodeMap(paths);
-  const trackedFiles = gitTrackedFiles(root);
+  const trackedFiles2 = gitTrackedFiles(root);
   const ANCHOR_TYPES = /* @__PURE__ */ new Set(["decision", "architecture", "gotcha"]);
   const actionableWords = /\b(always|never|prefer|use|run|avoid|because|instead|why|rationale|do not|must|should|require|required|requires|fix|fail|failed|fails|prevent|prevents|allow|allows|lets|ensure|ensures|catch|catches)\b/i;
   for (const { filePath, memory: memory2 } of loaded) {
@@ -322,9 +322,9 @@ async function lintMemoriesAsync(root, options = {}) {
         message: "Reads like generic best practice a capable model already follows. Hivelore's value is UNGUESSABLE team knowledge \u2014 add the concrete, arbitrary specifics (exact names, values, formats, magic numbers) or consider removing it to keep briefings high-signal."
       });
     }
-    const suggestedAnchors = suggestAnchors(root, { filePath, memory: memory2 }, codeMap, trackedFiles);
-    const isUnanchoredSeed = fm.tags.includes("stack-pack") && fm.tags.includes("needs_anchor");
-    if (ANCHOR_TYPES.has(fm.type) && fm.anchor.paths.length === 0 && fm.status === "validated" && !isUnanchoredSeed) {
+    const isStackSeed = fm.tags.includes("stack-pack");
+    const suggestedAnchors = isStackSeed ? { paths: [], symbols: [] } : suggestAnchors(root, { filePath, memory: memory2 }, codeMap, trackedFiles2);
+    if (ANCHOR_TYPES.has(fm.type) && fm.anchor.paths.length === 0 && fm.status === "validated" && !isStackSeed) {
       out.push({
         file: filePath,
         id: fm.id,
@@ -435,14 +435,14 @@ function titleFromId(id) {
   const withoutDate = id.replace(/^\d{4}-\d{2}-\d{2}-/, "");
   return withoutDate.split("-").filter(Boolean).map((part) => part.slice(0, 1).toUpperCase() + part.slice(1)).join(" ");
 }
-function suggestAnchors(root, loaded, codeMap, trackedFiles) {
+function suggestAnchors(root, loaded, codeMap, trackedFiles2) {
   const body = loaded.memory.body;
   const paths = /* @__PURE__ */ new Set();
   const symbols = /* @__PURE__ */ new Set();
   for (const match of body.matchAll(/`([^`\n]+\.[A-Za-z0-9]+)`|(?:^|\s)([A-Za-z0-9_./-]+\.[A-Za-z0-9]+)/gm)) {
     const candidate = (match[1] ?? match[2] ?? "").replace(/^\.?\//, "");
     if (!candidate || candidate.startsWith("http")) continue;
-    if (existsSync(path2.join(root, candidate)) && isSafeAnchorPath(candidate, trackedFiles)) {
+    if (existsSync(path2.join(root, candidate)) && isSafeAnchorPath(candidate, trackedFiles2)) {
       paths.add(candidate);
     }
   }
@@ -452,7 +452,7 @@ function suggestAnchors(root, loaded, codeMap, trackedFiles) {
       for (const exp of entry.exports) {
         if (!exp.name || exp.name.length < 4) continue;
         if (lowered.includes(exp.name.toLowerCase())) {
-          if (isSafeAnchorPath(file, trackedFiles)) {
+          if (isSafeAnchorPath(file, trackedFiles2)) {
             paths.add(file);
             symbols.add(exp.name);
           }
@@ -477,12 +477,12 @@ function gitTrackedFiles(root) {
   const files = result.stdout.split("\n").map((line) => line.trim()).filter(Boolean);
   return new Set(files);
 }
-function isSafeAnchorPath(file, trackedFiles) {
+function isSafeAnchorPath(file, trackedFiles2) {
   const normalized = file.replace(/\\/g, "/").replace(/^\.?\//, "");
   if (normalized.startsWith(".ai/.cache/") || normalized.startsWith(".ai/.runtime/")) return false;
   if (normalized.includes("/node_modules/") || normalized.startsWith("node_modules/")) return false;
   if (normalized.includes("/dist/") || normalized.startsWith("dist/")) return false;
-  if (trackedFiles && !trackedFiles.has(normalized)) return false;
+  if (trackedFiles2 && !trackedFiles2.has(normalized)) return false;
   return true;
 }
 function nearDuplicatePairs(loaded) {
@@ -728,20 +728,7 @@ async function projectContextVersionStatus(root, paths) {
 async function refreshCodeMap(root, paths, force) {
   const existing = await loadCodeMap2(paths);
   if (existing && !force) return false;
-  const map = await buildCodeMap(root, {
-    includeUntracked: true,
-    excludeDirs: [
-      "node_modules",
-      "dist",
-      "build",
-      "out",
-      ".git",
-      ".next",
-      ".turbo",
-      ".vitest-cache",
-      "coverage"
-    ]
-  });
+  const map = await buildCodeMap(root, { includeUntracked: true });
   if (existing && existing.root === map.root && JSON.stringify(existing.files) === JSON.stringify(map.files)) {
     return false;
   }
@@ -1355,6 +1342,7 @@ import path6 from "path";
 import "commander";
 import {
   buildCodeMap as buildCodeMap2,
+  CODE_MAP_DEFAULT_EXCLUDE,
   codeMapPath,
   findProjectRoot as findProjectRoot4,
   loadCodeMap as loadCodeMap4,
@@ -1383,18 +1371,7 @@ function registerIndexCode(program2) {
     ui.info(`Indexing source files in ${root}\u2026`);
     const map = await buildCodeMap2(root, {
       includeUntracked: true,
-      excludeDirs: [
-        "node_modules",
-        "dist",
-        "build",
-        "out",
-        ".git",
-        ".next",
-        ".turbo",
-        ".vitest-cache",
-        "coverage",
-        ...extraExcludes
-      ]
+      excludeDirs: [...CODE_MAP_DEFAULT_EXCLUDE, ...extraExcludes]
     });
     await saveCodeMap2(paths, map);
     const fileCount = Object.keys(map.files).length;
@@ -1504,14 +1481,14 @@ function isCodeMapStale(root, generatedAt, files) {
 // src/commands/init.ts
 import { execFile as execFile2 } from "child_process";
 import { mkdir as mkdir6, readFile as readFile6, readdir as readdir2, writeFile as writeFile7 } from "fs/promises";
-import { existsSync as existsSync11 } from "fs";
-import path12 from "path";
+import { existsSync as existsSync12 } from "fs";
+import path13 from "path";
 import { spawnSync as spawnSync3 } from "child_process";
 import { promisify as promisify2 } from "util";
 import "commander";
 import {
   AUTOPILOT_DEFAULTS as AUTOPILOT_DEFAULTS2,
-  BRIDGE_TARGETS,
+  BRIDGE_TARGETS as BRIDGE_TARGETS2,
   buildCodeMap as buildCodeMap3,
   buildFrontmatter as buildFrontmatter2,
   detectStacksFromManifests,
@@ -1523,20 +1500,93 @@ import {
   serializeMemory as serializeMemory3
 } from "@hivelore/core";
 
+// src/utils/doc-files.ts
+import { readdirSync } from "fs";
+function findDocFile(root, stem) {
+  let entries;
+  try {
+    entries = readdirSync(root);
+  } catch {
+    return void 0;
+  }
+  const re = new RegExp(`^${stem}(\\.(md|markdown|txt|rst))?$`, "i");
+  return entries.find((e) => re.test(e));
+}
+
+// src/utils/bridge-detect.ts
+import { existsSync as existsSync6, readdirSync as readdirSync2 } from "fs";
+import { homedir } from "os";
+import path7 from "path";
+import { BRIDGE_TARGET_PATH, BRIDGE_TARGETS } from "@hivelore/core";
+var VSCODE_EXTENSION_SIGNALS = {
+  copilot: ["github.copilot"],
+  cline: ["saoudrizwan.claude-dev"],
+  roo: ["rooveterinaryinc.roo"],
+  cody: ["sourcegraph.cody"],
+  continue: ["continue.continue"]
+};
+var HOME_SIGNALS = {
+  claude: [".claude", ".claude.json"],
+  cursor: [".cursor"],
+  windsurf: [".codeium/windsurf", ".windsurf"],
+  gemini: [".gemini"],
+  continue: [".continue"],
+  aider: [".aider.conf.yml", ".aider"],
+  zed: [".config/zed", "Library/Application Support/Zed"],
+  copilot: [".config/github-copilot"]
+};
+var ENV_SIGNALS = {
+  claude: ["CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT"],
+  cursor: ["CURSOR_AGENT"],
+  gemini: ["GEMINI_CLI"],
+  aider: ["AIDER_MODEL"]
+};
+function vscodeExtensionIds(home) {
+  const ids = [];
+  for (const dir of [".vscode/extensions", ".vscode-server/extensions", ".vscode-oss/extensions"]) {
+    try {
+      ids.push(...readdirSync2(path7.join(home, dir)).map((e) => e.toLowerCase()));
+    } catch {
+    }
+  }
+  return ids;
+}
+function detectBridgeTargets(root, env = process.env, home = homedir()) {
+  const reasons = { agents: "universal" };
+  const extensions = vscodeExtensionIds(home);
+  for (const target of BRIDGE_TARGETS) {
+    if (target === "agents") continue;
+    if (existsSync6(path7.join(root, BRIDGE_TARGET_PATH[target]))) {
+      reasons[target] = "repo file";
+      continue;
+    }
+    const homeHit = (HOME_SIGNALS[target] ?? []).some((p) => existsSync6(path7.join(home, p)));
+    const envHit = (ENV_SIGNALS[target] ?? []).some((v) => env[v]);
+    const extHit = (VSCODE_EXTENSION_SIGNALS[target] ?? []).some(
+      (prefix) => extensions.some((id) => id.startsWith(prefix))
+    );
+    if (homeHit || envHit || extHit) reasons[target] = "installed";
+  }
+  return {
+    targets: BRIDGE_TARGETS.filter((t) => t in reasons),
+    reasons
+  };
+}
+
 // src/utils/bridge-files.ts
 import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import path7 from "path";
+import { existsSync as existsSync7 } from "fs";
+import path8 from "path";
 import {
   BRIDGE_MARKERS,
-  BRIDGE_TARGET_PATH,
+  BRIDGE_TARGET_PATH as BRIDGE_TARGET_PATH2,
   generateBridges,
   isRetiredMemory,
   loadMemoriesFromDir as loadMemoriesFromDir5
 } from "@hivelore/core";
 async function writeBridgeFiles(root, paths, opts) {
   const result = { created: [], updated: [], unchanged: [], skipped: [], warnings: [] };
-  if (!existsSync6(paths.memoriesDir)) return result;
+  if (!existsSync7(paths.memoriesDir)) return result;
   const allLoaded = await loadMemoriesFromDir5(paths.memoriesDir);
   const memories = allLoaded.map((l) => l.memory).filter((m) => !isRetiredMemory(m.frontmatter, m.body));
   const sensors = [];
@@ -1554,8 +1604,8 @@ async function writeBridgeFiles(root, paths, opts) {
   const maxMemories = Math.max(1, opts.maxMemories ?? 8);
   const outputs = generateBridges(memories, sensors, { maxMemories, targets: opts.targets });
   for (const output of outputs) {
-    const targetFile = path7.join(root, output.path);
-    const fileExists = existsSync6(targetFile);
+    const targetFile = path8.join(root, output.path);
+    const fileExists = existsSync7(targetFile);
     if (opts.onlyExisting && !fileExists) continue;
     if (opts.dryRun) {
       if (!fileExists) {
@@ -1574,7 +1624,7 @@ async function writeBridgeFiles(root, paths, opts) {
       }
       continue;
     }
-    await mkdir2(path7.dirname(targetFile), { recursive: true });
+    await mkdir2(path8.dirname(targetFile), { recursive: true });
     if (!fileExists) {
       await writeFile3(targetFile, output.content, "utf8");
       result.created.push(output.path);
@@ -1597,10 +1647,10 @@ async function writeBridgeFiles(root, paths, opts) {
   return result;
 }
 async function getBridgeFileStatuses(root, paths, opts) {
-  if (!existsSync6(paths.memoriesDir)) {
+  if (!existsSync7(paths.memoriesDir)) {
     return opts.targets.map((target) => ({
       target,
-      path: BRIDGE_TARGET_PATH[target],
+      path: BRIDGE_TARGET_PATH2[target],
       exists: false,
       state: "missing",
       wouldChange: false,
@@ -1627,8 +1677,8 @@ async function getBridgeFileStatuses(root, paths, opts) {
   });
   const statuses = [];
   for (const output of outputs) {
-    const targetFile = path7.join(root, output.path);
-    const exists = existsSync6(targetFile);
+    const targetFile = path8.join(root, output.path);
+    const exists = existsSync7(targetFile);
     if (!exists) {
       statuses.push({
         target: output.target,
@@ -1784,18 +1834,18 @@ function legacyManagedRange(text) {
 
 // src/commands/agent.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { mkdir as mkdir4, writeFile as writeFile5 } from "fs/promises";
 import os2 from "os";
-import path9 from "path";
+import path10 from "path";
 import { createInterface } from "readline/promises";
 import "commander";
 import { findProjectRoot as findProjectRoot5, resolveHaivePaths as resolveHaivePaths5 } from "@hivelore/core";
 
 // src/commands/init-mcp-setup.ts
 import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
-import path8 from "path";
+import { existsSync as existsSync8 } from "fs";
+import path9 from "path";
 import os from "os";
 var HOME = os.homedir();
 var HAIVE_MCP_ENTRY = {
@@ -1810,14 +1860,14 @@ function projectMcpEntry(root) {
   };
 }
 function cursorMcpPath() {
-  return path8.join(HOME, ".cursor", "mcp.json");
+  return path9.join(HOME, ".cursor", "mcp.json");
 }
 async function configureCursor() {
   const mcpPath = cursorMcpPath();
-  const cursorDir = path8.join(HOME, ".cursor");
-  if (!existsSync7(cursorDir)) return { client: "Cursor", status: "not_installed" };
+  const cursorDir = path9.join(HOME, ".cursor");
+  if (!existsSync8(cursorDir)) return { client: "Cursor", status: "not_installed" };
   let config = {};
-  if (existsSync7(mcpPath)) {
+  if (existsSync8(mcpPath)) {
     try {
       config = JSON.parse(await readFile4(mcpPath, "utf8"));
     } catch {
@@ -1832,16 +1882,16 @@ async function configureCursor() {
 }
 function vscodeMcpPath() {
   const candidates = [
-    path8.join(HOME, ".config", "Code", "User", "mcp.json"),
+    path9.join(HOME, ".config", "Code", "User", "mcp.json"),
     // Linux
-    path8.join(HOME, "Library", "Application Support", "Code", "User", "mcp.json"),
+    path9.join(HOME, "Library", "Application Support", "Code", "User", "mcp.json"),
     // macOS
-    path8.join(HOME, "AppData", "Roaming", "Code", "User", "mcp.json"),
+    path9.join(HOME, "AppData", "Roaming", "Code", "User", "mcp.json"),
     // Windows
-    path8.join(HOME, ".config", "Code - Insiders", "User", "mcp.json")
+    path9.join(HOME, ".config", "Code - Insiders", "User", "mcp.json")
   ];
   for (const c of candidates) {
-    if (existsSync7(path8.dirname(c))) return c;
+    if (existsSync8(path9.dirname(c))) return c;
   }
   return null;
 }
@@ -1849,7 +1899,7 @@ async function configureVSCode() {
   const mcpPath = vscodeMcpPath();
   if (!mcpPath) return { client: "VS Code", status: "not_installed" };
   let config = {};
-  if (existsSync7(mcpPath)) {
+  if (existsSync8(mcpPath)) {
     try {
       config = JSON.parse(await readFile4(mcpPath, "utf8"));
     } catch {
@@ -1858,24 +1908,24 @@ async function configureVSCode() {
   config.servers ??= {};
   if (config.servers["hivelore"] || config.servers["haive"]) return { client: "VS Code", status: "already_configured" };
   config.servers["hivelore"] = { ...HAIVE_MCP_ENTRY, type: "stdio" };
-  await mkdir3(path8.dirname(mcpPath), { recursive: true });
+  await mkdir3(path9.dirname(mcpPath), { recursive: true });
   await writeFile4(mcpPath, JSON.stringify(config, null, 2), "utf8");
   return { client: "VS Code", status: "configured", path: mcpPath };
 }
 function claudeConfigPath() {
-  const p = path8.join(HOME, ".claude.json");
-  if (existsSync7(p)) return p;
-  const p2 = path8.join(HOME, ".config", "claude", "claude.json");
-  if (existsSync7(path8.dirname(p2))) return p2;
+  const p = path9.join(HOME, ".claude.json");
+  if (existsSync8(p)) return p;
+  const p2 = path9.join(HOME, ".config", "claude", "claude.json");
+  if (existsSync8(path9.dirname(p2))) return p2;
   return null;
 }
 async function configureClaude() {
-  const cfgPath = claudeConfigPath() ?? path8.join(HOME, ".claude.json");
-  if (!existsSync7(cfgPath) && !existsSync7(path8.join(HOME, ".claude"))) {
+  const cfgPath = claudeConfigPath() ?? path9.join(HOME, ".claude.json");
+  if (!existsSync8(cfgPath) && !existsSync8(path9.join(HOME, ".claude"))) {
     return { client: "Claude Code", status: "not_installed" };
   }
   let config = {};
-  if (existsSync7(cfgPath)) {
+  if (existsSync8(cfgPath)) {
     try {
       config = JSON.parse(await readFile4(cfgPath, "utf8"));
     } catch {
@@ -1889,11 +1939,11 @@ async function configureClaude() {
 }
 function windsurfMcpPath() {
   const candidates = [
-    path8.join(HOME, ".codeium", "windsurf", "mcp_config.json"),
-    path8.join(HOME, ".windsurf", "mcp.json")
+    path9.join(HOME, ".codeium", "windsurf", "mcp_config.json"),
+    path9.join(HOME, ".windsurf", "mcp.json")
   ];
   for (const c of candidates) {
-    if (existsSync7(path8.dirname(c))) return c;
+    if (existsSync8(path9.dirname(c))) return c;
   }
   return null;
 }
@@ -1901,7 +1951,7 @@ async function configureWindsurf() {
   const mcpPath = windsurfMcpPath();
   if (!mcpPath) return { client: "Windsurf", status: "not_installed" };
   let config = {};
-  if (existsSync7(mcpPath)) {
+  if (existsSync8(mcpPath)) {
     try {
       config = JSON.parse(await readFile4(mcpPath, "utf8"));
     } catch {
@@ -1910,7 +1960,7 @@ async function configureWindsurf() {
   config.mcpServers ??= {};
   if (config.mcpServers["hivelore"] || config.mcpServers["haive"]) return { client: "Windsurf", status: "already_configured" };
   config.mcpServers["hivelore"] = HAIVE_MCP_ENTRY;
-  await mkdir3(path8.dirname(mcpPath), { recursive: true });
+  await mkdir3(path9.dirname(mcpPath), { recursive: true });
   await writeFile4(mcpPath, JSON.stringify(config, null, 2), "utf8");
   return { client: "Windsurf", status: "configured", path: mcpPath };
 }
@@ -1931,9 +1981,9 @@ async function configureProjectMcpClients(root) {
   const entry = projectMcpEntry(root);
   const results = [];
   try {
-    const cursorPath = path8.join(root, ".cursor", "mcp.json");
+    const cursorPath = path9.join(root, ".cursor", "mcp.json");
     let config = {};
-    if (existsSync7(cursorPath)) {
+    if (existsSync8(cursorPath)) {
       try {
         config = JSON.parse(await readFile4(cursorPath, "utf8"));
       } catch {
@@ -1942,16 +1992,16 @@ async function configureProjectMcpClients(root) {
     config.mcpServers ??= {};
     delete config.mcpServers["haive"];
     config.mcpServers["hivelore"] = entry;
-    await mkdir3(path8.dirname(cursorPath), { recursive: true });
+    await mkdir3(path9.dirname(cursorPath), { recursive: true });
     await writeFile4(cursorPath, JSON.stringify(config, null, 2) + "\n", "utf8");
     results.push({ client: "Cursor (project)", status: "configured", path: cursorPath });
   } catch (err) {
     results.push({ client: "Cursor (project)", status: "error", error: String(err) });
   }
   try {
-    const vscodePath = path8.join(root, ".vscode", "mcp.json");
+    const vscodePath = path9.join(root, ".vscode", "mcp.json");
     let config = {};
-    if (existsSync7(vscodePath)) {
+    if (existsSync8(vscodePath)) {
       try {
         config = JSON.parse(await readFile4(vscodePath, "utf8"));
       } catch {
@@ -1960,16 +2010,16 @@ async function configureProjectMcpClients(root) {
     config.servers ??= {};
     delete config.servers["haive"];
     config.servers["hivelore"] = { ...entry, type: "stdio" };
-    await mkdir3(path8.dirname(vscodePath), { recursive: true });
+    await mkdir3(path9.dirname(vscodePath), { recursive: true });
     await writeFile4(vscodePath, JSON.stringify(config, null, 2) + "\n", "utf8");
     results.push({ client: "VS Code (workspace)", status: "configured", path: vscodePath });
   } catch (err) {
     results.push({ client: "VS Code (workspace)", status: "error", error: String(err) });
   }
   try {
-    const mcpPath = path8.join(root, ".mcp.json");
+    const mcpPath = path9.join(root, ".mcp.json");
     let config = {};
-    if (existsSync7(mcpPath)) {
+    if (existsSync8(mcpPath)) {
       try {
         config = JSON.parse(await readFile4(mcpPath, "utf8"));
       } catch {
@@ -2044,9 +2094,9 @@ async function detectAgentMode(dir) {
   const root = findProjectRoot5(dir);
   const paths = resolveHaivePaths5(root);
   const projectMcp = [
-    { client: "Claude Code", path: path9.join(root, ".mcp.json"), present: existsSync8(path9.join(root, ".mcp.json")) },
-    { client: "Cursor", path: path9.join(root, ".cursor", "mcp.json"), present: existsSync8(path9.join(root, ".cursor", "mcp.json")) },
-    { client: "VS Code", path: path9.join(root, ".vscode", "mcp.json"), present: existsSync8(path9.join(root, ".vscode", "mcp.json")) }
+    { client: "Claude Code", path: path10.join(root, ".mcp.json"), present: existsSync9(path10.join(root, ".mcp.json")) },
+    { client: "Cursor", path: path10.join(root, ".cursor", "mcp.json"), present: existsSync9(path10.join(root, ".cursor", "mcp.json")) },
+    { client: "VS Code", path: path10.join(root, ".vscode", "mcp.json"), present: existsSync9(path10.join(root, ".vscode", "mcp.json")) }
   ];
   const installedAgents = [
     { agent: "Codex", command: "codex", installed: commandExists("codex"), mcp_configured: codexMcpConfigured() },
@@ -2061,7 +2111,7 @@ async function detectAgentMode(dir) {
   const recommendedCommand = recommendedMode === "mcp" ? "Restart your AI client, then call get_briefing before editing." : recommendedMode === "wrapped" && wrapperAgent ? `hivelore run -- ${wrapperAgent.command}` : 'hivelore briefing --task "..." --files "..."';
   return {
     root,
-    initialized: existsSync8(paths.haiveDir),
+    initialized: existsSync9(paths.haiveDir),
     project_mcp: projectMcp,
     installed_agents: installedAgents,
     recommended_mode: recommendedMode,
@@ -2069,9 +2119,9 @@ async function detectAgentMode(dir) {
   };
 }
 async function writeAgentModeRecord(paths, detection, skippedReason) {
-  const dir = path9.join(paths.runtimeDir, "enforcement");
+  const dir = path10.join(paths.runtimeDir, "enforcement");
   await mkdir4(dir, { recursive: true });
-  const file = path9.join(dir, "agent-mode.json");
+  const file = path10.join(dir, "agent-mode.json");
   const record = {
     selected_mode: detection.recommended_mode,
     recommended_command: detection.recommended_command,
@@ -2112,7 +2162,7 @@ async function configureCodexIfAvailable(root) {
     "mcp",
     "--stdio"
   ], { encoding: "utf8" });
-  if (result.status === 0) return { client: "Codex", status: "configured", path: path9.join(os2.homedir(), ".codex", "config.toml") };
+  if (result.status === 0) return { client: "Codex", status: "configured", path: path10.join(os2.homedir(), ".codex", "config.toml") };
   return { client: "Codex", status: "error", error: result.stderr || result.stdout || "codex mcp add failed" };
 }
 function commandExists(command) {
@@ -2139,7 +2189,7 @@ function printDetection(detection, json) {
   console.log(ui.dim(`  root: ${detection.root}`));
   console.log(`${detection.initialized ? ui.green("\u2713") : ui.red("\u2717")} project initialized`);
   for (const cfg of detection.project_mcp) {
-    console.log(`${cfg.present ? ui.green("\u2713") : ui.yellow("\u2022")} ${cfg.client} project MCP ${ui.dim(path9.relative(detection.root, cfg.path))}`);
+    console.log(`${cfg.present ? ui.green("\u2713") : ui.yellow("\u2022")} ${cfg.client} project MCP ${ui.dim(path10.relative(detection.root, cfg.path))}`);
   }
   for (const agent of detection.installed_agents) {
     const marker = agent.installed ? ui.green("\u2713") : ui.dim("\u2022");
@@ -2168,8 +2218,8 @@ function printSetupResult(result) {
 
 // src/commands/init-bootstrap.ts
 import { readdir, readFile as readFile5 } from "fs/promises";
-import { existsSync as existsSync9, readdirSync } from "fs";
-import path10 from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync3 } from "fs";
+import path11 from "path";
 var IGNORE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -2255,12 +2305,12 @@ function detectKeyDeps(allDeps) {
   return KEY_DEPS.filter((d) => allDeps[d] !== void 0);
 }
 function detectLanguage(root) {
-  if (existsSync9(path10.join(root, "tsconfig.json"))) return "TypeScript";
-  if (existsSync9(path10.join(root, "pyproject.toml")) || existsSync9(path10.join(root, "setup.py"))) return "Python";
-  if (existsSync9(path10.join(root, "go.mod"))) return "Go";
-  if (existsSync9(path10.join(root, "pom.xml")) || existsSync9(path10.join(root, "build.gradle"))) return "Java/Kotlin";
-  if (existsSync9(path10.join(root, "Cargo.toml"))) return "Rust";
-  if (existsSync9(path10.join(root, "package.json"))) {
+  if (existsSync10(path11.join(root, "tsconfig.json"))) return "TypeScript";
+  if (existsSync10(path11.join(root, "pyproject.toml")) || existsSync10(path11.join(root, "setup.py"))) return "Python";
+  if (existsSync10(path11.join(root, "go.mod"))) return "Go";
+  if (existsSync10(path11.join(root, "pom.xml")) || existsSync10(path11.join(root, "build.gradle"))) return "Java/Kotlin";
+  if (existsSync10(path11.join(root, "Cargo.toml"))) return "Rust";
+  if (existsSync10(path11.join(root, "package.json"))) {
     return hasSourceWithExt(root, [".ts", ".tsx", ".mts", ".cts"]) ? "TypeScript" : "JavaScript";
   }
   return "Unknown";
@@ -2270,7 +2320,7 @@ function hasSourceWithExt(root, exts) {
   const scanDir = (dir, depth) => {
     let entries;
     try {
-      entries = readdirSync(dir, { withFileTypes: true });
+      entries = readdirSync3(dir, { withFileTypes: true });
     } catch {
       return false;
     }
@@ -2280,7 +2330,7 @@ function hasSourceWithExt(root, exts) {
     if (depth <= 0) return false;
     for (const entry of entries) {
       if (entry.isDirectory() && !IGNORE_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
-        if (scanDir(path10.join(dir, entry.name), depth - 1)) return true;
+        if (scanDir(path11.join(dir, entry.name), depth - 1)) return true;
       }
     }
     return false;
@@ -2301,7 +2351,7 @@ function detectProjectType(frameworks, scripts, isMonorepo) {
   if (frameworks.includes("Express") || frameworks.includes("Fastify") || frameworks.includes("Hono")) return "Backend API";
   if (frameworks.includes("React") || frameworks.includes("Vue") || frameworks.includes("Svelte")) return "Frontend SPA";
   if (scripts["build"] && !scripts["dev"]) return "CLI tool / library";
-  if (existsSync9("pom.xml")) return "Java backend";
+  if (existsSync10("pom.xml")) return "Java backend";
   return "Application";
 }
 async function scanDirs(root, maxDepth = 2) {
@@ -2317,9 +2367,9 @@ async function scanDirs(root, maxDepth = 2) {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (IGNORE_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
-      const rel = path10.relative(root, path10.join(dir, entry.name));
+      const rel = path11.relative(root, path11.join(dir, entry.name));
       results.push(rel);
-      await walk(path10.join(dir, entry.name), depth + 1);
+      await walk(path11.join(dir, entry.name), depth + 1);
     }
   }
   await walk(root, 0);
@@ -2436,8 +2486,8 @@ function readmeExcerpt(readme) {
 }
 async function generateBootstrapContext(root) {
   let pkg = {};
-  const pkgPath = path10.join(root, "package.json");
-  if (existsSync9(pkgPath)) {
+  const pkgPath = path11.join(root, "package.json");
+  if (existsSync10(pkgPath)) {
     try {
       pkg = JSON.parse(await readFile5(pkgPath, "utf8"));
     } catch {
@@ -2449,18 +2499,15 @@ async function generateBootstrapContext(root) {
   const language = detectLanguage(root);
   const isMonorepo = pkg.workspaces !== void 0 && (Array.isArray(pkg.workspaces) ? pkg.workspaces.length > 0 : true);
   const projectType = detectProjectType(frameworks, pkg.scripts ?? {}, isMonorepo);
-  const projectName = pkg.name ?? path10.basename(root);
+  const projectName = pkg.name ?? path11.basename(root);
   const projectDesc = pkg.description ?? "";
   let readmeSummary = "";
-  for (const name of ["README.md", "readme.md", "README"]) {
-    const p = path10.join(root, name);
-    if (existsSync9(p)) {
-      try {
-        const content = await readFile5(p, "utf8");
-        readmeSummary = readmeExcerpt(content);
-        break;
-      } catch {
-      }
+  const readmeName = findDocFile(root, "readme");
+  if (readmeName) {
+    try {
+      const content = await readFile5(path11.join(root, readmeName), "utf8");
+      readmeSummary = readmeExcerpt(content);
+    } catch {
     }
   }
   const dirs = await scanDirs(root, 2);
@@ -2513,7 +2560,7 @@ async function generateBootstrapContext(root) {
     "",
     `## Gotchas`,
     `TODO \u2014 known traps, surprising behavior, things newcomers stub their toes on.`,
-    `(Run \`hivelore memory import-changelog\` or \`hivelore memory import README.md\` to seed these automatically.)`,
+    `(Seed these with \`hivelore memory import --from ${findDocFile(root, "changelog") ?? "CHANGELOG.md"} --changelog\` or \`hivelore memory import --from ${findDocFile(root, "readme") ?? "README.md"}\` via your AI client.)`,
     ""
   ];
   return lines.join("\n");
@@ -2521,8 +2568,8 @@ async function generateBootstrapContext(root) {
 
 // src/commands/init-stack-packs.ts
 import { mkdir as mkdir5, writeFile as writeFile6 } from "fs/promises";
-import { existsSync as existsSync10 } from "fs";
-import path11 from "path";
+import { existsSync as existsSync11 } from "fs";
+import path12 from "path";
 import {
   buildFrontmatter,
   loadMemoriesFromDir as loadMemoriesFromDir6,
@@ -3626,7 +3673,7 @@ async function seedStackPack(haivePaths, stack) {
   const existingTopics = /* @__PURE__ */ new Set();
   const existingSignatures = /* @__PURE__ */ new Set();
   const handWrittenSlugs = [];
-  if (existsSync10(haivePaths.memoriesDir)) {
+  if (existsSync11(haivePaths.memoriesDir)) {
     for (const { memory: memory2 } of await loadMemoriesFromDir6(haivePaths.memoriesDir)) {
       if (memory2.frontmatter.topic) existingTopics.add(memory2.frontmatter.topic);
       existingSignatures.add(memory2.frontmatter.id.replace(DATE_PREFIX, ""));
@@ -3671,7 +3718,7 @@ async function seedStackPack(haivePaths, stack) {
       ...sensor ? { sensor } : {}
     });
     const filePath = memoryFilePath(haivePaths, "team", fm.id);
-    if (existsSync10(filePath)) continue;
+    if (existsSync11(filePath)) continue;
     const ruleSlug = combinedSlug.startsWith(`${stack}-`) ? combinedSlug.slice(stack.length + 1) : combinedSlug;
     const titleCase = (s) => s.split("-").filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
     const heading = `${titleCase(stack)}: ${titleCase(ruleSlug)}`;
@@ -3681,7 +3728,7 @@ ${mem.body}`;
     const content = serializeMemory2({ frontmatter: fm, body: `${titledBody}
 
 ${SEED_FOOTER(stack)}` });
-    await mkdir5(path11.dirname(filePath), { recursive: true });
+    await mkdir5(path12.dirname(filePath), { recursive: true });
     await writeFile6(filePath, content, "utf8");
     existingTopics.add(topic);
     existingSignatures.add(signature);
@@ -3708,7 +3755,7 @@ ${SEED_FOOTER(stack)}` });
 
 // src/commands/init.ts
 var execFileAsync = promisify2(execFile2);
-var HAIVE_GITHUB_ACTION_REF = `v${"0.33.0"}`;
+var HAIVE_GITHUB_ACTION_REF = `v${"0.35.0"}`;
 var PROJECT_CONTEXT_TEMPLATE = `# Project context
 
 > Generated by \`hivelore init\`. Run \`hivelore init --bootstrap\` to auto-fill from your codebase,
@@ -3901,9 +3948,9 @@ function registerInit(program2) {
     "Initialize a Hivelore project \u2014 autopilot mode ON by default (zero human intervention).\n  Auto-bootstraps project-context.md from local files and seeds detected stack packs.\n  Seeds draft memories from git revert/hotfix history (--seed, on by default).\n  Add --manual to control memory approval and session recaps yourself.\n  Add --no-bootstrap and --stack none to disable the auto-features."
   ).option("-d, --dir <dir>", "project root", process.cwd()).option("--no-bridges", "do not generate any native agent bridge files").option(
     "--bridge-targets <list>",
-    `which agent bridges to generate: 'all' (default) | comma-list.
-  Available: ${BRIDGE_TARGETS.join(", ")}. Each carries top memories + block sensors.`,
-    "all"
+    `which agent bridges to generate: 'auto' (default \u2014 clients detected on this machine/repo, plus AGENTS.md) | 'all' | comma-list.
+  Available: ${BRIDGE_TARGETS2.join(", ")}. Each carries top memories + block sensors.`,
+    "auto"
   ).option("--with-ci", "write a GitHub Actions workflow (.github/workflows/haive-sync.yml) \u2014 included automatically in autopilot mode").option(
     "--manual",
     "opt out of autopilot: memories require manual approval, no auto-session recap, no auto-context"
@@ -3936,7 +3983,7 @@ function registerInit(program2) {
     "approve user-level AI client configuration prompts during agent setup",
     false
   ).option("--json", "emit a machine-readable summary on stdout (human logs go to stderr)", false).action(async (opts) => {
-    const root = path12.resolve(opts.dir);
+    const root = path13.resolve(opts.dir);
     const paths = resolveHaivePaths6(root);
     const autopilot = opts.manual !== true;
     const json = opts.json === true;
@@ -3953,9 +4000,10 @@ function registerInit(program2) {
       gitCommitsScanned: 0,
       gitRevertsFound: 0,
       gitRecurring: 0,
-      bridgesWritten: 0
+      bridgesWritten: 0,
+      bridgeTargets: []
     };
-    if (existsSync11(paths.haiveDir)) {
+    if (existsSync12(paths.haiveDir)) {
       ui.warn(`.ai/ already exists at ${paths.haiveDir} \u2014 leaving existing files in place.`);
     }
     await mkdir6(paths.personalDir, { recursive: true });
@@ -3963,8 +4011,8 @@ function registerInit(program2) {
     await mkdir6(paths.moduleDir, { recursive: true });
     await mkdir6(paths.modulesContextDir, { recursive: true });
     await ensureAiRuntimeLayout(paths.runtimeDir);
-    await ensureAiCacheLayout(path12.join(paths.haiveDir, ".cache"));
-    if (!existsSync11(paths.projectContext)) {
+    await ensureAiCacheLayout(path13.join(paths.haiveDir, ".cache"));
+    if (!existsSync12(paths.projectContext)) {
       if (wantBootstrap) {
         ui.info("Bootstrapping project context from local files\u2026");
         try {
@@ -3977,11 +4025,11 @@ function registerInit(program2) {
         }
       } else {
         await writeFile7(paths.projectContext, PROJECT_CONTEXT_TEMPLATE, "utf8");
-        ui.success(`Created ${path12.relative(root, paths.projectContext)}`);
+        ui.success(`Created ${path13.relative(root, paths.projectContext)}`);
       }
     }
-    const configExists = existsSync11(
-      path12.join(paths.haiveDir, "haive.config.json")
+    const configExists = existsSync12(
+      path13.join(paths.haiveDir, "haive.config.json")
     );
     if (!configExists) {
       await saveConfig2(paths, autopilot ? AUTOPILOT_DEFAULTS2 : { autopilot: false });
@@ -4031,11 +4079,14 @@ function registerInit(program2) {
       }
     }
     if (opts.bridges) {
-      const targets = resolveBridgeTargets(opts.bridgeTargets);
+      const targets = resolveBridgeTargets(opts.bridgeTargets, root);
       const res = await writeBridgeFiles(root, paths, { targets });
-      await writeCursorHaiveRule(root);
+      if (targets.includes("cursor")) {
+        await writeCursorHaiveRule(root);
+      }
       const made = res.created.length + res.updated.length;
       report.bridgesWritten = made;
+      report.bridgeTargets = targets;
       if (res.created.length > 0) {
         ui.success(`Generated ${res.created.length} agent bridge(s): ${res.created.join(", ")}`);
       }
@@ -4048,13 +4099,13 @@ function registerInit(program2) {
     }
     const wantCi = opts.withCi || autopilot;
     if (wantCi) {
-      const ciPath = path12.join(root, ".github", "workflows", "haive-sync.yml");
-      if (existsSync11(ciPath)) {
+      const ciPath = path13.join(root, ".github", "workflows", "haive-sync.yml");
+      if (existsSync12(ciPath)) {
         ui.info("CI workflow already exists \u2014 skipped");
       } else {
-        await mkdir6(path12.dirname(ciPath), { recursive: true });
+        await mkdir6(path13.dirname(ciPath), { recursive: true });
         await writeFile7(ciPath, CI_WORKFLOW, "utf8");
-        ui.success(`Created ${path12.relative(root, ciPath)}`);
+        ui.success(`Created ${path13.relative(root, ciPath)}`);
       }
     }
     if (autopilot) {
@@ -4094,7 +4145,7 @@ function registerInit(program2) {
         interactive: process.stdin.isTTY
       });
       for (const r of agentSetup.project_results) {
-        if (r.status === "configured" && r.path) ui.success(`hivelore MCP project config written (${path12.relative(root, r.path)})`);
+        if (r.status === "configured" && r.path) ui.success(`hivelore MCP project config written (${path13.relative(root, r.path)})`);
         else if (r.status === "error") ui.warn(`${r.client}: ${r.error}`);
       }
       for (const r of agentSetup.global_results) {
@@ -4160,10 +4211,18 @@ function registerInit(program2) {
         console.log(ui.dim("  Review .ai/project-context.md and fill in the TODO sections."));
         console.log(ui.dim("  Or invoke the MCP prompt `bootstrap_project` for a richer AI-generated version."));
       }
-      console.log();
-      console.log(ui.dim("  Seed more memories instantly:"));
-      console.log(ui.dim("    hivelore memory import-changelog   \u2014 from CHANGELOG.md"));
-      console.log(ui.dim("    hivelore memory import README.md   \u2014 from README / docs"));
+      const changelogFile = findDocFile(root, "changelog");
+      const readmeFile = findDocFile(root, "readme");
+      if (changelogFile || readmeFile) {
+        console.log();
+        console.log(ui.dim("  Seed more memories:"));
+        if (changelogFile) {
+          console.log(ui.dim(`    hivelore memory import --from ${changelogFile} --changelog   \u2014 extract breaking-change gotchas (no AI needed)`));
+        }
+        if (readmeFile) {
+          console.log(ui.dim(`    hivelore memory import --from ${readmeFile}   \u2014 prepare an import prompt for your AI client`));
+        }
+      }
     } else {
       console.log(ui.bold("Next steps:"));
       if (!wantBootstrap) {
@@ -4189,7 +4248,42 @@ async function resolveStacksToSeed(root, stackOpt) {
   return stackOpt.split(",").map((s) => s.trim().toLowerCase()).filter(isValidStack);
 }
 async function collectNestedPackageDeps(root) {
-  const SKIP = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "out", ".git", ".next", "coverage", "vendor"]);
+  const SKIP = /* @__PURE__ */ new Set([
+    "node_modules",
+    "dist",
+    "build",
+    "out",
+    ".git",
+    ".next",
+    "coverage",
+    "vendor",
+    // Fixture/demo trees describe what the project TESTS AGAINST, not what it is built with.
+    // Vite's playground/ pulls react+vue+tailwind+express into detection and seeds four
+    // irrelevant stack packs on a build-tool repo.
+    "playground",
+    "playgrounds",
+    "example",
+    "examples",
+    "fixtures",
+    "__fixtures__",
+    "e2e",
+    "test",
+    "tests",
+    "demo",
+    "demos",
+    "template",
+    "templates",
+    "bench",
+    "benchmarks",
+    "samples",
+    "sandbox",
+    // Doc sites are built with their own framework (VitePress→vue, Docusaurus→react) — that is
+    // the DOCS' stack, not the product's.
+    "docs",
+    "doc",
+    "website"
+  ]);
+  const SKIP_PREFIX = /^(template|example|fixture|demo|sample)s?-/;
   const merged = {};
   let found = false;
   async function scan(dir, depth) {
@@ -4201,10 +4295,10 @@ async function collectNestedPackageDeps(root) {
       return;
     }
     for (const entry of entries) {
-      if (!entry.isDirectory() || entry.name.startsWith(".") || SKIP.has(entry.name)) continue;
-      const sub = path12.join(dir, entry.name);
-      const pkgPath = path12.join(sub, "package.json");
-      if (existsSync11(pkgPath)) {
+      if (!entry.isDirectory() || entry.name.startsWith(".") || SKIP.has(entry.name) || SKIP_PREFIX.test(entry.name)) continue;
+      const sub = path13.join(dir, entry.name);
+      const pkgPath = path13.join(sub, "package.json");
+      if (existsSync12(pkgPath)) {
         try {
           const pkg = JSON.parse(await readFile6(pkgPath, "utf8"));
           Object.assign(merged, pkg.dependencies ?? {}, pkg.devDependencies ?? {});
@@ -4223,8 +4317,8 @@ async function autoDetectStacksFromRoot(root) {
   let requirementsTxt;
   let goMod;
   let pomXml;
-  const pkgPath = path12.join(root, "package.json");
-  if (existsSync11(pkgPath)) {
+  const pkgPath = path13.join(root, "package.json");
+  if (existsSync12(pkgPath)) {
     try {
       const pkg = JSON.parse(await readFile6(pkgPath, "utf8"));
       packageJsonDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
@@ -4234,8 +4328,8 @@ async function autoDetectStacksFromRoot(root) {
   const nestedDeps = await collectNestedPackageDeps(root);
   if (nestedDeps) packageJsonDeps = { ...packageJsonDeps ?? {}, ...nestedDeps };
   for (const name of ["requirements.txt", "requirements/base.txt", "requirements/prod.txt"]) {
-    const reqPath = path12.join(root, name);
-    if (existsSync11(reqPath)) {
+    const reqPath = path13.join(root, name);
+    if (existsSync12(reqPath)) {
       try {
         requirementsTxt = await readFile6(reqPath, "utf8");
         break;
@@ -4243,39 +4337,39 @@ async function autoDetectStacksFromRoot(root) {
       }
     }
   }
-  const goModPath = path12.join(root, "go.mod");
-  if (existsSync11(goModPath)) {
+  const goModPath = path13.join(root, "go.mod");
+  if (existsSync12(goModPath)) {
     try {
       goMod = await readFile6(goModPath, "utf8");
     } catch {
     }
   }
-  const pomPath = path12.join(root, "pom.xml");
-  if (existsSync11(pomPath)) {
+  const pomPath = path13.join(root, "pom.xml");
+  if (existsSync12(pomPath)) {
     try {
       pomXml = await readFile6(pomPath, "utf8");
     } catch {
     }
   }
   let composerJson;
-  const composerPath = path12.join(root, "composer.json");
-  if (existsSync11(composerPath)) {
+  const composerPath = path13.join(root, "composer.json");
+  if (existsSync12(composerPath)) {
     try {
       composerJson = await readFile6(composerPath, "utf8");
     } catch {
     }
   }
   let gemfile;
-  const gemfilePath = path12.join(root, "Gemfile");
-  if (existsSync11(gemfilePath)) {
+  const gemfilePath = path13.join(root, "Gemfile");
+  if (existsSync12(gemfilePath)) {
     try {
       gemfile = await readFile6(gemfilePath, "utf8");
     } catch {
     }
   }
-  const hasDockerfile = existsSync11(path12.join(root, "Dockerfile"));
-  const hasTurboJson = existsSync11(path12.join(root, "turbo.json"));
-  const hasNxJson = existsSync11(path12.join(root, "nx.json"));
+  const hasDockerfile = existsSync12(path13.join(root, "Dockerfile"));
+  const hasTurboJson = existsSync12(path13.join(root, "turbo.json"));
+  const hasNxJson = existsSync12(path13.join(root, "nx.json"));
   let hasCsproj = false;
   try {
     const entries = await readdir2(root);
@@ -4327,8 +4421,8 @@ async function seedFromGitHistory(root, paths, limit) {
 _Seeded from git ${p.kind} commit ${p.source_sha}. Review and validate (or delete) \u2014 not yet authoritative._
 `;
     const file = memoryFilePath2(paths, fm.scope, fm.id, fm.module);
-    if (existsSync11(file)) continue;
-    await mkdir6(path12.dirname(file), { recursive: true });
+    if (existsSync12(file)) continue;
+    await mkdir6(path13.dirname(file), { recursive: true });
     await writeFile7(file, serializeMemory3({ frontmatter: fm, body }), "utf8");
     written++;
   }
@@ -4369,7 +4463,7 @@ function printInitReport(r) {
     lines.push(`  Total ready : ${r.totalMemories} lesson(s), ${r.totalSensors} sensor(s) \u2014 0 written by hand`);
   }
   if (r.bridgesWritten > 0) {
-    lines.push(`  Reach       : ${r.bridgesWritten} agent bridge(s) generated (Cursor, Cline, Copilot, Roo, Gemini, \u2026)`);
+    lines.push(`  Reach       : ${r.bridgesWritten} agent bridge(s) generated (${r.bridgeTargets.join(", ")})`);
   }
   if (lines.length === 0) return;
   const width = Math.max(...lines.map((l) => l.length), 44);
@@ -4390,33 +4484,37 @@ function printInitReport(r) {
 }
 async function writeCursorHaiveRule(root) {
   const relPath = ".cursor/rules/haive-mcp-required.mdc";
-  const target = path12.join(root, relPath);
-  if (existsSync11(target)) {
+  const target = path13.join(root, relPath);
+  if (existsSync12(target)) {
     ui.info(`Cursor rule ${relPath} already exists \u2014 skipped`);
     return;
   }
-  await mkdir6(path12.dirname(target), { recursive: true });
+  await mkdir6(path13.dirname(target), { recursive: true });
   await writeFile7(target, CURSOR_HAIVE_RULE_MDC, "utf8");
   ui.success(`Created Cursor rule ${relPath}`);
 }
-function resolveBridgeTargets(opt) {
-  const raw = (opt ?? "all").trim().toLowerCase();
-  if (raw === "" || raw === "all") return [...BRIDGE_TARGETS];
+function resolveBridgeTargets(opt, root) {
+  const raw = (opt ?? "auto").trim().toLowerCase();
+  if (raw === "all") return [...BRIDGE_TARGETS2];
+  if (raw === "" || raw === "auto") {
+    const detection = detectBridgeTargets(root);
+    const named = detection.targets.map((t) => detection.reasons[t] === "repo file" ? `${t} (already in repo)` : t).join(", ");
+    ui.info(`Bridge targets (detected): ${named} \u2014 pass --bridge-targets all for every supported client`);
+    return detection.targets;
+  }
   const requested = raw.split(",").map((t) => t.trim()).filter(Boolean);
-  const valid = requested.filter((t) => BRIDGE_TARGETS.includes(t));
-  const invalid = requested.filter((t) => !BRIDGE_TARGETS.includes(t));
+  const valid = requested.filter((t) => BRIDGE_TARGETS2.includes(t));
+  const invalid = requested.filter((t) => !BRIDGE_TARGETS2.includes(t));
   if (invalid.length > 0) {
-    ui.warn(`Ignoring unknown bridge target(s): ${invalid.join(", ")}. Valid: ${BRIDGE_TARGETS.join(", ")}`);
+    ui.warn(`Ignoring unknown bridge target(s): ${invalid.join(", ")}. Valid: ${BRIDGE_TARGETS2.join(", ")}`);
   }
-  return valid.length > 0 ? valid : [...BRIDGE_TARGETS];
+  return valid.length > 0 ? valid : [...BRIDGE_TARGETS2];
 }
 var RUNTIME_README_BODY = `# .ai/.runtime \u2014 disposable local layer
 
 Not team truth. Use for machine-local session notes or tooling scratch files.
 Official memories belong in .ai/memories/ (versioned in Git).
 Only .gitignore and this README are meant to commit; everything else stays untracked.
-
-Session continuity (local): agents may append \`session-journal.ndjson\` via MCP \`runtime_journal_append\` or \`hivelore runtime journal append\`.
 `;
 var RUNTIME_GITIGNORE_BODY = `*
 !.gitignore
@@ -4424,27 +4522,27 @@ var RUNTIME_GITIGNORE_BODY = `*
 `;
 async function ensureAiRuntimeLayout(runtimeDir) {
   await mkdir6(runtimeDir, { recursive: true });
-  const gi = path12.join(runtimeDir, ".gitignore");
-  if (!existsSync11(gi)) {
+  const gi = path13.join(runtimeDir, ".gitignore");
+  if (!existsSync12(gi)) {
     await writeFile7(gi, RUNTIME_GITIGNORE_BODY, "utf8");
   }
-  const readme = path12.join(runtimeDir, "README.md");
-  if (!existsSync11(readme)) {
+  const readme = path13.join(runtimeDir, "README.md");
+  if (!existsSync12(readme)) {
     await writeFile7(readme, RUNTIME_README_BODY, "utf8");
   }
 }
 async function ensureAiCacheLayout(cacheDir) {
   await mkdir6(cacheDir, { recursive: true });
-  const gi = path12.join(cacheDir, ".gitignore");
-  if (!existsSync11(gi)) {
+  const gi = path13.join(cacheDir, ".gitignore");
+  if (!existsSync12(gi)) {
     await writeFile7(gi, "*\n!.gitignore\n", "utf8");
   }
 }
 async function ensureGitignoreEntries(root, patterns) {
   try {
-    const gitignorePath = path12.join(root, ".gitignore");
+    const gitignorePath = path13.join(root, ".gitignore");
     let existing = "";
-    if (existsSync11(gitignorePath)) {
+    if (existsSync12(gitignorePath)) {
       existing = await readFile6(gitignorePath, "utf8");
     }
     const lines = existing.split("\n");
@@ -4458,8 +4556,8 @@ async function ensureGitignoreEntries(root, patterns) {
 
 // src/commands/observe.ts
 import { appendFile, mkdir as mkdir7 } from "fs/promises";
-import { existsSync as existsSync12 } from "fs";
-import path13 from "path";
+import { existsSync as existsSync13 } from "fs";
+import path14 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot7, resolveHaivePaths as resolveHaivePaths7 } from "@hivelore/core";
 var MAX_STDIN_BYTES = 256 * 1024;
@@ -4566,7 +4664,7 @@ function registerObserve(program2) {
       })();
       if (!root) return;
       const paths = resolveHaivePaths7(root);
-      if (!existsSync12(paths.haiveDir)) return;
+      if (!existsSync13(paths.haiveDir)) return;
       const failureHint = detectFailure(payload);
       const observation = {
         ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -4577,10 +4675,10 @@ function registerObserve(program2) {
         files: extractFiles(payload),
         ...failureHint ? { failure_hint: true } : {}
       };
-      const cacheDir = path13.join(paths.haiveDir, ".cache");
+      const cacheDir = path14.join(paths.haiveDir, ".cache");
       await mkdir7(cacheDir, { recursive: true });
       await appendFile(
-        path13.join(cacheDir, "observations.jsonl"),
+        path14.join(cacheDir, "observations.jsonl"),
         JSON.stringify(observation) + "\n",
         "utf8"
       );
@@ -4611,30 +4709,37 @@ function registerMcp(program2) {
 // src/commands/sync.ts
 import { spawnSync as spawnSync4 } from "child_process";
 import { readFile as readFile7, writeFile as writeFile8, mkdir as mkdir8 } from "fs/promises";
-import { existsSync as existsSync13 } from "fs";
-import path14 from "path";
+import { existsSync as existsSync14 } from "fs";
+import path15 from "path";
 import "commander";
 import {
   DEFAULT_AUTO_PROMOTE_RULE,
+  assessSensorHealth,
   buildFrontmatter as buildFrontmatter3,
+  existingGateMissShas,
   findProjectRoot as findProjectRoot9,
   getUsage as getUsage2,
+  gatePassedShas,
   isAutoPromoteEligible,
   isDecaying,
   isStackPackSeed,
   loadCodeMap as loadCodeMap5,
   loadConfig as loadConfig3,
   loadMemoriesFromDir as loadMemoriesFromDir7,
+  loadSensorLedger,
   loadUsageIndex as loadUsageIndex3,
   pullCrossRepoSources,
+  planGitWatch,
+  proposeGateMissDrafts,
   resolveHaivePaths as resolveHaivePaths8,
   resolveManifestFiles,
   serializeMemory as serializeMemory4,
+  withQuarantineNote,
   trackDependencies,
   verifyAnchor,
   watchContracts
 } from "@hivelore/core";
-import { BRIDGE_TARGETS as BRIDGE_TARGETS2 } from "@hivelore/core";
+import { BRIDGE_TARGETS as BRIDGE_TARGETS3 } from "@hivelore/core";
 var BRIDGE_START = "<!-- haive:memories-start -->";
 var BRIDGE_END = "<!-- haive:memories-end -->";
 function registerSync(program2) {
@@ -4649,7 +4754,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("--no-bridges", "skip auto-refresh of existing native agent bridge files (.cursor/rules, .clinerules, \u2026)").option("--dry-run", "report what would change without writing any files").action(async (opts) => {
     const root = findProjectRoot9(opts.dir);
     const paths = resolveHaivePaths8(root);
-    if (!existsSync13(paths.memoriesDir)) {
+    if (!existsSync14(paths.memoriesDir)) {
       if (!opts.quiet) ui.warn(`No .ai/memories at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -4667,6 +4772,24 @@ function registerSync(program2) {
     let revalidated = 0;
     let promoted = 0;
     let autoApproved = 0;
+    let quarantined = 0;
+    const sensorHealth = new Map(
+      assessSensorHealth(await loadSensorLedger(paths)).map((health) => [health.memory_id, health])
+    );
+    const quarantineCandidates = await loadMemoriesFromDir7(paths.memoriesDir);
+    for (const { memory: memory2, filePath } of quarantineCandidates) {
+      const sensor = memory2.frontmatter.sensor;
+      const health = sensorHealth.get(memory2.frontmatter.id);
+      if (!sensor || sensor.kind !== "shell" && sensor.kind !== "test" || sensor.severity !== "block" || !health?.quarantine_pending) continue;
+      if (!dryRun) {
+        const at = (/* @__PURE__ */ new Date()).toISOString();
+        await writeFile8(filePath, serializeMemory4({
+          frontmatter: { ...memory2.frontmatter, sensor: { ...sensor, severity: "warn" } },
+          body: withQuarantineNote(memory2.body, at, health.flap_count)
+        }), "utf8");
+      }
+      quarantined++;
+    }
     if (opts.verify !== false) {
       const memories = await loadMemoriesFromDir7(paths.memoriesDir);
       for (const { memory: memory2, filePath } of memories) {
@@ -4787,13 +4910,17 @@ function registerSync(program2) {
       for (const repair of repairs) log(ui.dim(`autopilot: ${repair.message}`));
     }
     const sinceReport = opts.since ? collectSinceChanges(root, opts.since) : null;
+    const gateMissIds = await processGateMissWatch(root, paths, dryRun);
+    if (gateMissIds.length > 0) {
+      log(ui.yellow(`gate-miss: proposed ${gateMissIds.length} lesson(s): ${gateMissIds.join(", ")}`));
+    }
     const draftMemories = (await loadMemoriesFromDir7(paths.memoriesDir)).filter(
       (m) => m.memory.frontmatter.status === "draft"
     );
     const draftCount = draftMemories.length;
     const autoApprovedNote = autoApproved > 0 ? ` \xB7 ${autoApproved} auto-approved` : "";
     log(
-      `${ui.dim("sync:")} ${staleMarked} stale \xB7 ${revalidated} revalidated \xB7 ${promoted} promoted${autoApprovedNote}${sinceReport ? ` \xB7 ${sinceReport.added.length}+/${sinceReport.modified.length}~/${sinceReport.removed.length}- since ${opts.since}` : ""}`
+      `${ui.dim("sync:")} ${staleMarked} stale \xB7 ${revalidated} revalidated \xB7 ${promoted} promoted \xB7 ${quarantined} quarantined${autoApprovedNote}${sinceReport ? ` \xB7 ${sinceReport.added.length}+/${sinceReport.modified.length}~/${sinceReport.removed.length}- since ${opts.since}` : ""}`
     );
     if (!opts.quiet && draftCount > 0) {
       log(
@@ -4805,7 +4932,7 @@ function registerSync(program2) {
     if (opts.injectBridge) {
       const maxInject = Math.max(1, Number(opts.bridgeMaxMemories ?? 5));
       if (opts.bridgeFile) {
-        await injectBridge(path14.resolve(opts.bridgeFile), paths.memoriesDir, maxInject, root, opts.quiet);
+        await injectBridge(path15.resolve(opts.bridgeFile), paths.memoriesDir, maxInject, root, opts.quiet);
       } else if (!dryRun) {
         const res = await writeBridgeFiles(root, paths, {
           targets: ["claude", "agents"],
@@ -4834,7 +4961,7 @@ function registerSync(program2) {
     if (opts.noBridges !== true) {
       try {
         const res = await writeBridgeFiles(root, paths, {
-          targets: BRIDGE_TARGETS2,
+          targets: BRIDGE_TARGETS3,
           onlyExisting: true,
           dryRun
         });
@@ -4954,10 +5081,10 @@ Wait for **explicit confirmation** before acting.
                   topic: `dep-bump-${slugParts}`
                 });
                 if (!dryRun) {
-                  const teamDir = path14.join(paths.memoriesDir, "team");
+                  const teamDir = path15.join(paths.memoriesDir, "team");
                   await mkdir8(teamDir, { recursive: true });
                   await writeFile8(
-                    path14.join(teamDir, `${fm.id}.md`),
+                    path15.join(teamDir, `${fm.id}.md`),
                     serializeMemory4({ frontmatter: { ...fm, requires_human_approval: true }, body }),
                     "utf8"
                   );
@@ -5023,10 +5150,10 @@ Wait for **explicit confirmation** before acting.
               topic: `contract-breaking-${diff.contract}`
             });
             if (!dryRun) {
-              const teamDir = path14.join(paths.memoriesDir, "team");
+              const teamDir = path15.join(paths.memoriesDir, "team");
               await mkdir8(teamDir, { recursive: true });
               await writeFile8(
-                path14.join(teamDir, `${fm.id}.md`),
+                path15.join(teamDir, `${fm.id}.md`),
                 serializeMemory4({ frontmatter: { ...fm, requires_human_approval: true }, body }),
                 "utf8"
               );
@@ -5111,13 +5238,90 @@ Wait for **explicit confirmation** before acting.
     }
   });
 }
+async function processGateMissWatch(root, paths, dryRun) {
+  const headResult = spawnSync4("git", ["rev-parse", "HEAD"], { cwd: root, encoding: "utf8" });
+  if (headResult.status !== 0) return [];
+  const head = headResult.stdout.trim();
+  if (!head) return [];
+  const stateFile = path15.join(paths.runtimeDir, "enforcement", "git-watch.json");
+  let state = null;
+  try {
+    state = JSON.parse(await readFile7(stateFile, "utf8"));
+  } catch {
+  }
+  const plan = planGitWatch(state, head);
+  if (plan.action === "initialize") {
+    if (!dryRun) {
+      await mkdir8(path15.dirname(stateFile), { recursive: true });
+      await writeFile8(stateFile, JSON.stringify(plan.next, null, 2) + "\n", "utf8");
+    }
+    return [];
+  }
+  if (plan.action === "idle") return [];
+  const proposals = proposeGateMissDrafts(
+    readGitCommitsRange(root, plan.range),
+    existingGateMissShas(await loadMemoriesFromDir7(paths.memoriesDir)),
+    gatePassedShas(await loadSensorLedger(paths))
+  );
+  const ids = [];
+  for (const proposal of proposals) {
+    const fm = {
+      ...buildFrontmatter3({
+        type: "attempt",
+        slug: proposal.slug,
+        scope: "team",
+        status: "proposed",
+        tags: ["gate-miss", proposal.kind],
+        paths: proposal.paths,
+        topic: `gate-miss-${proposal.reverted_sha}`
+      }),
+      status: "proposed"
+    };
+    ids.push(fm.id);
+    if (!dryRun) {
+      await mkdir8(paths.teamDir, { recursive: true });
+      await writeFile8(
+        path15.join(paths.teamDir, `${fm.id}.md`),
+        serializeMemory4({ frontmatter: fm, body: proposal.body }),
+        "utf8"
+      );
+    }
+  }
+  if (!dryRun) {
+    await mkdir8(path15.dirname(stateFile), { recursive: true });
+    await writeFile8(stateFile, JSON.stringify(plan.next, null, 2) + "\n", "utf8");
+  }
+  return ids;
+}
+function readGitCommitsRange(root, range) {
+  const result = spawnSync4(
+    "git",
+    ["log", "--reverse", "--format=%x1e%H%x1f%s%x1f%b%x1f", "--name-only", range],
+    { cwd: root, encoding: "utf8", maxBuffer: 8 * 1024 * 1024 }
+  );
+  if (result.status !== 0) return [];
+  const commits = [];
+  for (const block of result.stdout.split("").filter((part) => part.trim())) {
+    const [shaRaw, subjectRaw, bodyRaw, filesRaw = ""] = block.split("");
+    const sha = shaRaw?.trim();
+    const subject = subjectRaw?.trim();
+    if (!sha || !subject) continue;
+    commits.push({
+      sha,
+      subject,
+      body: bodyRaw?.trim() ?? "",
+      files: filesRaw.split("\n").map((file) => file.trim()).filter(Boolean)
+    });
+  }
+  return commits;
+}
 function bridgeSummaryLine(body) {
   const firstLine = body.split("\n").map((l) => l.replace(/^#+\s*/, "").trim()).find((l) => l.length > 0) ?? "";
   const oneLine = firstLine.replace(/\s+/g, " ");
   return oneLine.length > 140 ? oneLine.slice(0, 137) + "\u2026" : oneLine;
 }
 async function injectBridge(bridgeFile, memoriesDir, maxMemories, root, quiet) {
-  if (!existsSync13(memoriesDir)) return;
+  if (!existsSync14(memoriesDir)) return;
   const all = await loadMemoriesFromDir7(memoriesDir);
   const top = all.filter(({ memory: memory2 }) => {
     const s = memory2.frontmatter.status;
@@ -5143,17 +5347,17 @@ async function injectBridge(bridgeFile, memoriesDir, maxMemories, root, quiet) {
 ` + block + `
 
 ${BRIDGE_END}`;
-  const fileExists = existsSync13(bridgeFile);
+  const fileExists = existsSync14(bridgeFile);
   let existing = fileExists ? await readFile7(bridgeFile, "utf8") : "";
   existing = existing.replace(/\r\n/g, "\n");
   const startIdx = existing.indexOf(BRIDGE_START);
   const endIdx = existing.indexOf(BRIDGE_END);
   if (startIdx !== -1 && endIdx === -1) {
-    ui.warn(`${path14.relative(root, bridgeFile)}: found ${BRIDGE_START} without ${BRIDGE_END}. Fix the file manually before running --inject-bridge.`);
+    ui.warn(`${path15.relative(root, bridgeFile)}: found ${BRIDGE_START} without ${BRIDGE_END}. Fix the file manually before running --inject-bridge.`);
     return;
   }
   if (startIdx === -1 && endIdx !== -1) {
-    ui.warn(`${path14.relative(root, bridgeFile)}: found ${BRIDGE_END} without ${BRIDGE_START}. Fix the file manually before running --inject-bridge.`);
+    ui.warn(`${path15.relative(root, bridgeFile)}: found ${BRIDGE_END} without ${BRIDGE_START}. Fix the file manually before running --inject-bridge.`);
     return;
   }
   let updated;
@@ -5161,14 +5365,14 @@ ${BRIDGE_END}`;
     updated = existing.slice(0, startIdx) + injected + existing.slice(endIdx + BRIDGE_END.length);
   } else {
     if (!fileExists && !quiet) {
-      ui.info(`Creating ${path14.relative(root, bridgeFile)} with hivelore memory block.`);
+      ui.info(`Creating ${path15.relative(root, bridgeFile)} with hivelore memory block.`);
     }
     updated = existing + (existing.endsWith("\n") ? "" : "\n") + "\n" + injected + "\n";
   }
   await writeFile8(bridgeFile, updated, "utf8");
   if (!quiet) {
     console.log(
-      ui.dim(`bridge: injected ${top.length} memor${top.length === 1 ? "y" : "ies"} into ${path14.relative(root, bridgeFile)}`)
+      ui.dim(`bridge: injected ${top.length} memor${top.length === 1 ? "y" : "ies"} into ${path15.relative(root, bridgeFile)}`)
     );
   }
 }
@@ -5194,8 +5398,8 @@ function collectSinceChanges(root, ref) {
 // src/commands/memory-add.ts
 import { createHash } from "crypto";
 import { mkdir as mkdir9, readFile as readFile8, writeFile as writeFile9 } from "fs/promises";
-import { existsSync as existsSync14 } from "fs";
-import path15 from "path";
+import { existsSync as existsSync15 } from "fs";
+import path16 from "path";
 import { Option } from "commander";
 import {
   buildFrontmatter as buildFrontmatter4,
@@ -5237,7 +5441,7 @@ function registerMemoryAdd(memory2) {
     if (opts.body === void 0 && opts.content !== void 0) opts.body = opts.content;
     const root = findProjectRoot10(opts.dir);
     const paths = resolveHaivePaths9(root);
-    if (!existsSync14(paths.haiveDir)) {
+    if (!existsSync15(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -5254,7 +5458,7 @@ function registerMemoryAdd(memory2) {
     const inferredTags = autoTagsEnabled ? inferModulesFromPaths2(anchorPaths) : [];
     const mergedTags = Array.from(/* @__PURE__ */ new Set([...userTags, ...inferredTags]));
     if (anchorPaths.length > 0) {
-      const missing = anchorPaths.filter((p) => !existsSync14(path15.resolve(root, p)));
+      const missing = anchorPaths.filter((p) => !existsSync15(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}`);
@@ -5267,7 +5471,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 (!existsSync14(opts.bodyFile)) {
+      if (!existsSync15(opts.bodyFile)) {
         ui.error(`--body-file not found: ${opts.bodyFile}`);
         process.exitCode = 1;
         return;
@@ -5283,7 +5487,7 @@ TODO \u2014 write the memory body.
 `;
     }
     const scope = opts.scope ?? config.defaultScope ?? "personal";
-    if (existsSync14(paths.memoriesDir)) {
+    if (existsSync15(paths.memoriesDir)) {
       const incomingHash = createHash("sha256").update(body.trim()).digest("hex").slice(0, 12);
       const allForHash = await loadMemoriesFromDir8(paths.memoriesDir);
       const hashDup = allForHash.find(
@@ -5296,7 +5500,7 @@ TODO \u2014 write the memory body.
         return;
       }
     }
-    if (opts.topic && existsSync14(paths.memoriesDir)) {
+    if (opts.topic && existsSync15(paths.memoriesDir)) {
       const existing = await loadMemoriesFromDir8(paths.memoriesDir);
       const topicMatch = existing.find(
         ({ memory: memory3 }) => memory3.frontmatter.topic === opts.topic && memory3.frontmatter.scope === scope && (!opts.module || memory3.frontmatter.module === opts.module)
@@ -5316,7 +5520,7 @@ TODO \u2014 write the memory body.
           }
         };
         await writeFile9(topicMatch.filePath, serializeMemory5({ frontmatter: newFrontmatter, body }), "utf8");
-        ui.success(`Updated (topic upsert) ${path15.relative(root, topicMatch.filePath)}`);
+        ui.success(`Updated (topic upsert) ${path16.relative(root, topicMatch.filePath)}`);
         ui.info(`id=${fm.id}  revision=${revisionCount}`);
         printSensorLoopHint(opts.type, body, newFrontmatter.anchor.paths, Boolean(newFrontmatter.sensor));
         await runPostMemoryAutopilot(root, paths, config);
@@ -5340,13 +5544,13 @@ TODO \u2014 write the memory body.
     });
     if (frontmatter.status === "validated") frontmatter.validated_by = "auto";
     const file = memoryFilePath3(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir9(path15.dirname(file), { recursive: true });
-    if (existsSync14(file)) {
+    await mkdir9(path16.dirname(file), { recursive: true });
+    if (existsSync15(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
       return;
     }
-    if (existsSync14(paths.memoriesDir)) {
+    if (existsSync15(paths.memoriesDir)) {
       const existing = await loadMemoriesFromDir8(paths.memoriesDir);
       const slugTokens = slug.toLowerCase().split(/[-_\s]+/).filter(Boolean);
       const similar = existing.filter(({ memory: memory3 }) => {
@@ -5359,7 +5563,7 @@ TODO \u2014 write the memory body.
       }
     }
     await writeFile9(file, serializeMemory5({ frontmatter, body }), "utf8");
-    ui.success(`Created ${path15.relative(root, file)}`);
+    ui.success(`Created ${path16.relative(root, file)}`);
     ui.info(`id=${frontmatter.id}  scope=${frontmatter.scope}  status=${frontmatter.status}`);
     printSensorLoopHint(opts.type, body, anchorPaths, Boolean(frontmatter.sensor));
     await runPostMemoryAutopilot(root, paths, config);
@@ -5453,8 +5657,8 @@ function slugify(value) {
 }
 
 // src/commands/memory-list.ts
-import { existsSync as existsSync15 } from "fs";
-import path16 from "path";
+import { existsSync as existsSync16 } from "fs";
+import path17 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot11, resolveHaivePaths as resolveHaivePaths10 } from "@hivelore/core";
 function registerMemoryList(memory2) {
@@ -5466,7 +5670,7 @@ function registerMemoryList(memory2) {
     }
     const root = findProjectRoot11(opts.dir);
     const paths = resolveHaivePaths10(root);
-    if (!existsSync15(paths.memoriesDir)) {
+    if (!existsSync16(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -5505,7 +5709,7 @@ function registerMemoryList(memory2) {
       );
       const title = mem.body.match(/^#\s+(.+)$/m)?.[1]?.trim();
       if (title && title !== fm.id) console.log(`  ${title}`);
-      console.log(`  ${ui.dim(path16.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path17.relative(root, filePath))}`);
     }
     const totalLabel = clipped > 0 ? `
 ${displayed.length} of ${filtered.length} memories shown (use --limit to adjust)` : `
@@ -5543,8 +5747,8 @@ function matchesFilters(loaded, opts) {
 
 // src/commands/memory-promote.ts
 import { mkdir as mkdir10, unlink, writeFile as writeFile10 } from "fs/promises";
-import { existsSync as existsSync16 } from "fs";
-import path17 from "path";
+import { existsSync as existsSync17 } from "fs";
+import path18 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot12,
@@ -5556,7 +5760,7 @@ 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 = findProjectRoot12(opts.dir);
     const paths = resolveHaivePaths11(root);
-    if (!existsSync16(paths.memoriesDir)) {
+    if (!existsSync17(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -5591,19 +5795,19 @@ function registerMemoryPromote(memory2) {
       body: found.memory.body
     };
     const newPath = memoryFilePath4(paths, "team", updated.frontmatter.id);
-    await mkdir10(path17.dirname(newPath), { recursive: true });
+    await mkdir10(path18.dirname(newPath), { recursive: true });
     await writeFile10(newPath, serializeMemory6(updated), "utf8");
     await unlink(found.filePath);
     ui.success(`Promoted ${id} to team scope (status=proposed)`);
-    ui.info(`Now at ${path17.relative(root, newPath)}`);
+    ui.info(`Now at ${path18.relative(root, newPath)}`);
     console.log(ui.dim(`\u2192 next: hivelore memory approve ${id}  (validate for team use)`));
   });
 }
 
 // src/commands/memory-approve.ts
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync18 } from "fs";
 import { writeFile as writeFile11 } from "fs/promises";
-import path18 from "path";
+import path19 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot13,
@@ -5614,7 +5818,7 @@ 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 = findProjectRoot13(opts.dir);
     const paths = resolveHaivePaths12(root);
-    if (!existsSync17(paths.memoriesDir)) {
+    if (!existsSync18(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -5668,15 +5872,15 @@ function registerMemoryApprove(memory2) {
     };
     await writeFile11(found.filePath, serializeMemory7(next), "utf8");
     ui.success(`Approved ${id} (status=validated, by=human)`);
-    ui.info(path18.relative(root, found.filePath));
+    ui.info(path19.relative(root, found.filePath));
   });
 }
 
 // src/commands/memory-update.ts
 import { spawn } from "child_process";
 import { readFile as readFile9, writeFile as writeFile12 } from "fs/promises";
-import { existsSync as existsSync18 } from "fs";
-import path19 from "path";
+import { existsSync as existsSync19 } from "fs";
+import path20 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot14,
@@ -5689,7 +5893,7 @@ function registerMemoryUpdate(memory2) {
     const root = findProjectRoot14(opts.dir);
     const paths = resolveHaivePaths13(root);
     if (opts.edit) {
-      const all = existsSync18(paths.memoriesDir) ? await loadMemoriesFromDir(paths.memoriesDir) : [];
+      const all = existsSync19(paths.memoriesDir) ? await loadMemoriesFromDir(paths.memoriesDir) : [];
       const found = all.find((m) => m.memory.frontmatter.id === id);
       if (!found) {
         ui.error(`No memory with id "${id}".`);
@@ -5697,7 +5901,7 @@ function registerMemoryUpdate(memory2) {
         return;
       }
       const editor = opts.editor ?? process.env.EDITOR ?? process.env.VISUAL ?? "vi";
-      ui.info(`Opening ${path19.relative(root, found.filePath)} with ${editor}\u2026`);
+      ui.info(`Opening ${path20.relative(root, found.filePath)} with ${editor}\u2026`);
       const code = await new Promise((resolve) => {
         const child = spawn(editor, [found.filePath], { stdio: "inherit" });
         child.on("exit", (c) => resolve(c ?? 0));
@@ -5714,7 +5918,7 @@ function registerMemoryUpdate(memory2) {
       }
       return;
     }
-    if (!existsSync18(paths.memoriesDir)) {
+    if (!existsSync19(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -5756,7 +5960,7 @@ function registerMemoryUpdate(memory2) {
     if (opts.author !== void 0) updated.push("author");
     let newBody;
     if (opts.bodyFile !== void 0) {
-      if (!existsSync18(opts.bodyFile)) {
+      if (!existsSync19(opts.bodyFile)) {
         ui.error(`--body-file not found: ${opts.bodyFile}`);
         process.exitCode = 1;
         return;
@@ -5782,7 +5986,7 @@ function registerMemoryUpdate(memory2) {
       serializeMemory8({ frontmatter: newFrontmatter, body: newBody }),
       "utf8"
     );
-    ui.success(`Updated ${path19.relative(root, loaded.filePath)}`);
+    ui.success(`Updated ${path20.relative(root, loaded.filePath)}`);
     ui.info(`fields: ${updated.join(", ")}`);
   });
 }
@@ -5801,8 +6005,8 @@ function parseCsv3(value) {
 }
 
 // src/commands/memory-tried.ts
-import { existsSync as existsSync19 } from "fs";
-import path20 from "path";
+import { existsSync as existsSync20 } from "fs";
+import path21 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot15,
@@ -5817,7 +6021,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("--sensor-pattern <regex>", "one-shot: regex matching the FAULTY usage \u2014 validates + attaches a sensor in this call").option("--sensor-command <cmd>", "one-shot BEHAVIOUR sensor: a command (test/script) the gate runs when the diff touches --paths; non-zero exit = lesson fires").option("--sensor-kind <kind>", "with --sensor-command: shell | test (default test)").option("--sensor-timeout <ms>", "with --sensor-command: max runtime in ms (default 120000)").option("--sensor-absent <regex>", "one-shot: regex marking CORRECT usage nearby (excludes it from firing)").option("--sensor-severity <level>", "one-shot sensor severity: warn | block", "block").option("--sensor-message <text>", "one-shot: self-correction message shown when the sensor fires").option("--bad-example <code>", "one-shot: code snippet the sensor must fire on (validation)").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot15(opts.dir);
     const paths = resolveHaivePaths14(root);
-    if (!existsSync19(paths.haiveDir)) {
+    if (!existsSync20(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -5863,7 +6067,7 @@ function registerMemoryTried(memory2) {
       process.exitCode = 1;
       return;
     }
-    ui.success(`Recorded: ${path20.relative(root, result.file_path)}`);
+    ui.success(`Recorded: ${path21.relative(root, result.file_path)}`);
     ui.info(`id=${result.id}  type=attempt  status=validated (auto-approved)`);
     if (result.sensor_result) {
       if (result.sensor_result.accepted) {
@@ -5887,8 +6091,8 @@ function registerMemoryTried(memory2) {
 
 // src/commands/memory-seed.ts
 import { readFile as readFile10 } from "fs/promises";
-import { existsSync as existsSync20 } from "fs";
-import path21 from "path";
+import { existsSync as existsSync21 } from "fs";
+import path22 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot16,
@@ -5897,7 +6101,7 @@ import {
 } from "@hivelore/core";
 async function readDependencyMap(root) {
   try {
-    const raw = await readFile10(path21.join(root, "package.json"), "utf8");
+    const raw = await readFile10(path22.join(root, "package.json"), "utf8");
     const pkg = JSON.parse(raw);
     return { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
   } catch {
@@ -5932,7 +6136,7 @@ function registerMemorySeed(memory2) {
       }
       return;
     }
-    if (!existsSync20(paths.haiveDir)) {
+    if (!existsSync21(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -5988,8 +6192,8 @@ function registerMemorySeed(memory2) {
 }
 
 // src/commands/memory-query.ts
-import { existsSync as existsSync21 } from "fs";
-import path22 from "path";
+import { existsSync as existsSync22 } from "fs";
+import path23 from "path";
 import "commander";
 import {
   extractSnippet,
@@ -6005,7 +6209,7 @@ function registerMemoryQuery(memory2) {
   memory2.command("search <text>").alias("query").description("Search memories by id, tag, or substring (AND, OR fallback). Mirrors MCP mem_search. Alias: query").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 = findProjectRoot17(opts.dir);
     const paths = resolveHaivePaths16(root);
-    if (!existsSync21(paths.memoriesDir)) {
+    if (!existsSync22(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -6046,7 +6250,7 @@ function registerMemoryQuery(memory2) {
       const fm = mem.frontmatter;
       const statusBadge = ui.statusBadge(fm.status);
       console.log(`${ui.bold(fm.id)} ${ui.dim(fm.scope)} ${statusBadge}`);
-      console.log(`  ${ui.dim(path22.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path23.relative(root, filePath))}`);
       const snippet = extractSnippet(mem.body, snippetNeedle);
       if (snippet) console.log(`  ${snippet}`);
     }
@@ -6064,7 +6268,7 @@ ${top.length} of ${matches.length} match${matches.length === 1 ? "" : "es"}`)
 
 // src/commands/memory-reject.ts
 import { writeFile as writeFile13 } from "fs/promises";
-import { existsSync as existsSync22 } from "fs";
+import { existsSync as existsSync23 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot18,
@@ -6078,7 +6282,7 @@ 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 = findProjectRoot18(opts.dir);
     const paths = resolveHaivePaths17(root);
-    if (!existsSync22(paths.memoriesDir)) {
+    if (!existsSync23(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -6114,9 +6318,9 @@ function registerMemoryReject(memory2) {
 }
 
 // src/commands/memory-rm.ts
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 import { unlink as unlink2 } from "fs/promises";
-import path23 from "path";
+import path24 from "path";
 import { createInterface as createInterface2 } from "readline/promises";
 import "commander";
 import {
@@ -6129,7 +6333,7 @@ function registerMemoryRm(memory2) {
   memory2.command("delete <id>").alias("rm").description("Delete a memory file (and its usage entry by default). Mirrors MCP mem_delete. Alias: rm").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 = findProjectRoot19(opts.dir);
     const paths = resolveHaivePaths18(root);
-    if (!existsSync23(paths.memoriesDir)) {
+    if (!existsSync24(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -6141,7 +6345,7 @@ function registerMemoryRm(memory2) {
       process.exitCode = 1;
       return;
     }
-    const rel = path23.relative(root, found.filePath);
+    const rel = path24.relative(root, found.filePath);
     if (!opts.yes) {
       const rl = createInterface2({ input: process.stdin, output: process.stdout });
       const answer = (await rl.question(`Delete ${rel}? [y/N] `)).trim().toLowerCase();
@@ -6165,9 +6369,9 @@ function registerMemoryRm(memory2) {
 }
 
 // src/commands/memory-show.ts
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import { readFile as readFile11 } from "fs/promises";
-import path24 from "path";
+import path25 from "path";
 import "commander";
 import {
   deriveConfidence,
@@ -6180,7 +6384,7 @@ function registerMemoryShow(memory2) {
   memory2.command("get <id>").alias("show").description("Print a memory's frontmatter, body, and confidence/usage. Mirrors MCP mem_get. Alias: show").option("--raw", "print the raw file contents instead of a summary").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
     const root = findProjectRoot20(opts.dir);
     const paths = resolveHaivePaths19(root);
-    if (!existsSync24(paths.memoriesDir)) {
+    if (!existsSync25(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -6209,7 +6413,7 @@ function registerMemoryShow(memory2) {
     if (fm.verified_at) console.log(`${ui.dim("verified:")}   ${fm.verified_at}`);
     if (fm.stale_reason) console.log(`${ui.dim("stale:")}      ${fm.stale_reason}`);
     console.log(`${ui.dim("reads:")}      ${u.read_count}  ${ui.dim("rejections:")} ${u.rejected_count}`);
-    console.log(`${ui.dim("file:")}       ${path24.relative(root, found.filePath)}`);
+    console.log(`${ui.dim("file:")}       ${path25.relative(root, found.filePath)}`);
     if (fm.anchor.paths.length || fm.anchor.symbols.length) {
       console.log(ui.dim("anchor:"));
       if (fm.anchor.commit) console.log(`  ${ui.dim("commit:")}  ${fm.anchor.commit}`);
@@ -6224,8 +6428,8 @@ function registerMemoryShow(memory2) {
 }
 
 // src/commands/memory-stats.ts
-import { existsSync as existsSync25 } from "fs";
-import path25 from "path";
+import { existsSync as existsSync26 } from "fs";
+import path26 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence2,
@@ -6238,7 +6442,7 @@ 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("--hot", "only unvalidated (draft/proposed) memories read often \u2014 promotion candidates (absorbed `memory hot`)").option("--threshold <n>", "with --hot: minimum read_count to qualify", "3").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot21(opts.dir);
     const paths = resolveHaivePaths20(root);
-    if (!existsSync25(paths.memoriesDir)) {
+    if (!existsSync26(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -6269,13 +6473,13 @@ function registerMemoryStats(memory2) {
       console.log(
         `  ${ui.dim("status:")} ${fm.status}  ${ui.dim("reads:")} ${u.read_count}  ${ui.dim("rejections:")} ${u.rejected_count}`
       );
-      console.log(`  ${ui.dim(path25.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path26.relative(root, filePath))}`);
     }
   });
 }
 
 // src/commands/memory-impact.ts
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync27 } from "fs";
 import "commander";
 import {
   compareImpact,
@@ -6292,7 +6496,7 @@ function registerMemoryImpact(memory2) {
   ).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 = findProjectRoot22(opts.dir);
     const paths = resolveHaivePaths21(root);
-    if (!existsSync26(paths.memoriesDir)) {
+    if (!existsSync27(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -6363,7 +6567,7 @@ function pad(value, width) {
 }
 
 // src/commands/memory-feedback.ts
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 import { writeFile as writeFile14 } from "fs/promises";
 import "commander";
 import {
@@ -6390,7 +6594,7 @@ function registerMemoryFeedback(memory2) {
     }
     const root = findProjectRoot23(opts.dir);
     const paths = resolveHaivePaths22(root);
-    if (!existsSync27(paths.memoriesDir)) {
+    if (!existsSync28(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -6431,8 +6635,8 @@ function registerMemoryFeedback(memory2) {
 
 // src/commands/memory-verify.ts
 import { writeFile as writeFile15 } from "fs/promises";
-import { existsSync as existsSync28 } from "fs";
-import path26 from "path";
+import { existsSync as existsSync29 } from "fs";
+import path27 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot24,
@@ -6446,7 +6650,7 @@ function registerMemoryVerify(memory2) {
   ).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 = findProjectRoot24(opts.dir);
     const paths = resolveHaivePaths23(root);
-    if (!existsSync28(paths.memoriesDir)) {
+    if (!existsSync29(paths.memoriesDir)) {
       if (opts.json) {
         console.log(JSON.stringify({ error: "not-initialized", root }, null, 2));
       } else {
@@ -6474,7 +6678,7 @@ function registerMemoryVerify(memory2) {
     for (const { memory: mem, filePath } of targets) {
       const result = await verifyAnchor2(mem, { projectRoot: root });
       const isAnchored = mem.frontmatter.anchor.paths.length > 0 || mem.frontmatter.anchor.symbols.length > 0;
-      const rel = path26.relative(root, filePath);
+      const rel = path27.relative(root, filePath);
       if (!isAnchored) {
         anchorlessIds.push(mem.frontmatter.id);
         entries.push({ id: mem.frontmatter.id, status: "anchorless", path: rel });
@@ -6567,7 +6771,7 @@ function applyVerification(mem, result) {
 
 // src/commands/memory-import.ts
 import { readFile as readFile12 } from "fs/promises";
-import { existsSync as existsSync29 } from "fs";
+import { existsSync as existsSync30 } from "fs";
 import "commander";
 import {
   findProjectRoot as findProjectRoot25,
@@ -6584,12 +6788,12 @@ function registerMemoryImport(memory2) {
     }
     const root = findProjectRoot25(opts.dir);
     const paths = resolveHaivePaths24(root);
-    if (!existsSync29(paths.haiveDir)) {
+    if (!existsSync30(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
     }
-    if (!existsSync29(opts.from)) {
+    if (!existsSync30(opts.from)) {
       ui.error(`File not found: ${opts.from}`);
       process.exitCode = 1;
       return;
@@ -6622,9 +6826,9 @@ function registerMemoryImport(memory2) {
 }
 
 // src/commands/memory-digest.ts
-import { existsSync as existsSync30 } from "fs";
+import { existsSync as existsSync31 } from "fs";
 import { writeFile as writeFile16 } from "fs/promises";
-import path27 from "path";
+import path28 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence3,
@@ -6647,7 +6851,7 @@ function registerMemoryDigest(program2) {
   ).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 = findProjectRoot26(opts.dir);
     const paths = resolveHaivePaths25(root);
-    if (!existsSync30(paths.memoriesDir)) {
+    if (!existsSync31(paths.memoriesDir)) {
       ui.error("No .ai/memories found. Run `hivelore init` first.");
       process.exitCode = 1;
       return;
@@ -6719,7 +6923,7 @@ function registerMemoryDigest(program2) {
     );
     const digest = lines.join("\n");
     if (opts.out) {
-      const outPath = path27.resolve(process.cwd(), opts.out);
+      const outPath = path28.resolve(process.cwd(), opts.out);
       await writeFile16(outPath, digest, "utf8");
       ui.success(`Digest written to ${opts.out}  (${recent.length} memor${recent.length === 1 ? "y" : "ies"})`);
     } else {
@@ -6730,9 +6934,9 @@ function registerMemoryDigest(program2) {
 
 // src/commands/session-end.ts
 import { writeFile as writeFile17, mkdir as mkdir11, readFile as readFile13, rm } from "fs/promises";
-import { existsSync as existsSync31 } from "fs";
+import { existsSync as existsSync32 } from "fs";
 import { spawn as spawn2 } from "child_process";
-import path28 from "path";
+import path29 from "path";
 import { Option as Option2 } from "commander";
 import {
   buildFrontmatter as buildFrontmatter5,
@@ -6749,8 +6953,8 @@ import {
   writeSessionHandoff
 } from "@hivelore/core";
 async function buildAutoRecap(paths) {
-  const obsFile = path28.join(paths.haiveDir, ".cache", "observations.jsonl");
-  if (!existsSync31(obsFile)) return await buildGitAutoRecap(paths);
+  const obsFile = path29.join(paths.haiveDir, ".cache", "observations.jsonl");
+  if (!existsSync32(obsFile)) return await buildGitAutoRecap(paths);
   const raw = await readFile13(obsFile, "utf8").catch(() => "");
   if (!raw.trim()) return await buildGitAutoRecap(paths);
   const lines = raw.split("\n").filter(Boolean);
@@ -6918,8 +7122,8 @@ function runGit(cwd, args) {
   });
 }
 async function observationStart(paths) {
-  const obsFile = path28.join(paths.haiveDir, ".cache", "observations.jsonl");
-  if (!existsSync31(obsFile)) return null;
+  const obsFile = path29.join(paths.haiveDir, ".cache", "observations.jsonl");
+  if (!existsSync32(obsFile)) return null;
   const raw = await readFile13(obsFile, "utf8").catch(() => "");
   let first = null;
   for (const line of raw.split("\n")) {
@@ -6935,7 +7139,7 @@ async function observationStart(paths) {
 }
 async function printCaughtForYou(paths, since, quiet) {
   if (quiet) return;
-  const memories = existsSync31(paths.memoriesDir) ? await loadMemoriesFromDir10(paths.memoriesDir) : [];
+  const memories = existsSync32(paths.memoriesDir) ? await loadMemoriesFromDir10(paths.memoriesDir) : [];
   const usage = await loadUsageIndex11(paths);
   const events = await loadPreventionEvents(paths);
   const summary = summarizeCaughtForYou(events, memories, usage, {
@@ -6973,7 +7177,7 @@ function registerSessionEnd(session2) {
   ).option("--goal <text>", "what you were trying to accomplish (1\u20132 sentences)").option("--accomplished <text>", "what was actually done (bullet list recommended)").addOption(new Option2("--summary <text>", "alias for --accomplished").hideHelp()).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 = findProjectRoot27(opts.dir);
     const paths = resolveHaivePaths26(root);
-    if (!existsSync31(paths.haiveDir)) {
+    if (!existsSync32(paths.haiveDir)) {
       if (opts.auto || opts.quiet) return;
       ui.error(`No .ai/ found at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
@@ -7007,15 +7211,15 @@ function registerSessionEnd(session2) {
     });
     const topic = recapTopic(scope, opts.module);
     const filesTouched = parseCsv5(resolvedFiles).map((p) => normalizeAnchorPath(root, p));
-    const missingPaths = filesTouched.filter((p) => !existsSync31(path28.resolve(root, p)));
+    const missingPaths = filesTouched.filter((p) => !existsSync32(path29.resolve(root, p)));
     if (missingPaths.length > 0 && !opts.quiet) {
       ui.warn(`Anchor path${missingPaths.length > 1 ? "s" : ""} not found in project (will be stale):`);
       for (const p of missingPaths) ui.warn(`  \u2717 ${p}`);
     }
     const cleanupObservations = async () => {
       if (!opts.auto) return;
-      const obsFile = path28.join(paths.haiveDir, ".cache", "observations.jsonl");
-      if (existsSync31(obsFile)) await rm(obsFile).catch(() => {
+      const obsFile = path29.join(paths.haiveDir, ".cache", "observations.jsonl");
+      if (existsSync32(obsFile)) await rm(obsFile).catch(() => {
       });
     };
     const config = await loadConfig6(paths);
@@ -7039,7 +7243,7 @@ function registerSessionEnd(session2) {
       }
       return;
     }
-    if (existsSync31(paths.memoriesDir)) {
+    if (existsSync32(paths.memoriesDir)) {
       const existing = await loadMemoriesFromDir10(paths.memoriesDir);
       const topicMatch = existing.find(
         ({ memory: memory2 }) => memory2.frontmatter.topic === topic && memory2.frontmatter.scope === scope && (!opts.module || memory2.frontmatter.module === opts.module)
@@ -7060,7 +7264,7 @@ function registerSessionEnd(session2) {
         await cleanupObservations();
         if (!opts.quiet) {
           ui.success(`Session recap updated (revision #${revisionCount})`);
-          ui.info(`id=${fm.id}  file=${path28.relative(root, topicMatch.filePath)}`);
+          ui.info(`id=${fm.id}  file=${path29.relative(root, topicMatch.filePath)}`);
           await printCaughtForYou(paths, caughtSince, opts.quiet);
           ui.info("Tip: `hivelore stats --export-report` generates a usage JSON suitable for dashboards.");
         }
@@ -7078,12 +7282,12 @@ function registerSessionEnd(session2) {
       status: "validated"
     });
     const file = memoryFilePath5(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir11(path28.dirname(file), { recursive: true });
+    await mkdir11(path29.dirname(file), { recursive: true });
     await writeFile17(file, serializeMemory12({ frontmatter, body }), "utf8");
     await cleanupObservations();
     if (!opts.quiet) {
       ui.success(`Session recap created`);
-      ui.info(`id=${frontmatter.id}  scope=${scope}  file=${path28.relative(root, file)}`);
+      ui.info(`id=${frontmatter.id}  scope=${scope}  file=${path29.relative(root, file)}`);
       await printCaughtForYou(paths, caughtSince, opts.quiet);
       ui.info("Next session: call `get_briefing` \u2014 the recap will be surfaced automatically.");
       ui.info("Tip: export a local MCP usage rollup with `hivelore stats --export-report .ai/tool-usage-roi-report.json`.");
@@ -7096,29 +7300,47 @@ function parseCsv5(value) {
 }
 function normalizeAnchorPath(root, filePath) {
   if (!filePath) return filePath;
-  if (!path28.isAbsolute(filePath)) return filePath;
-  const rel = path28.relative(root, filePath);
+  if (!path29.isAbsolute(filePath)) return filePath;
+  const rel = path29.relative(root, filePath);
   if (rel.startsWith("..")) return filePath;
   return rel;
 }
 
 // src/commands/stats.ts
 import "commander";
-import { existsSync as existsSync32 } from "fs";
+import { existsSync as existsSync33 } from "fs";
 import { mkdir as mkdir12, writeFile as writeFile18 } from "fs/promises";
-import path29 from "path";
+import path30 from "path";
 import {
   aggregateUsage,
+  buildPreventionReceipt,
+  renderPreventionReceipt,
   findProjectRoot as findProjectRoot28,
   loadMemoriesFromDir as loadMemoriesFromDir11,
   loadUsageIndex as loadUsageIndex12,
+  loadPreventionEvents as loadPreventionEvents2,
   parseSince,
   readUsageEvents,
   resolveHaivePaths as resolveHaivePaths27,
   usageLogSize
 } from "@hivelore/core";
 function registerStats(program2) {
-  program2.command("stats").description("Show MCP tool-usage stats over a window (e.g. --since 7d).").option("--since <window>", "ISO date or relative (e.g. '7d', '24h', '30m')", "30d").option("--json", "emit JSON instead of human-readable output", false).option("--memory-hits", "show top-read memories (which mems are actually being used)", false).option(
+  const stats = program2.command("stats").description("Show MCP tool-usage stats and prevention receipts.");
+  stats.command("receipt").description("Show documented mistakes refused by the gate over a time window").addHelpText("after", "\nParent options also apply: --since <window> (default 7d here), --json, --dir <dir>.").action(async () => {
+    const opts = stats.opts();
+    const root = findProjectRoot28(opts.dir);
+    const paths = resolveHaivePaths27(root);
+    const sinceRaw = stats.getOptionValueSource("since") === "default" ? "7d" : opts.since ?? "7d";
+    const since = parseSince(sinceRaw) ?? new Date(Date.now() - 7 * 864e5);
+    const [events, usage, memories] = await Promise.all([
+      loadPreventionEvents2(paths),
+      loadUsageIndex12(paths),
+      existsSync33(paths.memoriesDir) ? loadMemoriesFromDir11(paths.memoriesDir) : Promise.resolve([])
+    ]);
+    const receipt = buildPreventionReceipt(events, memories, usage, { since });
+    console.log(opts.json ? JSON.stringify(receipt, null, 2) : renderPreventionReceipt(receipt));
+  });
+  stats.option("--since <window>", "ISO date or relative (e.g. '7d', '24h', '30m')", "30d").option("--json", "emit JSON instead of human-readable output", false).option("--memory-hits", "show top-read memories (which mems are actually being used)", false).option(
     "--export-report <path>",
     "write a JSON rollup (tools + briefing counts + heuristic ROI hints). Parent dirs are created if needed.",
     void 0
@@ -7178,11 +7400,11 @@ function registerStats(program2) {
   });
 }
 async function writeRoiReport(paths, root, sinceRaw, outRelative) {
-  const outAbs = path29.isAbsolute(outRelative) ? path29.resolve(outRelative) : path29.resolve(root, outRelative);
+  const outAbs = path30.isAbsolute(outRelative) ? path30.resolve(outRelative) : path30.resolve(root, outRelative);
   const size = await usageLogSize(paths);
   let events = await readUsageEvents(paths);
   let memoryCount = { team: 0, personal: 0, total_skipped_session: 0 };
-  if (existsSync32(paths.memoriesDir)) {
+  if (existsSync33(paths.memoriesDir)) {
     const mems = await loadMemoriesFromDir11(paths.memoriesDir);
     for (const { memory: memory2 } of mems) {
       const fm = memory2.frontmatter;
@@ -7212,7 +7434,7 @@ async function writeRoiReport(paths, root, sinceRaw, outRelative) {
     ui.warn("Usage log missing or empty \u2014 report still written with partial data.");
     events = [];
   }
-  await mkdir12(path29.dirname(outAbs), { recursive: true });
+  await mkdir12(path30.dirname(outAbs), { recursive: true });
   const payload = {
     generated_at: (/* @__PURE__ */ new Date()).toISOString(),
     project_root: root,
@@ -7401,9 +7623,9 @@ function summarize(name, t0, payload, notes) {
 }
 
 // src/commands/benchmark.ts
-import { existsSync as existsSync33 } from "fs";
+import { existsSync as existsSync34 } from "fs";
 import { readdir as readdir3, readFile as readFile14, writeFile as writeFile19 } from "fs/promises";
-import path30 from "path";
+import path31 from "path";
 import "commander";
 import { estimateTokens as estimateTokens2, findProjectRoot as findProjectRoot30 } from "@hivelore/core";
 function registerBenchmark(program2) {
@@ -7418,9 +7640,9 @@ function registerBenchmark(program2) {
     }
     const markdown = renderMarkdown(root, summary, rows);
     if (opts.out) {
-      const outFile = path30.isAbsolute(opts.out) ? opts.out : path30.join(root, opts.out);
+      const outFile = path31.isAbsolute(opts.out) ? opts.out : path31.join(root, opts.out);
       await writeFile19(outFile, markdown, "utf8");
-      ui.success(`wrote ${path30.relative(process.cwd(), outFile)}`);
+      ui.success(`wrote ${path31.relative(process.cwd(), outFile)}`);
       return;
     }
     console.log(markdown);
@@ -7444,19 +7666,19 @@ function registerBenchmark(program2) {
 }
 function resolveBenchmarkRoot(dir) {
   const candidate = dir ?? "benchmarks/agent-benchmark";
-  if (path30.isAbsolute(candidate)) return candidate;
+  if (path31.isAbsolute(candidate)) return candidate;
   const projectRoot = findProjectRoot30(process.cwd());
-  return path30.join(projectRoot, candidate);
+  return path31.join(projectRoot, candidate);
 }
 async function collectRows(root) {
-  if (!existsSync33(root)) throw new Error(`Benchmark directory not found: ${root}`);
+  if (!existsSync34(root)) throw new Error(`Benchmark directory not found: ${root}`);
   const entries = await readdir3(root, { withFileTypes: true });
   const rows = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const fixtureDir = path30.join(root, entry.name);
-    const reportFile = path30.join(fixtureDir, "BENCHMARK_AGENT_REPORT.md");
-    if (!existsSync33(reportFile)) continue;
+    const fixtureDir = path31.join(root, entry.name);
+    const reportFile = path31.join(fixtureDir, "BENCHMARK_AGENT_REPORT.md");
+    if (!existsSync34(reportFile)) continue;
     const report = await readFile14(reportFile, "utf8");
     rows.push(parseAgentReport(entry.name, report));
   }
@@ -7549,8 +7771,8 @@ function escapeRegExp(value) {
 
 // src/commands/eval.ts
 import { mkdir as mkdir13, readFile as readFile15, writeFile as writeFile20 } from "fs/promises";
-import { existsSync as existsSync34 } from "fs";
-import path31 from "path";
+import { existsSync as existsSync35 } from "fs";
+import path32 from "path";
 import "commander";
 import {
   aggregateRetrieval,
@@ -7564,7 +7786,7 @@ import {
   findProjectRoot as findProjectRoot31,
   loadConfig as loadConfig7,
   loadEvalHistory,
-  loadPreventionEvents as loadPreventionEvents2,
+  loadPreventionEvents as loadPreventionEvents3,
   loadUsageIndex as loadUsageIndex13,
   overallScore,
   resolveHaivePaths as resolveHaivePaths29,
@@ -7578,7 +7800,7 @@ function registerEval(program2) {
   ).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("--fail-under-catch-rate <pct>", "exit non-zero if sensor catch-rate is below this percentage").option("--fail-under-gate-precision <pct>", "exit non-zero if gate precision is below this percentage").option("--baseline", "save this run as the baseline (.ai/eval/baseline.json) for future --compare", false).option("--compare", "diff this run against the saved baseline and print the delta", false).option("--baseline-file <path>", "baseline file to read/write (default: .ai/eval/baseline.json)").option("--fail-on-regression", "with --compare, exit non-zero if the score dropped vs the baseline", false).option("--regression-gate", "CI-safe gate: compare against the baseline IF one exists (fail on regression), else no-op", false).option("--record", "append this run's score to .ai/.cache/eval-history.jsonl (trend the harness over time)", false).option("--trend", "print the recorded score trend (sparkline + latest/best/delta) and exit", false).option("--ref <ref>", "version/commit label stored with a --record run").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot31(opts.dir);
     const paths = resolveHaivePaths29(root);
-    if (!existsSync34(paths.memoriesDir)) {
+    if (!existsSync35(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -7631,7 +7853,7 @@ function registerEval(program2) {
     const authoredScore = resolvedSpec.authored > 0 && resolvedSpec.synthesized > 0 && (authoredRetrievalAgg || sensorAgg) ? overallScore(authoredRetrievalAgg, sensorAgg) : null;
     const [usage, preventionEvents, config] = await Promise.all([
       loadUsageIndex13(paths),
-      loadPreventionEvents2(paths),
+      loadPreventionEvents3(paths),
       loadConfig7(paths)
     ]);
     const gatePrecision = computeGatePrecision(
@@ -7650,7 +7872,7 @@ function registerEval(program2) {
       });
       if (!opts.json) ui.success(`Recorded eval score ${report.score}/100 to history.`);
     }
-    const baselineFile = opts.baselineFile ? path31.isAbsolute(opts.baselineFile) ? opts.baselineFile : path31.join(root, opts.baselineFile) : path31.join(root, ".ai", "eval", "baseline.json");
+    const baselineFile = opts.baselineFile ? path32.isAbsolute(opts.baselineFile) ? opts.baselineFile : path32.join(root, opts.baselineFile) : path32.join(root, ".ai", "eval", "baseline.json");
     if (opts.baseline) {
       const snapshot = {
         saved_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -7659,18 +7881,18 @@ function registerEval(program2) {
         report,
         gate_precision: gatePrecision
       };
-      await mkdir13(path31.dirname(baselineFile), { recursive: true });
+      await mkdir13(path32.dirname(baselineFile), { recursive: true });
       await writeFile20(baselineFile, JSON.stringify(snapshot, null, 2), "utf8");
-      if (!opts.json) ui.success(`Saved baseline (score ${report.score}/100) \u2192 ${path31.relative(root, baselineFile)}`);
+      if (!opts.json) ui.success(`Saved baseline (score ${report.score}/100) \u2192 ${path32.relative(root, baselineFile)}`);
     }
     let delta = null;
     let gateDelta = null;
     if (opts.compare || opts.regressionGate) {
-      if (!existsSync34(baselineFile)) {
+      if (!existsSync35(baselineFile)) {
         if (opts.regressionGate) {
-          if (!opts.json) ui.info(`No baseline at ${path31.relative(root, baselineFile)} \u2014 regression gate skipped. Run \`hivelore eval --baseline\` to enable it.`);
+          if (!opts.json) ui.info(`No baseline at ${path32.relative(root, baselineFile)} \u2014 regression gate skipped. Run \`hivelore eval --baseline\` to enable it.`);
         } else {
-          ui.error(`No baseline at ${path31.relative(root, baselineFile)}. Run \`hivelore eval --baseline\` first.`);
+          ui.error(`No baseline at ${path32.relative(root, baselineFile)}. Run \`hivelore eval --baseline\` first.`);
           process.exitCode = 1;
           return;
         }
@@ -7713,9 +7935,9 @@ function registerEval(program2) {
     }
     const md = renderMarkdown2(root, k, resolvedSpec, report, gatePrecision, authoredScore);
     if (opts.out) {
-      const outFile = path31.isAbsolute(opts.out) ? opts.out : path31.join(root, opts.out);
+      const outFile = path32.isAbsolute(opts.out) ? opts.out : path32.join(root, opts.out);
       await writeFile20(outFile, md, "utf8");
-      ui.success(`wrote ${path31.relative(process.cwd(), outFile)}`);
+      ui.success(`wrote ${path32.relative(process.cwd(), outFile)}`);
     } else {
       console.log(md);
     }
@@ -7799,13 +8021,13 @@ function countCases(spec) {
 }
 async function resolveSpec(opts, root, memoriesDir) {
   if (opts.spec) {
-    const file = path31.resolve(opts.spec);
+    const file = path32.resolve(opts.spec);
     const raw = await readFile15(file, "utf8");
     const spec = JSON.parse(raw);
     return { spec, source: file, synthesized: 0, authored: countCases(spec) };
   }
-  const defaultSpec = path31.join(root, ".ai", "eval", "spec.json");
-  if (existsSync34(defaultSpec)) {
+  const defaultSpec = path32.join(root, ".ai", "eval", "spec.json");
+  if (existsSync35(defaultSpec)) {
     const raw = await readFile15(defaultSpec, "utf8");
     const explicit = JSON.parse(raw);
     const memories2 = await loadMemoriesFromDir(memoriesDir);
@@ -7932,8 +8154,8 @@ function renderMarkdown2(root, k, resolved, report, gatePrecision, authoredScore
 
 // src/commands/memory-suggest.ts
 import { mkdir as mkdir14, writeFile as writeFile21 } from "fs/promises";
-import { existsSync as existsSync35 } from "fs";
-import path32 from "path";
+import { existsSync as existsSync36 } from "fs";
+import path33 from "path";
 import "commander";
 import {
   MemoryTypeSchema,
@@ -8023,7 +8245,7 @@ function registerMemorySuggest(memory2) {
       }
       const created = [];
       const skipped = [];
-      const existing = existsSync35(paths.memoriesDir) ? await loadMemoriesFromDir12(paths.memoriesDir) : [];
+      const existing = existsSync36(paths.memoriesDir) ? await loadMemoriesFromDir12(paths.memoriesDir) : [];
       for (const s of top) {
         const slug = slugify2(s.query);
         if (!slug) {
@@ -8046,13 +8268,13 @@ function registerMemorySuggest(memory2) {
         });
         const body = renderTemplate(s, fm.id, status);
         const file = memoryFilePath6(paths, fm.scope, fm.id, fm.module);
-        await mkdir14(path32.dirname(file), { recursive: true });
-        if (existsSync35(file)) {
-          skipped.push({ query: s.query, reason: `file already exists at ${path32.relative(root, file)}` });
+        await mkdir14(path33.dirname(file), { recursive: true });
+        if (existsSync36(file)) {
+          skipped.push({ query: s.query, reason: `file already exists at ${path33.relative(root, file)}` });
           continue;
         }
         await writeFile21(file, serializeMemory13({ frontmatter: fm, body }), "utf8");
-        created.push({ id: fm.id, file: path32.relative(root, file), query: s.query });
+        created.push({ id: fm.id, file: path33.relative(root, file), query: s.query });
       }
       if (opts.json) {
         console.log(JSON.stringify({ created, skipped }, null, 2));
@@ -8150,8 +8372,8 @@ function truncate2(text, max) {
 }
 
 // src/commands/memory-conflict-candidates.ts
-import { existsSync as existsSync36 } from "fs";
-import path33 from "path";
+import { existsSync as existsSync37 } from "fs";
+import path34 from "path";
 import "commander";
 import {
   findLexicalConflictPairs,
@@ -8187,9 +8409,9 @@ function registerMemoryConflictCandidates(memory2) {
   });
 }
 async function runConflictCandidates(opts) {
-  const root = path33.resolve(opts.dir ?? process.cwd());
+  const root = path34.resolve(opts.dir ?? process.cwd());
   const paths = resolveHaivePaths31(findProjectRoot33(root));
-  if (!existsSync36(paths.memoriesDir)) {
+  if (!existsSync37(paths.memoriesDir)) {
     ui.error("No memories \u2014 run `hivelore init`.");
     process.exitCode = 1;
     return;
@@ -8223,9 +8445,9 @@ async function runConflictCandidates(opts) {
 }
 
 // src/commands/memory-archive.ts
-import { existsSync as existsSync37 } from "fs";
+import { existsSync as existsSync38 } from "fs";
 import { writeFile as writeFile22 } from "fs/promises";
-import path34 from "path";
+import path35 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot34,
@@ -8244,7 +8466,7 @@ function registerMemoryArchive(memory2) {
   ).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 = findProjectRoot34(opts.dir);
     const paths = resolveHaivePaths32(root);
-    if (!existsSync37(paths.memoriesDir)) {
+    if (!existsSync38(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -8269,7 +8491,7 @@ 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) => !existsSync37(path34.join(paths.root, p)));
+      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync38(path35.join(paths.root, p)));
       const isAnchorless = !hasAnyAnchor;
       if (!retired.retired && !opts.unread && !isAnchorless && !allPathsGone) continue;
       const u = getUsage8(usage, fm.id);
@@ -8344,13 +8566,14 @@ function parseDays(input) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync38, statSync as statSync2 } from "fs";
+import { existsSync as existsSync39, statSync as statSync2 } from "fs";
 import { readFile as readFile16, stat, writeFile as writeFile23 } from "fs/promises";
-import path35 from "path";
+import path36 from "path";
 import { execFileSync, execSync } from "child_process";
 import "commander";
 import {
   codeMapPath as codeMapPath2,
+  assessSensorHealth as assessSensorHealth2,
   countSourceFilesOnDisk,
   extractReferencedPaths,
   sensorPatternBrittleness,
@@ -8360,7 +8583,8 @@ import {
   isStackPackSeed as isStackPackSeed2,
   loadCodeMap as loadCodeMap6,
   loadConfig as loadConfig10,
-  loadMemoriesFromDir as loadMemoriesFromDir14,
+  loadMemoriesFromDirDetailed,
+  loadSensorLedger as loadSensorLedger2,
   loadUsageIndex as loadUsageIndex15,
   readUsageEvents as readUsageEvents3,
   resolveHaivePaths as resolveHaivePaths33
@@ -8375,7 +8599,7 @@ function registerDoctor(program2) {
     const findings = [];
     const repairs = [];
     const config = await loadConfig10(paths);
-    if (!existsSync38(paths.haiveDir)) {
+    if (!existsSync39(paths.haiveDir)) {
       if (opts.json) {
         console.log(JSON.stringify({
           initialized: false,
@@ -8400,7 +8624,7 @@ function registerDoctor(program2) {
         })
       );
     }
-    if (!existsSync38(paths.projectContext)) {
+    if (!existsSync39(paths.projectContext)) {
       findings.push({
         severity: "warn",
         code: "no-project-context",
@@ -8420,7 +8644,7 @@ function registerDoctor(program2) {
         });
       } else {
         const referenced = extractReferencedPaths(content);
-        const missing = referenced.filter((p) => !existsSync38(path35.resolve(root, p)));
+        const missing = referenced.filter((p) => !existsSync39(path36.resolve(root, p)));
         const grounded = referenced.length - missing.length;
         if (referenced.length >= 3 && grounded / referenced.length < 0.5) {
           findings.push({
@@ -8442,13 +8666,23 @@ function registerDoctor(program2) {
         });
       }
     }
-    const memories = existsSync38(paths.memoriesDir) ? await loadMemoriesFromDir14(paths.memoriesDir) : [];
+    const memoriesDetailed = existsSync39(paths.memoriesDir) ? await loadMemoriesFromDirDetailed(paths.memoriesDir) : { loaded: [], invalid: [] };
+    const memories = memoriesDetailed.loaded;
     const now = Date.now();
+    if (memoriesDetailed.invalid.length > 0) {
+      const listed = memoriesDetailed.invalid.slice(0, 5).map((f) => `${path36.relative(root, f.filePath)} (${f.error})`).join("; ");
+      findings.push({
+        severity: "warn",
+        code: "invalid-memory-files",
+        message: `${memoriesDetailed.invalid.length} memory file(s) failed to parse and are INVISIBLE to briefings and the gate: ${listed}`,
+        fix: "Fix the frontmatter (or delete the file) \u2014 a corrupt memory is a silently lost team lesson."
+      });
+    }
     if (memories.length === 0) {
       findings.push({
         severity: "info",
         code: "no-memories",
-        message: "No memories yet. Capture knowledge as agents work via mem_save / mem_observe / mem_tried."
+        message: "No memories yet. Capture knowledge as agents work via mem_save / mem_tried."
       });
     } else {
       const usage = await loadUsageIndex15(paths);
@@ -8458,7 +8692,7 @@ function registerDoctor(program2) {
           severity: "warn",
           code: "stale-memories",
           message: `${stale.length} memor${stale.length === 1 ? "y" : "ies"} marked stale (anchored code drifted).`,
-          fix: "hivelore memory verify --update    # re-check anchors\nhaive memory edit <id>           # manually refresh body"
+          fix: "hivelore memory verify --update    # re-check anchors\nhivelore memory update <id>        # manually refresh body"
         });
       }
       const proposed = memories.filter((m) => m.memory.frontmatter.status === "proposed");
@@ -8546,6 +8780,18 @@ function registerDoctor(program2) {
       });
     }
     const sensorMemories = memories.filter((m) => m.memory.frontmatter.sensor);
+    const gateMissDrafts = memories.filter(
+      (m) => m.memory.frontmatter.status === "proposed" && m.memory.frontmatter.tags.includes("gate-miss")
+    );
+    if (gateMissDrafts.length > 0) {
+      findings.push({
+        severity: "info",
+        code: "gate-miss-drafts",
+        section: "Corpus health",
+        message: `${gateMissDrafts.length} proposed gate-miss lesson(s) await review: ${gateMissDrafts.slice(0, 5).map((m) => m.memory.frontmatter.id).join(", ")}.`,
+        fix: "Review with `hivelore memory list --status proposed`."
+      });
+    }
     const blockSensors = sensorMemories.filter(
       (m) => m.memory.frontmatter.sensor?.severity === "block"
     ).length;
@@ -8565,8 +8811,8 @@ function registerDoctor(program2) {
       const anchorPaths = s.paths.length > 0 ? s.paths : m.memory.frontmatter.anchor.paths;
       const targets = [];
       for (const rel of anchorPaths) {
-        const abs = path35.resolve(root, rel);
-        if (!existsSync38(abs)) continue;
+        const abs = path36.resolve(root, rel);
+        if (!existsSync39(abs)) continue;
         try {
           targets.push({ path: rel, content: await readFile16(abs, "utf8") });
         } catch {
@@ -8586,6 +8832,26 @@ function registerDoctor(program2) {
         fix: "Make the pattern discriminating (add an 'absent' companion), or demote: `hivelore sensors promote <id> --severity warn`"
       });
     }
+    const sensorHealth = assessSensorHealth2(await loadSensorLedger2(paths));
+    for (const health of sensorHealth.filter((h) => h.quarantine_pending)) {
+      const last = health.flaps.at(-1);
+      findings.push({
+        severity: "warn",
+        code: "sensor-flaky",
+        section: "Protection",
+        message: `${health.memory_id} flapped ${health.flap_count}\xD7 on identical inputs. Last contradiction: ${last.previous.at} ${last.previous.outcome} \u2192 ${last.current.at} ${last.current.outcome}.`,
+        fix: "Run `hivelore sync` to demote it, fix the oracle, then `hivelore sensors promote <id> --yes`."
+      });
+    }
+    for (const health of sensorHealth.filter((h) => h.never_fired)) {
+      findings.push({
+        severity: "info",
+        code: "sensor-never-fired",
+        section: "Protection",
+        message: `${health.memory_id} was evaluated ${health.evaluation_count} times across 30+ days and never fired \u2014 retirement candidate.`,
+        fix: "Review the sensor manually; no automatic delete/retire command is provided."
+      });
+    }
     const codeMap = await loadCodeMap6(paths);
     if (!codeMap) {
       findings.push({
@@ -8655,9 +8921,9 @@ function registerDoctor(program2) {
       }
     }
     if (config.enforcement?.requireBriefingFirst) {
-      const claudeSettings = path35.join(root, ".claude", "settings.local.json");
+      const claudeSettings = path36.join(root, ".claude", "settings.local.json");
       let hasClaudeEnforcement = false;
-      if (existsSync38(claudeSettings)) {
+      if (existsSync39(claudeSettings)) {
         try {
           const { readFile: readFile24 } = await import("fs/promises");
           const raw = await readFile24(claudeSettings, "utf8");
@@ -8683,7 +8949,7 @@ function registerDoctor(program2) {
         fix: "Edit .ai/haive.config.json: set autoSessionEnd: true (or re-run `hivelore init` without --manual)."
       });
     }
-    findings.push(...await collectInstallFindings(root, "0.33.0"));
+    findings.push(...await collectInstallFindings(root, "0.35.0"));
     findings.push(...await collectToolchainFindings(root));
     try {
       const legacyRaw = execSync("haive-mcp --version", {
@@ -8691,7 +8957,7 @@ function registerDoctor(program2) {
         timeout: 3e3,
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      const cliVersion = "0.33.0";
+      const cliVersion = "0.35.0";
       if (legacyRaw && legacyRaw !== cliVersion) {
         findings.push({
           severity: "warn",
@@ -8707,17 +8973,17 @@ npm uninstall -g @hivelore/mcp`
     }
     {
       const configPaths = [
-        path35.join(root, ".mcp.json"),
-        path35.join(root, ".cursor", "mcp.json"),
-        path35.join(root, ".vscode", "mcp.json")
+        path36.join(root, ".mcp.json"),
+        path36.join(root, ".cursor", "mcp.json"),
+        path36.join(root, ".vscode", "mcp.json")
       ];
       const staleConfigs = [];
       for (const cfgPath of configPaths) {
-        if (!existsSync38(cfgPath)) continue;
+        if (!existsSync39(cfgPath)) continue;
         try {
           const raw = await readFile16(cfgPath, "utf8");
           if (raw.includes('"haive-mcp"') || raw.includes("'haive-mcp'")) {
-            staleConfigs.push(path35.relative(root, cfgPath));
+            staleConfigs.push(path36.relative(root, cfgPath));
             if (opts.fix && !opts.dryRun) {
               const updated = raw.replace(/"command"\s*:\s*"haive-mcp"/g, '"command": "hivelore"').replace(/"args"\s*:\s*\[\]/g, '"args": ["mcp", "--stdio"]');
               await writeFile23(cfgPath, updated, "utf8");
@@ -9010,8 +9276,8 @@ which -a hivelore haive`
   const missingBins = /* @__PURE__ */ new Map();
   const staleBins = /* @__PURE__ */ new Map();
   for (const rel of integrationFiles) {
-    const file = path35.join(root, rel);
-    if (!existsSync38(file)) continue;
+    const file = path36.join(root, rel);
+    if (!existsSync39(file)) continue;
     const text = await readFile16(file, "utf8").catch(() => "");
     for (const bin of extractAbsoluteHaiveBins(text)) {
       const version = versionForBinary(bin);
@@ -9044,7 +9310,7 @@ which -a hivelore haive`
 async function collectToolchainFindings(root) {
   const findings = [];
   const pkg = await readJson(
-    path35.join(root, "package.json")
+    path36.join(root, "package.json")
   );
   const wantsPnpm = pkg?.packageManager?.startsWith("pnpm@") || Object.values(pkg?.scripts ?? {}).some((script) => /\bpnpm\b/.test(script));
   if (!wantsPnpm) return findings;
@@ -9063,10 +9329,10 @@ async function collectToolchainFindings(root) {
 }
 async function collectDistFreshnessFindings(root, expectedVersion) {
   const findings = [];
-  const isHaiveWorkspace = ["hivelore-monorepo", "haive-monorepo"].includes((await readJson(path35.join(root, "package.json")))?.name ?? "");
+  const isHaiveWorkspace = ["hivelore-monorepo", "haive-monorepo"].includes((await readJson(path36.join(root, "package.json")))?.name ?? "");
   if (!isHaiveWorkspace) return findings;
-  const cliDist = path35.join(root, "packages/cli/dist/index.js");
-  if (!existsSync38(cliDist)) {
+  const cliDist = path36.join(root, "packages/cli/dist/index.js");
+  if (!existsSync39(cliDist)) {
     findings.push({
       severity: "warn",
       code: "workspace-dist-missing",
@@ -9090,7 +9356,7 @@ async function collectDistFreshnessFindings(root, expectedVersion) {
     "packages/core/src/index.ts",
     "packages/mcp/src/server.ts",
     "packages/cli/src/index.ts"
-  ].map((rel) => path35.join(root, rel)).filter(existsSync38);
+  ].map((rel) => path36.join(root, rel)).filter(existsSync39);
   if (sourceFiles.length > 0) {
     const distMtime = statSync2(cliDist).mtimeMs;
     const newestSource = Math.max(...sourceFiles.map((file) => statSync2(file).mtimeMs));
@@ -9108,7 +9374,7 @@ async function collectDistFreshnessFindings(root, expectedVersion) {
 }
 async function collectWorkspaceVersionFindings(root, expectedVersion) {
   const findings = [];
-  const rootPkg = await readJson(path35.join(root, "package.json"));
+  const rootPkg = await readJson(path36.join(root, "package.json"));
   const workspacePackages = [
     "packages/core/package.json",
     "packages/embeddings/package.json",
@@ -9117,7 +9383,7 @@ async function collectWorkspaceVersionFindings(root, expectedVersion) {
   ];
   const existing = (await Promise.all(workspacePackages.map(async (rel) => ({
     rel,
-    pkg: await readJson(path35.join(root, rel))
+    pkg: await readJson(path36.join(root, rel))
   })))).filter((item) => item.pkg);
   const isHaiveWorkspace = rootPkg?.name === "hivelore-monorepo" || rootPkg?.name === "haive-monorepo" || existing.some((item) => item.pkg?.name?.startsWith("@hivelore/"));
   if (!isHaiveWorkspace) return findings;
@@ -9179,7 +9445,7 @@ function collectGlobalHivemoduleFindings(expectedVersion) {
   }
 }
 async function readJson(file) {
-  if (!existsSync38(file)) return null;
+  if (!existsSync39(file)) return null;
   try {
     return JSON.parse(await readFile16(file, "utf8"));
   } catch {
@@ -9408,27 +9674,29 @@ function runCommand(cmd, args, cwd) {
 }
 
 // src/commands/resolve-project.ts
-import path36 from "path";
+import path37 from "path";
 import "commander";
 import { resolveProjectInfo } from "@hivelore/core";
 function registerResolveProject(program2) {
   program2.command("resolve-project").description(
     "Print JSON for Hivelore project root resolution (HAIVE_PROJECT_ROOT, markers, .ai layout)."
   ).option("-d, --dir <dir>", "working directory", process.cwd()).action((opts) => {
-    const info = resolveProjectInfo({ cwd: path36.resolve(opts.dir) });
+    const info = resolveProjectInfo({ cwd: path37.resolve(opts.dir) });
     console.log(JSON.stringify({ ok: true, info }, null, 2));
   });
 }
 
 // src/commands/enforce.ts
-import { execFile as execFile4, execFileSync as execFileSync2, spawn as spawn4 } from "child_process";
-import { existsSync as existsSync40, statSync as statSync3 } from "fs";
+import { execFile as execFile5, execFileSync as execFileSync2, spawn as spawn4 } from "child_process";
+import { existsSync as existsSync41, statSync as statSync3 } from "fs";
 import { chmod, mkdir as mkdir16, readFile as readFile18, readdir as readdir4, rm as rm2, writeFile as writeFile25 } from "fs/promises";
-import path38 from "path";
-import { promisify as promisify4 } from "util";
+import path39 from "path";
+import { promisify as promisify5 } from "util";
 import "commander";
 import {
   antiPatternGateParams as antiPatternGateParams2,
+  appendSensorEvaluations,
+  assessSensorHealth as assessSensorHealth3,
   assessBootstrapState,
   isSensorScannablePath,
   findProjectRoot as findProjectRoot37,
@@ -9441,7 +9709,8 @@ import {
   isRetiredMemory as isRetiredMemory2,
   loadConfig as loadConfig12,
   detectAgentContext,
-  loadMemoriesFromDir as loadMemoriesFromDir15,
+  loadMemoriesFromDir as loadMemoriesFromDir14,
+  loadSensorLedger as loadSensorLedger3,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths2,
   readRecentBriefingMarker,
   recordPreventionHits,
@@ -9451,15 +9720,16 @@ import {
   saveConfig as saveConfig3,
   selectCommandSensors,
   sensorTargetsFromDiff,
+  sensorAppliesToPath as sensorAppliesToPath2,
   SESSION_RECAP_TTL_MS,
   verifyAnchor as verifyAnchor3,
   writeBriefingMarker as writeBriefingMarker2
 } from "@hivelore/core";
 
 // src/utils/claude-hooks.ts
-import { existsSync as existsSync39 } from "fs";
+import { existsSync as existsSync40 } from "fs";
 import { mkdir as mkdir15, readFile as readFile17, writeFile as writeFile24 } from "fs/promises";
-import path37 from "path";
+import path38 from "path";
 var HAIVE_HOOK_TAG = "haive-enforcement";
 var POST_TOOL_USE_GROUP = {
   matcher: "Edit|Write|Bash",
@@ -9545,7 +9815,7 @@ function unpatchClaudeSettings(input) {
 async function installClaudeHooksAtPath(settingsPath) {
   let raw = null;
   let created = false;
-  if (existsSync39(settingsPath)) {
+  if (existsSync40(settingsPath)) {
     try {
       raw = JSON.parse(await readFile17(settingsPath, "utf8"));
     } catch {
@@ -9555,12 +9825,12 @@ async function installClaudeHooksAtPath(settingsPath) {
     created = true;
   }
   const patched = patchClaudeSettings(raw);
-  await mkdir15(path37.dirname(settingsPath), { recursive: true });
+  await mkdir15(path38.dirname(settingsPath), { recursive: true });
   await writeFile24(settingsPath, JSON.stringify(patched, null, 2) + "\n", "utf8");
   return { settingsPath, created };
 }
 async function uninstallClaudeHooksAtPath(settingsPath) {
-  if (!existsSync39(settingsPath)) {
+  if (!existsSync40(settingsPath)) {
     return { settingsPath, created: false };
   }
   const raw = JSON.parse(await readFile17(settingsPath, "utf8"));
@@ -9571,9 +9841,9 @@ async function uninstallClaudeHooksAtPath(settingsPath) {
 function defaultClaudeSettingsPath(scope, projectRoot) {
   if (scope === "user") {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-    return path37.join(home, ".claude", "settings.json");
+    return path38.join(home, ".claude", "settings.json");
   }
-  return path37.join(projectRoot, ".claude", "settings.local.json");
+  return path38.join(projectRoot, ".claude", "settings.local.json");
 }
 
 // src/utils/command-sensors.ts
@@ -9653,8 +9923,52 @@ async function executeCommandSensors(specs, root) {
   return runs;
 }
 
+// src/utils/sensor-evaluations.ts
+import { execFile as execFile4 } from "child_process";
+import { promisify as promisify4 } from "util";
+import {
+  computeScopeHash,
+  sensorAppliesToPath
+} from "@hivelore/core";
+var exec3 = promisify4(execFile4);
+async function gitHeadSha(root) {
+  try {
+    const { stdout } = await exec3("git", ["rev-parse", "HEAD"], { cwd: root });
+    return stdout.trim();
+  } catch {
+    return "";
+  }
+}
+async function trackedFiles(root) {
+  try {
+    const { stdout } = await exec3("git", ["ls-files", "-co", "--exclude-standard"], { cwd: root });
+    return stdout.split("\n").map((f) => f.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+async function commandScopeHash(root, spec) {
+  if (spec.paths.length === 0) return "";
+  const sensor = { kind: spec.kind, paths: spec.paths };
+  const files = (await trackedFiles(root)).filter((file) => sensorAppliesToPath(sensor, [], file));
+  return computeScopeHash(root, files);
+}
+function evaluation(base, command) {
+  return {
+    at: base.at ?? (/* @__PURE__ */ new Date()).toISOString(),
+    memory_id: base.memory_id,
+    kind: base.kind,
+    stage: base.stage,
+    head_sha: base.head_sha,
+    scope_hash: base.scope_hash,
+    outcome: base.outcome,
+    ...command?.exit_code !== null ? { exit_code: command?.exit_code } : {},
+    ...command ? { duration_ms: command.duration_ms } : {}
+  };
+}
+
 // src/commands/enforce.ts
-var execFileAsync2 = promisify4(execFile4);
+var execFileAsync2 = promisify5(execFile5);
 var MAX_STDIN_BYTES2 = 256 * 1024;
 var ENFORCE_HOOK_MARKER = "# Hivelore enforcement hook";
 function registerEnforce(program2) {
@@ -9715,7 +10029,7 @@ function registerEnforce(program2) {
           ui.success(`Removed Hivelore hooks from ${result.settingsPath}`);
         } else {
           const result = await installClaudeHooksAtPath(settingsPath);
-          ui.success(`${result.created ? "Created" : "Patched"} Claude Code hooks (${path38.relative(root, result.settingsPath) || result.settingsPath})`);
+          ui.success(`${result.created ? "Created" : "Patched"} Claude Code hooks (${path39.relative(root, result.settingsPath) || result.settingsPath})`);
         }
       } catch (err) {
         ui.warn(`Claude Code hooks not ${opts.removeClaude ? "removed" : "installed"}: ${err instanceof Error ? err.message : String(err)}`);
@@ -9737,19 +10051,19 @@ function registerEnforce(program2) {
   enforce.command("cleanup").description("Remove generated Hivelore 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 = findProjectRoot37(opts.dir);
     const paths = resolveHaivePaths35(root);
-    const cacheDir = path38.join(paths.haiveDir, ".cache");
-    if (existsSync40(cacheDir)) {
-      if (opts.dryRun) ui.info(`would clean ${path38.relative(root, cacheDir)} (preserving .gitignore)`);
+    const cacheDir = path39.join(paths.haiveDir, ".cache");
+    if (existsSync41(cacheDir)) {
+      if (opts.dryRun) ui.info(`would clean ${path39.relative(root, cacheDir)} (preserving .gitignore)`);
       else {
         const removed = await cleanupCacheDir(cacheDir);
-        ui.success(`cleaned ${path38.relative(root, cacheDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
+        ui.success(`cleaned ${path39.relative(root, cacheDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
       }
     }
-    if (existsSync40(paths.runtimeDir)) {
-      if (opts.dryRun) ui.info(`would clean ${path38.relative(root, paths.runtimeDir)} (preserving briefing markers)`);
+    if (existsSync41(paths.runtimeDir)) {
+      if (opts.dryRun) ui.info(`would clean ${path39.relative(root, paths.runtimeDir)} (preserving briefing markers)`);
       else {
         const removed = await cleanupRuntimeDir(paths.runtimeDir);
-        ui.success(`cleaned ${path38.relative(root, paths.runtimeDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
+        ui.success(`cleaned ${path39.relative(root, paths.runtimeDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
       }
     }
   });
@@ -9793,7 +10107,7 @@ function registerEnforce(program2) {
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
     const paths = resolveHaivePaths35(root);
-    if (!existsSync40(paths.haiveDir)) return;
+    if (!existsSync41(paths.haiveDir)) return;
     await mkdir16(paths.runtimeDir, { recursive: true });
     const sessionId = opts.sessionId ?? payload.session_id;
     const task = opts.task ?? payload.prompt ?? "Start an AI coding session in this Hivelore-initialized project.";
@@ -9856,7 +10170,7 @@ ${briefing.project_context.content.slice(0, 1800)}`);
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
     const paths = resolveHaivePaths35(root);
-    if (!existsSync40(paths.haiveDir)) return;
+    if (!existsSync41(paths.haiveDir)) return;
     if (!isWriteLikeTool(payload)) return;
     const config = await loadConfig12(paths);
     if (config.enforcement?.requireBriefingFirst === false) return;
@@ -9921,7 +10235,7 @@ function emitPreToolUseContext(text) {
 async function buildFinishReport(dir) {
   const root = findProjectRoot37(dir);
   const paths = resolveHaivePaths35(root);
-  const initialized = existsSync40(paths.haiveDir);
+  const initialized = existsSync41(paths.haiveDir);
   const config = initialized ? await loadConfig12(paths) : {};
   const mode = config.enforcement?.mode ?? "strict";
   const findings = [];
@@ -10113,8 +10427,8 @@ async function buildFinishReport(dir) {
 async function checkFailureCapture(paths, config) {
   const gate = config.enforcement?.failureCaptureGate ?? "warn";
   if (gate === "off") return [];
-  const obsFile = path38.join(paths.haiveDir, ".cache", "observations.jsonl");
-  if (!existsSync40(obsFile)) return [];
+  const obsFile = path39.join(paths.haiveDir, ".cache", "observations.jsonl");
+  if (!existsSync41(obsFile)) return [];
   const failures = [];
   try {
     const raw = await readFile18(obsFile, "utf8");
@@ -10131,7 +10445,7 @@ async function checkFailureCapture(paths, config) {
     return [];
   }
   if (failures.length === 0) return [];
-  const memories = existsSync40(paths.memoriesDir) ? await loadMemoriesFromDir15(paths.memoriesDir) : [];
+  const memories = existsSync41(paths.memoriesDir) ? await loadMemoriesFromDir14(paths.memoriesDir) : [];
   const captureTimes = memories.filter(({ memory: memory2 }) => ["attempt", "gotcha"].includes(memory2.frontmatter.type)).map(({ memory: memory2 }) => memory2.frontmatter.created_at);
   const uncaptured = findUncapturedFailures(failures, captureTimes);
   if (uncaptured.length === 0) {
@@ -10166,7 +10480,7 @@ function finishReport(root, initialized, mode, findings, config) {
 async function runWithEnforcement(command, args, opts) {
   const root = findProjectRoot37(opts.dir);
   const paths = resolveHaivePaths35(root);
-  if (!existsSync40(paths.haiveDir)) {
+  if (!existsSync41(paths.haiveDir)) {
     ui.error(`No .ai/ found at ${root}. Run \`hivelore init\` first.`);
     process.exit(1);
   }
@@ -10185,7 +10499,7 @@ async function runWithEnforcement(command, args, opts) {
     process.exit(2);
   }
   ui.info(`Hivelore briefing marker created for wrapped agent session: ${sessionId}`);
-  ui.info(`Briefing written to ${path38.relative(root, briefingFile)} and exported as HAIVE_BRIEFING_FILE`);
+  ui.info(`Briefing written to ${path39.relative(root, briefingFile)} and exported as HAIVE_BRIEFING_FILE`);
   const child = spawn4(command, args, {
     cwd: root,
     stdio: "inherit",
@@ -10237,9 +10551,9 @@ async function writeWrapperBriefing(paths, sessionId, task) {
     source: "haive-run",
     memoryIds: briefing.memories.map((m) => m.id)
   });
-  const dir = path38.join(paths.runtimeDir, "enforcement", "briefings");
+  const dir = path39.join(paths.runtimeDir, "enforcement", "briefings");
   await mkdir16(dir, { recursive: true });
-  const file = path38.join(dir, `${sessionId}.md`);
+  const file = path39.join(dir, `${sessionId}.md`);
   const parts = [
     "# Hivelore Briefing",
     "",
@@ -10277,7 +10591,7 @@ async function checkBootstrapComplete(paths, config, productionCodeChanged) {
     projectContextRaw = await readFile18(paths.projectContext, "utf8");
   } catch {
   }
-  const memories = existsSync40(paths.memoriesDir) ? await loadMemoriesFromDir15(paths.memoriesDir) : [];
+  const memories = existsSync41(paths.memoriesDir) ? await loadMemoriesFromDir14(paths.memoriesDir) : [];
   const codeMap = await loadCodeMap7(paths);
   const codeFiles = codeMap ? Object.keys(codeMap.files) : [];
   let existingModules = [];
@@ -10309,7 +10623,7 @@ ${renderBootstrapChecklist(assessment)}`,
 async function buildEnforcementReport(dir, stage, sessionId) {
   const root = findProjectRoot37(dir);
   const paths = resolveHaivePaths35(root);
-  const initialized = existsSync40(paths.haiveDir);
+  const initialized = existsSync41(paths.haiveDir);
   const config = initialized ? await loadConfig12(paths) : {};
   if (initialized) {
     await applyLightweightRepairs(root, paths);
@@ -10343,7 +10657,7 @@ async function buildEnforcementReport(dir, stage, sessionId) {
       findings: [{ severity: "info", code: "enforcement-off", message: "Hivelore enforcement is disabled." }]
     });
   }
-  findings.push(...await inspectIntegrationVersions(root, "0.33.0"));
+  findings.push(...await inspectIntegrationVersions(root, "0.35.0"));
   if (config.enforcement?.requireBriefingFirst !== false && stage !== "ci") {
     const hasBriefing = await hasRecentBriefingMarker(paths, sessionId);
     findings.push(hasBriefing ? { severity: "ok", code: "briefing-loaded", message: "A recent Hivelore briefing marker exists." } : {
@@ -10423,7 +10737,7 @@ async function buildEnforcementReport(dir, stage, sessionId) {
     }];
   }
   const hasErrors = effectiveFindings.some((f) => f.severity === "error");
-  return withCategories({
+  const report = withCategories({
     root,
     initialized,
     mode,
@@ -10432,6 +10746,18 @@ async function buildEnforcementReport(dir, stage, sessionId) {
     should_block: mode === "strict" && hasErrors,
     findings: effectiveFindings
   });
+  if (!report.should_block && (stage === "pre-commit" || stage === "ci")) {
+    const headSha = await gitHeadSha(root);
+    await appendSensorEvaluations(paths, [evaluation({
+      memory_id: "__gate__",
+      kind: "shell",
+      stage,
+      head_sha: headSha,
+      scope_hash: "",
+      outcome: "silent"
+    })]);
+  }
+  return report;
 }
 function withCategories(report) {
   return {
@@ -10446,8 +10772,8 @@ function withCategories(report) {
 async function hasRecentSessionRecap(paths) {
   const handoffAge = await handoffAgeMs(paths.root);
   if (handoffAge !== null && handoffAge < SESSION_RECAP_TTL_MS) return true;
-  if (!existsSync40(paths.memoriesDir)) return false;
-  const all = await loadMemoriesFromDir15(paths.memoriesDir);
+  if (!existsSync41(paths.memoriesDir)) return false;
+  const all = await loadMemoriesFromDir14(paths.memoriesDir);
   return all.some(({ memory: memory2 }) => {
     const fm = memory2.frontmatter;
     const freshnessDate = fm.verified_at ?? fm.created_at;
@@ -10455,8 +10781,8 @@ async function hasRecentSessionRecap(paths) {
   });
 }
 async function verifyMemoryPolicy(paths, config) {
-  if (!existsSync40(paths.memoriesDir)) return [];
-  const all = await loadMemoriesFromDir15(paths.memoriesDir);
+  if (!existsSync41(paths.memoriesDir)) return [];
+  const all = await loadMemoriesFromDir14(paths.memoriesDir);
   const findings = [];
   const staleImportant = [];
   let verified = 0;
@@ -10493,12 +10819,12 @@ async function verifyMemoryPolicy(paths, config) {
   return findings;
 }
 async function verifyDecisionCoverage(paths, stage, sessionId) {
-  if (!existsSync40(paths.memoriesDir)) return [];
+  if (!existsSync41(paths.memoriesDir)) return [];
   const changedFiles = (await getChangedFiles(paths.root, stage)).filter((f) => !isGeneratedArtifact(f));
   if (changedFiles.length === 0) {
     return [{ severity: "info", code: "decision-coverage-no-changes", message: "No changed files to match against policy memories." }];
   }
-  const all = await loadMemoriesFromDir15(paths.memoriesDir);
+  const all = await loadMemoriesFromDir14(paths.memoriesDir);
   const changedSet = new Set(changedFiles);
   const policyTypes = /* @__PURE__ */ new Set(["decision", "gotcha", "architecture", "convention"]);
   const relevant = all.filter(({ memory: memory2 }) => {
@@ -10527,7 +10853,7 @@ async function verifyDecisionCoverage(paths, stage, sessionId) {
   const consulted = new Set(marker?.memory_ids ?? []);
   const missing = relevant.filter(({ memory: memory2, filePath }) => {
     if (consulted.has(memory2.frontmatter.id)) return false;
-    if (changedSet.has(path38.relative(paths.root, filePath))) return false;
+    if (changedSet.has(path39.relative(paths.root, filePath))) return false;
     return true;
   }).map(({ memory: memory2 }) => memory2);
   if (missing.length === 0) {
@@ -10587,12 +10913,12 @@ async function runPrecommitPolicy(paths, gate, stage) {
     anchored_blocks,
     semantic: true
   }, { paths });
-  const sensorFindings = await runSensorGate(paths, snapshot.diff);
+  const sensorFindings = await runSensorGate(paths, snapshot.diff, stage);
   const reviewWarnings = result.warnings.filter(
     (w) => w.level === "review" && !w.reasons.includes("sensor")
   );
   const REVIEW_SEEN_TTL_MS = 24 * 60 * 60 * 1e3;
-  const reviewSeenFile = path38.join(paths.runtimeDir, "enforcement", "review-seen.json");
+  const reviewSeenFile = path39.join(paths.runtimeDir, "enforcement", "review-seen.json");
   let reviewSeen = {};
   try {
     reviewSeen = JSON.parse(await readFile18(reviewSeenFile, "utf8"));
@@ -10619,7 +10945,7 @@ async function runPrecommitPolicy(paths, gate, stage) {
       for (const [id, at] of Object.entries(reviewSeen)) {
         if (!Number.isFinite(Date.parse(at)) || now - Date.parse(at) >= REVIEW_SEEN_TTL_MS) delete reviewSeen[id];
       }
-      await mkdir16(path38.dirname(reviewSeenFile), { recursive: true });
+      await mkdir16(path39.dirname(reviewSeenFile), { recursive: true });
       await writeFile25(reviewSeenFile, JSON.stringify(reviewSeen, null, 2), "utf8");
     } catch {
     }
@@ -10650,10 +10976,10 @@ async function runPrecommitPolicy(paths, gate, stage) {
     ...sensorFindings
   ];
 }
-async function runSensorGate(paths, diff) {
-  if (!diff || !existsSync40(paths.memoriesDir)) return [];
+async function runSensorGate(paths, diff, stage) {
+  if (!diff || !existsSync41(paths.memoriesDir)) return [];
   try {
-    const loaded = await loadMemoriesFromDir15(paths.memoriesDir);
+    const loaded = await loadMemoriesFromDir14(paths.memoriesDir);
     const scannable = loaded.map((l) => l.memory).filter((m) => Boolean(m.frontmatter.sensor) && !isRetiredMemory2(m.frontmatter, m.body));
     if (scannable.length === 0) return [];
     const targets = sensorTargetsFromDiff(diff).filter((t) => isSensorScannablePath(t.path));
@@ -10661,8 +10987,22 @@ async function runSensorGate(paths, diff) {
     const findings = [];
     const seen = /* @__PURE__ */ new Set();
     const firedIds = /* @__PURE__ */ new Set();
+    const ledgerRows = [];
+    const headSha = await gitHeadSha(paths.root);
     const regexSensorMemories = scannable.filter((m) => m.frontmatter.sensor.kind === "regex");
     const hits = regexSensorMemories.length > 0 ? runSensors(regexSensorMemories, targets) : [];
+    for (const memory2 of regexSensorMemories) {
+      const sensor = memory2.frontmatter.sensor;
+      if (!targets.some((target) => sensorAppliesToPath2(sensor, memory2.frontmatter.anchor.paths, target.path))) continue;
+      ledgerRows.push(evaluation({
+        memory_id: memory2.frontmatter.id,
+        kind: "regex",
+        stage,
+        head_sha: headSha,
+        scope_hash: "",
+        outcome: hits.some((hit) => hit.memory_id === memory2.frontmatter.id) ? "fired" : "silent"
+      }));
+    }
     for (const hit of hits) {
       if (seen.has(hit.memory_id)) continue;
       seen.add(hit.memory_id);
@@ -10674,7 +11014,8 @@ async function runSensorGate(paths, diff) {
           code: "sensor-block",
           message: `Block sensor fired \u2014 ${hit.memory_id}: ${hit.message}${where}`,
           fix: "Remove the flagged pattern, or run `hivelore sensors check` to inspect the match.",
-          impact: 45
+          impact: 45,
+          memory_ids: [hit.memory_id]
         });
       } else {
         findings.push({
@@ -10682,7 +11023,8 @@ async function runSensorGate(paths, diff) {
           code: "sensor-warn",
           message: `Sensor flagged ${hit.memory_id}: ${hit.message}${where}`,
           fix: "Review the flagged line; `hivelore sensors check` shows the matched code.",
-          impact: 5
+          impact: 5,
+          memory_ids: [hit.memory_id]
         });
       }
     }
@@ -10690,7 +11032,34 @@ async function runSensorGate(paths, diff) {
     if (config?.enforcement?.runCommandSensors === true) {
       const changedPaths = targets.map((t) => t.path).filter(Boolean);
       const specs = selectCommandSensors(scannable, changedPaths).filter((sp) => !seen.has(sp.memory_id));
-      for (const run of await executeCommandSensors(specs, paths.root)) {
+      const runs = await executeCommandSensors(specs, paths.root);
+      for (const run of runs) {
+        const spec = specs.find((candidate) => candidate.memory_id === run.memory_id);
+        ledgerRows.push(evaluation({
+          memory_id: run.memory_id,
+          kind: run.kind,
+          stage,
+          head_sha: headSha,
+          scope_hash: await commandScopeHash(paths.root, spec),
+          outcome: run.status === "failed" ? "fired" : run.status === "passed" ? "silent" : "unrunnable"
+        }, { exit_code: run.exit_code, duration_ms: run.duration_ms }));
+      }
+      const prior = await loadSensorLedger3(paths);
+      const health = new Map(assessSensorHealth3([...prior, ...ledgerRows]).map((h) => [h.memory_id, h]));
+      for (const run of runs) {
+        const sensorHealth = health.get(run.memory_id);
+        const quarantined = sensorHealth?.quarantine_pending === true;
+        if (quarantined && run.severity === "block") {
+          const last = sensorHealth.flaps.at(-1);
+          findings.push({
+            severity: "warn",
+            code: "sensor-flaky",
+            message: `Command sensor ${run.memory_id} flapped ${sensorHealth.flap_count}\xD7 on identical inputs; treated as warn pending sync quarantine. Last contradiction: ${last.previous.at} ${last.previous.outcome} \u2192 ${last.current.at} ${last.current.outcome}.`,
+            fix: "Run `hivelore sync`, fix the flaky oracle, then re-promote with `hivelore sensors promote <id> --yes`.",
+            impact: 5,
+            memory_ids: [run.memory_id]
+          });
+        }
         if (run.status === "passed") continue;
         seen.add(run.memory_id);
         if (run.status === "unrunnable") {
@@ -10707,14 +11076,15 @@ ${run.output_tail}` : ""),
         firedIds.add(run.memory_id);
         const outputBlock = run.output_tail ? `
 ${run.output_tail}` : "";
-        if (run.severity === "block") {
+        if (run.severity === "block" && !quarantined) {
           findings.push({
             severity: "error",
             code: "sensor-block",
             message: `Block ${run.kind} sensor fired \u2014 ${run.memory_id}: ${run.message}
 command: ${run.command} (exit ${run.exit_code}, ${run.duration_ms}ms)${outputBlock}`,
             fix: "Fix the behaviour the command checks, or run `hivelore sensors check --commands` to inspect it.",
-            impact: 45
+            impact: 45,
+            memory_ids: [run.memory_id]
           });
         } else {
           findings.push({
@@ -10722,13 +11092,19 @@ command: ${run.command} (exit ${run.exit_code}, ${run.duration_ms}ms)${outputBlo
             code: "sensor-warn",
             message: `${run.kind} sensor flagged ${run.memory_id}: ${run.message} (exit ${run.exit_code})${outputBlock}`,
             fix: "Review the failing command; `hivelore sensors check --commands` re-runs it.",
-            impact: 5
+            impact: 5,
+            memory_ids: [run.memory_id]
           });
         }
       }
     }
+    await appendSensorEvaluations(paths, ledgerRows);
     if (firedIds.size > 0) {
-      await recordPreventionHits(paths, [...firedIds], "sensor").catch(() => {
+      const details = Object.fromEntries([...firedIds].map((id) => {
+        const row = ledgerRows.find((entry) => entry.memory_id === id && entry.outcome === "fired");
+        return [id, { kind: row?.kind ?? "regex", stage, ...row?.exit_code !== void 0 ? { exit_code: row.exit_code } : {} }];
+      }));
+      await recordPreventionHits(paths, [...firedIds], "sensor", /* @__PURE__ */ new Date(), details).catch(() => {
       });
     }
     return findings;
@@ -10766,16 +11142,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(path38.join(runtimeDir, entry.name));
+      removed += await cleanupEnforcementDir(path39.join(runtimeDir, entry.name));
       continue;
     }
-    await rm2(path38.join(runtimeDir, entry.name), { recursive: true, force: true });
+    await rm2(path39.join(runtimeDir, entry.name), { recursive: true, force: true });
     removed++;
   }
-  await writeFile25(path38.join(runtimeDir, ".gitignore"), "*\n!.gitignore\n!README.md\n", "utf8");
-  if (!existsSync40(path38.join(runtimeDir, "README.md"))) {
+  await writeFile25(path39.join(runtimeDir, ".gitignore"), "*\n!.gitignore\n!README.md\n", "utf8");
+  if (!existsSync41(path39.join(runtimeDir, "README.md"))) {
     await writeFile25(
-      path38.join(runtimeDir, "README.md"),
+      path39.join(runtimeDir, "README.md"),
       "# .ai/.runtime \u2014 disposable local layer\n\nRuntime data is local. Hivelore cleanup preserves briefing markers so enforcement state remains valid.\n",
       "utf8"
     );
@@ -10788,10 +11164,10 @@ async function cleanupCacheDir(cacheDir) {
   const entries = await readdir4(cacheDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.name === ".gitignore") continue;
-    await rm2(path38.join(cacheDir, entry.name), { recursive: true, force: true });
+    await rm2(path39.join(cacheDir, entry.name), { recursive: true, force: true });
     removed++;
   }
-  await writeFile25(path38.join(cacheDir, ".gitignore"), "*\n!.gitignore\n", "utf8");
+  await writeFile25(path39.join(cacheDir, ".gitignore"), "*\n!.gitignore\n", "utf8");
   return removed;
 }
 async function cleanupEnforcementDir(enforcementDir) {
@@ -10799,7 +11175,7 @@ async function cleanupEnforcementDir(enforcementDir) {
   const entries = await readdir4(enforcementDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.name === "briefings") continue;
-    await rm2(path38.join(enforcementDir, entry.name), { recursive: true, force: true });
+    await rm2(path39.join(enforcementDir, entry.name), { recursive: true, force: true });
     removed++;
   }
   return removed;
@@ -10817,8 +11193,8 @@ async function inspectIntegrationVersions(root, expectedVersion) {
   const missingBins = /* @__PURE__ */ new Map();
   const staleBins = /* @__PURE__ */ new Map();
   for (const rel of files) {
-    const file = path38.join(root, rel);
-    if (!existsSync40(file)) continue;
+    const file = path39.join(root, rel);
+    if (!existsSync41(file)) continue;
     const text = await readFile18(file, "utf8").catch(() => "");
     for (const bin of extractAbsoluteHaiveBins2(text)) {
       const version = versionForBinary2(bin);
@@ -10935,7 +11311,7 @@ async function resolveCiDiffRange(root) {
 }
 async function resolveGithubEventRange(root) {
   const eventPath = process.env.GITHUB_EVENT_PATH;
-  if (!eventPath || !existsSync40(eventPath)) return null;
+  if (!eventPath || !existsSync41(eventPath)) return null;
   try {
     const event = JSON.parse(await readFile18(eventPath, "utf8"));
     const prBase = cleanGitSha(event.pull_request?.base?.sha);
@@ -11040,7 +11416,7 @@ function isShippablePath(file) {
 }
 var CI_SKIP_DIRECTIVE = /\[skip ci\]|\[ci skip\]|\[no ci\]|\[skip actions\]|\*\*\*NO_CI\*\*\*|skip-checks: *true/i;
 async function checkCommitMessageSkipCi(root, msgfile) {
-  const file = path38.isAbsolute(msgfile) ? msgfile : path38.join(root, msgfile);
+  const file = path39.isAbsolute(msgfile) ? msgfile : path39.join(root, msgfile);
   const raw = await readFile18(file, "utf8").catch(() => "");
   const cleaned = raw.split("\n").filter((line) => !line.startsWith("#")).join("\n");
   if (!CI_SKIP_DIRECTIVE.test(cleaned)) return { block: false, message: "" };
@@ -11069,7 +11445,7 @@ async function inspectReleaseVersionState(root, upstream) {
 }
 async function readPackageVersion(root, relPath) {
   try {
-    const data = JSON.parse(await readFile18(path38.join(root, relPath), "utf8"));
+    const data = JSON.parse(await readFile18(path39.join(root, relPath), "utf8"));
     return typeof data.version === "string" ? data.version : void 0;
   } catch {
     return void 0;
@@ -11257,8 +11633,8 @@ function buildScore(findings, threshold = 80) {
   };
 }
 async function installGitEnforcement(root) {
-  const hooksDir = path38.join(root, ".git", "hooks");
-  if (!existsSync40(path38.join(root, ".git"))) {
+  const hooksDir = path39.join(root, ".git", "hooks");
+  if (!existsSync41(path39.join(root, ".git"))) {
     ui.warn("No .git directory found; git enforcement hooks skipped.");
     return;
   }
@@ -11314,8 +11690,8 @@ _hivelore sync --quiet --since ORIG_HEAD || true
     }
   ];
   for (const hook of hooks) {
-    const file = path38.join(hooksDir, hook.name);
-    if (existsSync40(file)) {
+    const file = path39.join(hooksDir, hook.name);
+    if (existsSync41(file)) {
       const current = await readFile18(file, "utf8").catch(() => "");
       if (current.includes(ENFORCE_HOOK_MARKER)) {
         await writeFile25(file, hook.body, "utf8");
@@ -11332,13 +11708,29 @@ ${hook.body}`, "utf8");
   ui.success("Installed git hooks: pre-commit, pre-push, commit-msg (blocking) + post-merge, post-rewrite (sync)");
 }
 async function installCiEnforcement(root) {
-  const workflowPath = path38.join(root, ".github", "workflows", "haive-enforcement.yml");
-  await mkdir16(path38.dirname(workflowPath), { recursive: true });
-  if (existsSync40(workflowPath)) {
-    ui.info("GitHub Actions enforcement workflow already exists \u2014 skipped");
+  const workflowPath = path39.join(root, ".github", "workflows", "haive-enforcement.yml");
+  await mkdir16(path39.dirname(workflowPath), { recursive: true });
+  const workflow = renderCiEnforcementWorkflow();
+  if (existsSync41(workflowPath)) {
+    const existing = await readFile18(workflowPath, "utf8");
+    const start = "# haive:enforcement-workflow:start";
+    const end = "# haive:enforcement-workflow:end";
+    const startAt = existing.indexOf(start);
+    const endAt = existing.indexOf(end);
+    if (startAt >= 0 && endAt > startAt) {
+      await writeFile25(workflowPath, existing.slice(0, startAt) + workflow + existing.slice(endAt + end.length), "utf8");
+      ui.success(`Updated ${path39.relative(root, workflowPath)} managed block`);
+    } else {
+      ui.info("GitHub Actions enforcement workflow already exists without Hivelore markers \u2014 preserved");
+    }
     return;
   }
-  await writeFile25(workflowPath, `name: haive-enforcement
+  await writeFile25(workflowPath, workflow, "utf8");
+  ui.success(`Created ${path39.relative(root, workflowPath)}`);
+}
+function renderCiEnforcementWorkflow() {
+  return `# haive:enforcement-workflow:start
+name: haive-enforcement
 
 on:
   pull_request:
@@ -11350,6 +11742,7 @@ jobs:
     runs-on: ubuntu-latest
     permissions:
       contents: read
+      pull-requests: write
     steps:
       - uses: actions/checkout@v4
         with:
@@ -11360,12 +11753,51 @@ jobs:
       - name: Install Hivelore
         run: npm install -g @hivelore/cli
       - name: Enforce Hivelore policy
+        id: gate
         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: hivelore enforce ci
-`, "utf8");
-  ui.success(`Created ${path38.relative(root, workflowPath)}`);
+        run: |
+          set +e
+          hivelore enforce ci --json > "$RUNNER_TEMP/haive-gate.json"
+          echo "exit_code=$?" >> "$GITHUB_OUTPUT"
+          exit 0
+      - name: Upsert prevention receipt
+        if: always() && github.event_name == 'pull_request'
+        env:
+          GH_TOKEN: \${{ github.token }}
+          PR_NUMBER: \${{ github.event.pull_request.number }}
+        run: |
+          if [ -z "\${GH_TOKEN:-}" ] || ! command -v gh >/dev/null 2>&1; then exit 0; fi
+          receipt="$(hivelore stats receipt --since 7d --json 2>/dev/null)" || exit 0
+          gate="$(cat "$RUNNER_TEMP/haive-gate.json" 2>/dev/null)" || gate='{"findings":[]}'
+          body="$(jq -nr --arg marker '<!-- haive:prevention-receipt -->' --argjson receipt "$receipt" --argjson gate "$gate" '
+            $marker + "
+## Hivelore prevention receipt
+
+" +
+            (([$gate.findings[]? | select(.code == "sensor-block" or .code == "sensor-warn") |
+              "- **" + (.memory_ids[0] // "sensor") + "** \u2014 " + .message] | if length == 0 then
+              "No documented sensor fired on this PR." else "### Fired on this PR
+" + join("
+") end)) +
+            "
+
+Weekly total: **" + ($receipt.total|tostring) + "** refused; previous window: **" +
+            ($receipt.previous_total|tostring) + "**."
+          ')" || exit 0
+          comments="$(gh api "repos/$GITHUB_REPOSITORY/issues/$PR_NUMBER/comments" --paginate 2>/dev/null)" || exit 0
+          comment_id="$(printf '%s' "$comments" | jq -r '.[] | select(.body | contains("<!-- haive:prevention-receipt -->")) | .id' | head -1)"
+          if [ -n "$comment_id" ]; then
+            gh api --method PATCH "repos/$GITHUB_REPOSITORY/issues/comments/$comment_id" -f body="$body" >/dev/null 2>&1 || true
+          else
+            gh api --method POST "repos/$GITHUB_REPOSITORY/issues/$PR_NUMBER/comments" -f body="$body" >/dev/null 2>&1 || true
+          fi
+      - name: Fail when enforcement blocked
+        if: steps.gate.outputs.exit_code != '0'
+        run: exit \${{ steps.gate.outputs.exit_code }}
+# haive:enforcement-workflow:end
+`;
 }
 function printReport(report, json, explain = false) {
   if (json) {
@@ -11469,15 +11901,15 @@ function extractToolPaths(payload, root) {
 }
 function normalizeToolPath(file, root) {
   const normalized = file.replace(/\\/g, "/");
-  if (!path38.isAbsolute(normalized)) return normalized.replace(/^\.\//, "");
-  return path38.relative(root, normalized).replace(/\\/g, "/");
+  if (!path39.isAbsolute(normalized)) return normalized.replace(/^\.\//, "");
+  return path39.relative(root, normalized).replace(/\\/g, "/");
 }
 async function missingRequiredMemoriesForFiles(paths, files, sessionId) {
-  if (!existsSync40(paths.memoriesDir)) return [];
+  if (!existsSync41(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 loadMemoriesFromDir15(paths.memoriesDir);
+  const all = await loadMemoriesFromDir14(paths.memoriesDir);
   return all.filter(({ memory: memory2 }) => {
     const fm = memory2.frontmatter;
     if (!policyTypes.has(fm.type)) return false;
@@ -11518,7 +11950,7 @@ async function readStdin2(maxBytes) {
 }
 var ATOMIC_STAGE_EXCLUDE = ["/.usage/", "/.runtime/", "/.cache/"];
 async function stageResyncedArtifacts(root, paths) {
-  const aiRel = path38.relative(root, paths.haiveDir);
+  const aiRel = path39.relative(root, paths.haiveDir);
   const out = await runCommand2("git", ["diff", "--name-only", "--", aiRel], root).catch(() => "");
   const toStage = out.split("\n").map((line) => line.trim()).filter(Boolean).filter((file) => !ATOMIC_STAGE_EXCLUDE.some((excl) => `/${file}`.includes(excl)));
   if (toStage.length === 0) return;
@@ -11545,14 +11977,14 @@ function runCommand2(cmd, args, cwd) {
 }
 
 // src/commands/release.ts
-import { existsSync as existsSync41 } from "fs";
+import { existsSync as existsSync42 } from "fs";
 import { readFile as readFile19, writeFile as writeFile26 } from "fs/promises";
-import path39 from "path";
+import path40 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot38 } from "@hivelore/core";
-import { execFile as execFile5 } from "child_process";
-import { promisify as promisify5 } from "util";
-var exec3 = promisify5(execFile5);
+import { execFile as execFile6 } from "child_process";
+import { promisify as promisify6 } from "util";
+var exec4 = promisify6(execFile6);
 var VERSION_FILES2 = [
   "package.json",
   "packages/core/package.json",
@@ -11561,7 +11993,7 @@ var VERSION_FILES2 = [
   "packages/embeddings/package.json"
 ];
 async function readCurrentVersion(root) {
-  const pkg = JSON.parse(await readFile19(path39.join(root, "package.json"), "utf8"));
+  const pkg = JSON.parse(await readFile19(path40.join(root, "package.json"), "utf8"));
   if (!pkg.version) throw new Error("Root package.json has no version field.");
   return pkg.version;
 }
@@ -11582,8 +12014,8 @@ function registerRelease(program2) {
     const current = await readCurrentVersion(root);
     const next = nextVersion(current, spec);
     for (const rel of VERSION_FILES2) {
-      const file = path39.join(root, rel);
-      if (!existsSync41(file)) {
+      const file = path40.join(root, rel);
+      if (!existsSync42(file)) {
         ui.warn(`skip ${rel} (missing)`);
         continue;
       }
@@ -11596,8 +12028,8 @@ function registerRelease(program2) {
       }
       await writeFile26(file, updated, "utf8");
     }
-    const changelog = path39.join(root, "CHANGELOG.md");
-    if (existsSync41(changelog)) {
+    const changelog = path40.join(root, "CHANGELOG.md");
+    if (existsSync42(changelog)) {
       const raw = await readFile19(changelog, "utf8");
       const heading = `## [${next}]${opts.title ? ` \u2014 ${opts.title}` : ""}`;
       if (!raw.includes(`## [${next}]`)) {
@@ -11620,8 +12052,8 @@ ${heading}
     const root = findProjectRoot38(opts.dir);
     const version = await readCurrentVersion(root);
     for (const rel of VERSION_FILES2.slice(1)) {
-      const file = path39.join(root, rel);
-      if (!existsSync41(file)) continue;
+      const file = path40.join(root, rel);
+      if (!existsSync42(file)) continue;
       const v = JSON.parse(await readFile19(file, "utf8")).version;
       if (v !== version) {
         ui.error(`${rel} is at ${v}, root at ${version} \u2014 lockstep broken; run \`hivelore release bump\` first.`);
@@ -11629,24 +12061,24 @@ ${heading}
         return;
       }
     }
-    const dirty = (await exec3("git", ["status", "--porcelain"], { cwd: root })).stdout.trim();
+    const dirty = (await exec4("git", ["status", "--porcelain"], { cwd: root })).stdout.trim();
     if (dirty.length > 0) {
       ui.error("Working tree is not clean \u2014 commit the bump before tagging.");
       process.exitCode = 1;
       return;
     }
     const tag = `v${version}`;
-    const existing = (await exec3("git", ["tag", "--list", tag], { cwd: root })).stdout.trim();
+    const existing = (await exec4("git", ["tag", "--list", tag], { cwd: root })).stdout.trim();
     if (existing) {
       ui.error(`Tag ${tag} already exists \u2014 bump the version first.`);
       process.exitCode = 1;
       return;
     }
-    await exec3("git", ["tag", tag], { cwd: root });
+    await exec4("git", ["tag", tag], { cwd: root });
     ui.success(`Created ${tag} at HEAD.`);
     if (opts.push !== false) {
-      await exec3("git", ["push"], { cwd: root });
-      await exec3("git", ["push", "origin", tag], { cwd: root });
+      await exec4("git", ["push"], { cwd: root });
+      await exec4("git", ["push", "origin", tag], { cwd: root });
       ui.success(`Pushed branch and ${tag}.`);
       ui.info("Next: `hivelore enforce finish --wait` (polls CI), then publish via `pnpm run publish:all` (human step).");
     }
@@ -11666,29 +12098,34 @@ function registerRun(program2) {
 }
 
 // src/commands/sensors.ts
-import { execFile as execFile6 } from "child_process";
-import { existsSync as existsSync42 } from "fs";
+import { execFile as execFile7 } from "child_process";
+import { existsSync as existsSync43 } from "fs";
 import { chmod as chmod2, mkdir as mkdir17, readFile as readFile20, writeFile as writeFile27 } from "fs/promises";
-import path40 from "path";
-import { promisify as promisify6 } from "util";
+import path41 from "path";
+import { promisify as promisify7 } from "util";
 import "commander";
 import {
   extractSensorExamples,
+  appendSensorEvaluations as appendSensorEvaluations2,
+  assessSensorHealth as assessSensorHealth4,
   findProjectRoot as findProjectRoot39,
   isRetiredMemory as isRetiredMemory3,
   judgeProposedSensor,
   loadConfig as loadConfig13,
-  loadMemoriesFromDir as loadMemoriesFromDir16,
+  loadSensorLedger as loadSensorLedger4,
+  loadMemoriesFromDir as loadMemoriesFromDir15,
   recordPreventionHits as recordPreventionHits2,
   resolveHaivePaths as resolveHaivePaths36,
   runSensors as runSensors2,
   selectCommandSensors as selectCommandSensors2,
   sensorPatternBrittleness as sensorPatternBrittleness2,
   sensorSelfCheck as sensorSelfCheck2,
+  sensorAppliesToPath as sensorAppliesToPath3,
   scannableSensorTargets,
-  serializeMemory as serializeMemory15
+  serializeMemory as serializeMemory15,
+  withoutQuarantineNote
 } from "@hivelore/core";
-var exec4 = promisify6(execFile6);
+var exec5 = promisify7(execFile7);
 function registerSensors(program2) {
   const sensors = program2.command("sensors").description("Operate executable sensors derived from Hivelore memories");
   sensors.command("list").description("List memories carrying executable sensors").option("--json", "emit JSON", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
@@ -11724,7 +12161,7 @@ function registerSensors(program2) {
     const root = findProjectRoot39(opts.dir);
     const paths = resolveHaivePaths36(root);
     const memories = await runnableSensorMemories(paths);
-    const diff = opts.diffFile ? await readFile20(path40.resolve(root, opts.diffFile), "utf8") : await stagedDiff(root);
+    const diff = opts.diffFile ? await readFile20(path41.resolve(root, opts.diffFile), "utf8") : await stagedDiff(root);
     const targets = scannableSensorTargets(diff);
     const hits = runSensors2(memories, targets);
     const config = await loadConfig13(paths);
@@ -11735,12 +12172,44 @@ function registerSensors(program2) {
     const commandHits = [];
     const commandUnrunnable = [];
     const commandSkipped = [];
+    const ledgerRows = [];
+    const headSha = await gitHeadSha(root);
+    for (const memory2 of memories) {
+      const sensor = memory2.frontmatter.sensor;
+      if (!sensor || sensor.kind !== "regex") continue;
+      const anchors = memory2.frontmatter.anchor.paths;
+      const applicable = targets.some((target) => sensorAppliesToPath3(sensor, anchors, target.path));
+      if (!applicable) continue;
+      ledgerRows.push(evaluation({
+        memory_id: memory2.frontmatter.id,
+        kind: "regex",
+        stage: "manual",
+        head_sha: headSha,
+        scope_hash: "",
+        outcome: hits.some((hit) => hit.memory_id === memory2.frontmatter.id) ? "fired" : "silent"
+      }));
+    }
     if (commandSpecs.length > 0 && runCommands) {
-      for (const run of await executeCommandSensors(commandSpecs, root)) {
+      const runs = await executeCommandSensors(commandSpecs, root);
+      for (const run of runs) {
+        const spec = commandSpecs.find((candidate) => candidate.memory_id === run.memory_id);
+        ledgerRows.push(evaluation({
+          memory_id: run.memory_id,
+          kind: run.kind,
+          stage: "manual",
+          head_sha: headSha,
+          scope_hash: await commandScopeHash(root, spec),
+          outcome: run.status === "failed" ? "fired" : run.status === "passed" ? "silent" : "unrunnable"
+        }, { exit_code: run.exit_code, duration_ms: run.duration_ms }));
+      }
+      const prior = await loadSensorLedger4(paths);
+      const health = new Map(assessSensorHealth4([...prior, ...ledgerRows]).map((h) => [h.memory_id, h]));
+      for (const run of runs) {
+        const quarantined = health.get(run.memory_id)?.quarantine_pending === true;
         if (run.status === "failed") {
           commandHits.push({
             memory_id: run.memory_id,
-            severity: run.severity,
+            severity: quarantined ? "warn" : run.severity,
             message: run.message,
             matched_line: `command failed (exit ${run.exit_code}, ${run.duration_ms}ms): ${run.command}`,
             ...run.output_tail ? { output_tail: run.output_tail } : {}
@@ -11752,8 +12221,17 @@ function registerSensors(program2) {
     } else if (commandSpecs.length > 0) {
       for (const spec of commandSpecs) commandSkipped.push(spec.memory_id);
     }
+    await appendSensorEvaluations2(paths, ledgerRows);
     const firedIds = [...new Set([...hits, ...commandHits].map((hit) => hit.memory_id))];
-    await recordPreventionHits2(paths, firedIds, "sensor");
+    const preventionDetails = Object.fromEntries([
+      ...hits.map((hit) => [hit.memory_id, { kind: "regex", stage: "manual" }]),
+      ...commandHits.map((hit) => [hit.memory_id, {
+        kind: commandSpecs.find((spec) => spec.memory_id === hit.memory_id)?.kind ?? "shell",
+        stage: "manual",
+        exit_code: Number(/exit (\d+)/.exec(hit.matched_line)?.[1] ?? 1)
+      }])
+    ]);
+    await recordPreventionHits2(paths, firedIds, "sensor", /* @__PURE__ */ new Date(), preventionDetails);
     const output = {
       scanned: memories.length,
       hits: hits.map((hit) => ({
@@ -11812,7 +12290,7 @@ function registerSensors(program2) {
     }
     const root = findProjectRoot39(opts.dir);
     const paths = resolveHaivePaths36(root);
-    const loaded = existsSync42(paths.memoriesDir) ? await loadMemoriesFromDir16(paths.memoriesDir) : [];
+    const loaded = existsSync43(paths.memoriesDir) ? await loadMemoriesFromDir15(paths.memoriesDir) : [];
     const found = loaded.find(({ memory: memory2 }) => memory2.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory found with id ${id}`);
@@ -11860,7 +12338,7 @@ function registerSensors(program2) {
         ...found.memory.frontmatter,
         sensor: { ...sensor, severity }
       },
-      body: found.memory.body
+      body: severity === "block" ? withoutQuarantineNote(found.memory.body) : found.memory.body
     };
     await writeFile27(found.filePath, serializeMemory15(next), "utf8");
     ui.success(`Updated ${id}: sensor severity=${severity}`);
@@ -11877,7 +12355,7 @@ function registerSensors(program2) {
         return;
       }
       const root2 = findProjectRoot39(opts.dir);
-      const { proposeSensor } = await import("./server-LZKYO5O5.js");
+      const { proposeSensor } = await import("./server-2FUYM6KI.js");
       const out = await proposeSensor(
         {
           memory_id: id,
@@ -11920,7 +12398,7 @@ function registerSensors(program2) {
     }
     const root = findProjectRoot39(opts.dir);
     const paths = resolveHaivePaths36(root);
-    const loaded = existsSync42(paths.memoriesDir) ? await loadMemoriesFromDir16(paths.memoriesDir) : [];
+    const loaded = existsSync43(paths.memoriesDir) ? await loadMemoriesFromDir15(paths.memoriesDir) : [];
     const found = loaded.find(({ memory: memory2 }) => memory2.frontmatter.id === id);
     if (!found) {
       ui.error(`No memory found with id ${id}`);
@@ -11974,13 +12452,13 @@ function registerSensors(program2) {
     const root = findProjectRoot39(opts.dir);
     const paths = resolveHaivePaths36(root);
     const rows = await sensorRows(paths);
-    const outDir = path40.resolve(root, opts.outDir ?? ".ai/generated");
+    const outDir = path41.resolve(root, opts.outDir ?? ".ai/generated");
     await mkdir17(outDir, { recursive: true });
-    const outPath = path40.join(outDir, format === "grep" ? "haive-sensors-grep.sh" : "haive-sensors-eslint.json");
+    const outPath = path41.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 writeFile27(outPath, content, "utf8");
     if (format === "grep") await chmod2(outPath, 493);
-    ui.success(`Exported ${rows.length} sensor(s): ${path40.relative(root, outPath)}`);
+    ui.success(`Exported ${rows.length} sensor(s): ${path41.relative(root, outPath)}`);
   });
 }
 function deriveProposedMessage(body, pattern, absent) {
@@ -12013,8 +12491,8 @@ async function sensorRows(paths) {
   });
 }
 async function runnableSensorMemories(paths, regexOnly = true) {
-  if (!existsSync42(paths.memoriesDir)) return [];
-  const loaded = await loadMemoriesFromDir16(paths.memoriesDir);
+  if (!existsSync43(paths.memoriesDir)) return [];
+  const loaded = await loadMemoriesFromDir15(paths.memoriesDir);
   return loaded.map(({ memory: memory2 }) => memory2).filter((memory2) => {
     const sensor = memory2.frontmatter.sensor;
     if (!sensor) return false;
@@ -12024,7 +12502,7 @@ async function runnableSensorMemories(paths, regexOnly = true) {
 }
 async function stagedDiff(root) {
   try {
-    const { stdout } = await exec4("git", ["diff", "--cached"], { cwd: root });
+    const { stdout } = await exec5("git", ["diff", "--cached"], { cwd: root });
     return stdout;
   } catch (err) {
     throw new Error(`git diff --cached failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -12055,15 +12533,15 @@ function shellQuote(value) {
 }
 
 // src/commands/ingest.ts
-import { existsSync as existsSync43 } from "fs";
+import { existsSync as existsSync44 } from "fs";
 import { mkdir as mkdir18, readFile as readFile21, writeFile as writeFile28 } from "fs/promises";
-import path41 from "path";
+import path42 from "path";
 import "commander";
 import {
   draftsFromFindings,
   filterNewDrafts,
   findProjectRoot as findProjectRoot40,
-  loadMemoriesFromDir as loadMemoriesFromDir17,
+  loadMemoriesFromDir as loadMemoriesFromDir16,
   memoryFilePath as memoryFilePath7,
   parseFindings,
   resolveHaivePaths as resolveHaivePaths37,
@@ -12093,7 +12571,7 @@ function registerIngest(program2) {
     }
     const root = findProjectRoot40(opts.dir);
     const paths = resolveHaivePaths37(root);
-    if (!existsSync43(paths.haiveDir)) {
+    if (!existsSync44(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -12114,8 +12592,8 @@ function registerIngest(program2) {
         process.exitCode = 1;
         return;
       }
-      const reportPath = path41.resolve(root, file);
-      if (!existsSync43(reportPath)) {
+      const reportPath = path42.resolve(root, file);
+      if (!existsSync44(reportPath)) {
         ui.error(`Report file not found: ${reportPath}`);
         process.exitCode = 1;
         return;
@@ -12147,7 +12625,7 @@ function registerIngest(program2) {
       process.exitCode = 1;
       return;
     }
-    const existing = existsSync43(paths.memoriesDir) ? await loadMemoriesFromDir17(paths.memoriesDir) : [];
+    const existing = existsSync44(paths.memoriesDir) ? await loadMemoriesFromDir16(paths.memoriesDir) : [];
     const existingTopics = new Set(
       existing.map(({ memory: memory2 }) => memory2.frontmatter.topic).filter((t) => Boolean(t))
     );
@@ -12209,13 +12687,13 @@ function registerIngest(program2) {
       await writeDraft(paths, draft);
       created++;
     }
-    ui.success(`Created ${created} proposed memory(ies) under ${path41.relative(root, paths.memoriesDir)}/`);
+    ui.success(`Created ${created} proposed memory(ies) under ${path42.relative(root, paths.memoriesDir)}/`);
     ui.info("Review with `hivelore memory pending`; promote sensors with `hivelore sensors promote <id> --yes`.");
   });
 }
 async function writeDraft(paths, draft) {
   const file = memoryFilePath7(paths, draft.frontmatter.scope, draft.frontmatter.id, draft.frontmatter.module);
-  await mkdir18(path41.dirname(file), { recursive: true });
+  await mkdir18(path42.dirname(file), { recursive: true });
   await writeFile28(file, serializeMemory16({ frontmatter: draft.frontmatter, body: draft.body }), "utf8");
   return file;
 }
@@ -12257,14 +12735,14 @@ async function fetchSonarIssues(opts) {
 }
 
 // src/commands/dashboard.ts
-import { existsSync as existsSync44 } from "fs";
+import { existsSync as existsSync45 } from "fs";
 import "commander";
 import {
   buildDashboard,
   findProjectRoot as findProjectRoot41,
   loadConfig as loadConfig14,
-  loadMemoriesFromDir as loadMemoriesFromDir18,
-  loadPreventionEvents as loadPreventionEvents3,
+  loadMemoriesFromDir as loadMemoriesFromDir17,
+  loadPreventionEvents as loadPreventionEvents4,
   loadUsageIndex as loadUsageIndex16,
   resolveHaivePaths as resolveHaivePaths38
 } from "@hivelore/core";
@@ -12274,14 +12752,14 @@ function registerDashboard(program2) {
   ).option("--json", "emit the full report as JSON", false).option("--top <n>", "rows per top-list", "10").option("--dormant-days <n>", "dormancy window for impact scoring").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot41(opts.dir);
     const paths = resolveHaivePaths38(root);
-    if (!existsSync44(paths.haiveDir)) {
+    if (!existsSync45(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
     }
-    const memories = existsSync44(paths.memoriesDir) ? await loadMemoriesFromDir18(paths.memoriesDir) : [];
+    const memories = existsSync45(paths.memoriesDir) ? await loadMemoriesFromDir17(paths.memoriesDir) : [];
     const usage = await loadUsageIndex16(paths);
-    const preventionEvents = await loadPreventionEvents3(paths);
+    const preventionEvents = await loadPreventionEvents4(paths);
     const config = await loadConfig14(paths);
     const top = Math.max(1, Number.parseInt(opts.top ?? "10", 10) || 10);
     const dormantDays = opts.dormantDays ? Number.parseInt(opts.dormantDays, 10) : void 0;
@@ -12403,30 +12881,30 @@ function warnNum(n) {
 }
 
 // src/commands/dev-link.ts
-import { execFile as execFile7 } from "child_process";
+import { execFile as execFile8 } from "child_process";
 import { cp, readFile as readFile22 } from "fs/promises";
-import { existsSync as existsSync45 } from "fs";
-import path42 from "path";
-import { promisify as promisify7 } from "util";
+import { existsSync as existsSync46 } from "fs";
+import path43 from "path";
+import { promisify as promisify8 } from "util";
 import "commander";
 import { findProjectRoot as findProjectRoot42 } from "@hivelore/core";
-var exec5 = promisify7(execFile7);
+var exec6 = promisify8(execFile8);
 function registerDevLink(program2) {
   const dev = program2.commands.find((c) => c.name() === "dev") ?? program2.command("dev").description("Developer utilities for working on Hivelore itself.");
   dev.command("link").description("Hot-swap this repo's built dist into the global @hivelore (or legacy @hiveai) install so the global binary runs your local code.").option("-d, --dir <dir>", "repo root (default: discovered from cwd)").option("--json", "emit a machine-readable summary", false).action(async (opts) => {
     const root = findProjectRoot42(opts.dir);
-    if (!existsSync45(path42.join(root, "packages", "cli", "dist", "index.js"))) {
+    if (!existsSync46(path43.join(root, "packages", "cli", "dist", "index.js"))) {
       ui.error(`Not the Hivelore monorepo (no packages/cli/dist) at ${root}. Run \`pnpm -r build\` first, or pass --dir.`);
       process.exitCode = 1;
       return;
     }
     let globalModules;
     try {
-      globalModules = (await exec5("npm", ["root", "-g"])).stdout.trim();
+      globalModules = (await exec6("npm", ["root", "-g"])).stdout.trim();
     } catch {
-      globalModules = path42.join(path42.dirname(path42.dirname(process.execPath)), "lib", "node_modules");
+      globalModules = path43.join(path43.dirname(path43.dirname(process.execPath)), "lib", "node_modules");
     }
-    const scopeDirs = ["@hivelore", "@hiveai"].map((scope) => path42.join(globalModules, scope)).filter((dir) => existsSync45(dir));
+    const scopeDirs = ["@hivelore", "@hiveai"].map((scope) => path43.join(globalModules, scope)).filter((dir) => existsSync46(dir));
     if (scopeDirs.length === 0) {
       ui.error(`No global @hivelore (or legacy @hiveai) install under ${globalModules}. Install once with \`npm i -g @hivelore/cli\`, then re-run.`);
       process.exitCode = 1;
@@ -12434,24 +12912,24 @@ function registerDevLink(program2) {
     }
     const linked = [];
     const copyDist = async (fromPkg, toDistDir) => {
-      const from = path42.join(root, "packages", fromPkg, "dist");
-      if (!existsSync45(from) || !existsSync45(path42.dirname(toDistDir))) return;
+      const from = path43.join(root, "packages", fromPkg, "dist");
+      if (!existsSync46(from) || !existsSync46(path43.dirname(toDistDir))) return;
       await cp(from, toDistDir, { recursive: true });
-      linked.push(path42.relative(globalModules, toDistDir));
+      linked.push(path43.relative(globalModules, toDistDir));
     };
     for (const globalHive of scopeDirs) {
-      const nestedScope = path42.basename(globalHive);
+      const nestedScope = path43.basename(globalHive);
       for (const pkg of ["cli", "mcp"]) {
-        await copyDist(pkg, path42.join(globalHive, pkg, "dist"));
+        await copyDist(pkg, path43.join(globalHive, pkg, "dist"));
         for (const nested of ["core", "embeddings"]) {
-          await copyDist(nested, path42.join(globalHive, pkg, "node_modules", nestedScope, nested, "dist"));
+          await copyDist(nested, path43.join(globalHive, pkg, "node_modules", nestedScope, nested, "dist"));
         }
       }
-      await copyDist("core", path42.join(globalHive, "core", "dist"));
+      await copyDist("core", path43.join(globalHive, "core", "dist"));
     }
     let version = "unknown";
     try {
-      version = JSON.parse(await readFile22(path42.join(root, "package.json"), "utf8")).version ?? "unknown";
+      version = JSON.parse(await readFile22(path43.join(root, "package.json"), "utf8")).version ?? "unknown";
     } catch {
     }
     if (opts.json) {
@@ -12462,7 +12940,7 @@ function registerDevLink(program2) {
       ui.warn("Nothing linked \u2014 no matching dist targets were found in the global install.");
       return;
     }
-    ui.success(`Linked local dist (v${version}) into the global install(s): ${scopeDirs.map((d) => path42.basename(d)).join(", ")}`);
+    ui.success(`Linked local dist (v${version}) into the global install(s): ${scopeDirs.map((d) => path43.basename(d)).join(", ")}`);
     for (const t of linked) console.log(`  ${ui.dim("\u2192")} ${t}`);
     console.log(ui.dim("The global binary now runs your local build (git hooks + MCP included)."));
   });
@@ -12470,8 +12948,8 @@ function registerDevLink(program2) {
 
 // src/commands/coverage.ts
 import { readFile as readFile23 } from "fs/promises";
-import { existsSync as existsSync46 } from "fs";
-import path43 from "path";
+import { existsSync as existsSync47 } from "fs";
+import path44 from "path";
 import "commander";
 import {
   findCoverageGaps,
@@ -12481,7 +12959,7 @@ import {
   tallyHotFiles
 } from "@hivelore/core";
 async function readAgentHotFiles(root, cacheFile, sinceMs) {
-  if (!existsSync46(cacheFile)) return [];
+  if (!existsSync47(cacheFile)) return [];
   const raw = await readFile23(cacheFile, "utf8").catch(() => "");
   const files = [];
   for (const line of raw.split("\n")) {
@@ -12495,7 +12973,7 @@ async function readAgentHotFiles(root, cacheFile, sinceMs) {
       }
       for (const f of obs.files ?? []) {
         if (typeof f !== "string" || !f) continue;
-        const rel = path43.isAbsolute(f) ? path43.relative(root, f) : f;
+        const rel = path44.isAbsolute(f) ? path44.relative(root, f) : f;
         if (rel.startsWith("..")) continue;
         files.push(rel);
       }
@@ -12539,7 +13017,7 @@ function registerCoverage(program2) {
     }) : null;
     const gitHotFiles = (radar?.hotFiles ?? []).filter((h) => !isNoisePath(h.path)).map((h) => ({ path: h.path, changes: h.changes, source: "git" }));
     const sinceMs = Date.now() - days * 864e5;
-    const agentHotFiles = useAgent ? (await readAgentHotFiles(root, path43.join(paths.haiveDir, ".cache", "observations.jsonl"), sinceMs)).filter((h) => !isNoisePath(h.path)) : [];
+    const agentHotFiles = useAgent ? (await readAgentHotFiles(root, path44.join(paths.haiveDir, ".cache", "observations.jsonl"), sinceMs)).filter((h) => !isNoisePath(h.path)) : [];
     const hotFiles = mergeHotFiles(gitHotFiles, agentHotFiles);
     const memories = await loadMemoriesFromDir(paths.memoriesDir);
     const gaps = findCoverageGaps(hotFiles, memories, { minChanges, limit });
@@ -12577,8 +13055,8 @@ function registerCoverage(program2) {
 
 // src/commands/merge-driver.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { readFileSync, writeFileSync, existsSync as existsSync47 } from "fs";
-import path44 from "path";
+import { readFileSync, writeFileSync, existsSync as existsSync48 } from "fs";
+import path45 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot44, mergeMemoryVersions } from "@hivelore/core";
 var GITATTRIBUTES_MARK = "# Hivelore merge driver";
@@ -12610,8 +13088,8 @@ function registerMergeDriver(program2) {
       process.exitCode = 1;
       return;
     }
-    const gaPath = path44.join(root, ".gitattributes");
-    let content = existsSync47(gaPath) ? readFileSync(gaPath, "utf8") : "";
+    const gaPath = path45.join(root, ".gitattributes");
+    let content = existsSync48(gaPath) ? readFileSync(gaPath, "utf8") : "";
     if (!content.includes(GITATTRIBUTES_MARK)) {
       if (content.length > 0 && !content.endsWith("\n")) content += "\n";
       content += GITATTRIBUTES_BLOCK + "\n";
@@ -12625,21 +13103,21 @@ function registerMergeDriver(program2) {
 }
 
 // src/commands/bridges.ts
-import { existsSync as existsSync48 } from "fs";
-import path45 from "path";
+import { existsSync as existsSync49 } from "fs";
+import path46 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot45,
   resolveHaivePaths as resolveHaivePaths40,
-  BRIDGE_TARGET_PATH as BRIDGE_TARGET_PATH2,
-  BRIDGE_TARGETS as BRIDGE_TARGETS3
+  BRIDGE_TARGET_PATH as BRIDGE_TARGET_PATH3,
+  BRIDGE_TARGETS as BRIDGE_TARGETS4
 } from "@hivelore/core";
 function registerBridges(program2) {
   const bridges = program2.command("bridges").description(
     "Generate native agent bridge files from the Hivelore corpus.\n  Bridges inject top validated memories and block sensors into agent-harness-specific\n  config files (.cursor/rules/haive-memories.mdc, .clinerules, .windsurfrules,\n  .continuerules, .sourcegraph/cody-rules.md, .rules, AGENTS.md,\n  .github/copilot-instructions.md).\n  This is the reach differentiator vs memories.sh: our bridges carry enforcement, not just injection.\n\n  Example:\n    hivelore bridges sync --all\n    hivelore bridges sync --only cline,windsurf\n"
   );
   bridges.command("sync").description(
-    "Regenerate bridge files idempotently (marker-based, preserves manual content outside markers).\n  Supported targets: " + BRIDGE_TARGETS3.join(", ") + "\n"
+    "Regenerate bridge files idempotently (marker-based, preserves manual content outside markers).\n  Supported targets: " + BRIDGE_TARGETS4.join(", ") + "\n"
   ).option("--all", "generate all supported bridge targets").option(
     "--only <targets>",
     "comma-separated list of targets to generate (e.g. cline,windsurf,agents)"
@@ -12647,7 +13125,7 @@ function registerBridges(program2) {
     const root = findProjectRoot45(opts.dir);
     const paths = resolveHaivePaths40(root);
     const dryRun = opts.dryRun === true;
-    if (!existsSync48(paths.memoriesDir)) {
+    if (!existsSync49(paths.memoriesDir)) {
       ui.warn(`No .ai/memories at ${root}. Run \`hivelore init\` first.`);
       process.exitCode = 1;
       return;
@@ -12655,18 +13133,18 @@ function registerBridges(program2) {
     let targets;
     if (opts.only) {
       const requested = opts.only.split(",").map((t) => t.trim().toLowerCase()).filter(Boolean);
-      const invalid = requested.filter((t) => !BRIDGE_TARGETS3.includes(t));
+      const invalid = requested.filter((t) => !BRIDGE_TARGETS4.includes(t));
       if (invalid.length > 0) {
-        ui.error(`Unknown bridge target(s): ${invalid.join(", ")}. Valid: ${BRIDGE_TARGETS3.join(", ")}`);
+        ui.error(`Unknown bridge target(s): ${invalid.join(", ")}. Valid: ${BRIDGE_TARGETS4.join(", ")}`);
         process.exitCode = 1;
         return;
       }
       targets = requested;
     } else if (opts.all) {
-      targets = BRIDGE_TARGETS3;
+      targets = BRIDGE_TARGETS4;
     } else {
-      targets = BRIDGE_TARGETS3.filter(
-        (t) => existsSync48(path45.join(root, BRIDGE_TARGET_PATH2[t]))
+      targets = BRIDGE_TARGETS4.filter(
+        (t) => existsSync49(path46.join(root, BRIDGE_TARGET_PATH3[t]))
       );
       if (targets.length === 0) {
         ui.info(
@@ -12698,7 +13176,7 @@ function registerBridges(program2) {
     const root = findProjectRoot45(opts.dir);
     const paths = resolveHaivePaths40(root);
     const statuses = await getBridgeFileStatuses(root, paths, {
-      targets: BRIDGE_TARGETS3,
+      targets: BRIDGE_TARGETS4,
       maxMemories: Math.max(1, Number(opts.maxMemories ?? 8))
     });
     console.log(ui.bold("Hivelore bridge targets:"));
@@ -12714,7 +13192,7 @@ function registerBridges(program2) {
 
 // src/index.ts
 var program = new Command48();
-program.name("hivelore").description("Hivelore - repo-native memory and context policy for coding-agent harnesses").version("0.33.0").option("--advanced", "show maintenance and experimental commands in help").showSuggestionAfterError(true);
+program.name("hivelore").description("Hivelore - repo-native memory and context policy for coding-agent harnesses").version("0.35.0").option("--advanced", "show maintenance and experimental commands in help").showSuggestionAfterError(true);
 registerInit(program);
 registerResolveProject(program);
 registerEnforce(program);