@hiveai/cli 0.23.0 → 0.25.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(([path61, changes]) => ({ path: path61, 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,10 +2249,11 @@ 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,
+  meetsSeedQualityFloor,
   memoryFilePath,
   serializeMemory as serializeMemory2,
   STACK_PACK_TAG
@@ -2289,7 +2294,12 @@ app.useGlobalPipes(new ValidationPipe({ whitelist: true, forbidNonWhitelisted: t
       body: `Controllers must never import Prisma/TypeORM directly \u2014 that belongs in Services.
 
 Controller \u2192 Service \u2192 Repository (or direct ORM) is the required layering.
-Direct ORM usage in controllers makes testing impossible and couples transport to persistence.`
+Direct ORM usage in controllers makes testing impossible and couples transport to persistence.`,
+      sensor: {
+        pattern: "@prisma/client|PrismaClient|getRepository\\(|createQueryBuilder\\(",
+        paths: ["**/*.controller.ts"],
+        message: "ORM/Prisma used directly in a controller \u2014 move persistence into a Service (Controller \u2192 Service \u2192 Repository)."
+      }
     },
     {
       slug: "nestjs-exception-filter-for-prisma",
@@ -2474,7 +2484,11 @@ Routes without schema accept any body and bypass Fastify's fast-json-stringify s
 
 Calling $disconnect() after each request wastes the warm connection pool.
 Create one PrismaClient per process (module-level singleton), not per request.
-Disconnecting is only needed when the process is shutting down.`
+Disconnecting is only needed when the process is shutting down.`,
+      sensor: {
+        pattern: "\\$disconnect\\(\\)",
+        message: "prisma.$disconnect() per request drains the warm connection pool in serverless \u2014 use a module-level PrismaClient singleton and only disconnect on shutdown."
+      }
     },
     {
       slug: "prisma-migrations-never-modify",
@@ -2530,7 +2544,11 @@ const store = useStore();
 const count = useStore((s) => s.count);
 \`\`\`
 
-Subscribing to the whole store is the single most common Zustand performance mistake.`
+Subscribing to the whole store is the single most common Zustand performance mistake.`,
+      sensor: {
+        pattern: "use[A-Z]\\w*Store\\(\\s*\\)",
+        message: "A Zustand store hook called with no selector subscribes to the WHOLE store (re-renders on any change) \u2014 pass a slice selector: useStore(s => s.field)."
+      }
     },
     {
       slug: "zustand-devtools-wrap-dev-only",
@@ -2751,7 +2769,8 @@ const users = await User.find({});
 const users = await User.find({}).lean();
 \`\`\`
 
-Never use .lean() when you need to call .save() or Mongoose instance methods.`
+\`.lean()\` skips hydration into a Mongoose \`Document\`, so getters, virtuals, \`toObject()\` and
+instance methods are gone. Never use \`.lean()\` when you then call \`.save()\` or instance methods.`
     },
     {
       slug: "mongoose-index-frequently-queried-fields",
@@ -2970,7 +2989,11 @@ A committed key lets anyone forge sessions and CSRF tokens.`
 db.execute(f"SELECT * FROM users WHERE id = {uid}")
 # \u2705
 db.execute("SELECT * FROM users WHERE id = %s", (uid,))
-\`\`\``
+\`\`\``,
+      sensor: {
+        pattern: `execute\\(\\s*f["']`,
+        message: 'SQL built with an f-string inside execute() \u2014 SQL injection risk; use a parameterized query: execute("\u2026 %s \u2026", (params,)).'
+      }
     }
   ],
   vue: [
@@ -3338,6 +3361,7 @@ async function seedStackPack(haivePaths, stack) {
   let memCount = 0;
   let sensorCount = 0;
   for (const mem of memories) {
+    if (!meetsSeedQualityFloor(mem.body, Boolean(mem.sensor))) continue;
     const sensor = mem.sensor ? {
       kind: "regex",
       pattern: mem.sensor.pattern,
@@ -3374,7 +3398,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 +3410,7 @@ ${SEED_FOOTER(stack)}` });
 
 // src/commands/init.ts
 var execFileAsync = promisify2(execFile2);
-var HAIVE_GITHUB_ACTION_REF = `v${"0.23.0"}`;
+var HAIVE_GITHUB_ACTION_REF = `v${"0.25.0"}`;
 var PROJECT_CONTEXT_TEMPLATE = `# Project context
 
 > Generated by \`haive init\`. Run \`haive init --bootstrap\` to auto-fill from your codebase,
@@ -3614,7 +3638,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 +3665,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 +3679,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 +3750,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 +3796,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 +3895,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 +3904,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 +3913,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 +3928,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 +3936,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 +3998,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 +4060,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 +4094,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 +4129,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 +4232,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 +4248,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 +4307,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 +4384,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 +4502,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 +4524,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 +4694,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 +4754,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,
@@ -4788,7 +4813,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,
@@ -4834,14 +4859,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,
@@ -6579,6 +6604,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.
@@ -6588,7 +6614,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(
@@ -6868,6 +6897,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"),
@@ -7091,7 +7133,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),
@@ -8123,13 +8165,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",
@@ -8193,7 +8235,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",
@@ -8240,7 +8282,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 }),
@@ -8654,7 +8696,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
   };
 }
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.23.0";
+var SERVER_VERSION = "0.25.0";
 function jsonResult(data) {
   return {
     content: [
@@ -9688,7 +9730,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,
@@ -9882,10 +9924,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) {
@@ -10017,10 +10059,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"
                   );
@@ -10086,10 +10128,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"
               );
@@ -10212,11 +10254,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;
@@ -10224,14 +10266,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)}`)
     );
   }
 }
@@ -10258,7 +10300,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,
@@ -10316,7 +10358,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}`);
@@ -10380,7 +10422,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);
@@ -10404,7 +10446,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;
@@ -10423,7 +10465,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)}`);
@@ -10503,7 +10545,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";
 
@@ -10556,7 +10598,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)` : `
@@ -10595,7 +10637,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,
@@ -10642,11 +10684,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)`));
   });
 }
@@ -10654,7 +10696,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,
@@ -10718,14 +10760,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,
@@ -10804,7 +10846,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(", ")}`);
   });
 }
