@hiveai/cli 0.9.27 → 0.9.29

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command51 } from "commander";
+import { Command as Command52 } from "commander";
 
 // src/commands/briefing.ts
 import { existsSync as existsSync3 } from "fs";
@@ -11,6 +11,7 @@ import "commander";
 import {
   extractActionsBriefBody,
   findProjectRoot as findProjectRoot2,
+  isStackPackSeed,
   literalMatchesAllTokens,
   literalMatchesAnyToken,
   loadCodeMap as loadCodeMap3,
@@ -198,7 +199,7 @@ async function getHotFiles(root, daysBack, maxHotFiles, filePaths) {
       if (!f) continue;
       counts.set(f, (counts.get(f) ?? 0) + 1);
     }
-    let entries = [...counts.entries()].map(([path50, changes]) => ({ path: path50, changes }));
+    let entries = [...counts.entries()].map(([path51, changes]) => ({ path: path51, changes }));
     const lowerPaths = filePaths.map((p) => p.toLowerCase());
     if (lowerPaths.length > 0) {
       entries = entries.filter((e) => lowerPaths.some((p) => e.path.toLowerCase().includes(p)));
@@ -1098,6 +1099,7 @@ function classifyCliPriority(item, filePaths, tokens, exactTaskHit, partialTaskH
   const fm = item.memory.frontmatter;
   const anchored = filePaths.length > 0 && memoryMatchesAnchorPaths(item.memory, filePaths);
   if (anchored || fm.type === "attempt" && exactTaskHit) return "must_read";
+  if (isStackPackSeed(fm)) return "background";
   if (exactTaskHit || partialTaskHit || item.score >= 4 || tokens && fm.tags.some((tag) => tokens.includes(tag))) {
     return "useful";
   }
@@ -2018,7 +2020,8 @@ import path9 from "path";
 import {
   buildFrontmatter,
   memoryFilePath,
-  serializeMemory as serializeMemory2
+  serializeMemory as serializeMemory2,
+  STACK_PACK_TAG
 } from "@hiveai/core";
 var PACKS = {
   nestjs: [
@@ -2593,6 +2596,7 @@ new ApolloServer({
     }
   ]
 };
+var SEED_FOOTER = (stack) => `> _Seeded by \`haive init\` from the **${stack}** stack pack \u2014 generic guidance, not repo-specific. Anchor it to a real file or replace it with a repo-specific note to raise it above background priority._`;
 var SUPPORTED_STACKS = Object.keys(PACKS);
 function isValidStack(name) {
   return name in PACKS;
@@ -2634,11 +2638,15 @@ async function seedStackPack(haivePaths, stack) {
       slug: `${stack}-${mem.slug}`,
       scope: "team",
       status: "validated",
-      tags: mem.tags
+      // STACK_PACK_TAG marks this as generic seed knowledge so briefing ranking
+      // keeps it at `background` priority until it earns a repo-specific anchor.
+      tags: [...mem.tags, STACK_PACK_TAG]
     });
     const filePath = memoryFilePath(haivePaths, "team", fm.id);
     if (existsSync8(filePath)) continue;
-    const content = serializeMemory2({ frontmatter: fm, body: mem.body });
+    const content = serializeMemory2({ frontmatter: fm, body: `${mem.body}
+
+${SEED_FOOTER(stack)}` });
     await mkdir4(path9.dirname(filePath), { recursive: true });
     await writeFile5(filePath, content, "utf8");
     count++;
@@ -2669,30 +2677,25 @@ TODO \u2014 domain terms and what they mean here.
 TODO \u2014 known traps, surprising behavior, things newcomers stub their toes on.
 `;
 var BRIDGE_BODY = `<!-- hAIve bridge file \u2014 do not edit by hand. -->
-<!-- This file points your AI tool at the shared hAIve project context. -->
-
-See \`.ai/project-context.md\` for the full project context.
-Memories live under \`.ai/memories/\` (personal/team/module).
 
-## hAIve \u2014 mandatory rules for AI agents
+This repo uses **hAIve** for shared context. The map:
 
-Installing or initializing hAIve in this repository means **the team expects AI agents to drive work through hAIve**, not bypass it.
+- \`.ai/project-context.md\` \u2014 project overview, architecture, conventions.
+- \`.ai/memories/\` \u2014 decisions, gotchas, conventions, failed attempts (personal/team/module).
+- The breadcrumbs injected below (if any) are the top current memories.
 
-### MCP first (default \u2014 never optional unless the developer says so)
-The **haive** MCP server must be enabled in your client. Until it is unavailable (misconfiguration report to the developer), you **must** use it for substantive work:
+## Working through hAIve
 
-- **Before** you edit project source files, configs (\`package.json\`, tooling), or workflows for the current goal, invoke \`get_briefing\` with a short **task** string (and **files** / **symbols** when you know them). If project context was already refreshed in this session and you only need ranked memories, you may call \`mem_relevant_to\` instead\u2014but **still** consult hAIve before trusting ungrounded guesses.
-- **Before** declaring a coding task finished, invoke the MCP prompt \`post_task\` when the session produced learnings or substantive changes worth capturing.
+1. **Before editing** for a goal, call \`get_briefing\` (task + files/symbols) to load ranked context \u2014 or \`mem_relevant_to\` if project context is already loaded this session.
+2. **When an approach fails**, call \`mem_tried\` right away so the next agent skips the dead end.
+3. **Before closing** a substantive session, run the \`post_task\` prompt to capture what was learned.
 
-Do **not** treat these as nice-to-have: they are **default-required** for coding agents here.
+If the haive MCP server is not available, tell the developer rather than silently skipping it.
 
-### Session rules
-- **Immediately** when an approach fails (wrong API, wrong pattern, wrong assumption), call \`mem_tried\` \u2014 do not wait until the end of the session.
+## Safety
 
-### Safety rules \u2014 NEVER violate these
-- If \`get_briefing\` returns an \`action_required\` list, **stop and show each item to the developer** before doing anything. Use the exact \`developer_message\` provided. Wait for explicit confirmation.
-- **Never modify code autonomously** because of a breaking change detected in another project (dependency version bump, API contract change, removed field). Always ask first.
-- When in doubt about a cross-repo change: ask, don't act.
+- If \`get_briefing\` returns \`action_required\`, surface each item to the developer (use its \`developer_message\`) and wait for confirmation before changing code.
+- Never act autonomously on a cross-repo breaking change (dep bump, contract/API diff) \u2014 ask first.
 `;
 var CURSOR_HAIVE_RULE_MDC = `---
 description: Require hAIve MCP (get_briefing / mem_relevant_to) before substantive repo edits
@@ -2918,7 +2921,10 @@ function registerInit(program2) {
       }
       if (totalSeeded > 0) {
         ui.success(
-          `${totalSeeded} validated team memories pre-seeded \u2014 haive is useful from J+0`
+          `${totalSeeded} starter memories seeded (generic stack guidance, kept at background priority)`
+        );
+        ui.info(
+          "Anchor them to real files or replace them with repo-specific notes to make them high-signal."
         );
       }
     }
@@ -3663,6 +3669,7 @@ import {
   isGlobPath,
   isAutoPromoteEligible,
   isDecaying,
+  isStackPackSeed as isStackPackSeed2,
   literalMatchesAllTokens as literalMatchesAllTokens22,
   literalMatchesAnyToken as literalMatchesAnyToken22,
   loadCodeMap as loadCodeMap4,
@@ -3676,7 +3683,8 @@ import {
   serializeMemory as serializeMemory9,
   tokenizeQuery as tokenizeQuery22,
   trackReads as trackReads3,
-  truncateToTokens
+  truncateToTokens,
+  writeBriefingMarker as writeBriefingMarker2
 } from "@hiveai/core";
 import { z as z17 } from "zod";
 import { estimateTokens as estimateTokens2, loadCodeMap as loadCodeMap22, queryCodeMap as queryCodeMap22 } from "@hiveai/core";
@@ -5427,6 +5435,16 @@ When done, call \`mem_session_end\` to acknowledge \u2014 this clears the pendin
       );
     }
   }
+  if (existsSync18(ctx.paths.haiveDir)) {
+    await writeBriefingMarker2(ctx.paths, {
+      sessionId: process.env.HAIVE_SESSION_ID,
+      ...input.task ? { task: input.task } : {},
+      source: "mcp-get-briefing",
+      files: input.files,
+      memoryIds: outputMemories.map((m) => m.id)
+    }).catch(() => {
+    });
+  }
   return {
     ...input.task ? { task: input.task } : {},
     search_mode: searchMode,
@@ -5481,6 +5499,9 @@ function classifyMemoryPriority(memory2, loaded, inputFiles, inputSymbols) {
   if (fm?.requires_human_approval || directAnchor || directSymbol || memory2.type === "attempt" && (memory2.match_quality === "exact" || strongSemantic) || memory2.type === "skill" && (memory2.match_quality === "exact" || strongSemantic)) {
     return "must_read";
   }
+  if (isStackPackSeed2(fm)) {
+    return "background";
+  }
   if (memory2.type === "skill" || memory2.reasons.includes("module") || memory2.reasons.includes("domain") || memory2.match_quality === "exact" || usefulSemantic) {
     return "useful";
   }
@@ -5963,6 +5984,8 @@ async function antiPatternsCheck(input, ctx) {
       confidence: deriveConfidence6(fm, u),
       body_preview: body.split("\n").slice(0, 5).join("\n").slice(0, 400),
       reasons: [reason],
+      tags: fm.tags ?? [],
+      anchor_paths: fm.anchor?.paths ?? [],
       ...score !== void 0 ? { semantic_score: score } : {}
     });
   };
@@ -6553,8 +6576,45 @@ function fileTypeDowngradeReason(warning, paths) {
   if (configOnly && !warning.reasons.includes("anchor") && !hasStrongSemantic(warning)) {
     return "package/config-only change; warning has no anchor on these files and no strong semantic match \u2014 downgraded to info.";
   }
+  const touchesBuildFile = paths.some(isPackageOrConfigPath);
+  if (!touchesBuildFile && isBuildScopedWarning(warning) && !warning.reasons.includes("anchor") && !hasStrongSemantic(warning)) {
+    return "build/packaging gotcha, but no package/build file changed \u2014 downgraded to info.";
+  }
   return null;
 }
+function isBuildScopedWarning(warning) {
+  const tags = warning.tags ?? [];
+  if (tags.some((t) => BUILD_SCOPED_TAGS.has(t.toLowerCase()))) return true;
+  const anchors = warning.anchor_paths ?? [];
+  return anchors.length > 0 && anchors.every(isPackageOrConfigPath);
+}
+var BUILD_SCOPED_TAGS = /* @__PURE__ */ new Set([
+  "npm",
+  "pnpm",
+  "yarn",
+  "publish",
+  "install",
+  "packaging",
+  "package",
+  "build",
+  "tsup",
+  "bundler",
+  "monorepo",
+  "workspace",
+  "versioning",
+  "version",
+  "dev-workflow",
+  "hotswap",
+  "ci",
+  "workflow",
+  "release",
+  "changelog",
+  "dependencies",
+  "deps",
+  "dependency",
+  "tooling",
+  "config"
+]);
 function hasStrongSemantic(warning) {
   return warning.reasons.includes("semantic") && (warning.semantic_score ?? 0) >= 0.65;
 }
@@ -7130,7 +7190,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
   };
 }
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.9.27";
+var SERVER_VERSION = "0.9.29";
 function jsonResult(data) {
   return {
     content: [
@@ -8111,6 +8171,7 @@ import {
   getUsage as getUsage10,
   isAutoPromoteEligible as isAutoPromoteEligible2,
   isDecaying as isDecaying2,
+  isStackPackSeed as isStackPackSeed3,
   loadCodeMap as loadCodeMap5,
   loadConfig as loadConfig4,
   loadMemoriesFromDir as loadMemoriesFromDir23,
@@ -8555,12 +8616,18 @@ Attends une **confirmation explicite** avant d'agir.
     }
   });
 }
+function bridgeSummaryLine(body) {
+  const firstLine = body.split("\n").map((l) => l.replace(/^#+\s*/, "").trim()).find((l) => l.length > 0) ?? "";
+  const oneLine = firstLine.replace(/\s+/g, " ");
+  return oneLine.length > 140 ? oneLine.slice(0, 137) + "\u2026" : oneLine;
+}
 async function injectBridge(bridgeFile, memoriesDir, maxMemories, root, quiet) {
   if (!existsSync29(memoriesDir)) return;
   const all = await loadMemoriesFromDir23(memoriesDir);
   const top = all.filter(({ memory: memory2 }) => {
     const s = memory2.frontmatter.status;
     if (memory2.frontmatter.type === "session_recap") return false;
+    if (isStackPackSeed3(memory2.frontmatter)) return false;
     return s === "validated" || s === "proposed";
   }).sort((a, b) => {
     const score = (m) => {
@@ -8572,11 +8639,11 @@ async function injectBridge(bridgeFile, memoriesDir, maxMemories, root, quiet) {
   const block = top.map((m) => {
     const fm = m.memory.frontmatter;
     const unverified = fm.status === "proposed" ? " [UNVERIFIED]" : "";
-    return `### ${fm.id} (${fm.scope}/${fm.type})${unverified}
-${m.memory.body.trim()}`;
-  }).join("\n\n---\n\n");
+    return `- \`${fm.id}\` (${fm.scope}/${fm.type})${unverified} \u2014 ${bridgeSummaryLine(m.memory.body)}`;
+  }).join("\n");
   const injected = `${BRIDGE_START}
 <!-- AUTO-GENERATED by haive sync --inject-bridge \u2014 do not edit between these markers -->
+<!-- Top memories \u2014 call get_briefing / mem_get for the full body. -->
 
 ` + block + `
 
@@ -9545,21 +9612,118 @@ function parseCsv4(value) {
   return value.split(",").map((s) => s.trim()).filter(Boolean);
 }
 
-// src/commands/memory-pending.ts
+// src/commands/memory-seed.ts
+import { readFile as readFile13 } from "fs/promises";
 import { existsSync as existsSync41 } from "fs";
 import path27 from "path";
 import "commander";
 import {
   findProjectRoot as findProjectRoot23,
+  loadConfig as loadConfig6,
+  resolveHaivePaths as resolveHaivePaths20
+} from "@hiveai/core";
+async function readDependencyMap(root) {
+  try {
+    const raw = await readFile13(path27.join(root, "package.json"), "utf8");
+    const pkg = JSON.parse(raw);
+    return { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+  } catch {
+    return {};
+  }
+}
+function registerMemorySeed(memory2) {
+  memory2.command("seed [stack]").description(
+    "Seed a stack pack of starter memories on demand.\n\n  Stack packs are generic framework gotchas/conventions every team using that\n  stack rediscovers. They are tagged `stack-pack` and kept at BACKGROUND priority\n  in briefings until you anchor them to a real file or replace them with a\n  repo-specific note \u2014 so they never crowd out your own knowledge.\n\n  Examples:\n    haive memory seed              # auto-detect stacks from package.json and seed them\n    haive memory seed nestjs       # seed a specific stack\n    haive memory seed --list       # show supported + auto-detected stacks\n    haive memory seed --list --json\n"
+  ).option("--list", "list supported stacks (and which are auto-detected here) and exit").option("--json", "machine-readable output (use with --list)").option("-d, --dir <dir>", "project root").action(async (stack, opts) => {
+    const root = findProjectRoot23(opts.dir);
+    const paths = resolveHaivePaths20(root);
+    const deps = await readDependencyMap(root);
+    const detected = autoDetectStacks(deps);
+    if (opts.list) {
+      if (opts.json) {
+        console.log(JSON.stringify({ supported: SUPPORTED_STACKS, detected }, null, 2));
+        return;
+      }
+      ui.info("Supported stacks:");
+      for (const s of SUPPORTED_STACKS) {
+        const mark = detected.includes(s) ? ui.green(" \u2713 detected here") : "";
+        console.log(`  \u2022 ${s}${mark}`);
+      }
+      if (detected.length === 0) {
+        ui.info("No stack auto-detected from package.json \u2014 pass a stack name explicitly.");
+      }
+      return;
+    }
+    if (!existsSync41(paths.haiveDir)) {
+      ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
+      process.exitCode = 1;
+      return;
+    }
+    let stacksToSeed;
+    if (stack) {
+      if (!isValidStack(stack)) {
+        ui.error(`Unknown stack '${stack}'. Supported: ${SUPPORTED_STACKS.join(", ")}.`);
+        ui.info("Run `haive memory seed --list` to see all stacks.");
+        process.exitCode = 1;
+        return;
+      }
+      stacksToSeed = [stack];
+    } else if (detected.length > 0) {
+      stacksToSeed = detected;
+      ui.info(`Auto-detected from package.json: ${detected.join(", ")}`);
+    } else {
+      ui.error("No stack auto-detected from package.json.");
+      ui.info("Pass a stack name (e.g. `haive memory seed nestjs`) or run `haive memory seed --list`.");
+      process.exitCode = 1;
+      return;
+    }
+    let total = 0;
+    const seededStacks = [];
+    for (const s of stacksToSeed) {
+      const count = await seedStackPack(paths, s);
+      if (count > 0) {
+        total += count;
+        seededStacks.push(`${s} (${count})`);
+      } else {
+        ui.info(`Stack pack '${s}': all memories already exist \u2014 skipped.`);
+      }
+    }
+    if (total === 0) {
+      ui.info("Nothing new to seed \u2014 every memory in the selected pack(s) already exists.");
+      return;
+    }
+    ui.success(`Seeded ${total} starter memor${total === 1 ? "y" : "ies"}: ${seededStacks.join(", ")}`);
+    ui.info("Kept at background priority. Anchor them to a real file (or replace them) to make them high-signal:");
+    ui.info("  haive memory update <id> --paths <key-file>   # anchor a seed to a file");
+    const config = await loadConfig6(paths);
+    if (config.autopilot || config.autoRepair?.corpus === true) {
+      const repairs = await applyAutopilotRepairs(root, paths, {
+        applyConfig: false,
+        applyContext: false,
+        applyCorpus: true,
+        applyCodeMap: false,
+        applyCodeSearch: false
+      });
+      for (const repair of repairs) ui.info(repair.message);
+    }
+  });
+}
+
+// src/commands/memory-pending.ts
+import { existsSync as existsSync43 } from "fs";
+import path28 from "path";
+import "commander";
+import {
+  findProjectRoot as findProjectRoot24,
   getUsage as getUsage14,
   loadUsageIndex as loadUsageIndex16,
-  resolveHaivePaths as resolveHaivePaths20
+  resolveHaivePaths as resolveHaivePaths21
 } from "@hiveai/core";
 function registerMemoryPending(memory2) {
   memory2.command("pending").description("List draft and proposed memories awaiting review (sorted by reads desc).\n\n  draft = created but not yet activated \xB7 proposed = promoted, awaiting team validation").option("--scope <scope>", "filter by scope (personal | team | module)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot23(opts.dir);
-    const paths = resolveHaivePaths20(root);
-    if (!existsSync41(paths.memoriesDir)) {
+    const root = findProjectRoot24(opts.dir);
+    const paths = resolveHaivePaths21(root);
+    if (!existsSync43(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -9593,7 +9757,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(path27.relative(root, filePath))}`);
+        console.log(`    ${ui.dim(path28.relative(root, filePath))}`);
       }
       if (proposed.length > 0) console.log(ui.dim(`  \u2192 haive memory approve <id>  or  haive memory auto-promote`));
       console.log();
