@hiveai/cli 0.21.0 → 0.24.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command as Command64 } from "commander";
 // src/commands/briefing.ts
 import { existsSync as existsSync3 } from "fs";
 import { mkdir, readFile as readFile2 } from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 import "commander";
 import {
   classifyMemoryPriority,
@@ -67,6 +67,7 @@ var ui = {
 
 // src/utils/briefing-radar.ts
 import { execFile } from "child_process";
+import path from "path";
 import { promisify } from "util";
 var exec = promisify(execFile);
 var DEFAULT_DAYS_BACK = 14;
@@ -94,8 +95,11 @@ var SOURCE_GLOBS = [
 ];
 async function isGitRepo(root) {
   try {
-    await exec("git", ["rev-parse", "--is-inside-work-tree"], { cwd: root });
-    return true;
+    const { stdout } = await exec("git", ["rev-parse", "--show-toplevel"], { cwd: root });
+    const toplevel = path.resolve(stdout.trim());
+    const resolvedRoot = path.resolve(root);
+    if (toplevel === resolvedRoot) return true;
+    return toplevel.startsWith(resolvedRoot + path.sep);
   } catch {
     return false;
   }
@@ -208,7 +212,7 @@ async function getHotFiles(root, daysBack, maxHotFiles, filePaths) {
       if (!f) continue;
       counts.set(f, (counts.get(f) ?? 0) + 1);
     }
-    let entries = [...counts.entries()].map(([path60, changes]) => ({ path: path60, changes }));
+    let entries = [...counts.entries()].map(([path63, changes]) => ({ path: path63, changes }));
     const lowerPaths = filePaths.map((p) => p.toLowerCase());
     if (lowerPaths.length > 0) {
       entries = entries.filter((e) => lowerPaths.some((p) => e.path.toLowerCase().includes(p)));
@@ -238,7 +242,7 @@ function radarHasContent(r) {
 // src/utils/autopilot.ts
 import { existsSync as existsSync2 } from "fs";
 import { readFile, writeFile as writeFile2 } from "fs/promises";
-import path2 from "path";
+import path3 from "path";
 import {
   AUTOPILOT_DEFAULTS,
   buildCodeMap,
@@ -253,7 +257,7 @@ import {
 import { existsSync } from "fs";
 import { writeFile } from "fs/promises";
 import { spawnSync } from "child_process";
-import path from "path";
+import path2 from "path";
 import "commander";
 import {
   findProjectRoot,
@@ -441,7 +445,7 @@ function suggestAnchors(root, loaded, codeMap, trackedFiles) {
   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(path.join(root, candidate)) && isSafeAnchorPath(candidate, trackedFiles)) {
+    if (existsSync(path2.join(root, candidate)) && isSafeAnchorPath(candidate, trackedFiles)) {
       paths.add(candidate);
     }
   }
@@ -704,7 +708,7 @@ async function projectContextVersionStatus(root, paths) {
   if (!existsSync2(paths.projectContext)) {
     return { mismatch: false, canSync: false };
   }
-  const packagePath = path2.join(root, "package.json");
+  const packagePath = path3.join(root, "package.json");
   if (!existsSync2(packagePath)) {
     return { mismatch: false, canSync: false };
   }
@@ -940,7 +944,7 @@ function registerBriefing(program2) {
             continue;
           }
           const otherMemories = await loadMemoriesFromDir3(otherPaths.memoriesDir);
-          const tag = path3.basename(otherRoot);
+          const tag = path4.basename(otherRoot);
           for (const m of otherMemories) {
             ownMemories.push({ ...m, origin: tag });
           }
@@ -1066,7 +1070,7 @@ function registerBriefing(program2) {
           status: item.memory.frontmatter.status,
           priority: priorities[i],
           score: item.score,
-          file: path3.relative(root, item.filePath),
+          file: path4.relative(root, item.filePath),
           summary: (item.memory.body.split("\n").map((l) => l.replace(/^#+\s*/, "").trim()).find((l) => l.length > 0) ?? "").slice(0, 140)
         }))
       }, null, 2));
@@ -1088,7 +1092,7 @@ function registerBriefing(program2) {
         `${ui.bold(fm.id)}  ${priorityBadge(priority)}  ${ui.dim(fm.scope + "/" + fm.type)}  ${badge}${draftMarker}${unverifiedMarker}${originMarker}${hitMarker}`
       );
       if (opts.explainSource) {
-        const relPath = path3.relative(root, item.filePath);
+        const relPath = path4.relative(root, item.filePath);
         const anchorPaths = fm.anchor?.paths ?? [];
         const anchorSymbols = fm.anchor?.symbols ?? [];
         const parts = [`source: ${relPath}`];
@@ -1212,7 +1216,7 @@ function registerTui(program2) {
 
 // src/commands/embeddings.ts
 import { existsSync as existsSync4 } from "fs";
-import path4 from "path";
+import path5 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot4, resolveHaivePaths as resolveHaivePaths3 } from "@hiveai/core";
 function registerEmbeddings(program2) {
@@ -1254,7 +1258,7 @@ function registerEmbeddings(program2) {
     for (const hit of result.hits) {
       const score = hit.score.toFixed(3);
       console.log(`${ui.bold(score)}  ${hit.id}`);
-      console.log(`       ${ui.dim(path4.relative(root, hit.file_path))}`);
+      console.log(`       ${ui.dim(path5.relative(root, hit.file_path))}`);
     }
   });
   embeddings.command("status").description("Show the embeddings index status").option("-d, --dir <dir>", "project root").action(async (opts) => {
@@ -1285,7 +1289,7 @@ async function loadEmbeddings() {
 
 // src/commands/index-code.ts
 import { existsSync as existsSync5, statSync } from "fs";
-import path5 from "path";
+import path6 from "path";
 import "commander";
 import {
   buildCodeMap as buildCodeMap2,
@@ -1334,7 +1338,7 @@ function registerIndexCode(program2) {
     const fileCount = Object.keys(map.files).length;
     const exportCount = Object.values(map.files).reduce((s, f) => s + f.exports.length, 0);
     ui.success(
-      `Indexed ${fileCount} file(s) with ${exportCount} export(s) \u2192 ${path5.relative(root, codeMapPath(paths))}`
+      `Indexed ${fileCount} file(s) with ${exportCount} export(s) \u2192 ${path6.relative(root, codeMapPath(paths))}`
     );
   });
   idx.command("code-search").description(
@@ -1371,12 +1375,12 @@ async function reportIndexStatus(root, paths, asJson) {
   const fileCount = map ? Object.keys(map.files).length : 0;
   const exportCount = map ? Object.values(map.files).reduce((s, f) => s + f.exports.length, 0) : 0;
   const mapMtime = existsSync5(mapFile) ? statSync(mapFile).mtime.toISOString() : null;
-  const searchIndexFile = path5.join(paths.haiveDir, ".cache", "embeddings", "code-embeddings-index.json");
+  const searchIndexFile = path6.join(paths.haiveDir, ".cache", "embeddings", "code-embeddings-index.json");
   const searchIndexPresent = existsSync5(searchIndexFile);
   const status = {
     code_map: {
       present: map !== null,
-      path: path5.relative(root, mapFile),
+      path: path6.relative(root, mapFile),
       files: fileCount,
       exports: exportCount,
       generated_at: map?.generated_at ?? null,
@@ -1384,7 +1388,7 @@ async function reportIndexStatus(root, paths, asJson) {
     },
     code_search_index: {
       present: searchIndexPresent,
-      path: path5.relative(root, searchIndexFile)
+      path: path6.relative(root, searchIndexFile)
     }
   };
   if (asJson) {
@@ -1409,7 +1413,7 @@ async function reportIndexStatus(root, paths, asJson) {
 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 path11 from "path";
+import path12 from "path";
 import { spawnSync as spawnSync3 } from "child_process";
 import { promisify as promisify2 } from "util";
 import "commander";
@@ -1430,7 +1434,7 @@ import {
 // 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 path6 from "path";
+import path7 from "path";
 import {
   BRIDGE_MARKERS,
   generateBridges,
@@ -1457,14 +1461,14 @@ 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 = path6.join(root, output.path);
+    const targetFile = path7.join(root, output.path);
     const fileExists = existsSync6(targetFile);
     if (opts.onlyExisting && !fileExists) continue;
     if (opts.dryRun) {
       (fileExists ? result.updated : result.created).push(output.path);
       continue;
     }
-    await mkdir2(path6.dirname(targetFile), { recursive: true });
+    await mkdir2(path7.dirname(targetFile), { recursive: true });
     if (!fileExists) {
       await writeFile3(targetFile, output.content, "utf8");
       result.created.push(output.path);
@@ -1513,7 +1517,7 @@ import { spawnSync as spawnSync2 } from "child_process";
 import { existsSync as existsSync8 } from "fs";
 import { mkdir as mkdir4, writeFile as writeFile5 } from "fs/promises";
 import os2 from "os";
-import path8 from "path";
+import path9 from "path";
 import { createInterface } from "readline/promises";
 import "commander";
 import { findProjectRoot as findProjectRoot6, resolveHaivePaths as resolveHaivePaths5 } from "@hiveai/core";
@@ -1521,7 +1525,7 @@ import { findProjectRoot as findProjectRoot6, resolveHaivePaths as resolveHaiveP
 // 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 path7 from "path";
+import path8 from "path";
 import os from "os";
 var HOME = os.homedir();
 var HAIVE_MCP_ENTRY = {
@@ -1536,11 +1540,11 @@ function projectMcpEntry(root) {
   };
 }
 function cursorMcpPath() {
-  return path7.join(HOME, ".cursor", "mcp.json");
+  return path8.join(HOME, ".cursor", "mcp.json");
 }
 async function configureCursor() {
   const mcpPath = cursorMcpPath();
-  const cursorDir = path7.join(HOME, ".cursor");
+  const cursorDir = path8.join(HOME, ".cursor");
   if (!existsSync7(cursorDir)) return { client: "Cursor", status: "not_installed" };
   let config = {};
   if (existsSync7(mcpPath)) {
@@ -1558,16 +1562,16 @@ async function configureCursor() {
 }
 function vscodeMcpPath() {
   const candidates = [
-    path7.join(HOME, ".config", "Code", "User", "mcp.json"),
+    path8.join(HOME, ".config", "Code", "User", "mcp.json"),
     // Linux
-    path7.join(HOME, "Library", "Application Support", "Code", "User", "mcp.json"),
+    path8.join(HOME, "Library", "Application Support", "Code", "User", "mcp.json"),
     // macOS
-    path7.join(HOME, "AppData", "Roaming", "Code", "User", "mcp.json"),
+    path8.join(HOME, "AppData", "Roaming", "Code", "User", "mcp.json"),
     // Windows
-    path7.join(HOME, ".config", "Code - Insiders", "User", "mcp.json")
+    path8.join(HOME, ".config", "Code - Insiders", "User", "mcp.json")
   ];
   for (const c of candidates) {
-    if (existsSync7(path7.dirname(c))) return c;
+    if (existsSync7(path8.dirname(c))) return c;
   }
   return null;
 }
@@ -1584,20 +1588,20 @@ async function configureVSCode() {
   config.servers ??= {};
   if (config.servers["haive"]) return { client: "VS Code", status: "already_configured" };
   config.servers["haive"] = { ...HAIVE_MCP_ENTRY, type: "stdio" };
-  await mkdir3(path7.dirname(mcpPath), { recursive: true });
+  await mkdir3(path8.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 = path7.join(HOME, ".claude.json");
+  const p = path8.join(HOME, ".claude.json");
   if (existsSync7(p)) return p;
-  const p2 = path7.join(HOME, ".config", "claude", "claude.json");
-  if (existsSync7(path7.dirname(p2))) return p2;
+  const p2 = path8.join(HOME, ".config", "claude", "claude.json");
+  if (existsSync7(path8.dirname(p2))) return p2;
   return null;
 }
 async function configureClaude() {
-  const cfgPath = claudeConfigPath() ?? path7.join(HOME, ".claude.json");
-  if (!existsSync7(cfgPath) && !existsSync7(path7.join(HOME, ".claude"))) {
+  const cfgPath = claudeConfigPath() ?? path8.join(HOME, ".claude.json");
+  if (!existsSync7(cfgPath) && !existsSync7(path8.join(HOME, ".claude"))) {
     return { client: "Claude Code", status: "not_installed" };
   }
   let config = {};
@@ -1615,11 +1619,11 @@ async function configureClaude() {
 }
 function windsurfMcpPath() {
   const candidates = [
-    path7.join(HOME, ".codeium", "windsurf", "mcp_config.json"),
-    path7.join(HOME, ".windsurf", "mcp.json")
+    path8.join(HOME, ".codeium", "windsurf", "mcp_config.json"),
+    path8.join(HOME, ".windsurf", "mcp.json")
   ];
   for (const c of candidates) {
-    if (existsSync7(path7.dirname(c))) return c;
+    if (existsSync7(path8.dirname(c))) return c;
   }
   return null;
 }
@@ -1636,7 +1640,7 @@ async function configureWindsurf() {
   config.mcpServers ??= {};
   if (config.mcpServers["haive"]) return { client: "Windsurf", status: "already_configured" };
   config.mcpServers["haive"] = HAIVE_MCP_ENTRY;
-  await mkdir3(path7.dirname(mcpPath), { recursive: true });
+  await mkdir3(path8.dirname(mcpPath), { recursive: true });
   await writeFile4(mcpPath, JSON.stringify(config, null, 2), "utf8");
   return { client: "Windsurf", status: "configured", path: mcpPath };
 }
@@ -1657,7 +1661,7 @@ async function configureProjectMcpClients(root) {
   const entry = projectMcpEntry(root);
   const results = [];
   try {
-    const cursorPath = path7.join(root, ".cursor", "mcp.json");
+    const cursorPath = path8.join(root, ".cursor", "mcp.json");
     let config = {};
     if (existsSync7(cursorPath)) {
       try {
@@ -1667,14 +1671,14 @@ async function configureProjectMcpClients(root) {
     }
     config.mcpServers ??= {};
     config.mcpServers["haive"] = entry;
-    await mkdir3(path7.dirname(cursorPath), { recursive: true });
+    await mkdir3(path8.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 = path7.join(root, ".vscode", "mcp.json");
+    const vscodePath = path8.join(root, ".vscode", "mcp.json");
     let config = {};
     if (existsSync7(vscodePath)) {
       try {
@@ -1684,14 +1688,14 @@ async function configureProjectMcpClients(root) {
     }
     config.servers ??= {};
     config.servers["haive"] = { ...entry, type: "stdio" };
-    await mkdir3(path7.dirname(vscodePath), { recursive: true });
+    await mkdir3(path8.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 = path7.join(root, ".mcp.json");
+    const mcpPath = path8.join(root, ".mcp.json");
     let config = {};
     if (existsSync7(mcpPath)) {
       try {
@@ -1767,9 +1771,9 @@ async function detectAgentMode(dir) {
   const root = findProjectRoot6(dir);
   const paths = resolveHaivePaths5(root);
   const projectMcp = [
-    { client: "Claude Code", path: path8.join(root, ".mcp.json"), present: existsSync8(path8.join(root, ".mcp.json")) },
-    { client: "Cursor", path: path8.join(root, ".cursor", "mcp.json"), present: existsSync8(path8.join(root, ".cursor", "mcp.json")) },
-    { client: "VS Code", path: path8.join(root, ".vscode", "mcp.json"), present: existsSync8(path8.join(root, ".vscode", "mcp.json")) }
+    { 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")) }
   ];
   const installedAgents = [
     { agent: "Codex", command: "codex", installed: commandExists("codex"), mcp_configured: codexMcpConfigured() },
@@ -1792,9 +1796,9 @@ async function detectAgentMode(dir) {
   };
 }
 async function writeAgentModeRecord(paths, detection, skippedReason) {
-  const dir = path8.join(paths.runtimeDir, "enforcement");
+  const dir = path9.join(paths.runtimeDir, "enforcement");
   await mkdir4(dir, { recursive: true });
-  const file = path8.join(dir, "agent-mode.json");
+  const file = path9.join(dir, "agent-mode.json");
   const record = {
     selected_mode: detection.recommended_mode,
     recommended_command: detection.recommended_command,
@@ -1835,7 +1839,7 @@ async function configureCodexIfAvailable(root) {
     "mcp",
     "--stdio"
   ], { encoding: "utf8" });
-  if (result.status === 0) return { client: "Codex", status: "configured", path: path8.join(os2.homedir(), ".codex", "config.toml") };
+  if (result.status === 0) return { client: "Codex", status: "configured", path: path9.join(os2.homedir(), ".codex", "config.toml") };
   return { client: "Codex", status: "error", error: result.stderr || result.stdout || "codex mcp add failed" };
 }
 function commandExists(command) {
@@ -1862,7 +1866,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(path8.relative(detection.root, cfg.path))}`);
+    console.log(`${cfg.present ? ui.green("\u2713") : ui.yellow("\u2022")} ${cfg.client} project MCP ${ui.dim(path9.relative(detection.root, cfg.path))}`);
   }
   for (const agent of detection.installed_agents) {
     const marker = agent.installed ? ui.green("\u2713") : ui.dim("\u2022");
@@ -1892,7 +1896,7 @@ function printSetupResult(result) {
 // src/commands/init-bootstrap.ts
 import { readdir, readFile as readFile5 } from "fs/promises";
 import { existsSync as existsSync9, readdirSync } from "fs";
-import path9 from "path";
+import path10 from "path";
 var IGNORE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -1978,12 +1982,12 @@ function detectKeyDeps(allDeps) {
   return KEY_DEPS.filter((d) => allDeps[d] !== void 0);
 }
 function detectLanguage(root) {
-  if (existsSync9(path9.join(root, "tsconfig.json"))) return "TypeScript";
-  if (existsSync9(path9.join(root, "pyproject.toml")) || existsSync9(path9.join(root, "setup.py"))) return "Python";
-  if (existsSync9(path9.join(root, "go.mod"))) return "Go";
-  if (existsSync9(path9.join(root, "pom.xml")) || existsSync9(path9.join(root, "build.gradle"))) return "Java/Kotlin";
-  if (existsSync9(path9.join(root, "Cargo.toml"))) return "Rust";
-  if (existsSync9(path9.join(root, "package.json"))) {
+  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"))) {
     return hasSourceWithExt(root, [".ts", ".tsx", ".mts", ".cts"]) ? "TypeScript" : "JavaScript";
   }
   return "Unknown";
@@ -2003,7 +2007,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(path9.join(dir, entry.name), depth - 1)) return true;
+        if (scanDir(path10.join(dir, entry.name), depth - 1)) return true;
       }
     }
     return false;
@@ -2040,9 +2044,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 = path9.relative(root, path9.join(dir, entry.name));
+      const rel = path10.relative(root, path10.join(dir, entry.name));
       results.push(rel);
-      await walk(path9.join(dir, entry.name), depth + 1);
+      await walk(path10.join(dir, entry.name), depth + 1);
     }
   }
   await walk(root, 0);
@@ -2159,7 +2163,7 @@ function readmeExcerpt(readme) {
 }
 async function generateBootstrapContext(root) {
   let pkg = {};
-  const pkgPath = path9.join(root, "package.json");
+  const pkgPath = path10.join(root, "package.json");
   if (existsSync9(pkgPath)) {
     try {
       pkg = JSON.parse(await readFile5(pkgPath, "utf8"));
@@ -2172,11 +2176,11 @@ 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 ?? path9.basename(root);
+  const projectName = pkg.name ?? path10.basename(root);
   const projectDesc = pkg.description ?? "";
   let readmeSummary = "";
   for (const name of ["README.md", "readme.md", "README"]) {
-    const p = path9.join(root, name);
+    const p = path10.join(root, name);
     if (existsSync9(p)) {
       try {
         const content = await readFile5(p, "utf8");
@@ -2245,7 +2249,7 @@ 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 path10 from "path";
+import path11 from "path";
 import {
   buildFrontmatter,
   loadMemoriesFromDir as loadMemoriesFromDir5,
@@ -3374,7 +3378,7 @@ ${mem.body}`;
     const content = serializeMemory2({ frontmatter: fm, body: `${titledBody}
 
 ${SEED_FOOTER(stack)}` });
-    await mkdir5(path10.dirname(filePath), { recursive: true });
+    await mkdir5(path11.dirname(filePath), { recursive: true });
     await writeFile6(filePath, content, "utf8");
     existingTopics.add(topic);
     existingSignatures.add(signature);
@@ -3386,7 +3390,7 @@ ${SEED_FOOTER(stack)}` });
 
 // src/commands/init.ts
 var execFileAsync = promisify2(execFile2);
-var HAIVE_GITHUB_ACTION_REF = `v${"0.21.0"}`;
+var HAIVE_GITHUB_ACTION_REF = `v${"0.24.0"}`;
 var PROJECT_CONTEXT_TEMPLATE = `# Project context
 
 > Generated by \`haive init\`. Run \`haive init --bootstrap\` to auto-fill from your codebase,
@@ -3614,7 +3618,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 = path11.resolve(opts.dir);
+    const root = path12.resolve(opts.dir);
     const paths = resolveHaivePaths6(root);
     const autopilot = opts.manual !== true;
     const json = opts.json === true;
@@ -3641,7 +3645,7 @@ function registerInit(program2) {
     await mkdir6(paths.moduleDir, { recursive: true });
     await mkdir6(paths.modulesContextDir, { recursive: true });
     await ensureAiRuntimeLayout(paths.runtimeDir);
-    await ensureAiCacheLayout(path11.join(paths.haiveDir, ".cache"));
+    await ensureAiCacheLayout(path12.join(paths.haiveDir, ".cache"));
     if (!existsSync11(paths.projectContext)) {
       if (wantBootstrap) {
         ui.info("Bootstrapping project context from local files\u2026");
@@ -3655,11 +3659,11 @@ function registerInit(program2) {
         }
       } else {
         await writeFile7(paths.projectContext, PROJECT_CONTEXT_TEMPLATE, "utf8");
-        ui.success(`Created ${path11.relative(root, paths.projectContext)}`);
+        ui.success(`Created ${path12.relative(root, paths.projectContext)}`);
       }
     }
     const configExists = existsSync11(
-      path11.join(paths.haiveDir, "haive.config.json")
+      path12.join(paths.haiveDir, "haive.config.json")
     );
     if (!configExists) {
       await saveConfig2(paths, autopilot ? AUTOPILOT_DEFAULTS2 : { autopilot: false });
@@ -3726,13 +3730,13 @@ function registerInit(program2) {
     }
     const wantCi = opts.withCi || autopilot;
     if (wantCi) {
-      const ciPath = path11.join(root, ".github", "workflows", "haive-sync.yml");
+      const ciPath = path12.join(root, ".github", "workflows", "haive-sync.yml");
       if (existsSync11(ciPath)) {
         ui.info("CI workflow already exists \u2014 skipped");
       } else {
-        await mkdir6(path11.dirname(ciPath), { recursive: true });
+        await mkdir6(path12.dirname(ciPath), { recursive: true });
         await writeFile7(ciPath, CI_WORKFLOW, "utf8");
-        ui.success(`Created ${path11.relative(root, ciPath)}`);
+        ui.success(`Created ${path12.relative(root, ciPath)}`);
       }
     }
     if (autopilot) {
@@ -3772,7 +3776,7 @@ function registerInit(program2) {
         interactive: process.stdin.isTTY
       });
       for (const r of agentSetup.project_results) {
-        if (r.status === "configured" && r.path) ui.success(`haive MCP project config written (${path11.relative(root, r.path)})`);
+        if (r.status === "configured" && r.path) ui.success(`haive MCP project config written (${path12.relative(root, r.path)})`);
         else if (r.status === "error") ui.warn(`${r.client}: ${r.error}`);
       }
       for (const r of agentSetup.global_results) {
@@ -3871,7 +3875,7 @@ async function autoDetectStacksFromRoot(root) {
   let requirementsTxt;
   let goMod;
   let pomXml;
-  const pkgPath = path11.join(root, "package.json");
+  const pkgPath = path12.join(root, "package.json");
   if (existsSync11(pkgPath)) {
     try {
       const pkg = JSON.parse(await readFile6(pkgPath, "utf8"));
@@ -3880,7 +3884,7 @@ async function autoDetectStacksFromRoot(root) {
     }
   }
   for (const name of ["requirements.txt", "requirements/base.txt", "requirements/prod.txt"]) {
-    const reqPath = path11.join(root, name);
+    const reqPath = path12.join(root, name);
     if (existsSync11(reqPath)) {
       try {
         requirementsTxt = await readFile6(reqPath, "utf8");
@@ -3889,14 +3893,14 @@ async function autoDetectStacksFromRoot(root) {
       }
     }
   }
-  const goModPath = path11.join(root, "go.mod");
+  const goModPath = path12.join(root, "go.mod");
   if (existsSync11(goModPath)) {
     try {
       goMod = await readFile6(goModPath, "utf8");
     } catch {
     }
   }
-  const pomPath = path11.join(root, "pom.xml");
+  const pomPath = path12.join(root, "pom.xml");
   if (existsSync11(pomPath)) {
     try {
       pomXml = await readFile6(pomPath, "utf8");
@@ -3904,7 +3908,7 @@ async function autoDetectStacksFromRoot(root) {
     }
   }
   let composerJson;
-  const composerPath = path11.join(root, "composer.json");
+  const composerPath = path12.join(root, "composer.json");
   if (existsSync11(composerPath)) {
     try {
       composerJson = await readFile6(composerPath, "utf8");
@@ -3912,16 +3916,16 @@ async function autoDetectStacksFromRoot(root) {
     }
   }
   let gemfile;
-  const gemfilePath = path11.join(root, "Gemfile");
+  const gemfilePath = path12.join(root, "Gemfile");
   if (existsSync11(gemfilePath)) {
     try {
       gemfile = await readFile6(gemfilePath, "utf8");
     } catch {
     }
   }
-  const hasDockerfile = existsSync11(path11.join(root, "Dockerfile"));
-  const hasTurboJson = existsSync11(path11.join(root, "turbo.json"));
-  const hasNxJson = existsSync11(path11.join(root, "nx.json"));
+  const hasDockerfile = existsSync11(path12.join(root, "Dockerfile"));
+  const hasTurboJson = existsSync11(path12.join(root, "turbo.json"));
+  const hasNxJson = existsSync11(path12.join(root, "nx.json"));
   let hasCsproj = false;
   try {
     const entries = await readdir2(root);
@@ -3974,7 +3978,7 @@ _Seeded from git ${p.kind} commit ${p.source_sha}. Review and validate (or delet
 `;
     const file = memoryFilePath2(paths, fm.scope, fm.id, fm.module);
     if (existsSync11(file)) continue;
-    await mkdir6(path11.dirname(file), { recursive: true });
+    await mkdir6(path12.dirname(file), { recursive: true });
     await writeFile7(file, serializeMemory3({ frontmatter: fm, body }), "utf8");
     written++;
   }
@@ -4036,12 +4040,12 @@ function printInitReport(r) {
 }
 async function writeCursorHaiveRule(root) {
   const relPath = ".cursor/rules/haive-mcp-required.mdc";
-  const target = path11.join(root, relPath);
+  const target = path12.join(root, relPath);
   if (existsSync11(target)) {
     ui.info(`Cursor rule ${relPath} already exists \u2014 skipped`);
     return;
   }
-  await mkdir6(path11.dirname(target), { recursive: true });
+  await mkdir6(path12.dirname(target), { recursive: true });
   await writeFile7(target, CURSOR_HAIVE_RULE_MDC, "utf8");
   ui.success(`Created Cursor rule ${relPath}`);
 }
@@ -4070,25 +4074,25 @@ var RUNTIME_GITIGNORE_BODY = `*
 `;
 async function ensureAiRuntimeLayout(runtimeDir) {
   await mkdir6(runtimeDir, { recursive: true });
-  const gi = path11.join(runtimeDir, ".gitignore");
+  const gi = path12.join(runtimeDir, ".gitignore");
   if (!existsSync11(gi)) {
     await writeFile7(gi, RUNTIME_GITIGNORE_BODY, "utf8");
   }
-  const readme = path11.join(runtimeDir, "README.md");
+  const readme = path12.join(runtimeDir, "README.md");
   if (!existsSync11(readme)) {
     await writeFile7(readme, RUNTIME_README_BODY, "utf8");
   }
 }
 async function ensureAiCacheLayout(cacheDir) {
   await mkdir6(cacheDir, { recursive: true });
-  const gi = path11.join(cacheDir, ".gitignore");
+  const gi = path12.join(cacheDir, ".gitignore");
   if (!existsSync11(gi)) {
     await writeFile7(gi, "*\n!.gitignore\n", "utf8");
   }
 }
 async function ensureGitignoreEntries(root, patterns) {
   try {
-    const gitignorePath = path11.join(root, ".gitignore");
+    const gitignorePath = path12.join(root, ".gitignore");
     let existing = "";
     if (existsSync11(gitignorePath)) {
       existing = await readFile6(gitignorePath, "utf8");
@@ -4105,14 +4109,14 @@ async function ensureGitignoreEntries(root, patterns) {
 // src/commands/install-hooks.ts
 import { mkdir as mkdir8, writeFile as writeFile9, chmod, readFile as readFile8 } from "fs/promises";
 import { existsSync as existsSync13 } from "fs";
-import path13 from "path";
+import path14 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot8 } from "@hiveai/core";
 
 // src/utils/claude-hooks.ts
 import { existsSync as existsSync12 } from "fs";
 import { mkdir as mkdir7, readFile as readFile7, writeFile as writeFile8 } from "fs/promises";
-import path12 from "path";
+import path13 from "path";
 var HAIVE_HOOK_TAG = "haive-enforcement";
 var POST_TOOL_USE_GROUP = {
   matcher: "Edit|Write|Bash",
@@ -4208,7 +4212,7 @@ async function installClaudeHooksAtPath(settingsPath) {
     created = true;
   }
   const patched = patchClaudeSettings(raw);
-  await mkdir7(path12.dirname(settingsPath), { recursive: true });
+  await mkdir7(path13.dirname(settingsPath), { recursive: true });
   await writeFile8(settingsPath, JSON.stringify(patched, null, 2) + "\n", "utf8");
   return { settingsPath, created };
 }
@@ -4224,9 +4228,9 @@ async function uninstallClaudeHooksAtPath(settingsPath) {
 function defaultClaudeSettingsPath(scope, projectRoot) {
   if (scope === "user") {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-    return path12.join(home, ".claude", "settings.json");
+    return path13.join(home, ".claude", "settings.json");
   }
-  return path12.join(projectRoot, ".claude", "settings.local.json");
+  return path13.join(projectRoot, ".claude", "settings.local.json");
 }
 
 // src/commands/install-hooks.ts
@@ -4283,18 +4287,18 @@ fi
 ];
 async function installGitHooks(opts) {
   const root = findProjectRoot8(opts.dir);
-  const gitDir = path13.join(root, ".git");
+  const gitDir = path14.join(root, ".git");
   if (!existsSync13(gitDir)) {
     ui.error(`No .git directory at ${root}.`);
     process.exitCode = 1;
     return;
   }
-  const hooksDir = path13.join(gitDir, "hooks");
+  const hooksDir = path14.join(gitDir, "hooks");
   await mkdir8(hooksDir, { recursive: true });
   let installed = 0;
   let skipped = 0;
   for (const { name, body } of HOOKS) {
-    const file = path13.join(hooksDir, name);
+    const file = path14.join(hooksDir, name);
     if (existsSync13(file) && !opts.force) {
       const existing = await readFile8(file, "utf8");
       if (!existing.includes(HOOK_MARKER)) {
@@ -4360,7 +4364,7 @@ function registerInstallHooks(program2) {
 // src/commands/observe.ts
 import { appendFile, mkdir as mkdir9 } from "fs/promises";
 import { existsSync as existsSync14 } from "fs";
-import path14 from "path";
+import path15 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot9, resolveHaivePaths as resolveHaivePaths7 } from "@hiveai/core";
 var MAX_STDIN_BYTES = 256 * 1024;
@@ -4478,10 +4482,10 @@ function registerObserve(program2) {
         files: extractFiles(payload),
         ...failureHint ? { failure_hint: true } : {}
       };
-      const cacheDir = path14.join(paths.haiveDir, ".cache");
+      const cacheDir = path15.join(paths.haiveDir, ".cache");
       await mkdir9(cacheDir, { recursive: true });
       await appendFile(
-        path14.join(cacheDir, "observations.jsonl"),
+        path15.join(cacheDir, "observations.jsonl"),
         JSON.stringify(observation) + "\n",
         "utf8"
       );
@@ -4500,7 +4504,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { findProjectRoot as findProjectRoot10, resolveHaivePaths as resolveHaivePaths8 } from "@hiveai/core";
 import { mkdir as mkdir10, writeFile as writeFile10 } from "fs/promises";
 import { existsSync as existsSync15 } from "fs";
-import path15 from "path";
+import path16 from "path";
 import { z } from "zod";
 import { readFile as readFile9, readdir as readdir3 } from "fs/promises";
 import { existsSync as existsSync22 } from "fs";
@@ -4670,6 +4674,7 @@ import path82 from "path";
 import { execSync } from "child_process";
 import { readFile as readFile52, writeFile as writeFile13 } from "fs/promises";
 import { existsSync as existsSync21 } from "fs";
+import path112 from "path";
 import {
   allocateBudget,
   briefingProofLine,
@@ -4729,7 +4734,7 @@ import { z as z23 } from "zod";
 import { z as z24 } from "zod";
 import { existsSync as existsSync24 } from "fs";
 import { spawn } from "child_process";
-import path112 from "path";
+import path122 from "path";
 import {
   deriveConfidence as deriveConfidence5,
   getUsage as getUsage7,
@@ -4742,7 +4747,6 @@ import { z as z25 } from "zod";
 import { existsSync as existsSync25 } from "fs";
 import {
   addedLinesFromDiff,
-  appendPreventionEvent,
   BRIDGE_TARGET_PATH,
   buildDocFrequency,
   CODE_STOPWORDS,
@@ -4754,9 +4758,8 @@ import {
   loadUsageIndex as loadUsageIndex10,
   literalMatchesAnyToken as literalMatchesAnyToken3,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths4,
-  recordPrevention,
+  recordPreventionHits,
   runSensors,
-  saveUsageIndex as saveUsageIndex4,
   sensorTargetsFromDiff,
   tokenizeQuery as tokenizeQuery3
 } from "@hiveai/core";
@@ -4790,7 +4793,7 @@ import { z as z29 } from "zod";
 import { z as z30 } from "zod";
 import { mkdir as mkdir82, writeFile as writeFile14 } from "fs/promises";
 import { existsSync as existsSync29 } from "fs";
-import path122 from "path";
+import path132 from "path";
 import { execSync as execSync2 } from "child_process";
 import {
   buildFrontmatter as buildFrontmatter5,
@@ -4803,7 +4806,8 @@ import { existsSync as existsSync30 } from "fs";
 import {
   findLexicalConflictPairs,
   findTopicStatusConflictPairs,
-  loadMemoriesFromDir as loadMemoriesFromDir23
+  loadMemoriesFromDir as loadMemoriesFromDir23,
+  planConflictResolution
 } from "@hiveai/core";
 import { z as z32 } from "zod";
 import { resolveProjectInfo } from "@hiveai/core";
@@ -4835,14 +4839,14 @@ var BootstrapProjectSaveInputSchema = {
   overwrite: z.boolean().default(false).describe("Overwrite an existing file instead of failing")
 };
 async function bootstrapProjectSave(input, ctx) {
-  const target = input.module ? path15.join(ctx.paths.modulesContextDir, input.module, "context.md") : ctx.paths.projectContext;
+  const target = input.module ? path16.join(ctx.paths.modulesContextDir, input.module, "context.md") : ctx.paths.projectContext;
   const exists = existsSync15(target);
   if (exists && !input.overwrite) {
     throw new Error(
       `${target} already exists. Pass overwrite=true to replace it.`
     );
   }
-  await mkdir10(path15.dirname(target), { recursive: true });
+  await mkdir10(path16.dirname(target), { recursive: true });
   await writeFile10(target, input.content, "utf8");
   return {
     file_path: target,
@@ -5807,7 +5811,15 @@ async function memTried(input, ctx) {
     throw new Error(`Memory already exists at ${file}`);
   }
   await writeFile82(file, serializeMemory7({ frontmatter, body }), "utf8");
-  return { id: frontmatter.id, scope: frontmatter.scope, file_path: file };
+  const sensorGenerated = Boolean(sensor);
+  const hint = sensorGenerated ? void 0 : input.paths.length === 0 ? "No sensor was generated (no `paths` given), so this lesson is feedforward-only \u2014 it will be briefed but the gate cannot block the repeat. Re-run with `paths` set to the file(s) where the mistake lives to close the loop." : "No sensor could be derived from the wording (no distinctive code token). The lesson is briefed but not enforced; add a concrete forbidden token/value, or attach a sensor manually, to make the gate block the repeat.";
+  return {
+    id: frontmatter.id,
+    scope: frontmatter.scope,
+    file_path: file,
+    sensor_generated: sensorGenerated,
+    ...hint ? { hint } : {}
+  };
 }
 var IngestFindingsInputSchema = {
   format: z16.enum(["sarif", "sonar"]).describe("Report format: 'sarif' (ESLint/Semgrep/CodeQL) or 'sonar' (SonarQube issues JSON)"),
@@ -6572,6 +6584,7 @@ async function getBriefing(input, ctx) {
         const topSymbols = Object.entries(codeMap.files).flatMap(
           ([fp, entry]) => entry.exports.slice(0, 3).map((e) => `${e.name} (${fp.split("/").slice(-2).join("/")})`)
         ).slice(0, 15).join(", ");
+        const commands = await detectRunCommands(ctx.paths.root);
         projectContext = `# Project context (auto-generated by hAIve)
 
 > \u26A0 This is a minimal auto-generated context based on the code-map. Invoke the \`bootstrap_project\` MCP prompt to replace it with a full analysis.
@@ -6581,7 +6594,10 @@ async function getBriefing(input, ctx) {
 - **Main file types:** ${topExts}
 - **Generated at:** ${codeMap.generated_at}
 
-## Key exports (sample)
+` + (commands ? `## Commands
+${commands}
+
+` : "") + `## Key exports (sample)
 ` + topSymbols + "\n";
         autoContextGenerated = true;
         setupWarnings.push(
@@ -6861,6 +6877,19 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
     }
   };
 }
+async function detectRunCommands(root) {
+  const pkgPath = path112.join(root, "package.json");
+  if (!existsSync21(pkgPath)) return null;
+  try {
+    const pkg = JSON.parse(await readFile52(pkgPath, "utf8"));
+    const scripts = pkg.scripts ?? {};
+    const order = ["test", "build", "lint", "typecheck", "type-check", "dev", "start"];
+    const lines = order.filter((name) => typeof scripts[name] === "string" && scripts[name].trim() !== "").map((name) => `- \`${name}\`: \`${scripts[name]}\``);
+    return lines.length > 0 ? lines.join("\n") : null;
+  } catch {
+    return null;
+  }
+}
 var CodeMapInputSchema = {
   file: z20.string().optional().describe("Filter to files whose path contains this substring"),
   symbol: z20.string().optional().describe("Filter to files exporting a symbol whose name contains this substring"),
@@ -7084,7 +7113,7 @@ var WhyThisFileInputSchema = {
   memory_limit: z25.number().int().positive().max(20).default(5).describe("Cap on memories anchored to this path.")
 };
 async function whyThisFile(input, ctx) {
-  const fileExists = existsSync24(path112.join(ctx.paths.root, input.path));
+  const fileExists = existsSync24(path122.join(ctx.paths.root, input.path));
   const [commits, memories, codeMap] = await Promise.all([
     runGitLog(ctx.paths.root, input.path, input.git_log_limit).catch(() => []),
     collectAnchoredMemories(ctx, input.path, input.memory_limit),
@@ -7358,19 +7387,7 @@ async function antiPatternsCheck(input, ctx) {
   const strongCatches = warnings.filter(
     (w) => w.reasons.includes("sensor") || w.reasons.includes("anchor") && w.reasons.includes("literal")
   );
-  if (strongCatches.length > 0) {
-    const recordedIds = [];
-    for (const w of strongCatches) if (recordPrevention(usage, w.id)) recordedIds.push(w.id);
-    if (recordedIds.length > 0) {
-      await saveUsageIndex4(ctx.paths, usage).catch(() => {
-      });
-      const at = (/* @__PURE__ */ new Date()).toISOString();
-      for (const id of recordedIds) {
-        await appendPreventionEvent(ctx.paths, { at, id, source: "anti-pattern" }).catch(() => {
-        });
-      }
-    }
-  }
+  await recordPreventionHits(ctx.paths, strongCatches.map((w) => w.id), "anti-pattern");
   return {
     scanned: negative.length,
     warnings
@@ -8128,13 +8145,13 @@ async function patternDetect(input, ctx) {
   try {
     const changedFiles = gitChangedFiles(ctx.paths.root, input.since_days);
     const configFiles = changedFiles.filter(
-      (f) => CONFIG_PATTERNS.some((p) => path122.basename(f.toLowerCase()).includes(p))
+      (f) => CONFIG_PATTERNS.some((p) => path132.basename(f.toLowerCase()).includes(p))
     );
     for (const file of configFiles.slice(0, 5)) {
       const diff = gitFileDiff(ctx.paths.root, file, input.since_days);
       if (!diff) continue;
-      const parentDir = path122.basename(path122.dirname(file));
-      const baseName = path122.basename(file).replace(/\.[^.]+$/, "");
+      const parentDir = path132.basename(path132.dirname(file));
+      const baseName = path132.basename(file).replace(/\.[^.]+$/, "");
       const slug = `${parentDir}-${baseName}`.replace(/[^a-z0-9]/gi, "-").toLowerCase().slice(0, 40);
       matches.push({
         kind: "config_change",
@@ -8198,7 +8215,7 @@ async function patternDetect(input, ctx) {
   for (const [p, { count, tools }] of pathCounts) {
     if (count < HOT_FILE_MIN) continue;
     if (tools.has("mem_tried") || tools.has("mem_observe")) continue;
-    if (CONFIG_PATTERNS.some((cp2) => path122.basename(p).includes(cp2))) continue;
+    if (CONFIG_PATTERNS.some((cp2) => path132.basename(p).includes(cp2))) continue;
     const slug = p.replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").slice(0, 40);
     matches.push({
       kind: "hot_file",
@@ -8245,7 +8262,7 @@ async function patternDetect(input, ctx) {
         void 0
       );
       if (existsSync29(file)) continue;
-      await mkdir82(path122.dirname(file), { recursive: true });
+      await mkdir82(path132.dirname(file), { recursive: true });
       await writeFile14(
         file,
         serializeMemory12({ frontmatter: fm, body: match.proposed_body }),
@@ -8288,6 +8305,18 @@ function gitFileDiff(root, file, sinceDays) {
     return null;
   }
 }
+function suggestResolution(byId, idA, idB) {
+  const a = byId.get(idA);
+  const b = byId.get(idB);
+  if (!a || !b) return null;
+  const plan = planConflictResolution(a, b);
+  return {
+    keep_id: plan.keep_id,
+    supersede_id: plan.supersede_id,
+    reason: plan.reason,
+    command: `haive memory resolve-conflict ${plan.keep_id} ${plan.supersede_id} --yes`
+  };
+}
 var MemConflictCandidatesInputSchema = {
   since_days: z32.number().int().positive().max(3650).default(365).describe("Only memories created since N days ago"),
   types: z32.array(z32.enum(["decision", "architecture", "convention", "gotcha"])).default(["decision", "architecture"]).describe("Memory types scanned for pairwise lexical overlap"),
@@ -8309,6 +8338,7 @@ async function memConflictCandidates(input, ctx) {
     };
   }
   const all = await loadMemoriesFromDir23(ctx.paths.memoriesDir);
+  const byId = new Map(all.map((m) => [m.memory.frontmatter.id, m]));
   const { pairs, scanned, truncated } = findLexicalConflictPairs(all, {
     sinceDays: input.since_days,
     types: input.types,
@@ -8317,8 +8347,22 @@ async function memConflictCandidates(input, ctx) {
     maxScan: input.max_scan
   });
   const topicStatusPairs = findTopicStatusConflictPairs(all, input.max_topic_pairs);
+  const enrichedPairs = pairs.map((p) => ({
+    ...p,
+    suggested_resolution: suggestResolution(byId, p.id_a, p.id_b)
+  }));
+  const enrichedTopicStatusPairs = topicStatusPairs.map((p) => ({
+    ...p,
+    suggested_resolution: suggestResolution(byId, p.id_a, p.id_b)
+  }));
   const notice = pairs.length === 0 && topicStatusPairs.length === 0 ? "No lexical or topic-status candidates \u2014 widen since_days/types or lower min_jaccard." : void 0;
-  return { pairs, topic_status_pairs: topicStatusPairs, scanned, truncated, notice };
+  return {
+    pairs: enrichedPairs,
+    topic_status_pairs: enrichedTopicStatusPairs,
+    scanned,
+    truncated,
+    notice
+  };
 }
 var MemResolveProjectInputSchema = {
   cwd: z33.string().optional().describe("Directory used for root discovery when HAIVE_PROJECT_ROOT is unset.")
@@ -8632,7 +8676,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
   };
 }
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.21.0";
+var SERVER_VERSION = "0.24.0";
 function jsonResult(data) {
   return {
     content: [
@@ -9666,7 +9710,7 @@ function registerMcp(program2) {
 import { spawnSync as spawnSync4 } from "child_process";
 import { readFile as readFile10, writeFile as writeFile15, mkdir as mkdir11 } from "fs/promises";
 import { existsSync as existsSync33 } from "fs";
-import path16 from "path";
+import path17 from "path";
 import "commander";
 import {
   DEFAULT_AUTO_PROMOTE_RULE as DEFAULT_AUTO_PROMOTE_RULE2,
@@ -9860,10 +9904,10 @@ function registerSync(program2) {
       const maxInject = Math.max(1, Number(opts.bridgeMaxMemories ?? 5));
       let bridgeTargets;
       if (opts.bridgeFile) {
-        bridgeTargets = [path16.resolve(opts.bridgeFile)];
+        bridgeTargets = [path17.resolve(opts.bridgeFile)];
       } else {
-        const agentsMd = path16.join(root, "AGENTS.md");
-        bridgeTargets = [path16.join(root, "CLAUDE.md")];
+        const agentsMd = path17.join(root, "AGENTS.md");
+        bridgeTargets = [path17.join(root, "CLAUDE.md")];
         if (existsSync33(agentsMd)) bridgeTargets.push(agentsMd);
       }
       for (const bridgeFile of bridgeTargets) {
@@ -9995,10 +10039,10 @@ Wait for **explicit confirmation** before acting.
                   topic: `dep-bump-${slugParts}`
                 });
                 if (!dryRun) {
-                  const teamDir = path16.join(paths.memoriesDir, "team");
+                  const teamDir = path17.join(paths.memoriesDir, "team");
                   await mkdir11(teamDir, { recursive: true });
                   await writeFile15(
-                    path16.join(teamDir, `${fm.id}.md`),
+                    path17.join(teamDir, `${fm.id}.md`),
                     serializeMemory13({ frontmatter: { ...fm, requires_human_approval: true }, body }),
                     "utf8"
                   );
@@ -10064,10 +10108,10 @@ Wait for **explicit confirmation** before acting.
               topic: `contract-breaking-${diff.contract}`
             });
             if (!dryRun) {
-              const teamDir = path16.join(paths.memoriesDir, "team");
+              const teamDir = path17.join(paths.memoriesDir, "team");
               await mkdir11(teamDir, { recursive: true });
               await writeFile15(
-                path16.join(teamDir, `${fm.id}.md`),
+                path17.join(teamDir, `${fm.id}.md`),
                 serializeMemory13({ frontmatter: { ...fm, requires_human_approval: true }, body }),
                 "utf8"
               );
@@ -10190,11 +10234,11 @@ ${BRIDGE_END}`;
   const startIdx = existing.indexOf(BRIDGE_START);
   const endIdx = existing.indexOf(BRIDGE_END);
   if (startIdx !== -1 && endIdx === -1) {
-    ui.warn(`${path16.relative(root, bridgeFile)}: found ${BRIDGE_START} without ${BRIDGE_END}. Fix the file manually before running --inject-bridge.`);
+    ui.warn(`${path17.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(`${path16.relative(root, bridgeFile)}: found ${BRIDGE_END} without ${BRIDGE_START}. Fix the file manually before running --inject-bridge.`);
+    ui.warn(`${path17.relative(root, bridgeFile)}: found ${BRIDGE_END} without ${BRIDGE_START}. Fix the file manually before running --inject-bridge.`);
     return;
   }
   let updated;
@@ -10202,14 +10246,14 @@ ${BRIDGE_END}`;
     updated = existing.slice(0, startIdx) + injected + existing.slice(endIdx + BRIDGE_END.length);
   } else {
     if (!fileExists && !quiet) {
-      ui.info(`Creating ${path16.relative(root, bridgeFile)} with haive memory block.`);
+      ui.info(`Creating ${path17.relative(root, bridgeFile)} with haive memory block.`);
     }
     updated = existing + (existing.endsWith("\n") ? "" : "\n") + "\n" + injected + "\n";
   }
   await writeFile15(bridgeFile, updated, "utf8");
   if (!quiet) {
     console.log(
-      ui.dim(`bridge: injected ${top.length} memor${top.length === 1 ? "y" : "ies"} into ${path16.relative(root, bridgeFile)}`)
+      ui.dim(`bridge: injected ${top.length} memor${top.length === 1 ? "y" : "ies"} into ${path17.relative(root, bridgeFile)}`)
     );
   }
 }
@@ -10236,7 +10280,7 @@ function collectSinceChanges(root, ref) {
 import { createHash as createHash2 } from "crypto";
 import { mkdir as mkdir12, readFile as readFile11, writeFile as writeFile16 } from "fs/promises";
 import { existsSync as existsSync34 } from "fs";
-import path17 from "path";
+import path18 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter7,
@@ -10294,7 +10338,7 @@ function registerMemoryAdd(memory2) {
     const inferredTags = autoTagsEnabled ? inferModulesFromPaths3(anchorPaths) : [];
     const mergedTags = Array.from(/* @__PURE__ */ new Set([...userTags, ...inferredTags]));
     if (anchorPaths.length > 0) {
-      const missing = anchorPaths.filter((p) => !existsSync34(path17.resolve(root, p)));
+      const missing = anchorPaths.filter((p) => !existsSync34(path18.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}`);
@@ -10358,7 +10402,7 @@ TODO \u2014 write the memory body.
         const suggestedSensor = !newFrontmatter.sensor ? suggestSensorForCliMemory(opts.type, body, newFrontmatter.anchor.paths) : null;
         if (suggestedSensor) newFrontmatter.sensor = suggestedSensor;
         await writeFile16(topicMatch.filePath, serializeMemory14({ frontmatter: newFrontmatter, body }), "utf8");
-        ui.success(`Updated (topic upsert) ${path17.relative(root, topicMatch.filePath)}`);
+        ui.success(`Updated (topic upsert) ${path18.relative(root, topicMatch.filePath)}`);
         ui.info(`id=${fm.id}  revision=${revisionCount}`);
         if (suggestedSensor) ui.info(`sensor=regex warn autogen pattern=${JSON.stringify(suggestedSensor.pattern)}`);
         await runPostMemoryAutopilot(root, paths, config);
@@ -10382,7 +10426,7 @@ TODO \u2014 write the memory body.
       activation
     });
     const file = memoryFilePath7(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir12(path17.dirname(file), { recursive: true });
+    await mkdir12(path18.dirname(file), { recursive: true });
     if (existsSync34(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
@@ -10401,7 +10445,7 @@ TODO \u2014 write the memory body.
       }
     }
     await writeFile16(file, serializeMemory14({ frontmatter, body }), "utf8");
-    ui.success(`Created ${path17.relative(root, file)}`);
+    ui.success(`Created ${path18.relative(root, file)}`);
     ui.info(`id=${frontmatter.id}  scope=${frontmatter.scope}  status=${frontmatter.status}`);
     if (frontmatter.sensor?.autogen) {
       ui.info(`sensor=regex warn autogen pattern=${JSON.stringify(frontmatter.sensor.pattern)}`);
@@ -10481,7 +10525,7 @@ function slugify(value) {
 
 // src/commands/memory-list.ts
 import { existsSync as existsSync35 } from "fs";
-import path18 from "path";
+import path19 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot14, resolveHaivePaths as resolveHaivePaths11 } from "@hiveai/core";
 
@@ -10534,7 +10578,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(path18.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path19.relative(root, filePath))}`);
     }
     const totalLabel = clipped > 0 ? `
 ${displayed.length} of ${filtered.length} memories shown (use --limit to adjust)` : `
@@ -10573,7 +10617,7 @@ function matchesFilters(loaded, opts) {
 // src/commands/memory-promote.ts
 import { mkdir as mkdir13, unlink as unlink2, writeFile as writeFile17 } from "fs/promises";
 import { existsSync as existsSync36 } from "fs";
-import path19 from "path";
+import path20 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot15,
@@ -10620,11 +10664,11 @@ function registerMemoryPromote(memory2) {
       body: found.memory.body
     };
     const newPath = memoryFilePath8(paths, "team", updated.frontmatter.id);
-    await mkdir13(path19.dirname(newPath), { recursive: true });
+    await mkdir13(path20.dirname(newPath), { recursive: true });
     await writeFile17(newPath, serializeMemory15(updated), "utf8");
     await unlink2(found.filePath);
     ui.success(`Promoted ${id} to team scope (status=proposed)`);
-    ui.info(`Now at ${path19.relative(root, newPath)}`);
+    ui.info(`Now at ${path20.relative(root, newPath)}`);
     console.log(ui.dim(`\u2192 next: haive memory approve ${id}  (validate for team use)`));
   });
 }
@@ -10632,7 +10676,7 @@ function registerMemoryPromote(memory2) {
 // src/commands/memory-approve.ts
 import { existsSync as existsSync37 } from "fs";
 import { writeFile as writeFile18 } from "fs/promises";
-import path20 from "path";
+import path21 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot16,
@@ -10696,14 +10740,14 @@ function registerMemoryApprove(memory2) {
     };
     await writeFile18(found.filePath, serializeMemory16(next), "utf8");
     ui.success(`Approved ${id} (status=validated)`);
-    ui.info(path20.relative(root, found.filePath));
+    ui.info(path21.relative(root, found.filePath));
   });
 }
 
 // src/commands/memory-update.ts
 import { readFile as readFile12, writeFile as writeFile19 } from "fs/promises";
 import { existsSync as existsSync38 } from "fs";
-import path21 from "path";
+import path23 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot17,
@@ -10782,7 +10826,7 @@ function registerMemoryUpdate(memory2) {
       serializeMemory17({ frontmatter: newFrontmatter, body: newBody }),
       "utf8"
     );
-    ui.success(`Updated ${path21.relative(root, loaded.filePath)}`);
+    ui.success(`Updated ${path23.relative(root, loaded.filePath)}`);
     ui.info(`fields: ${updated.join(", ")}`);
   });
 }
@@ -10803,7 +10847,7 @@ function parseCsv3(value) {
 // src/commands/memory-auto-promote.ts
 import { writeFile as writeFile20 } from "fs/promises";
 import { existsSync as existsSync39 } from "fs";
-import path23 from "path";
+import path24 from "path";
 import "commander";
 import {
   DEFAULT_AUTO_PROMOTE_RULE as DEFAULT_AUTO_PROMOTE_RULE3,
@@ -10848,7 +10892,7 @@ function registerMemoryAutoPromote(memory2) {
       console.log(
         `${ui.bold(opts.apply ? "PROMOTE" : "would promote")}  ${mem.frontmatter.id}  ${ui.dim(`reads=${u.read_count} rejections=${u.rejected_count}`)}`
       );
-      console.log(`             ${ui.dim(path23.relative(root, filePath))}`);
+      console.log(`             ${ui.dim(path24.relative(root, filePath))}`);
       if (opts.apply) {
         const next = {
           frontmatter: { ...mem.frontmatter, status: "validated" },
@@ -10867,7 +10911,7 @@ function registerMemoryAutoPromote(memory2) {
 import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync40 } from "fs";
 import { readFile as readFile13 } from "fs/promises";
-import path24 from "path";
+import path25 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot19,
@@ -10891,7 +10935,7 @@ function registerMemoryEdit(memory2) {
       return;
     }
     const editor = opts.editor ?? process.env.EDITOR ?? process.env.VISUAL ?? "vi";
-    ui.info(`Opening ${path24.relative(root, found.filePath)} with ${editor}\u2026`);
+    ui.info(`Opening ${path25.relative(root, found.filePath)} with ${editor}\u2026`);
     const code = await runEditor(editor, found.filePath);
     if (code !== 0) {
       ui.warn(`Editor exited with status ${code}.`);
@@ -10919,7 +10963,7 @@ function runEditor(editor, file) {
 
 // src/commands/memory-for-files.ts
 import { existsSync as existsSync41 } from "fs";
-import path25 from "path";
+import path26 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence9,
@@ -11041,13 +11085,13 @@ function printGroup(root, label, loaded, usage) {
     const u = getUsage13(usage, fm.id);
     const conf = deriveConfidence9(fm, u);
     console.log(`${ui.bold(fm.id)}  ${ui.dim(`${fm.scope}/${fm.type}`)}  ${ui.bold(conf)}`);
-    console.log(`  ${ui.dim(path25.relative(root, filePath))}`);
+    console.log(`  ${ui.dim(path26.relative(root, filePath))}`);
   }
 }
 
 // src/commands/memory-hot.ts
 import { existsSync as existsSync43 } from "fs";
-import path26 from "path";
+import path27 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot21,
@@ -11089,7 +11133,7 @@ function registerMemoryHot(memory2) {
       console.log(
         `${ui.bold(fm.id)}  ${ui.dim(`${fm.scope}/${fm.type}`)}  ${ui.bold(fm.status)}  ${ui.dim(`reads=${u.read_count} rejections=${u.rejected_count}`)}`
       );
-      console.log(`  ${ui.dim(path26.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path27.relative(root, filePath))}`);
     }
     ui.info(
       `${candidates.length} hot (read \u2265${threshold}\xD7) \u2014 agents rely on these; promote with \`haive memory promote <id>\`.
@@ -11101,7 +11145,7 @@ function registerMemoryHot(memory2) {
 // src/commands/memory-tried.ts
 import { mkdir as mkdir14, writeFile as writeFile21 } from "fs/promises";
 import { existsSync as existsSync44 } from "fs";
-import path27 from "path";
+import path28 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter8,
@@ -11157,16 +11201,22 @@ function registerMemoryTried(memory2) {
       frontmatter.sensor = sensor;
     }
     const file = memoryFilePath9(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir14(path27.dirname(file), { recursive: true });
+    await mkdir14(path28.dirname(file), { recursive: true });
     if (existsSync44(file)) {
       ui.error(`Memory already exists at ${file}`);
       process.exitCode = 1;
       return;
     }
     await writeFile21(file, serializeMemory19({ frontmatter, body }), "utf8");
-    ui.success(`Recorded: ${path27.relative(root, file)}`);
+    ui.success(`Recorded: ${path28.relative(root, file)}`);
     ui.info(`id=${frontmatter.id}  type=attempt  status=validated (auto-approved)`);
-    if (sensor) ui.info(`sensor=regex warn autogen pattern=${JSON.stringify(sensor.pattern)}`);
+    if (sensor) {
+      ui.info(`sensor=regex warn autogen pattern=${JSON.stringify(sensor.pattern)}`);
+    } else {
+      ui.warn(
+        frontmatter.anchor.paths.length === 0 ? "No sensor generated (no --paths) \u2014 lesson is briefed but NOT enforced. Add --paths to close the loop." : "No sensor could be derived from the wording \u2014 lesson is briefed but NOT enforced. Use a concrete forbidden token to enable a gate block."
+      );
+    }
   });
 }
 function parseCsv4(value) {
@@ -11177,7 +11227,7 @@ function parseCsv4(value) {
 // src/commands/memory-seed.ts
 import { readFile as readFile14 } from "fs/promises";
 import { existsSync as existsSync45 } from "fs";
-import path28 from "path";
+import path29 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot23,
@@ -11186,7 +11236,7 @@ import {
 } from "@hiveai/core";
 async function readDependencyMap(root) {
   try {
-    const raw = await readFile14(path28.join(root, "package.json"), "utf8");
+    const raw = await readFile14(path29.join(root, "package.json"), "utf8");
     const pkg = JSON.parse(raw);
     return { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
   } catch {
@@ -11273,7 +11323,7 @@ function registerMemorySeed(memory2) {
 
 // src/commands/memory-pending.ts
 import { existsSync as existsSync46 } from "fs";
-import path29 from "path";
+import path30 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot24,
@@ -11319,7 +11369,7 @@ function registerMemoryPending(memory2) {
         console.log(
           `  ${ui.bold(fm.id)}  ${ui.dim(`${fm.scope}/${fm.type}`)}  ${ui.dim(`age=${ageStr} reads=${u.read_count}`)}`
         );
-        console.log(`    ${ui.dim(path29.relative(root, filePath))}`);
+        console.log(`    ${ui.dim(path30.relative(root, filePath))}`);
       }
       if (proposed.length > 0) console.log(ui.dim(`  \u2192 haive memory approve <id>  or  haive memory auto-promote`));
       console.log();
@@ -11334,7 +11384,7 @@ function registerMemoryPending(memory2) {
         console.log(
           `  ${ui.bold(fm.id)}  ${ui.dim(`${fm.scope}/${fm.type}`)}  ${ui.dim(`age=${ageStr} reads=${u.read_count}`)}`
         );
-        console.log(`    ${ui.dim(path29.relative(root, filePath))}`);
+        console.log(`    ${ui.dim(path30.relative(root, filePath))}`);
       }
       console.log(ui.dim(`  \u2192 haive memory approve <id>   (activate)  |  haive memory promote <id>  (share with team)`));
     }
@@ -11344,7 +11394,7 @@ function registerMemoryPending(memory2) {
 
 // src/commands/memory-query.ts
 import { existsSync as existsSync47 } from "fs";
-import path30 from "path";
+import path31 from "path";
 import "commander";
 import {
   extractSnippet as extractSnippet2,
@@ -11401,7 +11451,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(path30.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path31.relative(root, filePath))}`);
       const snippet = extractSnippet2(mem.body, snippetNeedle);
       if (snippet) console.log(`  ${snippet}`);
     }
@@ -11426,7 +11476,7 @@ import {
   loadUsageIndex as loadUsageIndex18,
   recordRejection as recordRejection3,
   resolveHaivePaths as resolveHaivePaths23,
-  saveUsageIndex as saveUsageIndex5,
+  saveUsageIndex as saveUsageIndex4,
   serializeMemory as serializeMemory20
 } from "@hiveai/core";
 function registerMemoryReject(memory2) {
@@ -11459,7 +11509,7 @@ function registerMemoryReject(memory2) {
     );
     const idx = await loadUsageIndex18(paths);
     recordRejection3(idx, id, opts.reason ?? null);
-    await saveUsageIndex5(paths, idx);
+    await saveUsageIndex4(paths, idx);
     const u = idx.by_id[id];
     ui.success(
       `Rejected ${id} (status=rejected, ${u.rejected_count} rejection${u.rejected_count === 1 ? "" : "s"})`
@@ -11471,14 +11521,14 @@ function registerMemoryReject(memory2) {
 // src/commands/memory-rm.ts
 import { existsSync as existsSync49 } from "fs";
 import { unlink as unlink3 } from "fs/promises";
-import path31 from "path";
+import path33 from "path";
 import { createInterface as createInterface2 } from "readline/promises";
 import "commander";
 import {
   findProjectRoot as findProjectRoot27,
   loadUsageIndex as loadUsageIndex19,
   resolveHaivePaths as resolveHaivePaths24,
-  saveUsageIndex as saveUsageIndex6
+  saveUsageIndex as saveUsageIndex5
 } from "@hiveai/core";
 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) => {
@@ -11496,7 +11546,7 @@ function registerMemoryRm(memory2) {
       process.exitCode = 1;
       return;
     }
-    const rel = path31.relative(root, found.filePath);
+    const rel = path33.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();
@@ -11512,7 +11562,7 @@ function registerMemoryRm(memory2) {
       const idx = await loadUsageIndex19(paths);
       if (idx.by_id[id]) {
         delete idx.by_id[id];
-        await saveUsageIndex6(paths, idx);
+        await saveUsageIndex5(paths, idx);
         ui.info("Removed usage entry");
       }
     }
@@ -11522,7 +11572,7 @@ function registerMemoryRm(memory2) {
 // src/commands/memory-show.ts
 import { existsSync as existsSync50 } from "fs";
 import { readFile as readFile15 } from "fs/promises";
-import path33 from "path";
+import path34 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence10,
@@ -11564,7 +11614,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:")}       ${path33.relative(root, found.filePath)}`);
+    console.log(`${ui.dim("file:")}       ${path34.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}`);
@@ -11580,7 +11630,7 @@ function registerMemoryShow(memory2) {
 
 // src/commands/memory-stats.ts
 import { existsSync as existsSync51 } from "fs";
-import path34 from "path";
+import path35 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence11,
@@ -11618,7 +11668,7 @@ 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(path34.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path35.relative(root, filePath))}`);
     }
   });
 }
@@ -11725,7 +11775,7 @@ import {
   recordRejection as recordRejection4,
   recommendFeedbackAdjustment as recommendFeedbackAdjustment2,
   resolveHaivePaths as resolveHaivePaths28,
-  saveUsageIndex as saveUsageIndex7,
+  saveUsageIndex as saveUsageIndex6,
   serializeMemory as serializeMemory21
 } from "@hiveai/core";
 function registerMemoryFeedback(memory2) {
@@ -11755,7 +11805,7 @@ function registerMemoryFeedback(memory2) {
     const outcome = opts.applied ? "applied" : "rejected";
     if (opts.applied) recordApplied2(index, id);
     else recordRejection4(index, id, opts.reason ?? null);
-    await saveUsageIndex7(paths, index);
+    await saveUsageIndex6(paths, index);
     const usage = getUsage19(index, id);
     const adjustment = opts.rejected ? recommendFeedbackAdjustment2(target.memory.frontmatter, usage) : { action: "none", reason: "No automatic adjustment needed." };
     const adjustedFrontmatter = applyFeedbackAdjustment2(target.memory.frontmatter, adjustment);
@@ -11781,7 +11831,7 @@ function registerMemoryFeedback(memory2) {
 // src/commands/memory-verify.ts
 import { writeFile as writeFile25 } from "fs/promises";
 import { existsSync as existsSync55 } from "fs";
-import path35 from "path";
+import path36 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot32,
@@ -11823,7 +11873,7 @@ function registerMemoryVerify(memory2) {
     for (const { memory: mem, filePath } of targets) {
       const result = await verifyAnchor3(mem, { projectRoot: root });
       const isAnchored = mem.frontmatter.anchor.paths.length > 0 || mem.frontmatter.anchor.symbols.length > 0;
-      const rel = path35.relative(root, filePath);
+      const rel = path36.relative(root, filePath);
       if (!isAnchored) {
         anchorlessIds.push(mem.frontmatter.id);
         entries.push({ id: mem.frontmatter.id, status: "anchorless", path: rel });
@@ -11968,7 +12018,7 @@ function registerMemoryImport(memory2) {
 // src/commands/memory-import-changelog.ts
 import { existsSync as existsSync57 } from "fs";
 import { readFile as readFile17, mkdir as mkdir15, writeFile as writeFile26 } from "fs/promises";
-import path36 from "path";
+import path37 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter9,
@@ -12040,7 +12090,7 @@ function registerMemoryImportChangelog(memory2) {
   ).option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot34(opts.dir);
     const paths = resolveHaivePaths31(root);
-    const changelogPath = path36.resolve(root, opts.fromChangelog);
+    const changelogPath = path37.resolve(root, opts.fromChangelog);
     if (!existsSync57(changelogPath)) {
       ui.error(`CHANGELOG not found: ${changelogPath}`);
       process.exitCode = 1;
@@ -12061,9 +12111,9 @@ function registerMemoryImportChangelog(memory2) {
         entries = entries.filter((e) => requested.includes(e.version));
       }
     }
-    const pkgName = opts.package ?? path36.basename(path36.dirname(changelogPath));
+    const pkgName = opts.package ?? path37.basename(path37.dirname(changelogPath));
     const scope = opts.scope ?? "team";
-    const teamDir = path36.join(paths.memoriesDir, scope);
+    const teamDir = path37.join(paths.memoriesDir, scope);
     await mkdir15(teamDir, { recursive: true });
     let saved = 0;
     for (const entry of entries) {
@@ -12086,7 +12136,7 @@ function registerMemoryImportChangelog(memory2) {
         lines.push("");
       }
       lines.push(
-        `**Source:** \`${path36.relative(root, changelogPath)}\`  
+        `**Source:** \`${path37.relative(root, changelogPath)}\`  
 **Action:** Update all usages of ${pkgName} if they rely on any of the above.`
       );
       const slug = `changelog-${pkgName.replace(/[^a-z0-9]/gi, "-").toLowerCase()}-v${entry.version.replace(/\./g, "-")}`;
@@ -12101,11 +12151,11 @@ function registerMemoryImportChangelog(memory2) {
           pkgName.replace(/[^a-z0-9]/gi, "-").toLowerCase(),
           `v${entry.version}`
         ],
-        paths: [path36.relative(root, changelogPath)],
+        paths: [path37.relative(root, changelogPath)],
         topic: `changelog-${pkgName}-${entry.version}`
       });
       await writeFile26(
-        path36.join(teamDir, `${fm.id}.md`),
+        path37.join(teamDir, `${fm.id}.md`),
         serializeMemory24({ frontmatter: fm, body: lines.join("\n") }),
         "utf8"
       );
@@ -12130,7 +12180,7 @@ ${ui.bold(`Imported ${saved} changelog entr${saved === 1 ? "y" : "ies"} from ${p
 // src/commands/memory-digest.ts
 import { existsSync as existsSync58 } from "fs";
 import { writeFile as writeFile27 } from "fs/promises";
-import path37 from "path";
+import path38 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence12,
@@ -12225,7 +12275,7 @@ function registerMemoryDigest(program2) {
     );
     const digest = lines.join("\n");
     if (opts.out) {
-      const outPath = path37.resolve(process.cwd(), opts.out);
+      const outPath = path38.resolve(process.cwd(), opts.out);
       await writeFile27(outPath, digest, "utf8");
       ui.success(`Digest written to ${opts.out}  (${recent.length} memor${recent.length === 1 ? "y" : "ies"})`);
     } else {
@@ -12238,7 +12288,7 @@ function registerMemoryDigest(program2) {
 import { writeFile as writeFile28, mkdir as mkdir16, readFile as readFile18, rm as rm2 } from "fs/promises";
 import { existsSync as existsSync59 } from "fs";
 import { spawn as spawn4 } from "child_process";
-import path38 from "path";
+import path39 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter10,
@@ -12253,7 +12303,7 @@ import {
   summarizeCaughtForYou
 } from "@hiveai/core";
 async function buildAutoRecap(paths) {
-  const obsFile = path38.join(paths.haiveDir, ".cache", "observations.jsonl");
+  const obsFile = path39.join(paths.haiveDir, ".cache", "observations.jsonl");
   if (!existsSync59(obsFile)) return await buildGitAutoRecap(paths);
   const raw = await readFile18(obsFile, "utf8").catch(() => "");
   if (!raw.trim()) return await buildGitAutoRecap(paths);
@@ -12422,7 +12472,7 @@ function runGit(cwd, args) {
   });
 }
 async function observationStart(paths) {
-  const obsFile = path38.join(paths.haiveDir, ".cache", "observations.jsonl");
+  const obsFile = path39.join(paths.haiveDir, ".cache", "observations.jsonl");
   if (!existsSync59(obsFile)) return null;
   const raw = await readFile18(obsFile, "utf8").catch(() => "");
   let first = null;
@@ -12511,14 +12561,14 @@ function registerSessionEnd(session2) {
     });
     const topic = recapTopic2(scope, opts.module);
     const filesTouched = parseCsv5(resolvedFiles).map((p) => normalizeAnchorPath(root, p));
-    const missingPaths = filesTouched.filter((p) => !existsSync59(path38.resolve(root, p)));
+    const missingPaths = filesTouched.filter((p) => !existsSync59(path39.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 = path38.join(paths.haiveDir, ".cache", "observations.jsonl");
+      const obsFile = path39.join(paths.haiveDir, ".cache", "observations.jsonl");
       if (existsSync59(obsFile)) await rm2(obsFile).catch(() => {
       });
     };
@@ -12543,7 +12593,7 @@ function registerSessionEnd(session2) {
         await cleanupObservations();
         if (!opts.quiet) {
           ui.success(`Session recap updated (revision #${revisionCount})`);
-          ui.info(`id=${fm.id}  file=${path38.relative(root, topicMatch.filePath)}`);
+          ui.info(`id=${fm.id}  file=${path39.relative(root, topicMatch.filePath)}`);
           await printCaughtForYou(paths, caughtSince, opts.quiet);
           ui.info("Tip: `haive stats --export-report` generates a usage JSON suitable for dashboards.");
         }
@@ -12561,12 +12611,12 @@ function registerSessionEnd(session2) {
       status: "validated"
     });
     const file = memoryFilePath10(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir16(path38.dirname(file), { recursive: true });
+    await mkdir16(path39.dirname(file), { recursive: true });
     await writeFile28(file, serializeMemory25({ frontmatter, body }), "utf8");
     await cleanupObservations();
     if (!opts.quiet) {
       ui.success(`Session recap created`);
-      ui.info(`id=${frontmatter.id}  scope=${scope}  file=${path38.relative(root, file)}`);
+      ui.info(`id=${frontmatter.id}  scope=${scope}  file=${path39.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 `haive stats --export-report .ai/tool-usage-roi-report.json`.");
@@ -12579,8 +12629,8 @@ function parseCsv5(value) {
 }
 function normalizeAnchorPath(root, filePath) {
   if (!filePath) return filePath;
-  if (!path38.isAbsolute(filePath)) return filePath;
-  const rel = path38.relative(root, filePath);
+  if (!path39.isAbsolute(filePath)) return filePath;
+  const rel = path39.relative(root, filePath);
   if (rel.startsWith("..")) return filePath;
   return rel;
 }
@@ -12588,7 +12638,7 @@ function normalizeAnchorPath(root, filePath) {
 // src/commands/snapshot.ts
 import { existsSync as existsSync60 } from "fs";
 import { readdir as readdir4 } from "fs/promises";
-import path39 from "path";
+import path40 from "path";
 import "commander";
 import {
   diffContract,
@@ -12627,7 +12677,7 @@ function registerSnapshot(program2) {
       return;
     }
     if (opts.list) {
-      const contractsDir = path39.join(paths.haiveDir, "contracts");
+      const contractsDir = path40.join(paths.haiveDir, "contracts");
       if (!existsSync60(contractsDir)) {
         console.log(ui.dim("No contract snapshots found."));
         return;
@@ -12683,7 +12733,7 @@ function registerSnapshot(program2) {
       return;
     }
     const contractPath = opts.contract;
-    const name = opts.name ?? path39.basename(contractPath, path39.extname(contractPath));
+    const name = opts.name ?? path40.basename(contractPath, path40.extname(contractPath));
     const format = opts.format ?? detectFormat(contractPath) ?? "openapi";
     const contract = { name, path: contractPath, format };
     try {
@@ -12738,8 +12788,8 @@ async function runDiff(root, haiveDir, contract) {
   }
 }
 function detectFormat(filePath) {
-  const ext = path39.extname(filePath).toLowerCase();
-  const base = path39.basename(filePath).toLowerCase();
+  const ext = path40.extname(filePath).toLowerCase();
+  const base = path40.basename(filePath).toLowerCase();
   if (ext === ".yaml" || ext === ".yml" || ext === ".json") {
     if (base.includes("openapi") || base.includes("swagger")) return "openapi";
     if (base.includes("schema") || base.includes("graphql")) return "graphql";
@@ -12754,7 +12804,7 @@ function detectFormat(filePath) {
 // src/commands/hub.ts
 import { existsSync as existsSync61 } from "fs";
 import { mkdir as mkdir17, readFile as readFile19, writeFile as writeFile29, copyFile } from "fs/promises";
-import path40 from "path";
+import path41 from "path";
 import { spawnSync as spawnSync5 } from "child_process";
 import "commander";
 import {
@@ -12773,7 +12823,7 @@ function registerHub(program2) {
   hub.command("init <hubPath>").description(
     "Initialize a new team-knowledge hub repo at <hubPath>.\n\n  Creates a git repo with a .ai/ directory structure ready for shared memories.\n\n  Example:\n    haive hub init ../team-hub\n    haive hub init /srv/git/team-knowledge\n"
   ).action(async (hubPath) => {
-    const absPath = path40.resolve(hubPath);
+    const absPath = path41.resolve(hubPath);
     await mkdir17(absPath, { recursive: true });
     const gitCheck = spawnSync5("git", ["rev-parse", "--git-dir"], { cwd: absPath });
     if (gitCheck.status !== 0) {
@@ -12784,10 +12834,10 @@ function registerHub(program2) {
         return;
       }
     }
-    const sharedDir = path40.join(absPath, ".ai", "memories", "shared");
+    const sharedDir = path41.join(absPath, ".ai", "memories", "shared");
     await mkdir17(sharedDir, { recursive: true });
     await writeFile29(
-      path40.join(absPath, ".ai", "README.md"),
+      path41.join(absPath, ".ai", "README.md"),
       `# hAIve Team Knowledge Hub
 
 This repo is a shared knowledge hub for hAIve.
@@ -12809,7 +12859,7 @@ haive hub pull   # import into a project
       "utf8"
     );
     await writeFile29(
-      path40.join(absPath, ".gitignore"),
+      path41.join(absPath, ".gitignore"),
       ".ai/.cache/\n.ai/memories/personal/\n",
       "utf8"
     );
@@ -12824,7 +12874,7 @@ haive hub pull   # import into a project
         `
 Next steps:
   1. Add hubPath to your project's .ai/haive.config.json:
-       { "hubPath": "${path40.relative(process.cwd(), absPath)}" }
+       { "hubPath": "${path41.relative(process.cwd(), absPath)}" }
   2. Run \`haive hub push\` to publish your shared memories
   3. Share ${absPath} with teammates (git remote, NFS, etc.)
 `
@@ -12853,14 +12903,14 @@ Next steps:
       process.exitCode = 1;
       return;
     }
-    const hubRoot = path40.resolve(root, config.hubPath);
+    const hubRoot = path41.resolve(root, config.hubPath);
     if (!existsSync61(hubRoot)) {
       ui.error(`Hub not found at ${hubRoot}. Run \`haive hub init ${config.hubPath}\` first.`);
       process.exitCode = 1;
       return;
     }
-    const projectName = path40.basename(root);
-    const destDir = path40.join(hubRoot, ".ai", "memories", "shared", projectName);
+    const projectName = path41.basename(root);
+    const destDir = path41.join(hubRoot, ".ai", "memories", "shared", projectName);
     await mkdir17(destDir, { recursive: true });
     const all = await loadMemoriesFromDir30(paths.memoriesDir);
     const shared = all.filter(
@@ -12879,7 +12929,7 @@ Next steps:
     for (const { memory: memory2 } of shared) {
       const fm = memory2.frontmatter;
       const fileName = `${fm.id}.md`;
-      const destPath = path40.join(destDir, fileName);
+      const destPath = path41.join(destDir, fileName);
       await writeFile29(destPath, serializeMemory26(memory2), "utf8");
       pushed++;
     }
@@ -12887,7 +12937,7 @@ Next steps:
     console.log(ui.dim(`  Location: ${destDir}`));
     if (opts.commit) {
       const message = opts.message ?? `haive: sync shared memories from ${projectName} (${pushed} memories)`;
-      spawnSync5("git", ["add", path40.join(".ai", "memories", "shared", projectName)], {
+      spawnSync5("git", ["add", path41.join(".ai", "memories", "shared", projectName)], {
         cwd: hubRoot
       });
       const commit = spawnSync5("git", ["commit", "-m", message], {
@@ -12922,13 +12972,13 @@ Next steps:
       process.exitCode = 1;
       return;
     }
-    const hubRoot = path40.resolve(root, config.hubPath);
-    const hubSharedDir = path40.join(hubRoot, ".ai", "memories", "shared");
+    const hubRoot = path41.resolve(root, config.hubPath);
+    const hubSharedDir = path41.join(hubRoot, ".ai", "memories", "shared");
     if (!existsSync61(hubSharedDir)) {
       ui.warn("Hub has no shared memories yet. Run `haive hub push` from other projects first.");
       return;
     }
-    const projectName = path40.basename(root);
+    const projectName = path41.basename(root);
     const { readdir: readdir7 } = await import("fs/promises");
     const projectDirs = (await readdir7(hubSharedDir, { withFileTypes: true })).filter((d) => d.isDirectory() && d.name !== projectName).map((d) => d.name);
     if (projectDirs.length === 0) {
@@ -12938,16 +12988,16 @@ Next steps:
     let totalImported = 0;
     let totalUpdated = 0;
     for (const sourceName of projectDirs) {
-      const sourceDir = path40.join(hubSharedDir, sourceName);
-      const destDir = path40.join(paths.memoriesDir, "shared", sourceName);
+      const sourceDir = path41.join(hubSharedDir, sourceName);
+      const destDir = path41.join(paths.memoriesDir, "shared", sourceName);
       await mkdir17(destDir, { recursive: true });
       const sourceFiles = (await readdir7(sourceDir)).filter((f) => f.endsWith(".md"));
       const { loadMemoriesFromDir: loadDir } = await import("@hiveai/core");
       const existingInDest = await loadDir(destDir);
       const existingIds = new Set(existingInDest.map(({ memory: memory2 }) => memory2.frontmatter.id));
       for (const file of sourceFiles) {
-        const srcPath = path40.join(sourceDir, file);
-        const destPath = path40.join(destDir, file);
+        const srcPath = path41.join(sourceDir, file);
+        const destPath = path41.join(destDir, file);
         const fileContent = await readFile19(srcPath, "utf8");
         const alreadyTagged = fileContent.includes(`cross-repo:${sourceName}`);
         if (!alreadyTagged) {
@@ -12978,14 +13028,14 @@ Next steps:
     console.log(
       `  hubPath: ${config.hubPath ? ui.green(config.hubPath) : ui.dim("not configured")}`
     );
-    const sharedDir = path40.join(paths.memoriesDir, "shared");
+    const sharedDir = path41.join(paths.memoriesDir, "shared");
     if (existsSync61(sharedDir)) {
       const { readdir: readdir7 } = await import("fs/promises");
       const sources = (await readdir7(sharedDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
       console.log(`
   Imported from ${sources.length} source(s):`);
       for (const src of sources) {
-        const files = (await readdir7(path40.join(sharedDir, src))).filter((f) => f.endsWith(".md"));
+        const files = (await readdir7(path41.join(sharedDir, src))).filter((f) => f.endsWith(".md"));
         console.log(`    ${src}: ${files.length} memor${files.length === 1 ? "y" : "ies"}`);
       }
     } else {
@@ -13010,7 +13060,7 @@ Next steps:
 import "commander";
 import { existsSync as existsSync63 } from "fs";
 import { mkdir as mkdir18, writeFile as writeFile30 } from "fs/promises";
-import path41 from "path";
+import path43 from "path";
 import {
   aggregateUsage,
   findProjectRoot as findProjectRoot39,
@@ -13082,7 +13132,7 @@ function registerStats(program2) {
   });
 }
 async function writeRoiReport(paths, root, sinceRaw, outRelative) {
-  const outAbs = path41.isAbsolute(outRelative) ? path41.resolve(outRelative) : path41.resolve(root, outRelative);
+  const outAbs = path43.isAbsolute(outRelative) ? path43.resolve(outRelative) : path43.resolve(root, outRelative);
   const size = await usageLogSize(paths);
   let events = await readUsageEvents2(paths);
   let memoryCount = { team: 0, personal: 0, total_skipped_session: 0 };
@@ -13117,7 +13167,7 @@ async function writeRoiReport(paths, root, sinceRaw, outRelative) {
     ui.warn("Usage log missing or empty \u2014 report still written with partial data.");
     events = [];
   }
-  await mkdir18(path41.dirname(outAbs), { recursive: true });
+  await mkdir18(path43.dirname(outAbs), { recursive: true });
   const payload = {
     generated_at: (/* @__PURE__ */ new Date()).toISOString(),
     project_root: root,
@@ -13308,7 +13358,7 @@ function summarize(name, t0, payload, notes) {
 // src/commands/benchmark.ts
 import { existsSync as existsSync64 } from "fs";
 import { readdir as readdir5, readFile as readFile20, writeFile as writeFile31 } from "fs/promises";
-import path43 from "path";
+import path44 from "path";
 import "commander";
 import { estimateTokens as estimateTokens4, findProjectRoot as findProjectRoot41 } from "@hiveai/core";
 function registerBenchmark(program2) {
@@ -13323,9 +13373,9 @@ function registerBenchmark(program2) {
     }
     const markdown = renderMarkdown(root, summary, rows);
     if (opts.out) {
-      const outFile = path43.isAbsolute(opts.out) ? opts.out : path43.join(root, opts.out);
+      const outFile = path44.isAbsolute(opts.out) ? opts.out : path44.join(root, opts.out);
       await writeFile31(outFile, markdown, "utf8");
-      ui.success(`wrote ${path43.relative(process.cwd(), outFile)}`);
+      ui.success(`wrote ${path44.relative(process.cwd(), outFile)}`);
       return;
     }
     console.log(markdown);
@@ -13349,9 +13399,9 @@ function registerBenchmark(program2) {
 }
 function resolveBenchmarkRoot(dir) {
   const candidate = dir ?? "benchmarks/agent-benchmark";
-  if (path43.isAbsolute(candidate)) return candidate;
+  if (path44.isAbsolute(candidate)) return candidate;
   const projectRoot = findProjectRoot41(process.cwd());
-  return path43.join(projectRoot, candidate);
+  return path44.join(projectRoot, candidate);
 }
 async function collectRows(root) {
   if (!existsSync64(root)) throw new Error(`Benchmark directory not found: ${root}`);
@@ -13359,8 +13409,8 @@ async function collectRows(root) {
   const rows = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const fixtureDir = path43.join(root, entry.name);
-    const reportFile = path43.join(fixtureDir, "BENCHMARK_AGENT_REPORT.md");
+    const fixtureDir = path44.join(root, entry.name);
+    const reportFile = path44.join(fixtureDir, "BENCHMARK_AGENT_REPORT.md");
     if (!existsSync64(reportFile)) continue;
     const report = await readFile20(reportFile, "utf8");
     rows.push(parseAgentReport(entry.name, report));
@@ -13378,7 +13428,7 @@ function parseAgentReport(fixture, report) {
     test_iterations: countMatches(section(report, "Test Iterations"), /Iteration\s+\d+|^- /gim),
     terminal_failures: countMatches(section(report, "Terminal Errors"), /fail|error|not raised|exited with code 1/gi),
     decision_mentions: sectionBulletCount(report, "Key Decisions"),
-    token_proxy: estimateTokens4(report),
+    report_tokens_est: estimateTokens4(report),
     haive_impact: /hAIve Memory Impact[\s\S]*?\b(yes|directly|changed|shaped|confirmed)\b/i.test(report)
   };
 }
@@ -13400,7 +13450,7 @@ function summarizeGroup(rows) {
     test_iterations: sum("test_iterations"),
     terminal_failures: sum("terminal_failures"),
     decision_mentions: sum("decision_mentions"),
-    token_proxy: sum("token_proxy"),
+    report_tokens_est: sum("report_tokens_est"),
     haive_impact_count: rows.filter((r) => r.haive_impact).length
   };
 }
@@ -13412,29 +13462,31 @@ function renderMarkdown(root, summary, rows) {
     "",
     "## Summary",
     "",
-    "| Group | Fixtures | Commands | Files read | Files modified | Test iterations | Terminal failures | Decision mentions | Token proxy | hAIve impact |",
+    "| Group | Fixtures | Commands | Files read | Files modified | Test iterations | Terminal failures | Decision mentions | Report tokens (est, report only) | hAIve impact |",
     "| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |",
     groupLine("hAIve", summary.haive),
     groupLine("Plain", summary.plain),
     "",
     "## Fixtures",
     "",
-    "| Fixture | Group | Commands | Files read | Files modified | Test iterations | Terminal failures | Decisions | Token proxy | hAIve impact |",
+    "| Fixture | Group | Commands | Files read | Files modified | Test iterations | Terminal failures | Decisions | Report tokens (est, report only) | hAIve impact |",
     "| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- |",
     ...rows.map(
-      (row) => `| \`${row.fixture}\` | ${row.group} | ${row.commands} | ${row.files_read} | ${row.files_modified} | ${row.test_iterations} | ${row.terminal_failures} | ${row.decision_mentions} | ${row.token_proxy} | ${row.haive_impact ? "yes" : "no"} |`
+      (row) => `| \`${row.fixture}\` | ${row.group} | ${row.commands} | ${row.files_read} | ${row.files_modified} | ${row.test_iterations} | ${row.terminal_failures} | ${row.decision_mentions} | ${row.report_tokens_est} | ${row.haive_impact ? "yes" : "no"} |`
     ),
     "",
     "## Reading",
     "",
-    "The token proxy is estimated from the agent report size, not from private model billing data.",
+    "`Report tokens (est)` estimates the size of the agent's WRITTEN REPORT only \u2014 a verbosity proxy, NOT",
+    "the agent's total token consumption. For real per-agent token/latency, capture your runner's telemetry",
+    "(e.g. subagent token counts) separately; this report can't see model billing.",
     "Use this report to compare relative effort and decision quality, then pair it with final test results and a human review of the diffs.",
     ""
   ];
   return lines.join("\n");
 }
 function groupLine(label, group) {
-  return `| ${label} | ${group.fixtures} | ${group.commands} | ${group.files_read} | ${group.files_modified} | ${group.test_iterations} | ${group.terminal_failures} | ${group.decision_mentions} | ${group.token_proxy} | ${group.haive_impact_count} |`;
+  return `| ${label} | ${group.fixtures} | ${group.commands} | ${group.files_read} | ${group.files_modified} | ${group.test_iterations} | ${group.terminal_failures} | ${group.decision_mentions} | ${group.report_tokens_est} | ${group.haive_impact_count} |`;
 }
 function sectionBulletCount(markdown, title) {
   return countMatches(section(markdown, title), /^- |^\d+\.\s/gm);
@@ -13453,7 +13505,7 @@ function escapeRegExp(value) {
 // src/commands/eval.ts
 import { mkdir as mkdir19, readFile as readFile21, writeFile as writeFile33 } from "fs/promises";
 import { existsSync as existsSync65 } from "fs";
-import path44 from "path";
+import path45 from "path";
 import "commander";
 import {
   aggregateRetrieval,
@@ -13549,7 +13601,7 @@ function registerEval(program2) {
       });
       if (!opts.json) ui.success(`Recorded eval score ${report.score}/100 to history.`);
     }
-    const baselineFile = opts.baselineFile ? path44.isAbsolute(opts.baselineFile) ? opts.baselineFile : path44.join(root, opts.baselineFile) : path44.join(root, ".ai", "eval", "baseline.json");
+    const baselineFile = opts.baselineFile ? path45.isAbsolute(opts.baselineFile) ? opts.baselineFile : path45.join(root, opts.baselineFile) : path45.join(root, ".ai", "eval", "baseline.json");
     if (opts.baseline) {
       const snapshot = {
         saved_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -13558,18 +13610,18 @@ function registerEval(program2) {
         report,
         gate_precision: gatePrecision
       };
-      await mkdir19(path44.dirname(baselineFile), { recursive: true });
+      await mkdir19(path45.dirname(baselineFile), { recursive: true });
       await writeFile33(baselineFile, JSON.stringify(snapshot, null, 2), "utf8");
-      if (!opts.json) ui.success(`Saved baseline (score ${report.score}/100) \u2192 ${path44.relative(root, baselineFile)}`);
+      if (!opts.json) ui.success(`Saved baseline (score ${report.score}/100) \u2192 ${path45.relative(root, baselineFile)}`);
     }
     let delta = null;
     let gateDelta = null;
     if (opts.compare || opts.regressionGate) {
       if (!existsSync65(baselineFile)) {
         if (opts.regressionGate) {
-          if (!opts.json) ui.info(`No baseline at ${path44.relative(root, baselineFile)} \u2014 regression gate skipped. Run \`haive eval --baseline\` to enable it.`);
+          if (!opts.json) ui.info(`No baseline at ${path45.relative(root, baselineFile)} \u2014 regression gate skipped. Run \`haive eval --baseline\` to enable it.`);
         } else {
-          ui.error(`No baseline at ${path44.relative(root, baselineFile)}. Run \`haive eval --baseline\` first.`);
+          ui.error(`No baseline at ${path45.relative(root, baselineFile)}. Run \`haive eval --baseline\` first.`);
           process.exitCode = 1;
           return;
         }
@@ -13586,6 +13638,7 @@ function registerEval(program2) {
         root,
         k,
         spec_source: resolvedSpec.source,
+        provenance: { synthesized: resolvedSpec.synthesized, authored: resolvedSpec.authored },
         report,
         gate_precision: gatePrecision,
         ...delta ? { delta } : {},
@@ -13594,17 +13647,22 @@ function registerEval(program2) {
       applyExitGates(opts, report, delta, gatePrecision, gateDelta);
       return;
     }
+    if (resolvedSpec.authored === 0 && resolvedSpec.synthesized > 0) {
+      ui.warn(
+        `All ${resolvedSpec.synthesized} case(s) are self-synthesized from your own memories (self-referential). Add hand-labeled cases in .ai/eval/spec.json, or run \`haive eval --spec <file>\`, for an independent score.`
+      );
+    }
     if (delta) {
       console.log(renderDelta(delta));
     }
     if (gateDelta) {
       console.log(renderGateDelta(gateDelta));
     }
-    const md = renderMarkdown2(root, k, resolvedSpec.source, report, gatePrecision);
+    const md = renderMarkdown2(root, k, resolvedSpec, report, gatePrecision);
     if (opts.out) {
-      const outFile = path44.isAbsolute(opts.out) ? opts.out : path44.join(root, opts.out);
+      const outFile = path45.isAbsolute(opts.out) ? opts.out : path45.join(root, opts.out);
       await writeFile33(outFile, md, "utf8");
-      ui.success(`wrote ${path44.relative(process.cwd(), outFile)}`);
+      ui.success(`wrote ${path45.relative(process.cwd(), outFile)}`);
     } else {
       console.log(md);
     }
@@ -13683,30 +13741,39 @@ function renderGateDelta(delta) {
   lines.push(`  rejections ${delta.rejections.baseline ?? "n/a"} \u2192 ${delta.rejections.current ?? "n/a"} ${ui.dim(`(${rejectionDelta})`)}`);
   return lines.join("\n");
 }
+function countCases(spec) {
+  return (spec.retrieval?.length ?? 0) + (spec.sensors?.length ?? 0);
+}
 async function resolveSpec(opts, root, memoriesDir) {
   if (opts.spec) {
-    const file = path44.resolve(opts.spec);
+    const file = path45.resolve(opts.spec);
     const raw = await readFile21(file, "utf8");
-    return { spec: JSON.parse(raw), source: file };
+    const spec = JSON.parse(raw);
+    return { spec, source: file, synthesized: 0, authored: countCases(spec) };
   }
-  const defaultSpec = path44.join(root, ".ai", "eval", "spec.json");
+  const defaultSpec = path45.join(root, ".ai", "eval", "spec.json");
   if (existsSync65(defaultSpec)) {
     const raw = await readFile21(defaultSpec, "utf8");
     const explicit = JSON.parse(raw);
     const memories2 = await loadMemoriesFromDir27(memoriesDir);
-    const synthesized = synthesizeSelfEvalCases(memories2, { includeFiles: !opts.semanticOnly });
+    const synthesized2 = synthesizeSelfEvalCases(memories2, { includeFiles: !opts.semanticOnly });
     return {
       spec: {
-        retrieval: [...synthesized, ...explicit.retrieval ?? []],
+        retrieval: [...synthesized2, ...explicit.retrieval ?? []],
         sensors: explicit.sensors ?? []
       },
-      source: ".ai/eval/spec.json + synthesized anchored retrieval"
+      source: ".ai/eval/spec.json + synthesized anchored retrieval",
+      synthesized: synthesized2.length,
+      authored: countCases(explicit)
     };
   }
   const memories = await loadMemoriesFromDir27(memoriesDir);
+  const synthesized = synthesizeSelfEvalCases(memories, { includeFiles: !opts.semanticOnly });
   return {
-    spec: { retrieval: synthesizeSelfEvalCases(memories, { includeFiles: !opts.semanticOnly }) },
-    source: "synthesized anchored retrieval"
+    spec: { retrieval: synthesized },
+    source: "synthesized anchored retrieval",
+    synthesized: synthesized.length,
+    authored: 0
   };
 }
 async function runRetrieval(c, k, ctx) {
@@ -13739,12 +13806,14 @@ async function runSensorCase(c, ctx) {
 function pct(n) {
   return `${Math.round(n * 100)}%`;
 }
-function renderMarkdown2(root, k, source, report, gatePrecision) {
+function renderMarkdown2(root, k, resolved, report, gatePrecision) {
+  const provenance = resolved.authored === 0 ? `${resolved.synthesized} synthesized (self-referential \u2014 sanity floor, not ground truth)` : resolved.synthesized === 0 ? `${resolved.authored} authored (independent ground truth)` : `${resolved.authored} authored (independent) + ${resolved.synthesized} synthesized (self-referential)`;
   const lines = [
     "# hAIve eval report",
     "",
     `Project: \`${root}\` \xB7 top-k: ${k}`,
-    `Spec: ${source}`,
+    `Spec: ${resolved.source}`,
+    `Cases: ${provenance}`,
     "",
     `## Overall score: ${report.score}/100`,
     ""
@@ -13803,7 +13872,7 @@ function renderMarkdown2(root, k, source, report, gatePrecision) {
 // src/commands/memory-suggest.ts
 import { mkdir as mkdir20, writeFile as writeFile34 } from "fs/promises";
 import { existsSync as existsSync66 } from "fs";
-import path45 from "path";
+import path46 from "path";
 import "commander";
 import {
   aggregateUsage as aggregateUsage2,
@@ -13904,13 +13973,13 @@ function registerMemorySuggest(memory2) {
         });
         const body = renderTemplate(s, fm.id, status);
         const file = memoryFilePath11(paths, fm.scope, fm.id, fm.module);
-        await mkdir20(path45.dirname(file), { recursive: true });
+        await mkdir20(path46.dirname(file), { recursive: true });
         if (existsSync66(file)) {
-          skipped.push({ query: s.query, reason: `file already exists at ${path45.relative(root, file)}` });
+          skipped.push({ query: s.query, reason: `file already exists at ${path46.relative(root, file)}` });
           continue;
         }
         await writeFile34(file, serializeMemory27({ frontmatter: fm, body }), "utf8");
-        created.push({ id: fm.id, file: path45.relative(root, file), query: s.query });
+        created.push({ id: fm.id, file: path46.relative(root, file), query: s.query });
       }
       if (opts.json) {
         console.log(JSON.stringify({ created, skipped }, null, 2));
@@ -14010,7 +14079,7 @@ function truncate2(text, max) {
 // src/commands/memory-archive.ts
 import { existsSync as existsSync67 } from "fs";
 import { writeFile as writeFile35 } from "fs/promises";
-import path46 from "path";
+import path47 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot44,
@@ -14054,7 +14123,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) => !existsSync67(path46.join(paths.root, p)));
+      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync67(path47.join(paths.root, p)));
       const isAnchorless = !hasAnyAnchor;
       if (!retired.retired && !opts.unread && !isAnchorless && !allPathsGone) continue;
       const u = getUsage21(usage, fm.id);
@@ -14131,7 +14200,7 @@ function parseDays(input) {
 // src/commands/doctor.ts
 import { existsSync as existsSync68, statSync as statSync2 } from "fs";
 import { readFile as readFile23, stat, writeFile as writeFile36 } from "fs/promises";
-import path47 from "path";
+import path48 from "path";
 import { execFileSync, execSync as execSync3 } from "child_process";
 import "commander";
 import {
@@ -14185,8 +14254,8 @@ function registerDoctor(program2) {
         fix: "haive init"
       });
     } else {
-      const { readFile: readFile28 } = await import("fs/promises");
-      const content = await readFile28(paths.projectContext, "utf8");
+      const { readFile: readFile29 } = await import("fs/promises");
+      const content = await readFile29(paths.projectContext, "utf8");
       const isTemplate = content.includes("TODO \u2014 high-level overview") || content.includes("Generated by `haive init`");
       if (isTemplate) {
         findings.push({
@@ -14356,12 +14425,12 @@ function registerDoctor(program2) {
       }
     }
     if (config.enforcement?.requireBriefingFirst) {
-      const claudeSettings = path47.join(root, ".claude", "settings.local.json");
+      const claudeSettings = path48.join(root, ".claude", "settings.local.json");
       let hasClaudeEnforcement = false;
       if (existsSync68(claudeSettings)) {
         try {
-          const { readFile: readFile28 } = await import("fs/promises");
-          const raw = await readFile28(claudeSettings, "utf8");
+          const { readFile: readFile29 } = await import("fs/promises");
+          const raw = await readFile29(claudeSettings, "utf8");
           hasClaudeEnforcement = raw.includes("haive enforce session-start") && raw.includes("haive enforce pre-tool-use");
         } catch {
           hasClaudeEnforcement = false;
@@ -14384,7 +14453,7 @@ function registerDoctor(program2) {
         fix: "Edit .ai/haive.config.json: set autoSessionEnd: true (or re-run `haive init` without --manual)."
       });
     }
-    findings.push(...await collectInstallFindings(root, "0.21.0"));
+    findings.push(...await collectInstallFindings(root, "0.24.0"));
     findings.push(...await collectToolchainFindings(root));
     try {
       const legacyRaw = execSync3("haive-mcp --version", {
@@ -14392,7 +14461,7 @@ function registerDoctor(program2) {
         timeout: 3e3,
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      const cliVersion = "0.21.0";
+      const cliVersion = "0.24.0";
       if (legacyRaw && legacyRaw !== cliVersion) {
         findings.push({
           severity: "warn",
@@ -14408,9 +14477,9 @@ npm uninstall -g @hiveai/mcp`
     }
     {
       const configPaths = [
-        path47.join(root, ".mcp.json"),
-        path47.join(root, ".cursor", "mcp.json"),
-        path47.join(root, ".vscode", "mcp.json")
+        path48.join(root, ".mcp.json"),
+        path48.join(root, ".cursor", "mcp.json"),
+        path48.join(root, ".vscode", "mcp.json")
       ];
       const staleConfigs = [];
       for (const cfgPath of configPaths) {
@@ -14418,7 +14487,7 @@ npm uninstall -g @hiveai/mcp`
         try {
           const raw = await readFile23(cfgPath, "utf8");
           if (raw.includes('"haive-mcp"') || raw.includes("'haive-mcp'")) {
-            staleConfigs.push(path47.relative(root, cfgPath));
+            staleConfigs.push(path48.relative(root, cfgPath));
             if (opts.fix && !opts.dryRun) {
               const updated = raw.replace(/"command"\s*:\s*"haive-mcp"/g, '"command": "haive"').replace(/"args"\s*:\s*\[\]/g, '"args": ["mcp", "--stdio"]');
               await writeFile36(cfgPath, updated, "utf8");
@@ -14709,7 +14778,7 @@ which -a haive`
     ".vscode/mcp.json"
   ];
   for (const rel of integrationFiles) {
-    const file = path47.join(root, rel);
+    const file = path48.join(root, rel);
     if (!existsSync68(file)) continue;
     const text = await readFile23(file, "utf8").catch(() => "");
     for (const bin of extractAbsoluteHaiveBins(text)) {
@@ -14736,7 +14805,7 @@ which -a haive`
 async function collectToolchainFindings(root) {
   const findings = [];
   const pkg = await readJson(
-    path47.join(root, "package.json")
+    path48.join(root, "package.json")
   );
   const wantsPnpm = pkg?.packageManager?.startsWith("pnpm@") || Object.values(pkg?.scripts ?? {}).some((script) => /\bpnpm\b/.test(script));
   if (!wantsPnpm) return findings;
@@ -14755,9 +14824,9 @@ async function collectToolchainFindings(root) {
 }
 async function collectDistFreshnessFindings(root, expectedVersion) {
   const findings = [];
-  const isHaiveWorkspace = (await readJson(path47.join(root, "package.json")))?.name === "haive-monorepo";
+  const isHaiveWorkspace = (await readJson(path48.join(root, "package.json")))?.name === "haive-monorepo";
   if (!isHaiveWorkspace) return findings;
-  const cliDist = path47.join(root, "packages/cli/dist/index.js");
+  const cliDist = path48.join(root, "packages/cli/dist/index.js");
   if (!existsSync68(cliDist)) {
     findings.push({
       severity: "warn",
@@ -14782,7 +14851,7 @@ async function collectDistFreshnessFindings(root, expectedVersion) {
     "packages/core/src/index.ts",
     "packages/mcp/src/server.ts",
     "packages/cli/src/index.ts"
-  ].map((rel) => path47.join(root, rel)).filter(existsSync68);
+  ].map((rel) => path48.join(root, rel)).filter(existsSync68);
   if (sourceFiles.length > 0) {
     const distMtime = statSync2(cliDist).mtimeMs;
     const newestSource = Math.max(...sourceFiles.map((file) => statSync2(file).mtimeMs));
@@ -14800,7 +14869,7 @@ async function collectDistFreshnessFindings(root, expectedVersion) {
 }
 async function collectWorkspaceVersionFindings(root, expectedVersion) {
   const findings = [];
-  const rootPkg = await readJson(path47.join(root, "package.json"));
+  const rootPkg = await readJson(path48.join(root, "package.json"));
   const workspacePackages = [
     "packages/core/package.json",
     "packages/embeddings/package.json",
@@ -14809,7 +14878,7 @@ async function collectWorkspaceVersionFindings(root, expectedVersion) {
   ];
   const existing = (await Promise.all(workspacePackages.map(async (rel) => ({
     rel,
-    pkg: await readJson(path47.join(root, rel))
+    pkg: await readJson(path48.join(root, rel))
   })))).filter((item) => item.pkg);
   const isHaiveWorkspace = rootPkg?.name === "haive-monorepo" || existing.some((item) => item.pkg?.name?.startsWith("@hiveai/"));
   if (!isHaiveWorkspace) return findings;
@@ -15314,21 +15383,21 @@ function registerMemorySuggestTopic(memory2) {
 }
 
 // src/commands/resolve-project.ts
-import path48 from "path";
+import path49 from "path";
 import "commander";
 import { resolveProjectInfo as resolveProjectInfo2 } from "@hiveai/core";
 function registerResolveProject(program2) {
   program2.command("resolve-project").description(
     "Print JSON for hAIve project root resolution (HAIVE_PROJECT_ROOT, markers, .ai layout)."
   ).option("-d, --dir <dir>", "working directory", process.cwd()).action((opts) => {
-    const info = resolveProjectInfo2({ cwd: path48.resolve(opts.dir) });
+    const info = resolveProjectInfo2({ cwd: path49.resolve(opts.dir) });
     console.log(JSON.stringify({ ok: true, info }, null, 2));
   });
 }
 
 // src/commands/runtime-journal.ts
 import { existsSync as existsSync71 } from "fs";
-import path49 from "path";
+import path50 from "path";
 import "commander";
 import {
   appendRuntimeJournalEntry as appendRuntimeJournalEntry3,
@@ -15342,15 +15411,15 @@ function registerRuntime(program2) {
   );
   const journal = runtime.command("journal").description("Append or read the machine-local session journal (NDJSON)");
   journal.command("append").description("Append one JSON line to .ai/.runtime/session-journal.ndjson").argument("<message>", "short text to log").option("-k, --kind <kind>", "note | session_end | mcp", "note").option("-d, --dir <dir>", "project root", process.cwd()).action(async (message, opts) => {
-    const root = path49.resolve(opts.dir ?? process.cwd());
+    const root = path50.resolve(opts.dir ?? process.cwd());
     const paths = resolveHaivePaths45(findProjectRoot49(root));
     const raw = opts.kind ?? "note";
     const kind = ["note", "session_end", "mcp"].includes(raw) ? raw : "note";
     await appendRuntimeJournalEntry3(paths, { kind, message });
-    ui.success(`Appended to ${path49.relative(root, paths.runtimeDir)}/session-journal.ndjson`);
+    ui.success(`Appended to ${path50.relative(root, paths.runtimeDir)}/session-journal.ndjson`);
   });
   journal.command("tail").description("Print the last N entries from the runtime session journal as JSON").option("-n, --limit <n>", "number of lines", "30").option("-d, --dir <dir>", "project root", process.cwd()).action(async (opts) => {
-    const root = path49.resolve(opts.dir ?? process.cwd());
+    const root = path50.resolve(opts.dir ?? process.cwd());
     const paths = resolveHaivePaths45(findProjectRoot49(root));
     const limit = Math.min(500, Math.max(1, parseInt(opts.limit, 10) || 30));
     if (!existsSync71(paths.haiveDir)) {
@@ -15369,7 +15438,7 @@ function registerRuntime(program2) {
 
 // src/commands/memory-timeline.ts
 import { existsSync as existsSync73 } from "fs";
-import path50 from "path";
+import path51 from "path";
 import "commander";
 import {
   collectTimelineEntries as collectTimelineEntries2,
@@ -15385,7 +15454,7 @@ function registerMemoryTimeline(memory2) {
       process.exitCode = 1;
       return;
     }
-    const root = path50.resolve(opts.dir ?? process.cwd());
+    const root = path51.resolve(opts.dir ?? process.cwd());
     const paths = resolveHaivePaths46(findProjectRoot50(root));
     if (!existsSync73(paths.memoriesDir)) {
       ui.error("No memories \u2014 run `haive init`.");
@@ -15406,7 +15475,7 @@ function registerMemoryTimeline(memory2) {
 
 // src/commands/memory-conflict-candidates.ts
 import { existsSync as existsSync74 } from "fs";
-import path51 from "path";
+import path53 from "path";
 import "commander";
 import {
   findLexicalConflictPairs as findLexicalConflictPairs2,
@@ -15428,7 +15497,7 @@ function registerMemoryConflictCandidates(memory2) {
     "decision,architecture,convention,gotcha (lexical scan)",
     "decision,architecture"
   ).option("--min-jaccard <x>", "minimum Jaccard for lexical pairs", "0.45").option("--max-pairs <n>", "cap lexical pairs", "20").option("--max-scan <n>", "max memories scanned (lexical)", "500").option("--max-topic-pairs <n>", "cap topic/status pairs", "20").action(async (opts) => {
-    const root = path51.resolve(opts.dir ?? process.cwd());
+    const root = path53.resolve(opts.dir ?? process.cwd());
     const paths = resolveHaivePaths47(findProjectRoot51(root));
     if (!existsSync74(paths.memoriesDir)) {
       ui.error("No memories \u2014 run `haive init`.");
@@ -15465,10 +15534,11 @@ function registerMemoryConflictCandidates(memory2) {
 }
 
 // src/commands/enforce.ts
-import { execFileSync as execFileSync2, spawn as spawn6 } from "child_process";
+import { execFile as execFile3, execFileSync as execFileSync2, spawn as spawn6 } from "child_process";
 import { existsSync as existsSync75, statSync as statSync3 } from "fs";
 import { chmod as chmod2, mkdir as mkdir21, readFile as readFile24, readdir as readdir6, rm as rm3, writeFile as writeFile37 } from "fs/promises";
-import path53 from "path";
+import path54 from "path";
+import { promisify as promisify3 } from "util";
 import "commander";
 import {
   antiPatternGateParams as antiPatternGateParams2,
@@ -15482,15 +15552,18 @@ import {
   loadMemoriesFromDir as loadMemoriesFromDir38,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths6,
   readRecentBriefingMarker,
+  recordPreventionHits as recordPreventionHits2,
   resolveBriefingBudget as resolveBriefingBudget3,
   resolveHaivePaths as resolveHaivePaths48,
   runSensors as runSensors2,
   saveConfig as saveConfig4,
+  selectCommandSensors,
   sensorTargetsFromDiff as sensorTargetsFromDiff2,
   SESSION_RECAP_TTL_MS,
   verifyAnchor as verifyAnchor4,
   writeBriefingMarker as writeBriefingMarker3
 } from "@hiveai/core";
+var execFileAsync2 = promisify3(execFile3);
 var MAX_STDIN_BYTES2 = 256 * 1024;
 var ENFORCE_HOOK_MARKER = "# hAIve enforcement hook";
 function registerEnforce(program2) {
@@ -15524,7 +15597,7 @@ function registerEnforce(program2) {
     if (opts.claude !== false) {
       try {
         const result = await installClaudeHooksAtPath(defaultClaudeSettingsPath("project", root));
-        ui.success(`${result.created ? "Created" : "Patched"} Claude Code hooks (${path53.relative(root, result.settingsPath)})`);
+        ui.success(`${result.created ? "Created" : "Patched"} Claude Code hooks (${path54.relative(root, result.settingsPath)})`);
       } catch (err) {
         ui.warn(`Claude Code hooks not installed: ${err instanceof Error ? err.message : String(err)}`);
       }
@@ -15545,19 +15618,19 @@ function registerEnforce(program2) {
   enforce.command("cleanup").description("Remove generated hAIve runtime/cache artifacts that should not appear in commits.").option("-d, --dir <dir>", "project root").option("--dry-run", "print what would be removed without deleting", false).action(async (opts) => {
     const root = findProjectRoot52(opts.dir);
     const paths = resolveHaivePaths48(root);
-    const cacheDir = path53.join(paths.haiveDir, ".cache");
+    const cacheDir = path54.join(paths.haiveDir, ".cache");
     if (existsSync75(cacheDir)) {
-      if (opts.dryRun) ui.info(`would clean ${path53.relative(root, cacheDir)} (preserving .gitignore)`);
+      if (opts.dryRun) ui.info(`would clean ${path54.relative(root, cacheDir)} (preserving .gitignore)`);
       else {
         const removed = await cleanupCacheDir(cacheDir);
-        ui.success(`cleaned ${path53.relative(root, cacheDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
+        ui.success(`cleaned ${path54.relative(root, cacheDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
       }
     }
     if (existsSync75(paths.runtimeDir)) {
-      if (opts.dryRun) ui.info(`would clean ${path53.relative(root, paths.runtimeDir)} (preserving briefing markers)`);
+      if (opts.dryRun) ui.info(`would clean ${path54.relative(root, paths.runtimeDir)} (preserving briefing markers)`);
       else {
         const removed = await cleanupRuntimeDir(paths.runtimeDir);
-        ui.success(`cleaned ${path53.relative(root, paths.runtimeDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
+        ui.success(`cleaned ${path54.relative(root, paths.runtimeDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
       }
     }
   });
@@ -15910,7 +15983,7 @@ async function buildFinishReport(dir) {
 async function checkFailureCapture(paths, config) {
   const gate = config.enforcement?.failureCaptureGate ?? "warn";
   if (gate === "off") return [];
-  const obsFile = path53.join(paths.haiveDir, ".cache", "observations.jsonl");
+  const obsFile = path54.join(paths.haiveDir, ".cache", "observations.jsonl");
   if (!existsSync75(obsFile)) return [];
   const failures = [];
   try {
@@ -15982,7 +16055,7 @@ async function runWithEnforcement(command, args, opts) {
     process.exit(2);
   }
   ui.info(`hAIve briefing marker created for wrapped agent session: ${sessionId}`);
-  ui.info(`Briefing written to ${path53.relative(root, briefingFile)} and exported as HAIVE_BRIEFING_FILE`);
+  ui.info(`Briefing written to ${path54.relative(root, briefingFile)} and exported as HAIVE_BRIEFING_FILE`);
   const child = spawn6(command, args, {
     cwd: root,
     stdio: "inherit",
@@ -16032,9 +16105,9 @@ async function writeWrapperBriefing(paths, sessionId, task) {
     source: "haive-run",
     memoryIds: briefing.memories.map((m) => m.id)
   });
-  const dir = path53.join(paths.runtimeDir, "enforcement", "briefings");
+  const dir = path54.join(paths.runtimeDir, "enforcement", "briefings");
   await mkdir21(dir, { recursive: true });
-  const file = path53.join(dir, `${sessionId}.md`);
+  const file = path54.join(dir, `${sessionId}.md`);
   const parts = [
     "# hAIve Briefing",
     "",
@@ -16092,7 +16165,7 @@ async function buildEnforcementReport(dir, stage, sessionId) {
       findings: [{ severity: "info", code: "enforcement-off", message: "hAIve enforcement is disabled." }]
     });
   }
-  findings.push(...await inspectIntegrationVersions(root, "0.21.0"));
+  findings.push(...await inspectIntegrationVersions(root, "0.24.0"));
   if (config.enforcement?.requireBriefingFirst !== false && stage !== "ci") {
     const hasBriefing = await hasRecentBriefingMarker2(paths, sessionId);
     findings.push(hasBriefing ? { severity: "ok", code: "briefing-loaded", message: "A recent hAIve briefing marker exists." } : {
@@ -16243,7 +16316,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(path53.relative(paths.root, filePath))) return false;
+    if (changedSet.has(path54.relative(paths.root, filePath))) return false;
     return true;
   }).map(({ memory: memory2 }) => memory2);
   if (missing.length === 0) {
@@ -16344,19 +16417,19 @@ async function runSensorGate(paths, diff) {
   if (!diff || !existsSync75(paths.memoriesDir)) return [];
   try {
     const loaded = await loadMemoriesFromDir38(paths.memoriesDir);
-    const sensorMemories = loaded.map((l) => l.memory).filter((m) => {
-      const s = m.frontmatter.sensor;
-      return Boolean(s) && s.kind === "regex" && !isRetiredMemory3(m.frontmatter, m.body);
-    });
-    if (sensorMemories.length === 0) return [];
+    const scannable = loaded.map((l) => l.memory).filter((m) => Boolean(m.frontmatter.sensor) && !isRetiredMemory3(m.frontmatter, m.body));
+    if (scannable.length === 0) return [];
     const targets = sensorTargetsFromDiff2(diff).filter((t) => isSensorScannablePath(t.path));
     if (targets.length === 0) return [];
-    const hits = runSensors2(sensorMemories, targets);
     const findings = [];
     const seen = /* @__PURE__ */ new Set();
+    const firedIds = /* @__PURE__ */ new Set();
+    const regexSensorMemories = scannable.filter((m) => m.frontmatter.sensor.kind === "regex");
+    const hits = regexSensorMemories.length > 0 ? runSensors2(regexSensorMemories, targets) : [];
     for (const hit of hits) {
       if (seen.has(hit.memory_id)) continue;
       seen.add(hit.memory_id);
+      firedIds.add(hit.memory_id);
       const where = hit.file ? ` (${hit.file})` : "";
       if (hit.severity === "block") {
         findings.push({
@@ -16376,11 +16449,51 @@ async function runSensorGate(paths, diff) {
         });
       }
     }
+    const config = await loadConfig14(paths).catch(() => null);
+    if (config?.enforcement?.runCommandSensors === true) {
+      const changedPaths = targets.map((t) => t.path).filter(Boolean);
+      for (const spec of selectCommandSensors(scannable, changedPaths)) {
+        if (seen.has(spec.memory_id)) continue;
+        const failed = await runGateCommandSensor(spec, paths.root);
+        if (!failed) continue;
+        seen.add(spec.memory_id);
+        firedIds.add(spec.memory_id);
+        if (spec.severity === "block") {
+          findings.push({
+            severity: "error",
+            code: "sensor-block",
+            message: `Block command sensor fired \u2014 ${spec.memory_id}: ${spec.message} (command: ${spec.command})`,
+            fix: "Fix the condition the command checks, or run `haive sensors check --commands` to inspect it.",
+            impact: 45
+          });
+        } else {
+          findings.push({
+            severity: "warn",
+            code: "sensor-warn",
+            message: `Command sensor flagged ${spec.memory_id}: ${spec.message}`,
+            fix: "Review the failing command; `haive sensors check --commands` re-runs it.",
+            impact: 5
+          });
+        }
+      }
+    }
+    if (firedIds.size > 0) {
+      await recordPreventionHits2(paths, [...firedIds], "sensor").catch(() => {
+      });
+    }
     return findings;
   } catch {
     return [];
   }
 }
+async function runGateCommandSensor(spec, root) {
+  try {
+    await execFileAsync2("bash", ["-c", spec.command], { cwd: root, timeout: 12e4, maxBuffer: 8 * 1024 * 1024 });
+    return false;
+  } catch {
+    return true;
+  }
+}
 async function findGeneratedArtifacts(paths) {
   const dirty = await runCommand4("git", ["status", "--short", "--untracked-files=all"], paths.root).catch(() => "");
   const generated = dirty.split("\n").map((line) => line.trim()).filter(Boolean).filter(
@@ -16411,16 +16524,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(path53.join(runtimeDir, entry.name));
+      removed += await cleanupEnforcementDir(path54.join(runtimeDir, entry.name));
       continue;
     }
-    await rm3(path53.join(runtimeDir, entry.name), { recursive: true, force: true });
+    await rm3(path54.join(runtimeDir, entry.name), { recursive: true, force: true });
     removed++;
   }
-  await writeFile37(path53.join(runtimeDir, ".gitignore"), "*\n!.gitignore\n!README.md\n", "utf8");
-  if (!existsSync75(path53.join(runtimeDir, "README.md"))) {
+  await writeFile37(path54.join(runtimeDir, ".gitignore"), "*\n!.gitignore\n!README.md\n", "utf8");
+  if (!existsSync75(path54.join(runtimeDir, "README.md"))) {
     await writeFile37(
-      path53.join(runtimeDir, "README.md"),
+      path54.join(runtimeDir, "README.md"),
       "# .ai/.runtime \u2014 disposable local layer\n\nRuntime data is local. hAIve cleanup preserves briefing markers so enforcement state remains valid.\n",
       "utf8"
     );
@@ -16433,10 +16546,10 @@ async function cleanupCacheDir(cacheDir) {
   const entries = await readdir6(cacheDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.name === ".gitignore") continue;
-    await rm3(path53.join(cacheDir, entry.name), { recursive: true, force: true });
+    await rm3(path54.join(cacheDir, entry.name), { recursive: true, force: true });
     removed++;
   }
-  await writeFile37(path53.join(cacheDir, ".gitignore"), "*\n!.gitignore\n", "utf8");
+  await writeFile37(path54.join(cacheDir, ".gitignore"), "*\n!.gitignore\n", "utf8");
   return removed;
 }
 async function cleanupEnforcementDir(enforcementDir) {
@@ -16444,7 +16557,7 @@ async function cleanupEnforcementDir(enforcementDir) {
   const entries = await readdir6(enforcementDir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     if (entry.name === "briefings") continue;
-    await rm3(path53.join(enforcementDir, entry.name), { recursive: true, force: true });
+    await rm3(path54.join(enforcementDir, entry.name), { recursive: true, force: true });
     removed++;
   }
   return removed;
@@ -16460,7 +16573,7 @@ async function inspectIntegrationVersions(root, expectedVersion) {
   ];
   const findings = [];
   for (const rel of files) {
-    const file = path53.join(root, rel);
+    const file = path54.join(root, rel);
     if (!existsSync75(file)) continue;
     const text = await readFile24(file, "utf8").catch(() => "");
     for (const bin of extractAbsoluteHaiveBins2(text)) {
@@ -16676,7 +16789,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 = path53.isAbsolute(msgfile) ? msgfile : path53.join(root, msgfile);
+  const file = path54.isAbsolute(msgfile) ? msgfile : path54.join(root, msgfile);
   const raw = await readFile24(file, "utf8").catch(() => "");
   const cleaned = raw.split("\n").filter((line) => !line.startsWith("#")).join("\n");
   if (!CI_SKIP_DIRECTIVE.test(cleaned)) return { block: false, message: "" };
@@ -16705,7 +16818,7 @@ async function inspectReleaseVersionState(root, upstream) {
 }
 async function readPackageVersion(root, relPath) {
   try {
-    const data = JSON.parse(await readFile24(path53.join(root, relPath), "utf8"));
+    const data = JSON.parse(await readFile24(path54.join(root, relPath), "utf8"));
     return typeof data.version === "string" ? data.version : void 0;
   } catch {
     return void 0;
@@ -16893,8 +17006,8 @@ function buildScore(findings, threshold = 80) {
   };
 }
 async function installGitEnforcement(root) {
-  const hooksDir = path53.join(root, ".git", "hooks");
-  if (!existsSync75(path53.join(root, ".git"))) {
+  const hooksDir = path54.join(root, ".git", "hooks");
+  if (!existsSync75(path54.join(root, ".git"))) {
     ui.warn("No .git directory found; git enforcement hooks skipped.");
     return;
   }
@@ -16923,7 +17036,7 @@ haive enforce commit-msg "$1" --dir . || exit $?
     }
   ];
   for (const hook of hooks) {
-    const file = path53.join(hooksDir, hook.name);
+    const file = path54.join(hooksDir, hook.name);
     if (existsSync75(file)) {
       const current = await readFile24(file, "utf8").catch(() => "");
       if (current.includes(ENFORCE_HOOK_MARKER)) {
@@ -16941,8 +17054,8 @@ ${hook.body}`, "utf8");
   ui.success("Installed blocking git enforcement hooks: pre-commit, pre-push, commit-msg");
 }
 async function installCiEnforcement(root) {
-  const workflowPath = path53.join(root, ".github", "workflows", "haive-enforcement.yml");
-  await mkdir21(path53.dirname(workflowPath), { recursive: true });
+  const workflowPath = path54.join(root, ".github", "workflows", "haive-enforcement.yml");
+  await mkdir21(path54.dirname(workflowPath), { recursive: true });
   if (existsSync75(workflowPath)) {
     ui.info("GitHub Actions enforcement workflow already exists \u2014 skipped");
     return;
@@ -16974,7 +17087,7 @@ jobs:
           HAIVE_HEAD_SHA: \${{ github.event.pull_request.head.sha || github.sha }}
         run: haive enforce ci
 `, "utf8");
-  ui.success(`Created ${path53.relative(root, workflowPath)}`);
+  ui.success(`Created ${path54.relative(root, workflowPath)}`);
 }
 function printReport(report, json, explain = false) {
   if (json) {
@@ -17078,8 +17191,8 @@ function extractToolPaths(payload, root) {
 }
 function normalizeToolPath(file, root) {
   const normalized = file.replace(/\\/g, "/");
-  if (!path53.isAbsolute(normalized)) return normalized.replace(/^\.\//, "");
-  return path53.relative(root, normalized).replace(/\\/g, "/");
+  if (!path54.isAbsolute(normalized)) return normalized.replace(/^\.\//, "");
+  return path54.relative(root, normalized).replace(/\\/g, "/");
 }
 async function missingRequiredMemoriesForFiles(paths, files, sessionId) {
   if (!existsSync75(paths.memoriesDir)) return [];
@@ -17127,7 +17240,7 @@ async function readStdin2(maxBytes) {
 }
 var ATOMIC_STAGE_EXCLUDE = ["/.usage/", "/.runtime/", "/.cache/"];
 async function stageResyncedArtifacts(root, paths) {
-  const aiRel = path53.relative(root, paths.haiveDir);
+  const aiRel = path54.relative(root, paths.haiveDir);
   const out = await runCommand4("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;
@@ -17166,28 +17279,25 @@ function registerRun(program2) {
 }
 
 // src/commands/sensors.ts
-import { execFile as execFile3 } from "child_process";
+import { execFile as execFile4 } from "child_process";
 import { existsSync as existsSync76 } from "fs";
 import { chmod as chmod3, mkdir as mkdir23, readFile as readFile25, writeFile as writeFile38 } from "fs/promises";
-import path54 from "path";
-import { promisify as promisify3 } from "util";
+import path55 from "path";
+import { promisify as promisify4 } from "util";
 import "commander";
 import {
-  appendPreventionEvent as appendPreventionEvent2,
   findProjectRoot as findProjectRoot53,
   isRetiredMemory as isRetiredMemory4,
   loadConfig as loadConfig15,
   loadMemoriesFromDir as loadMemoriesFromDir39,
-  loadUsageIndex as loadUsageIndex31,
-  recordPrevention as recordPrevention2,
+  recordPreventionHits as recordPreventionHits3,
   resolveHaivePaths as resolveHaivePaths49,
   runSensors as runSensors3,
-  saveUsageIndex as saveUsageIndex8,
-  selectCommandSensors,
+  selectCommandSensors as selectCommandSensors2,
   sensorTargetsFromDiff as sensorTargetsFromDiff3,
   serializeMemory as serializeMemory29
 } from "@hiveai/core";
-var exec2 = promisify3(execFile3);
+var exec2 = promisify4(execFile4);
 function registerSensors(program2) {
   const sensors = program2.command("sensors").description("Operate executable sensors derived from hAIve memories");
   sensors.command("list").description("List memories carrying executable sensors").option("--json", "emit JSON", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
@@ -17217,14 +17327,14 @@ function registerSensors(program2) {
     const root = findProjectRoot53(opts.dir);
     const paths = resolveHaivePaths49(root);
     const memories = await runnableSensorMemories(paths);
-    const diff = opts.diffFile ? await readFile25(path54.resolve(root, opts.diffFile), "utf8") : await stagedDiff(root);
+    const diff = opts.diffFile ? await readFile25(path55.resolve(root, opts.diffFile), "utf8") : await stagedDiff(root);
     const targets = sensorTargetsFromDiff3(diff);
     const hits = runSensors3(memories, targets.length > 0 ? targets : [{ path: "", content: diff }]);
     const config = await loadConfig15(paths);
     const runCommands = opts.commands || config.enforcement?.runCommandSensors === true;
     const changedPaths = targets.map((t) => t.path).filter(Boolean);
     const allSensorMemories = await runnableSensorMemories(paths, false);
-    const commandSpecs = selectCommandSensors(allSensorMemories, changedPaths);
+    const commandSpecs = selectCommandSensors2(allSensorMemories, changedPaths);
     const commandHits = [];
     const commandSkipped = [];
     if (commandSpecs.length > 0 && runCommands) {
@@ -17243,20 +17353,7 @@ function registerSensors(program2) {
       for (const spec of commandSpecs) commandSkipped.push(spec.memory_id);
     }
     const firedIds = [...new Set([...hits, ...commandHits].map((hit) => hit.memory_id))];
-    if (firedIds.length > 0) {
-      const usage = await loadUsageIndex31(paths);
-      const recordedIds = [];
-      for (const id of firedIds) if (recordPrevention2(usage, id)) recordedIds.push(id);
-      if (recordedIds.length > 0) {
-        await saveUsageIndex8(paths, usage).catch(() => {
-        });
-        const at = (/* @__PURE__ */ new Date()).toISOString();
-        for (const id of recordedIds) {
-          await appendPreventionEvent2(paths, { at, id, source: "sensor" }).catch(() => {
-          });
-        }
-      }
-    }
+    await recordPreventionHits3(paths, firedIds, "sensor");
     const output = {
       scanned: memories.length,
       hits: hits.map((hit) => ({
@@ -17342,13 +17439,13 @@ function registerSensors(program2) {
     const root = findProjectRoot53(opts.dir);
     const paths = resolveHaivePaths49(root);
     const rows = await sensorRows(paths);
-    const outDir = path54.resolve(root, opts.outDir ?? ".ai/generated");
+    const outDir = path55.resolve(root, opts.outDir ?? ".ai/generated");
     await mkdir23(outDir, { recursive: true });
-    const outPath = path54.join(outDir, format === "grep" ? "haive-sensors-grep.sh" : "haive-sensors-eslint.json");
+    const outPath = path55.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 writeFile38(outPath, content, "utf8");
     if (format === "grep") await chmod3(outPath, 493);
-    ui.success(`Exported ${rows.length} sensor(s): ${path54.relative(root, outPath)}`);
+    ui.success(`Exported ${rows.length} sensor(s): ${path55.relative(root, outPath)}`);
   });
 }
 async function sensorRows(paths) {
@@ -17421,7 +17518,7 @@ function shellQuote(value) {
 // src/commands/ingest.ts
 import { existsSync as existsSync77 } from "fs";
 import { mkdir as mkdir24, readFile as readFile26, writeFile as writeFile39 } from "fs/promises";
-import path55 from "path";
+import path56 from "path";
 import "commander";
 import {
   draftsFromFindings as draftsFromFindings2,
@@ -17478,7 +17575,7 @@ function registerIngest(program2) {
         process.exitCode = 1;
         return;
       }
-      const reportPath = path55.resolve(root, file);
+      const reportPath = path56.resolve(root, file);
       if (!existsSync77(reportPath)) {
         ui.error(`Report file not found: ${reportPath}`);
         process.exitCode = 1;
@@ -17567,13 +17664,13 @@ function registerIngest(program2) {
       await writeDraft2(paths, draft);
       created++;
     }
-    ui.success(`Created ${created} proposed memory(ies) under ${path55.relative(root, paths.memoriesDir)}/`);
+    ui.success(`Created ${created} proposed memory(ies) under ${path56.relative(root, paths.memoriesDir)}/`);
     ui.info("Review with `haive memory pending`; promote sensors with `haive sensors promote <id> --yes`.");
   });
 }
 async function writeDraft2(paths, draft) {
   const file = memoryFilePath12(paths, draft.frontmatter.scope, draft.frontmatter.id, draft.frontmatter.module);
-  await mkdir24(path55.dirname(file), { recursive: true });
+  await mkdir24(path56.dirname(file), { recursive: true });
   await writeFile39(file, serializeMemory30({ frontmatter: draft.frontmatter, body: draft.body }), "utf8");
   return file;
 }
@@ -17623,7 +17720,7 @@ import {
   loadConfig as loadConfig16,
   loadMemoriesFromDir as loadMemoriesFromDir41,
   loadPreventionEvents as loadPreventionEvents4,
-  loadUsageIndex as loadUsageIndex33,
+  loadUsageIndex as loadUsageIndex31,
   resolveHaivePaths as resolveHaivePaths51
 } from "@hiveai/core";
 function registerDashboard(program2) {
@@ -17638,7 +17735,7 @@ function registerDashboard(program2) {
       return;
     }
     const memories = existsSync78(paths.memoriesDir) ? await loadMemoriesFromDir41(paths.memoriesDir) : [];
-    const usage = await loadUsageIndex33(paths);
+    const usage = await loadUsageIndex31(paths);
     const preventionEvents = await loadPreventionEvents4(paths);
     const config = await loadConfig16(paths);
     const top = Math.max(1, Number.parseInt(opts.top ?? "10", 10) || 10);
@@ -17665,6 +17762,18 @@ function renderDashboard(r) {
   console.log(`  ${ui.dim("scopes:")} ${formatCounts(inv.by_scope)}`);
   console.log(`  ${ui.dim("types: ")} ${formatCounts(inv.by_type)}`);
   console.log();
+  console.log(ui.bold("Value") + ui.dim("  (what hAIve demonstrably earned \u2014 vs its per-task cost)"));
+  const blocked = prevention.trend.last_30d;
+  const demonstrated = impact.high;
+  console.log(
+    `  ${blocked > 0 ? ui.green(`${blocked} repeat${blocked === 1 ? "" : "s"} blocked (30d)`) : "0 repeats blocked (30d)"} \xB7 ${demonstrated} high-impact memor${demonstrated === 1 ? "y" : "ies"} (applied/prevented) \xB7 ${inv.active} active polic${inv.active === 1 ? "y" : "ies"} surfaceable`
+  );
+  console.log(
+    ui.dim(
+      "  Cost is real: the briefing adds context to every task; the payoff is downstream (defects/incidents avoided), not the agent's token bill."
+    )
+  );
+  console.log();
   console.log(ui.bold("Prevention") + ui.dim("  (caught-for-you outcome)"));
   console.log(
     `  ${prevention.trend.last_30d} catch${prevention.trend.last_30d === 1 ? "" : "es"} in 30d \xB7 ${prevention.recurrence.recurring_count} recurrence${prevention.recurrence.recurring_count === 1 ? "" : "s"} to review \xB7 ${prevention.trend.last_7d} in 7d`
@@ -17749,19 +17858,19 @@ function warnNum(n) {
 }
 
 // src/commands/dev-link.ts
-import { execFile as execFile4 } from "child_process";
+import { execFile as execFile5 } from "child_process";
 import { cp, readFile as readFile27 } from "fs/promises";
 import { existsSync as existsSync79 } from "fs";
-import path56 from "path";
-import { promisify as promisify4 } from "util";
+import path57 from "path";
+import { promisify as promisify5 } from "util";
 import "commander";
 import { findProjectRoot as findProjectRoot56 } from "@hiveai/core";
-var exec3 = promisify4(execFile4);
+var exec3 = promisify5(execFile5);
 function registerDevLink(program2) {
   const dev = program2.commands.find((c) => c.name() === "dev") ?? program2.command("dev").description("Developer utilities for working on hAIve itself.");
   dev.command("link").description("Hot-swap this repo's built dist into the global @hiveai install so `haive` 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 = findProjectRoot56(opts.dir);
-    if (!existsSync79(path56.join(root, "packages", "cli", "dist", "index.js"))) {
+    if (!existsSync79(path57.join(root, "packages", "cli", "dist", "index.js"))) {
       ui.error(`Not the hAIve monorepo (no packages/cli/dist) at ${root}. Run \`pnpm -r build\` first, or pass --dir.`);
       process.exitCode = 1;
       return;
@@ -17770,9 +17879,9 @@ function registerDevLink(program2) {
     try {
       globalModules = (await exec3("npm", ["root", "-g"])).stdout.trim();
     } catch {
-      globalModules = path56.join(path56.dirname(path56.dirname(process.execPath)), "lib", "node_modules");
+      globalModules = path57.join(path57.dirname(path57.dirname(process.execPath)), "lib", "node_modules");
     }
-    const globalHive = path56.join(globalModules, "@hiveai");
+    const globalHive = path57.join(globalModules, "@hiveai");
     if (!existsSync79(globalHive)) {
       ui.error(`No global @hiveai install at ${globalHive}. Install once with \`npm i -g @hiveai/cli\`, then re-run.`);
       process.exitCode = 1;
@@ -17780,21 +17889,21 @@ function registerDevLink(program2) {
     }
     const linked = [];
     const copyDist = async (fromPkg, toDistDir) => {
-      const from = path56.join(root, "packages", fromPkg, "dist");
-      if (!existsSync79(from) || !existsSync79(path56.dirname(toDistDir))) return;
+      const from = path57.join(root, "packages", fromPkg, "dist");
+      if (!existsSync79(from) || !existsSync79(path57.dirname(toDistDir))) return;
       await cp(from, toDistDir, { recursive: true });
-      linked.push(path56.relative(globalModules, toDistDir));
+      linked.push(path57.relative(globalModules, toDistDir));
     };
     for (const pkg of ["cli", "mcp"]) {
-      await copyDist(pkg, path56.join(globalHive, pkg, "dist"));
+      await copyDist(pkg, path57.join(globalHive, pkg, "dist"));
       for (const nested of ["core", "embeddings"]) {
-        await copyDist(nested, path56.join(globalHive, pkg, "node_modules", "@hiveai", nested, "dist"));
+        await copyDist(nested, path57.join(globalHive, pkg, "node_modules", "@hiveai", nested, "dist"));
       }
     }
-    await copyDist("core", path56.join(globalHive, "core", "dist"));
+    await copyDist("core", path57.join(globalHive, "core", "dist"));
     let version = "unknown";
     try {
-      version = JSON.parse(await readFile27(path56.join(root, "package.json"), "utf8")).version ?? "unknown";
+      version = JSON.parse(await readFile27(path57.join(root, "package.json"), "utf8")).version ?? "unknown";
     } catch {
     }
     if (opts.json) {
@@ -17812,8 +17921,41 @@ function registerDevLink(program2) {
 }
 
 // src/commands/coverage.ts
+import { readFile as readFile28 } from "fs/promises";
+import { existsSync as existsSync80 } from "fs";
+import path58 from "path";
 import "commander";
-import { findCoverageGaps, findProjectRoot as findProjectRoot57, resolveHaivePaths as resolveHaivePaths52 } from "@hiveai/core";
+import {
+  findCoverageGaps,
+  findProjectRoot as findProjectRoot57,
+  mergeHotFiles,
+  resolveHaivePaths as resolveHaivePaths52,
+  tallyHotFiles
+} from "@hiveai/core";
+async function readAgentHotFiles(root, cacheFile, sinceMs) {
+  if (!existsSync80(cacheFile)) return [];
+  const raw = await readFile28(cacheFile, "utf8").catch(() => "");
+  const files = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const obs = JSON.parse(trimmed);
+      if (sinceMs > 0 && obs.ts) {
+        const t = Date.parse(obs.ts);
+        if (Number.isFinite(t) && t < sinceMs) continue;
+      }
+      for (const f of obs.files ?? []) {
+        if (typeof f !== "string" || !f) continue;
+        const rel = path58.isAbsolute(f) ? path58.relative(root, f) : f;
+        if (rel.startsWith("..")) continue;
+        files.push(rel);
+      }
+    } catch {
+    }
+  }
+  return tallyHotFiles(files, "agent");
+}
 function isNoisePath(p) {
   if (/(^|\/)(node_modules|dist|build|coverage|\.next)\//.test(p)) return true;
   if (p.startsWith(".ai/")) return true;
@@ -17825,29 +17967,47 @@ function isNoisePath(p) {
 function registerCoverage(program2) {
   program2.command("coverage").description(
     "Coverage-gap report: frequently-edited files with no covering team memory (blind spots)."
-  ).option("--json", "emit JSON", false).option("--min-changes <n>", "minimum git-churn count to flag a file", "3").option("--limit <n>", "max gaps to report", "20").option("--days <n>", "git-history lookback window in days", "90").option("-d, --dir <dir>", "project root").action(async (opts) => {
+  ).option("--json", "emit JSON", false).option("--min-changes <n>", "minimum churn count to flag a file", "3").option("--limit <n>", "max gaps to report", "20").option("--days <n>", "lookback window in days (git history + agent edits)", "90").option("--source <which>", "heat source: git | agent | both", "both").option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot57(opts.dir);
     const paths = resolveHaivePaths52(root);
     const minChanges = Math.max(1, parseInt(opts.minChanges ?? "3", 10) || 3);
     const limit = Math.max(1, parseInt(opts.limit ?? "20", 10) || 20);
     const days = Math.max(1, parseInt(opts.days ?? "90", 10) || 90);
-    const radar = await buildRadar({
+    const source = (opts.source ?? "both").toLowerCase();
+    if (!["git", "agent", "both"].includes(source)) {
+      ui.error("--source must be one of: git | agent | both");
+      process.exitCode = 1;
+      return;
+    }
+    const useGit = source === "git" || source === "both";
+    const useAgent = source === "agent" || source === "both";
+    const radar = useGit ? await buildRadar({
       root,
       taskTokens: null,
       filePaths: [],
       daysBack: Math.ceil(days / 6),
       // getHotFiles multiplies daysBack by 6
       maxHotFiles: 500
-    });
-    const hotFiles = radar.hotFiles.filter((h) => !isNoisePath(h.path)).map((h) => ({ path: h.path, changes: h.changes }));
+    }) : 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, path58.join(paths.haiveDir, ".cache", "observations.jsonl"), sinceMs)).filter((h) => !isNoisePath(h.path)) : [];
+    const hotFiles = mergeHotFiles(gitHotFiles, agentHotFiles);
     const memories = await loadMemoriesFromDir27(paths.memoriesDir);
     const gaps = findCoverageGaps(hotFiles, memories, { minChanges, limit });
     if (opts.json) {
-      console.log(JSON.stringify({ root, scanned_hot_files: hotFiles.length, gaps }, null, 2));
+      console.log(JSON.stringify({
+        root,
+        source,
+        scanned_hot_files: hotFiles.length,
+        git_hot_files: gitHotFiles.length,
+        agent_hot_files: agentHotFiles.length,
+        gaps
+      }, null, 2));
       return;
     }
-    if (!radar.insideGitRepo) {
-      ui.warn("Not a git repository \u2014 coverage uses git churn to find hot files.");
+    if (useGit && radar && !radar.insideGitRepo && agentHotFiles.length === 0) {
+      ui.warn("Not a git repository and no agent-edit history \u2014 nothing to cross-check.");
       return;
     }
     if (gaps.length === 0) {
@@ -17856,7 +18016,8 @@ function registerCoverage(program2) {
     }
     console.log(ui.bold(`hAIve coverage \u2014 ${gaps.length} blind spot(s) (hot files with no covering memory)`));
     for (const gap of gaps) {
-      console.log(`  ${ui.yellow("\u25CB")} ${gap.path} ${ui.dim(`(${gap.changes} change${gap.changes === 1 ? "" : "s"})`)}`);
+      const src = gap.source ? ui.dim(` [${gap.source}]`) : "";
+      console.log(`  ${ui.yellow("\u25CB")} ${gap.path} ${ui.dim(`(${gap.changes} change${gap.changes === 1 ? "" : "s"})`)}${src}`);
     }
     console.log(
       ui.dim(
@@ -17868,8 +18029,8 @@ function registerCoverage(program2) {
 
 // src/commands/merge-driver.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { readFileSync, writeFileSync, existsSync as existsSync80 } from "fs";
-import path57 from "path";
+import { readFileSync, writeFileSync, existsSync as existsSync81 } from "fs";
+import path59 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot58, mergeMemoryVersions } from "@hiveai/core";
 var GITATTRIBUTES_MARK = "# hAIve merge driver";
@@ -17901,8 +18062,8 @@ function registerMergeDriver(program2) {
       process.exitCode = 1;
       return;
     }
-    const gaPath = path57.join(root, ".gitattributes");
-    let content = existsSync80(gaPath) ? readFileSync(gaPath, "utf8") : "";
+    const gaPath = path59.join(root, ".gitattributes");
+    let content = existsSync81(gaPath) ? readFileSync(gaPath, "utf8") : "";
     if (!content.includes(GITATTRIBUTES_MARK)) {
       if (content.length > 0 && !content.endsWith("\n")) content += "\n";
       content += GITATTRIBUTES_BLOCK + "\n";
@@ -17917,11 +18078,12 @@ function registerMergeDriver(program2) {
 
 // src/commands/memory-resolve-conflict.ts
 import { writeFile as writeFile40 } from "fs/promises";
-import { existsSync as existsSync81 } from "fs";
+import { existsSync as existsSync83 } from "fs";
 import "commander";
 import {
+  applyConflictResolution,
   findProjectRoot as findProjectRoot59,
-  planConflictResolution,
+  planConflictResolution as planConflictResolution2,
   resolveHaivePaths as resolveHaivePaths53,
   serializeMemory as serializeMemory31
 } from "@hiveai/core";
@@ -17929,7 +18091,7 @@ function registerMemoryResolveConflict(memory2) {
   memory2.command("resolve-conflict <id_a> <id_b>").description("Resolve a contradiction: keep the stronger memory, deprecate (supersede) the other").option("--yes", "apply the resolution (without this, only previews it)", false).option("--json", "emit JSON", false).option("-d, --dir <dir>", "project root").action(async (idA, idB, opts) => {
     const root = findProjectRoot59(opts.dir);
     const paths = resolveHaivePaths53(root);
-    if (!existsSync81(paths.memoriesDir)) {
+    if (!existsSync83(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -17942,43 +18104,53 @@ function registerMemoryResolveConflict(memory2) {
       process.exitCode = 1;
       return;
     }
-    const plan = planConflictResolution(a, b);
+    const plan = planConflictResolution2(a, b);
+    const winner = plan.keep_id === idA ? a : b;
     const loser = plan.supersede_id === idA ? a : b;
+    const applied = applyConflictResolution(winner, loser, plan);
     if (opts.json) {
-      console.log(JSON.stringify({ ...plan, applied: Boolean(opts.yes) }, null, 2));
+      console.log(JSON.stringify({
+        ...plan,
+        winner_revision_count: applied.winner.revision_count,
+        topic: applied.topic,
+        topic_adopted: applied.topic_adopted,
+        applied: Boolean(opts.yes)
+      }, null, 2));
     } else {
       console.log(ui.bold("Conflict resolution"));
-      console.log(`  keep:      ${ui.green(plan.keep_id)}`);
+      console.log(`  keep:      ${ui.green(plan.keep_id)} ${ui.dim(`(rev ${winner.memory.frontmatter.revision_count}\u2192${applied.winner.revision_count})`)}`);
       console.log(`  supersede: ${ui.red(plan.supersede_id)} ${ui.dim(`\u2192 deprecated`)}`);
       console.log(`  reason:    ${plan.reason}`);
+      if (applied.topic) {
+        console.log(`  topic:     ${applied.topic}${applied.topic_adopted ? ui.dim(" (adopted from superseded \u2014 future captures upsert into the winner)") : ""}`);
+      }
     }
     if (!opts.yes) {
       if (!opts.json) ui.info("Preview only \u2014 re-run with --yes to apply.");
       return;
     }
+    await writeFile40(
+      winner.filePath,
+      serializeMemory31({ frontmatter: applied.winner, body: winner.memory.body }),
+      "utf8"
+    );
     await writeFile40(
       loser.filePath,
-      serializeMemory31({
-        frontmatter: {
-          ...loser.memory.frontmatter,
-          status: "deprecated",
-          stale_reason: plan.stale_reason,
-          related_ids: [.../* @__PURE__ */ new Set([...loser.memory.frontmatter.related_ids, plan.keep_id])]
-        },
-        body: loser.memory.body
-      }),
+      serializeMemory31({ frontmatter: applied.loser, body: loser.memory.body }),
       "utf8"
     );
-    if (!opts.json) ui.success(`Deprecated ${plan.supersede_id}; ${plan.keep_id} remains authoritative.`);
+    if (!opts.json) {
+      ui.success(`Deprecated ${plan.supersede_id}; promoted ${plan.keep_id} (rev ${applied.winner.revision_count}${applied.topic ? `, topic=${applied.topic}` : ""}).`);
+    }
   });
 }
 
 // src/commands/memory-seed-git.ts
-import { execFile as execFile5 } from "child_process";
+import { execFile as execFile6 } from "child_process";
 import { mkdir as mkdir25, writeFile as writeFile41 } from "fs/promises";
-import { existsSync as existsSync83 } from "fs";
-import path58 from "path";
-import { promisify as promisify5 } from "util";
+import { existsSync as existsSync84 } from "fs";
+import path60 from "path";
+import { promisify as promisify6 } from "util";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter12,
@@ -17988,12 +18160,12 @@ import {
   resolveHaivePaths as resolveHaivePaths54,
   serializeMemory as serializeMemory33
 } from "@hiveai/core";
-var exec4 = promisify5(execFile5);
+var exec4 = promisify6(execFile6);
 function registerMemorySeedGit(memory2) {
   memory2.command("seed-git").description("Propose draft `attempt` seeds from revert/hotfix commits in git history (cold-start)").option("--apply", "write the proposed seeds as draft memories (default: preview only)", false).option("--limit <n>", "max seeds to propose", "20").option("--days <n>", "git-history lookback window in days", "365").option("--scope <scope>", "personal | team", "team").option("--json", "emit JSON", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot60(opts.dir);
     const paths = resolveHaivePaths54(root);
-    if (!existsSync83(paths.haiveDir)) {
+    if (!existsSync84(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -18038,8 +18210,8 @@ function registerMemorySeedGit(memory2) {
 _Seeded from git ${p.kind} commit ${p.source_sha}. Review and validate (or delete) \u2014 not yet authoritative._
 `;
       const file = memoryFilePath13(paths, fm.scope, fm.id, fm.module);
-      if (existsSync83(file)) continue;
-      await mkdir25(path58.dirname(file), { recursive: true });
+      if (existsSync84(file)) continue;
+      await mkdir25(path60.dirname(file), { recursive: true });
       await writeFile41(file, serializeMemory33({ frontmatter: fm, body }), "utf8");
       written += 1;
     }
@@ -18071,8 +18243,8 @@ async function readCommits(root, days) {
 }
 
 // src/commands/bridges.ts
-import { existsSync as existsSync84 } from "fs";
-import path59 from "path";
+import { existsSync as existsSync85 } from "fs";
+import path61 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot61,
@@ -18093,7 +18265,7 @@ function registerBridges(program2) {
     const root = findProjectRoot61(opts.dir);
     const paths = resolveHaivePaths55(root);
     const dryRun = opts.dryRun === true;
-    if (!existsSync84(paths.memoriesDir)) {
+    if (!existsSync85(paths.memoriesDir)) {
       ui.warn(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -18112,7 +18284,7 @@ function registerBridges(program2) {
       targets = BRIDGE_TARGETS3;
     } else {
       targets = BRIDGE_TARGETS3.filter(
-        (t) => existsSync84(path59.join(root, BRIDGE_TARGET_PATH3[t]))
+        (t) => existsSync85(path61.join(root, BRIDGE_TARGET_PATH3[t]))
       );
       if (targets.length === 0) {
         ui.info(
@@ -18141,7 +18313,7 @@ function registerBridges(program2) {
     console.log(ui.bold("hAIve bridge targets:"));
     for (const target of BRIDGE_TARGETS3) {
       const relPath = BRIDGE_TARGET_PATH3[target];
-      const exists = existsSync84(path59.join(root, relPath));
+      const exists = existsSync85(path61.join(root, relPath));
       const marker = exists ? ui.dim("\u2713") : ui.dim("\xB7");
       console.log(`  ${marker} ${target.padEnd(10)} ${relPath}${exists ? "" : "  (not present)"}`);
     }
@@ -18152,7 +18324,7 @@ function registerBridges(program2) {
 
 // src/index.ts
 var program = new Command64();
-program.name("haive").description("hAIve - repo-native memory and context policy for coding-agent harnesses").version("0.21.0").option("--advanced", "show maintenance and experimental commands in help");
+program.name("haive").description("hAIve - repo-native memory and context policy for coding-agent harnesses").version("0.24.0").option("--advanced", "show maintenance and experimental commands in help");
 registerInit(program);
 registerWelcome(program);
 registerResolveProject(program);