@hiveai/cli 0.9.10 → 0.9.11

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command49 } from "commander";
+import { Command as Command50 } from "commander";
 
 // src/commands/briefing.ts
 import { existsSync } from "fs";
@@ -198,7 +198,7 @@ async function getHotFiles(root, daysBack, maxHotFiles, filePaths) {
       if (!f) continue;
       counts.set(f, (counts.get(f) ?? 0) + 1);
     }
-    let entries = [...counts.entries()].map(([path46, changes]) => ({ path: path46, changes }));
+    let entries = [...counts.entries()].map(([path47, changes]) => ({ path: path47, changes }));
     const lowerPaths = filePaths.map((p) => p.toLowerCase());
     if (lowerPaths.length > 0) {
       entries = entries.filter((e) => lowerPaths.some((p) => e.path.toLowerCase().includes(p)));
@@ -308,12 +308,14 @@ function registerBriefing(program2) {
   ).option("-d, --dir <dir>", "project root").action(async (opts) => {
     const root = findProjectRoot(opts.dir);
     const paths = resolveHaivePaths(root);
+    const markerFiles = parseCsv(opts.files);
     if (existsSync(paths.haiveDir)) {
       await mkdir(paths.runtimeDir, { recursive: true });
       await writeBriefingMarker(paths, {
         task: opts.task ?? "CLI briefing",
         source: "haive-briefing-cli",
-        sessionId: process.env.HAIVE_SESSION_ID
+        sessionId: process.env.HAIVE_SESSION_ID,
+        files: markerFiles
       }).catch(() => {
       });
     }
@@ -386,7 +388,7 @@ function registerBriefing(program2) {
       }
     }
     const all = ownMemories;
-    const filePaths = parseCsv(opts.files);
+    const filePaths = markerFiles;
     const tokens = opts.task ? tokenizeQuery(opts.task) : null;
     const scopeFilter = opts.scope ?? "all";
     const recaps = all.filter(({ memory: mem }) => mem.frontmatter.type === "session_recap").sort(
@@ -498,6 +500,14 @@ function registerBriefing(program2) {
     if (ids.length > 0) {
       await trackReads(paths, ids).catch(() => {
       });
+      await writeBriefingMarker(paths, {
+        task: opts.task ?? "CLI briefing",
+        source: "haive-briefing-cli",
+        sessionId: process.env.HAIVE_SESSION_ID,
+        memoryIds: ids,
+        files: filePaths
+      }).catch(() => {
+      });
     }
     const radarForced = opts.radar === true;
     const radarAuto = opts.radar !== false && top.length < RADAR_AUTO_THRESHOLD;
@@ -6072,7 +6082,7 @@ When done, respond with: "Imported N memories: [list of IDs]" or "Nothing action
   };
 }
 var SERVER_NAME = "haive";
-var SERVER_VERSION = "0.9.10";
+var SERVER_VERSION = "0.9.11";
 function jsonResult(data) {
   return {
     content: [
@@ -6086,14 +6096,11 @@ function jsonResult(data) {
 var ENFORCEMENT_PROFILE_TOOLS = /* @__PURE__ */ new Set([
   "get_briefing",
   "mem_save",
-  "mem_tried",
   "mem_search",
-  "mem_get",
-  "mem_update",
   "mem_verify",
   "mem_relevant_to",
-  "code_map",
-  "pre_commit_check"
+  "pre_commit_check",
+  "mem_session_end"
 ]);
 var BRIEFING_TOOLS = /* @__PURE__ */ new Set(["get_briefing", "mem_relevant_to"]);
 var MUTATING_TOOLS = /* @__PURE__ */ new Set([
@@ -8821,8 +8828,8 @@ function parseChangelog(content) {
   const entries = [];
   const versionRe = /^#{1,3}\s+(?:\[?)([0-9]+\.[0-9]+[.0-9]*)/m;
   const sections = content.split(/^#{1,3}\s+/m).slice(1);
-  for (const section of sections) {
-    const versionMatch = section.match(/^(?:\[?)([0-9]+\.[0-9]+[.0-9]*)/);
+  for (const section2 of sections) {
+    const versionMatch = section2.match(/^(?:\[?)([0-9]+\.[0-9]+[.0-9]*)/);
     const version = versionMatch?.[1];
     if (!version) continue;
     const entry = {
@@ -8833,7 +8840,7 @@ function parseChangelog(content) {
       fixed: [],
       added: []
     };
-    const subSections = section.split(/^#{2,4}\s+/m);
+    const subSections = section2.split(/^#{2,4}\s+/m);
     for (const sub of subSections) {
       const firstLine = (sub.split("\n")[0] ?? "").toLowerCase().trim();
       const items = sub.split("\n").slice(1).filter((l) => l.trim().startsWith("-") || l.trim().startsWith("*")).map((l) => l.replace(/^[\s\-*]+/, "").trim()).filter(Boolean);
@@ -8859,7 +8866,7 @@ function parseChangelog(content) {
       }
     }
     if (entry.breaking.length === 0) {
-      for (const line of section.split("\n")) {
+      for (const line of section2.split("\n")) {
         if (/breaking|⚠|deprecated|removed/.test(line.toLowerCase())) {
           const item = line.replace(/^[\s\-*#]+/, "").trim();
           if (item) entry.breaking.push(item);
@@ -9611,8 +9618,8 @@ Next steps:
       return;
     }
     const projectName = path35.basename(root);
-    const { readdir: readdir5 } = await import("fs/promises");
-    const projectDirs = (await readdir5(hubSharedDir, { withFileTypes: true })).filter((d) => d.isDirectory() && d.name !== projectName).map((d) => d.name);
+    const { readdir: readdir6 } = await import("fs/promises");
+    const projectDirs = (await readdir6(hubSharedDir, { withFileTypes: true })).filter((d) => d.isDirectory() && d.name !== projectName).map((d) => d.name);
     if (projectDirs.length === 0) {
       console.log(ui.dim("No other projects have pushed to the hub yet."));
       return;
@@ -9623,7 +9630,7 @@ Next steps:
       const sourceDir = path35.join(hubSharedDir, sourceName);
       const destDir = path35.join(paths.memoriesDir, "shared", sourceName);
       await mkdir15(destDir, { recursive: true });
-      const sourceFiles = (await readdir5(sourceDir)).filter((f) => f.endsWith(".md"));
+      const sourceFiles = (await readdir6(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));
@@ -9662,12 +9669,12 @@ Next steps:
     );
     const sharedDir = path35.join(paths.memoriesDir, "shared");
     if (existsSync55(sharedDir)) {
-      const { readdir: readdir5 } = await import("fs/promises");
-      const sources = (await readdir5(sharedDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name);
+      const { readdir: readdir6 } = await import("fs/promises");
+      const sources = (await readdir6(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 readdir5(path35.join(sharedDir, src))).filter((f) => f.endsWith(".md"));
+        const files = (await readdir6(path35.join(sharedDir, src))).filter((f) => f.endsWith(".md"));
         console.log(`    ${src}: ${files.length} memor${files.length === 1 ? "y" : "ies"}`);
       }
     } else {
@@ -9987,15 +9994,160 @@ function summarize(name, t0, payload, notes) {
   };
 }
 
-// src/commands/memory-suggest.ts
-import { mkdir as mkdir17, writeFile as writeFile28 } from "fs/promises";
+// src/commands/benchmark.ts
 import { existsSync as existsSync57 } from "fs";
+import { readdir as readdir5, readFile as readFile16, writeFile as writeFile28 } from "fs/promises";
 import path37 from "path";
 import "commander";
+import { estimateTokens as estimateTokens4, findProjectRoot as findProjectRoot36 } 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) => {
+    const root = resolveBenchmarkRoot(opts.dir);
+    const rows = await collectRows(root);
+    const summary = summarizeRows(rows);
+    if (opts.json) {
+      console.log(JSON.stringify({ root, summary, rows }, null, 2));
+      return;
+    }
+    const markdown = renderMarkdown(root, summary, rows);
+    if (opts.out) {
+      const outFile = path37.isAbsolute(opts.out) ? opts.out : path37.join(root, opts.out);
+      await writeFile28(outFile, markdown, "utf8");
+      ui.success(`wrote ${path37.relative(process.cwd(), outFile)}`);
+      return;
+    }
+    console.log(markdown);
+  });
+  benchmark.command("demo").description("Print the recommended protocol for running a hAIve vs plain agent benchmark.").action(() => {
+    console.log([
+      "# hAIve Agent Benchmark Demo",
+      "",
+      "1. Create paired fixtures: one `*-haive`, one `*-plain`.",
+      "2. Put the same failing tests in both fixtures.",
+      "3. Add precise `.ai/memories/team/*.md` policy memories only to the hAIve fixture.",
+      "4. Run equal agents in parallel:",
+      "   - hAIve agents must run `haive briefing --files ... --task ...` first.",
+      "   - Plain agents must not read `.ai` or call hAIve.",
+      "5. Require every agent to write `BENCHMARK_AGENT_REPORT.md`.",
+      "6. Run `haive benchmark report --dir <benchmark-root> --out RESULTS.md`.",
+      "",
+      "Recommended metrics: pass rate, test iterations, files read, files changed, visible artifacts, decision quality, and token proxy."
+    ].join("\n"));
+  });
+}
+function resolveBenchmarkRoot(dir) {
+  const candidate = dir ?? "benchmarks/agent-benchmark";
+  if (path37.isAbsolute(candidate)) return candidate;
+  const projectRoot = findProjectRoot36(process.cwd());
+  return path37.join(projectRoot, candidate);
+}
+async function collectRows(root) {
+  if (!existsSync57(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 = path37.join(root, entry.name);
+    const reportFile = path37.join(fixtureDir, "BENCHMARK_AGENT_REPORT.md");
+    if (!existsSync57(reportFile)) continue;
+    const report = await readFile16(reportFile, "utf8");
+    rows.push(parseAgentReport(entry.name, report));
+  }
+  return rows.sort((a, b) => a.fixture.localeCompare(b.fixture));
+}
+function parseAgentReport(fixture, report) {
+  const group = fixture.endsWith("-haive") ? "haive" : fixture.endsWith("-plain") ? "plain" : "unknown";
+  return {
+    fixture,
+    group,
+    commands: sectionBulletCount(report, "Commands"),
+    files_read: sectionBulletCount(report, "Files Read"),
+    files_modified: sectionBulletCount(report, "Files Modified"),
+    test_iterations: countMatches(section(report, "Test Iterations"), /Iteration\s+\d+|^- /gim),
+    terminal_failures: countMatches(section(report, "Terminal Errors"), /fail|error|not raised|exited with code 1/gi),
+    decision_mentions: sectionBulletCount(report, "Key Decisions"),
+    token_proxy: estimateTokens4(report),
+    haive_impact: /hAIve Memory Impact[\s\S]*?\b(yes|directly|changed|shaped|confirmed)\b/i.test(report)
+  };
+}
+function summarizeRows(rows) {
+  const byGroup = (group) => rows.filter((r) => r.group === group);
+  return {
+    fixtures: rows.length,
+    haive: summarizeGroup(byGroup("haive")),
+    plain: summarizeGroup(byGroup("plain"))
+  };
+}
+function summarizeGroup(rows) {
+  const sum = (key) => rows.reduce((total, row) => total + Number(row[key] ?? 0), 0);
+  return {
+    fixtures: rows.length,
+    commands: sum("commands"),
+    files_read: sum("files_read"),
+    files_modified: sum("files_modified"),
+    test_iterations: sum("test_iterations"),
+    terminal_failures: sum("terminal_failures"),
+    decision_mentions: sum("decision_mentions"),
+    token_proxy: sum("token_proxy"),
+    haive_impact_count: rows.filter((r) => r.haive_impact).length
+  };
+}
+function renderMarkdown(root, summary, rows) {
+  const lines = [
+    "# hAIve Agent Benchmark Report",
+    "",
+    `Benchmark root: \`${root}\``,
+    "",
+    "## Summary",
+    "",
+    "| Group | Fixtures | Commands | Files read | Files modified | Test iterations | Terminal failures | Decision mentions | Token proxy | hAIve impact |",
+    "| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |",
+    groupLine("hAIve", summary.haive),
+    groupLine("Plain", summary.plain),
+    "",
+    "## Fixtures",
+    "",
+    "| Fixture | Group | Commands | Files read | Files modified | Test iterations | Terminal failures | Decisions | Token proxy | hAIve impact |",
+    "| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- |",
+    ...rows.map(
+      (row) => `| \`${row.fixture}\` | ${row.group} | ${row.commands} | ${row.files_read} | ${row.files_modified} | ${row.test_iterations} | ${row.terminal_failures} | ${row.decision_mentions} | ${row.token_proxy} | ${row.haive_impact ? "yes" : "no"} |`
+    ),
+    "",
+    "## Reading",
+    "",
+    "The token proxy is estimated from the agent report size, not from private model billing data.",
+    "Use this report to compare relative effort and decision quality, then pair it with final test results and a human review of the diffs.",
+    ""
+  ];
+  return lines.join("\n");
+}
+function groupLine(label, group) {
+  return `| ${label} | ${group.fixtures} | ${group.commands} | ${group.files_read} | ${group.files_modified} | ${group.test_iterations} | ${group.terminal_failures} | ${group.decision_mentions} | ${group.token_proxy} | ${group.haive_impact_count} |`;
+}
+function sectionBulletCount(markdown, title) {
+  return countMatches(section(markdown, title), /^- |^\d+\.\s/gm);
+}
+function section(markdown, title) {
+  const re = new RegExp(`##\\s+[^\\n]*${escapeRegExp(title)}[^\\n]*\\n([\\s\\S]*?)(?=\\n##\\s+|$)`, "i");
+  return re.exec(markdown)?.[1] ?? "";
+}
+function countMatches(text, re) {
+  return [...text.matchAll(re)].length;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/commands/memory-suggest.ts
+import { mkdir as mkdir17, writeFile as writeFile29 } from "fs/promises";
+import { existsSync as existsSync58 } from "fs";
+import path38 from "path";
+import "commander";
 import {
   aggregateUsage as aggregateUsage2,
   buildFrontmatter as buildFrontmatter11,
-  findProjectRoot as findProjectRoot36,
+  findProjectRoot as findProjectRoot37,
   loadMemoriesFromDir as loadMemoriesFromDir30,
   memoryFilePath as memoryFilePath10,
   parseSince as parseSince2,
@@ -10013,7 +10165,7 @@ 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 draft the top-N suggestions as draft memories. They land\n  in personal scope by default with status=draft, ready for you to edit and promote."
   ).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 drafted memories (personal | team)", "personal").option("--auto-save", "draft top-N suggestions as draft 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 = findProjectRoot36(opts.dir);
+    const root = findProjectRoot37(opts.dir);
     const paths = resolveHaivePaths33(root);
     const events = await readUsageEvents3(paths);
     if (events.length === 0) {
@@ -10060,7 +10212,7 @@ function registerMemorySuggest(memory2) {
       }
       const created = [];
       const skipped = [];
-      const existing = existsSync57(paths.memoriesDir) ? await loadMemoriesFromDir30(paths.memoriesDir) : [];
+      const existing = existsSync58(paths.memoriesDir) ? await loadMemoriesFromDir30(paths.memoriesDir) : [];
       for (const s of top) {
         const slug = slugify(s.query);
         if (!slug) {
@@ -10083,13 +10235,13 @@ function registerMemorySuggest(memory2) {
         fm.status = "draft";
         const body = renderTemplate(s);
         const file = memoryFilePath10(paths, fm.scope, fm.id, fm.module);
-        await mkdir17(path37.dirname(file), { recursive: true });
-        if (existsSync57(file)) {
-          skipped.push({ query: s.query, reason: `file already exists at ${path37.relative(root, file)}` });
+        await mkdir17(path38.dirname(file), { recursive: true });
+        if (existsSync58(file)) {
+          skipped.push({ query: s.query, reason: `file already exists at ${path38.relative(root, file)}` });
           continue;
         }
-        await writeFile28(file, serializeMemory24({ frontmatter: fm, body }), "utf8");
-        created.push({ id: fm.id, file: path37.relative(root, file), query: s.query });
+        await writeFile29(file, serializeMemory24({ frontmatter: fm, body }), "utf8");
+        created.push({ id: fm.id, file: path38.relative(root, file), query: s.query });
       }
       if (opts.json) {
         console.log(JSON.stringify({ created, skipped }, null, 2));
@@ -10182,12 +10334,12 @@ function truncate2(text, max) {
 }
 
 // src/commands/memory-archive.ts
-import { existsSync as existsSync58 } from "fs";
-import { writeFile as writeFile29 } from "fs/promises";
-import path38 from "path";
+import { existsSync as existsSync59 } from "fs";
+import { writeFile as writeFile30 } from "fs/promises";
+import path39 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot37,
+  findProjectRoot as findProjectRoot38,
   getUsage as getUsage18,
   loadMemoriesFromDir as loadMemoriesFromDir31,
   loadUsageIndex as loadUsageIndex24,
@@ -10199,9 +10351,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 = findProjectRoot37(opts.dir);
+    const root = findProjectRoot38(opts.dir);
     const paths = resolveHaivePaths34(root);
-    if (!existsSync58(paths.memoriesDir)) {
+    if (!existsSync59(paths.memoriesDir)) {
       ui.error(`No .ai/memories at ${root}. Run \`haive init\` first.`);
       process.exitCode = 1;
       return;
@@ -10222,7 +10374,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) => !existsSync58(path38.join(paths.root, p)));
+      const allPathsGone = fm.anchor.paths.length > 0 && fm.anchor.paths.every((p) => !existsSync59(path39.join(paths.root, p)));
       const isAnchorless = !hasAnyAnchor;
       if (!isAnchorless && !allPathsGone) continue;
       const u = getUsage18(usage, fm.id);
@@ -10270,7 +10422,7 @@ function registerMemoryArchive(memory2) {
       if (!found) continue;
       const fm = { ...found.memory.frontmatter, status: "deprecated" };
       try {
-        await writeFile29(c.filePath, serializeMemory25({ frontmatter: fm, body: found.memory.body }), "utf8");
+        await writeFile30(c.filePath, serializeMemory25({ frontmatter: fm, body: found.memory.body }), "utf8");
         archived++;
       } catch (err) {
         if (!opts.json) {
@@ -10296,14 +10448,14 @@ function parseDays(input) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync59 } from "fs";
+import { existsSync as existsSync60 } from "fs";
 import { stat } from "fs/promises";
-import path39 from "path";
+import path40 from "path";
 import { execSync as execSync3 } from "child_process";
 import "commander";
 import {
   codeMapPath as codeMapPath2,
-  findProjectRoot as findProjectRoot38,
+  findProjectRoot as findProjectRoot39,
   getUsage as getUsage19,
   loadCodeMap as loadCodeMap5,
   loadConfig as loadConfig7,
@@ -10317,10 +10469,10 @@ 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 suggest commands you can copy-paste."
   ).option("--json", "emit JSON instead of human-readable output", false).option("--fix", "include suggested fix commands in human output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot38(opts.dir);
+    const root = findProjectRoot39(opts.dir);
     const paths = resolveHaivePaths35(root);
     const findings = [];
-    if (!existsSync59(paths.haiveDir)) {
+    if (!existsSync60(paths.haiveDir)) {
       findings.push({
         severity: "error",
         code: "not-initialized",
@@ -10329,7 +10481,7 @@ function registerDoctor(program2) {
       });
       return emit(findings, opts);
     }
-    if (!existsSync59(paths.projectContext)) {
+    if (!existsSync60(paths.projectContext)) {
       findings.push({
         severity: "warn",
         code: "no-project-context",
@@ -10337,8 +10489,8 @@ function registerDoctor(program2) {
         fix: "haive init"
       });
     } else {
-      const { readFile: readFile17 } = await import("fs/promises");
-      const content = await readFile17(paths.projectContext, "utf8");
+      const { readFile: readFile18 } = await import("fs/promises");
+      const content = await readFile18(paths.projectContext, "utf8");
       const isTemplate = content.includes("TODO \u2014 high-level overview") || content.includes("Generated by `haive init`");
       if (isTemplate) {
         findings.push({
@@ -10349,7 +10501,7 @@ function registerDoctor(program2) {
         });
       }
     }
-    const memories = existsSync59(paths.memoriesDir) ? await loadMemoriesFromDir32(paths.memoriesDir) : [];
+    const memories = existsSync60(paths.memoriesDir) ? await loadMemoriesFromDir32(paths.memoriesDir) : [];
     const now = Date.now();
     if (memories.length === 0) {
       findings.push({
@@ -10460,12 +10612,12 @@ function registerDoctor(program2) {
     }
     const config = await loadConfig7(paths);
     if (config.enforcement?.requireBriefingFirst) {
-      const claudeSettings = path39.join(root, ".claude", "settings.local.json");
+      const claudeSettings = path40.join(root, ".claude", "settings.local.json");
       let hasClaudeEnforcement = false;
-      if (existsSync59(claudeSettings)) {
+      if (existsSync60(claudeSettings)) {
         try {
-          const { readFile: readFile17 } = await import("fs/promises");
-          const raw = await readFile17(claudeSettings, "utf8");
+          const { readFile: readFile18 } = await import("fs/promises");
+          const raw = await readFile18(claudeSettings, "utf8");
           hasClaudeEnforcement = raw.includes("haive enforce session-start") && raw.includes("haive enforce pre-tool-use");
         } catch {
           hasClaudeEnforcement = false;
@@ -10494,7 +10646,7 @@ function registerDoctor(program2) {
         timeout: 3e3,
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      const cliVersion = "0.9.10";
+      const cliVersion = "0.9.11";
       if (legacyRaw && legacyRaw !== cliVersion) {
         findings.push({
           severity: "warn",
@@ -10543,10 +10695,10 @@ function isSearchTool(name) {
 }
 
 // src/commands/playback.ts
-import { existsSync as existsSync60 } from "fs";
+import { existsSync as existsSync61 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot39,
+  findProjectRoot as findProjectRoot40,
   loadMemoriesFromDir as loadMemoriesFromDir33,
   parseSince as parseSince3,
   readUsageEvents as readUsageEvents5,
@@ -10557,7 +10709,7 @@ 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 = findProjectRoot39(opts.dir);
+    const root = findProjectRoot40(opts.dir);
     const paths = resolveHaivePaths36(root);
     const events = await readUsageEvents5(paths);
     if (events.length === 0) {
@@ -10573,7 +10725,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 = existsSync60(paths.memoriesDir) ? await loadMemoriesFromDir33(paths.memoriesDir) : [];
+    const all = existsSync61(paths.memoriesDir) ? await loadMemoriesFromDir33(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);
@@ -10663,7 +10815,7 @@ function truncate3(text, max) {
 import { spawn as spawn4 } from "child_process";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot40,
+  findProjectRoot as findProjectRoot41,
   resolveHaivePaths as resolveHaivePaths37
 } from "@hiveai/core";
 function registerPrecommit(program2) {
@@ -10674,7 +10826,7 @@ 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 = findProjectRoot40(opts.dir);
+    const root = findProjectRoot41(opts.dir);
     const paths = resolveHaivePaths37(root);
     const ctx = { paths };
     let diff = "";
@@ -10767,10 +10919,10 @@ function runCommand3(cmd, args, cwd) {
 }
 
 // src/commands/welcome.ts
-import { existsSync as existsSync61 } from "fs";
+import { existsSync as existsSync63 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot41,
+  findProjectRoot as findProjectRoot42,
   loadMemoriesFromDir as loadMemoriesFromDir34,
   resolveHaivePaths as resolveHaivePaths38
 } from "@hiveai/core";
@@ -10786,9 +10938,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 = findProjectRoot41(opts.dir);
+    const root = findProjectRoot42(opts.dir);
     const paths = resolveHaivePaths38(root);
-    if (!existsSync61(paths.memoriesDir)) {
+    if (!existsSync63(paths.memoriesDir)) {
       ui.error(`No memories at ${paths.memoriesDir}. Run 'haive init' first.`);
       process.exitCode = 1;
       return;
@@ -10829,17 +10981,17 @@ function registerWelcome(program2) {
 }
 
 // src/commands/memory-lint.ts
-import { existsSync as existsSync63 } from "fs";
+import { existsSync as existsSync64 } from "fs";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot42,
+  findProjectRoot as findProjectRoot43,
   loadMemoriesFromDir as loadMemoriesFromDir35,
   resolveHaivePaths as resolveHaivePaths39
 } from "@hiveai/core";
 async function lintMemoriesAsync(root) {
   const paths = resolveHaivePaths39(root);
   const out = [];
-  if (!existsSync63(paths.memoriesDir)) return out;
+  if (!existsSync64(paths.memoriesDir)) return out;
   const loaded = await loadMemoriesFromDir35(paths.memoriesDir);
   const ANCHOR_TYPES = /* @__PURE__ */ new Set(["decision", "architecture", "gotcha"]);
   for (const { filePath, memory: memory2 } of loaded) {
@@ -10900,7 +11052,7 @@ function registerMemoryLint(parent) {
   parent.command("lint").description(
     "Heuristic corpus checks (anchors on key types, headings, verbosity). Static analysis only."
   ).option("--json", "emit findings as JSON", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
-    const root = findProjectRoot42(opts.dir);
+    const root = findProjectRoot43(opts.dir);
     const findings = await lintMemoriesAsync(root);
     if (opts.json) {
       console.log(JSON.stringify({ findings_count: findings.length, findings }, null, 2));
@@ -10946,25 +11098,25 @@ function registerMemorySuggestTopic(memory2) {
 }
 
 // src/commands/resolve-project.ts
-import path40 from "path";
+import path41 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: path40.resolve(opts.dir) });
+    const info = resolveProjectInfo2({ cwd: path41.resolve(opts.dir) });
     console.log(JSON.stringify({ ok: true, info }, null, 2));
   });
 }
 
 // src/commands/runtime-journal.ts
-import { existsSync as existsSync64 } from "fs";
-import path41 from "path";
+import { existsSync as existsSync65 } from "fs";
+import path43 from "path";
 import "commander";
 import {
   appendRuntimeJournalEntry as appendRuntimeJournalEntry3,
-  findProjectRoot as findProjectRoot43,
+  findProjectRoot as findProjectRoot44,
   readRuntimeJournalTail as readRuntimeJournalTail2,
   resolveHaivePaths as resolveHaivePaths40
 } from "@hiveai/core";
@@ -10974,18 +11126,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 = path41.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths40(findProjectRoot43(root));
+    const root = path43.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths40(findProjectRoot44(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 ${path41.relative(root, paths.runtimeDir)}/session-journal.ndjson`);
+    ui.success(`Appended to ${path43.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 = path41.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths40(findProjectRoot43(root));
+    const root = path43.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths40(findProjectRoot44(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;
@@ -11000,12 +11152,12 @@ function registerRuntime(program2) {
 }
 
 // src/commands/memory-timeline.ts
-import { existsSync as existsSync65 } from "fs";
-import path43 from "path";
+import { existsSync as existsSync66 } from "fs";
+import path44 from "path";
 import "commander";
 import {
   collectTimelineEntries as collectTimelineEntries2,
-  findProjectRoot as findProjectRoot44,
+  findProjectRoot as findProjectRoot45,
   resolveHaivePaths as resolveHaivePaths41
 } from "@hiveai/core";
 function registerMemoryTimeline(memory2) {
@@ -11017,9 +11169,9 @@ function registerMemoryTimeline(memory2) {
       process.exitCode = 1;
       return;
     }
-    const root = path43.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths41(findProjectRoot44(root));
-    if (!existsSync65(paths.memoriesDir)) {
+    const root = path44.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths41(findProjectRoot45(root));
+    if (!existsSync66(paths.memoriesDir)) {
       ui.error("No memories \u2014 run `haive init`.");
       process.exitCode = 1;
       return;
@@ -11037,13 +11189,13 @@ function registerMemoryTimeline(memory2) {
 }
 
 // src/commands/memory-conflict-candidates.ts
-import { existsSync as existsSync66 } from "fs";
-import path44 from "path";
+import { existsSync as existsSync67 } from "fs";
+import path45 from "path";
 import "commander";
 import {
   findLexicalConflictPairs as findLexicalConflictPairs2,
   findTopicStatusConflictPairs as findTopicStatusConflictPairs2,
-  findProjectRoot as findProjectRoot45,
+  findProjectRoot as findProjectRoot46,
   resolveHaivePaths as resolveHaivePaths42
 } from "@hiveai/core";
 function parseTypes(csv) {
@@ -11060,9 +11212,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 = path44.resolve(opts.dir ?? process.cwd());
-    const paths = resolveHaivePaths42(findProjectRoot45(root));
-    if (!existsSync66(paths.memoriesDir)) {
+    const root = path45.resolve(opts.dir ?? process.cwd());
+    const paths = resolveHaivePaths42(findProjectRoot46(root));
+    if (!existsSync67(paths.memoriesDir)) {
       ui.error("No memories \u2014 run `haive init`.");
       process.exitCode = 1;
       return;
@@ -11098,16 +11250,18 @@ function registerMemoryConflictCandidates(memory2) {
 
 // src/commands/enforce.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync67 } from "fs";
-import { chmod as chmod2, mkdir as mkdir18, readFile as readFile16, writeFile as writeFile30 } from "fs/promises";
-import path45 from "path";
+import { existsSync as existsSync68 } from "fs";
+import { chmod as chmod2, mkdir as mkdir18, readFile as readFile17, rm as rm3, writeFile as writeFile31 } from "fs/promises";
+import path46 from "path";
 import "commander";
 import {
-  findProjectRoot as findProjectRoot46,
+  findProjectRoot as findProjectRoot47,
   hasRecentBriefingMarker,
   isFreshIsoDate,
   loadConfig as loadConfig8,
   loadMemoriesFromDir as loadMemoriesFromDir36,
+  memoryMatchesAnchorPaths as memoryMatchesAnchorPaths6,
+  readRecentBriefingMarker,
   resolveBriefingBudget as resolveBriefingBudget3,
   resolveHaivePaths as resolveHaivePaths43,
   saveConfig as saveConfig3,
@@ -11122,7 +11276,7 @@ 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 = findProjectRoot46(opts.dir);
+    const root = findProjectRoot47(opts.dir);
     const paths = resolveHaivePaths43(root);
     await mkdir18(paths.haiveDir, { recursive: true });
     const current = await loadConfig8(paths);
@@ -11135,7 +11289,11 @@ function registerEnforce(program2) {
         requireSessionRecap: true,
         requireMemoryVerify: true,
         blockStaleDecisionChanges: true,
-        toolProfile: "enforcement"
+        requireDecisionCoverage: true,
+        scoreThreshold: 85,
+        cleanupGeneratedArtifacts: true,
+        toolProfile: "enforcement",
+        policyPacks: ["architecture", "gotchas", "security", "domain", "release"]
       }
     });
     ui.success("hAIve strict enforcement enabled in .ai/haive.config.json");
@@ -11144,7 +11302,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 (${path45.relative(root, result.settingsPath)})`);
+        ui.success(`${result.created ? "Created" : "Patched"} Claude Code hooks (${path46.relative(root, result.settingsPath)})`);
       } catch (err) {
         ui.warn(`Claude Code hooks not installed: ${err instanceof Error ? err.message : String(err)}`);
       }
@@ -11162,6 +11320,23 @@ function registerEnforce(program2) {
     printReport(report, Boolean(opts.json));
     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 = findProjectRoot47(opts.dir);
+    const paths = resolveHaivePaths43(root);
+    const targets = [
+      path46.join(paths.haiveDir, ".cache"),
+      path46.join(paths.haiveDir, ".runtime")
+    ];
+    for (const target of targets) {
+      if (!existsSync68(target)) continue;
+      const rel = path46.relative(root, target);
+      if (opts.dryRun) ui.info(`would remove ${rel}`);
+      else {
+        await rm3(target, { recursive: true, force: true });
+        ui.success(`removed ${rel}`);
+      }
+    }
+  });
   enforce.command("ci").description("CI entrypoint: fail if the repository violates hAIve enforcement policy.").option("-d, --dir <dir>", "project root").option("--json", "emit JSON", false).action(async (opts) => {
     const report = await buildEnforcementReport(opts.dir, "ci");
     printReport(report, Boolean(opts.json));
@@ -11172,15 +11347,10 @@ function registerEnforce(program2) {
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
     const paths = resolveHaivePaths43(root);
-    if (!existsSync67(paths.haiveDir)) return;
+    if (!existsSync68(paths.haiveDir)) return;
     await mkdir18(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.";
-    await writeBriefingMarker2(paths, {
-      sessionId,
-      task,
-      source: opts.source ?? "claude-session-start"
-    });
     const budget = resolveBriefingBudget3("quick", {
       max_tokens: 2500,
       max_memories: 5,
@@ -11204,6 +11374,12 @@ function registerEnforce(program2) {
       },
       { paths }
     );
+    await writeBriefingMarker2(paths, {
+      sessionId,
+      task,
+      source: opts.source ?? "claude-session-start",
+      memoryIds: briefing.memories.map((m) => m.id)
+    });
     console.log("hAIve briefing loaded. Agents must consult this before editing.");
     if (briefing.last_session) {
       console.log(`
@@ -11233,7 +11409,7 @@ ${briefing.project_context.content.slice(0, 1800)}`);
     const root = resolveRoot(opts.dir, payload);
     if (!root) return;
     const paths = resolveHaivePaths43(root);
-    if (!existsSync67(paths.haiveDir)) return;
+    if (!existsSync68(paths.haiveDir)) return;
     if (!isWriteLikeTool(payload)) return;
     const ok = await hasRecentBriefingMarker(paths, payload.session_id);
     if (ok) return;
@@ -11255,9 +11431,9 @@ ${briefing.project_context.content.slice(0, 1800)}`);
   });
 }
 async function runWithEnforcement(command, args, opts) {
-  const root = findProjectRoot46(opts.dir);
+  const root = findProjectRoot47(opts.dir);
   const paths = resolveHaivePaths43(root);
-  if (!existsSync67(paths.haiveDir)) {
+  if (!existsSync68(paths.haiveDir)) {
     ui.error(`No .ai/ found at ${root}. Run \`haive init\` first.`);
     process.exit(1);
   }
@@ -11276,7 +11452,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 ${path45.relative(root, briefingFile)} and exported as HAIVE_BRIEFING_FILE`);
+  ui.info(`Briefing written to ${path46.relative(root, briefingFile)} and exported as HAIVE_BRIEFING_FILE`);
   const child = spawn5(command, args, {
     cwd: root,
     stdio: "inherit",
@@ -11319,9 +11495,15 @@ async function writeWrapperBriefing(paths, sessionId, task) {
     min_semantic_score: 0.25,
     budget_preset: "quick"
   }, { paths });
-  const dir = path45.join(paths.runtimeDir, "enforcement", "briefings");
+  await writeBriefingMarker2(paths, {
+    sessionId,
+    task,
+    source: "haive-run",
+    memoryIds: briefing.memories.map((m) => m.id)
+  });
+  const dir = path46.join(paths.runtimeDir, "enforcement", "briefings");
   await mkdir18(dir, { recursive: true });
-  const file = path45.join(dir, `${sessionId}.md`);
+  const file = path46.join(dir, `${sessionId}.md`);
   const parts = [
     "# hAIve Briefing",
     "",
@@ -11339,13 +11521,13 @@ async function writeWrapperBriefing(paths, sessionId, task) {
   if (briefing.setup_warnings.length > 0) {
     parts.push("", "## Setup Warnings", ...briefing.setup_warnings.map((w) => `- ${w}`));
   }
-  await writeFile30(file, parts.join("\n") + "\n", "utf8");
+  await writeFile31(file, parts.join("\n") + "\n", "utf8");
   return file;
 }
 async function buildEnforcementReport(dir, stage, sessionId) {
-  const root = findProjectRoot46(dir);
+  const root = findProjectRoot47(dir);
   const paths = resolveHaivePaths43(root);
-  const initialized = existsSync67(paths.haiveDir);
+  const initialized = existsSync68(paths.haiveDir);
   const config = initialized ? await loadConfig8(paths) : {};
   const mode = config.enforcement?.mode ?? "strict";
   const findings = [];
@@ -11354,12 +11536,14 @@ async function buildEnforcementReport(dir, stage, sessionId) {
       root,
       initialized,
       mode,
+      score: buildScore([], config.enforcement?.scoreThreshold),
       should_block: true,
       findings: [{
         severity: "error",
         code: "not-initialized",
         message: "This repository is not initialized with hAIve.",
-        fix: "Run `haive init` or `haive enforce install`."
+        fix: "Run `haive init` or `haive enforce install`.",
+        impact: 100
       }]
     };
   }
@@ -11368,6 +11552,7 @@ async function buildEnforcementReport(dir, stage, sessionId) {
       root,
       initialized,
       mode,
+      score: buildScore([], config.enforcement?.scoreThreshold),
       should_block: false,
       findings: [{ severity: "info", code: "enforcement-off", message: "hAIve enforcement is disabled." }]
     };
@@ -11378,42 +11563,67 @@ async function buildEnforcementReport(dir, stage, sessionId) {
       severity: "error",
       code: "briefing-missing",
       message: "No recent hAIve briefing marker was found for this workflow.",
-      fix: 'Run `haive briefing --task "..."`, `haive enforce session-start`, or wrap the agent with `haive run -- <agent>`.'
+      fix: 'Run `haive briefing --task "..."`, `haive enforce session-start`, or wrap the agent with `haive run -- <agent>`.',
+      impact: 35
     });
   }
   if (config.enforcement?.requireSessionRecap !== false && (stage === "pre-push" || stage === "ci")) {
     const hasRecap = await hasRecentSessionRecap(paths);
-    findings.push(hasRecap ? { severity: "ok", code: "session-recap-present", message: "A recent session_recap memory exists." } : {
+    findings.push(hasRecap ? { severity: "ok", code: "session-recap-present", message: "A recent session_recap memory exists." } : stage === "ci" ? {
+      severity: "warn",
+      code: "session-recap-missing",
+      message: "No recent session_recap memory was found. CI reports this as a warning because personal recaps are usually not committed.",
+      fix: "Run `haive session end --scope team --goal ... --accomplished ...` if you want a team recap visible in CI.",
+      impact: 5
+    } : {
       severity: "error",
       code: "session-recap-missing",
       message: "No recent session_recap memory was found.",
-      fix: "Run `haive session end --goal ... --accomplished ...` before pushing."
+      fix: "Run `haive session end --goal ... --accomplished ...` before pushing.",
+      impact: 20
     });
   }
   if (config.enforcement?.requireMemoryVerify !== false) {
     findings.push(...await verifyMemoryPolicy(paths, config));
   }
+  if (config.enforcement?.requireDecisionCoverage !== false) {
+    findings.push(...await verifyDecisionCoverage(paths, stage, sessionId));
+  }
   if (stage === "pre-commit" || stage === "ci") {
     findings.push(...await runPrecommitPolicy(paths));
   }
+  if (config.enforcement?.cleanupGeneratedArtifacts !== false) {
+    findings.push(...await findGeneratedArtifacts(paths));
+  }
+  const score = buildScore(findings, config.enforcement?.scoreThreshold);
+  if (score.score < score.threshold) {
+    findings.push({
+      severity: "error",
+      code: "enforcement-score-below-threshold",
+      message: `Enforcement score ${score.score}% is below required threshold ${score.threshold}%.`,
+      fix: "Load the relevant briefing, address policy findings, then rerun `haive enforce check`.",
+      impact: 0
+    });
+  }
   const hasErrors = findings.some((f) => f.severity === "error");
   return {
     root,
     initialized,
     mode,
+    score: buildScore(findings, config.enforcement?.scoreThreshold),
     should_block: mode === "strict" && hasErrors,
     findings
   };
 }
 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 }) => memory2.frontmatter.type === "session_recap" && memory2.frontmatter.status !== "rejected" && isFreshIsoDate(memory2.frontmatter.created_at, SESSION_RECAP_TTL_MS)
   );
 }
 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 = [];
@@ -11444,11 +11654,51 @@ async function verifyMemoryPolicy(paths, config) {
       severity: "error",
       code: "stale-important-memories",
       message: `${staleImportant.length} important anchored memories are stale: ${staleImportant.slice(0, 8).join(", ")}`,
-      fix: "Run `haive memory verify --update`, then update or delete stale decisions/gotchas before merging."
+      fix: "Run `haive memory verify --update`, then update or delete stale decisions/gotchas before merging.",
+      impact: 40
     });
   }
   return findings;
 }
+async function verifyDecisionCoverage(paths, stage, sessionId) {
+  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." }];
+  }
+  const all = await loadMemoriesFromDir36(paths.memoriesDir);
+  const policyTypes = /* @__PURE__ */ new Set(["decision", "gotcha", "architecture", "convention"]);
+  const relevant = all.map(({ memory: memory2 }) => memory2).filter((memory2) => {
+    const fm = memory2.frontmatter;
+    if (!policyTypes.has(fm.type)) return false;
+    if (fm.status === "rejected" || fm.status === "deprecated" || fm.status === "stale") return false;
+    return memoryMatchesAnchorPaths6(memory2, changedFiles);
+  });
+  if (relevant.length === 0) {
+    return [{
+      severity: "ok",
+      code: "decision-coverage-none-required",
+      message: `No anchored decisions or policies matched ${changedFiles.length} changed file(s).`
+    }];
+  }
+  const marker = await readRecentBriefingMarker(paths, sessionId);
+  const consulted = new Set(marker?.memory_ids ?? []);
+  const missing = relevant.filter((memory2) => !consulted.has(memory2.frontmatter.id));
+  if (missing.length === 0) {
+    return [{
+      severity: "ok",
+      code: "decision-coverage-pass",
+      message: `Relevant decisions/policies were surfaced for ${changedFiles.length} changed file(s): ${relevant.length}/${relevant.length}.`
+    }];
+  }
+  return [{
+    severity: stage === "local" ? "warn" : "error",
+    code: "decision-coverage-missing",
+    message: `${missing.length}/${relevant.length} relevant anchored decisions/policies were not present in the latest briefing: ${missing.slice(0, 6).map((m) => m.frontmatter.id).join(", ")}`,
+    fix: `Run \`haive briefing --files "${changedFiles.slice(0, 10).join(",")}" --task "..."\` before committing.`,
+    impact: Math.min(35, 10 + missing.length * 5)
+  }];
+}
 async function runPrecommitPolicy(paths) {
   const staged = await runCommand4("git", ["diff", "--cached", "--name-only"], paths.root).catch(() => "");
   const touchedPaths = staged.split("\n").map((s) => s.trim()).filter(Boolean);
@@ -11473,12 +11723,62 @@ async function runPrecommitPolicy(paths) {
     severity: "error",
     code: "precommit-policy-block",
     message: `Pre-commit policy matched ${result.summary.anti_patterns} anti-pattern(s), ${result.summary.stale_anchors} stale anchor(s).`,
-    fix: "Review the hAIve warnings, then update the code or the relevant memories."
+    fix: "Review the hAIve warnings, then update the code or the relevant memories.",
+    impact: 45
   }];
 }
+async function findGeneratedArtifacts(paths) {
+  const dirty = await runCommand4("git", ["status", "--short", "--untracked-files=all"], paths.root).catch(() => "");
+  const generated = dirty.split("\n").map((line) => line.trim()).filter(Boolean).filter(
+    (line) => line.includes(".ai/.cache/") || line.includes(".ai/.runtime/") || line.includes("__pycache__/") || line.endsWith(".pyc")
+  );
+  if (generated.length === 0) {
+    return [{ severity: "ok", code: "generated-artifacts-clean", message: "No generated runtime/cache artifacts are visible to git." }];
+  }
+  return [{
+    severity: "warn",
+    code: "generated-artifacts-visible",
+    message: `${generated.length} generated artifact(s) are visible in git status.`,
+    fix: "Run `haive enforce cleanup`, update .gitignore, or remove test/runtime outputs before committing.",
+    impact: 10
+  }];
+}
+async function getChangedFiles(root, stage) {
+  const commands = stage === "pre-commit" ? [["diff", "--cached", "--name-only"]] : [
+    ["diff", "--cached", "--name-only"],
+    ["diff", "--name-only"]
+  ];
+  const files = /* @__PURE__ */ new Set();
+  for (const args of commands) {
+    const out = await runCommand4("git", args, root).catch(() => "");
+    for (const line of out.split("\n")) {
+      const file = line.trim();
+      if (file) files.add(file);
+    }
+  }
+  return [...files].filter((file) => !file.startsWith(".ai/.runtime/") && !file.startsWith(".ai/.cache/"));
+}
+function buildScore(findings, threshold = 80) {
+  const checks = {
+    total: findings.length,
+    ok: findings.filter((f) => f.severity === "ok").length,
+    warn: findings.filter((f) => f.severity === "warn").length,
+    error: findings.filter((f) => f.severity === "error").length
+  };
+  const penalty = findings.reduce((sum, f) => {
+    if (f.severity === "error") return sum + (f.impact ?? 25);
+    if (f.severity === "warn") return sum + (f.impact ?? 8);
+    return sum;
+  }, 0);
+  return {
+    score: Math.max(0, Math.min(100, 100 - penalty)),
+    threshold,
+    checks
+  };
+}
 async function installGitEnforcement(root) {
-  const hooksDir = path45.join(root, ".git", "hooks");
-  if (!existsSync67(path45.join(root, ".git"))) {
+  const hooksDir = path46.join(root, ".git", "hooks");
+  if (!existsSync68(path46.join(root, ".git"))) {
     ui.warn("No .git directory found; git enforcement hooks skipped.");
     return;
   }
@@ -11500,31 +11800,31 @@ haive enforce check --stage pre-push --dir . || exit $?
     }
   ];
   for (const hook of hooks) {
-    const file = path45.join(hooksDir, hook.name);
-    if (existsSync67(file)) {
-      const current = await readFile16(file, "utf8").catch(() => "");
+    const file = path46.join(hooksDir, hook.name);
+    if (existsSync68(file)) {
+      const current = await readFile17(file, "utf8").catch(() => "");
       if (current.includes(ENFORCE_HOOK_MARKER)) {
-        await writeFile30(file, hook.body, "utf8");
+        await writeFile31(file, hook.body, "utf8");
       } else {
-        await writeFile30(file, `${current.trimEnd()}
+        await writeFile31(file, `${current.trimEnd()}
 
 ${hook.body}`, "utf8");
       }
     } else {
-      await writeFile30(file, hook.body, "utf8");
+      await writeFile31(file, hook.body, "utf8");
     }
     await chmod2(file, 493);
   }
   ui.success("Installed blocking git enforcement hooks: pre-commit, pre-push");
 }
 async function installCiEnforcement(root) {
-  const workflowPath = path45.join(root, ".github", "workflows", "haive-enforcement.yml");
-  await mkdir18(path45.dirname(workflowPath), { recursive: true });
-  if (existsSync67(workflowPath)) {
+  const workflowPath = path46.join(root, ".github", "workflows", "haive-enforcement.yml");
+  await mkdir18(path46.dirname(workflowPath), { recursive: true });
+  if (existsSync68(workflowPath)) {
     ui.info("GitHub Actions enforcement workflow already exists \u2014 skipped");
     return;
   }
-  await writeFile30(workflowPath, `name: haive-enforcement
+  await writeFile31(workflowPath, `name: haive-enforcement
 
 on:
   pull_request:
@@ -11548,7 +11848,7 @@ jobs:
       - name: Enforce hAIve policy
         run: haive enforce ci
 `, "utf8");
-  ui.success(`Created ${path45.relative(root, workflowPath)}`);
+  ui.success(`Created ${path46.relative(root, workflowPath)}`);
 }
 function printReport(report, json) {
   if (json) {
@@ -11557,6 +11857,7 @@ function printReport(report, json) {
   }
   console.log(ui.bold(`hAIve enforcement \u2014 ${report.mode}`));
   console.log(ui.dim(`  root: ${report.root}`));
+  console.log(ui.dim(`  score: ${report.score.score}% / threshold ${report.score.threshold}%`));
   for (const finding of report.findings) {
     const marker = finding.severity === "error" ? ui.red("\u2717") : finding.severity === "warn" ? ui.yellow("\u26A0") : finding.severity === "ok" ? ui.green("\u2713") : ui.dim("\u2022");
     console.log(`${marker} ${finding.code}: ${finding.message}`);
@@ -11576,7 +11877,7 @@ async function readHookPayload() {
 }
 function resolveRoot(dir, payload) {
   try {
-    return findProjectRoot46(dir ?? payload.cwd);
+    return findProjectRoot47(dir ?? payload.cwd);
   } catch {
     return null;
   }
@@ -11645,8 +11946,8 @@ function registerRun(program2) {
 }
 
 // src/index.ts
-var program = new Command49();
-program.name("haive").description("hAIve \u2014 team-first persistent memory layer for AI coding agents").version("0.9.10");
+var program = new Command50();
+program.name("haive").description("hAIve \u2014 policy enforcement layer for AI coding agents").version("0.9.11");
 registerInit(program);
 registerWelcome(program);
 registerResolveProject(program);
@@ -11694,6 +11995,7 @@ registerSnapshot(program);
 registerHub(program);
 registerStats(program);
 registerBench(program);
+registerBenchmark(program);
 registerDoctor(program);
 registerPlayback(program);
 registerPrecommit(program);