@@ -9608,7 +9772,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(path27.relative(root, filePath))}`);
+        console.log(`    ${ui.dim(path28.relative(root, filePath))}`);
       }
       console.log(ui.dim(`  \u2192 haive memory approve <id>   (activate)  |  haive memory promote <id>  (share with team)`));
     }
@@ -9617,24 +9781,24 @@ function registerMemoryPending(memory2) {
 }
 
 // src/commands/memory-query.ts
-import { existsSync as existsSync43 } from "fs";
-import path28 from "path";
+import { existsSync as existsSync44 } from "fs";
+import path29 from "path";
 import "commander";
 import {
   extractSnippet as extractSnippet2,
-  findProjectRoot as findProjectRoot24,
+  findProjectRoot as findProjectRoot25,
   literalMatchesAllTokens as literalMatchesAllTokens3,
   literalMatchesAnyToken as literalMatchesAnyToken4,
   pickSnippetNeedle as pickSnippetNeedle2,
-  resolveHaivePaths as resolveHaivePaths21,
+  resolveHaivePaths as resolveHaivePaths22,
   tokenizeQuery as tokenizeQuery6,
   trackReads as trackReads4
 } from "@hiveai/core";
 function registerMemoryQuery(memory2) {
   memory2.command("query <text>").alias("search").description("Search memories by id, tag, or substring (AND, OR fallback). Alias: search").option("-d, --dir <dir>", "project root").option("--limit <n>", "max results", "20").option("--scope <scope>", "personal | team | module").option("--status <csv>", "filter by status (draft,proposed,validated,stale,rejected)").option("--show-rejected", "include rejected memories (hidden by default)").action(async (text, opts) => {
-    const root = findProjectRoot24(opts.dir);
-    const paths = resolveHaivePaths21(root);
-    if (!existsSync43(paths.memoriesDir)) {
+    const root = findProjectRoot25(opts.dir);
+    const paths = resolveHaivePaths22(root);
+    if (!existsSync44(paths.memoriesDir)) {
       ui.error(`No memories directory at ${paths.memoriesDir}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -9675,7 +9839,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(path28.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path29.relative(root, filePath))}`);
       const snippet = extractSnippet2(mem.body, snippetNeedle);
       if (snippet) console.log(`  ${snippet}`);
     }
@@ -9693,21 +9857,21 @@ ${top.length} of ${matches.length} match${matches.length === 1 ? "" : "es"}`)
 
 // src/commands/memory-reject.ts
 import { writeFile as writeFile20 } from "fs/promises";
