@hiveai/core 0.14.0 → 0.17.0

package/dist/index.js

@@ -318,6 +318,16 @@ var STACK_PACK_TAG = "stack-pack";
 function isStackPackSeed(fm) {
   return Boolean(fm?.tags?.includes(STACK_PACK_TAG));
 }
+var ENV_WORKAROUND_TAGS = /* @__PURE__ */ new Set([
+  "dev-workflow",
+  "dev-env",
+  "hotswap",
+  "local-setup",
+  "tooling-debt"
+]);
+function isEnvWorkaroundMemory(fm) {
+  return Boolean(fm?.tags?.some((t) => ENV_WORKAROUND_TAGS.has(t)));
+}
 var MODULE_PATTERNS = [
   /^packages\/([^/]+)\//,
   /^apps\/([^/]+)\//,
@@ -2833,11 +2843,24 @@ function briefingMarkerPath(paths, sessionId) {
   return path16.join(briefingMarkersDir(paths), `${normalizeSessionId(sessionId)}.json`);
 }
 async function writeBriefingMarker(paths, input) {
+  const sessionId = normalizeSessionId(input.sessionId);
+  const accumulate = input.accumulate ?? true;
+  let priorIds = [];
+  let priorFiles = [];
+  if (accumulate) {
+    const existing = await readSessionBriefingMarker(paths, sessionId);
+    if (existing) {
+      priorIds = existing.memory_ids ?? [];
+      priorFiles = existing.files ?? [];
+    }
+  }
+  const mergedIds = [.../* @__PURE__ */ new Set([...priorIds, ...input.memoryIds ?? []])];
+  const mergedFiles = [.../* @__PURE__ */ new Set([...priorFiles, ...input.files ?? []])];
   const marker = {
-    session_id: normalizeSessionId(input.sessionId),
+    session_id: sessionId,
     ...input.task?.trim() ? { task: input.task.trim() } : {},
-    ...input.memoryIds && input.memoryIds.length > 0 ? { memory_ids: [...new Set(input.memoryIds)] } : {},
-    ...input.files && input.files.length > 0 ? { files: [...new Set(input.files)] } : {},
+    ...mergedIds.length > 0 ? { memory_ids: mergedIds } : {},
+    ...mergedFiles.length > 0 ? { files: mergedFiles } : {},
     source: input.source,
     created_at: (/* @__PURE__ */ new Date()).toISOString(),
     root: paths.root
@@ -2850,6 +2873,18 @@ async function writeBriefingMarker(paths, input) {
   );
   return marker;
 }
+async function readSessionBriefingMarker(paths, sessionId, ttlMs = BRIEFING_MARKER_TTL_MS) {
+  const file = briefingMarkerPath(paths, sessionId);
+  if (!existsSync14(file)) return null;
+  try {
+    const marker = JSON.parse(await readFile13(file, "utf8"));
+    const created = Date.parse(marker.created_at);
+    if (!Number.isFinite(created) || Date.now() - created > ttlMs) return null;
+    return marker;
+  } catch {
+    return null;
+  }
+}
 async function hasRecentBriefingMarker(paths, sessionId, ttlMs = BRIEFING_MARKER_TTL_MS) {
   const now = Date.now();
   const candidates = [];
@@ -2943,10 +2978,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, path17) {
+function sensorAppliesToPath(sensor, anchorPaths, path18) {
   const scopes = sensor.paths.length > 0 ? sensor.paths : anchorPaths;
   if (scopes.length === 0) return true;
-  const target = normalizeProjectPath(path17);
+  const target = normalizeProjectPath(path18);
   return scopes.some((rawScope) => {
     const scope = normalizeProjectPath(rawScope);
     if (!scope) return false;
@@ -2994,6 +3029,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;
@@ -3220,8 +3277,8 @@ function normalizeFindingSeverity(raw) {
       return "info";
   }
 }
-function findingKey(tool, ruleId, path17) {
-  return `${tool}:${ruleId}:${path17}`;
+function findingKey(tool, ruleId, path18) {
+  return `${tool}:${ruleId}:${path18}`;
 }
 function coerceJson(input) {
   if (typeof input === "string") {
@@ -3255,8 +3312,8 @@ function parseSarif(input) {
       const physical = asRecord(location.physicalLocation);
       const artifact = asRecord(physical.artifactLocation);
       const region = asRecord(physical.region);
-      const path17 = typeof artifact.uri === "string" ? normalizeUri(artifact.uri) : "";
-      if (!path17) 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({
@@ -3264,10 +3321,10 @@ function parseSarif(input) {
         ruleId,
         message: message.trim(),
         severity,
-        path: path17,
+        path: path18,
         ...line !== void 0 ? { line } : {},
         ...snippet ? { snippet } : {},
-        key: findingKey(tool, ruleId, path17)
+        key: findingKey(tool, ruleId, path18)
       });
     }
   }
@@ -3286,17 +3343,17 @@ function parseSonar(input) {
       (typeof issue.severity === "string" ? issue.severity : void 0) ?? impactSeverity
     );
     const component = typeof issue.component === "string" ? issue.component : "";
-    const path17 = componentToPath(component);
-    if (!path17) 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: path17,
+      path: path18,
       ...line !== void 0 ? { line } : {},
-      key: findingKey("sonar", ruleId, path17)
+      key: findingKey("sonar", ruleId, path18)
     });
   }
   return findings;
@@ -3373,6 +3430,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) {
@@ -3514,6 +3617,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,
@@ -3521,6 +3629,293 @@ 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" };
+}
+
+// src/recap.ts
+function isAutoRecap(body) {
+  return /Auto-captured session/i.test(body) || /\bEdited \d+ files? across \d+ tool calls?/i.test(body) || /\b\d+ tool calls?\b/i.test(body);
+}
+function compactAutoRecapBody(body, maxChars = 600) {
+  if (!isAutoRecap(body)) return body;
+  const goalMatch = body.match(/##+\s*Goal[^\n]*\n+([^\n]+)/i);
+  const callsMatch = body.match(/Auto-captured session \(([^)]+)\)/i);
+  const header = goalMatch?.[1]?.trim() ? `_${goalMatch[1].trim()}_` : callsMatch ? `_Auto-captured session (${callsMatch[1]})._` : "_Auto-captured session._";
+  const discMatch = body.match(/##+\s*Discoveries[^\n]*\n([\s\S]*?)(?=\n##+\s|\n*$)/i);
+  const discovery = discMatch?.[1]?.trim() ?? "";
+  const trivialDiscovery = discovery === "" || /^no (new memories|surprising)/i.test(discovery) || /No new memories saved this session\.?$/i.test(discovery);
+  if (trivialDiscovery) {
+    return `${header}
+
+_No notable discoveries captured. Run post_task / \`mem_session_end\` for a richer recap._`;
+  }
+  const trimmed = discovery.length > maxChars ? discovery.slice(0, maxChars) + "\u2026" : discovery;
+  return `${header}
+
+**Discoveries:**
+${trimmed}`;
+}
+
+// src/priority.ts
+var DEFAULT_PRIORITY_SIGNALS = {
+  type: "",
+  tags: [],
+  requiresHumanApproval: false,
+  directAnchor: false,
+  directSymbol: false,
+  exactTaskMatch: false,
+  strongSemantic: false,
+  usefulSemantic: false,
+  moduleOrDomainMatch: false,
+  tagTaskMatch: false
+};
+function prioritySignals(partial) {
+  return { ...DEFAULT_PRIORITY_SIGNALS, ...partial };
+}
+function classifyMemoryPriority(signals) {
+  const isNegative = signals.type === "attempt";
+  const isSkill2 = signals.type === "skill";
+  if (signals.requiresHumanApproval || signals.directAnchor || signals.directSymbol || isNegative && (signals.exactTaskMatch || signals.strongSemantic) || isSkill2 && (signals.exactTaskMatch || signals.strongSemantic)) {
+    return "must_read";
+  }
+  if (isStackPackSeed({ tags: signals.tags }) || isEnvWorkaroundMemory({ tags: signals.tags })) {
+    return "background";
+  }
+  if (isSkill2 || signals.moduleOrDomainMatch || signals.exactTaskMatch || signals.usefulSemantic || signals.tagTaskMatch) {
+    return "useful";
+  }
+  return "background";
+}
+function priorityRank(priority) {
+  return priority === "must_read" ? 3 : priority === "useful" ? 2 : 1;
+}
 export {
   AUTOPILOT_DEFAULTS,
   ActivationSchema,
@@ -3537,6 +3932,8 @@ export {
   DEFAULT_CONFIDENCE_THRESHOLDS,
   DEFAULT_CONFIG,
   DEFAULT_DORMANT_DAYS,
+  DEFAULT_PRIORITY_SIGNALS,
+  ENV_WORKAROUND_TAGS,
   GUESSABLE_THRESHOLD,
   HAIVE_DIR,
   MEMORIES_DIR,
@@ -3561,22 +3958,28 @@ export {
   aggregateUsage,
   allocateBudget,
   antiPatternGateParams,
+  appendEvalHistory,
   appendPreventionEvent,
   appendRuntimeJournalEntry,
   appendUsageEvent,
   briefingMarkerPath,
   briefingMarkersDir,
   buildCodeMap,
+  buildCoverageIndex,
   buildDashboard,
   buildDocFrequency,
   buildFrontmatter,
   buildReport,
   bumpRead,
+  classifyMemoryPriority,
   codeMapPath,
   collectTimelineEntries,
+  compactAutoRecapBody,
   compareEvalReports,
   compareImpact,
   compileRegexSensor,
+  computeEvalTrend,
+  computeGatePrecision,
   computeImpact,
   computePreventionTrend,
   computeRecurrence,
@@ -3591,13 +3994,16 @@ export {
   emptyUsageIndex,
   enforcementDir,
   estimateTokens,
+  evalHistoryPath,
   evaluateSkillActivation,
   extractActionsBriefBody,
   extractSnippet,
   filterNewDrafts,
+  findCoverageGaps,
   findLexicalConflictPairs,
   findProjectRoot,
   findTopicStatusConflictPairs,
+  findUncapturedFailures,
   findingBody,
   findingToDraft,
   firstMemoryOneLine,
@@ -3607,8 +4013,11 @@ export {
   hashProjectContext,
   inferModulesFromPaths,
   isAutoPromoteEligible,
+  isAutoRecap,
+  isCovered,
   isDecaying,
   isDistinctiveToken,
+  isEnvWorkaroundMemory,
   isFreshIsoDate,
   isGlobPath,
   isLikelyGuessable,
@@ -3622,12 +4031,14 @@ export {
   loadCodeMap,
   loadConfig,
   loadConfigSync,
+  loadEvalHistory,
   loadMemoriesFromDir,
   loadMemory,
   loadPreventionEvents,
   loadUsageIndex,
   memoryFilePath,
   memoryMatchesAnchorPaths,
+  mergeMemoryVersions,
   newMemoryId,
   normalizeFindingSeverity,
   normalizeSessionId,
@@ -3639,8 +4050,12 @@ export {
   parseSonar,
   pathsOverlap,
   pickSnippetNeedle,
+  planConflictResolution,
   preventionLogPath,
+  priorityRank,
+  prioritySignals,
   projectContextRecentlyEmitted,
+  proposeSeedsFromCommits,
   pullCrossRepoSources,
   queryCodeMap,
   rankMemoriesLexical,
@@ -3665,12 +4080,14 @@ export {
   saveUsageIndex,
   scoreRetrievalCase,
   scoreSensorCase,
+  selectCommandSensors,
   sensorAppliesToPath,
   sensorTargetsFromDiff,
   serializeMemory,
   snapshotContract,
   specificityScore,
   stripPrivate,
+  suggestGate,
   suggestSensorFromMemory,
   suggestTopicKey,
   summarizeImpact,