@hiveai/core 0.13.7 → 0.13.9

package/dist/index.js

@@ -596,7 +596,9 @@ function emptyUsage() {
     last_rejected_at: null,
     rejection_reason: null,
     applied_count: 0,
-    last_applied_at: null
+    last_applied_at: null,
+    prevented_count: 0,
+    last_prevented_at: null
   };
 }
 function normalizeUsage(stored) {
@@ -667,6 +669,21 @@ function recordApplied(index, id) {
   };
   return index;
 }
+var PREVENTION_DEBOUNCE_MS = 5 * 60 * 1e3;
+function recordPrevention(index, id, now = Date.now()) {
+  const current = normalizeUsage(index.by_id[id]);
+  const last = current.last_prevented_at ? Date.parse(current.last_prevented_at) : 0;
+  if (Number.isFinite(last) && last > 0 && now - last < PREVENTION_DEBOUNCE_MS) {
+    index.by_id[id] = current;
+    return false;
+  }
+  index.by_id[id] = {
+    ...current,
+    prevented_count: current.prevented_count + 1,
+    last_prevented_at: new Date(now).toISOString()
+  };
+  return true;
+}
 var DECAY_DAYS = 90;
 function isDecaying(usage, createdAt) {
   const threshold = Date.now() - DECAY_DAYS * 24 * 60 * 60 * 1e3;
@@ -710,7 +727,10 @@ function computeImpact(fm, usage, options = {}) {
     raw += Math.min(1, usage.applied_count / 4) * 0.6;
     signals.push(`applied ${usage.applied_count}\xD7`);
   }
-  if (hasSensorFired(fm)) {
+  if (usage.prevented_count > 0) {
+    raw += Math.min(1, usage.prevented_count / 3) * 0.6;
+    signals.push(`prevented ${usage.prevented_count}\xD7`);
+  } else if (hasSensorFired(fm)) {
     raw += 0.25;
     signals.push("sensor fired");
   }
@@ -771,6 +791,71 @@ function summarizeImpact(scores) {
   return summary;
 }
 
+// src/prevention.ts
+import { appendFile, mkdir as mkdir2, readFile as readFile4 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import path6 from "path";
+function preventionLogPath(paths) {
+  return path6.join(paths.haiveDir, ".cache", "prevention-log.jsonl");
+}
+async function appendPreventionEvent(paths, event) {
+  const file = preventionLogPath(paths);
+  await mkdir2(path6.dirname(file), { recursive: true });
+  await appendFile(file, JSON.stringify(event) + "\n", "utf8");
+}
+async function loadPreventionEvents(paths) {
+  const file = preventionLogPath(paths);
+  if (!existsSync4(file)) return [];
+  const raw = await readFile4(file, "utf8").catch(() => "");
+  const events = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const e = JSON.parse(trimmed);
+      if (e && typeof e.at === "string" && typeof e.id === "string") events.push(e);
+    } catch {
+    }
+  }
+  return events;
+}
+var MS_PER_DAY2 = 864e5;
+function computePreventionTrend(events, now = /* @__PURE__ */ new Date(), weeks = 6) {
+  const nowMs = now.getTime();
+  let last7 = 0;
+  let last30 = 0;
+  const weekly = new Array(weeks).fill(0);
+  for (const e of events) {
+    const t = Date.parse(e.at);
+    if (!Number.isFinite(t)) continue;
+    const ageDays = (nowMs - t) / MS_PER_DAY2;
+    if (ageDays < 0) continue;
+    if (ageDays <= 7) last7 += 1;
+    if (ageDays <= 30) last30 += 1;
+    const weekIdx = weeks - 1 - Math.floor(ageDays / 7);
+    if (weekIdx >= 0 && weekIdx < weeks) weekly[weekIdx] = (weekly[weekIdx] ?? 0) + 1;
+  }
+  return { last_7d: last7, last_30d: last30, weekly };
+}
+function computeRecurrence(events) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    const cur = byId.get(e.id) ?? { catches: 0, days: /* @__PURE__ */ new Set(), last: e.at };
+    cur.catches += 1;
+    cur.days.add(e.at.slice(0, 10));
+    if (e.at > cur.last) cur.last = e.at;
+    byId.set(e.id, cur);
+  }
+  const rows = [];
+  for (const [id, v] of byId) {
+    if (v.days.size >= 2) {
+      rows.push({ id, catches: v.catches, distinct_days: v.days.size, last_at: v.last });
+    }
+  }
+  rows.sort((a, b) => b.distinct_days - a.distinct_days || b.catches - a.catches);
+  return { recurring_count: rows.length, top: rows };
+}
+
 // src/eval.ts
 function round32(n) {
   return Math.round(n * 1e3) / 1e3;
@@ -906,13 +991,13 @@ var DEFAULT_CONFIDENCE_THRESHOLDS = {
   decayDays: 180,
   hardDecayDays: 365
 };
-var MS_PER_DAY2 = 24 * 60 * 60 * 1e3;
+var MS_PER_DAY3 = 24 * 60 * 60 * 1e3;
 function deriveConfidence(fm, usage, thresholds = DEFAULT_CONFIDENCE_THRESHOLDS, now = /* @__PURE__ */ new Date()) {
   if (fm.status === "stale" || fm.status === "deprecated" || fm.status === "rejected") return "stale";
   const baseLevel = baseConfidence(fm, usage, thresholds);
   if (baseLevel !== "authoritative" && baseLevel !== "trusted") return baseLevel;
   const anchor = usage.last_read_at ?? fm.created_at;
-  const ageDays = (now.getTime() - new Date(anchor).getTime()) / MS_PER_DAY2;
+  const ageDays = (now.getTime() - new Date(anchor).getTime()) / MS_PER_DAY3;
   if (Number.isNaN(ageDays) || ageDays <= 0) return baseLevel;
   if (ageDays >= thresholds.hardDecayDays) {
     return "low";
@@ -1206,10 +1291,10 @@ function allocateBudget(parts, maxTokens) {
 }
 
 // src/code-map.ts
-import { mkdir as mkdir2, readFile as readFile4, readdir as readdir3, writeFile as writeFile2 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
+import { mkdir as mkdir3, readFile as readFile5, readdir as readdir3, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
 import { spawnSync } from "child_process";
-import path6 from "path";
+import path7 from "path";
 var CODE_MAP_FILE = "code-map.json";
 var DEFAULT_INCLUDE = [
   ".ts",
@@ -1251,16 +1336,16 @@ var DEFAULT_EXCLUDE = [
 ];
 var TEST_FILE_RE = /\.(test|spec)\.[a-z]+$/i;
 function codeMapPath(paths) {
-  return path6.join(paths.haiveDir, CODE_MAP_FILE);
+  return path7.join(paths.haiveDir, CODE_MAP_FILE);
 }
 async function loadCodeMap(paths) {
   const file = codeMapPath(paths);
-  if (!existsSync4(file)) return null;
-  return JSON.parse(await readFile4(file, "utf8"));
+  if (!existsSync5(file)) return null;
+  return JSON.parse(await readFile5(file, "utf8"));
 }
 async function saveCodeMap(paths, map) {
   const file = codeMapPath(paths);
-  await mkdir2(path6.dirname(file), { recursive: true });
+  await mkdir3(path7.dirname(file), { recursive: true });
   await writeFile2(file, JSON.stringify(map, null, 2), "utf8");
 }
 async function buildCodeMap(root, options = {}) {
@@ -1268,10 +1353,10 @@ async function buildCodeMap(root, options = {}) {
   const exclude = new Set(options.excludeDirs ?? DEFAULT_EXCLUDE);
   const files = {};
   for await (const abs of collectSourceFiles(root, include, exclude, options.includeUntracked)) {
-    const rel = path6.relative(root, abs).replace(/\\/g, "/");
+    const rel = path7.relative(root, abs).replace(/\\/g, "/");
     if (rel.startsWith(".ai/")) continue;
-    const content = await readFile4(abs, "utf8");
-    const ext = path6.extname(abs).toLowerCase();
+    const content = await readFile5(abs, "utf8");
+    const ext = path7.extname(abs).toLowerCase();
     const entry = parseFile(content, ext);
     if (entry.exports.length > 0) files[rel] = entry;
   }
@@ -1285,7 +1370,7 @@ async function buildCodeMap(root, options = {}) {
 async function* collectSourceFiles(root, include, exclude, includeUntracked) {
   const gitFiles = gitSourceFiles(root, include, exclude, includeUntracked === true);
   if (gitFiles) {
-    for (const rel of gitFiles) yield path6.join(root, rel);
+    for (const rel of gitFiles) yield path7.join(root, rel);
     return;
   }
   yield* walkSourceFiles(root, include, exclude);
@@ -1312,11 +1397,11 @@ async function* walkSourceFiles(dir, include, exclude) {
       if (entry.isDirectory()) continue;
     }
     if (exclude.has(entry.name)) continue;
-    const full = path6.join(dir, entry.name);
+    const full = path7.join(dir, entry.name);
     if (entry.isDirectory()) {
       yield* walkSourceFiles(full, include, exclude);
     } else if (entry.isFile()) {
-      const ext = path6.extname(entry.name).toLowerCase();
+      const ext = path7.extname(entry.name).toLowerCase();
       if (include.has(ext) && !TEST_FILE_RE.test(entry.name)) yield full;
     }
   }
@@ -1327,7 +1412,7 @@ function isIncludedSourcePath(rel, include, exclude) {
   const parts = normalized.split("/");
   if (parts.some((part) => exclude.has(part))) return false;
   const base = parts.at(-1) ?? "";
-  const ext = path6.extname(base).toLowerCase();
+  const ext = path7.extname(base).toLowerCase();
   return include.has(ext) && !TEST_FILE_RE.test(base);
 }
 var EXPORT_RE = /^export\s+(?:default\s+)?(async\s+)?(function|class|interface|type|const|let|var|enum)\s+(\*?)\s*([A-Za-z_$][\w$]*)/gm;
@@ -1541,10 +1626,10 @@ function queryCodeMap(map, options) {
 }
 
 // src/config.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { readFileSync } from "fs";
-import { readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
-import path7 from "path";
+import { readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
+import path8 from "path";
 var CONFIG_FILE = "haive.config.json";
 var DEFAULT_CONFIG = {
   autopilot: false,
@@ -1616,13 +1701,13 @@ function antiPatternGateParams(gate) {
   }
 }
 function configPath(paths) {
-  return path7.join(paths.haiveDir, CONFIG_FILE);
+  return path8.join(paths.haiveDir, CONFIG_FILE);
 }
 async function loadConfig(paths) {
   const file = configPath(paths);
-  if (!existsSync5(file)) return { ...DEFAULT_CONFIG };
+  if (!existsSync6(file)) return { ...DEFAULT_CONFIG };
   try {
-    const raw = await readFile5(file, "utf8");
+    const raw = await readFile6(file, "utf8");
     const parsed = JSON.parse(raw);
     const merged = mergeConfig(DEFAULT_CONFIG, parsed);
     if (merged.autopilot) {
@@ -1635,7 +1720,7 @@ async function loadConfig(paths) {
 }
 function loadConfigSync(paths) {
   const file = configPath(paths);
-  if (!existsSync5(file)) return { ...DEFAULT_CONFIG };
+  if (!existsSync6(file)) return { ...DEFAULT_CONFIG };
   try {
     const parsed = JSON.parse(readFileSync(file, "utf8"));
     const merged = mergeConfig(DEFAULT_CONFIG, parsed);
@@ -1663,21 +1748,21 @@ function mergeConfig(base, override) {
 }
 
 // src/cross-repo.ts
-import { existsSync as existsSync6 } from "fs";
-import { mkdir as mkdir3, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
-import path8 from "path";
+import { existsSync as existsSync7 } from "fs";
+import { mkdir as mkdir4, readFile as readFile7, writeFile as writeFile4 } from "fs/promises";
+import path9 from "path";
 import { spawnSync as spawnSync2 } from "child_process";
 async function loadImportMap(cacheDir) {
-  const mapPath = path8.join(cacheDir, "import-map.json");
-  if (!existsSync6(mapPath)) return {};
+  const mapPath = path9.join(cacheDir, "import-map.json");
+  if (!existsSync7(mapPath)) return {};
   try {
-    return JSON.parse(await readFile6(mapPath, "utf8"));
+    return JSON.parse(await readFile7(mapPath, "utf8"));
   } catch {
     return {};
   }
 }
 async function saveImportMap(cacheDir, map) {
-  await writeFile4(path8.join(cacheDir, "import-map.json"), JSON.stringify(map, null, 2) + "\n", "utf8");
+  await writeFile4(path9.join(cacheDir, "import-map.json"), JSON.stringify(map, null, 2) + "\n", "utf8");
 }
 async function pullCrossRepoSources(paths, config, projectRoot) {
   const sources = config.crossRepoSources ?? [];
@@ -1698,8 +1783,8 @@ async function pullFromSource(paths, source, projectRoot) {
   };
   let sourceRoot = null;
   if (source.path) {
-    const resolved = path8.resolve(projectRoot, source.path);
-    if (!existsSync6(resolved)) {
+    const resolved = path9.resolve(projectRoot, source.path);
+    if (!existsSync7(resolved)) {
       report.errors.push(`Path not found: ${resolved}`);
       return report;
     }
@@ -1712,7 +1797,7 @@ async function pullFromSource(paths, source, projectRoot) {
     return report;
   }
   const sourcePaths = resolveHaivePaths(sourceRoot);
-  if (!existsSync6(sourcePaths.memoriesDir)) {
+  if (!existsSync7(sourcePaths.memoriesDir)) {
     report.errors.push(`No .ai/memories/ found at ${sourceRoot}`);
     return report;
   }
@@ -1735,10 +1820,10 @@ async function pullFromSource(paths, source, projectRoot) {
     report.skipped.push("no shared memories found in source");
     return report;
   }
-  const destDir = path8.join(paths.memoriesDir, "shared", source.name);
-  await mkdir3(destDir, { recursive: true });
-  const cacheDir = path8.join(paths.haiveDir, ".cache", "cross-repo", source.name);
-  await mkdir3(cacheDir, { recursive: true });
+  const destDir = path9.join(paths.memoriesDir, "shared", source.name);
+  await mkdir4(destDir, { recursive: true });
+  const cacheDir = path9.join(paths.haiveDir, ".cache", "cross-repo", source.name);
+  await mkdir4(cacheDir, { recursive: true });
   const importMap = await loadImportMap(cacheDir);
   const mapDirty = false;
   let dirty = mapDirty;
@@ -1752,7 +1837,7 @@ async function pullFromSource(paths, source, projectRoot) {
 
 `;
     const existingLocalPath = importMap[sourceId];
-    if (existingLocalPath && existsSync6(existingLocalPath)) {
+    if (existingLocalPath && existsSync7(existingLocalPath)) {
       const existingFiles = await loadMemoriesFromDir(destDir);
       const existingEntry = existingFiles.find(({ filePath }) => filePath === existingLocalPath);
       const sourceBodyStripped = memory.body.trim();
@@ -1787,7 +1872,7 @@ async function pullFromSource(paths, source, projectRoot) {
         topic: fm.topic ? `${source.name}:${fm.topic}` : void 0
       });
       const body = importedBodyPrefix + memory.body;
-      const destPath = path8.join(destDir, `${newFm.id}.md`);
+      const destPath = path9.join(destDir, `${newFm.id}.md`);
       await writeFile4(destPath, serializeMemory({ frontmatter: newFm, body }), "utf8");
       importMap[sourceId] = destPath;
       dirty = true;
@@ -1798,9 +1883,9 @@ async function pullFromSource(paths, source, projectRoot) {
   return report;
 }
 async function cloneOrFetchGitSource(source, paths, report) {
-  const cacheDir = path8.join(paths.haiveDir, ".cache", "cross-repo", source.name);
-  await mkdir3(cacheDir, { recursive: true });
-  if (existsSync6(path8.join(cacheDir, ".git"))) {
+  const cacheDir = path9.join(paths.haiveDir, ".cache", "cross-repo", source.name);
+  await mkdir4(cacheDir, { recursive: true });
+  if (existsSync7(path9.join(cacheDir, ".git"))) {
     const result = spawnSync2("git", ["fetch", "--depth=1", "origin"], {
       cwd: cacheDir,
       encoding: "utf8"
@@ -1825,9 +1910,9 @@ async function cloneOrFetchGitSource(source, paths, report) {
 }
 
 // src/dep-tracker.ts
-import { existsSync as existsSync7 } from "fs";
-import { readFile as readFile7, writeFile as writeFile5, mkdir as mkdir4 } from "fs/promises";
-import path9 from "path";
+import { existsSync as existsSync8 } from "fs";
+import { readFile as readFile8, writeFile as writeFile5, mkdir as mkdir5 } from "fs/promises";
+import path10 from "path";
 function parsePackageJson(content) {
   try {
     const pkg = JSON.parse(content);
@@ -1899,7 +1984,7 @@ var KNOWN_MANIFESTS = [
   { name: "pom.xml", parser: parsePomXml }
 ];
 function getParser(file) {
-  const base = path9.basename(file);
+  const base = path10.basename(file);
   return KNOWN_MANIFESTS.find((m) => m.name === base)?.parser ?? null;
 }
 function extractMajor(version) {
@@ -1917,32 +2002,32 @@ function isMajorBump(from, to) {
 }
 function resolveManifestFiles(projectRoot, configuredFiles) {
   if (configuredFiles !== void 0) {
-    return configuredFiles.map((f) => path9.resolve(projectRoot, f)).filter(existsSync7);
+    return configuredFiles.map((f) => path10.resolve(projectRoot, f)).filter(existsSync8);
   }
-  return KNOWN_MANIFESTS.map(({ name }) => path9.join(projectRoot, name)).filter(existsSync7);
+  return KNOWN_MANIFESTS.map(({ name }) => path10.join(projectRoot, name)).filter(existsSync8);
 }
 async function trackDependencies(projectRoot, haiveDir, manifestFiles) {
-  const contractsDir = path9.join(haiveDir, "contracts");
-  await mkdir4(contractsDir, { recursive: true });
+  const contractsDir = path10.join(haiveDir, "contracts");
+  await mkdir5(contractsDir, { recursive: true });
   const results = [];
   for (const manifestPath of manifestFiles) {
     const parser = getParser(manifestPath);
     if (!parser) continue;
-    const content = await readFile7(manifestPath, "utf8");
+    const content = await readFile8(manifestPath, "utf8");
     const currentDeps = parser(content);
-    const lockName = `deps-${path9.basename(manifestPath)}.lock`;
-    const lockPath = path9.join(contractsDir, lockName);
-    if (!existsSync7(lockPath)) {
+    const lockName = `deps-${path10.basename(manifestPath)}.lock`;
+    const lockPath = path10.join(contractsDir, lockName);
+    if (!existsSync8(lockPath)) {
       const snapshot2 = {
-        file: path9.relative(projectRoot, manifestPath),
-        format: path9.basename(manifestPath),
+        file: path10.relative(projectRoot, manifestPath),
+        format: path10.basename(manifestPath),
         captured_at: (/* @__PURE__ */ new Date()).toISOString(),
         deps: currentDeps
       };
       await writeFile5(lockPath, JSON.stringify(snapshot2, null, 2) + "\n", "utf8");
       continue;
     }
-    const snapshot = JSON.parse(await readFile7(lockPath, "utf8"));
+    const snapshot = JSON.parse(await readFile8(lockPath, "utf8"));
     const changes = [];
     for (const [name, currentVer] of Object.entries(currentDeps)) {
       const prevVer = snapshot.deps[name];
@@ -1956,7 +2041,7 @@ async function trackDependencies(projectRoot, haiveDir, manifestFiles) {
       }
     }
     if (changes.length > 0) {
-      results.push({ file: path9.relative(projectRoot, manifestPath), changes });
+      results.push({ file: path10.relative(projectRoot, manifestPath), changes });
       const updated = {
         ...snapshot,
         captured_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1969,9 +2054,9 @@ async function trackDependencies(projectRoot, haiveDir, manifestFiles) {
 }
 
 // src/contract-watcher.ts
-import { existsSync as existsSync8 } from "fs";
-import { readFile as readFile8, writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
-import path10 from "path";
+import { existsSync as existsSync9 } from "fs";
+import { readFile as readFile9, writeFile as writeFile6, mkdir as mkdir6 } from "fs/promises";
+import path11 from "path";
 import crypto from "crypto";
 function sha256(content) {
   return crypto.createHash("sha256").update(content).digest("hex");
@@ -2174,14 +2259,14 @@ function diffSnapshots(before, after) {
   return changes;
 }
 function contractLockPath(haiveDir, name) {
-  return path10.join(haiveDir, "contracts", `${name}.lock`);
+  return path11.join(haiveDir, "contracts", `${name}.lock`);
 }
 async function snapshotContract(projectRoot, haiveDir, contract) {
-  const filePath = path10.resolve(projectRoot, contract.path);
-  if (!existsSync8(filePath)) {
+  const filePath = path11.resolve(projectRoot, contract.path);
+  if (!existsSync9(filePath)) {
     throw new Error(`Contract file not found: ${filePath}`);
   }
-  const content = await readFile8(filePath, "utf8");
+  const content = await readFile9(filePath, "utf8");
   const parsed = parseByFormat(content, contract.format, filePath);
   const snapshot = {
     name: contract.name,
@@ -2191,23 +2276,23 @@ async function snapshotContract(projectRoot, haiveDir, contract) {
     hash: sha256(content),
     ...parsed
   };
-  const contractsDir = path10.join(haiveDir, "contracts");
-  await mkdir5(contractsDir, { recursive: true });
+  const contractsDir = path11.join(haiveDir, "contracts");
+  await mkdir6(contractsDir, { recursive: true });
   await writeFile6(contractLockPath(haiveDir, contract.name), JSON.stringify(snapshot, null, 2) + "\n", "utf8");
   return snapshot;
 }
 async function diffContract(projectRoot, haiveDir, contract) {
-  const filePath = path10.resolve(projectRoot, contract.path);
-  if (!existsSync8(filePath)) {
+  const filePath = path11.resolve(projectRoot, contract.path);
+  if (!existsSync9(filePath)) {
     return { contract: contract.name, file: contract.path, changes: [], unchanged: true };
   }
   const lockPath = contractLockPath(haiveDir, contract.name);
-  if (!existsSync8(lockPath)) {
+  if (!existsSync9(lockPath)) {
     await snapshotContract(projectRoot, haiveDir, contract);
     return { contract: contract.name, file: contract.path, changes: [], unchanged: true };
   }
-  const content = await readFile8(filePath, "utf8");
-  const beforeSnapshot = JSON.parse(await readFile8(lockPath, "utf8"));
+  const content = await readFile9(filePath, "utf8");
+  const beforeSnapshot = JSON.parse(await readFile9(lockPath, "utf8"));
   const afterParsed = parseByFormat(content, contract.format, filePath);
   const afterSnapshot = {
     ...beforeSnapshot,
@@ -2235,27 +2320,27 @@ async function watchContracts(projectRoot, haiveDir, contractFiles) {
 }
 
 // src/usage-log.ts
-import { appendFile, mkdir as mkdir6, readFile as readFile9, stat as stat2 } from "fs/promises";
-import { existsSync as existsSync9 } from "fs";
-import path11 from "path";
+import { appendFile as appendFile2, mkdir as mkdir7, readFile as readFile10, stat as stat2 } from "fs/promises";
+import { existsSync as existsSync10 } from "fs";
+import path12 from "path";
 var USAGE_LOG_FILE = "tool-usage.jsonl";
 var USAGE_LOG_DIR = ".usage";
 function usageLogPath(paths) {
-  return path11.join(paths.haiveDir, USAGE_LOG_DIR, USAGE_LOG_FILE);
+  return path12.join(paths.haiveDir, USAGE_LOG_DIR, USAGE_LOG_FILE);
 }
 async function appendUsageEvent(paths, event) {
   try {
     const file = usageLogPath(paths);
-    const dir = path11.dirname(file);
-    if (!existsSync9(dir)) await mkdir6(dir, { recursive: true });
-    await appendFile(file, JSON.stringify(event) + "\n", "utf8");
+    const dir = path12.dirname(file);
+    if (!existsSync10(dir)) await mkdir7(dir, { recursive: true });
+    await appendFile2(file, JSON.stringify(event) + "\n", "utf8");
   } catch {
   }
 }
 async function readUsageEvents(paths) {
   const file = usageLogPath(paths);
-  if (!existsSync9(file)) return [];
-  const raw = await readFile9(file, "utf8");
+  if (!existsSync10(file)) return [];
+  const raw = await readFile10(file, "utf8");
   const out = [];
   for (const line of raw.split("\n")) {
     if (!line) continue;
@@ -2304,9 +2389,9 @@ function parseSince(input) {
 }
 async function usageLogSize(paths) {
   const file = usageLogPath(paths);
-  if (!existsSync9(file)) return { exists: false, size_bytes: 0, lines: 0 };
+  if (!existsSync10(file)) return { exists: false, size_bytes: 0, lines: 0 };
   const st = await stat2(file);
-  const raw = await readFile9(file, "utf8");
+  const raw = await readFile10(file, "utf8");
   return { exists: true, size_bytes: st.size, lines: raw.split("\n").filter((l) => l).length };
 }
 
@@ -2376,21 +2461,21 @@ function extractActionsBriefBody(markdown, maxChars = MAX_DEFAULT_CHARS) {
 }
 
 // src/resolve-project.ts
-import { existsSync as existsSync10 } from "fs";
-import path12 from "path";
+import { existsSync as existsSync11 } from "fs";
+import path13 from "path";
 var ROOT_MARKERS2 = [".ai", ".git", "package.json"];
 function markersAtRoot(root) {
   const found = [];
   for (const m of ROOT_MARKERS2) {
-    if (existsSync10(path12.join(root, m))) found.push(m);
+    if (existsSync11(path13.join(root, m))) found.push(m);
   }
   return found;
 }
 function resolveProjectInfo(opts = {}) {
   const env = opts.env ?? process.env;
-  const cwd = path12.resolve(opts.cwd ?? process.cwd());
+  const cwd = path13.resolve(opts.cwd ?? process.cwd());
   const raw = env.HAIVE_PROJECT_ROOT;
-  const explicit = raw !== void 0 && raw !== "" ? path12.resolve(raw) : null;
+  const explicit = raw !== void 0 && raw !== "" ? path13.resolve(raw) : null;
   const resolvedRoot = explicit ?? findProjectRoot(cwd);
   const paths = resolveHaivePaths(resolvedRoot);
   return {
@@ -2398,8 +2483,8 @@ function resolveProjectInfo(opts = {}) {
     resolved_root: resolvedRoot,
     haive_project_root_env: explicit,
     explicit_root: explicit != null,
-    haive_dir_exists: existsSync10(paths.haiveDir),
-    memories_dir_exists: existsSync10(paths.memoriesDir),
+    haive_dir_exists: existsSync11(paths.haiveDir),
+    memories_dir_exists: existsSync11(paths.memoriesDir),
     runtime_dir: paths.runtimeDir,
     markers_found: markersAtRoot(resolvedRoot)
   };
@@ -2654,16 +2739,16 @@ function findLexicalConflictPairs(memories, opts) {
 }
 
 // src/runtime-journal.ts
-import { mkdir as mkdir7, readFile as readFile10, appendFile as appendFile2 } from "fs/promises";
-import { existsSync as existsSync11 } from "fs";
-import path13 from "path";
+import { mkdir as mkdir8, readFile as readFile11, appendFile as appendFile3 } from "fs/promises";
+import { existsSync as existsSync12 } from "fs";
+import path14 from "path";
 var RUNTIME_JOURNAL_FILENAME = "session-journal.ndjson";
 function runtimeJournalPath(paths) {
-  return path13.join(paths.runtimeDir, RUNTIME_JOURNAL_FILENAME);
+  return path14.join(paths.runtimeDir, RUNTIME_JOURNAL_FILENAME);
 }
 async function appendRuntimeJournalEntry(paths, entry) {
   try {
-    await mkdir7(paths.runtimeDir, { recursive: true });
+    await mkdir8(paths.runtimeDir, { recursive: true });
     const line = {
       ts: entry.ts ?? (/* @__PURE__ */ new Date()).toISOString(),
       kind: entry.kind,
@@ -2671,7 +2756,7 @@ async function appendRuntimeJournalEntry(paths, entry) {
       ...entry.tool !== void 0 ? { tool: entry.tool } : {},
       ...entry.meta !== void 0 ? { meta: entry.meta } : {}
     };
-    await appendFile2(
+    await appendFile3(
       runtimeJournalPath(paths),
       JSON.stringify(line) + "\n",
       "utf8"
@@ -2681,9 +2766,9 @@ async function appendRuntimeJournalEntry(paths, entry) {
 }
 async function readRuntimeJournalTail(paths, limit) {
   const file = runtimeJournalPath(paths);
-  if (!existsSync11(file) || limit <= 0) return [];
+  if (!existsSync12(file) || limit <= 0) return [];
   try {
-    const raw = await readFile10(file, "utf8");
+    const raw = await readFile11(file, "utf8");
     const lines = raw.trim().split("\n").filter(Boolean);
     const parsed = [];
     for (const line of lines.slice(-limit)) {
@@ -2699,22 +2784,22 @@ async function readRuntimeJournalTail(paths, limit) {
 }
 
 // src/enforcement.ts
-import { mkdir as mkdir8, readdir as readdir4, readFile as readFile11, writeFile as writeFile7 } from "fs/promises";
-import { existsSync as existsSync12 } from "fs";
-import path14 from "path";
+import { mkdir as mkdir9, readdir as readdir4, readFile as readFile12, writeFile as writeFile7 } from "fs/promises";
+import { existsSync as existsSync13 } from "fs";
+import path15 from "path";
 var BRIEFING_MARKER_TTL_MS = 12 * 60 * 60 * 1e3;
 var SESSION_RECAP_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 function enforcementDir(paths) {
-  return path14.join(paths.runtimeDir, "enforcement");
+  return path15.join(paths.runtimeDir, "enforcement");
 }
 function briefingMarkersDir(paths) {
-  return path14.join(enforcementDir(paths), "briefings");
+  return path15.join(enforcementDir(paths), "briefings");
 }
 function normalizeSessionId(sessionId) {
   return (sessionId?.trim() || "default").replace(/[^a-zA-Z0-9_.-]+/g, "-").slice(0, 120);
 }
 function briefingMarkerPath(paths, sessionId) {
-  return path14.join(briefingMarkersDir(paths), `${normalizeSessionId(sessionId)}.json`);
+  return path15.join(briefingMarkersDir(paths), `${normalizeSessionId(sessionId)}.json`);
 }
 async function writeBriefingMarker(paths, input) {
   const marker = {
@@ -2726,7 +2811,7 @@ async function writeBriefingMarker(paths, input) {
     created_at: (/* @__PURE__ */ new Date()).toISOString(),
     root: paths.root
   };
-  await mkdir8(briefingMarkersDir(paths), { recursive: true });
+  await mkdir9(briefingMarkersDir(paths), { recursive: true });
   await writeFile7(
     briefingMarkerPath(paths, marker.session_id),
     JSON.stringify(marker, null, 2) + "\n",
@@ -2738,18 +2823,18 @@ async function hasRecentBriefingMarker(paths, sessionId, ttlMs = BRIEFING_MARKER
   const now = Date.now();
   const candidates = [];
   const exact = briefingMarkerPath(paths, sessionId);
-  if (existsSync12(exact)) candidates.push(exact);
+  if (existsSync13(exact)) candidates.push(exact);
   try {
     const dir = briefingMarkersDir(paths);
     const files = await readdir4(dir);
     for (const file of files) {
-      if (file.endsWith(".json")) candidates.push(path14.join(dir, file));
+      if (file.endsWith(".json")) candidates.push(path15.join(dir, file));
     }
   } catch {
   }
   for (const file of new Set(candidates)) {
     try {
-      const marker = JSON.parse(await readFile11(file, "utf8"));
+      const marker = JSON.parse(await readFile12(file, "utf8"));
       const created = Date.parse(marker.created_at);
       if (Number.isFinite(created) && now - created <= ttlMs) return true;
     } catch {
@@ -2761,12 +2846,12 @@ async function readRecentBriefingMarker(paths, sessionId, ttlMs = BRIEFING_MARKE
   const now = Date.now();
   const candidates = [];
   const exact = briefingMarkerPath(paths, sessionId);
-  if (existsSync12(exact)) candidates.push(exact);
+  if (existsSync13(exact)) candidates.push(exact);
   try {
     const dir = briefingMarkersDir(paths);
     const files = await readdir4(dir);
     for (const file of files) {
-      if (file.endsWith(".json")) candidates.push(path14.join(dir, file));
+      if (file.endsWith(".json")) candidates.push(path15.join(dir, file));
     }
   } catch {
   }
@@ -2774,7 +2859,7 @@ async function readRecentBriefingMarker(paths, sessionId, ttlMs = BRIEFING_MARKE
   let freshestTs = 0;
   for (const file of new Set(candidates)) {
     try {
-      const marker = JSON.parse(await readFile11(file, "utf8"));
+      const marker = JSON.parse(await readFile12(file, "utf8"));
       const created = Date.parse(marker.created_at);
       if (!Number.isFinite(created) || now - created > ttlMs) continue;
       if (created > freshestTs) {
@@ -2827,10 +2912,10 @@ function isRetiredMemory(fm, body = "", now = /* @__PURE__ */ new Date()) {
 function normalizeProjectPath(value) {
   return value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^[ab]\//, "").replace(/\/+$/g, "");
 }
-function sensorAppliesToPath(sensor, anchorPaths, path15) {
+function sensorAppliesToPath(sensor, anchorPaths, path16) {
   const scopes = sensor.paths.length > 0 ? sensor.paths : anchorPaths;
   if (scopes.length === 0) return true;
-  const target = normalizeProjectPath(path15);
+  const target = normalizeProjectPath(path16);
   return scopes.some((rawScope) => {
     const scope = normalizeProjectPath(rawScope);
     if (!scope) return false;
@@ -3104,8 +3189,8 @@ function normalizeFindingSeverity(raw) {
       return "info";
   }
 }
-function findingKey(tool, ruleId, path15) {
-  return `${tool}:${ruleId}:${path15}`;
+function findingKey(tool, ruleId, path16) {
+  return `${tool}:${ruleId}:${path16}`;
 }
 function coerceJson(input) {
   if (typeof input === "string") {
@@ -3139,8 +3224,8 @@ function parseSarif(input) {
       const physical = asRecord(location.physicalLocation);
       const artifact = asRecord(physical.artifactLocation);
       const region = asRecord(physical.region);
-      const path15 = typeof artifact.uri === "string" ? normalizeUri(artifact.uri) : "";
-      if (!path15) continue;
+      const path16 = typeof artifact.uri === "string" ? normalizeUri(artifact.uri) : "";
+      if (!path16) continue;
       const line = typeof region.startLine === "number" ? region.startLine : void 0;
       const snippet = typeof asRecord(region.snippet).text === "string" ? asRecord(region.snippet).text.trim() : void 0;
       findings.push({
@@ -3148,10 +3233,10 @@ function parseSarif(input) {
         ruleId,
         message: message.trim(),
         severity,
-        path: path15,
+        path: path16,
         ...line !== void 0 ? { line } : {},
         ...snippet ? { snippet } : {},
-        key: findingKey(tool, ruleId, path15)
+        key: findingKey(tool, ruleId, path16)
       });
     }
   }
@@ -3170,17 +3255,17 @@ function parseSonar(input) {
       (typeof issue.severity === "string" ? issue.severity : void 0) ?? impactSeverity
     );
     const component = typeof issue.component === "string" ? issue.component : "";
-    const path15 = componentToPath(component);
-    if (!path15) continue;
+    const path16 = componentToPath(component);
+    if (!path16) continue;
     const line = typeof issue.line === "number" ? issue.line : void 0;
     findings.push({
       tool: "sonar",
       ruleId,
       message,
       severity,
-      path: path15,
+      path: path16,
       ...line !== void 0 ? { line } : {},
-      key: findingKey("sonar", ruleId, path15)
+      key: findingKey("sonar", ruleId, path16)
     });
   }
   return findings;
@@ -3258,7 +3343,7 @@ function filterNewDrafts(drafts, existingTopics) {
 }
 
 // src/dashboard.ts
-var MS_PER_DAY3 = 24 * 60 * 60 * 1e3;
+var MS_PER_DAY4 = 24 * 60 * 60 * 1e3;
 function isAnchorless(fm) {
   if (!["decision", "gotcha", "architecture"].includes(fm.type)) return false;
   if (fm.status !== "validated") return false;
@@ -3294,6 +3379,8 @@ function buildDashboard(memories, usage, options = {}) {
   let decaying = 0;
   let bodyChars = 0;
   const dormantRows = [];
+  let preventionEvents = 0;
+  const preventionRows = [];
   for (const { memory } of memories) {
     const fm = memory.frontmatter;
     if (fm.type === "session_recap") {
@@ -3338,10 +3425,19 @@ function buildDashboard(memories, usage, options = {}) {
       signals: impact.signals,
       prune_candidate: impact.pruneCandidate
     });
+    if (memUsage.prevented_count > 0) {
+      preventionEvents += memUsage.prevented_count;
+      preventionRows.push({
+        id: fm.id,
+        type: fm.type,
+        prevented_count: memUsage.prevented_count,
+        last_prevented_at: memUsage.last_prevented_at
+      });
+    }
     if (isDecaying(memUsage, fm.created_at)) decaying += 1;
     if (impact.tier === "dormant") {
       const anchor = memUsage.last_read_at ?? fm.created_at;
-      const ageDays = Math.floor((now.getTime() - new Date(anchor).getTime()) / MS_PER_DAY3);
+      const ageDays = Math.floor((now.getTime() - new Date(anchor).getTime()) / MS_PER_DAY4);
       dormantRows.push({ id: fm.id, last_read_at: memUsage.last_read_at, age_days: ageDays });
     }
   }
@@ -3377,6 +3473,16 @@ function buildDashboard(memories, usage, options = {}) {
       decaying,
       top_dormant: dormantRows.slice(0, top)
     },
+    prevention: {
+      total_events: preventionEvents,
+      memories_with_catches: preventionRows.length,
+      top: preventionRows.sort((a, b) => b.prevented_count - a.prevented_count).slice(0, top),
+      trend: computePreventionTrend(options.preventionEvents ?? [], now),
+      recurrence: {
+        ...computeRecurrence(options.preventionEvents ?? []),
+        top: computeRecurrence(options.preventionEvents ?? []).top.slice(0, top)
+      }
+    },
     corpus: {
       memory_files: inventory.total,
       body_chars: bodyChars,
@@ -3408,6 +3514,7 @@ export {
   MemoryScopeSchema,
   MemoryStatusSchema,
   MemoryTypeSchema,
+  PREVENTION_DEBOUNCE_MS,
   PROJECT_CONTEXT_FILE,
   RUNTIME_JOURNAL_FILENAME,
   SESSION_RECAP_TTL_MS,
@@ -3422,6 +3529,7 @@ export {
   aggregateUsage,
   allocateBudget,
   antiPatternGateParams,
+  appendPreventionEvent,
   appendRuntimeJournalEntry,
   appendUsageEvent,
   briefingMarkerPath,
@@ -3438,6 +3546,8 @@ export {
   compareImpact,
   compileRegexSensor,
   computeImpact,
+  computePreventionTrend,
+  computeRecurrence,
   configPath,
   contractLockPath,
   deriveConfidence,
@@ -3481,6 +3591,7 @@ export {
   loadConfigSync,
   loadMemoriesFromDir,
   loadMemory,
+  loadPreventionEvents,
   loadUsageIndex,
   memoryFilePath,
   memoryMatchesAnchorPaths,
@@ -3495,6 +3606,7 @@ export {
   parseSonar,
   pathsOverlap,
   pickSnippetNeedle,
+  preventionLogPath,
   pullCrossRepoSources,
   queryCodeMap,
   rankMemoriesLexical,
@@ -3502,6 +3614,7 @@ export {
   readRuntimeJournalTail,
   readUsageEvents,
   recordApplied,
+  recordPrevention,
   recordRejection,
   relPathFrom,
   resolveBriefingBudget,