@hiveai/core 0.13.9 → 0.15.0

package/dist/index.d.ts

@@ -609,6 +609,14 @@ interface RecurrenceReport {
 }
 declare function computeRecurrence(events: PreventionEvent[]): RecurrenceReport;
 
+/** How long an emitted project context is considered "still fresh in the agent's context". */
+declare const PROJECT_CONTEXT_THROTTLE_MS: number;
+declare function hashProjectContext(content: string): string;
+/** True if an identical project-context body was already emitted within the throttle window. */
+declare function projectContextRecentlyEmitted(paths: HaivePaths, hash: string, now?: number): Promise<boolean>;
+/** Record that this exact project-context body was just emitted. Best-effort. */
+declare function recordProjectContextEmission(paths: HaivePaths, hash: string, now?: number): Promise<void>;
+
 /**
  * A rigorous, model-free, repeatable evaluation of hAIve's core promise: surfacing
  * the right knowledge and guardrails at the right moment. Unlike the agent benchmark
@@ -1102,6 +1110,14 @@ interface HaiveConfig {
         mode?: "off" | "advisory" | "strict";
         /** Require get_briefing / mem_relevant_to before state-changing MCP tools. */
         requireBriefingFirst?: boolean;
+        /**
+         * Pre-edit (PreToolUse) behaviour when a file's anchored policy was not yet surfaced:
+         *   - "advise" (default): inject the relevant memory content into the agent's context and record
+         *     it in the briefing marker, then ALLOW the edit — no round-trip, no separate briefing command.
+         *   - "block": hard-block the edit until a briefing covers the file (the legacy strict behaviour).
+         * The commit-time decision-coverage gate and CI enforcement remain the hard backstops either way.
+         */
+        preEditGate?: "advise" | "block";
         /** Require a session recap before pre-push / CI gates pass. */
         requireSessionRecap?: boolean;
         /** Require memory anchor verification before pre-commit / CI gates pass. */
