@hiveai/core 0.12.4 → 0.12.9

package/README.md

@@ -1,3 +1,9 @@
+<p align="center">
+  <a href="https://github.com/Doucs91/hAIve">
+    <img src="https://raw.githubusercontent.com/Doucs91/hAIve/main/packages/vscode/media/logo.svg" alt="hAIve logo" width="96" />
+  </a>
+</p>
+
 # @hiveai/core
 
 > Internal library — policy, memory, anchor, and enforcement primitives for hAIve.

package/dist/index.d.ts

@@ -634,6 +634,30 @@ declare function aggregateSensors(cases: SensorCaseResult[]): SensorAggregate;
 /** Combine retrieval + sensor aggregates into a single 0..100 quality score. */
 declare function overallScore(retrieval: RetrievalAggregate | null, sensors: SensorAggregate | null): number;
 declare function buildReport(retrieval: RetrievalAggregate | null, sensors: SensorAggregate | null): EvalReport;
+/**
+ * Baseline / compare — makes the "hAIve improves retrieval by N%" claim reproducible.
+ *
+ * `haive eval --baseline` snapshots a report; `--compare` re-runs and diffs against it,
+ * so a ranking/sensor regression is a number, not a vibe. Pure math here; the CLI does I/O.
+ */
+interface MetricDelta {
+    baseline: number;
+    current: number;
+    /** current − baseline (positive = improvement for all these metrics). */
+    delta: number;
+}
+interface EvalDelta {
+    score: MetricDelta;
+    mean_recall: MetricDelta | null;
+    mrr: MetricDelta | null;
+    catch_rate: MetricDelta | null;
+    /** True when the overall score dropped vs the baseline. */
+    regressed: boolean;
+    /** True when the overall score rose vs the baseline. */
+    improved: boolean;
+}
+/** Diff a current report against a baseline. Pure. */
+declare function compareEvalReports(baseline: EvalReport, current: EvalReport): EvalDelta;
 /** Extract a short task-like title from a memory body (first heading or first line). */
 declare function titleFromBody(body: string): string;
 interface SelfEvalOptions {
@@ -1466,4 +1490,160 @@ interface SensorSuggestionOptions {
  */
 declare function suggestSensorFromMemory(body: string, anchorPaths: string[], options?: SensorSuggestionOptions): Sensor | null;
 
-export { AUTOPILOT_DEFAULTS, type Activation, type ActivationContext, ActivationSchema, type Anchor, AnchorSchema, type AntiPatternGate, type AutoPromoteRule, BRIEFING_MARKER_TTL_MS, BRIEFING_PRESET_DEFAULTS, type BreakingChange, type BriefingBudgetNumbers, type BriefingBudgetPreset, type BriefingMarker, type BudgetPart, type BudgetSlice, type BuildCodeMapOptions, CHARS_PER_TOKEN, CODE_MAP_FILE, CODE_STOPWORDS, CONFIG_FILE, type CodeExport, type CodeExportKind, type CodeFileEntry, type CodeMap, type CodeMapQueryOptions, type CollectTimelineOpts, type ConfidenceLevel, type ConfidenceThresholds, type ConflictCandidatePair, type ConflictCandidatesOpts, type ContractDiffResult, type ContractFile, type ContractSnapshot, CrossRepoProvenanceSchema, type CrossRepoReport, type CrossRepoSource, DECAY_DAYS, DEFAULT_AUTO_PROMOTE_RULE, DEFAULT_CONFIDENCE_THRESHOLDS, DEFAULT_CONFIG, DEFAULT_DORMANT_DAYS, type DepChange, type DepTrackResult, type DependencySnapshot, type DocFrequency, type EvalReport, type EvalSpec, GUESSABLE_THRESHOLD, HAIVE_DIR, type HaiveConfig, type HaivePaths, type ImpactOptions, type ImpactScore, type ImpactSummary, type ImpactTier, type LexicalRankResult, type LoadedMemory, MEMORIES_DIR, MIN_WORD_LEN, type Memory, type MemoryFrontmatter, MemoryFrontmatterSchema, type MemoryScope, MemoryScopeSchema, type MemoryStatus, MemoryStatusSchema, type MemoryType, MemoryTypeSchema, type MemoryUsage, PROJECT_CONTEXT_FILE, RUNTIME_JOURNAL_FILENAME, type ResolveProjectInfo, type RetirementSignal, type RetrievalAggregate, type RetrievalCase, type RetrievalCaseResult, type RuntimeJournalEntry, SESSION_RECAP_TTL_MS, STACK_PACK_TAG, type SelfEvalOptions, type Sensor, type SensorAggregate, type SensorCase, type SensorCaseResult, type SensorHit, SensorSchema, type SensorSuggestionOptions, type SensorTarget, type SkillActivation, type TimelineEntry, type TopicStatusPair, type TruncateOptions, type TruncateResult, USAGE_FILE, USAGE_LOG_DIR, USAGE_LOG_FILE, type UsageAggregate, type UsageEvent, type UsageIndex, type VerifyOptions, type VerifyResult, addedLinesFromDiff, aggregateRetrieval, aggregateSensors, aggregateUsage, allocateBudget, antiPatternGateParams, appendRuntimeJournalEntry, appendUsageEvent, briefingMarkerPath, briefingMarkersDir, buildCodeMap, buildDocFrequency, buildFrontmatter, buildReport, bumpRead, codeMapPath, collectTimelineEntries, compareImpact, compileRegexSensor, computeImpact, configPath, contractLockPath, deriveConfidence, diffContract, diffHasDistinctiveOverlap, distinctiveCap, emptyUsage, emptyUsageIndex, enforcementDir, estimateTokens, evaluateSkillActivation, extractActionsBriefBody, extractSnippet, findLexicalConflictPairs, findProjectRoot, findTopicStatusConflictPairs, firstMemoryOneLine, getUsage, globToRegExp, hasRecentBriefingMarker, inferModulesFromPaths, isAutoPromoteEligible, isDecaying, isDistinctiveToken, isFreshIsoDate, isGlobPath, isLikelyGuessable, isRetiredMemory, isSkill, isSkillSuppressed, isStackPackSeed, listMarkdownFilesRecursive, literalMatchesAllTokens, literalMatchesAnyToken, loadCodeMap, loadConfig, loadConfigSync, loadMemoriesFromDir, loadMemory, loadUsageIndex, memoryFilePath, memoryMatchesAnchorPaths, newMemoryId, normalizeSessionId, overallScore, parseMemory, parseSince, pathsOverlap, pickSnippetNeedle, pullCrossRepoSources, queryCodeMap, rankMemoriesLexical, readRecentBriefingMarker, readRuntimeJournalTail, readUsageEvents, recordApplied, recordRejection, relPathFrom, resolveBriefingBudget, resolveHaivePaths, resolveManifestFiles, resolveProjectInfo, retirementSignal, runRegexSensor, runSensors, runtimeJournalPath, saveCodeMap, saveConfig, saveUsageIndex, scoreRetrievalCase, scoreSensorCase, sensorAppliesToPath, sensorTargetsFromDiff, serializeMemory, snapshotContract, specificityScore, stripPrivate, suggestSensorFromMemory, suggestTopicKey, summarizeImpact, synthesizeSelfEvalCases, titleFromBody, tokenizeQuery, tokenizeWords, trackDependencies, trackReads, truncateToTokens, usageLogPath, usageLogSize, usagePath, verifyAnchor, watchContracts, writeBriefingMarker };
+/**
+ * Findings ingestion — the self-feeding half of the sensors story (feature B).
+ *
+ * Phase 1/2 turned a documented mistake into an executable `sensor`. But someone still has
+ * to *document* the mistake. Findings ingestion closes the review↔memory loop: a real defect
+ * reported by a scanner (SonarQube, or any SARIF-emitting tool like ESLint/Semgrep/CodeQL)
+ * becomes an anchored `gotcha`/`convention` memory, pre-filled with a conservative autogen
+ * sensor, so the *next* agent is steered away from it before it writes the same code.
+ *
+ * This module is pure: parsers + draft synthesis, no I/O. The CLI (`haive ingest`) and the
+ * MCP tool (`ingest_findings`) read files / write memories around these functions.
+ *
+ * Safety: every draft is `status: proposed` and every suggested sensor is `severity: warn`
+ * + `autogen: true`. Ingestion never auto-validates and never auto-blocks (safety rules +
+ * `2026-05-07-attempt-strict-precommit-gate-on-haive`). A human promotes both.
+ */
+type FindingSeverity = "info" | "minor" | "major" | "critical" | "blocker";
+interface Finding {
+    /** Source tool, e.g. "sonar", "eslint", "semgrep". */
+    tool: string;
+    /** Rule key, e.g. "typescript:S1234" or "no-unused-vars". */
+    ruleId: string;
+    /** Human-readable description of the problem. */
+    message: string;
+    severity: FindingSeverity;
+    /** Project-relative file path. */
+    path: string;
+    /** 1-based line number, when known. */
+    line?: number;
+    /** Offending source snippet, when the report provides one. */
+    snippet?: string;
+    /**
+     * Stable dedup key: `tool:ruleId:path`. Deliberately excludes the line so re-running a
+     * scan after unrelated edits (which shift line numbers) does not re-propose the same memory.
+     */
+    key: string;
+}
+interface MemoryDraft {
+    key: string;
+    /** `ingest:<key>` — used as the memory `topic` so re-ingestion upserts instead of duplicating. */
+    topic: string;
+    frontmatter: MemoryFrontmatter;
+    body: string;
+    finding: Finding;
+    /** True when a conservative sensor could be derived from the finding. */
+    has_sensor: boolean;
+}
+interface DraftOptions {
+    /** Memory type for the draft. Default "gotcha". */
+    type?: "gotcha" | "convention";
+    /** Scope for the draft. Default "team". */
+    scope?: "personal" | "team" | "module";
+    module?: string;
+    author?: string;
+}
+interface DraftsOptions extends DraftOptions {
+    /** Cap on number of drafts produced (after in-batch dedup). */
+    limit?: number;
+    /** Only ingest findings at or above this severity. Default: none (all). */
+    minSeverity?: FindingSeverity;
+}
+/** Normalize a tool-specific severity string to the shared scale. */
+declare function normalizeFindingSeverity(raw: string | undefined | null): FindingSeverity;
+/**
+ * Parse SARIF 2.1.0 (`runs[].results[]`). Works for any SARIF emitter (ESLint, Semgrep,
+ * CodeQL, etc.). The tool name comes from `runs[].tool.driver.name`.
+ */
+declare function parseSarif(input: string | unknown): Finding[];
+/**
+ * Parse the SonarQube issues payload (`issues[]` from `/api/issues/search`). The file path
+ * lives in `component` as `projectKey:relative/path`; we strip the project key.
+ */
+declare function parseSonar(input: string | unknown): Finding[];
+/** Dispatch to the right parser by declared format. */
+declare function parseFindings(format: "sarif" | "sonar", input: string | unknown): Finding[];
+/** Build the markdown body for a finding-derived memory. */
+declare function findingBody(finding: Finding): string;
+/** Convert one finding into a proposed memory draft (with a conservative sensor when derivable). */
+declare function findingToDraft(finding: Finding, options?: DraftOptions): MemoryDraft;
+/** Convert a batch of findings into drafts, deduped within the batch and capped/filtered. */
+declare function draftsFromFindings(findings: Finding[], options?: DraftsOptions): MemoryDraft[];
+/** Drop drafts whose topic already exists in the corpus (cross-run dedup). */
+declare function filterNewDrafts(drafts: MemoryDraft[], existingTopics: Iterable<string>): MemoryDraft[];
+
+interface DashboardOptions {
+    /** How many rows to include in each "top" list. Default 10. */
+    top?: number;
+    /** Dormancy window for impact scoring. Defaults to impact's own default. */
+    dormantDays?: number;
+    now?: Date;
+}
+interface ImpactRow {
+    id: string;
+    score: number;
+    tier: ImpactScore["tier"];
+    signals: string[];
+    prune_candidate: boolean;
+}
+interface SensorRow {
+    id: string;
+    severity: "warn" | "block";
+    last_fired: string;
+}
+interface DormantRow {
+    id: string;
+    last_read_at: string | null;
+    age_days: number;
+}
+interface DashboardReport {
+    generated_at: string;
+    inventory: {
+        /** Policy corpus size (excludes session_recap). */
+        total: number;
+        session_recaps: number;
+        active: number;
+        retired: number;
+        by_scope: Record<string, number>;
+        by_type: Record<string, number>;
+        by_status: Record<string, number>;
+    };
+    impact: ImpactSummary & {
+        top: ImpactRow[];
+    };
+    sensors: {
+        total: number;
+        warn: number;
+        block: number;
+        autogen: number;
+        fired: number;
+        recently_fired: SensorRow[];
+    };
+    health: {
+        stale: number;
+        retired: number;
+        /** Validated decision/gotcha/architecture memories with no anchor paths or symbols. */
+        anchorless: number;
+        /** Memories awaiting review (draft/proposed). */
+        pending: number;
+        prune_candidates: number;
+    };
+    decay: {
+        decay_days: number;
+        decaying: number;
+        top_dormant: DormantRow[];
+    };
+    corpus: {
+        /** Number of memory files (policy corpus, excludes session_recap). */
+        memory_files: number;
+        body_chars: number;
+        /** Rough token estimate (~chars/4) — how heavy the corpus is to inject. */
+        est_tokens: number;
+    };
+}
+/** Build the full observability rollup from the loaded corpus + usage index. Pure. */
+declare function buildDashboard(memories: LoadedMemory[], usage: UsageIndex, options?: DashboardOptions): DashboardReport;
+
+export { AUTOPILOT_DEFAULTS, type Activation, type ActivationContext, ActivationSchema, type Anchor, AnchorSchema, type AntiPatternGate, type AutoPromoteRule, BRIEFING_MARKER_TTL_MS, BRIEFING_PRESET_DEFAULTS, type BreakingChange, type BriefingBudgetNumbers, type BriefingBudgetPreset, type BriefingMarker, type BudgetPart, type BudgetSlice, type BuildCodeMapOptions, CHARS_PER_TOKEN, CODE_MAP_FILE, CODE_STOPWORDS, CONFIG_FILE, type CodeExport, type CodeExportKind, type CodeFileEntry, type CodeMap, type CodeMapQueryOptions, type CollectTimelineOpts, type ConfidenceLevel, type ConfidenceThresholds, type ConflictCandidatePair, type ConflictCandidatesOpts, type ContractDiffResult, type ContractFile, type ContractSnapshot, CrossRepoProvenanceSchema, type CrossRepoReport, type CrossRepoSource, DECAY_DAYS, DEFAULT_AUTO_PROMOTE_RULE, DEFAULT_CONFIDENCE_THRESHOLDS, DEFAULT_CONFIG, DEFAULT_DORMANT_DAYS, type DashboardOptions, type DashboardReport, type DepChange, type DepTrackResult, type DependencySnapshot, type DocFrequency, type DormantRow, type DraftOptions, type DraftsOptions, type EvalDelta, type EvalReport, type EvalSpec, type Finding, type FindingSeverity, GUESSABLE_THRESHOLD, HAIVE_DIR, type HaiveConfig, type HaivePaths, type ImpactOptions, type ImpactRow, type ImpactScore, type ImpactSummary, type ImpactTier, type LexicalRankResult, type LoadedMemory, MEMORIES_DIR, MIN_WORD_LEN, type Memory, type MemoryDraft, type MemoryFrontmatter, MemoryFrontmatterSchema, type MemoryScope, MemoryScopeSchema, type MemoryStatus, MemoryStatusSchema, type MemoryType, MemoryTypeSchema, type MemoryUsage, type MetricDelta, PROJECT_CONTEXT_FILE, RUNTIME_JOURNAL_FILENAME, type ResolveProjectInfo, type RetirementSignal, type RetrievalAggregate, type RetrievalCase, type RetrievalCaseResult, type RuntimeJournalEntry, SESSION_RECAP_TTL_MS, STACK_PACK_TAG, type SelfEvalOptions, type Sensor, type SensorAggregate, type SensorCase, type SensorCaseResult, type SensorHit, type SensorRow, SensorSchema, type SensorSuggestionOptions, type SensorTarget, type SkillActivation, type TimelineEntry, type TopicStatusPair, type TruncateOptions, type TruncateResult, USAGE_FILE, USAGE_LOG_DIR, USAGE_LOG_FILE, type UsageAggregate, type UsageEvent, type UsageIndex, type VerifyOptions, type VerifyResult, addedLinesFromDiff, aggregateRetrieval, aggregateSensors, aggregateUsage, allocateBudget, antiPatternGateParams, appendRuntimeJournalEntry, appendUsageEvent, briefingMarkerPath, briefingMarkersDir, buildCodeMap, buildDashboard, buildDocFrequency, buildFrontmatter, buildReport, bumpRead, codeMapPath, collectTimelineEntries, compareEvalReports, compareImpact, compileRegexSensor, computeImpact, configPath, contractLockPath, deriveConfidence, diffContract, diffHasDistinctiveOverlap, distinctiveCap, draftsFromFindings, emptyUsage, emptyUsageIndex, enforcementDir, estimateTokens, evaluateSkillActivation, extractActionsBriefBody, extractSnippet, filterNewDrafts, findLexicalConflictPairs, findProjectRoot, findTopicStatusConflictPairs, findingBody, findingToDraft, firstMemoryOneLine, getUsage, globToRegExp, hasRecentBriefingMarker, inferModulesFromPaths, isAutoPromoteEligible, isDecaying, isDistinctiveToken, isFreshIsoDate, isGlobPath, isLikelyGuessable, isRetiredMemory, isSkill, isSkillSuppressed, isStackPackSeed, listMarkdownFilesRecursive, literalMatchesAllTokens, literalMatchesAnyToken, loadCodeMap, loadConfig, loadConfigSync, loadMemoriesFromDir, loadMemory, loadUsageIndex, memoryFilePath, memoryMatchesAnchorPaths, newMemoryId, normalizeFindingSeverity, normalizeSessionId, overallScore, parseFindings, parseMemory, parseSarif, parseSince, parseSonar, pathsOverlap, pickSnippetNeedle, pullCrossRepoSources, queryCodeMap, rankMemoriesLexical, readRecentBriefingMarker, readRuntimeJournalTail, readUsageEvents, recordApplied, recordRejection, relPathFrom, resolveBriefingBudget, resolveHaivePaths, resolveManifestFiles, resolveProjectInfo, retirementSignal, runRegexSensor, runSensors, runtimeJournalPath, saveCodeMap, saveConfig, saveUsageIndex, scoreRetrievalCase, scoreSensorCase, sensorAppliesToPath, sensorTargetsFromDiff, serializeMemory, snapshotContract, specificityScore, stripPrivate, suggestSensorFromMemory, suggestTopicKey, summarizeImpact, synthesizeSelfEvalCases, titleFromBody, tokenizeQuery, tokenizeWords, trackDependencies, trackReads, truncateToTokens, usageLogPath, usageLogSize, usagePath, verifyAnchor, watchContracts, writeBriefingMarker };

package/dist/index.js

@@ -850,6 +850,22 @@ function overallScore(retrieval, sensors) {
 function buildReport(retrieval, sensors) {
   return { retrieval, sensors, score: overallScore(retrieval, sensors) };
 }
+function metricDelta(baseline, current) {
+  return { baseline: round32(baseline), current: round32(current), delta: round32(current - baseline) };
+}
+function compareEvalReports(baseline, current) {
+  const recall = baseline.retrieval && current.retrieval ? metricDelta(baseline.retrieval.mean_recall, current.retrieval.mean_recall) : null;
+  const mrr = baseline.retrieval && current.retrieval ? metricDelta(baseline.retrieval.mrr, current.retrieval.mrr) : null;
+  const catchRate = baseline.sensors && current.sensors ? metricDelta(baseline.sensors.catch_rate, current.sensors.catch_rate) : null;
+  return {
+    score: metricDelta(baseline.score, current.score),
+    mean_recall: recall,
+    mrr,
+    catch_rate: catchRate,
+    regressed: current.score < baseline.score,
+    improved: current.score > baseline.score
+  };
+}
 function titleFromBody(body) {
   const lines = body.split("\n");
   for (const line of lines) {
@@ -3056,6 +3072,318 @@ function sensorMessageFromBody(body, token) {
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+
+// src/findings.ts
+var SEVERITY_RANK = {
+  info: 0,
+  minor: 1,
+  major: 2,
+  critical: 3,
+  blocker: 4
+};
+function normalizeFindingSeverity(raw) {
+  const v = (raw ?? "").toString().trim().toLowerCase();
+  switch (v) {
+    case "blocker":
+      return "blocker";
+    case "critical":
+    case "error":
+    case "fatal":
+      return "critical";
+    case "major":
+    case "warning":
+    case "warn":
+      return "major";
+    case "minor":
+    case "note":
+    case "info":
+    case "information":
+    case "informational":
+      return v === "minor" ? "minor" : "info";
+    default:
+      return "info";
+  }
+}
+function findingKey(tool, ruleId, path15) {
+  return `${tool}:${ruleId}:${path15}`;
+}
+function coerceJson(input) {
+  if (typeof input === "string") {
+    try {
+      return JSON.parse(input);
+    } catch (err) {
+      throw new Error(`Invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return input;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function asRecord(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function parseSarif(input) {
+  const doc = asRecord(coerceJson(input));
+  const findings = [];
+  for (const runRaw of asArray(doc.runs)) {
+    const run = asRecord(runRaw);
+    const driver = asRecord(asRecord(run.tool).driver);
+    const tool = (typeof driver.name === "string" ? driver.name : "sarif").toLowerCase();
+    for (const resultRaw of asArray(run.results)) {
+      const result = asRecord(resultRaw);
+      const ruleId = typeof result.ruleId === "string" && result.ruleId || (typeof asRecord(result.rule).id === "string" ? asRecord(result.rule).id : "") || "unknown-rule";
+      const message = (typeof asRecord(result.message).text === "string" ? asRecord(result.message).text : "") || ruleId;
+      const severity = normalizeFindingSeverity(typeof result.level === "string" ? result.level : "warning");
+      const location = asRecord(asArray(result.locations)[0]);
+      const physical = asRecord(location.physicalLocation);
+      const artifact = asRecord(physical.artifactLocation);
+      const region = asRecord(physical.region);
+      const path15 = typeof artifact.uri === "string" ? normalizeUri(artifact.uri) : "";
+      if (!path15) continue;
+      const 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({
+        tool,
+        ruleId,
+        message: message.trim(),
+        severity,
+        path: path15,
+        ...line !== void 0 ? { line } : {},
+        ...snippet ? { snippet } : {},
+        key: findingKey(tool, ruleId, path15)
+      });
+    }
+  }
+  return findings;
+}
+function parseSonar(input) {
+  const doc = asRecord(coerceJson(input));
+  const findings = [];
+  for (const issueRaw of asArray(doc.issues)) {
+    const issue = asRecord(issueRaw);
+    const ruleId = typeof issue.rule === "string" ? issue.rule : "unknown-rule";
+    const message = typeof issue.message === "string" ? issue.message.trim() : ruleId;
+    const impacts = asArray(issue.impacts);
+    const impactSeverity = impacts.length > 0 && typeof asRecord(impacts[0]).severity === "string" ? asRecord(impacts[0]).severity : void 0;
+    const severity = normalizeFindingSeverity(
+      (typeof issue.severity === "string" ? issue.severity : void 0) ?? impactSeverity
+    );
+    const component = typeof issue.component === "string" ? issue.component : "";
+    const path15 = componentToPath(component);
+    if (!path15) continue;
+    const line = typeof issue.line === "number" ? issue.line : void 0;
+    findings.push({
+      tool: "sonar",
+      ruleId,
+      message,
+      severity,
+      path: path15,
+      ...line !== void 0 ? { line } : {},
+      key: findingKey("sonar", ruleId, path15)
+    });
+  }
+  return findings;
+}
+function parseFindings(format, input) {
+  return format === "sonar" ? parseSonar(input) : parseSarif(input);
+}
+function normalizeUri(uri) {
+  return uri.replace(/^file:\/\//, "").replace(/^\.\//, "");
+}
+function componentToPath(component) {
+  const idx = component.indexOf(":");
+  return idx === -1 ? component : component.slice(idx + 1);
+}
+function sanitize(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+}
+function basename(p) {
+  const parts = p.split("/");
+  return parts[parts.length - 1] || p;
+}
+function findingBody(finding) {
+  const lines = [
+    `# ${finding.ruleId} in ${finding.path}`,
+    "",
+    `**Source:** ${finding.tool} finding (severity: ${finding.severity})`,
+    "",
+    finding.message,
+    "",
+    `**Location:** ${finding.path}${finding.line !== void 0 ? `:${finding.line}` : ""}`
+  ];
+  if (finding.snippet) {
+    lines.push("", "**Offending code:**", "```", finding.snippet, "```");
+  }
+  lines.push("", `**Instead, use:** Resolve the ${finding.tool} finding \u2014 ${finding.message}`);
+  return lines.join("\n") + "\n";
+}
+function findingToDraft(finding, options = {}) {
+  const type = options.type ?? "gotcha";
+  const scope = options.scope ?? "team";
+  const topic = `ingest:${finding.key}`;
+  const slug = `${sanitize(finding.tool)}-${sanitize(finding.ruleId)}-${sanitize(basename(finding.path))}`;
+  const body = findingBody(finding);
+  const frontmatter = buildFrontmatter({
+    type,
+    slug,
+    scope,
+    module: options.module,
+    author: options.author,
+    paths: [finding.path],
+    tags: ["ingested", finding.tool, finding.severity],
+    topic,
+    status: "proposed"
+  });
+  const sensor = suggestSensorFromMemory(body, [finding.path]);
+  if (sensor) frontmatter.sensor = sensor;
+  return { key: finding.key, topic, frontmatter, body, finding, has_sensor: Boolean(sensor) };
+}
+function draftsFromFindings(findings, options = {}) {
+  const minRank = options.minSeverity ? SEVERITY_RANK[options.minSeverity] : -1;
+  const seen = /* @__PURE__ */ new Set();
+  const drafts = [];
+  for (const finding of findings) {
+    if (SEVERITY_RANK[finding.severity] < minRank) continue;
+    if (seen.has(finding.key)) continue;
+    seen.add(finding.key);
+    drafts.push(findingToDraft(finding, options));
+    if (options.limit !== void 0 && drafts.length >= options.limit) break;
+  }
+  return drafts;
+}
+function filterNewDrafts(drafts, existingTopics) {
+  const existing = new Set(existingTopics);
+  return drafts.filter((d) => !existing.has(d.topic));
+}
+
+// src/dashboard.ts
+var MS_PER_DAY3 = 24 * 60 * 60 * 1e3;
+function isAnchorless(fm) {
+  if (!["decision", "gotcha", "architecture"].includes(fm.type)) return false;
+  if (fm.status !== "validated") return false;
+  return fm.anchor.paths.length === 0 && fm.anchor.symbols.length === 0;
+}
+function inc(map, key) {
+  map[key] = (map[key] ?? 0) + 1;
+}
+function buildDashboard(memories, usage, options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const top = options.top ?? 10;
+  const inventory = {
+    total: 0,
+    session_recaps: 0,
+    active: 0,
+    retired: 0,
+    by_scope: {},
+    by_type: {},
+    by_status: {}
+  };
+  const impactScores = [];
+  const impactRows = [];
+  const sensorRows = [];
+  let sensorTotal = 0;
+  let sensorWarn = 0;
+  let sensorBlock = 0;
+  let sensorAutogen = 0;
+  let sensorFired = 0;
+  let stale = 0;
+  let retired = 0;
+  let anchorless = 0;
+  let pending = 0;
+  let decaying = 0;
+  let bodyChars = 0;
+  const dormantRows = [];
+  for (const { memory } of memories) {
+    const fm = memory.frontmatter;
+    if (fm.type === "session_recap") {
+      inventory.session_recaps += 1;
+      continue;
+    }
+    inventory.total += 1;
+    inc(inventory.by_scope, fm.scope);
+    inc(inventory.by_type, fm.type);
+    inc(inventory.by_status, fm.status);
+    bodyChars += memory.body.length;
+    const isRetired = isRetiredMemory(fm, memory.body, now);
+    if (isRetired) {
+      inventory.retired += 1;
+      retired += 1;
+    } else {
+      inventory.active += 1;
+    }
+    if (fm.status === "stale") stale += 1;
+    if (isAnchorless(fm)) anchorless += 1;
+    if (fm.status === "draft" || fm.status === "proposed") pending += 1;
+    if (fm.sensor) {
+      sensorTotal += 1;
+      if (fm.sensor.severity === "block") sensorBlock += 1;
+      else sensorWarn += 1;
+      if (fm.sensor.autogen) sensorAutogen += 1;
+      if (fm.sensor.last_fired) {
+        sensorFired += 1;
+        sensorRows.push({ id: fm.id, severity: fm.sensor.severity, last_fired: fm.sensor.last_fired });
+      }
+    }
+    const memUsage = getUsage(usage, fm.id);
+    const impact = computeImpact(fm, memUsage, {
+      now,
+      ...options.dormantDays !== void 0 ? { dormantDays: options.dormantDays } : {}
+    });
+    impactScores.push(impact);
+    impactRows.push({
+      id: fm.id,
+      score: impact.score,
+      tier: impact.tier,
+      signals: impact.signals,
+      prune_candidate: impact.pruneCandidate
+    });
+    if (isDecaying(memUsage, fm.created_at)) decaying += 1;
+    if (impact.tier === "dormant") {
+      const anchor = memUsage.last_read_at ?? fm.created_at;
+      const ageDays = Math.floor((now.getTime() - new Date(anchor).getTime()) / MS_PER_DAY3);
+      dormantRows.push({ id: fm.id, last_read_at: memUsage.last_read_at, age_days: ageDays });
+    }
+  }
+  impactRows.sort(
+    (a, b) => compareImpact(
+      { score: a.score, tier: a.tier, signals: a.signals, pruneCandidate: a.prune_candidate },
+      { score: b.score, tier: b.tier, signals: b.signals, pruneCandidate: b.prune_candidate }
+    )
+  );
+  sensorRows.sort((a, b) => b.last_fired.localeCompare(a.last_fired));
+  dormantRows.sort((a, b) => b.age_days - a.age_days);
+  return {
+    generated_at: now.toISOString(),
+    inventory,
+    impact: { ...summarizeImpact(impactScores), top: impactRows.slice(0, top) },
+    sensors: {
+      total: sensorTotal,
+      warn: sensorWarn,
+      block: sensorBlock,
+      autogen: sensorAutogen,
+      fired: sensorFired,
+      recently_fired: sensorRows.slice(0, top)
+    },
+    health: {
+      stale,
+      retired,
+      anchorless,
+      pending,
+      prune_candidates: impactScores.filter((s) => s.pruneCandidate).length
+    },
+    decay: {
+      decay_days: DECAY_DAYS,
+      decaying,
+      top_dormant: dormantRows.slice(0, top)
+    },
+    corpus: {
+      memory_files: inventory.total,
+      body_chars: bodyChars,
+      est_tokens: Math.round(bodyChars / 4)
+    }
+  };
+}
 export {
   AUTOPILOT_DEFAULTS,
   ActivationSchema,
@@ -3099,12 +3427,14 @@ export {
   briefingMarkerPath,
   briefingMarkersDir,
   buildCodeMap,
+  buildDashboard,
   buildDocFrequency,
   buildFrontmatter,
   buildReport,
   bumpRead,
   codeMapPath,
   collectTimelineEntries,
+  compareEvalReports,
   compareImpact,
   compileRegexSensor,
   computeImpact,
@@ -3114,6 +3444,7 @@ export {
   diffContract,
   diffHasDistinctiveOverlap,
   distinctiveCap,
+  draftsFromFindings,
   emptyUsage,
   emptyUsageIndex,
   enforcementDir,
@@ -3121,9 +3452,12 @@ export {
   evaluateSkillActivation,
   extractActionsBriefBody,
   extractSnippet,
+  filterNewDrafts,
   findLexicalConflictPairs,
   findProjectRoot,
   findTopicStatusConflictPairs,
+  findingBody,
+  findingToDraft,
   firstMemoryOneLine,
   getUsage,
   globToRegExp,
@@ -3151,10 +3485,14 @@ export {
   memoryFilePath,
   memoryMatchesAnchorPaths,
   newMemoryId,
+  normalizeFindingSeverity,
   normalizeSessionId,
   overallScore,
+  parseFindings,
   parseMemory,
+  parseSarif,
   parseSince,
+  parseSonar,
   pathsOverlap,
   pickSnippetNeedle,
   pullCrossRepoSources,