@hivelore/core 0.34.1 → 0.35.1

package/dist/index.js

@@ -54,7 +54,14 @@ var SensorSchema = z.object({
   /** True when Hivelore generated this sensor automatically (vs. hand-authored). */
   autogen: z.boolean().default(false),
   /** ISO timestamp of the last time this sensor matched a diff. */
-  last_fired: z.string().nullable().default(null)
+  last_fired: z.string().nullable().default(null),
+  /**
+   * ISO timestamp of the last manual `sensors promote` back to block. Health assessment ignores
+   * ledger evaluations older than this — without it, a promoted sensor whose oracle was FIXED is
+   * re-quarantined on the next commit for up to 30 days (the stale flaps are still in the window),
+   * making the promotion promised by the quarantine note a no-op.
+   */
+  promoted_at: z.string().optional()
 });
 var ActivationSchema = z.object({
   /** Case-insensitive substrings matched against the task text. */
@@ -891,7 +898,7 @@ async function appendPreventionEvent(paths, event) {
   await mkdir2(path6.dirname(file), { recursive: true });
   await appendFile(file, JSON.stringify(event) + "\n", "utf8");
 }
-async function recordPreventionHits(paths, firedIds, source, now = /* @__PURE__ */ new Date()) {
+async function recordPreventionHits(paths, firedIds, source, now = /* @__PURE__ */ new Date(), details = {}) {
   const unique = [...new Set(firedIds)].filter(Boolean);
   if (unique.length === 0) return [];
   const usage = await loadUsageIndex(paths).catch(() => null);
@@ -905,11 +912,68 @@ async function recordPreventionHits(paths, firedIds, source, now = /* @__PURE__
   });
   const at = now.toISOString();
   for (const id of recordedIds) {
-    await appendPreventionEvent(paths, { at, id, source }).catch(() => {
+    await appendPreventionEvent(paths, { at, id, source, ...details[id] }).catch(() => {
     });
   }
   return recordedIds;
 }
+function buildPreventionReceipt(events, memories, usage, options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const sinceMs = options.since.getTime();
+  const nowMs = now.getTime();
+  const windowMs = Math.max(1, nowMs - sinceMs);
+  const previousSince = sinceMs - windowMs;
+  const byId = new Map(memories.map((m) => [m.memory.frontmatter.id, m]));
+  const current = events.filter((e) => {
+    const at = Date.parse(e.at);
+    return Number.isFinite(at) && at >= sinceMs && at <= nowMs;
+  });
+  const previousTotal = events.filter((e) => {
+    const at = Date.parse(e.at);
+    return Number.isFinite(at) && at >= previousSince && at < sinceMs;
+  }).length;
+  const rows = current.map((event) => {
+    const loaded = byId.get(event.id);
+    const sensor = loaded?.memory.frontmatter.sensor;
+    return {
+      at: event.at,
+      id: event.id,
+      title: titleFromMemory(loaded) || event.id,
+      source: event.source,
+      kind: event.kind ?? sensor?.kind ?? (event.source === "sensor" ? "regex" : null),
+      stage: event.stage ?? null,
+      exit_code: event.exit_code ?? null,
+      message: sensor?.message ?? null
+    };
+  }).sort((a, b) => b.at.localeCompare(a.at));
+  const preventedCountTotal = Object.values(usage.by_id).reduce((sum, item) => sum + item.prevented_count, 0);
+  return {
+    generated_at: now.toISOString(),
+    since: options.since.toISOString(),
+    window_days: Math.max(1, Math.round(windowMs / MS_PER_DAY2)),
+    total: rows.length,
+    previous_total: previousTotal,
+    prevented_count_total: preventedCountTotal,
+    trend: computePreventionTrend(events, now),
+    events: rows
+  };
+}
+function renderPreventionReceipt(receipt) {
+  const lines = [
+    `Hivelore prevention receipt \u2014 last ${receipt.window_days} days`,
+    `  ${receipt.total} repeat mistake${receipt.total === 1 ? "" : "s"} refused before ${receipt.total === 1 ? "it" : "they"} reached review.`
+  ];
+  for (const row of receipt.events) {
+    const kind = row.kind ? `${row.kind} sensor` : row.source;
+    const exit = row.exit_code === null ? "" : `, exit ${row.exit_code}`;
+    const stage = row.stage ? ` \u2014 caught at ${row.stage}` : "";
+    lines.push(`  \u2717\u2192\u2713 ${row.at.slice(0, 10)}  ${row.id.padEnd(32)} (${kind}${exit}${stage})`);
+  }
+  lines.push(
+    `  Trend: ${receipt.total} this window vs ${receipt.previous_total} previous window (${receipt.total <= receipt.previous_total ? "recurrences declining" : "recurrences rising"}).`
+  );
+  return lines.join("\n");
+}
 async function loadPreventionEvents(paths) {
   const file = preventionLogPath(paths);
   if (!existsSync4(file)) return [];
@@ -3782,10 +3846,10 @@ function sensorPatternBrittleness(pattern) {
 function normalizeProjectPath(value) {
   return value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^[ab]\//, "").replace(/\/+$/g, "");
 }
-function sensorAppliesToPath(sensor, anchorPaths, path19) {
+function sensorAppliesToPath(sensor, anchorPaths, path20) {
   const scopes = sensor.paths.length > 0 ? sensor.paths : anchorPaths;
   if (scopes.length === 0) return true;
-  const target = normalizeProjectPath(path19);
+  const target = normalizeProjectPath(path20);
   return scopes.some((rawScope) => {
     const scope = normalizeProjectPath(rawScope);
     if (!scope) return false;
@@ -3978,6 +4042,154 @@ function addedLinesFromDiff(diff) {
   return diff.split("\n").filter((l) => l.startsWith("+") && !l.startsWith("+++")).map((l) => l.slice(1)).join("\n");
 }
 
+// src/sensor-ledger.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync15, readFileSync as readFileSync2 } from "fs";
+import { appendFile as appendFile4, mkdir as mkdir11, readFile as readFile14, rename, writeFile as writeFile9 } from "fs/promises";
+import path17 from "path";
+var MAX_LINES = 1e4;
+var RETAINED_LINES = 8e3;
+var DAY_MS = 864e5;
+function sensorLedgerPath(paths) {
+  return path17.join(paths.runtimeDir, "enforcement", "sensor-ledger.ndjson");
+}
+function isEvaluation(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return typeof v.at === "string" && typeof v.memory_id === "string" && (v.kind === "regex" || v.kind === "shell" || v.kind === "test") && (v.stage === "pre-commit" || v.stage === "pre-push" || v.stage === "ci" || v.stage === "manual") && typeof v.head_sha === "string" && typeof v.scope_hash === "string" && (v.outcome === "fired" || v.outcome === "silent" || v.outcome === "unrunnable");
+}
+async function appendSensorEvaluations(paths, evaluations) {
+  if (evaluations.length === 0) return;
+  try {
+    const file = sensorLedgerPath(paths);
+    await mkdir11(path17.dirname(file), { recursive: true });
+    await appendFile4(file, evaluations.map((e) => JSON.stringify(e)).join("\n") + "\n", "utf8");
+    const raw = await readFile14(file, "utf8");
+    const lines = raw.split("\n").filter(Boolean);
+    if (lines.length > MAX_LINES) {
+      const temp = `${file}.${process.pid}.tmp`;
+      await writeFile9(temp, lines.slice(-RETAINED_LINES).join("\n") + "\n", "utf8");
+      await rename(temp, file);
+    }
+  } catch {
+  }
+}
+async function loadSensorLedger(paths, opts = {}) {
+  try {
+    const file = sensorLedgerPath(paths);
+    if (!existsSync15(file)) return [];
+    const since = opts.since ? Date.parse(opts.since) : Number.NEGATIVE_INFINITY;
+    const raw = await readFile14(file, "utf8");
+    const out = [];
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const parsed = JSON.parse(line);
+        if (!isEvaluation(parsed)) continue;
+        const at = Date.parse(parsed.at);
+        if (!Number.isFinite(at) || at < since) continue;
+        out.push(parsed);
+      } catch {
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+function computeScopeHash(root, scopedFiles) {
+  try {
+    const files = [...new Set(scopedFiles.map((f) => f.replace(/\\/g, "/")))].sort();
+    if (files.length === 0) return "";
+    const hash = createHash2("sha256");
+    let included = 0;
+    for (const rel of files) {
+      const abs = path17.resolve(root, rel);
+      if (!existsSync15(abs)) continue;
+      try {
+        hash.update(rel);
+        hash.update("\0");
+        hash.update(readFileSync2(abs));
+        hash.update("\0");
+        included++;
+      } catch {
+      }
+    }
+    return included === 0 ? "" : hash.digest("hex");
+  } catch {
+    return "";
+  }
+}
+function assessSensorHealth(evaluations, now = /* @__PURE__ */ new Date(), opts = {}) {
+  const cutoff = now.getTime() - 30 * DAY_MS;
+  const byMemory = /* @__PURE__ */ new Map();
+  for (const e of evaluations) {
+    if (e.memory_id === "__gate__" || e.kind !== "shell" && e.kind !== "test") continue;
+    const promotedAtIso = opts.promotedAt?.get(e.memory_id);
+    if (promotedAtIso) {
+      const promoted = Date.parse(promotedAtIso);
+      if (Number.isFinite(promoted) && Date.parse(e.at) <= promoted) continue;
+    }
+    const list = byMemory.get(e.memory_id) ?? [];
+    list.push(e);
+    byMemory.set(e.memory_id, list);
+  }
+  const out = [];
+  for (const [memoryId, all] of byMemory) {
+    all.sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+    const recent = all.filter((e) => Date.parse(e.at) >= cutoff && Date.parse(e.at) <= now.getTime());
+    const byHash = /* @__PURE__ */ new Map();
+    for (const e of recent) {
+      if (e.outcome === "unrunnable") continue;
+      const list = byHash.get(e.scope_hash) ?? [];
+      list.push(e);
+      byHash.set(e.scope_hash, list);
+    }
+    const flaps = [];
+    for (const [scopeHash, rows] of byHash) {
+      for (let i = 1; i < rows.length; i++) {
+        const previous = rows[i - 1];
+        const current = rows[i];
+        if (previous.outcome !== current.outcome) {
+          flaps.push({ memory_id: memoryId, scope_hash: scopeHash, previous, current });
+        }
+      }
+    }
+    flaps.sort((a, b) => Date.parse(a.current.at) - Date.parse(b.current.at));
+    const runnable = all.filter((e) => e.outcome !== "unrunnable");
+    const span = runnable.length > 1 ? Date.parse(runnable[runnable.length - 1].at) - Date.parse(runnable[0].at) : 0;
+    out.push({
+      memory_id: memoryId,
+      flap_count: flaps.length,
+      flaps,
+      quarantine_pending: flaps.length >= 2,
+      never_fired: runnable.length >= 20 && span >= 30 * DAY_MS && runnable.every((e) => e.outcome === "silent"),
+      evaluation_count: runnable.length
+    });
+  }
+  return out.sort((a, b) => a.memory_id.localeCompare(b.memory_id));
+}
+function sensorPromotedAtMap(frontmatters) {
+  const out = /* @__PURE__ */ new Map();
+  for (const fm of frontmatters) {
+    if (fm.sensor?.promoted_at) out.set(fm.id, fm.sensor.promoted_at);
+  }
+  return out;
+}
+function quarantineNote(at, flapCount) {
+  return `> Quarantined ${at}: oracle flapped ${flapCount}\xD7 on identical inputs \u2014 demoted block\u2192warn. Fix the test, then re-promote with \`hivelore sensors promote <id>\`.`;
+}
+function withQuarantineNote(body, at, flapCount) {
+  const without = body.split("\n").filter((line) => !line.startsWith("> Quarantined ")).join("\n").trimEnd();
+  return `${without}
+
+${quarantineNote(at, flapCount)}
+`;
+}
+function withoutQuarantineNote(body) {
+  return body.split("\n").filter((line) => !line.startsWith("> Quarantined ")).join("\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+}
+
 // src/sensor-suggest.ts
 var CODE_TOKEN_RE = /`([^`\n]{3,80})`|["']([A-Za-z0-9_.:-]{3,80})["']|\b([A-Za-z][A-Za-z0-9_.:-]{2,79})\b/g;
 var SENSOR_STOPWORDS = /* @__PURE__ */ new Set([
@@ -4425,8 +4637,8 @@ function normalizeFindingSeverity(raw) {
       return "info";
   }
 }
-function findingKey(tool, ruleId, path19) {
-  return `${tool}:${ruleId}:${path19}`;
+function findingKey(tool, ruleId, path20) {
+  return `${tool}:${ruleId}:${path20}`;
 }
 function coerceJson(input) {
   if (typeof input === "string") {
@@ -4460,8 +4672,8 @@ function parseSarif(input) {
       const physical = asRecord(location.physicalLocation);
       const artifact = asRecord(physical.artifactLocation);
       const region = asRecord(physical.region);
-      const path19 = typeof artifact.uri === "string" ? normalizeUri(artifact.uri) : "";
-      if (!path19) continue;
+      const path20 = typeof artifact.uri === "string" ? normalizeUri(artifact.uri) : "";
+      if (!path20) 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({
@@ -4469,10 +4681,10 @@ function parseSarif(input) {
         ruleId,
         message: message.trim(),
         severity,
-        path: path19,
+        path: path20,
         ...line !== void 0 ? { line } : {},
         ...snippet ? { snippet } : {},
-        key: findingKey(tool, ruleId, path19)
+        key: findingKey(tool, ruleId, path20)
       });
     }
   }
@@ -4491,17 +4703,17 @@ function parseSonar(input) {
       (typeof issue.severity === "string" ? issue.severity : void 0) ?? impactSeverity
     );
     const component = typeof issue.component === "string" ? issue.component : "";
-    const path19 = componentToPath(component);
-    if (!path19) continue;
+    const path20 = componentToPath(component);
+    if (!path20) continue;
     const line = typeof issue.line === "number" ? issue.line : void 0;
     findings.push({
       tool: "sonar",
       ruleId,
       message,
       severity,
-      path: path19,
+      path: path20,
       ...line !== void 0 ? { line } : {},
-      key: findingKey("sonar", ruleId, path19)
+      key: findingKey("sonar", ruleId, path20)
     });
   }
   return findings;
@@ -4514,7 +4726,7 @@ function parseEslintJson(input, opts = {}) {
     const file = asRecord(fileRaw);
     const rawPath = typeof file.filePath === "string" ? file.filePath : "";
     if (!rawPath) continue;
-    const path19 = cwd && rawPath.startsWith(cwd) ? rawPath.slice(cwd.length) : rawPath;
+    const path20 = cwd && rawPath.startsWith(cwd) ? rawPath.slice(cwd.length) : rawPath;
     for (const msgRaw of asArray(file.messages)) {
       const msg = asRecord(msgRaw);
       const ruleId = typeof msg.ruleId === "string" && msg.ruleId ? msg.ruleId : "parse-error";
@@ -4526,9 +4738,9 @@ function parseEslintJson(input, opts = {}) {
         ruleId,
         message,
         severity,
-        path: path19,
+        path: path20,
         ...line !== void 0 ? { line } : {},
-        key: findingKey("eslint", ruleId, path19)
+        key: findingKey("eslint", ruleId, path20)
       });
     }
   }
@@ -4946,7 +5158,7 @@ function tallyHotFiles(paths, source = "agent") {
     if (!norm) continue;
     counts.set(norm, (counts.get(norm) ?? 0) + 1);
   }
-  return [...counts.entries()].map(([path19, changes]) => ({ path: path19, changes, source })).sort((a, b) => b.changes - a.changes);
+  return [...counts.entries()].map(([path20, changes]) => ({ path: path20, changes, source })).sort((a, b) => b.changes - a.changes);
 }
 function mergeHotFiles(a, b) {
   const merged = /* @__PURE__ */ new Map();
@@ -4966,21 +5178,21 @@ function mergeHotFiles(a, b) {
 }
 
 // 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";
+import { appendFile as appendFile5, mkdir as mkdir12, readFile as readFile15 } from "fs/promises";
+import { existsSync as existsSync16 } from "fs";
+import path18 from "path";
 function evalHistoryPath(paths) {
-  return path17.join(paths.haiveDir, ".cache", "eval-history.jsonl");
+  return path18.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");
+  await mkdir12(path18.dirname(file), { recursive: true });
+  await appendFile5(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(() => "");
+  if (!existsSync16(file)) return [];
+  const raw = await readFile15(file, "utf8").catch(() => "");
   const out = [];
   for (const line of raw.split("\n")) {
     const trimmed = line.trim();
@@ -5124,6 +5336,81 @@ function proposeSeedsFromCommits(commits, limit = 20) {
   return out;
 }
 
+// src/gate-miss.ts
+function planGitWatch(state, headSha) {
+  const next = { last_scanned_sha: headSha };
+  if (!state?.last_scanned_sha) return { action: "initialize", next };
+  if (state.last_scanned_sha === headSha) return { action: "idle", next };
+  return { action: "scan", range: `${state.last_scanned_sha}..${headSha}`, next };
+}
+var REVERTED_SHA_RE = /\bThis reverts commit ([0-9a-f]{7,40})\b/i;
+var BODY_REVERTED_SHA_RE = /^Reverted SHA:\s*([0-9a-f]{7,40})\s*$/im;
+function revertedShaFromCommit(commit) {
+  return commit.reverted_sha ?? REVERTED_SHA_RE.exec(commit.body ?? "")?.[1] ?? null;
+}
+function existingGateMissShas(memories) {
+  const shas = /* @__PURE__ */ new Set();
+  for (const loaded of memories) {
+    if (!loaded.memory.frontmatter.tags.includes("gate-miss")) continue;
+    const sha = BODY_REVERTED_SHA_RE.exec(loaded.memory.body)?.[1];
+    if (sha) shas.add(sha);
+  }
+  return shas;
+}
+function gatePassedShas(evaluations) {
+  return new Set(
+    evaluations.filter((e) => e.memory_id === "__gate__" && e.outcome === "silent" && e.head_sha).map((e) => e.head_sha)
+  );
+}
+function shaMatches(set, sha) {
+  for (const candidate of set) {
+    if (candidate === sha || candidate.startsWith(sha) || sha.startsWith(candidate)) return true;
+  }
+  return false;
+}
+function proposeGateMissDrafts(commits, existingRevertedShas, passedShas, opts = {}) {
+  const seeds = proposeSeedsFromCommits(commits, commits.length);
+  const bySha = new Map(commits.map((commit) => [commit.sha, commit]));
+  const seen = new Set(existingRevertedShas);
+  const out = [];
+  for (const seed of seeds) {
+    const commit = bySha.get(seed.source_sha);
+    if (!commit) continue;
+    const failedSha = revertedShaFromCommit(commit) ?? commit.sha;
+    if (shaMatches(seen, failedSha)) continue;
+    seen.add(failedSha);
+    const gatePassed = shaMatches(passedShas, failedSha);
+    const paths = (commit.files ?? []).filter((p) => !p.startsWith(".ai/")).filter((p) => opts.pathExists?.(p) ?? true).slice(0, 8);
+    const base = `# Gate miss: ${seed.what}
+
+A git ${seed.kind} indicates that a change escaped the existing harness. This is a proposed lesson only; review the actual regression before validating it.
+
+Reverted SHA: ${failedSha}
+Revert SHA: ${commit.sha}
+Subject: ${seed.what}
+` + (paths.length > 0 ? `Top paths: ${paths.join(", ")}
+` : "") + `
+**Why it failed / do NOT use:** ${seed.why_failed}
+`;
+    const gateLine = gatePassed ? "\nThe gate PASSED this commit \u2014 a validated sensor here upgrades the harness.\n" : "";
+    const candidate = suggestSensorSeed(seed.what, paths);
+    const sensorHint = candidate ? `
+proposed_sensor_seed: ${JSON.stringify(candidate)}
+` : "\nproposed_sensor_seed: inspect the revert diff, then author a deterministic candidate with `hivelore sensors propose <id>`.\n";
+    out.push({
+      slug: `gate-miss-${failedSha.slice(0, 12)}`,
+      reverted_sha: failedSha,
+      revert_sha: commit.sha,
+      subject: seed.what,
+      paths,
+      kind: seed.kind,
+      gate_passed: gatePassed,
+      body: base + gateLine + sensorHint
+    });
+  }
+  return out;
+}
+
 // src/seed.ts
 var JS_DETECTORS = [
   ["nestjs", ["@nestjs/core"]],
@@ -5248,12 +5535,12 @@ ${trimmed}`;
 }
 
 // src/handoff.ts
-import { writeFile as writeFile9, readFile as readFile15, stat as stat3 } from "fs/promises";
-import { existsSync as existsSync16 } from "fs";
-import path18 from "path";
+import { writeFile as writeFile10, readFile as readFile16, stat as stat3 } from "fs/promises";
+import { existsSync as existsSync17 } from "fs";
+import path19 from "path";
 var HANDOFF_FILENAME = "NEXT.md";
 function handoffFilePath(root) {
-  return path18.join(root, HANDOFF_FILENAME);
+  return path19.join(root, HANDOFF_FILENAME);
 }
 function buildHandoffMarkdown(data) {
   const at = (data.at ?? /* @__PURE__ */ new Date()).toISOString();
@@ -5302,18 +5589,18 @@ function buildHandoffMarkdown(data) {
 }
 async function writeSessionHandoff(root, data) {
   const file = handoffFilePath(root);
-  await writeFile9(file, buildHandoffMarkdown(data), "utf8");
+  await writeFile10(file, buildHandoffMarkdown(data), "utf8");
   return file;
 }
 async function readSessionHandoff(root) {
   const file = handoffFilePath(root);
-  if (!existsSync16(file)) return null;
-  const raw = await readFile15(file, "utf8").catch(() => "");
+  if (!existsSync17(file)) return null;
+  const raw = await readFile16(file, "utf8").catch(() => "");
   return raw.trim() ? raw : null;
 }
 async function handoffAgeMs(root, now = /* @__PURE__ */ new Date()) {
   const file = handoffFilePath(root);
-  if (!existsSync16(file)) return null;
+  if (!existsSync17(file)) return null;
   try {
     const s = await stat3(file);
     return Math.max(0, now.getTime() - s.mtimeMs);
@@ -5429,10 +5716,12 @@ export {
   appendEvalHistory,
   appendPreventionEvent,
   appendRuntimeJournalEntry,
+  appendSensorEvaluations,
   appendUsageEvent,
   applyConflictResolution,
   applyFeedbackAdjustment,
   assessBootstrapState,
+  assessSensorHealth,
   bridgeMemorySummary,
   briefingMarkerPath,
   briefingMarkersDir,
@@ -5443,6 +5732,7 @@ export {
   buildDocFrequency,
   buildFrontmatter,
   buildHandoffMarkdown,
+  buildPreventionReceipt,
   buildReport,
   bumpRead,
   classifyMemoryPriority,
@@ -5459,6 +5749,7 @@ export {
   computeImpact,
   computePreventionTrend,
   computeRecurrence,
+  computeScopeHash,
   configPath,
   contractLockPath,
   countSourceFilesOnDisk,
@@ -5475,6 +5766,7 @@ export {
   estimateTokens,
   evalHistoryPath,
   evaluateSkillActivation,
+  existingGateMissShas,
   extractActionsBriefBody,
   extractReferencedPaths,
   extractSensorExamples,
@@ -5488,6 +5780,7 @@ export {
   findingBody,
   findingToDraft,
   firstMemoryOneLine,
+  gatePassedShas,
   generateBridges,
   getUsage,
   globToRegExp,
@@ -5525,6 +5818,7 @@ export {
   loadMemoriesFromDirDetailed,
   loadMemory,
   loadPreventionEvents,
+  loadSensorLedger,
   loadUsageIndex,
   looksLikeGenericAdvice,
   meetsSeedQualityFloor,
@@ -5549,13 +5843,16 @@ export {
   pathsOverlap,
   pickSnippetNeedle,
   planConflictResolution,
+  planGitWatch,
   prepareBridgeData,
   preventionLogPath,
   priorityRank,
   prioritySignals,
   projectContextRecentlyEmitted,
+  proposeGateMissDrafts,
   proposeSeedsFromCommits,
   pullCrossRepoSources,
+  quarantineNote,
   queryCodeMap,
   rankMemoriesLexical,
   readRecentBriefingMarker,
@@ -5571,11 +5868,13 @@ export {
   relPathFrom,
   renderBootstrapChecklist,
   renderCaughtForYou,
+  renderPreventionReceipt,
   resolveBriefingBudget,
   resolveHaivePaths,
   resolveManifestFiles,
   resolveProjectInfo,
   retirementSignal,
+  revertedShaFromCommit,
   runRegexSensor,
   runSensors,
   runtimeJournalPath,
@@ -5587,7 +5886,9 @@ export {
   scoreSensorCase,
   selectCommandSensors,
   sensorAppliesToPath,
+  sensorLedgerPath,
   sensorPatternBrittleness,
+  sensorPromotedAtMap,
   sensorSelfCheck,
   sensorTargetsFromDiff,
   serializeMemory,
@@ -5613,6 +5914,8 @@ export {
   usagePath,
   verifyAnchor,
   watchContracts,
+  withQuarantineNote,
+  withoutQuarantineNote,
   writeBriefingMarker,
   writeSessionHandoff
 };