@@ -1121,6 +1137,29 @@ interface HaiveConfig {
          * Default: "anchored" — makes "known bad approaches are blocked" true for the precise case.
          */
         antiPatternGate?: "off" | "review" | "anchored" | "strict";
+        /**
+         * Execute `kind: "shell" | "test"` memory sensors during `haive sensors check`.
+         * These run arbitrary repo-authored commands, so they are OFF by default; turn on per repo
+         * (or pass `--commands`) once the team trusts the sensors. Regex sensors always run. Default false.
+         */
+        runCommandSensors?: boolean;
+        /**
+         * How `haive enforce finish` reacts to hard failures observed this session that were never
+         * captured as a lesson (`mem_tried`):
+         *   - off:   ignore
+         *   - warn:  surface them as an info finding (default — failure detection has false positives)
+         *   - block: hard-block finish until each is captured
+         * Default: "warn".
+         */
+        failureCaptureGate?: "off" | "warn" | "block";
+        /**
+         * How `haive eval --ci` reacts to a harness-quality regression vs the recorded baseline:
+         *   - off:   never block
+         *   - warn:  report the drop (default)
+         *   - block: exit non-zero on any score drop
+         * Default: "warn".
+         */
+        evalRegressionGate?: "off" | "warn" | "block";
         /**
          * Default unread-age window (in days) for `haive memory archive` corpus decay.
          * A noisy or stale corpus is actively harmful — it makes the agent follow outdated policy.
@@ -1529,6 +1568,27 @@ declare function runRegexSensor(memoryId: string, sensor: Sensor, target: Sensor
  * are the CLI's responsibility). At most one hit per (memory, file) pair is returned.
  */
 declare function runSensors(memories: Memory[], targets: SensorTarget[]): SensorHit[];
+/**
+ * A shell/test sensor selected for execution — the feedback *computational* layer that a regex
+ * can't express. The schema reserves `kind: "shell" | "test"`; this picks the ones whose memory
+ * applies to the changed paths so the CLI can run `command` (core stays pure — it never executes).
+ */
+interface CommandSensorSpec {
+    memory_id: string;
+    /** Command to execute (shell or test runner invocation). */
+    command: string;
+    kind: "shell" | "test";
+    severity: Sensor["severity"];
+    /** LLM-facing self-correction message carried from the sensor. */
+    message: string;
+    /** Anchor/scoped paths this sensor cares about (for reporting). */
+    paths: string[];
+}
+/**
+ * Select the shell/test sensors that apply to `changedPaths`. With no changed paths (or a sensor
+ * scoped to everywhere) the sensor is selected unconditionally. Pure: the caller executes commands.
+ */
+declare function selectCommandSensors(memories: Memory[], changedPaths: string[]): CommandSensorSpec[];
 /** Split a unified diff into per-file targets containing only added lines. */
 declare function sensorTargetsFromDiff(diff: string): SensorTarget[];
 /**
@@ -1634,6 +1694,47 @@ declare function draftsFromFindings(findings: Finding[], options?: DraftsOptions
 /** Drop drafts whose topic already exists in the corpus (cross-run dedup). */
 declare function filterNewDrafts(drafts: MemoryDraft[], existingTopics: Iterable<string>): MemoryDraft[];
 
+/**
+ * Gate signal-quality — is the inferential (anti-pattern) gate earning trust or crying wolf?
+ *
+ * hAIve's anti-pattern gate is probabilistic and warmup-sensitive, so it is deliberately calibrated
+ * NOT to hard-block on weak matches. But a team needs to SEE whether the gate's signal is precise:
+ * are its catches turning out to be real (prevented mistakes, applied lessons) or noise (rejected by
+ * humans via `mem_feedback`)? This module turns the signals hAIve already records — prevention events
+ * (by source) and per-memory rejection counts — into a precision indicator and an actionable tuning
+ * suggestion for `enforcement.antiPatternGate`. Pure: no I/O.
+ */
+
+interface GatePrecision {
+    /** Catches recorded by deterministic regex/command sensors. */
+    sensor_catches: number;
+    /** Catches recorded by the inferential anti-pattern gate. */
+    anti_pattern_catches: number;
+    /** Total "useful" outcomes (catches + human-applied lessons). */
+    useful: number;
+    /** Total human rejections (mem_feedback "not useful"). Proxy for false positives. */
+    rejections: number;
+    /** useful / (useful + rejections), 0..1. Null when there is no signal yet. */
+    precision: number | null;
+    /** A tuning recommendation for enforcement.antiPatternGate, or null when current looks right. */
+    suggestion: GateTuningSuggestion | null;
+}
+interface GateTuningSuggestion {
+    recommended: AntiPatternGate;
+    reason: string;
+}
+/**
+ * Compute the gate's signal quality from prevention events + usage.
+ * @param currentGate the configured antiPatternGate, used to decide whether to suggest a change.
+ */
+declare function computeGatePrecision(events: PreventionEvent[], usage: UsageIndex, currentGate?: AntiPatternGate): GatePrecision;
+/**
+ * Suggest loosening the gate when it is noisy (low precision with real rejection volume), or
+ * tightening it when it is precise but currently soft. Returns null when current looks right or
+ * there isn't enough signal to act on.
+ */
+declare function suggestGate(precision: number | null, rejections: number, currentGate: AntiPatternGate): GateTuningSuggestion | null;
+
 interface DashboardOptions {
     /** How many rows to include in each "top" list. Default 10. */
     top?: number;
@@ -1642,6 +1743,8 @@ interface DashboardOptions {
     now?: Date;
     /** Prevention event log (from `loadPreventionEvents`) — powers the trend + recurrence rollups. */
     preventionEvents?: PreventionEvent[];
+    /** Configured anti-pattern gate — lets the gate-precision rollup suggest tightening/loosening. */
+    antiPatternGate?: AntiPatternGate;
 }
 interface ImpactRow {
     id: string;
@@ -1714,6 +1817,8 @@ interface DashboardReport {
         /** Lessons re-introduced after capture (caught on >= 2 distinct days). */
         recurrence: RecurrenceReport;
     };
+    /** Inferential-gate signal quality: are catches real (useful) or noise (rejected)? + tuning hint. */
+    gate_precision: GatePrecision;
     corpus: {
         /** Number of memory files (policy corpus, excludes session_recap). */
         memory_files: number;
@@ -1725,4 +1830,201 @@ interface DashboardReport {
 /** 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, PREVENTION_DEBOUNCE_MS, PROJECT_CONTEXT_FILE, type PreventionEvent, type PreventionRow, type PreventionSource, type PreventionTrend, RUNTIME_JOURNAL_FILENAME, type RecurrenceReport, type RecurrenceRow, 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, appendPreventionEvent, appendRuntimeJournalEntry, appendUsageEvent, briefingMarkerPath, briefingMarkersDir, buildCodeMap, buildDashboard, buildDocFrequency, buildFrontmatter, buildReport, bumpRead, codeMapPath, collectTimelineEntries, compareEvalReports, compareImpact, compileRegexSensor, computeImpact, computePreventionTrend, computeRecurrence, 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, loadPreventionEvents, loadUsageIndex, memoryFilePath, memoryMatchesAnchorPaths, newMemoryId, normalizeFindingSeverity, normalizeSessionId, overallScore, parseFindings, parseMemory, parseSarif, parseSince, parseSonar, pathsOverlap, pickSnippetNeedle, preventionLogPath, pullCrossRepoSources, queryCodeMap, rankMemoriesLexical, readRecentBriefingMarker, readRuntimeJournalTail, readUsageEvents, recordApplied, recordPrevention, 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 };
+/**
+ * Failure-capture coverage — the gate behind hAIve's "never silently fix the same mistake" loop.
+ *
+ * `haive observe` (the PostToolUse hook) appends an observation per tool call to
+ * `.ai/.cache/observations.jsonl`, tagging hard failures with `failure_hint: true`
+ * (non-zero Bash exit, `error TSxxxx`, ENOENT, …). Those failures are exactly the
+ * `mem_tried` candidates the harness wants captured — otherwise the next session repeats them.
+ *
+ * This module is the pure decision layer: given the failure observations and the corpus's
+ * `attempt`/`gotcha` memories, which failures look UNCAPTURED (no lesson recorded after them)?
+ * The CLI reads the files and turns the result into an `enforce finish` finding. No I/O here.
+ */
+interface FailureObservation {
+    /** ISO timestamp of the observation. */
+    ts: string;
+    /** Tool that failed (Bash / Edit / …). */
+    tool: string;
+    /** Short human-readable summary of what was attempted. */
+    summary: string;
+}
+interface UncapturedFailure {
+    ts: string;
+    tool: string;
+    summary: string;
+}
+interface FailureCoverageOptions {
+    /** Only consider failures newer than this many hours (avoid stale observations blocking forever). Default 24. */
+    windowHours?: number;
+    /** Collapse near-identical failures (same normalized summary) to one row. Default true. */
+    dedupe?: boolean;
+    now?: Date;
+}
+/**
+ * A failure is CAPTURED when an `attempt`/`gotcha` lesson was recorded at or after it
+ * (within the window) — the agent stopped and wrote the lesson down. Failures that pre-date
+ * every recent capture are uncaptured: the gate should nudge (or block) on those.
+ *
+ * @param failures     failure-tagged observations (any order)
+ * @param captureTimes ISO created_at of every attempt/gotcha memory in the corpus
+ */
+declare function findUncapturedFailures(failures: FailureObservation[], captureTimes: string[], options?: FailureCoverageOptions): UncapturedFailure[];
+
+/**
+ * Harness coverage-gap detection — "which churny files have NO team knowledge on them?".
+ *
+ * hAIve's `eval` synthesizes cases from the memories that EXIST (does the corpus surface
+ * correctly?). It cannot tell you what knowledge is MISSING. This module answers the inverse,
+ * proactive question Fowler frames as an open challenge: of the files the team edits most, which
+ * carry no covering decision/convention/gotcha/architecture memory? Those are the blind spots
+ * where a confident agent is most likely to violate an unwritten rule.
+ *
+ * Pure: the caller supplies hot files (from git history / briefing-radar) and the loaded corpus.
+ */
+
+interface HotFile {
+    path: string;
+    /** Number of times the file changed in the lookback window (the "heat"). */
+    changes: number;
+}
+interface CoverageGap {
+    path: string;
+    changes: number;
+}
+interface CoverageOptions {
+    /** Only flag files with at least this many changes. Default 3. */
+    minChanges?: number;
+    /** Memory types that count as "covering" a file. Default decision/convention/gotcha/architecture. */
+    coveringTypes?: string[];
+    /** Cap on returned gaps. Default 20. */
+    limit?: number;
+}
+/**
+ * Build the set of path prefixes the corpus covers: every anchor path of a non-dead,
+ * non-recap covering memory. A file is covered if it equals, or sits under, one of them.
+ */
+declare function buildCoverageIndex(memories: LoadedMemory[], coveringTypes?: string[]): Set<string>;
+/** True when `file` equals or is nested under any covered path prefix. */
+declare function isCovered(file: string, coverage: Set<string>): boolean;
+/**
+ * Cross hot files with the coverage index → the uncovered, frequently-edited files.
+ * Highest heat first. These are the highest-value places to add a memory or sensor.
+ */
+declare function findCoverageGaps(hotFiles: HotFile[], memories: LoadedMemory[], options?: CoverageOptions): CoverageGap[];
+
+interface EvalHistoryEntry {
+    /** ISO timestamp of the eval run. */
+    at: string;
+    /** Overall 0..100 score. */
+    score: number;
+    /** Optional component metrics for richer trend views. */
+    mean_recall?: number;
+    mrr?: number;
+    catch_rate?: number;
+    /** Optional version/commit the run was taken at. */
+    ref?: string;
+}
+declare function evalHistoryPath(paths: HaivePaths): string;
+/** Append one eval run to the history. Best-effort, creates the dir on demand. */
+declare function appendEvalHistory(paths: HaivePaths, entry: EvalHistoryEntry): Promise<void>;
+/** Read all eval runs (skips malformed lines). */
+declare function loadEvalHistory(paths: HaivePaths): Promise<EvalHistoryEntry[]>;
+interface EvalTrend {
+    /** Most recent score, or null when there is no history. */
+    latest: number | null;
+    /** Score before the latest, or null. */
+    previous: number | null;
+    /** latest − previous (positive = improving). */
+    delta: number | null;
+    /** Best score ever recorded. */
+    best: number | null;
+    /** Number of runs recorded. */
+    runs: number;
+    /** Last N scores oldest → newest for a sparkline. */
+    recent: number[];
+    /** True when the latest run dropped vs the previous one. */
+    regressed: boolean;
+}
+/** Pure trend over the history (chronological order is enforced internally). */
+declare function computeEvalTrend(entries: EvalHistoryEntry[], recentN?: number): EvalTrend;
+
+/**
+ * Contradiction resolution planning — turns "two memories conflict" into "do THIS".
+ *
+ * `conflict-candidates.ts` surfaces pairs (same topic with opposed status, or lexically near-
+ * duplicate). That's detection, not resolution — and Fowler lists incoherence-at-scale (a harness
+ * full of contradictory guides) as a core open challenge. This module decides, deterministically,
+ * which memory of a pair should WIN and which should be superseded (deprecated), so the CLI can
+ * apply it. Pure: no I/O, unit-tested.
+ *
+ * Decision order (strongest signal first):
+ *   1. status     — a `validated` memory beats a `rejected`/`deprecated`/`stale` one.
+ *   2. revision   — higher `revision_count` (more refined via topic-upsert) wins.
+ *   3. recency    — newer `created_at` wins (the team's latest word).
+ */
+
+interface ConflictResolution {
+    /** Memory id to keep authoritative. */
+    keep_id: string;
+    /** Memory id to deprecate (superseded). */
+    supersede_id: string;
+    /** Human-readable reason the winner was chosen. */
+    reason: string;
+    /** stale_reason to stamp on the superseded memory. */
+    stale_reason: string;
+}
+/** Compare two memories; returns the one that should WIN plus the reason. Pure. */
+declare function planConflictResolution(a: LoadedMemory, b: LoadedMemory): ConflictResolution;
+
+/**
+ * Cold-start seeding from git history — the harness has value only once the corpus is populated,
+ * and a fresh repo starts empty (Fowler's "harnessability": greenfield is easy, legacy is hard).
+ *
+ * Reverts and fixups are the cheapest signal of a real, repo-specific mistake: a commit that had to
+ * be undone or hot-fixed encodes a lesson the team already paid for. This module parses a list of
+ * commits (the CLI runs `git log`) and proposes DRAFT `attempt` seeds — never validated, always
+ * human-reviewed. Pure: the caller does the git I/O and the memory writes.
+ */
+interface GitCommit {
+    sha: string;
+    subject: string;
+    /** Files touched by the commit (optional — improves anchoring). */
+    files?: string[];
+}
+interface SeedProposal {
+    /** Kebab-ish slug derived from the reverted subject. */
+    slug: string;
+    /** What was tried (the thing that had to be reverted/fixed). */
+    what: string;
+    /** Why it failed (inferred from the revert/fixup). */
+    why_failed: string;
+    /** Suggested anchor paths (from the commit's files). */
+    paths: string[];
+    /** The source commit, for provenance. */
+    source_sha: string;
+    /** Detected signal kind. */
+    kind: "revert" | "fixup";
+}
+/**
+ * Turn commits into seed proposals. A `Revert "X"` commit proposes an attempt about X; an obvious
+ * hotfix/fixup commit proposes an attempt about the fixed area. Deduped by slug. Pure.
+ */
+declare function proposeSeedsFromCommits(commits: GitCommit[], limit?: number): SeedProposal[];
+
+interface MergeResult {
+    /** The chosen file content. */
+    content: string;
+    /** Which side won. */
+    winner: "ours" | "theirs";
+    /** Why (for logging). */
+    reason: string;
+}
+/**
+ * Resolve two versions of the same memory file. Returns the winning content and the rationale.
+ * Falls back to "ours" when either side can't be parsed (never throws — a merge driver must not).
+ */
+declare function mergeMemoryVersions(ours: string, theirs: string): MergeResult;
+
+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 CommandSensorSpec, type ConfidenceLevel, type ConfidenceThresholds, type ConflictCandidatePair, type ConflictCandidatesOpts, type ConflictResolution, type ContractDiffResult, type ContractFile, type ContractSnapshot, type CoverageGap, type CoverageOptions, 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 EvalHistoryEntry, type EvalReport, type EvalSpec, type EvalTrend, type FailureCoverageOptions, type FailureObservation, type Finding, type FindingSeverity, GUESSABLE_THRESHOLD, type GatePrecision, type GateTuningSuggestion, type GitCommit, HAIVE_DIR, type HaiveConfig, type HaivePaths, type HotFile, 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 MergeResult, type MetricDelta, PREVENTION_DEBOUNCE_MS, PROJECT_CONTEXT_FILE, PROJECT_CONTEXT_THROTTLE_MS, type PreventionEvent, type PreventionRow, type PreventionSource, type PreventionTrend, RUNTIME_JOURNAL_FILENAME, type RecurrenceReport, type RecurrenceRow, type ResolveProjectInfo, type RetirementSignal, type RetrievalAggregate, type RetrievalCase, type RetrievalCaseResult, type RuntimeJournalEntry, SESSION_RECAP_TTL_MS, STACK_PACK_TAG, type SeedProposal, 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 UncapturedFailure, type UsageAggregate, type UsageEvent, type UsageIndex, type VerifyOptions, type VerifyResult, addedLinesFromDiff, aggregateRetrieval, aggregateSensors, aggregateUsage, allocateBudget, antiPatternGateParams, appendEvalHistory, appendPreventionEvent, appendRuntimeJournalEntry, appendUsageEvent, briefingMarkerPath, briefingMarkersDir, buildCodeMap, buildCoverageIndex, buildDashboard, buildDocFrequency, buildFrontmatter, buildReport, bumpRead, codeMapPath, collectTimelineEntries, compareEvalReports, compareImpact, compileRegexSensor, computeEvalTrend, computeGatePrecision, computeImpact, computePreventionTrend, computeRecurrence, configPath, contractLockPath, deriveConfidence, diffContract, diffHasDistinctiveOverlap, distinctiveCap, draftsFromFindings, emptyUsage, emptyUsageIndex, enforcementDir, estimateTokens, evalHistoryPath, evaluateSkillActivation, extractActionsBriefBody, extractSnippet, filterNewDrafts, findCoverageGaps, findLexicalConflictPairs, findProjectRoot, findTopicStatusConflictPairs, findUncapturedFailures, findingBody, findingToDraft, firstMemoryOneLine, getUsage, globToRegExp, hasRecentBriefingMarker, hashProjectContext, inferModulesFromPaths, isAutoPromoteEligible, isCovered, isDecaying, isDistinctiveToken, isFreshIsoDate, isGlobPath, isLikelyGuessable, isRetiredMemory, isSkill, isSkillSuppressed, isStackPackSeed, listMarkdownFilesRecursive, literalMatchesAllTokens, literalMatchesAnyToken, loadCodeMap, loadConfig, loadConfigSync, loadEvalHistory, loadMemoriesFromDir, loadMemory, loadPreventionEvents, loadUsageIndex, memoryFilePath, memoryMatchesAnchorPaths, mergeMemoryVersions, newMemoryId, normalizeFindingSeverity, normalizeSessionId, overallScore, parseFindings, parseMemory, parseSarif, parseSince, parseSonar, pathsOverlap, pickSnippetNeedle, planConflictResolution, preventionLogPath, projectContextRecentlyEmitted, proposeSeedsFromCommits, pullCrossRepoSources, queryCodeMap, rankMemoriesLexical, readRecentBriefingMarker, readRuntimeJournalTail, readUsageEvents, recordApplied, recordPrevention, recordProjectContextEmission, recordRejection, relPathFrom, resolveBriefingBudget, resolveHaivePaths, resolveManifestFiles, resolveProjectInfo, retirementSignal, runRegexSensor, runSensors, runtimeJournalPath, saveCodeMap, saveConfig, saveUsageIndex, scoreRetrievalCase, scoreSensorCase, selectCommandSensors, sensorAppliesToPath, sensorTargetsFromDiff, serializeMemory, snapshotContract, specificityScore, stripPrivate, suggestGate, suggestSensorFromMemory, suggestTopicKey, summarizeImpact, synthesizeSelfEvalCases, titleFromBody, tokenizeQuery, tokenizeWords, trackDependencies, trackReads, truncateToTokens, usageLogPath, usageLogSize, usagePath, verifyAnchor, watchContracts, writeBriefingMarker };