@@ -10825,7 +10867,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,
@@ -10870,7 +10912,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" },
@@ -10889,7 +10931,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,
@@ -10913,7 +10955,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}.`);
@@ -10941,7 +10983,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,
@@ -11063,13 +11105,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,
@@ -11111,7 +11153,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>\`.
@@ -11123,7 +11165,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,
@@ -11179,14 +11221,14 @@ 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)}`);
@@ -11205,7 +11247,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,
@@ -11214,7 +11256,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 {
@@ -11301,7 +11343,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,
@@ -11347,7 +11389,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();
@@ -11362,7 +11404,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)`));
     }
@@ -11372,7 +11414,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,
@@ -11429,7 +11471,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}`);
     }
@@ -11499,7 +11541,7 @@ 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 {
@@ -11524,7 +11566,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();
@@ -11550,7 +11592,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,
@@ -11592,7 +11634,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}`);
@@ -11608,7 +11650,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,
@@ -11646,7 +11688,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))}`);
     }
   });
 }
@@ -11809,7 +11851,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,
@@ -11851,7 +11893,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 });
@@ -11996,7 +12038,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,
@@ -12068,7 +12110,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;
@@ -12089,9 +12131,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) {
@@ -12114,7 +12156,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, "-")}`;
@@ -12129,11 +12171,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"
       );
@@ -12158,7 +12200,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,
@@ -12253,7 +12295,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 {
@@ -12266,7 +12308,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,
@@ -12281,7 +12323,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);
@@ -12450,7 +12492,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;
@@ -12539,14 +12581,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(() => {
       });
     };
@@ -12571,7 +12613,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.");
         }
@@ -12589,12 +12631,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`.");
@@ -12607,8 +12649,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;
 }
@@ -12616,7 +12658,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,
@@ -12655,7 +12697,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;
@@ -12711,7 +12753,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 {
@@ -12766,8 +12808,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";
@@ -12782,7 +12824,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 {
@@ -12801,7 +12843,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) {
@@ -12812,10 +12854,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.
@@ -12837,7 +12879,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"
     );
@@ -12852,7 +12894,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.)
 `
@@ -12881,14 +12923,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(
@@ -12907,7 +12949,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++;
     }
@@ -12915,7 +12957,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], {
@@ -12950,13 +12992,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) {
@@ -12966,16 +13008,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) {
@@ -13006,14 +13048,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 {
@@ -13038,7 +13080,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,
@@ -13110,7 +13152,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 };
@@ -13145,7 +13187,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,
@@ -13336,7 +13378,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) {
@@ -13351,9 +13393,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);
@@ -13377,9 +13419,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}`);
@@ -13387,8 +13429,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));
@@ -13406,7 +13448,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)
   };
 }