-import { existsSync as existsSync44 } from "fs";
+import { existsSync as existsSync45 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot25,
+  findProjectRoot as findProjectRoot26,
   loadUsageIndex as loadUsageIndex17,
   recordRejection as recordRejection2,
-  resolveHaivePaths as resolveHaivePaths22,
+  resolveHaivePaths as resolveHaivePaths23,
   saveUsageIndex as saveUsageIndex3,
   serializeMemory as serializeMemory18
 } from "@hiveai/core";
 function registerMemoryReject(memory2) {
   memory2.command("reject <id>").description("Record a rejection (blocks auto-promotion and lowers confidence)").option("-r, --reason <reason>", "why this memory is being rejected").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
-    const root = findProjectRoot25(opts.dir);
-    const paths = resolveHaivePaths22(root);
-    if (!existsSync44(paths.memoriesDir)) {
+    const root = findProjectRoot26(opts.dir);
+    const paths = resolveHaivePaths23(root);
+    if (!existsSync45(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -9743,22 +9907,22 @@ function registerMemoryReject(memory2) {
 }
 
 // src/commands/memory-rm.ts
-import { existsSync as existsSync45 } from "fs";
+import { existsSync as existsSync46 } from "fs";
 import { unlink as unlink3 } from "fs/promises";
-import path29 from "path";
+import path30 from "path";
 import { createInterface as createInterface2 } from "readline/promises";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot26,
+  findProjectRoot as findProjectRoot27,
   loadUsageIndex as loadUsageIndex18,
-  resolveHaivePaths as resolveHaivePaths23,
+  resolveHaivePaths as resolveHaivePaths24,
   saveUsageIndex as saveUsageIndex4
 } from "@hiveai/core";
 function registerMemoryRm(memory2) {
   memory2.command("rm <id>").description("Delete a memory file (and its usage entry by default)").option("-y, --yes", "skip the confirmation prompt").option("--keep-usage", "do not remove the usage.json entry").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
-    const root = findProjectRoot26(opts.dir);
-    const paths = resolveHaivePaths23(root);
-    if (!existsSync45(paths.memoriesDir)) {
+    const root = findProjectRoot27(opts.dir);
+    const paths = resolveHaivePaths24(root);
+    if (!existsSync46(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -9770,7 +9934,7 @@ function registerMemoryRm(memory2) {
       process.exitCode = 1;
       return;
     }
-    const rel = path29.relative(root, found.filePath);
+    const rel = path30.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();
@@ -9794,22 +9958,22 @@ function registerMemoryRm(memory2) {
 }
 
 // src/commands/memory-show.ts
-import { existsSync as existsSync46 } from "fs";
-import { readFile as readFile13 } from "fs/promises";
-import path30 from "path";
+import { existsSync as existsSync47 } from "fs";
+import { readFile as readFile14 } from "fs/promises";
+import path31 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence10,
-  findProjectRoot as findProjectRoot27,
+  findProjectRoot as findProjectRoot28,
   getUsage as getUsage15,
   loadUsageIndex as loadUsageIndex19,
-  resolveHaivePaths as resolveHaivePaths24
+  resolveHaivePaths as resolveHaivePaths25
 } from "@hiveai/core";
 function registerMemoryShow(memory2) {
   memory2.command("show <id>").description("Print a memory's frontmatter, body, and confidence/usage").option("--raw", "print the raw file contents instead of a summary").option("-d, --dir <dir>", "project root").action(async (id, opts) => {
-    const root = findProjectRoot27(opts.dir);
-    const paths = resolveHaivePaths24(root);
-    if (!existsSync46(paths.memoriesDir)) {
+    const root = findProjectRoot28(opts.dir);
+    const paths = resolveHaivePaths25(root);
+    if (!existsSync47(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}.`);
       process.exitCode = 1;
       return;
@@ -9822,7 +9986,7 @@ function registerMemoryShow(memory2) {
       return;
     }
     if (opts.raw) {
-      console.log(await readFile13(found.filePath, "utf8"));
+      console.log(await readFile14(found.filePath, "utf8"));
       return;
     }
     const fm = found.memory.frontmatter;
@@ -9838,7 +10002,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:")}       ${path30.relative(root, found.filePath)}`);
+    console.log(`${ui.dim("file:")}       ${path31.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}`);
@@ -9853,21 +10017,21 @@ function registerMemoryShow(memory2) {
 }
 
 // src/commands/memory-stats.ts
-import { existsSync as existsSync47 } from "fs";
-import path31 from "path";
+import { existsSync as existsSync48 } from "fs";
+import path33 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence11,
-  findProjectRoot as findProjectRoot28,
+  findProjectRoot as findProjectRoot29,
   getUsage as getUsage16,
   loadUsageIndex as loadUsageIndex20,
-  resolveHaivePaths as resolveHaivePaths25
+  resolveHaivePaths as resolveHaivePaths26
 } from "@hiveai/core";
 function registerMemoryStats(memory2) {
   memory2.command("stats").description("Show usage stats and confidence levels per memory").option("--id <id>", "show stats for a single memory id").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot28(opts.dir);
-    const paths = resolveHaivePaths25(root);
-    if (!existsSync47(paths.memoriesDir)) {
+    const root = findProjectRoot29(opts.dir);
+    const paths = resolveHaivePaths26(root);
+    if (!existsSync48(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -9892,19 +10056,19 @@ 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(path31.relative(root, filePath))}`);
+      console.log(`  ${ui.dim(path33.relative(root, filePath))}`);
     }
   });
 }
 
 // src/commands/memory-verify.ts
 import { writeFile as writeFile21 } from "fs/promises";
-import { existsSync as existsSync48 } from "fs";
-import path33 from "path";
+import { existsSync as existsSync49 } from "fs";
+import path34 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot29,
-  resolveHaivePaths as resolveHaivePaths26,
+  findProjectRoot as findProjectRoot30,
+  resolveHaivePaths as resolveHaivePaths27,
   serializeMemory as serializeMemory19,
   verifyAnchor as verifyAnchor3
 } from "@hiveai/core";
@@ -9912,9 +10076,9 @@ function registerMemoryVerify(memory2) {
   memory2.command("verify").description(
     "Check that memory anchor paths still exist in the current codebase.\n\n  A memory is 'stale' when its anchored file or symbol was moved, deleted, or renamed.\n  Stale memories are shown with a warning in get_briefing and should be updated or deleted.\n\n  haive sync runs this automatically. Use this command for on-demand checks or in CI.\n\n  CI recommendation: add 'haive memory verify' to your haive-sync.yml PR check job\n  to catch stale memories before they reach main.\n\n  Examples:\n    haive memory verify                          # check all, report only\n    haive memory verify --update                 # mark stale/fresh on disk\n    haive memory verify --id 2026-04-28-gotcha-x # check one memory\n"
   ).option("--id <id>", "verify a single memory by id").option("--all", "verify every memory (default if --id is omitted)").option("--update", "write status=stale or status=validated back to disk").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot29(opts.dir);
-    const paths = resolveHaivePaths26(root);
-    if (!existsSync48(paths.memoriesDir)) {
+    const root = findProjectRoot30(opts.dir);
+    const paths = resolveHaivePaths27(root);
+    if (!existsSync49(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -9937,7 +10101,7 @@ function registerMemoryVerify(memory2) {
         anchorlessIds.push(mem.frontmatter.id);
         continue;
       }
-      const rel = path33.relative(root, filePath);
+      const rel = path34.relative(root, filePath);
       if (result.stale) {
         staleCount++;
         console.log(`${ui.bold("STALE")}  ${mem.frontmatter.id}`);
@@ -10000,30 +10164,30 @@ function applyVerification2(mem, result) {
 }
 
 // src/commands/memory-import.ts
-import { readFile as readFile14 } from "fs/promises";
-import { existsSync as existsSync49 } from "fs";
+import { readFile as readFile15 } from "fs/promises";
+import { existsSync as existsSync50 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot30,
-  resolveHaivePaths as resolveHaivePaths27
+  findProjectRoot as findProjectRoot31,
+  resolveHaivePaths as resolveHaivePaths28
 } from "@hiveai/core";
 function registerMemoryImport(memory2) {
   memory2.command("import").description(
     "Parse a Markdown file and suggest memories via the import_docs MCP prompt (prints a ready-to-use prompt invocation)"
   ).requiredOption("--from <file>", "Markdown/text file to import from").option("--scope <scope>", "personal | team (default: team)", "team").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot30(opts.dir);
-    const paths = resolveHaivePaths27(root);
-    if (!existsSync49(paths.haiveDir)) {
+    const root = findProjectRoot31(opts.dir);
+    const paths = resolveHaivePaths28(root);
+    if (!existsSync50(paths.haiveDir)) {
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
     }
-    if (!existsSync49(opts.from)) {
+    if (!existsSync50(opts.from)) {
       ui.error(`File not found: ${opts.from}`);
       process.exitCode = 1;
       return;
     }
-    const content = await readFile14(opts.from, "utf8");
+    const content = await readFile15(opts.from, "utf8");
     const scope = opts.scope ?? "team";
     ui.info(`Preparing import from: ${opts.from}  (scope=${scope})`);
     ui.info(`Content length: ${content.length} chars`);
@@ -10051,14 +10215,14 @@ function registerMemoryImport(memory2) {
 }
 
 // src/commands/memory-import-changelog.ts
-import { existsSync as existsSync50 } from "fs";
-import { readFile as readFile15, mkdir as mkdir14, writeFile as writeFile23 } from "fs/promises";
-import path34 from "path";
+import { existsSync as existsSync51 } from "fs";
+import { readFile as readFile16, mkdir as mkdir14, writeFile as writeFile23 } from "fs/promises";
+import path35 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter9,
-  findProjectRoot as findProjectRoot31,
-  resolveHaivePaths as resolveHaivePaths28,
+  findProjectRoot as findProjectRoot32,
+  resolveHaivePaths as resolveHaivePaths29,
   serializeMemory as serializeMemory20
 } from "@hiveai/core";
 function parseChangelog(content) {
@@ -10123,15 +10287,15 @@ function registerMemoryImportChangelog(memory2) {
     "--versions <csv>",
     "only import specific versions (comma-separated), or 'latest' for the most recent breaking version"
   ).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot31(opts.dir);
-    const paths = resolveHaivePaths28(root);
-    const changelogPath = path34.resolve(root, opts.fromChangelog);
-    if (!existsSync50(changelogPath)) {
+    const root = findProjectRoot32(opts.dir);
+    const paths = resolveHaivePaths29(root);
+    const changelogPath = path35.resolve(root, opts.fromChangelog);
+    if (!existsSync51(changelogPath)) {
       ui.error(`CHANGELOG not found: ${changelogPath}`);
       process.exitCode = 1;
       return;
     }
-    const content = await readFile15(changelogPath, "utf8");
+    const content = await readFile16(changelogPath, "utf8");
     let entries = parseChangelog(content);
     if (entries.length === 0) {
       ui.warn("No breaking changes, deprecations, or removals found in the CHANGELOG.");
@@ -10146,9 +10310,9 @@ function registerMemoryImportChangelog(memory2) {
         entries = entries.filter((e) => requested.includes(e.version));
       }
     }
-    const pkgName = opts.package ?? path34.basename(path34.dirname(changelogPath));
+    const pkgName = opts.package ?? path35.basename(path35.dirname(changelogPath));
     const scope = opts.scope ?? "team";
-    const teamDir = path34.join(paths.memoriesDir, scope);
+    const teamDir = path35.join(paths.memoriesDir, scope);
     await mkdir14(teamDir, { recursive: true });
     let saved = 0;
     for (const entry of entries) {
@@ -10171,7 +10335,7 @@ function registerMemoryImportChangelog(memory2) {
         lines.push("");
       }
       lines.push(
-        `**Source:** \`${path34.relative(root, changelogPath)}\`  
+        `**Source:** \`${path35.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, "-")}`;
@@ -10186,11 +10350,11 @@ function registerMemoryImportChangelog(memory2) {
           pkgName.replace(/[^a-z0-9]/gi, "-").toLowerCase(),
           `v${entry.version}`
         ],
-        paths: [path34.relative(root, changelogPath)],
+        paths: [path35.relative(root, changelogPath)],
         topic: `changelog-${pkgName}-${entry.version}`
       });
       await writeFile23(
-        path34.join(teamDir, `${fm.id}.md`),
+        path35.join(teamDir, `${fm.id}.md`),
         serializeMemory20({ frontmatter: fm, body: lines.join("\n") }),
         "utf8"
       );
@@ -10213,17 +10377,17 @@ ${ui.bold(`Imported ${saved} changelog entr${saved === 1 ? "y" : "ies"} from ${p
 }
 
 // src/commands/memory-digest.ts
-import { existsSync as existsSync51 } from "fs";
+import { existsSync as existsSync53 } from "fs";
 import { writeFile as writeFile24 } from "fs/promises";
-import path35 from "path";
+import path36 from "path";
 import "commander";
 import {
   deriveConfidence as deriveConfidence12,
-  findProjectRoot as findProjectRoot32,
+  findProjectRoot as findProjectRoot33,
   getUsage as getUsage17,
   loadMemoriesFromDir as loadMemoriesFromDir26,
   loadUsageIndex as loadUsageIndex21,
-  resolveHaivePaths as resolveHaivePaths29
+  resolveHaivePaths as resolveHaivePaths30
 } from "@hiveai/core";
 var CONFIDENCE_EMOJI = {
   unverified: "\u2B1C",
@@ -10236,9 +10400,9 @@ function registerMemoryDigest(program2) {
   program2.command("digest").description(
     "Generate a Markdown review digest of recently added or updated memories.\n\n  Groups memories by type, shows confidence, status, read count, and anchor info.\n  Each memory has action checkboxes (approve / reject / keep as-is) for peer review.\n\n  Use this to do a bulk weekly review of team memories, or share with teammates\n  as a pull-request attachment so humans can validate what the AI captured.\n\n  Examples:\n    haive memory digest                         # last 7 days, team scope\n    haive memory digest --days 30 --scope all   # last 30 days, all scopes\n    haive memory digest --out review.md         # write to file\n"
   ).option("--days <n>", "look-back window in days (default: 7)", "7").option("--scope <scope>", "personal | team | module | all (default: team)", "team").option("--out <file>", "write digest to a file instead of stdout").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot32(opts.dir);
-    const paths = resolveHaivePaths29(root);
-    if (!existsSync51(paths.memoriesDir)) {
+    const root = findProjectRoot33(opts.dir);
+    const paths = resolveHaivePaths30(root);
+    if (!existsSync53(paths.memoriesDir)) {
       ui.error("No .ai/memories found. Run `haive init` first.");
       process.exitCode = 1;
       return;
@@ -10310,7 +10474,7 @@ function registerMemoryDigest(program2) {
     );
     const digest = lines.join("\n");
     if (opts.out) {
-      const outPath = path35.resolve(process.cwd(), opts.out);
+      const outPath = path36.resolve(process.cwd(), opts.out);
       await writeFile24(outPath, digest, "utf8");
       ui.success(`Digest written to ${opts.out}  (${recent.length} memor${recent.length === 1 ? "y" : "ies"})`);
     } else {
@@ -10320,23 +10484,23 @@ function registerMemoryDigest(program2) {
 }
 
 // src/commands/session-end.ts
-import { writeFile as writeFile25, mkdir as mkdir15, readFile as readFile16, rm as rm2 } from "fs/promises";
-import { existsSync as existsSync53 } from "fs";
+import { writeFile as writeFile25, mkdir as mkdir15, readFile as readFile17, rm as rm2 } from "fs/promises";
+import { existsSync as existsSync54 } from "fs";
 import { spawn as spawn4 } from "child_process";
-import path36 from "path";
+import path37 from "path";
 import "commander";
 import {
   buildFrontmatter as buildFrontmatter10,
-  findProjectRoot as findProjectRoot33,
+  findProjectRoot as findProjectRoot34,
   loadMemoriesFromDir as loadMemoriesFromDir27,
   memoryFilePath as memoryFilePath9,
-  resolveHaivePaths as resolveHaivePaths30,
+  resolveHaivePaths as resolveHaivePaths31,
   serializeMemory as serializeMemory21
 } from "@hiveai/core";
 async function buildAutoRecap(paths) {
-  const obsFile = path36.join(paths.haiveDir, ".cache", "observations.jsonl");
-  if (!existsSync53(obsFile)) return await buildGitAutoRecap(paths);
-  const raw = await readFile16(obsFile, "utf8").catch(() => "");
+  const obsFile = path37.join(paths.haiveDir, ".cache", "observations.jsonl");
+  if (!existsSync54(obsFile)) return await buildGitAutoRecap(paths);
+  const raw = await readFile17(obsFile, "utf8").catch(() => "");
   if (!raw.trim()) return await buildGitAutoRecap(paths);
   const lines = raw.split("\n").filter(Boolean);
   const obs = [];
@@ -10524,9 +10688,9 @@ function registerSessionEnd(session2) {
       --next "Add integration tests for webhook signature validation"
 `
   ).option("--goal <text>", "what you were trying to accomplish (1\u20132 sentences)").option("--accomplished <text>", "what was actually done (bullet list recommended)").option("--discoveries <text>", "bugs, surprises, or inconsistencies found during this session").option("--files <csv>", "key files touched, comma-separated (used as anchor for staleness detection)").option("--next <text>", "what should happen next (for the next session or a teammate)").option("--scope <scope>", "personal | team | module (default: personal)", "personal").option("--module <name>", "module name (required when scope=module)").option("--auto", "synthesize the recap from .ai/.cache/observations.jsonl (used by Claude Code SessionEnd hook)").option("--quiet", "suppress non-error output (for hook use)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot33(opts.dir);
-    const paths = resolveHaivePaths30(root);
-    if (!existsSync53(paths.haiveDir)) {
+    const root = findProjectRoot34(opts.dir);
+    const paths = resolveHaivePaths31(root);
+    if (!existsSync54(paths.haiveDir)) {
       if (opts.auto || opts.quiet) return;
       ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
@@ -10559,18 +10723,18 @@ function registerSessionEnd(session2) {
     });
     const topic = recapTopic2(scope, opts.module);
     const filesTouched = parseCsv5(resolvedFiles).map((p) => normalizeAnchorPath(root, p));
-    const missingPaths = filesTouched.filter((p) => !existsSync53(path36.resolve(root, p)));
+    const missingPaths = filesTouched.filter((p) => !existsSync54(path37.resolve(root, p)));
     if (missingPaths.length > 0 && !opts.quiet) {
       ui.warn(`Anchor path${missingPaths.length > 1 ? "s" : ""} not found in project (will be stale):`);
       for (const p of missingPaths) ui.warn(`  \u2717 ${p}`);
     }
     const cleanupObservations = async () => {
       if (!opts.auto) return;
-      const obsFile = path36.join(paths.haiveDir, ".cache", "observations.jsonl");
-      if (existsSync53(obsFile)) await rm2(obsFile).catch(() => {
+      const obsFile = path37.join(paths.haiveDir, ".cache", "observations.jsonl");
+      if (existsSync54(obsFile)) await rm2(obsFile).catch(() => {
       });
     };
-    if (existsSync53(paths.memoriesDir)) {
+    if (existsSync54(paths.memoriesDir)) {
       const existing = await loadMemoriesFromDir27(paths.memoriesDir);
       const topicMatch = existing.find(
         ({ memory: memory2 }) => memory2.frontmatter.topic === topic && memory2.frontmatter.scope === scope && (!opts.module || memory2.frontmatter.module === opts.module)
@@ -10591,7 +10755,7 @@ function registerSessionEnd(session2) {
         await cleanupObservations();
         if (!opts.quiet) {
           ui.success(`Session recap updated (revision #${revisionCount})`);
-          ui.info(`id=${fm.id}  file=${path36.relative(root, topicMatch.filePath)}`);
+          ui.info(`id=${fm.id}  file=${path37.relative(root, topicMatch.filePath)}`);
           ui.info("Tip: `haive stats --export-report` generates a usage JSON suitable for dashboards.");
         }
         return;
@@ -10608,12 +10772,12 @@ function registerSessionEnd(session2) {
       status: "validated"
     });
     const file = memoryFilePath9(paths, frontmatter.scope, frontmatter.id, frontmatter.module);
-    await mkdir15(path36.dirname(file), { recursive: true });
+    await mkdir15(path37.dirname(file), { recursive: true });
     await writeFile25(file, serializeMemory21({ frontmatter, body }), "utf8");
     await cleanupObservations();
     if (!opts.quiet) {
       ui.success(`Session recap created`);
-      ui.info(`id=${frontmatter.id}  scope=${scope}  file=${path36.relative(root, file)}`);
+      ui.info(`id=${frontmatter.id}  scope=${scope}  file=${path37.relative(root, file)}`);
       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`.");
     }
@@ -10625,22 +10789,22 @@ function parseCsv5(value) {
 }
 function normalizeAnchorPath(root, filePath) {
   if (!filePath) return filePath;
-  if (!path36.isAbsolute(filePath)) return filePath;
-  const rel = path36.relative(root, filePath);
+  if (!path37.isAbsolute(filePath)) return filePath;
+  const rel = path37.relative(root, filePath);
   if (rel.startsWith("..")) return filePath;
   return rel;
 }
 
 // src/commands/snapshot.ts
-import { existsSync as existsSync54 } from "fs";
+import { existsSync as existsSync55 } from "fs";
 import { readdir as readdir4 } from "fs/promises";
-import path37 from "path";
+import path38 from "path";
 import "commander";
 import {
   diffContract,
-  findProjectRoot as findProjectRoot34,
-  loadConfig as loadConfig6,
-  resolveHaivePaths as resolveHaivePaths31,
+  findProjectRoot as findProjectRoot35,
+  loadConfig as loadConfig7,
+  resolveHaivePaths as resolveHaivePaths32,
   snapshotContract
 } from "@hiveai/core";
 function registerSnapshot(program2) {
@@ -10665,16 +10829,16 @@ function registerSnapshot(program2) {
     "--format <format>",
     "contract format: openapi | graphql | proto | typescript | json-schema (auto-detected if omitted)"
   ).option("--diff", "compare the contract against its stored snapshot").option("--list", "list all stored contract snapshots").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot34(opts.dir);
-    const paths = resolveHaivePaths31(root);
-    if (!existsSync54(paths.haiveDir)) {
+    const root = findProjectRoot35(opts.dir);
+    const paths = resolveHaivePaths32(root);
+    if (!existsSync55(paths.haiveDir)) {
       ui.error("No .ai/ found. Run `haive init` first.");
       process.exitCode = 1;
       return;
     }
     if (opts.list) {
-      const contractsDir = path37.join(paths.haiveDir, "contracts");
-      if (!existsSync54(contractsDir)) {
+      const contractsDir = path38.join(paths.haiveDir, "contracts");
+      if (!existsSync55(contractsDir)) {
         console.log(ui.dim("No contract snapshots found."));
         return;
       }
@@ -10694,7 +10858,7 @@ function registerSnapshot(program2) {
     }
     if (opts.diff) {
       if (!opts.name) {
-        const config2 = await loadConfig6(paths);
+        const config2 = await loadConfig7(paths);
         const contracts = config2.contractFiles ?? [];
         if (contracts.length === 0) {
           ui.error("--diff requires --name, or configure contractFiles in haive.config.json");
@@ -10706,7 +10870,7 @@ function registerSnapshot(program2) {
         }
         return;
       }
-      const config = await loadConfig6(paths);
+      const config = await loadConfig7(paths);
       const configured = (config.contractFiles ?? []).find((c) => c.name === opts.name);
       if (!configured && !opts.contract) {
         ui.error(
@@ -10729,7 +10893,7 @@ function registerSnapshot(program2) {
       return;
     }
     const contractPath = opts.contract;
-    const name = opts.name ?? path37.basename(contractPath, path37.extname(contractPath));
+    const name = opts.name ?? path38.basename(contractPath, path38.extname(contractPath));
     const format = opts.format ?? detectFormat(contractPath) ?? "openapi";
     const contract = { name, path: contractPath, format };
     try {
@@ -10784,8 +10948,8 @@ async function runDiff(root, haiveDir, contract) {
   }
 }
 function detectFormat(filePath) {
-  const ext = path37.extname(filePath).toLowerCase();
-  const base = path37.basename(filePath).toLowerCase();
+  const ext = path38.extname(filePath).toLowerCase();
+  const base = path38.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";
@@ -10798,16 +10962,16 @@ function detectFormat(filePath) {
 }
 
 // src/commands/hub.ts
-import { existsSync as existsSync55 } from "fs";
-import { mkdir as mkdir16, readFile as readFile17, writeFile as writeFile26, copyFile } from "fs/promises";
-import path38 from "path";
+import { existsSync as existsSync56 } from "fs";
+import { mkdir as mkdir16, readFile as readFile18, writeFile as writeFile26, copyFile } from "fs/promises";
+import path39 from "path";
 import { spawnSync as spawnSync5 } from "child_process";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot35,
-  loadConfig as loadConfig7,
+  findProjectRoot as findProjectRoot36,
+  loadConfig as loadConfig8,
   loadMemoriesFromDir as loadMemoriesFromDir28,
-  resolveHaivePaths as resolveHaivePaths32,
+  resolveHaivePaths as resolveHaivePaths33,
   saveConfig as saveConfig3,
   serializeMemory as serializeMemory23
 } from "@hiveai/core";
@@ -10819,7 +10983,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 = path38.resolve(hubPath);
+    const absPath = path39.resolve(hubPath);
     await mkdir16(absPath, { recursive: true });
     const gitCheck = spawnSync5("git", ["rev-parse", "--git-dir"], { cwd: absPath });
     if (gitCheck.status !== 0) {
@@ -10830,10 +10994,10 @@ function registerHub(program2) {
         return;
       }
     }
-    const sharedDir = path38.join(absPath, ".ai", "memories", "shared");
+    const sharedDir = path39.join(absPath, ".ai", "memories", "shared");
     await mkdir16(sharedDir, { recursive: true });
     await writeFile26(
-      path38.join(absPath, ".ai", "README.md"),
+      path39.join(absPath, ".ai", "README.md"),
       `# hAIve Team Knowledge Hub
 
 This repo is a shared knowledge hub for hAIve.
@@ -10855,7 +11019,7 @@ haive hub pull   # import into a project
       "utf8"
     );
     await writeFile26(
-      path38.join(absPath, ".gitignore"),
+      path39.join(absPath, ".gitignore"),
       ".ai/.cache/\n.ai/memories/personal/\n",
       "utf8"
     );
@@ -10870,7 +11034,7 @@ haive hub pull   # import into a project
         `
 Next steps:
   1. Add hubPath to your project's .ai/haive.config.json:
-       { "hubPath": "${path38.relative(process.cwd(), absPath)}" }
+       { "hubPath": "${path39.relative(process.cwd(), absPath)}" }
   2. Run \`haive hub push\` to publish your shared memories
   3. Share ${absPath} with teammates (git remote, NFS, etc.)
 `
@@ -10889,9 +11053,9 @@ Next steps:
     haive hub push --commit --message "feat: add payment API contract memories"
 `
   ).option("-d, --dir <dir>", "project root").option("--commit", "auto-commit to the hub repo after pushing").option("--message <msg>", "commit message for the hub (used with --commit)").action(async (opts) => {
-    const root = findProjectRoot35(opts.dir);
-    const paths = resolveHaivePaths32(root);
-    const config = await loadConfig7(paths);
+    const root = findProjectRoot36(opts.dir);
+    const paths = resolveHaivePaths33(root);
+    const config = await loadConfig8(paths);
     if (!config.hubPath) {
       ui.error(
         'hubPath not configured in .ai/haive.config.json.\n  Add: { "hubPath": "../team-hub" }\n  Or run: haive hub init <path> first.'
@@ -10899,14 +11063,14 @@ Next steps:
       process.exitCode = 1;
       return;
     }
-    const hubRoot = path38.resolve(root, config.hubPath);
-    if (!existsSync55(hubRoot)) {
+    const hubRoot = path39.resolve(root, config.hubPath);
+    if (!existsSync56(hubRoot)) {
       ui.error(`Hub not found at ${hubRoot}. Run \`haive hub init ${config.hubPath}\` first.`);
       process.exitCode = 1;
       return;
     }
-    const projectName = path38.basename(root);
-    const destDir = path38.join(hubRoot, ".ai", "memories", "shared", projectName);
+    const projectName = path39.basename(root);
+    const destDir = path39.join(hubRoot, ".ai", "memories", "shared", projectName);
     await mkdir16(destDir, { recursive: true });
     const all = await loadMemoriesFromDir28(paths.memoriesDir);
     const shared = all.filter(
@@ -10925,7 +11089,7 @@ Next steps:
     for (const { memory: memory2 } of shared) {
       const fm = memory2.frontmatter;
       const fileName = `${fm.id}.md`;
-      const destPath = path38.join(destDir, fileName);
+      const destPath = path39.join(destDir, fileName);
       await writeFile26(destPath, serializeMemory23(memory2), "utf8");
       pushed++;
     }
@@ -10933,7 +11097,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", path38.join(".ai", "memories", "shared", projectName)], {
+      spawnSync5("git", ["add", path39.join(".ai", "memories", "shared", projectName)], {
         cwd: hubRoot
       });
       const commit = spawnSync5("git", ["commit", "-m", message], {
@@ -10958,9 +11122,9 @@ Next steps:
   hub.command("pull").description(
     "Pull shared memories from the hub into this project.\n\n  Imports all memories from hub/.ai/memories/shared/ EXCEPT this project's own.\n  Imported memories land in .ai/memories/shared/<source-project-name>/.\n\n  Examples:\n    haive hub pull\n"
   ).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot35(opts.dir);
-    const paths = resolveHaivePaths32(root);
-    const config = await loadConfig7(paths);
+    const root = findProjectRoot36(opts.dir);
+    const paths = resolveHaivePaths33(root);
+    const config = await loadConfig8(paths);
     if (!config.hubPath) {
       ui.error(
         'hubPath not configured in .ai/haive.config.json.\n  Add: { "hubPath": "../team-hub" }\n  Or run: haive hub init <path> first.'
@@ -10968,13 +11132,13 @@ Next steps:
       process.exitCode = 1;
       return;
     }
-    const hubRoot = path38.resolve(root, config.hubPath);
-    const hubSharedDir = path38.join(hubRoot, ".ai", "memories", "shared");
-    if (!existsSync55(hubSharedDir)) {
+    const hubRoot = path39.resolve(root, config.hubPath);
+    const hubSharedDir = path39.join(hubRoot, ".ai", "memories", "shared");
+    if (!existsSync56(hubSharedDir)) {
       ui.warn("Hub has no shared memories yet. Run `haive hub push` from other projects first.");
       return;
     }
-    const projectName = path38.basename(root);
+    const projectName = path39.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) {
@@ -10984,17 +11148,17 @@ Next steps:
     let totalImported = 0;
     let totalUpdated = 0;
     for (const sourceName of projectDirs) {
-      const sourceDir = path38.join(hubSharedDir, sourceName);
-      const destDir = path38.join(paths.memoriesDir, "shared", sourceName);
+      const sourceDir = path39.join(hubSharedDir, sourceName);
+      const destDir = path39.join(paths.memoriesDir, "shared", sourceName);
       await mkdir16(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 = path38.join(sourceDir, file);
-        const destPath = path38.join(destDir, file);
-        const fileContent = await readFile17(srcPath, "utf8");
+        const srcPath = path39.join(sourceDir, file);
+        const destPath = path39.join(destDir, file);
+        const fileContent = await readFile18(srcPath, "utf8");
         const alreadyTagged = fileContent.includes(`cross-repo:${sourceName}`);
         if (!alreadyTagged) {
           await copyFile(srcPath, destPath);
@@ -11017,21 +11181,21 @@ Next steps:
     );
   });
   hub.command("status").description("Show hub sync status.").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot35(opts.dir);
-    const paths = resolveHaivePaths32(root);
-    const config = await loadConfig7(paths);
+    const root = findProjectRoot36(opts.dir);
+    const paths = resolveHaivePaths33(root);
+    const config = await loadConfig8(paths);
     console.log(ui.bold("Hub status"));
     console.log(
       `  hubPath: ${config.hubPath ? ui.green(config.hubPath) : ui.dim("not configured")}`
     );
-    const sharedDir = path38.join(paths.memoriesDir, "shared");
-    if (existsSync55(sharedDir)) {
+    const sharedDir = path39.join(paths.memoriesDir, "shared");
+    if (existsSync56(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(path38.join(sharedDir, src))).filter((f) => f.endsWith(".md"));
+        const files = (await readdir7(path39.join(sharedDir, src))).filter((f) => f.endsWith(".md"));
         console.log(`    ${src}: ${files.length} memor${files.length === 1 ? "y" : "ies"}`);
       }
     } else {
@@ -11046,7 +11210,7 @@ Next steps:
     if (outgoing.length > 0) {
       console.log(ui.dim("  Run `haive hub push` to publish them to the hub."));
     }
-    void readFile17;
+    void readFile18;
     void writeFile26;
     void saveConfig3;
   });
@@ -11054,17 +11218,17 @@ Next steps:
 
 // src/commands/stats.ts
 import "commander";
-import { existsSync as existsSync56 } from "fs";
+import { existsSync as existsSync57 } from "fs";
 import { mkdir as mkdir17, writeFile as writeFile27 } from "fs/promises";
-import path39 from "path";
+import path40 from "path";
 import {
   aggregateUsage,
-  findProjectRoot as findProjectRoot36,
+  findProjectRoot as findProjectRoot37,
   loadMemoriesFromDir as loadMemoriesFromDir29,
   loadUsageIndex as loadUsageIndex23,
   parseSince,
   readUsageEvents as readUsageEvents2,
-  resolveHaivePaths as resolveHaivePaths33,
+  resolveHaivePaths as resolveHaivePaths34,
   usageLogSize
 } from "@hiveai/core";
 function registerStats(program2) {
@@ -11073,8 +11237,8 @@ function registerStats(program2) {
     "write a JSON rollup (tools + briefing counts + heuristic ROI hints). Parent dirs are created if needed.",
     void 0
   ).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot36(opts.dir);
-    const paths = resolveHaivePaths33(root);
+    const root = findProjectRoot37(opts.dir);
+    const paths = resolveHaivePaths34(root);
     if (opts.exportReport) {
       await writeRoiReport(paths, root, opts.since ?? "30d", opts.exportReport);
       return;
@@ -11128,11 +11292,11 @@ function registerStats(program2) {
   });
 }
 async function writeRoiReport(paths, root, sinceRaw, outRelative) {
-  const outAbs = path39.isAbsolute(outRelative) ? path39.resolve(outRelative) : path39.resolve(root, outRelative);
+  const outAbs = path40.isAbsolute(outRelative) ? path40.resolve(outRelative) : path40.resolve(root, outRelative);
   const size = await usageLogSize(paths);
   let events = await readUsageEvents2(paths);
   let memoryCount = { team: 0, personal: 0, total_skipped_session: 0 };
-  if (existsSync56(paths.memoriesDir)) {
+  if (existsSync57(paths.memoriesDir)) {
     const mems = await loadMemoriesFromDir29(paths.memoriesDir);
     for (const { memory: memory2 } of mems) {
       const fm = memory2.frontmatter;
@@ -11163,7 +11327,7 @@ async function writeRoiReport(paths, root, sinceRaw, outRelative) {
     ui.warn("Usage log missing or empty \u2014 report still written with partial data.");
     events = [];
   }
-  await mkdir17(path39.dirname(outAbs), { recursive: true });
+  await mkdir17(path40.dirname(outAbs), { recursive: true });
   const payload = {
     generated_at: (/* @__PURE__ */ new Date()).toISOString(),
     project_root: root,
@@ -11227,13 +11391,13 @@ import { performance } from "perf_hooks";
 import "commander";
 import {
   estimateTokens as estimateTokens3,
-  findProjectRoot as findProjectRoot37,
-  resolveHaivePaths as resolveHaivePaths34
+  findProjectRoot as findProjectRoot38,
+  resolveHaivePaths as resolveHaivePaths35
 } from "@hiveai/core";
 function registerBench(program2) {
   program2.command("bench").description("Self-test the local hAIve setup: runs core MCP tools against this project and reports latency + payload size.").option("-t, --task <task>", "task description for ranking-aware tools", "audit dependencies for security risks").option("--json", "emit JSON instead of a table", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot37(opts.dir);
-    const paths = resolveHaivePaths34(root);
+    const root = findProjectRoot38(opts.dir);
+    const paths = resolveHaivePaths35(root);
     const ctx = { paths };
     const task = opts.task ?? "audit dependencies for security risks";
     const scenarios = [
@@ -11352,11 +11516,11 @@ function summarize(name, t0, payload, notes) {
 }
 
 // src/commands/benchmark.ts
-import { existsSync as existsSync57 } from "fs";
-import { readdir as readdir5, readFile as readFile18, writeFile as writeFile28 } from "fs/promises";
-import path40 from "path";
+import { existsSync as existsSync58 } from "fs";
+import { readdir as readdir5, readFile as readFile19, writeFile as writeFile28 } from "fs/promises";
+import path41 from "path";
 import "commander";
-import { estimateTokens as estimateTokens4, findProjectRoot as findProjectRoot38 } from "@hiveai/core";
+import { estimateTokens as estimateTokens4, findProjectRoot as findProjectRoot39 } from "@hiveai/core";
 function registerBenchmark(program2) {
   const benchmark = program2.command("benchmark").description("Official hAIve benchmark/demo utilities for measuring agent enforcement value.");
   benchmark.command("report").description("Summarize BENCHMARK_AGENT_REPORT.md files from a paired hAIve/plain agent benchmark.").option("-d, --dir <dir>", "benchmark root", "benchmarks/agent-benchmark").option("--out <file>", "write a Markdown report").option("--json", "emit JSON", false).action(async (opts) => {
@@ -11369,9 +11533,9 @@ function registerBenchmark(program2) {
     }
     const markdown = renderMarkdown(root, summary, rows);
     if (opts.out) {
-      const outFile = path40.isAbsolute(opts.out) ? opts.out : path40.join(root, opts.out);
+      const outFile = path41.isAbsolute(opts.out) ? opts.out : path41.join(root, opts.out);
       await writeFile28(outFile, markdown, "utf8");
-      ui.success(`wrote ${path40.relative(process.cwd(), outFile)}`);
+      ui.success(`wrote ${path41.relative(process.cwd(), outFile)}`);
       return;
     }
     console.log(markdown);
@@ -11395,20 +11559,20 @@ function registerBenchmark(program2) {
 }
 function resolveBenchmarkRoot(dir) {
   const candidate = dir ?? "benchmarks/agent-benchmark";
-  if (path40.isAbsolute(candidate)) return candidate;
-  const projectRoot = findProjectRoot38(process.cwd());
-  return path40.join(projectRoot, candidate);
+  if (path41.isAbsolute(candidate)) return candidate;
+  const projectRoot = findProjectRoot39(process.cwd());
+  return path41.join(projectRoot, candidate);
 }
 async function collectRows(root) {
-  if (!existsSync57(root)) throw new Error(`Benchmark directory not found: ${root}`);
+  if (!existsSync58(root)) throw new Error(`Benchmark directory not found: ${root}`);
   const entries = await readdir5(root, { withFileTypes: true });
   const rows = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const fixtureDir = path40.join(root, entry.name);
-    const reportFile = path40.join(fixtureDir, "BENCHMARK_AGENT_REPORT.md");
-    if (!existsSync57(reportFile)) continue;
-    const report = await readFile18(reportFile, "utf8");
+    const fixtureDir = path41.join(root, entry.name);
+    const reportFile = path41.join(fixtureDir, "BENCHMARK_AGENT_REPORT.md");
+    if (!existsSync58(reportFile)) continue;
+    const report = await readFile19(reportFile, "utf8");
     rows.push(parseAgentReport(entry.name, report));
   }
   return rows.sort((a, b) => a.fixture.localeCompare(b.fixture));
@@ -11498,19 +11662,19 @@ function escapeRegExp(value) {
 
 // src/commands/memory-suggest.ts
 import { mkdir as mkdir18, writeFile as writeFile29 } from "fs/promises";
-import { existsSync as existsSync58 } from "fs";
-import path41 from "path";
+import { existsSync as existsSync59 } from "fs";
+import path43 from "path";
 import "commander";
 import {
   aggregateUsage as aggregateUsage2,
   buildFrontmatter as buildFrontmatter11,
-  findProjectRoot as findProjectRoot39,
-  loadConfig as loadConfig8,
+  findProjectRoot as findProjectRoot40,
+  loadConfig as loadConfig9,
   loadMemoriesFromDir as loadMemoriesFromDir30,
   memoryFilePath as memoryFilePath10,
   parseSince as parseSince2,
   readUsageEvents as readUsageEvents3,
-  resolveHaivePaths as resolveHaivePaths35,
+  resolveHaivePaths as resolveHaivePaths36,
   serializeMemory as serializeMemory24
 } from "@hiveai/core";
 var SEARCH_TOOLS = /* @__PURE__ */ new Set([
@@ -11527,8 +11691,8 @@ function registerMemorySuggest(memory2) {
   memory2.command("suggest").description(
     "Suggest memories to create based on recurring search queries in the usage log.\n\n  Use --auto-save to save the top-N suggestions using the project defaults.\n  In autopilot, suggestions land as validated team records; in manual mode they stay draft."
   ).option("--since <window>", "ISO date or relative (e.g. '7d', '24h')", "30d").option("--min <count>", "minimum repeat count to surface a query", "2").option("--top-n <n>", "with --auto-save, draft this many top suggestions", "3").option("--scope <scope>", "with --auto-save, scope of saved memories (personal | team; default: config default)").option("--auto-save", "save top-N suggestions as memories on disk", false).option("--json", "emit JSON instead of human-readable output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot39(opts.dir);
-    const paths = resolveHaivePaths35(root);
+    const root = findProjectRoot40(opts.dir);
+    const paths = resolveHaivePaths36(root);
     const events = await readUsageEvents3(paths);
     if (events.length === 0) {
       if (opts.json) {
@@ -11566,7 +11730,7 @@ function registerMemorySuggest(memory2) {
       inferred_type: inferType(v.tools, query)
     })).sort((a, b) => b.count - a.count);
     if (opts.autoSave) {
-      const config = await loadConfig8(paths);
+      const config = await loadConfig9(paths);
       const topN = Math.max(1, parseInt(opts.topN ?? "3", 10));
       const scope = opts.scope === "personal" || opts.scope === "team" ? opts.scope : config.defaultScope ?? "personal";
       const status = config.defaultStatus === "validated" ? "validated" : "draft";
@@ -11577,7 +11741,7 @@ function registerMemorySuggest(memory2) {
       }
       const created = [];
       const skipped = [];
-      const existing = existsSync58(paths.memoriesDir) ? await loadMemoriesFromDir30(paths.memoriesDir) : [];
+      const existing = existsSync59(paths.memoriesDir) ? await loadMemoriesFromDir30(paths.memoriesDir) : [];
       for (const s of top) {
         const slug = slugify2(s.query);
         if (!slug) {
@@ -11600,13 +11764,13 @@ function registerMemorySuggest(memory2) {
         });
         const body = renderTemplate(s, fm.id, status);
         const file = memoryFilePath10(paths, fm.scope, fm.id, fm.module);
-        await mkdir18(path41.dirname(file), { recursive: true });
-        if (existsSync58(file)) {
-          skipped.push({ query: s.query, reason: `file already exists at ${path41.relative(root, file)}` });
+        await mkdir18(path43.dirname(file), { recursive: true });
+        if (existsSync59(file)) {
+          skipped.push({ query: s.query, reason: `file already exists at ${path43.relative(root, file)}` });
           continue;
         }
         await writeFile29(file, serializeMemory24({ frontmatter: fm, body }), "utf8");
-        created.push({ id: fm.id, file: path41.relative(root, file), query: s.query });
+        created.push({ id: fm.id, file: path43.relative(root, file), query: s.query });
       }
       if (opts.json) {
         console.log(JSON.stringify({ created, skipped }, null, 2));
@@ -11704,16 +11868,16 @@ function truncate2(text, max) {
 }
 
 // src/commands/memory-archive.ts
-import { existsSync as existsSync59 } from "fs";
+import { existsSync as existsSync60 } from "fs";
 import { writeFile as writeFile30 } from "fs/promises";
-import path43 from "path";
+import path44 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot40,
+  findProjectRoot as findProjectRoot41,
   getUsage as getUsage18,
   loadMemoriesFromDir as loadMemoriesFromDir31,
   loadUsageIndex as loadUsageIndex24,
-  resolveHaivePaths as resolveHaivePaths36,
+  resolveHaivePaths as resolveHaivePaths37,
   serializeMemory as serializeMemory25
 } from "@hiveai/core";
 var MS_PER_DAY2 = 24 * 60 * 60 * 1e3;
@@ -11721,9 +11885,9 @@ function registerMemoryArchive(memory2) {
   memory2.command("archive").description(
     "Archive obsolete memories: marks status='deprecated' for memories not read in N days\n  whose anchored paths have all disappeared (or have no anchor at all).\n\n  Defaults to a DRY RUN \u2014 pass --apply to actually rewrite files.\n  Targets `attempt` memories by default since they age the fastest.\n\n  Recover later with `haive memory edit <id>` to set status back to validated."
   ).option("--since <window>", "minimum age since last read (e.g. '180d', '6m')", "180d").option("--type <type>", "limit to a memory type (default 'attempt'). Pass 'all' to scan all types.", "attempt").option("--apply", "actually rewrite files (default: dry run)", false).option("--json", "emit JSON instead of human-readable output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot40(opts.dir);
-    const paths = resolveHaivePaths36(root);
-    if (!existsSync59(paths.memoriesDir)) {
+    const root = findProjectRoot41(opts.dir);
+    const paths = resolveHaivePaths37(root);
+    if (!existsSync60(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -11744,7 +11908,7 @@ function registerMemoryArchive(memory2) {
       if (typeFilter && fm.type !== typeFilter) continue;
       if (fm.status === "deprecated" || fm.status === "rejected") continue;
       const hasAnyAnchor = fm.anchor.paths.length + fm.anchor.symbols.length > 0;
-      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync59(path43.join(paths.root, p)));
+      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync60(path44.join(paths.root, p)));
       const isAnchorless = !hasAnyAnchor;
       if (!isAnchorless && !allPathsGone) continue;
       const u = getUsage18(usage, fm.id);
@@ -11818,33 +11982,33 @@ function parseDays(input) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync60, statSync } from "fs";
-import { readFile as readFile19, stat, writeFile as writeFile31 } from "fs/promises";
-import path44 from "path";
+import { existsSync as existsSync61, statSync } from "fs";
+import { readFile as readFile20, stat, writeFile as writeFile31 } from "fs/promises";
+import path45 from "path";
 import { execFileSync, execSync as execSync3 } from "child_process";
 import "commander";
 import {
   codeMapPath as codeMapPath2,
-  findProjectRoot as findProjectRoot41,
+  findProjectRoot as findProjectRoot42,
   getUsage as getUsage19,
   loadCodeMap as loadCodeMap6,
-  loadConfig as loadConfig9,
+  loadConfig as loadConfig10,
   loadMemoriesFromDir as loadMemoriesFromDir33,
   loadUsageIndex as loadUsageIndex25,
   readUsageEvents as readUsageEvents4,
-  resolveHaivePaths as resolveHaivePaths37
+  resolveHaivePaths as resolveHaivePaths38
 } from "@hiveai/core";
 var MS_PER_DAY3 = 24 * 60 * 60 * 1e3;
 function registerDoctor(program2) {
   program2.command("doctor").description(
     "Analyze the local hAIve setup and emit actionable recommendations.\n\n  Inspects: project-context status, memory health (stale/anchorless/decay/pending),\n  code-map freshness, usage log signals (low-hit briefings, repeated empty searches).\n\n  Read-only by default. Pass --fix to apply safe autopilot repairs."
   ).option("--json", "emit JSON instead of human-readable output", false).option("--fix", "include suggested fix commands in human output", false).option("--dry-run", "with --fix, show delegated repairs without applying them", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot41(opts.dir);
-    const paths = resolveHaivePaths37(root);
+    const root = findProjectRoot42(opts.dir);
+    const paths = resolveHaivePaths38(root);
     const findings = [];
     const repairs = [];
-    const config = await loadConfig9(paths);
-    if (!existsSync60(paths.haiveDir)) {
+    const config = await loadConfig10(paths);
+    if (!existsSync61(paths.haiveDir)) {
       findings.push({
         severity: "error",
         code: "not-initialized",
@@ -11865,7 +12029,7 @@ function registerDoctor(program2) {
         })
       );
     }
-    if (!existsSync60(paths.projectContext)) {
+    if (!existsSync61(paths.projectContext)) {
       findings.push({
         severity: "warn",
         code: "no-project-context",
@@ -11873,8 +12037,8 @@ function registerDoctor(program2) {
         fix: "haive init"
       });
     } else {
-      const { readFile: readFile21 } = await import("fs/promises");
-      const content = await readFile21(paths.projectContext, "utf8");
+      const { readFile: readFile23 } = await import("fs/promises");
+      const content = await readFile23(paths.projectContext, "utf8");
       const isTemplate = content.includes("TODO \u2014 high-level overview") || content.includes("Generated by `haive init`");
       if (isTemplate) {
         findings.push({
@@ -11894,7 +12058,7 @@ function registerDoctor(program2) {
         });
       }
     }
-    const memories = existsSync60(paths.memoriesDir) ? await loadMemoriesFromDir33(paths.memoriesDir) : [];
+    const memories = existsSync61(paths.memoriesDir) ? await loadMemoriesFromDir33(paths.memoriesDir) : [];
     const now = Date.now();
     if (memories.length === 0) {
       findings.push({
@@ -12035,12 +12199,12 @@ function registerDoctor(program2) {
       }
     }
     if (config.enforcement?.requireBriefingFirst) {
-      const claudeSettings = path44.join(root, ".claude", "settings.local.json");
+      const claudeSettings = path45.join(root, ".claude", "settings.local.json");
       let hasClaudeEnforcement = false;
-      if (existsSync60(claudeSettings)) {
+      if (existsSync61(claudeSettings)) {
         try {
-          const { readFile: readFile21 } = await import("fs/promises");
-          const raw = await readFile21(claudeSettings, "utf8");
+          const { readFile: readFile23 } = await import("fs/promises");
+          const raw = await readFile23(claudeSettings, "utf8");
           hasClaudeEnforcement = raw.includes("haive enforce session-start") && raw.includes("haive enforce pre-tool-use");
         } catch {
           hasClaudeEnforcement = false;
@@ -12063,14 +12227,14 @@ function registerDoctor(program2) {
         fix: "Edit .ai/haive.config.json: set autoSessionEnd: true (or re-run `haive init` without --manual)."
       });
     }
-    findings.push(...await collectInstallFindings(root, "0.9.27"));
+    findings.push(...await collectInstallFindings(root, "0.9.29"));
     try {
       const legacyRaw = execSync3("haive-mcp --version", {
         encoding: "utf8",
         timeout: 3e3,
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      const cliVersion = "0.9.27";
+      const cliVersion = "0.9.29";
       if (legacyRaw && legacyRaw !== cliVersion) {
         findings.push({
           severity: "warn",
@@ -12086,17 +12250,17 @@ npm uninstall -g @hiveai/mcp`
     }
     {
       const configPaths = [
-        path44.join(root, ".mcp.json"),
-        path44.join(root, ".cursor", "mcp.json"),
-        path44.join(root, ".vscode", "mcp.json")
+        path45.join(root, ".mcp.json"),
+        path45.join(root, ".cursor", "mcp.json"),
+        path45.join(root, ".vscode", "mcp.json")
       ];
       const staleConfigs = [];
       for (const cfgPath of configPaths) {
-        if (!existsSync60(cfgPath)) continue;
+        if (!existsSync61(cfgPath)) continue;
         try {
-          const raw = await readFile19(cfgPath, "utf8");
+          const raw = await readFile20(cfgPath, "utf8");
           if (raw.includes('"haive-mcp"') || raw.includes("'haive-mcp'")) {
-            staleConfigs.push(path44.relative(root, cfgPath));
+            staleConfigs.push(path45.relative(root, cfgPath));
             if (opts.fix && !opts.dryRun) {
               const updated = raw.replace(/"command"\s*:\s*"haive-mcp"/g, '"command": "haive"').replace(/"args"\s*:\s*\[\]/g, '"args": ["mcp", "--stdio"]');
               await writeFile31(cfgPath, updated, "utf8");
@@ -12386,9 +12550,9 @@ which -a haive`
     ".vscode/mcp.json"
   ];
   for (const rel of integrationFiles) {
-    const file = path44.join(root, rel);
-    if (!existsSync60(file)) continue;
-    const text = await readFile19(file, "utf8").catch(() => "");
+    const file = path45.join(root, rel);
+    if (!existsSync61(file)) continue;
+    const text = await readFile20(file, "utf8").catch(() => "");
     for (const bin of extractAbsoluteHaiveBins(text)) {
       const version = versionForBinary(bin);
       if (!version) {
@@ -12412,7 +12576,7 @@ which -a haive`
 }
 async function collectWorkspaceVersionFindings(root, expectedVersion) {
   const findings = [];
-  const rootPkg = await readJson(path44.join(root, "package.json"));
+  const rootPkg = await readJson(path45.join(root, "package.json"));
   const workspacePackages = [
     "packages/core/package.json",
     "packages/embeddings/package.json",
@@ -12421,7 +12585,7 @@ async function collectWorkspaceVersionFindings(root, expectedVersion) {
   ];
   const existing = (await Promise.all(workspacePackages.map(async (rel) => ({
     rel,
-    pkg: await readJson(path44.join(root, rel))
+    pkg: await readJson(path45.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;
@@ -12483,9 +12647,9 @@ function collectGlobalHivemoduleFindings(expectedVersion) {
   }
 }
 async function readJson(file) {
-  if (!existsSync60(file)) return null;
+  if (!existsSync61(file)) return null;
   try {
-    return JSON.parse(await readFile19(file, "utf8"));
+    return JSON.parse(await readFile20(file, "utf8"));
   } catch {
     return null;
   }
@@ -12530,22 +12694,22 @@ function extractAbsoluteHaiveBins(text) {
 }
 
 // src/commands/playback.ts
-import { existsSync as existsSync61 } from "fs";
+import { existsSync as existsSync63 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot42,
+  findProjectRoot as findProjectRoot43,
   loadMemoriesFromDir as loadMemoriesFromDir34,
   parseSince as parseSince3,
   readUsageEvents as readUsageEvents5,
-  resolveHaivePaths as resolveHaivePaths38
+  resolveHaivePaths as resolveHaivePaths39
 } from "@hiveai/core";
 var MS_PER_MINUTE = 6e4;
 function registerPlayback(program2) {
   program2.command("playback").description(
     "Replay past sessions from the usage log. For each session, show:\n  - tool calls (what kind, how many)\n  - briefing tasks asked\n  - memories that have been created since then (that the session didn't have)\n\n  Useful to ask 'would today's haive have helped past me on this task?'"
   ).option("--since <window>", "limit to events in this window (e.g. '7d')", "30d").option("--session-gap <minutes>", "minutes of inactivity that splits a session", "30").option("--limit <n>", "show at most this many sessions (newest first)", "10").option("--json", "emit JSON instead of human-readable output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot42(opts.dir);
-    const paths = resolveHaivePaths38(root);
+    const root = findProjectRoot43(opts.dir);
+    const paths = resolveHaivePaths39(root);
     const events = await readUsageEvents5(paths);
     if (events.length === 0) {
       if (opts.json) {
@@ -12560,7 +12724,7 @@ function registerPlayback(program2) {
     const filtered = cutoff > 0 ? events.filter((e) => Date.parse(e.at) >= cutoff) : events;
     const gapMs = Math.max(1, parseInt(opts.sessionGap ?? "30", 10)) * MS_PER_MINUTE;
     const sessions = bucketSessions(filtered, gapMs);
-    const all = existsSync61(paths.memoriesDir) ? await loadMemoriesFromDir34(paths.memoriesDir) : [];
+    const all = existsSync63(paths.memoriesDir) ? await loadMemoriesFromDir34(paths.memoriesDir) : [];
     const memByCreatedAt = all.filter(({ memory: memory2 }) => memory2.frontmatter.type !== "session_recap").map(({ memory: memory2 }) => ({ id: memory2.frontmatter.id, at: Date.parse(memory2.frontmatter.created_at) })).sort((a, b) => a.at - b.at);
     const enriched = sessions.map((s, i) => {
       const startMs = Date.parse(s.start);
@@ -12650,8 +12814,8 @@ function truncate3(text, max) {
 import { spawn as spawn5 } from "child_process";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot43,
-  resolveHaivePaths as resolveHaivePaths39
+  findProjectRoot as findProjectRoot44,
+  resolveHaivePaths as resolveHaivePaths40
 } from "@hiveai/core";
 function registerPrecommit(program2) {
   program2.command("precommit").description(
@@ -12661,8 +12825,8 @@ function registerPrecommit(program2) {
     "'any' | 'high-confidence' (default) | 'never' (report only)",
     "high-confidence"
   ).option("--no-semantic", "disable semantic search in anti-patterns matching").option("--json", "emit JSON instead of human-readable output", false).option("--paths <paths...>", "explicit paths to check (skips git diff)").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot43(opts.dir);
-    const paths = resolveHaivePaths39(root);
+    const root = findProjectRoot44(opts.dir);
+    const paths = resolveHaivePaths40(root);
     const ctx = { paths };
     let diff = "";
     let touchedPaths = opts.paths ?? [];
@@ -12792,12 +12956,12 @@ function runCommand3(cmd, args, cwd) {
 }
 
 // src/commands/welcome.ts
-import { existsSync as existsSync63 } from "fs";
+import { existsSync as existsSync64 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot44,
+  findProjectRoot as findProjectRoot45,
   loadMemoriesFromDir as loadMemoriesFromDir35,
-  resolveHaivePaths as resolveHaivePaths40
+  resolveHaivePaths as resolveHaivePaths41
 } from "@hiveai/core";
 var TYPE_RANK = {
   skill: 0,
@@ -12812,9 +12976,9 @@ function registerWelcome(program2) {
   program2.command("welcome").description(
     "Onboarding checklist: ranks validated/proposed **team** memories by type.\nUse after `haive init` so new devs skim institutional knowledge quickly.\n\n  haive welcome\n  haive welcome --limit 15\n"
   ).option("--limit <n>", "maximum memories listed", "20").option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot44(opts.dir);
-    const paths = resolveHaivePaths40(root);
-    if (!existsSync63(paths.memoriesDir)) {
+    const root = findProjectRoot45(opts.dir);
+    const paths = resolveHaivePaths41(root);
+    if (!existsSync64(paths.memoriesDir)) {
       ui.error(`No memories at ${paths.memoriesDir}. Run 'haive init' first.`);
       process.exitCode = 1;
       return;
@@ -12873,27 +13037,27 @@ function registerMemorySuggestTopic(memory2) {
 }
 
 // src/commands/resolve-project.ts
-import path45 from "path";
+import path46 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: path45.resolve(opts.dir) });
+    const info = resolveProjectInfo2({ cwd: path46.resolve(opts.dir) });
     console.log(JSON.stringify({ ok: true, info }, null, 2));
   });
 }
 
 // src/commands/runtime-journal.ts
-import { existsSync as existsSync64 } from "fs";
-import path46 from "path";
+import { existsSync as existsSync65 } from "fs";
+import path47 from "path";
 import "commander";
 import {
   appendRuntimeJournalEntry as appendRuntimeJournalEntry3,
-  findProjectRoot as findProjectRoot45,
+  findProjectRoot as findProjectRoot46,
   readRuntimeJournalTail as readRuntimeJournalTail2,
-  resolveHaivePaths as resolveHaivePaths41
+  resolveHaivePaths as resolveHaivePaths42
 } from "@hiveai/core";
 function registerRuntime(program2) {
   const runtime = program2.command("runtime").description(
@@ -12901,18 +13065,18 @@ function registerRuntime(program2) {
   );
   const journal = runtime.command("journal").description("Append or read the machine-local session journal (NDJSON)");
   journal.command("append").description("Append one JSON line to .ai/.runtime/session-journal.ndjson").argument("<message>", "short text to log").option("-k, --kind <kind>", "note | session_end | mcp", "note").option("-d, --dir <dir>", "project root", process.cwd()).action(async (message, opts) => {
-    const root = path46.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths41(findProjectRoot45(root));
+    const root = path47.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths42(findProjectRoot46(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 ${path46.relative(root, paths.runtimeDir)}/session-journal.ndjson`);
+    ui.success(`Appended to ${path47.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 = path46.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths41(findProjectRoot45(root));
+    const root = path47.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths42(findProjectRoot46(root));
     const limit = Math.min(500, Math.max(1, parseInt(opts.limit, 10) || 30));
-    if (!existsSync64(paths.haiveDir)) {
+    if (!existsSync65(paths.haiveDir)) {
       ui.error("No .ai/ \u2014 run `haive init` first.");
       process.exitCode = 1;
       return;
@@ -12927,13 +13091,13 @@ function registerRuntime(program2) {
 }
 
 // src/commands/memory-timeline.ts
-import { existsSync as existsSync65 } from "fs";
-import path47 from "path";
+import { existsSync as existsSync66 } from "fs";
+import path48 from "path";
 import "commander";
 import {
   collectTimelineEntries as collectTimelineEntries2,
-  findProjectRoot as findProjectRoot46,
-  resolveHaivePaths as resolveHaivePaths42
+  findProjectRoot as findProjectRoot47,
+  resolveHaivePaths as resolveHaivePaths43
 } from "@hiveai/core";
 function registerMemoryTimeline(memory2) {
   memory2.command("timeline").description(
@@ -12944,9 +13108,9 @@ function registerMemoryTimeline(memory2) {
       process.exitCode = 1;
       return;
     }
-    const root = path47.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths42(findProjectRoot46(root));
-    if (!existsSync65(paths.memoriesDir)) {
+    const root = path48.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths43(findProjectRoot47(root));
+    if (!existsSync66(paths.memoriesDir)) {
       ui.error("No memories \u2014 run `haive init`.");
       process.exitCode = 1;
       return;
@@ -12964,14 +13128,14 @@ function registerMemoryTimeline(memory2) {
 }
 
 // src/commands/memory-conflict-candidates.ts
-import { existsSync as existsSync66 } from "fs";
-import path48 from "path";
+import { existsSync as existsSync67 } from "fs";
+import path49 from "path";
 import "commander";
 import {
   findLexicalConflictPairs as findLexicalConflictPairs2,
   findTopicStatusConflictPairs as findTopicStatusConflictPairs2,
-  findProjectRoot as findProjectRoot47,
-  resolveHaivePaths as resolveHaivePaths43
+  findProjectRoot as findProjectRoot48,
+  resolveHaivePaths as resolveHaivePaths44
 } from "@hiveai/core";
 function parseTypes(csv) {
   const allowed = ["decision", "architecture", "convention", "gotcha"];
@@ -12987,9 +13151,9 @@ function registerMemoryConflictCandidates(memory2) {
     "decision,architecture,convention,gotcha (lexical scan)",
     "decision,architecture"
   ).option("--min-jaccard <x>", "minimum Jaccard for lexical pairs", "0.45").option("--max-pairs <n>", "cap lexical pairs", "20").option("--max-scan <n>", "max memories scanned (lexical)", "500").option("--max-topic-pairs <n>", "cap topic/status pairs", "20").action(async (opts) => {
-    const root = path48.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths43(findProjectRoot47(root));
-    if (!existsSync66(paths.memoriesDir)) {
+    const root = path49.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths44(findProjectRoot48(root));
+    if (!existsSync67(paths.memoriesDir)) {
       ui.error("No memories \u2014 run `haive init`.");
       process.exitCode = 1;
       return;
@@ -13025,24 +13189,24 @@ function registerMemoryConflictCandidates(memory2) {
 
 // src/commands/enforce.ts
 import { execFileSync as execFileSync2, spawn as spawn6 } from "child_process";
-import { existsSync as existsSync67, statSync as statSync2 } from "fs";
-import { chmod as chmod2, mkdir as mkdir19, readFile as readFile20, readdir as readdir6, rm as rm3, writeFile as writeFile33 } from "fs/promises";
-import path49 from "path";
+import { existsSync as existsSync68, statSync as statSync2 } from "fs";
+import { chmod as chmod2, mkdir as mkdir19, readFile as readFile21, readdir as readdir6, rm as rm3, writeFile as writeFile33 } from "fs/promises";
+import path50 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot48,
+  findProjectRoot as findProjectRoot49,
   hasRecentBriefingMarker,
   isFreshIsoDate,
-  loadConfig as loadConfig10,
+  loadConfig as loadConfig11,
   loadMemoriesFromDir as loadMemoriesFromDir36,
   memoryMatchesAnchorPaths as memoryMatchesAnchorPaths6,
   readRecentBriefingMarker,
   resolveBriefingBudget as resolveBriefingBudget3,
-  resolveHaivePaths as resolveHaivePaths44,
+  resolveHaivePaths as resolveHaivePaths45,
   saveConfig as saveConfig4,
   SESSION_RECAP_TTL_MS,
   verifyAnchor as verifyAnchor4,
-  writeBriefingMarker as writeBriefingMarker2
+  writeBriefingMarker as writeBriefingMarker3
 } from "@hiveai/core";
 var MAX_STDIN_BYTES2 = 256 * 1024;
 var ENFORCE_HOOK_MARKER = "# hAIve enforcement hook";
@@ -13051,10 +13215,10 @@ function registerEnforce(program2) {
     "Agent-agnostic enforcement helpers: install policy gates, report status, and block unsafe workflows."
   );
   enforce.command("install").description("Install hAIve enforcement across MCP config, git hooks, CI template, and supported client hooks.").option("-d, --dir <dir>", "project root").option("--no-git", "skip git pre-commit/pre-push enforcement hooks").option("--no-claude", "skip Claude Code hooks").option("--no-ci", "skip GitHub Actions enforcement workflow").action(async (opts) => {
-    const root = findProjectRoot48(opts.dir);
-    const paths = resolveHaivePaths44(root);
+    const root = findProjectRoot49(opts.dir);
+    const paths = resolveHaivePaths45(root);
     await mkdir19(paths.haiveDir, { recursive: true });
-    const current = await loadConfig10(paths);
+    const current = await loadConfig11(paths);
     await saveConfig4(paths, {
       ...current,
       enforcement: {
@@ -13077,7 +13241,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 (${path49.relative(root, result.settingsPath)})`);
+        ui.success(`${result.created ? "Created" : "Patched"} Claude Code hooks (${path50.relative(root, result.settingsPath)})`);
       } catch (err) {
         ui.warn(`Claude Code hooks not installed: ${err instanceof Error ? err.message : String(err)}`);
       }
@@ -13096,21 +13260,21 @@ function registerEnforce(program2) {
     if (report.should_block) process.exit(2);
   });
   enforce.command("cleanup").description("Remove generated hAIve runtime/cache artifacts that should not appear in commits.").option("-d, --dir <dir>", "project root").option("--dry-run", "print what would be removed without deleting", false).action(async (opts) => {
-    const root = findProjectRoot48(opts.dir);
-    const paths = resolveHaivePaths44(root);
-    const cacheDir = path49.join(paths.haiveDir, ".cache");
-    if (existsSync67(cacheDir)) {
-      if (opts.dryRun) ui.info(`would clean ${path49.relative(root, cacheDir)} (preserving .gitignore)`);
+    const root = findProjectRoot49(opts.dir);
+    const paths = resolveHaivePaths45(root);
+    const cacheDir = path50.join(paths.haiveDir, ".cache");
+    if (existsSync68(cacheDir)) {
+      if (opts.dryRun) ui.info(`would clean ${path50.relative(root, cacheDir)} (preserving .gitignore)`);
       else {
         const removed = await cleanupCacheDir(cacheDir);
-        ui.success(`cleaned ${path49.relative(root, cacheDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
+        ui.success(`cleaned ${path50.relative(root, cacheDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
       }
     }
-    if (existsSync67(paths.runtimeDir)) {
-      if (opts.dryRun) ui.info(`would clean ${path49.relative(root, paths.runtimeDir)} (preserving briefing markers)`);
+    if (existsSync68(paths.runtimeDir)) {
+      if (opts.dryRun) ui.info(`would clean ${path50.relative(root, paths.runtimeDir)} (preserving briefing markers)`);
       else {
         const removed = await cleanupRuntimeDir(paths.runtimeDir);
-        ui.success(`cleaned ${path49.relative(root, paths.runtimeDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
+        ui.success(`cleaned ${path50.relative(root, paths.runtimeDir)}${removed > 0 ? ` (${removed} item${removed === 1 ? "" : "s"} removed)` : ""}`);
       }
     }
   });
@@ -13123,8 +13287,8 @@ function registerEnforce(program2) {
     const payload = await readHookPayload();
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
-    const paths = resolveHaivePaths44(root);
-    if (!existsSync67(paths.haiveDir)) return;
+    const paths = resolveHaivePaths45(root);
+    if (!existsSync68(paths.haiveDir)) return;
     await mkdir19(paths.runtimeDir, { recursive: true });
     const sessionId = opts.sessionId ?? payload.session_id;
     const task = opts.task ?? payload.prompt ?? "Start an AI coding session in this hAIve-initialized project.";
@@ -13152,7 +13316,7 @@ function registerEnforce(program2) {
       },
       { paths }
     );
-    await writeBriefingMarker2(paths, {
+    await writeBriefingMarker3(paths, {
       sessionId,
       task,
       source: opts.source ?? "claude-session-start",
@@ -13186,8 +13350,8 @@ ${briefing.project_context.content.slice(0, 1800)}`);
     const payload = await readHookPayload();
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
-    const paths = resolveHaivePaths44(root);
-    if (!existsSync67(paths.haiveDir)) return;
+    const paths = resolveHaivePaths45(root);
+    if (!existsSync68(paths.haiveDir)) return;
     if (!isWriteLikeTool(payload)) return;
     const ok = await hasRecentBriefingMarker(paths, payload.session_id);
     if (ok) {
@@ -13229,15 +13393,15 @@ ${briefing.project_context.content.slice(0, 1800)}`);
   });
 }
 async function runWithEnforcement(command, args, opts) {
-  const root = findProjectRoot48(opts.dir);
-  const paths = resolveHaivePaths44(root);
-  if (!existsSync67(paths.haiveDir)) {
+  const root = findProjectRoot49(opts.dir);
+  const paths = resolveHaivePaths45(root);
+  if (!existsSync68(paths.haiveDir)) {
     ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
     process.exit(1);
   }
   const sessionId = `haive-run-${process.pid}-${Date.now()}`;
   const task = opts.task ?? `Run agent command: ${[command, ...args].join(" ")}`;
-  await writeBriefingMarker2(paths, {
+  await writeBriefingMarker3(paths, {
     sessionId,
     task,
     source: "haive-run"
@@ -13250,7 +13414,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 ${path49.relative(root, briefingFile)} and exported as HAIVE_BRIEFING_FILE`);
+  ui.info(`Briefing written to ${path50.relative(root, briefingFile)} and exported as HAIVE_BRIEFING_FILE`);
   const child = spawn6(command, args, {
     cwd: root,
     stdio: "inherit",
@@ -13294,15 +13458,15 @@ async function writeWrapperBriefing(paths, sessionId, task) {
     min_semantic_score: 0.25,
     budget_preset: "quick"
   }, { paths });
-  await writeBriefingMarker2(paths, {
+  await writeBriefingMarker3(paths, {
     sessionId,
     task,
     source: "haive-run",
     memoryIds: briefing.memories.map((m) => m.id)
   });
-  const dir = path49.join(paths.runtimeDir, "enforcement", "briefings");
+  const dir = path50.join(paths.runtimeDir, "enforcement", "briefings");
   await mkdir19(dir, { recursive: true });
-  const file = path49.join(dir, `${sessionId}.md`);
+  const file = path50.join(dir, `${sessionId}.md`);
   const parts = [
     "# hAIve Briefing",
     "",
@@ -13324,10 +13488,10 @@ async function writeWrapperBriefing(paths, sessionId, task) {
   return file;
 }
 async function buildEnforcementReport(dir, stage, sessionId) {
-  const root = findProjectRoot48(dir);
-  const paths = resolveHaivePaths44(root);
-  const initialized = existsSync67(paths.haiveDir);
-  const config = initialized ? await loadConfig10(paths) : {};
+  const root = findProjectRoot49(dir);
+  const paths = resolveHaivePaths45(root);
+  const initialized = existsSync68(paths.haiveDir);
+  const config = initialized ? await loadConfig11(paths) : {};
   if (initialized) await applyLightweightRepairs(root, paths);
   const mode = config.enforcement?.mode ?? "strict";
   const findings = [];
@@ -13357,7 +13521,7 @@ async function buildEnforcementReport(dir, stage, sessionId) {
       findings: [{ severity: "info", code: "enforcement-off", message: "hAIve enforcement is disabled." }]
     });
   }
-  findings.push(...await inspectIntegrationVersions(root, "0.9.27"));
+  findings.push(...await inspectIntegrationVersions(root, "0.9.29"));
   if (config.enforcement?.requireBriefingFirst !== false && stage !== "ci") {
     const hasBriefing = await hasRecentBriefingMarker(paths, sessionId);
     findings.push(hasBriefing ? { severity: "ok", code: "briefing-loaded", message: "A recent hAIve briefing marker exists." } : {
@@ -13427,7 +13591,7 @@ function withCategories(report) {
   };
 }
 async function hasRecentSessionRecap(paths) {
-  if (!existsSync67(paths.memoriesDir)) return false;
+  if (!existsSync68(paths.memoriesDir)) return false;
   const all = await loadMemoriesFromDir36(paths.memoriesDir);
   return all.some(({ memory: memory2 }) => {
     const fm = memory2.frontmatter;
@@ -13436,7 +13600,7 @@ async function hasRecentSessionRecap(paths) {
   });
 }
 async function verifyMemoryPolicy(paths, config) {
-  if (!existsSync67(paths.memoriesDir)) return [];
+  if (!existsSync68(paths.memoriesDir)) return [];
   const all = await loadMemoriesFromDir36(paths.memoriesDir);
   const findings = [];
   const staleImportant = [];
@@ -13474,7 +13638,7 @@ async function verifyMemoryPolicy(paths, config) {
   return findings;
 }
 async function verifyDecisionCoverage(paths, stage, sessionId) {
-  if (!existsSync67(paths.memoriesDir)) return [];
+  if (!existsSync68(paths.memoriesDir)) return [];
   const changedFiles = await getChangedFiles(paths.root, stage);
   if (changedFiles.length === 0) {
     return [{ severity: "info", code: "decision-coverage-no-changes", message: "No changed files to match against policy memories." }];
@@ -13573,16 +13737,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(path49.join(runtimeDir, entry.name));
+      removed += await cleanupEnforcementDir(path50.join(runtimeDir, entry.name));
       continue;
     }
-    await rm3(path49.join(runtimeDir, entry.name), { recursive: true, force: true });
+    await rm3(path50.join(runtimeDir, entry.name), { recursive: true, force: true });
     removed++;
   }
-  await writeFile33(path49.join(runtimeDir, ".gitignore"), "*\n!.gitignore\n!README.md\n", "utf8");
-  if (!existsSync67(path49.join(runtimeDir, "README.md"))) {
+  await writeFile33(path50.join(runtimeDir, ".gitignore"), "*\n!.gitignore\n!README.md\n", "utf8");
+  if (!existsSync68(path50.join(runtimeDir, "README.md"))) {
     await writeFile33(
-      path49.join(runtimeDir, "README.md"),
+      path50.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"
     );
@@ -13595,10 +13759,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(path49.join(cacheDir, entry.name), { recursive: true, force: true });
+    await rm3(path50.join(cacheDir, entry.name), { recursive: true, force: true });
     removed++;
   }
-  await writeFile33(path49.join(cacheDir, ".gitignore"), "*\n!.gitignore\n", "utf8");
+  await writeFile33(path50.join(cacheDir, ".gitignore"), "*\n!.gitignore\n", "utf8");
   return removed;
 }
 async function cleanupEnforcementDir(enforcementDir) {
@@ -13606,7 +13770,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(path49.join(enforcementDir, entry.name), { recursive: true, force: true });
+    await rm3(path50.join(enforcementDir, entry.name), { recursive: true, force: true });
     removed++;
   }
   return removed;
@@ -13622,9 +13786,9 @@ async function inspectIntegrationVersions(root, expectedVersion) {
   ];
   const findings = [];
   for (const rel of files) {
-    const file = path49.join(root, rel);
-    if (!existsSync67(file)) continue;
-    const text = await readFile20(file, "utf8").catch(() => "");
+    const file = path50.join(root, rel);
+    if (!existsSync68(file)) continue;
+    const text = await readFile21(file, "utf8").catch(() => "");
     for (const bin of extractAbsoluteHaiveBins2(text)) {
       const version = versionForBinary2(bin);
       if (!version) {
@@ -13718,8 +13882,8 @@ function buildScore(findings, threshold = 80) {
   };
 }
 async function installGitEnforcement(root) {
-  const hooksDir = path49.join(root, ".git", "hooks");
-  if (!existsSync67(path49.join(root, ".git"))) {
+  const hooksDir = path50.join(root, ".git", "hooks");
+  if (!existsSync68(path50.join(root, ".git"))) {
     ui.warn("No .git directory found; git enforcement hooks skipped.");
     return;
   }
@@ -13741,9 +13905,9 @@ haive enforce check --stage pre-push --dir . || exit $?
     }
   ];
   for (const hook of hooks) {
-    const file = path49.join(hooksDir, hook.name);
-    if (existsSync67(file)) {
-      const current = await readFile20(file, "utf8").catch(() => "");
+    const file = path50.join(hooksDir, hook.name);
+    if (existsSync68(file)) {
+      const current = await readFile21(file, "utf8").catch(() => "");
       if (current.includes(ENFORCE_HOOK_MARKER)) {
         await writeFile33(file, hook.body, "utf8");
       } else {
@@ -13759,9 +13923,9 @@ ${hook.body}`, "utf8");
   ui.success("Installed blocking git enforcement hooks: pre-commit, pre-push");
 }
 async function installCiEnforcement(root) {
-  const workflowPath = path49.join(root, ".github", "workflows", "haive-enforcement.yml");
-  await mkdir19(path49.dirname(workflowPath), { recursive: true });
-  if (existsSync67(workflowPath)) {
+  const workflowPath = path50.join(root, ".github", "workflows", "haive-enforcement.yml");
+  await mkdir19(path50.dirname(workflowPath), { recursive: true });
+  if (existsSync68(workflowPath)) {
     ui.info("GitHub Actions enforcement workflow already exists \u2014 skipped");
     return;
   }
@@ -13789,7 +13953,7 @@ jobs:
       - name: Enforce hAIve policy
         run: haive enforce ci
 `, "utf8");
-  ui.success(`Created ${path49.relative(root, workflowPath)}`);
+  ui.success(`Created ${path50.relative(root, workflowPath)}`);
 }
 function printReport(report, json, explain = false) {
   if (json) {
@@ -13849,7 +14013,7 @@ async function readHookPayload() {
 }
 function resolveRoot(dir, payload) {
   try {
-    return findProjectRoot48(dir ?? payload.cwd);
+    return findProjectRoot49(dir ?? payload.cwd);
   } catch {
     return null;
   }
@@ -13886,11 +14050,11 @@ function extractToolPaths(payload, root) {
 }
 function normalizeToolPath(file, root) {
   const normalized = file.replace(/\\/g, "/");
-  if (!path49.isAbsolute(normalized)) return normalized.replace(/^\.\//, "");
-  return path49.relative(root, normalized).replace(/\\/g, "/");
+  if (!path50.isAbsolute(normalized)) return normalized.replace(/^\.\//, "");
+  return path50.relative(root, normalized).replace(/\\/g, "/");
 }
 async function missingRequiredMemoriesForFiles(paths, files, sessionId) {
-  if (!existsSync67(paths.memoriesDir)) return [];
+  if (!existsSync68(paths.memoriesDir)) return [];
   const marker = await readRecentBriefingMarker(paths, sessionId);
   const consulted = new Set(marker?.memory_ids ?? []);
   const policyTypes = /* @__PURE__ */ new Set(["decision", "gotcha", "architecture", "convention", "attempt"]);
@@ -13963,8 +14127,8 @@ function registerRun(program2) {
 }
 
 // src/index.ts
-var program = new Command51();
-program.name("haive").description("hAIve \u2014 the memory and enforcement layer of your agent harness").version("0.9.27").option("--advanced", "show maintenance and experimental commands in help");
+var program = new Command52();
+program.name("haive").description("hAIve \u2014 the memory and enforcement layer of your agent harness").version("0.9.29").option("--advanced", "show maintenance and experimental commands in help");
 registerInit(program);
 registerWelcome(program);
 registerResolveProject(program);
@@ -13998,6 +14162,7 @@ registerMemoryApprove(memory);
 registerMemoryUpdate(memory);
 registerMemoryHot(memory);
 registerMemoryTried(memory);
+registerMemorySeed(memory);
 registerMemoryImport(memory);
 registerMemoryImportChangelog(memory);
 registerMemoryDigest(memory);