@hiveai/core 0.13.9 → 0.15.0

package/dist/index.js

@@ -856,6 +856,37 @@ function computeRecurrence(events) {
   return { recurring_count: rows.length, top: rows };
 }
 
+// src/context-throttle.ts
+import { createHash } from "crypto";
+import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import path7 from "path";
+var PROJECT_CONTEXT_THROTTLE_MS = 8 * 60 * 1e3;
+function throttleMarkerPath(paths) {
+  return path7.join(paths.haiveDir, ".cache", "briefing-context.json");
+}
+function hashProjectContext(content) {
+  return createHash("sha1").update(content).digest("hex").slice(0, 16);
+}
+async function projectContextRecentlyEmitted(paths, hash, now = Date.now()) {
+  const file = throttleMarkerPath(paths);
+  if (!existsSync5(file)) return false;
+  try {
+    const m = JSON.parse(await readFile5(file, "utf8"));
+    if (m.hash !== hash || !m.at) return false;
+    return now - Date.parse(m.at) < PROJECT_CONTEXT_THROTTLE_MS;
+  } catch {
+    return false;
+  }
+}
+async function recordProjectContextEmission(paths, hash, now = Date.now()) {
+  const file = throttleMarkerPath(paths);
+  await mkdir3(path7.dirname(file), { recursive: true }).catch(() => {
+  });
+  await writeFile2(file, JSON.stringify({ hash, at: new Date(now).toISOString() }), "utf8").catch(() => {
+  });
+}
+
 // src/eval.ts
 function round32(n) {
   return Math.round(n * 1e3) / 1e3;
@@ -1291,10 +1322,10 @@ function allocateBudget(parts, maxTokens) {
 }
 
 // src/code-map.ts
-import { mkdir as mkdir3, readFile as readFile5, readdir as readdir3, writeFile as writeFile2 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
+import { mkdir as mkdir4, readFile as readFile6, readdir as readdir3, writeFile as writeFile3 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
 import { spawnSync } from "child_process";
-import path7 from "path";
+import path8 from "path";
 var CODE_MAP_FILE = "code-map.json";
 var DEFAULT_INCLUDE = [
   ".ts",
@@ -1336,27 +1367,27 @@ var DEFAULT_EXCLUDE = [
 ];
 var TEST_FILE_RE = /\.(test|spec)\.[a-z]+$/i;
 function codeMapPath(paths) {
-  return path7.join(paths.haiveDir, CODE_MAP_FILE);
+  return path8.join(paths.haiveDir, CODE_MAP_FILE);
 }
 async function loadCodeMap(paths) {
   const file = codeMapPath(paths);
-  if (!existsSync5(file)) return null;
-  return JSON.parse(await readFile5(file, "utf8"));
+  if (!existsSync6(file)) return null;
+  return JSON.parse(await readFile6(file, "utf8"));
 }
 async function saveCodeMap(paths, map) {
   const file = codeMapPath(paths);
-  await mkdir3(path7.dirname(file), { recursive: true });
-  await writeFile2(file, JSON.stringify(map, null, 2), "utf8");
+  await mkdir4(path8.dirname(file), { recursive: true });
+  await writeFile3(file, JSON.stringify(map, null, 2), "utf8");
 }
 async function buildCodeMap(root, options = {}) {
   const include = new Set(options.includeExtensions ?? DEFAULT_INCLUDE);
   const exclude = new Set(options.excludeDirs ?? DEFAULT_EXCLUDE);
   const files = {};
   for await (const abs of collectSourceFiles(root, include, exclude, options.includeUntracked)) {
-    const rel = path7.relative(root, abs).replace(/\\/g, "/");
+    const rel = path8.relative(root, abs).replace(/\\/g, "/");
     if (rel.startsWith(".ai/")) continue;
-    const content = await readFile5(abs, "utf8");
-    const ext = path7.extname(abs).toLowerCase();
+    const content = await readFile6(abs, "utf8");
+    const ext = path8.extname(abs).toLowerCase();
     const entry = parseFile(content, ext);
     if (entry.exports.length > 0) files[rel] = entry;
   }
@@ -1370,7 +1401,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 path7.join(root, rel);
+    for (const rel of gitFiles) yield path8.join(root, rel);
     return;
   }
   yield* walkSourceFiles(root, include, exclude);
@@ -1397,11 +1428,11 @@ async function* walkSourceFiles(dir, include, exclude) {
       if (entry.isDirectory()) continue;
     }
     if (exclude.has(entry.name)) continue;
-    const full = path7.join(dir, entry.name);
+    const full = path8.join(dir, entry.name);
     if (entry.isDirectory()) {
       yield* walkSourceFiles(full, include, exclude);
     } else if (entry.isFile()) {
-      const ext = path7.extname(entry.name).toLowerCase();
+      const ext = path8.extname(entry.name).toLowerCase();
       if (include.has(ext) && !TEST_FILE_RE.test(entry.name)) yield full;
     }
   }
@@ -1412,7 +1443,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 = path7.extname(base).toLowerCase();
+  const ext = path8.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;
@@ -1626,10 +1657,10 @@ function queryCodeMap(map, options) {
 }
 
 // src/config.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { readFileSync } from "fs";
-import { readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
-import path8 from "path";
+import { readFile as readFile7, writeFile as writeFile4 } from "fs/promises";
+import path9 from "path";
 var CONFIG_FILE = "haive.config.json";
 var DEFAULT_CONFIG = {
   autopilot: false,
@@ -1701,13 +1732,13 @@ function antiPatternGateParams(gate) {
   }
 }
 function configPath(paths) {
-  return path8.join(paths.haiveDir, CONFIG_FILE);
+  return path9.join(paths.haiveDir, CONFIG_FILE);
 }
 async function loadConfig(paths) {
   const file = configPath(paths);
-  if (!existsSync6(file)) return { ...DEFAULT_CONFIG };
+  if (!existsSync7(file)) return { ...DEFAULT_CONFIG };
   try {
-    const raw = await readFile6(file, "utf8");
+    const raw = await readFile7(file, "utf8");
     const parsed = JSON.parse(raw);
     const merged = mergeConfig(DEFAULT_CONFIG, parsed);
     if (merged.autopilot) {
@@ -1720,7 +1751,7 @@ async function loadConfig(paths) {
 }
 function loadConfigSync(paths) {
   const file = configPath(paths);
-  if (!existsSync6(file)) return { ...DEFAULT_CONFIG };
+  if (!existsSync7(file)) return { ...DEFAULT_CONFIG };
   try {
     const parsed = JSON.parse(readFileSync(file, "utf8"));
     const merged = mergeConfig(DEFAULT_CONFIG, parsed);
@@ -1730,7 +1761,7 @@ function loadConfigSync(paths) {
   }
 }
 async function saveConfig(paths, config) {
-  await writeFile3(configPath(paths), JSON.stringify(config, null, 2) + "\n", "utf8");
+  await writeFile4(configPath(paths), JSON.stringify(config, null, 2) + "\n", "utf8");
 }
 function mergeConfig(base, override) {
   return {
@@ -1748,21 +1779,21 @@ function mergeConfig(base, override) {
 }
 
 // src/cross-repo.ts
-import { existsSync as existsSync7 } from "fs";
-import { mkdir as mkdir4, readFile as readFile7, writeFile as writeFile4 } from "fs/promises";
-import path9 from "path";
+import { existsSync as existsSync8 } from "fs";
+import { mkdir as mkdir5, readFile as readFile8, writeFile as writeFile5 } from "fs/promises";
+import path10 from "path";
 import { spawnSync as spawnSync2 } from "child_process";
 async function loadImportMap(cacheDir) {
-  const mapPath = path9.join(cacheDir, "import-map.json");
-  if (!existsSync7(mapPath)) return {};
+  const mapPath = path10.join(cacheDir, "import-map.json");
+  if (!existsSync8(mapPath)) return {};
   try {
-    return JSON.parse(await readFile7(mapPath, "utf8"));
+    return JSON.parse(await readFile8(mapPath, "utf8"));
   } catch {
     return {};
   }
 }
 async function saveImportMap(cacheDir, map) {
-  await writeFile4(path9.join(cacheDir, "import-map.json"), JSON.stringify(map, null, 2) + "\n", "utf8");
+  await writeFile5(path10.join(cacheDir, "import-map.json"), JSON.stringify(map, null, 2) + "\n", "utf8");
 }
 async function pullCrossRepoSources(paths, config, projectRoot) {
   const sources = config.crossRepoSources ?? [];
@@ -1783,8 +1814,8 @@ async function pullFromSource(paths, source, projectRoot) {
   };
   let sourceRoot = null;
   if (source.path) {
-    const resolved = path9.resolve(projectRoot, source.path);
-    if (!existsSync7(resolved)) {
+    const resolved = path10.resolve(projectRoot, source.path);
+    if (!existsSync8(resolved)) {
       report.errors.push(`Path not found: ${resolved}`);
       return report;
     }
@@ -1797,7 +1828,7 @@ async function pullFromSource(paths, source, projectRoot) {
     return report;
   }
   const sourcePaths = resolveHaivePaths(sourceRoot);
-  if (!existsSync7(sourcePaths.memoriesDir)) {
+  if (!existsSync8(sourcePaths.memoriesDir)) {
     report.errors.push(`No .ai/memories/ found at ${sourceRoot}`);
     return report;
   }
@@ -1820,10 +1851,10 @@ async function pullFromSource(paths, source, projectRoot) {
     report.skipped.push("no shared memories found in source");
     return report;
   }
-  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 destDir = path10.join(paths.memoriesDir, "shared", source.name);
+  await mkdir5(destDir, { recursive: true });
+  const cacheDir = path10.join(paths.haiveDir, ".cache", "cross-repo", source.name);
+  await mkdir5(cacheDir, { recursive: true });
   const importMap = await loadImportMap(cacheDir);
   const mapDirty = false;
   let dirty = mapDirty;
@@ -1837,7 +1868,7 @@ async function pullFromSource(paths, source, projectRoot) {
 
 `;
     const existingLocalPath = importMap[sourceId];
-    if (existingLocalPath && existsSync7(existingLocalPath)) {
+    if (existingLocalPath && existsSync8(existingLocalPath)) {
       const existingFiles = await loadMemoriesFromDir(destDir);
       const existingEntry = existingFiles.find(({ filePath }) => filePath === existingLocalPath);
       const sourceBodyStripped = memory.body.trim();
@@ -1848,7 +1879,7 @@ async function pullFromSource(paths, source, projectRoot) {
       }
       const updatedBody = importedBodyPrefix + memory.body;
       if (existingEntry) {
-        await writeFile4(
+        await writeFile5(
           existingLocalPath,
           serializeMemory({ frontmatter: existingEntry.memory.frontmatter, body: updatedBody }),
           "utf8"
@@ -1872,8 +1903,8 @@ async function pullFromSource(paths, source, projectRoot) {
         topic: fm.topic ? `${source.name}:${fm.topic}` : void 0
       });
       const body = importedBodyPrefix + memory.body;
-      const destPath = path9.join(destDir, `${newFm.id}.md`);
-      await writeFile4(destPath, serializeMemory({ frontmatter: newFm, body }), "utf8");
+      const destPath = path10.join(destDir, `${newFm.id}.md`);
+      await writeFile5(destPath, serializeMemory({ frontmatter: newFm, body }), "utf8");
       importMap[sourceId] = destPath;
       dirty = true;
       report.imported.push(sourceId);
@@ -1883,9 +1914,9 @@ async function pullFromSource(paths, source, projectRoot) {
   return report;
 }
 async function cloneOrFetchGitSource(source, paths, report) {
-  const cacheDir = path9.join(paths.haiveDir, ".cache", "cross-repo", source.name);
-  await mkdir4(cacheDir, { recursive: true });
-  if (existsSync7(path9.join(cacheDir, ".git"))) {
+  const cacheDir = path10.join(paths.haiveDir, ".cache", "cross-repo", source.name);
+  await mkdir5(cacheDir, { recursive: true });
+  if (existsSync8(path10.join(cacheDir, ".git"))) {
     const result = spawnSync2("git", ["fetch", "--depth=1", "origin"], {
       cwd: cacheDir,
       encoding: "utf8"
@@ -1910,9 +1941,9 @@ async function cloneOrFetchGitSource(source, paths, report) {
 }
 
 // src/dep-tracker.ts
-import { existsSync as existsSync8 } from "fs";
-import { readFile as readFile8, writeFile as writeFile5, 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";
 function parsePackageJson(content) {
   try {
     const pkg = JSON.parse(content);
@@ -1984,7 +2015,7 @@ var KNOWN_MANIFESTS = [
   { name: "pom.xml", parser: parsePomXml }
 ];
 function getParser(file) {
-  const base = path10.basename(file);
+  const base = path11.basename(file);
   return KNOWN_MANIFESTS.find((m) => m.name === base)?.parser ?? null;
 }
 function extractMajor(version) {
@@ -2002,32 +2033,32 @@ function isMajorBump(from, to) {
 }
 function resolveManifestFiles(projectRoot, configuredFiles) {
   if (configuredFiles !== void 0) {
-    return configuredFiles.map((f) => path10.resolve(projectRoot, f)).filter(existsSync8);
+    return configuredFiles.map((f) => path11.resolve(projectRoot, f)).filter(existsSync9);
   }
-  return KNOWN_MANIFESTS.map(({ name }) => path10.join(projectRoot, name)).filter(existsSync8);
+  return KNOWN_MANIFESTS.map(({ name }) => path11.join(projectRoot, name)).filter(existsSync9);
 }
 async function trackDependencies(projectRoot, haiveDir, manifestFiles) {
-  const contractsDir = path10.join(haiveDir, "contracts");
-  await mkdir5(contractsDir, { recursive: true });
+  const contractsDir = path11.join(haiveDir, "contracts");
+  await mkdir6(contractsDir, { recursive: true });
   const results = [];
   for (const manifestPath of manifestFiles) {
     const parser = getParser(manifestPath);
     if (!parser) continue;
-    const content = await readFile8(manifestPath, "utf8");
+    const content = await readFile9(manifestPath, "utf8");
     const currentDeps = parser(content);
-    const lockName = `deps-${path10.basename(manifestPath)}.lock`;
-    const lockPath = path10.join(contractsDir, lockName);
-    if (!existsSync8(lockPath)) {
+    const lockName = `deps-${path11.basename(manifestPath)}.lock`;
+    const lockPath = path11.join(contractsDir, lockName);
+    if (!existsSync9(lockPath)) {
       const snapshot2 = {
-        file: path10.relative(projectRoot, manifestPath),
-        format: path10.basename(manifestPath),
+        file: path11.relative(projectRoot, manifestPath),
+        format: path11.basename(manifestPath),
         captured_at: (/* @__PURE__ */ new Date()).toISOString(),
         deps: currentDeps
       };
-      await writeFile5(lockPath, JSON.stringify(snapshot2, null, 2) + "\n", "utf8");
+      await writeFile6(lockPath, JSON.stringify(snapshot2, null, 2) + "\n", "utf8");
       continue;
     }
-    const snapshot = JSON.parse(await readFile8(lockPath, "utf8"));
+    const snapshot = JSON.parse(await readFile9(lockPath, "utf8"));
     const changes = [];
     for (const [name, currentVer] of Object.entries(currentDeps)) {
       const prevVer = snapshot.deps[name];
@@ -2041,22 +2072,22 @@ async function trackDependencies(projectRoot, haiveDir, manifestFiles) {
       }
     }
     if (changes.length > 0) {
-      results.push({ file: path10.relative(projectRoot, manifestPath), changes });
+      results.push({ file: path11.relative(projectRoot, manifestPath), changes });
       const updated = {
         ...snapshot,
         captured_at: (/* @__PURE__ */ new Date()).toISOString(),
         deps: currentDeps
       };
-      await writeFile5(lockPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
+      await writeFile6(lockPath, JSON.stringify(updated, null, 2) + "\n", "utf8");
     }
   }
   return results;
 }
 
 // src/contract-watcher.ts
-import { existsSync as existsSync9 } from "fs";
-import { readFile as readFile9, writeFile as writeFile6, mkdir as mkdir6 } from "fs/promises";
-import path11 from "path";
+import { existsSync as existsSync10 } from "fs";
+import { readFile as readFile10, writeFile as writeFile7, mkdir as mkdir7 } from "fs/promises";
+import path12 from "path";
 import crypto from "crypto";
 function sha256(content) {
   return crypto.createHash("sha256").update(content).digest("hex");
@@ -2259,14 +2290,14 @@ function diffSnapshots(before, after) {
   return changes;
 }
 function contractLockPath(haiveDir, name) {
-  return path11.join(haiveDir, "contracts", `${name}.lock`);
+  return path12.join(haiveDir, "contracts", `${name}.lock`);
 }
 async function snapshotContract(projectRoot, haiveDir, contract) {
-  const filePath = path11.resolve(projectRoot, contract.path);
-  if (!existsSync9(filePath)) {
+  const filePath = path12.resolve(projectRoot, contract.path);
+  if (!existsSync10(filePath)) {
     throw new Error(`Contract file not found: ${filePath}`);
   }
-  const content = await readFile9(filePath, "utf8");
+  const content = await readFile10(filePath, "utf8");
   const parsed = parseByFormat(content, contract.format, filePath);
   const snapshot = {
     name: contract.name,
@@ -2276,23 +2307,23 @@ async function snapshotContract(projectRoot, haiveDir, contract) {
     hash: sha256(content),
     ...parsed
   };
-  const contractsDir = path11.join(haiveDir, "contracts");
-  await mkdir6(contractsDir, { recursive: true });
-  await writeFile6(contractLockPath(haiveDir, contract.name), JSON.stringify(snapshot, null, 2) + "\n", "utf8");
+  const contractsDir = path12.join(haiveDir, "contracts");
+  await mkdir7(contractsDir, { recursive: true });
+  await writeFile7(contractLockPath(haiveDir, contract.name), JSON.stringify(snapshot, null, 2) + "\n", "utf8");
   return snapshot;
 }
 async function diffContract(projectRoot, haiveDir, contract) {
-  const filePath = path11.resolve(projectRoot, contract.path);
-  if (!existsSync9(filePath)) {
+  const filePath = path12.resolve(projectRoot, contract.path);
+  if (!existsSync10(filePath)) {
     return { contract: contract.name, file: contract.path, changes: [], unchanged: true };
   }
   const lockPath = contractLockPath(haiveDir, contract.name);
-  if (!existsSync9(lockPath)) {
+  if (!existsSync10(lockPath)) {
     await snapshotContract(projectRoot, haiveDir, contract);
     return { contract: contract.name, file: contract.path, changes: [], unchanged: true };
   }
-  const content = await readFile9(filePath, "utf8");
-  const beforeSnapshot = JSON.parse(await readFile9(lockPath, "utf8"));
+  const content = await readFile10(filePath, "utf8");
+  const beforeSnapshot = JSON.parse(await readFile10(lockPath, "utf8"));
   const afterParsed = parseByFormat(content, contract.format, filePath);
   const afterSnapshot = {
     ...beforeSnapshot,
@@ -2302,7 +2333,7 @@ async function diffContract(projectRoot, haiveDir, contract) {
   };
   const changes = diffSnapshots(beforeSnapshot, afterSnapshot);
   if (changes.length > 0) {
-    await writeFile6(lockPath, JSON.stringify(afterSnapshot, null, 2) + "\n", "utf8");
+    await writeFile7(lockPath, JSON.stringify(afterSnapshot, null, 2) + "\n", "utf8");
   }
   return {
     contract: contract.name,
@@ -2320,27 +2351,27 @@ async function watchContracts(projectRoot, haiveDir, contractFiles) {
 }
 
 // src/usage-log.ts
-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";
+import { appendFile as appendFile2, mkdir as mkdir8, readFile as readFile11, stat as stat2 } from "fs/promises";
+import { existsSync as existsSync11 } from "fs";
+import path13 from "path";
 var USAGE_LOG_FILE = "tool-usage.jsonl";
 var USAGE_LOG_DIR = ".usage";
 function usageLogPath(paths) {
-  return path12.join(paths.haiveDir, USAGE_LOG_DIR, USAGE_LOG_FILE);
+  return path13.join(paths.haiveDir, USAGE_LOG_DIR, USAGE_LOG_FILE);
 }
 async function appendUsageEvent(paths, event) {
   try {
     const file = usageLogPath(paths);
-    const dir = path12.dirname(file);
-    if (!existsSync10(dir)) await mkdir7(dir, { recursive: true });
+    const dir = path13.dirname(file);
+    if (!existsSync11(dir)) await mkdir8(dir, { recursive: true });
     await appendFile2(file, JSON.stringify(event) + "\n", "utf8");
   } catch {
   }
 }
 async function readUsageEvents(paths) {
   const file = usageLogPath(paths);
-  if (!existsSync10(file)) return [];
-  const raw = await readFile10(file, "utf8");
+  if (!existsSync11(file)) return [];
+  const raw = await readFile11(file, "utf8");
   const out = [];
   for (const line of raw.split("\n")) {
     if (!line) continue;
@@ -2389,9 +2420,9 @@ function parseSince(input) {
 }
 async function usageLogSize(paths) {
   const file = usageLogPath(paths);
-  if (!existsSync10(file)) return { exists: false, size_bytes: 0, lines: 0 };
+  if (!existsSync11(file)) return { exists: false, size_bytes: 0, lines: 0 };
   const st = await stat2(file);
-  const raw = await readFile10(file, "utf8");
+  const raw = await readFile11(file, "utf8");
   return { exists: true, size_bytes: st.size, lines: raw.split("\n").filter((l) => l).length };
 }
 
@@ -2461,21 +2492,21 @@ function extractActionsBriefBody(markdown, maxChars = MAX_DEFAULT_CHARS) {
 }
 
 // src/resolve-project.ts
-import { existsSync as existsSync11 } from "fs";
-import path13 from "path";
+import { existsSync as existsSync12 } from "fs";
+import path14 from "path";
 var ROOT_MARKERS2 = [".ai", ".git", "package.json"];
 function markersAtRoot(root) {
   const found = [];
   for (const m of ROOT_MARKERS2) {
-    if (existsSync11(path13.join(root, m))) found.push(m);
+    if (existsSync12(path14.join(root, m))) found.push(m);
   }
   return found;
 }
 function resolveProjectInfo(opts = {}) {
   const env = opts.env ?? process.env;
-  const cwd = path13.resolve(opts.cwd ?? process.cwd());
+  const cwd = path14.resolve(opts.cwd ?? process.cwd());
   const raw = env.HAIVE_PROJECT_ROOT;
-  const explicit = raw !== void 0 && raw !== "" ? path13.resolve(raw) : null;
+  const explicit = raw !== void 0 && raw !== "" ? path14.resolve(raw) : null;
   const resolvedRoot = explicit ?? findProjectRoot(cwd);
   const paths = resolveHaivePaths(resolvedRoot);
   return {
@@ -2483,8 +2514,8 @@ function resolveProjectInfo(opts = {}) {
     resolved_root: resolvedRoot,
     haive_project_root_env: explicit,
     explicit_root: explicit != null,
-    haive_dir_exists: existsSync11(paths.haiveDir),
-    memories_dir_exists: existsSync11(paths.memoriesDir),
+    haive_dir_exists: existsSync12(paths.haiveDir),
+    memories_dir_exists: existsSync12(paths.memoriesDir),
     runtime_dir: paths.runtimeDir,
     markers_found: markersAtRoot(resolvedRoot)
   };
@@ -2739,16 +2770,16 @@ function findLexicalConflictPairs(memories, opts) {
 }
 
 // src/runtime-journal.ts
-import { mkdir as mkdir8, readFile as readFile11, appendFile as appendFile3 } from "fs/promises";
-import { existsSync as existsSync12 } from "fs";
-import path14 from "path";
+import { mkdir as mkdir9, readFile as readFile12, appendFile as appendFile3 } from "fs/promises";
+import { existsSync as existsSync13 } from "fs";
+import path15 from "path";
 var RUNTIME_JOURNAL_FILENAME = "session-journal.ndjson";
 function runtimeJournalPath(paths) {
-  return path14.join(paths.runtimeDir, RUNTIME_JOURNAL_FILENAME);
+  return path15.join(paths.runtimeDir, RUNTIME_JOURNAL_FILENAME);
 }
 async function appendRuntimeJournalEntry(paths, entry) {
   try {
-    await mkdir8(paths.runtimeDir, { recursive: true });
+    await mkdir9(paths.runtimeDir, { recursive: true });
     const line = {
       ts: entry.ts ?? (/* @__PURE__ */ new Date()).toISOString(),
       kind: entry.kind,
@@ -2766,9 +2797,9 @@ async function appendRuntimeJournalEntry(paths, entry) {
 }
 async function readRuntimeJournalTail(paths, limit) {
   const file = runtimeJournalPath(paths);
-  if (!existsSync12(file) || limit <= 0) return [];
+  if (!existsSync13(file) || limit <= 0) return [];
   try {
-    const raw = await readFile11(file, "utf8");
+    const raw = await readFile12(file, "utf8");
     const lines = raw.trim().split("\n").filter(Boolean);
     const parsed = [];
     for (const line of lines.slice(-limit)) {
@@ -2784,22 +2815,22 @@ async function readRuntimeJournalTail(paths, limit) {
 }
 
 // src/enforcement.ts
-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";
+import { mkdir as mkdir10, readdir as readdir4, readFile as readFile13, writeFile as writeFile8 } from "fs/promises";
+import { existsSync as existsSync14 } from "fs";
+import path16 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 path15.join(paths.runtimeDir, "enforcement");
+  return path16.join(paths.runtimeDir, "enforcement");
 }
 function briefingMarkersDir(paths) {
-  return path15.join(enforcementDir(paths), "briefings");
+  return path16.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 path15.join(briefingMarkersDir(paths), `${normalizeSessionId(sessionId)}.json`);
+  return path16.join(briefingMarkersDir(paths), `${normalizeSessionId(sessionId)}.json`);
 }
 async function writeBriefingMarker(paths, input) {
   const marker = {
@@ -2811,8 +2842,8 @@ async function writeBriefingMarker(paths, input) {
     created_at: (/* @__PURE__ */ new Date()).toISOString(),
     root: paths.root
   };
-  await mkdir9(briefingMarkersDir(paths), { recursive: true });
-  await writeFile7(
+  await mkdir10(briefingMarkersDir(paths), { recursive: true });
+  await writeFile8(
     briefingMarkerPath(paths, marker.session_id),
     JSON.stringify(marker, null, 2) + "\n",
     "utf8"
@@ -2823,18 +2854,18 @@ async function hasRecentBriefingMarker(paths, sessionId, ttlMs = BRIEFING_MARKER
   const now = Date.now();
   const candidates = [];
   const exact = briefingMarkerPath(paths, sessionId);
-  if (existsSync13(exact)) candidates.push(exact);
+  if (existsSync14(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(path15.join(dir, file));
+      if (file.endsWith(".json")) candidates.push(path16.join(dir, file));
     }
   } catch {
   }
   for (const file of new Set(candidates)) {
     try {
-      const marker = JSON.parse(await readFile12(file, "utf8"));
+      const marker = JSON.parse(await readFile13(file, "utf8"));
       const created = Date.parse(marker.created_at);
       if (Number.isFinite(created) && now - created <= ttlMs) return true;
     } catch {
@@ -2846,12 +2877,12 @@ async function readRecentBriefingMarker(paths, sessionId, ttlMs = BRIEFING_MARKE
   const now = Date.now();
   const candidates = [];
   const exact = briefingMarkerPath(paths, sessionId);
-  if (existsSync13(exact)) candidates.push(exact);
+  if (existsSync14(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(path15.join(dir, file));
+      if (file.endsWith(".json")) candidates.push(path16.join(dir, file));
     }
   } catch {
   }
@@ -2859,7 +2890,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 readFile12(file, "utf8"));
+      const marker = JSON.parse(await readFile13(file, "utf8"));
       const created = Date.parse(marker.created_at);
       if (!Number.isFinite(created) || now - created > ttlMs) continue;
       if (created > freshestTs) {
@@ -2912,10 +2943,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, path16) {
+function sensorAppliesToPath(sensor, anchorPaths, path18) {
   const scopes = sensor.paths.length > 0 ? sensor.paths : anchorPaths;
   if (scopes.length === 0) return true;
-  const target = normalizeProjectPath(path16);
+  const target = normalizeProjectPath(path18);
   return scopes.some((rawScope) => {
     const scope = normalizeProjectPath(rawScope);
     if (!scope) return false;
@@ -2963,6 +2994,28 @@ function runSensors(memories, targets) {
   }
   return hits;
 }
+function selectCommandSensors(memories, changedPaths) {
+  const specs = [];
+  for (const memory of memories) {
+    const sensor = memory.frontmatter.sensor;
+    if (!sensor) continue;
+    if (sensor.kind !== "shell" && sensor.kind !== "test") continue;
+    const command = sensor.command?.trim();
+    if (!command) continue;
+    const anchorPaths = memory.frontmatter.anchor.paths;
+    const applies = changedPaths.length === 0 ? true : changedPaths.some((p) => sensorAppliesToPath(sensor, anchorPaths, p));
+    if (!applies) continue;
+    specs.push({
+      memory_id: memory.frontmatter.id,
+      command,
+      kind: sensor.kind,
+      severity: sensor.severity,
+      message: sensor.message,
+      paths: sensor.paths.length > 0 ? sensor.paths : anchorPaths
+    });
+  }
+  return specs;
+}
 function sensorTargetsFromDiff(diff) {
   const targets = [];
   let currentPath = null;
@@ -3189,8 +3242,8 @@ function normalizeFindingSeverity(raw) {
       return "info";
   }
 }
-function findingKey(tool, ruleId, path16) {
-  return `${tool}:${ruleId}:${path16}`;
+function findingKey(tool, ruleId, path18) {
+  return `${tool}:${ruleId}:${path18}`;
 }
 function coerceJson(input) {
   if (typeof input === "string") {
@@ -3224,8 +3277,8 @@ function parseSarif(input) {
       const physical = asRecord(location.physicalLocation);
       const artifact = asRecord(physical.artifactLocation);
       const region = asRecord(physical.region);
-      const path16 = typeof artifact.uri === "string" ? normalizeUri(artifact.uri) : "";
-      if (!path16) continue;
+      const path18 = typeof artifact.uri === "string" ? normalizeUri(artifact.uri) : "";
+      if (!path18) 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({
@@ -3233,10 +3286,10 @@ function parseSarif(input) {
         ruleId,
         message: message.trim(),
         severity,
-        path: path16,
+        path: path18,
         ...line !== void 0 ? { line } : {},
         ...snippet ? { snippet } : {},
-        key: findingKey(tool, ruleId, path16)
+        key: findingKey(tool, ruleId, path18)
       });
     }
   }
@@ -3255,17 +3308,17 @@ function parseSonar(input) {
       (typeof issue.severity === "string" ? issue.severity : void 0) ?? impactSeverity
     );
     const component = typeof issue.component === "string" ? issue.component : "";
-    const path16 = componentToPath(component);
-    if (!path16) continue;
+    const path18 = componentToPath(component);
+    if (!path18) continue;
     const line = typeof issue.line === "number" ? issue.line : void 0;
     findings.push({
       tool: "sonar",
       ruleId,
       message,
       severity,
-      path: path16,
+      path: path18,
       ...line !== void 0 ? { line } : {},
-      key: findingKey("sonar", ruleId, path16)
+      key: findingKey("sonar", ruleId, path18)
     });
   }
   return findings;
@@ -3342,6 +3395,52 @@ function filterNewDrafts(drafts, existingTopics) {
   return drafts.filter((d) => !existing.has(d.topic));
 }
 
+// src/gate-precision.ts
+function round33(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+function computeGatePrecision(events, usage, currentGate = "anchored") {
+  let sensorCatches = 0;
+  let antiPatternCatches = 0;
+  for (const e of events) {
+    if (e.source === "sensor") sensorCatches += 1;
+    else if (e.source === "anti-pattern") antiPatternCatches += 1;
+  }
+  let applied = 0;
+  let rejections = 0;
+  for (const mem of Object.values(usage.by_id ?? {})) {
+    applied += mem.applied_count ?? 0;
+    rejections += mem.rejected_count ?? 0;
+  }
+  const useful = sensorCatches + antiPatternCatches + applied;
+  const denom = useful + rejections;
+  const precision = denom === 0 ? null : round33(useful / denom);
+  return {
+    sensor_catches: sensorCatches,
+    anti_pattern_catches: antiPatternCatches,
+    useful,
+    rejections,
+    precision,
+    suggestion: suggestGate(precision, rejections, currentGate)
+  };
+}
+function suggestGate(precision, rejections, currentGate) {
+  if (precision === null || rejections < 3) return null;
+  if (precision < 0.5 && (currentGate === "anchored" || currentGate === "strict")) {
+    return {
+      recommended: "review",
+      reason: `Gate precision ${precision} with ${rejections} rejection(s) \u2014 the gate is crying wolf. Loosen to "review" (surface, don't hard-block) until the corpus is cleaner.`
+    };
+  }
+  if (precision >= 0.85 && currentGate === "review") {
+    return {
+      recommended: "anchored",
+      reason: `Gate precision ${precision} \u2014 catches are reliably real. Tighten to "anchored" so corroborated anti-patterns hard-block.`
+    };
+  }
+  return null;
+}
+
 // src/dashboard.ts
 var MS_PER_DAY4 = 24 * 60 * 60 * 1e3;
 function isAnchorless(fm) {
@@ -3483,6 +3582,11 @@ function buildDashboard(memories, usage, options = {}) {
         top: computeRecurrence(options.preventionEvents ?? []).top.slice(0, top)
       }
     },
+    gate_precision: computeGatePrecision(
+      options.preventionEvents ?? [],
+      usage,
+      options.antiPatternGate ?? "anchored"
+    ),
     corpus: {
       memory_files: inventory.total,
       body_chars: bodyChars,
@@ -3490,6 +3594,235 @@ function buildDashboard(memories, usage, options = {}) {
     }
   };
 }
+
+// src/failure-coverage.ts
+var MS_PER_HOUR = 36e5;
+function normalizeSummary(summary) {
+  return summary.toLowerCase().replace(/\s+/g, " ").trim().slice(0, 160);
+}
+function findUncapturedFailures(failures, captureTimes, options = {}) {
+  const now = (options.now ?? /* @__PURE__ */ new Date()).getTime();
+  const windowMs = (options.windowHours ?? 24) * MS_PER_HOUR;
+  const dedupe = options.dedupe ?? true;
+  let latestCapture = 0;
+  for (const iso of captureTimes) {
+    const t = Date.parse(iso);
+    if (Number.isFinite(t) && now - t <= windowMs && t > latestCapture) latestCapture = t;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const f of failures) {
+    const t = Date.parse(f.ts);
+    if (!Number.isFinite(t)) continue;
+    if (now - t > windowMs) continue;
+    if (t <= latestCapture) continue;
+    if (dedupe) {
+      const key = normalizeSummary(f.summary);
+      if (seen.has(key)) continue;
+      seen.add(key);
+    }
+    out.push({ ts: f.ts, tool: f.tool, summary: f.summary });
+  }
+  out.sort((a, b) => a.ts.localeCompare(b.ts));
+  return out;
+}
+
+// src/coverage.ts
+var DEFAULT_COVERING_TYPES = ["decision", "convention", "gotcha", "architecture"];
+function normalizePath(value) {
+  return value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/g, "");
+}
+function buildCoverageIndex(memories, coveringTypes = DEFAULT_COVERING_TYPES) {
+  const types = new Set(coveringTypes);
+  const covered = /* @__PURE__ */ new Set();
+  for (const { memory } of memories) {
+    const fm = memory.frontmatter;
+    if (!types.has(fm.type)) continue;
+    if (fm.status === "stale" || fm.status === "deprecated" || fm.status === "rejected") continue;
+    for (const p of fm.anchor.paths) {
+      const norm = normalizePath(p);
+      if (norm) covered.add(norm);
+    }
+  }
+  return covered;
+}
+function isCovered(file, coverage) {
+  const target = normalizePath(file);
+  if (coverage.has(target)) return true;
+  for (const scope of coverage) {
+    if (target === scope || target.startsWith(`${scope}/`)) return true;
+  }
+  return false;
+}
+function findCoverageGaps(hotFiles, memories, options = {}) {
+  const minChanges = options.minChanges ?? 3;
+  const limit = options.limit ?? 20;
+  const coverage = buildCoverageIndex(memories, options.coveringTypes);
+  const gaps = [];
+  for (const hot of hotFiles) {
+    if (hot.changes < minChanges) continue;
+    if (isCovered(hot.path, coverage)) continue;
+    gaps.push({ path: normalizePath(hot.path), changes: hot.changes });
+  }
+  gaps.sort((a, b) => b.changes - a.changes);
+  return gaps.slice(0, limit);
+}
+
+// src/eval-history.ts
+import { appendFile as appendFile4, mkdir as mkdir11, readFile as readFile14 } from "fs/promises";
+import { existsSync as existsSync15 } from "fs";
+import path17 from "path";
+function evalHistoryPath(paths) {
+  return path17.join(paths.haiveDir, ".cache", "eval-history.jsonl");
+}
+async function appendEvalHistory(paths, entry) {
+  const file = evalHistoryPath(paths);
+  await mkdir11(path17.dirname(file), { recursive: true });
+  await appendFile4(file, JSON.stringify(entry) + "\n", "utf8");
+}
+async function loadEvalHistory(paths) {
+  const file = evalHistoryPath(paths);
+  if (!existsSync15(file)) return [];
+  const raw = await readFile14(file, "utf8").catch(() => "");
+  const out = [];
+  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.score === "number") out.push(e);
+    } catch {
+    }
+  }
+  return out;
+}
+function computeEvalTrend(entries, recentN = 10) {
+  const sorted = [...entries].sort((a, b) => a.at.localeCompare(b.at));
+  const scores = sorted.map((e) => e.score);
+  const latest = scores.length > 0 ? scores[scores.length - 1] : null;
+  const previous = scores.length > 1 ? scores[scores.length - 2] : null;
+  const delta = latest !== null && previous !== null ? Math.round((latest - previous) * 1e3) / 1e3 : null;
+  const best = scores.length > 0 ? Math.max(...scores) : null;
+  return {
+    latest,
+    previous,
+    delta,
+    best,
+    runs: scores.length,
+    recent: scores.slice(-recentN),
+    regressed: delta !== null && delta < 0
+  };
+}
+
+// src/conflict-resolve.ts
+var STATUS_RANK = {
+  validated: 4,
+  proposed: 3,
+  draft: 2,
+  stale: 1,
+  deprecated: 0,
+  rejected: 0
+};
+function statusRank(fm) {
+  return STATUS_RANK[fm.status] ?? 2;
+}
+function planConflictResolution(a, b) {
+  const fa = a.memory.frontmatter;
+  const fb = b.memory.frontmatter;
+  const ra = statusRank(fa);
+  const rb = statusRank(fb);
+  let winner;
+  let loser;
+  let reason;
+  if (ra !== rb) {
+    [winner, loser] = ra > rb ? [a, b] : [b, a];
+    reason = `status (${winner.memory.frontmatter.status} beats ${loser.memory.frontmatter.status})`;
+  } else if (fa.revision_count !== fb.revision_count) {
+    [winner, loser] = fa.revision_count > fb.revision_count ? [a, b] : [b, a];
+    reason = `revision_count (${winner.memory.frontmatter.revision_count} > ${loser.memory.frontmatter.revision_count})`;
+  } else {
+    const cmp = fa.created_at.localeCompare(fb.created_at);
+    [winner, loser] = cmp >= 0 ? [a, b] : [b, a];
+    reason = `recency (${winner.memory.frontmatter.created_at} is newer)`;
+  }
+  const keepId = winner.memory.frontmatter.id;
+  const supersedeId = loser.memory.frontmatter.id;
+  return {
+    keep_id: keepId,
+    supersede_id: supersedeId,
+    reason,
+    stale_reason: `Superseded by ${keepId} (conflict resolved on ${reason}).`
+  };
+}
+
+// src/seed-git.ts
+var REVERT_RE = /^Revert\s+"(.+)"\s*$/i;
+var FIXUP_RE = /^(?:fixup!|hotfix[:!]|fix[:!]\s*revert|revert\s+revert)/i;
+var URGENT_FIX_RE = /\b(hotfix|urgent fix|emergency fix|critical fix|broke production|broken build)\b/i;
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "reverted-change";
+}
+function proposeSeedsFromCommits(commits, limit = 20) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const commit of commits) {
+    const subject = commit.subject.trim();
+    let what = null;
+    let kind = null;
+    const revert = subject.match(REVERT_RE);
+    if (revert) {
+      what = revert[1].trim();
+      kind = "revert";
+    } else if (FIXUP_RE.test(subject) || URGENT_FIX_RE.test(subject)) {
+      what = subject.replace(FIXUP_RE, "").trim() || subject;
+      kind = "fixup";
+    }
+    if (!what || !kind) continue;
+    const slug = slugify(what);
+    if (seen.has(slug)) continue;
+    seen.add(slug);
+    out.push({
+      slug,
+      what,
+      why_failed: kind === "revert" ? `This change was reverted in commit ${commit.sha} \u2014 it caused a regression and was backed out. Verify the root cause before re-attempting.` : `This area required an urgent fix (commit ${commit.sha}: "${subject}") \u2014 it shipped broken once. Treat changes here with extra care.`,
+      paths: (commit.files ?? []).slice(0, 8),
+      source_sha: commit.sha,
+      kind
+    });
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+
+// src/merge-memory.ts
+function safeParse(raw) {
+  try {
+    return parseMemory(raw);
+  } catch {
+    return null;
+  }
+}
+function mergeMemoryVersions(ours, theirs) {
+  if (ours === theirs) {
+    return { content: ours, winner: "ours", reason: "identical" };
+  }
+  const a = safeParse(ours);
+  const b = safeParse(theirs);
+  if (!a || !b) {
+    return { content: ours, winner: "ours", reason: "unparseable side \u2014 kept ours" };
+  }
+  const ra = a.frontmatter.revision_count ?? 0;
+  const rb = b.frontmatter.revision_count ?? 0;
+  if (ra !== rb) {
+    return rb > ra ? { content: theirs, winner: "theirs", reason: `higher revision_count (${rb} > ${ra})` } : { content: ours, winner: "ours", reason: `higher revision_count (${ra} > ${rb})` };
+  }
+  const ca = a.frontmatter.created_at ?? "";
+  const cb = b.frontmatter.created_at ?? "";
+  const cmp = cb.localeCompare(ca);
+  if (cmp > 0) return { content: theirs, winner: "theirs", reason: `newer created_at (${cb})` };
+  if (cmp < 0) return { content: ours, winner: "ours", reason: `newer created_at (${ca})` };
+  return { content: ours, winner: "ours", reason: "tie \u2014 kept ours" };
+}
 export {
   AUTOPILOT_DEFAULTS,
   ActivationSchema,
@@ -3516,6 +3849,7 @@ export {
   MemoryTypeSchema,
   PREVENTION_DEBOUNCE_MS,
   PROJECT_CONTEXT_FILE,
+  PROJECT_CONTEXT_THROTTLE_MS,
   RUNTIME_JOURNAL_FILENAME,
   SESSION_RECAP_TTL_MS,
   STACK_PACK_TAG,
@@ -3529,12 +3863,14 @@ export {
   aggregateUsage,
   allocateBudget,
   antiPatternGateParams,
+  appendEvalHistory,
   appendPreventionEvent,
   appendRuntimeJournalEntry,
   appendUsageEvent,
   briefingMarkerPath,
   briefingMarkersDir,
   buildCodeMap,
+  buildCoverageIndex,
   buildDashboard,
   buildDocFrequency,
   buildFrontmatter,
@@ -3545,6 +3881,8 @@ export {
   compareEvalReports,
   compareImpact,
   compileRegexSensor,
+  computeEvalTrend,
+  computeGatePrecision,
   computeImpact,
   computePreventionTrend,
   computeRecurrence,
@@ -3559,21 +3897,26 @@ export {
   emptyUsageIndex,
   enforcementDir,
   estimateTokens,
+  evalHistoryPath,
   evaluateSkillActivation,
   extractActionsBriefBody,
   extractSnippet,
   filterNewDrafts,
+  findCoverageGaps,
   findLexicalConflictPairs,
   findProjectRoot,
   findTopicStatusConflictPairs,
+  findUncapturedFailures,
   findingBody,
   findingToDraft,
   firstMemoryOneLine,
   getUsage,
   globToRegExp,
   hasRecentBriefingMarker,
+  hashProjectContext,
   inferModulesFromPaths,
   isAutoPromoteEligible,
+  isCovered,
   isDecaying,
   isDistinctiveToken,
   isFreshIsoDate,
@@ -3589,12 +3932,14 @@ export {
   loadCodeMap,
   loadConfig,
   loadConfigSync,
+  loadEvalHistory,
   loadMemoriesFromDir,
   loadMemory,
   loadPreventionEvents,
   loadUsageIndex,
   memoryFilePath,
   memoryMatchesAnchorPaths,
+  mergeMemoryVersions,
   newMemoryId,
   normalizeFindingSeverity,
   normalizeSessionId,
@@ -3606,7 +3951,10 @@ export {
   parseSonar,
   pathsOverlap,
   pickSnippetNeedle,
+  planConflictResolution,
   preventionLogPath,
+  projectContextRecentlyEmitted,
+  proposeSeedsFromCommits,
   pullCrossRepoSources,
   queryCodeMap,
   rankMemoriesLexical,
@@ -3615,6 +3963,7 @@ export {
   readUsageEvents,
   recordApplied,
   recordPrevention,
+  recordProjectContextEmission,
   recordRejection,
   relPathFrom,
   resolveBriefingBudget,
@@ -3630,12 +3979,14 @@ export {
   saveUsageIndex,
   scoreRetrievalCase,
   scoreSensorCase,
+  selectCommandSensors,
   sensorAppliesToPath,
   sensorTargetsFromDiff,
   serializeMemory,
   snapshotContract,
   specificityScore,
   stripPrivate,
+  suggestGate,
   suggestSensorFromMemory,
   suggestTopicKey,
   summarizeImpact,