@@ -13428,7 +13470,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
   };
 }
@@ -13440,29 +13482,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);
@@ -13481,7 +13525,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,
@@ -13577,7 +13621,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(),
@@ -13586,18 +13630,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;
         }
@@ -13636,9 +13680,9 @@ function registerEval(program2) {
     }
     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);
     }
@@ -13722,12 +13766,12 @@ function countCases(spec) {
 }
 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");
     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);
@@ -13848,7 +13892,7 @@ function renderMarkdown2(root, k, resolved, 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,
@@ -13949,13 +13993,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));
@@ -14055,7 +14099,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,
@@ -14099,7 +14143,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);
@@ -14176,7 +14220,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 {
@@ -14401,7 +14445,7 @@ 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 {
@@ -14429,7 +14473,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.23.0"));
+    findings.push(...await collectInstallFindings(root, "0.25.0"));
     findings.push(...await collectToolchainFindings(root));
     try {
       const legacyRaw = execSync3("haive-mcp --version", {
@@ -14437,7 +14481,7 @@ function registerDoctor(program2) {
         timeout: 3e3,
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      const cliVersion = "0.23.0";
+      const cliVersion = "0.25.0";
       if (legacyRaw && legacyRaw !== cliVersion) {
         findings.push({
           severity: "warn",
@@ -14453,9 +14497,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) {
@@ -14463,7 +14507,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");
@@ -14754,7 +14798,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)) {
@@ -14781,7 +14825,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;
@@ -14800,9 +14844,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",
@@ -14827,7 +14871,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));
@@ -14845,7 +14889,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",
@@ -14854,7 +14898,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;
@@ -15359,21 +15403,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,
@@ -15387,15 +15431,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)) {
@@ -15414,7 +15458,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,
@@ -15430,7 +15474,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`.");
@@ -15451,7 +15495,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,
@@ -15473,7 +15517,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`.");
@@ -15513,7 +15557,7 @@ function registerMemoryConflictCandidates(memory2) {
 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 {
@@ -15573,7 +15617,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)}`);
       }
@@ -15594,19 +15638,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)` : ""}`);
       }
     }
   });
@@ -15959,7 +16003,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 {
@@ -16031,7 +16075,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",
@@ -16081,9 +16125,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",
     "",
@@ -16141,7 +16185,7 @@ async function buildEnforcementReport(dir, stage, sessionId) {
       findings: [{ severity: "info", code: "enforcement-off", message: "hAIve enforcement is disabled." }]
     });
   }
-  findings.push(...await inspectIntegrationVersions(root, "0.23.0"));
+  findings.push(...await inspectIntegrationVersions(root, "0.25.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." } : {
@@ -16292,7 +16336,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) {
@@ -16500,16 +16544,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"
     );
@@ -16522,10 +16566,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) {
@@ -16533,7 +16577,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;
@@ -16549,7 +16593,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)) {
@@ -16765,7 +16809,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: "" };
@@ -16794,7 +16838,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;
@@ -16982,8 +17026,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;
   }
@@ -17012,7 +17056,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)) {
@@ -17030,8 +17074,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;
@@ -17063,7 +17107,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) {
@@ -17167,8 +17211,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 [];
@@ -17216,7 +17260,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;
@@ -17258,7 +17302,7 @@ function registerRun(program2) {
 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 path55 from "path";
 import { promisify as promisify4 } from "util";
 import "commander";
 import {
@@ -17303,7 +17347,7 @@ 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);
@@ -17415,13 +17459,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) {
@@ -17494,7 +17538,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,
@@ -17551,7 +17595,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;
@@ -17640,13 +17684,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;
 }
@@ -17738,6 +17782,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`
@@ -17825,7 +17881,7 @@ function warnNum(n) {
 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 path57 from "path";
 import { promisify as promisify5 } from "util";
 import "commander";
 import { findProjectRoot as findProjectRoot56 } from "@hiveai/core";
@@ -17834,7 +17890,7 @@ 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;
@@ -17843,9 +17899,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;
@@ -17853,21 +17909,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) {
@@ -17887,7 +17943,7 @@ function registerDevLink(program2) {
 // src/commands/coverage.ts
 import { readFile as readFile28 } from "fs/promises";
 import { existsSync as existsSync80 } from "fs";
-import path57 from "path";
+import path58 from "path";
 import "commander";
 import {
   findCoverageGaps,
@@ -17911,7 +17967,7 @@ async function readAgentHotFiles(root, cacheFile, sinceMs) {
       }
       for (const f of obs.files ?? []) {
         if (typeof f !== "string" || !f) continue;
-        const rel = path57.isAbsolute(f) ? path57.relative(root, f) : f;
+        const rel = path58.isAbsolute(f) ? path58.relative(root, f) : f;
         if (rel.startsWith("..")) continue;
         files.push(rel);
       }
@@ -17955,7 +18011,7 @@ function registerCoverage(program2) {
     }) : null;
     const gitHotFiles = (radar?.hotFiles ?? []).filter((h) => !isNoisePath(h.path)).map((h) => ({ path: h.path, changes: h.changes, source: "git" }));
     const sinceMs = Date.now() - days * 864e5;
-    const agentHotFiles = useAgent ? (await readAgentHotFiles(root, path57.join(paths.haiveDir, ".cache", "observations.jsonl"), sinceMs)).filter((h) => !isNoisePath(h.path)) : [];
+    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 });
@@ -17994,7 +18050,7 @@ function registerCoverage(program2) {
 // src/commands/merge-driver.ts
 import { execFileSync as execFileSync3 } from "child_process";
 import { readFileSync, writeFileSync, existsSync as existsSync81 } from "fs";
-import path58 from "path";
+import path59 from "path";
 import "commander";
 import { findProjectRoot as findProjectRoot58, mergeMemoryVersions } from "@hiveai/core";
 var GITATTRIBUTES_MARK = "# hAIve merge driver";
@@ -18026,7 +18082,7 @@ function registerMergeDriver(program2) {
       process.exitCode = 1;
       return;
     }
-    const gaPath = path58.join(root, ".gitattributes");
+    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";
@@ -18113,7 +18169,7 @@ function registerMemoryResolveConflict(memory2) {
 import { execFile as execFile6 } from "child_process";
 import { mkdir as mkdir25, writeFile as writeFile41 } from "fs/promises";
 import { existsSync as existsSync84 } from "fs";
-import path59 from "path";
+import path60 from "path";
 import { promisify as promisify6 } from "util";
 import "commander";
 import {
@@ -18175,7 +18231,7 @@ _Seeded from git ${p.kind} commit ${p.source_sha}. Review and validate (or delet
 `;
       const file = memoryFilePath13(paths, fm.scope, fm.id, fm.module);
       if (existsSync84(file)) continue;
-      await mkdir25(path59.dirname(file), { recursive: true });
+      await mkdir25(path60.dirname(file), { recursive: true });
       await writeFile41(file, serializeMemory33({ frontmatter: fm, body }), "utf8");
       written += 1;
     }
@@ -18208,7 +18264,7 @@ async function readCommits(root, days) {
 
 // src/commands/bridges.ts
 import { existsSync as existsSync85 } from "fs";
-import path60 from "path";
+import path61 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot61,
@@ -18248,7 +18304,7 @@ function registerBridges(program2) {
       targets = BRIDGE_TARGETS3;
     } else {
       targets = BRIDGE_TARGETS3.filter(
-        (t) => existsSync85(path60.join(root, BRIDGE_TARGET_PATH3[t]))
+        (t) => existsSync85(path61.join(root, BRIDGE_TARGET_PATH3[t]))
       );
       if (targets.length === 0) {
         ui.info(
@@ -18277,7 +18333,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 = existsSync85(path60.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)"}`);
     }
@@ -18288,7 +18344,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.23.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.25.0").option("--advanced", "show maintenance and experimental commands in help");
 registerInit(program);
 registerWelcome(program);
 registerResolveProject(program);