@hiveai/core 0.13.9 → 0.14.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, path17) {
   const scopes = sensor.paths.length > 0 ? sensor.paths : anchorPaths;
   if (scopes.length === 0) return true;
-  const target = normalizeProjectPath(path16);
+  const target = normalizeProjectPath(path17);
   return scopes.some((rawScope) => {
     const scope = normalizeProjectPath(rawScope);
     if (!scope) return false;
@@ -3189,8 +3220,8 @@ function normalizeFindingSeverity(raw) {
       return "info";
   }
 }
-function findingKey(tool, ruleId, path16) {
-  return `${tool}:${ruleId}:${path16}`;
+function findingKey(tool, ruleId, path17) {
+  return `${tool}:${ruleId}:${path17}`;
 }
 function coerceJson(input) {
   if (typeof input === "string") {
@@ -3224,8 +3255,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 path17 = typeof artifact.uri === "string" ? normalizeUri(artifact.uri) : "";
+      if (!path17) 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 +3264,10 @@ function parseSarif(input) {
         ruleId,
         message: message.trim(),
         severity,
-        path: path16,
+        path: path17,
         ...line !== void 0 ? { line } : {},
         ...snippet ? { snippet } : {},
-        key: findingKey(tool, ruleId, path16)
+        key: findingKey(tool, ruleId, path17)
       });
     }
   }
@@ -3255,17 +3286,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 path17 = componentToPath(component);
+    if (!path17) continue;
     const line = typeof issue.line === "number" ? issue.line : void 0;
     findings.push({
       tool: "sonar",
       ruleId,
       message,
       severity,
-      path: path16,
+      path: path17,
       ...line !== void 0 ? { line } : {},
-      key: findingKey("sonar", ruleId, path16)
+      key: findingKey("sonar", ruleId, path17)
     });
   }
   return findings;
@@ -3516,6 +3547,7 @@ export {
   MemoryTypeSchema,
   PREVENTION_DEBOUNCE_MS,
   PROJECT_CONTEXT_FILE,
+  PROJECT_CONTEXT_THROTTLE_MS,
   RUNTIME_JOURNAL_FILENAME,
   SESSION_RECAP_TTL_MS,
   STACK_PACK_TAG,
@@ -3572,6 +3604,7 @@ export {
   getUsage,
   globToRegExp,
   hasRecentBriefingMarker,
+  hashProjectContext,
   inferModulesFromPaths,
   isAutoPromoteEligible,
   isDecaying,
@@ -3607,6 +3640,7 @@ export {
   pathsOverlap,
   pickSnippetNeedle,
   preventionLogPath,
+  projectContextRecentlyEmitted,
   pullCrossRepoSources,
   queryCodeMap,
   rankMemoriesLexical,
@@ -3615,6 +3649,7 @@ export {
   readUsageEvents,
   recordApplied,
   recordPrevention,
+  recordProjectContextEmission,
   recordRejection,
   relPathFrom,
   resolveBriefingBudget,